.NET Lessons

What is .NET? Understand the difference between.NET, C#, the SDK, the runtime, and. This beginner lesson builds the first mental model carefully so students can understand what the .NET toolchain or framework feature is actually doing before layering

Console.WriteLine(".NET lets one C# codebase target web, desktop, cloud, and more.");

Install & Configure Visual Studio Code Install the.NET SDK, the C# extension, and a working terminal. This beginner lesson builds the first mental model carefully so students can understand what the .NET toolchain or framework feature is actually doi

// dotnet --info
// code .
// Install the C# Dev Kit extension in VS Code

Build .NET Applications with C# Learn how project templates, csproj files, restore, build, and run. This beginner lesson builds the first mental model carefully so students can understand what the .NET toolchain or framework feature is actually doing

// dotnet new console -n DotNetIntro
// cd DotNetIntro
// dotnet build
// dotnet run

Write Your First C# Code Write and run the first lines of C# so students. This beginner lesson builds the first mental model carefully so students can understand what the .NET toolchain or framework feature is actually doing before layering on projec

Console.WriteLine("Hello from CodeByte and .NET!");

Create and Run Console Apps Use the dotnet CLI and the generated Program.cs structure to. This intermediate lesson moves into practical implementation so learners can connect the concept to realistic project structure, debugging, and team-ready devel

using System;

class Program
{
    static void Main()
    {
        Console.WriteLine("Console apps are the best way to learn the workflow.");
    }
}

Add Logic to Console Apps Move beyond printing text by adding conditions, loops, and simple. This intermediate lesson moves into practical implementation so learners can connect the concept to realistic project structure, debugging, and team-ready de

int score = 78;
if (score >= 70)
{
    Console.WriteLine("Pass");
}
else
{
    Console.WriteLine("Keep practicing");
}

Work with Variables Store values, update program state, and understand how variables make. This intermediate lesson moves into practical implementation so learners can connect the concept to realistic project structure, debugging, and team-ready deve

string name = "Elena";
int lessonsCompleted = 12;
Console.WriteLine(name + " completed " + lessonsCompleted + " lessons.");

Create Methods Package repeated logic into methods so.NET applications become more readable. This advanced lesson focuses on production-minded tradeoffs, architecture, maintainability, and the kinds of design decisions developers face once the basic

static int Add(int left, int right)
{
    return left + right;
}

Console.WriteLine(Add(7, 5));

Manage Data in Console Apps Use collections and simple models to keep track of multiple. This advanced lesson focuses on production-minded tradeoffs, architecture, maintainability, and the kinds of design decisions developers face once the basic demo

List<string> topics = new List<string> { "SDK", "CLI", "Methods" };
foreach (var topic in topics)
{
    Console.WriteLine(topic);
}

ASP.NET Core Fundamentals Understand how ASP.NET Core starts up, maps routes, builds request. This beginner lesson builds the first mental model carefully so students can understand what the .NET toolchain or framework feature is actually doing befor

var builder = WebApplication.CreateBuilder(args);
var app = builder.Build();

app.MapGet("/", () => "Hello from ASP.NET Core");
app.Run();

Build Web APIs with ASP.NET Core Create JSON APIs with routes, DTOs, and handlers so students. This beginner lesson builds the first mental model carefully so students can understand what the .NET toolchain or framework feature is actually doing befo

app.MapGet("/courses", () => new[]
{
    new { Id = 1, Title = "C#" },
    new { Id = 2, Title = ".NET" }
});

Middleware, Routing, Dependency Injection Study the ASP.NET Core request pipeline so students understand where. This intermediate lesson moves into practical implementation so learners can connect the concept to realistic project structure, debugging

builder.Services.AddScoped<ICourseService, CourseService>();

app.Use(async (context, next) =>
{
    Console.WriteLine("Request incoming");
    await next();
});

Razor Pages & MVC Compare Razor Pages and MVC so learners understand when server-rendered. This intermediate lesson moves into practical implementation so learners can connect the concept to realistic project structure, debugging, and team-ready deve

public class IndexModel : PageModel
{
    public string Message { get; private set; } = "Welcome to Razor Pages";
    public void OnGet() { }
}

