Back To Course Home

Modern C# and .NET Tutorial: Cross-Platform Basics

0% completed

Introduction

Introduction to the Course

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!

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#

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

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

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

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

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

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

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

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

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

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

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

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

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

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

Conclusion

Introduction: Working with Files, Streams, and Serialization

Get an overview of the section on working with files, streams, and serialization.

This section concerns reading and writing to files and streams, text encoding, and serialization. We will cover essential skills. We’ll learn fundamental file operations and data handling techniques.

This section covers the following topics:

Managing the filesystem
Reading and writing with streams
Encoding and decoding text
Reading and writing with random access handles
Serializing object graphs

Get hands-on with 1400+ tech skills courses.