The C# Ecosystem — Complete Guide

# Search for packages
dotnet search Newtonsoft.Json

# Install a package
dotnet add package Dapper
dotnet add package Microsoft.EntityFrameworkCore.SqlServer --version 9.0.0

# List installed packages
dotnet list package

# Remove a package
dotnet remove package Newtonsoft.Json

# Update all packages
dotnet outdated

# Create a NuGet package
dotnet pack -c Release

# Publish to NuGet.org
dotnet nuget push MyPackage.1.0.0.nupkg --api-key <key> --source https://api.nuget.org/v3/index.json

<!-- Package reference in .csproj -->
<ItemGroup>
  <PackageReference Include="Dapper" Version="2.1.28" />
  <PackageReference Include="Serilog.AspNetCore" Version="8.0.0" />
  <PackageReference Include="FluentValidation" Version="11.9.0" />
</ItemGroup>

// Dapper: Lightweight ORM
using Dapper;
var products = connection.Query<Product>("SELECT * FROM Products WHERE Price > @min", new { min = 10 });

// FluentValidation: Validation library
public class ProductValidator : AbstractValidator<Product>
{
    public ProductValidator()
    {
        RuleFor(p => p.Name).NotEmpty().Length(1, 100);
        RuleFor(p => p.Price).InclusiveBetween(0, 10000);
    }
}

// AutoMapper: Object mapping
var config = new MapperConfiguration(cfg => cfg.CreateMap<Product, ProductDto>());
var mapper = config.CreateMapper();
var dto = mapper.Map<ProductDto>(product);

// Polly: Resilience and transient fault handling
var retryPolicy = Policy.Handle<HttpRequestException>()
    .WaitAndRetryAsync(3, retryAttempt => TimeSpan.FromSeconds(Math.Pow(2, retryAttempt)));

var response = await retryPolicy.ExecuteAsync(() => httpClient.GetAsync(url));

// ASP.NET Core Web API
var builder = WebApplication.CreateBuilder(args);
builder.Services.AddControllers();
var app = builder.Build();
app.MapControllers();
app.Run();

// Blazor WebAssembly
// Runs C# in the browser via WebAssembly
// Components are written in .razor files
@page "/counter"
<button @onclick="IncrementCount">Click me</button>
<p>Count: @currentCount</p>
@code {
    private int currentCount = 0;
    private void IncrementCount() => currentCount++;
}

// .NET MAUI (Multi-platform App UI)
// Build native mobile and desktop apps from one codebase
public partial class MainPage : ContentPage
{
    int count = 0;
    private void OnCounterClicked(object? sender, EventArgs e)
    {
        count++;
        CounterLabel.Text = $"Clicked {count} times";
    }
}

// Windows Presentation Foundation (WPF)
// Desktop applications for Windows
<Button Content="Click Me" Click="Button_Click" />

// Console / Background Services
public class Worker : BackgroundService
{
    protected override async Task ExecuteAsync(CancellationToken stoppingToken)
    {
        while (!stoppingToken.IsCancellationRequested)
        {
            Console.WriteLine("Worker running at: {time}", DateTimeOffset.Now);
            await Task.Delay(1000, stoppingToken);
        }
    }
}

# Create projects
dotnet new webapi -n MyApi
dotnet new blazor -n MyBlazorApp
dotnet new maui -n MyMauiApp
dotnet new console -n MyConsole
dotnet new classlib -n MyLibrary
dotnet new worker -n MyWorker

# Build and test
dotnet build -c Release
dotnet test --filter "Category=Integration"
dotnet publish -c Release -o ./publish

# EF Core migrations
dotnet ef migrations add InitialCreate
dotnet ef database update
dotnet ef dbcontext scaffold "connection" Microsoft.EntityFrameworkCore.SqlServer

# Global tools
dotnet tool install -g dotnet-ef
dotnet tool install -g dotnet-outdated-tool
dotnet tool install -g dotnet-format

// Key resources for C# developers
public static class CommunityResources
{
    // Official: docs.microsoft.com/dotnet
    // Source code: github.com/dotnet/runtime
    // Community: dotnetfoundation.org

    public static string[] Podcasts =
    {
        ".NET Rocks!",
        "The .NET Core Podcast",
        "Merge Conflict",
        "Azure Friday"
    };

    public static string[] Blogs =
    {
        "devblogs.microsoft.com/dotnet",
        "blog.jetbrains.com/dotnet",
        "exceptionnotfound.net",
        "code-maze.com"
    };

    public static string[] Conferences =
    {
        ".NET Conf (free, annual)",
        "NDC (Copenhagen, London, Sydney)",
        "DotNext (Moscow)",
        "Build Stuff (online)"
    };
}

# Clone the runtime repo
git clone https://github.com/dotnet/runtime.git

# Clone the Roslyn compiler
git clone https://github.com/dotnet/roslyn.git

# Find issues for new contributors
# https://github.com/dotnet/runtime/issues?q=is%3Aissue+is%3Aopen+label%3A%22help+wanted%22

public static class CareerPaths
{
    public static Dictionary<string, string> Roles = new()
    {
        ["Backend Developer"] = "Build APIs, microservices, and server-side logic with ASP.NET Core",
        ["Full-Stack Developer"] = "Combine ASP.NET Core with Blazor or JavaScript frameworks",
        ["Cloud Developer"] = "Build cloud-native apps with Azure, AWS, or GCP using .NET",
        ["Game Developer"] = "Use Unity, which uses C# as its primary scripting language",
        ["Desktop Developer"] = "Build WPF, WinForms, or MAUI applications",
        ["Mobile Developer"] = "Use .NET MAUI or Xamarin for cross-platform mobile apps",
        ["DevOps Engineer"] = "Automate CI/CD pipelines for .NET applications",
        ["Architect"] = "Design large-scale distributed systems with .NET"
    };

    public static string[] Certifications =
    {
        "Microsoft Certified: Azure Developer Associate",
        "Microsoft Certified: Azure Solutions Architect",
        "Microsoft Certified: .NET Developer"
    };
}

public static class NextSteps
{
    public static async Task ContinueLearning()
    {
        Console.WriteLine("Topics to explore next:");
        Console.WriteLine("1. Microservices with .NET and Docker");
        Console.WriteLine("2. Cloud-native development with Azure");
        Console.WriteLine("3. Real-time systems with SignalR");
        Console.WriteLine("4. Machine learning with ML.NET");
        Console.WriteLine("5. Game development with Unity");
        Console.WriteLine("6. Desktop apps with .NET MAUI");
        Console.WriteLine("7. WebAssembly with Blazor");
        Console.WriteLine("8. Performance tuning with BenchmarkDotNet");

        Console.WriteLine("\nPractice strategies:");
        Console.WriteLine("- Build a personal project end-to-end");
        Console.WriteLine("- Contribute to open source");
        Console.WriteLine("- Write blog posts about what you learn");
        Console.WriteLine("- Participate in hackathons");
        Console.WriteLine("- Join local .NET user groups");
    }
}

using System;

Console.WriteLine(@"Congratulations on completing the C# tutorial series!

You have learned:
- C# language fundamentals (types, control flow, OOP)
- Modern features (records, pattern matching, nullable reference types)
- Data access (LINQ, EF Core, Dapper)
- Web development (ASP.NET Core, REST APIs, Blazor)
- Advanced topics (async, performance, memory management)
- Professional practices (testing, DI, design patterns)

The journey does not end here. Build something. Break something. Learn from both.
The .NET community is here to help you grow.

Happy coding!
");