Authentication & Authorization Secure.NET web apps with identity, policies, claims, and protected endpoints. This advanced lesson focuses on production-minded tradeoffs, architecture, maintainability, and the kinds of design decisions developers face

builder.Services.AddAuthorization();

app.MapGet("/admin", () => "Protected area")
   .RequireAuthorization();

Build Web Apps with Blazor Use C# to build interactive UI with components, events, and. This advanced lesson focuses on production-minded tradeoffs, architecture, maintainability, and the kinds of design decisions developers face once the basic demo

<button @onclick="Increment">Count: @count</button>

@code {
    int count = 0;
    void Increment() => count++;
}

Build Mobile & Desktop Apps with .NET MAUI Understand how.NET MAUI shares app structure across platforms while still. This beginner lesson builds the first mental model carefully so students can understand what the .NET toolchain or framework feature

public partial class MainPage : ContentPage
{
    public MainPage()
    {
        InitializeComponent();
    }
}

UI Layouts Arrange controls with stack, grid, and content layouts so students. This beginner lesson builds the first mental model carefully so students can understand what the .NET toolchain or framework feature is actually doing before layering on p

Content = new VerticalStackLayout
{
    Padding = 24,
    Children =
    {
        new Label { Text = "Welcome to .NET MAUI" },
        new Button { Text = "Start learning" }
    }
};

Navigation Move between screens with navigation stacks and routing so app. This intermediate lesson moves into practical implementation so learners can connect the concept to realistic project structure, debugging, and team-ready development patterns

await Navigation.PushAsync(new DetailsPage());

Data Binding Bind UI to view-model state so updates flow cleanly between. This intermediate lesson moves into practical implementation so learners can connect the concept to realistic project structure, debugging, and team-ready development patterns.

BindingContext = new LessonViewModel();
// XAML: <Label Text="{Binding Title}" />

Platform APIs Use.NET abstractions and platform-specific capabilities like device info, storage, or. This advanced lesson focuses on production-minded tradeoffs, architecture, maintainability, and the kinds of design decisions developers face once th

var device = DeviceInfo.Current;
Console.WriteLine(device.Platform);
Preferences.Default.Set("theme", "dark");

Create Cloud-Native Apps with ASP.NET Core Design.NET services that are configuration-driven, observable, and ready for cloud. This beginner lesson builds the first mental model carefully so students can understand what the .NET toolchain or framewor

var builder = WebApplication.CreateBuilder(args);
builder.Services.AddHealthChecks();
var app = builder.Build();
app.MapHealthChecks("/health");
app.Run();

Background Services Run scheduled or continuous work safely with hosted services so. This intermediate lesson moves into practical implementation so learners can connect the concept to realistic project structure, debugging, and team-ready developmen

public class SyncWorker : BackgroundService
{
    protected override async Task ExecuteAsync(CancellationToken stoppingToken)
    {
        while (!stoppingToken.IsCancellationRequested)
        {
            Console.WriteLine("Sync tick");
            await Task.Delay(5000, stoppingToken);
        }
    }
}

Messaging & Queues Use message-driven thinking to decouple services and build systems that. This intermediate lesson moves into practical implementation so learners can connect the concept to realistic project structure, debugging, and team-ready dev

record OrderPlaced(int OrderId, decimal Total);

var message = new OrderPlaced(42, 99.50m);
Console.WriteLine("Publish order event: " + message.OrderId);

Microservices Architecture Understand service boundaries, communication styles, deployment tradeoffs, and why splitting. This advanced lesson focuses on production-minded tradeoffs, architecture, maintainability, and the kinds of design decisions dev

interface IOrdersService
{
    Task<string> GetStatusAsync(int orderId);
}

Containers & Docker with .NET Package.NET applications into containers so local development, CI, and production. This advanced lesson focuses on production-minded tradeoffs, architecture, maintainability, and the kinds of design decisions developers

# Dockerfile
FROM mcr.microsoft.com/dotnet/aspnet:8.0
WORKDIR /app
COPY . .
ENTRYPOINT ["dotnet", "MyService.dll"]

