C#

C# (pronounced C-sharp) is a statically-typed, object-oriented language developed by Microsoft. It runs on the .NET runtime and is known for its clean syntax and powerful features.

Core Features:
• Strong typing with type inference
• Object-oriented: classes, inheritance, polymorphism
• Async/await for asynchronous programming
• LINQ (Language Integrated Query) for data manipulation
• Delegates and events for event-driven programming
• Properties and automatic properties for encapsulation

C# runs on .NET, which includes frameworks and libraries for building diverse applications.

.NET Platforms:
• .NET 7+ (cross-platform): desktop, web, cloud
• ASP.NET Core: web applications and APIs
• Entity Framework Core: ORM for data access
• WPF: Windows desktop applications
• Unity: game development
• Blazor: web applications with C#

Modern C# includes advanced features for writing clean, maintainable code.

Features:
• Async/await patterns for non-blocking operations
• LINQ: querying collections, databases, XML
• Extension methods: adding methods to existing types
• Reflection: runtime type inspection
• Generics: type-safe reusable code
• Nullable reference types: null safety
• Records: immutable data types

C# is widely used for building enterprise systems, web services, and business applications.

Use Cases:
• Enterprise backend systems (banking, insurance, retail)
• Web APIs with ASP.NET Core
• Cloud applications on Azure
• Desktop applications with WPF or WinForms
• Game development with Unity
• Real-time applications with SignalR

// Modern C# (10+) features
// Records immutable data types
public record Person(string Name, int Age)
{
    // Computed property
    public bool IsAdult => Age >= 18;
}

var alice = new Person("Alice", 30); var olderAlice = alice with { Age = 31 }; // non-destructive mutation Console.WriteLine(alice == olderAlice); // false

// Pattern matching (C# 9+) static string Describe(object obj) => obj switch { int n when n < 0 => "negative number", int n => $"positive: {n}", string s when s.Length > 10 => "long string", string s => $"short string: {s}", null => "null", _ => "unknown" };

// Async/await public async Task> GetActiveUsersAsync() { await using var conn = new SqlConnection(_connectionString); var users = await conn.QueryAsync( "SELECT * FROM Users WHERE Active = 1"); return users.ToList(); }

// LINQ var topProducts = products .Where(p => p.IsActive && p.Stock > 0) .GroupBy(p => p.Category) .Select(g => new { Category = g.Key, Count = g.Count(), AvgPrice = g.Average(p => p.Price) }) .OrderByDescending(x => x.AvgPrice) .Take(5) .ToList(); ```

// Minimal API (ASP.NET Core 6+)
var builder = WebApplication.CreateBuilder(args);
builder.Services.AddDbContext<AppDbContext>(opt =>
    opt.UseSqlServer(builder.Configuration.GetConnectionString("Default")));
builder.Services.AddScoped<IUserService, UserService>();

var app = builder.Build();

// Route group with auth var users = app.MapGroup("/api/users").RequireAuthorization();

users.MapGet("/", async (IUserService svc) => Results.Ok(await svc.GetAllAsync()));

users.MapGet("/{id:int}", async (int id, IUserService svc) => await svc.GetByIdAsync(id) is User user ? Results.Ok(user) : Results.NotFound());

users.MapPost("/", async (CreateUserDto dto, IUserService svc) => { var user = await svc.CreateAsync(dto); return Results.Created($"/api/users/{user.Id}", user); });

// Minimal controller-style app.Run();

// Entity Framework Core public class AppDbContext : DbContext { public DbSet Users { get; set; } public DbSet Products { get; set; }

protected override void OnModelCreating(ModelBuilder mb) { mb.Entity() .HasIndex(u => u.Email).IsUnique(); mb.Entity() .HasOne(o => o.User) .WithMany(u => u.Orders) .OnDelete(DeleteBehavior.Cascade); } } ```