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

Trending

Intermediate

40h

Updated yesterday

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

This course introduces modern C# and .NET, covering everything from setup to building full-featured web apps using OOP, data access tools, and modern development features.

Join 2.7 million developers at

Overview

Content

Reviews

This course offers a comprehensive introduction to C# and the .NET platform, designed to help you build cross-platform applications from the ground up. You’ll start by setting up your development environment and learning the fundamentals of the C# language, including syntax, control flow, exception handling, and object-oriented programming. Next, you’ll explore practical development techniques like working with files and streams, implementing serialization, and using debugging tools. You’ll also learn to access and manipulate data using Entity Framework Core and LINQ. Finally, the course explores modern web development with ASP.NET Core and Blazor, teaching you to build interactive user interfaces and scalable web applications. You’ll work with advanced tools like .NET Interactive Notebooks and Hot Reload, applying the latest C# and .NET features to create efficient, production-ready solutions.

This course offers a comprehensive introduction to C# and the .NET platform, designed to help you build cross-platform applicati...Show More

WHAT YOU'LL LEARN

An understanding of C# basics, including language constructs, flow control, and exception handling

The ability to write reusable code using object-oriented programming and debugging tools

Familiarity with Entity Framework Core and LINQ for data access and manipulation

The ability to build web applications and user interfaces with ASP.NET Core and Blazor

An understanding of C# basics, including language constructs, flow control, and exception handling

Content

304 Lessons86 Quizzes

Introduction

1 Lessons

Master modern C# and .NET 7 for cross-platform application development.

Introduction to the Course

Hello, C#! Welcome, .NET!

17 Lessons

Explore modern .NET development, tools, and building console applications across platforms.

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#

21 Lessons

Explore C# fundamentals, including syntax, variables, and asynchronous programming techniques.

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

14 Lessons

Master essential C# programming concepts, including control flow, operators, and exception handling.

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

19 Lessons

Master function writing, debugging, and testing for robust C# applications.

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

21 Lessons

Master object-oriented programming in C# by creating custom types and utilizing modern features.

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

25 Lessons

Master essential C# concepts, including interfaces, inheritance, generics, and memory management.

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

17 Lessons

Master packaging, deploying, and distributing .NET applications across platforms effectively.

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

19 Lessons

Explore essential .NET types for data manipulation, including numbers, text, and collections.

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

17 Lessons

Master essential file handling, data manipulation, and serialization techniques in C#.

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

22 Lessons

Master data management with Entity Framework Core, covering models, queries, and transactions.

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

21 Lessons

Master efficient data querying and manipulation using LINQ's powerful features.

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

13 Lessons

Explore ASP.NET Core's features, project structuring, and entity model development for web applications.

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

17 Lessons

Master web development with ASP.NET Core Razor Pages, focusing on dynamic content and security.

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

25 Lessons

Master building complex websites with ASP.NET Core MVC, focusing on scalability and customization.

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

18 Lessons

Master building and consuming web services with ASP.NET Core and Minimal APIs.

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

16 Lessons

Explore Blazor for building interactive web applications with C# across server and client environments.

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

1 Lessons

Congratulations on mastering essential skills for modern cross-platform C# and .NET development.

Wrap Up

Certificate of Completion

Showcase your accomplishment by sharing your certificate of completion.

Developed by MAANG Engineers

Every Educative lesson is designed by our in-house team of ex-MAANG software engineers and PhD computer science educators, and developed in consultation with developers and data scientists working at Meta, Google, and more. Our mission is to get you hands-on with the necessary skills to stay ahead in a constantly changing industry. No video, no fluff. Just interactive, project-based learning with personalized feedback that adapts to your goals and experience.

Trusted by 2.7 million developers working at companies

"These are high-quality courses. Trust me. I own around 10 and the price is worth it for the content quality. EducativeInc came at the right time in my career. I'm understanding topics better than with any book or online video tutorial I've done. Truly made for developers. Thanks"

Anthony Walker

@_webarchitect_

"Just finished my first full #ML course: Machine learning for Software Engineers from Educative, Inc. ... Highly recommend!"

Evan Dunbar

ML Engineer

"You guys are the gold standard of crash-courses... Narrow enough that it doesn't need years of study or a full blown book to get the gist, but broad enough that an afternoon of Googling doesn't cut it."

Software Developer

Carlos Matias La Borde

"I spend my days and nights on Educative. It is indispensable. It is such a unique and reader-friendly site"

Souvik Kundu

Front-end Developer

"Your courses are simply awesome, the depth they go into and the breadth of coverage is so good that I don't have to refer to 10 different websites looking for interview topics and content."

Vinay Krishnaiah

Software Developer

Hands-on Learning Powered by AI

See how Educative uses AI to make your learning more immersive than ever before.

Personalized Interview Prep

Skip the LeetCode grind with a custom roadmap that adapts to your goals. Hands-on practice for Coding Interviews, System Design, and more.

Mock Interviews

Test your skills in a simulated interview setting. Receive personalized feedback based on your performance. Available for Coding Interviews, System Design, and more.

AI Prompt

Build prompt engineering skills. Practice implementing AI-informed solutions.

Code Feedback

Evaluate and debug your code with the click of a button. Get real-time feedback on test cases, including time and space complexity of your solutions.

Explain with AI

Select any text within any Educative course, and get an instant explanation — without ever leaving your browser.

AI Code Mentor

AI Code Mentor helps you quickly identify errors in your code, learn from your mistakes, and nudge you in the right direction — just like a 1:1 tutor!

Free Resources

FOR TEAMS

Interested in this course for your business or team?

Unlock this course (and 1,000+ more) for your entire org with DevPath