Connect to Databases Learn the role of connection strings, providers, contexts, and repository. This beginner lesson builds the first mental model carefully so students can understand what the .NET toolchain or framework feature is actually doing bef

string connectionString = "Server=.;Database=CodeByte;Trusted_Connection=True;";
Console.WriteLine(connectionString);

Entity Framework Core Basics Use DbContext and DbSet to map classes to tables so. This beginner lesson builds the first mental model carefully so students can understand what the .NET toolchain or framework feature is actually doing before layering o

public class AppDbContext : DbContext
{
    public DbSet<Course> Courses => Set<Course>();
}

LINQ Queries Query data with readable filters, projections, and sorting so the. This intermediate lesson moves into practical implementation so learners can connect the concept to realistic project structure, debugging, and team-ready development pat

var published = context.Courses
    .Where(course => course.IsPublished)
    .OrderBy(course => course.Title)
    .ToList();

Data Modeling Design entities and relationships around real domain concepts so the. This intermediate lesson moves into practical implementation so learners can connect the concept to realistic project structure, debugging, and team-ready development

public class Course
{
    public int Id { get; set; }
    public string Title { get; set; } = "";
    public List<Lesson> Lessons { get; set; } = new();
}

EF Core Migrations Track schema changes through migrations so database evolution stays reproducible. This advanced lesson focuses on production-minded tradeoffs, architecture, maintainability, and the kinds of design decisions developers face once th

// dotnet ef migrations add InitialCreate
// dotnet ef database update

Build AI Apps with Azure OpenAI Understand how a.NET application calls Azure-hosted language models, secures credentials. This beginner lesson builds the first mental model carefully so students can understand what the .NET toolchain or framework fea

// using Azure.AI.OpenAI;
string endpoint = "https://your-resource.openai.azure.com/";
string deployment = "gpt-4o-mini";
Console.WriteLine("Configure Azure OpenAI client here.");

Generate Text & Conversations Model prompts, responses, and chat history so students can build. This intermediate lesson moves into practical implementation so learners can connect the concept to realistic project structure, debugging, and team-ready

var messages = new List<string>
{
    "system: You are a helpful .NET tutor.",
    "user: Explain dependency injection simply."
};
Console.WriteLine("Send chat messages to the model and inspect the reply.");

Semantic Kernel (deprecated path) Study Semantic Kernel as an important historical.NET AI abstraction while. This advanced lesson focuses on production-minded tradeoffs, architecture, maintainability, and the kinds of design decisions developers face

// Historical example shape
// var kernel = Kernel.CreateBuilder().Build();
// Newer .NET AI work should be evaluated against current Azure/OpenAI guidance.

Unity with C# Understand how Unity uses C# scripts as components so gameplay. This beginner lesson builds the first mental model carefully so students can understand what the .NET toolchain or framework feature is actually doing before layering on pr

using UnityEngine;

public class PlayerController : MonoBehaviour
{
    void Start()
    {
        Debug.Log("Unity with C# is ready.");
    }
}

Game Loops Learn how Update, FixedUpdate, and frame-driven logic differ from request-response. This beginner lesson builds the first mental model carefully so students can understand what the .NET toolchain or framework feature is actually doing befo

void Update()
{
    transform.Rotate(0, 45f * Time.deltaTime, 0);
}

Input Handling Read keyboard, mouse, or controller input and connect it to. This intermediate lesson moves into practical implementation so learners can connect the concept to realistic project structure, debugging, and team-ready development pattern

float horizontal = Input.GetAxis("Horizontal");
float vertical = Input.GetAxis("Vertical");
Vector3 movement = new Vector3(horizontal, 0, vertical);
transform.Translate(movement * Time.deltaTime * 5f);

Physics & Rendering Understand how movement, collisions, rigidbodies, and visible rendering work together. This advanced lesson focuses on production-minded tradeoffs, architecture, maintainability, and the kinds of design decisions developers face o

Rigidbody body = GetComponent<Rigidbody>();
Renderer meshRenderer = GetComponent<Renderer>();
body.AddForce(Vector3.up * 5f, ForceMode.Impulse);
meshRenderer.material.color = Color.cyan;