Mini Map
Search
⌘ K
Log In
Modern C# and .NET Tutorial: Cross-Platform Basics
0%
1.
Introduction
Introduction to the Course
2.
Hello, C#! Welcome, .NET!
Introduction: Hello, C# Welcome, .NET
Selection of Optimal Tools and Application Types
Understanding .NET Framework and Core
Deploying Cross-Platform
Understanding the Journey to One .NET and .NET Support
What Is Different About Modern .NET?
.NET Standards, Intermediate Language, and .NET Technologies
Building Console Apps in Windows Using Visual Studio
Understanding Top Level Programs
Working with Multiple Projects in Visual Studio
Building Console App Using Visual Studio Code
Compiling and Running the Code Using the Dotnet CLI
Working with Multiple Projects in Visual Studio Code
Exploring Code Using .NET Interactive Notebooks
Reviewing the Folders and Files for Project and Looking for Help
Quiz: Hello, C#! Welcome, .NET!
Summary: Hello, C#! Welcome, .NET!
3.
Speaking C#
Introduction: Speaking C#
C# Language
Managing C# Compiler Versions and .NET SDK Compatibility
Understanding C# Grammar
Understanding C# Vocabulary
Importing Namespace
Verbs and Nouns in English and C#
Revealing the Extent of C# Vocabulary
Working with Variables: Strings
Working with Variables: Numbers
Working with Variable: Storing Any Type of Object
Declaring Local Variables and Access the Default Values of Types
Formatting Methods to Output
Getting Text/Key Input from User and Simplifying Console App Use
Passing Arguments to a Console App
Setting Option with Arguments and Handling Platforms
Understanding async and await
Challenge: Number Sizes and Ranges
Solution: Number Sizes and Ranges
Quiz: Speaking C#
Summary: Speaking C#
4.
Controlling Flow, Converting Types, and Handling Exception
Introduction: Control Flow, Convert Types, and Handle Exceptions
Unary and Binary Operators
Assignment and Logical Operators
Bitwise, Binary Shift, and Miscellaneous Operators
Understanding Selection Statement
Understanding Iteration Statements
Storing Multiple Values in Array
Casting and Converting Between Types
Handling Exception
Checking for Overflow
Challenge: Loops, Operators, and Exception Handling
Solution: Loops, Operators, and Exception Handling
Quiz: Controlling Flow, Converting Types, Handling Exception
Summary: Controlling Flow, Converting Types, Handling Exception
5.
Writing, Debugging, and Testing Functions
Introduction: Writing, Debugging, and Testing Functions
Code Reusability and Organization
Generating Time Table in C#
Function Basics: Parameter, Arguments, and Returning Values
Converting Numbers from Cardinal to Ordinal
Calculating Factorial with Recursion
Documenting Function with XML Comments and Lambda Usage
Debugging During Development and Setting Breakpoint
Navigating with the Debugger Toolbar and Debugging Windows
Customizing Breakpoint
Hot Reloading During Development
Logging During Development and Runtime
Switching Trace Level
Unit Testing
Throwing and Catching Exceptions in Functions
Challenge: Prime Factor
Solution: Prime Factor
Quiz: Writing, Debugging, and Testing Functions
Summary: Writing, Debugging, and Testing Functions
6.
Building Your Own Types with Object-Oriented Programming
Introduction: Building Your Own Types with OOP
Talking About OOP
Building Class Libraries
Importing a Namespace to Use a Type and Understanding Objects
Storing Data Within Fields
Storing Values Using Different Techniques
Making a Field Static, Constant, and Read-Only
Initializing Fields in Constructors
Writing and Calling Methods
Parameters Passing and Methods Overloading
Passing Optional and Named Parameter
Controlling How Parameters Are Passed
Using Partial and Controlling Access Properties
Properties to Be Set During Instantiation and Defining Indexers
Implementing Functionality Using Methods
Implementing Functions with Operators and Local Functions
Pattern Matching with Objects
Working with Records
Positional Data Members in Records
Quiz: Building Your Own Types with Object-Oriented Programming
Summary: Building Your Own Types with Object-Oriented Programming
7.
Implementing Interfaces and Inheriting Classes
Introduction: Implementing Interfaces and Inheriting Classes
Setting Up a Class Library and Console Application
Making Types Safely Reusable with Generics
Raise and Handle Events
Implementing Interfaces: Comparing Objects When Sorting
Implementing Interfaces: Comparing Objects Using a Separate Class
Implementing Interface: Implicit, Explicit, and Default
Managing Memory with Reference and Value Types
Equality of Types
Defining Struct and Record Struct Types
Releasing Unmanaged Resources and Ensuring Dispose Calling
Working with Null Values
Declare Non-Nullable Variables, Parameters, and Check for Null
Checking for Null Values
Inheriting Subclasses from Classes
Inheriting from Abstract Class
Casting Within Inheritance Hierarchies
Inheriting and Extending .NET Types
Treating Warning as Errors and Understanding Warning Waves
Using an Analyzer to Write Better Code
Methods to Suppress Warnings
Challenge: Create a Hierarchy of Inheritance
Solution: Create a Hierarchy of Inheritance
Quiz: Implementing Interfaces and Inheriting Classes
Summary: Implementing Interfaces and Inheriting Classes
8.
Packaging and Distributing .NET Types
Introduction: Packaging and Distributing .NET Types
The Road to .NET 7
Understanding .NET Components
Working with Namespaces and Types
Relating C# Keywords to .NET Types
.NET Standards, Compatibility, and Management
Publishing Code for Deployment
Understanding dotnet Command
Publishing a Self-Contained App
Publishing a Single-File App
Decompiling .NET Assemblies
Packaging Libraries for NuGet Distribution
Exploring NuGet Packages with a Tool
Porting from .NET Framework to Modern .NET
Working with Preview Features
Quiz: Packaging and Distributing .NET Types
Summary: Packaging and Distributing .NET Types
9.
Working with Common .NET Types
Introduction: Working with Common .NET Types
Working with Numbers
Working with Text: Getting Length and Character of String
Working with Text: String Manipulation Operations
Working with Text: Advanced String Operations
Pattern Matching with Regular Expressions
Activating Regular Expression Syntax Coloring
Improving Regular Expression Performance with Source Generators
Storing Multiple Objects in Collections
Understanding Collection Choices
Lists, Dictionaries, and Queues
Sorting Collections
Working with Immutable Collections
Working with Spans, Indexes, and Ranges
Working with Network Resources
Challenge: Regular Expressions
Solution: Regular Expressions
Quiz: Working with Common .NET Types
Summary: Working with Common .NET Types
10.
Working with Files, Streams, and Serialization
Introduction: Working with Files, Streams, and Serialization
Managing the Filesystem
Drives and Directories Management
Files and Paths Management
File Information and File Control
Reading and Writing with Streams
Writing to Text and XML Streams
Simplified Disposal and Compressed Streams
Working with Tar Archive
Encoding, Decoding, and Random Access Handle
Serializing Object Graphs as XML
Serializing Object Graphs with JSON
Controlling JSON Processing
Challenge: Serializing as XML
Solution: Serializing as XML
Quiz: Working with Files, Streams, and Serialization
Summary: Working with Files, Streams, and Serialization
11.
Working with Data Using Entity Framework Core
Introduction: Working with Data Using Entity Framework Core
Understanding Modern Database and Entity Framework Core
Creating a Console App for Working with EF Core
Creating and Managing the Northwind Sample Database
Setting Up EF Core
Defining EF Core Models
Building EF Core Models for the Northwind Tables
Setting Up the Dotnet-Ef Tool
Scaffolding Models Using an Existing Database
Querying EF Core Model
Filtering Included Entities
Getting the Generated SQL
Logging EF Core
EF Core Like Operations and Global Filters
Loading Patterns in EF Core
Modifying Data with EF Core: Insert Entities
Modifying Data with EF Core: Update, and Delete Entities
Modifying Data with EF Core: More Efficient Updates and Deletes
Working with Transactions
Defining Code First EF Core Model
Quiz: Working with Data Using Entity Framewor Core
Summary: Working with Data Using Entity Framework Core
12.
Querying and Manipulating Data Using LINQ
Introduction: Querying and Manipulating Data Using LINQ
Understanding LINQ’s Shift from Imperative to Declarative Program
Writing LINQ Expressions
Advanced LINQ Techniques for Filtering and Simplification
Sorting Entities in LINQ
Declaring a Query and Filtering by Type
Working with Sets and Bags Using LINQ
LINQ with EF Core
Filtering and Sorting Sequences in LINQ
Projecting Sequence into New Types
Join and GroupJoin Sequences
Aggregating Sequences
Paging with LINQ
Sweetening LINQ Syntax with Syntactic Sugar
Using Multiple Threads with Parallel LINQ
Creating LINQ Extension Method
Working with LINQ to XML
Challenge: Querying with LINQ
Solution: Querying with LINQ
Quiz: Querying and Manipulating Data Using LINQ
Summary: Querying and Manipulating Data Using LINQ
13.
Introducing Web Development Using ASP.NET Core
Introduction: Introducing Web Development Using ASP.NET Core
Understanding ASP.NET Core
Building Websites Using ASP.NET Core
New Features in ASP.NET Core
Structuring Projects in ASP.NET
Building an Entity Model Using SQLite
Improving the Class-to-Table Mapping
Creating a Class Library for a Northwind Database Context
Creating a Class Library for Entity Models Using SQL Server
Testing the Class Libraries
Understanding the Web Development
Quiz: Introducing Web Development Using ASP.NET Core
Summary: Introducing Web Development Using ASP.NET Core
14.
Building Websites Using ASP.NET Core Razor Pages
Introduction: Building Websites Using ASP.NET Core Razor Pages
Creating an Empty Project
Testing and Securing the Website
Controlling the Hosting Environment
Enable a Website to Serve Static Content
Exploring ASP.NET Core Razor Pages
Using Shared Layouts with Razor Pages
Using Code-Behind Files with Razor Pages
Using Entity Framework Core with ASP.NET Core
Manipulating Data Using Razor Pages
Using Razor Class Libraries
Configuring Services
Configuring the HTTP Request Pipeline
Middleware with Anonymous Inline Delegate & Decompression Support
Enabling HTTP/3 Support
Quiz: Building Website Using ASP.NET Core Razor Pages
Summary: Building Websites Using ASP.NET Core Razor Pages
15.
Building Websites Using the Model-View-Controller Pattern
Introduction: Building Websites Using the MVC Pattern
Setting Up and Creating an ASP.NET Core MVC Website
Creating the Authentication Database for SQL Server LocalDB
Exploring and Starting the MVC Website
MVC Website Structure and ASP.NET Core Identity Database Review
ASP.NET Core MVC Initialization
Controllers and Actions
View Search Path Convention and Logging
Entity and View Model
Views and Tag Helper
Customizing an ASP.NET Core MVC Website
Passing Parameters Using the Route Value
Model Binders in More Detail
Validating the Model
Defining Views
Filter to Secure an Action Method
Filter to Define a Custom Route and to Cache a Response
Using Output Caching
Varying Cached Data by Query String
Querying a Database and Using Display Templates
Improving Scalability Using Asynchronous Tasks
Challenge: Implement a Category Detail Page
Solution: Implement a Category Detail Page
Quiz: Building Websites Using the MVC Pattern
Summary: Building Websites Using the MVC Pattern
16.
Building and Consuming Web Services
Introduction: Building and Consuming Web Services
Web Services Using ASP.NET Core Web API
Creating an ASP.NET Core Web API Project
Reviewing the Web Service’s Functionality
Creating a Web Service for the Northwind Database
Data Repositories for Entities and Web API Controller
Configuring the Customer Repository and Web API Controller
Specifying the Problem Details and Controling XML Serialization
Documenting and Testing Web Services
Making Requests Using REST Client
Understanding and Testing Swagger
Enabling HTTP Logging and Support for Logging
Consuming Web Services Using HTTP Clients and Getting Consumers
Starting Projects
Implementing Advanced Features for Web Services
Building Web Services Using Minimal APIs
Quiz: Building and Consuming Web Services
Summary: Building and Consuming Web Services
17.
Building User Interfaces Using Blazor
Introduction: Building User Interfaces Using Blazor
Understanding Blazor
Comparing Blazor Project Templates
Blazor Routing to Page Components
Running the Blazor Server Project Template
Reviewing the Blazor WebAssembly Project Template
Building Components Using Blazor Server
Getting Entities into a Component
Abstracting a Service for a Blazor Component
Building and Testing Customer Components
Building Components Using Blazor WebAssembly
Testing the Blazor WebAssembly Components and Service
Improving Blazor WebAssembly
Advanced Functionality in Blazor WebAssembly
Quiz: Building User Interfaces Using Blazor
Summary: Building User Interfaces Using Blazor
18.
Conclusion
Wrap Up
Home
/
Courses
/
Modern C# and .NET Tutorial: Cross-Platform Basics
Quiz: Hello, C#! Welcome, .NET!
Test your knowledge of the Hello, C#! Welcome, .NET! concepts you’ve learned.
We'll cover the following...
Multiple choice questions
Short questions
Multiple choice questions
...