C# 12 avec .NET 8: Développement d'Applications Robustes

C# 12 avec .NET 8: Développement d'Applications Robustes

C# est devenu l'un des langages les plus modernes et puissants. Voici comment le maîtriser.

Installation et Setup

# Installer .NET
# https://dotnet.microsoft.com/download

# Créer un nouveau projet
dotnet new console -n MonApp
cd MonApp

# Exécuter
dotnet run

# Version
dotnet --version

Types et Variables

// Types de base
int age = 25;
string name = "Jean";
double price = 19.99;
bool isActive = true;
char initial = 'J';

// Nullables
string? nullable = null;
int? age2 = null;

// Var (inférence de type)
var user = new User { Name = "Jean" };

// Tuple
(int x, int y) coordinates = (10, 20);
var (x, y) = coordinates;

// Constants
const double PI = 3.14159;

Classes et Objets

public class User
{
// Properties
public int Id { get; set; }
public string Name { get; set; }

// Auto-property avec validation
private int _age;
public int Age
{
get => _age;
set => _age = value >= 0 ? value : 0;
}

// Constructor
public User(string name, int age)
{
Name = name;
Age = age;
}

// Methods
public void DisplayInfo()
{
Console.WriteLine($"{Name}, {Age} ans");
}

// Override ToString
public override string ToString() => $"{Name} ({Age})";
}

// Utilisation
var user = new User("Jean", 30);
user.DisplayInfo();

Async/Await

// Récupérer des données de manière asynchrone
public async Task<User> GetUserAsync(int id)
{
using var client = new HttpClient();

var response = await client.GetAsync($"https://api.example.com/users/{id}");
response.EnsureSuccessStatusCode();

var json = await response.Content.ReadAsStringAsync();
return JsonSerializer.Deserialize<User>(json);
}

// Appeler une fonction async
var user = await GetUserAsync(1);
Console.WriteLine(user.Name);

// Attendre plusieurs tâches
Task[] tasks = new[]
{
GetUserAsync(1),
GetUserAsync(2),
GetUserAsync(3),
};
await Task.WhenAll(tasks);

LINQ - Requêtes sur Collections

List<User> users = new()
{
new User { Id = 1, Name = "Jean", Age = 30 },
new User { Id = 2, Name = "Marie", Age = 28 },
new User { Id = 3, Name = "Pierre", Age = 35 },
};

// Filtering
var adults = users.Where(u => u.Age >= 18);

// Mapping
var names = users.Select(u => u.Name);

// Sorting
var sorted = users.OrderBy(u => u.Age);

// Aggregation
int count = users.Count();
double avgAge = users.Average(u => u.Age);
var oldest = users.MaxBy(u => u.Age);

// Combining
var result = users
.Where(u => u.Age > 25)
.OrderBy(u => u.Name)
.Select(u => new { u.Name, u.Age })
.ToList();

Entity Framework Core - ORM

// DbContext
public class AppDbContext : DbContext
{
public DbSet<User> Users { get; set; }
public DbSet<Post> Posts { get; set; }

protected override void OnConfiguring(DbContextOptionsBuilder options)
{
options.UseSqlServer("Server=localhost;Database=myapp;");
}
}

// Utilisation
using var context = new AppDbContext();

// Create
var user = new User { Name = "Jean", Age = 30 };
context.Users.Add(user);
await context.SaveChangesAsync();

// Read
var users = await context.Users.ToListAsync();
var user = await context.Users.FindAsync(1);

// Update
user.Age = 31;
await context.SaveChangesAsync();

// Delete
context.Users.Remove(user);
await context.SaveChangesAsync();

// Queries
var adults = await context.Users
.Where(u => u.Age >= 18)
.OrderBy(u => u.Name)
.ToListAsync();

Dependency Injection

// Service interface
public interface IUserService
{
Task<User> GetUserAsync(int id);
}

// Implementation
public class UserService : IUserService
{
private readonly AppDbContext _context;

public UserService(AppDbContext context)
{
_context = context;
}

public async Task<User> GetUserAsync(int id)
{
return await _context.Users.FindAsync(id);
}
}

// Program.cs (ASP.NET Core)
var builder = WebApplication.CreateBuilder(args);

// Register services
builder.Services.AddScoped<IUserService, UserService>();
builder.Services.AddDbContext<AppDbContext>();

var app = builder.Build();

// Utiliser dans un controller
public class UserController : ControllerBase
{
private readonly IUserService _userService;

public UserController(IUserService userService)
{
_userService = userService;
}

[HttpGet("{id}")]
public async Task<IActionResult> Get(int id)
{
var user = await _userService.GetUserAsync(id);
return Ok(user);
}
}

Exceptions et Validation

public class UserValidator
{
public void Validate(User user)
{
if (string.IsNullOrWhiteSpace(user.Name))
throw new ArgumentException("Name is required");

if (user.Age < 0 || user.Age > 150)
throw new ArgumentException("Age must be between 0 and 150");
}
}

// Utilisation
try
{
var user = new User { Name = "", Age = 200 };
validator.Validate(user);
}
catch (ArgumentException ex)
{
Console.WriteLine($"Validation error: {ex.Message}");
}

Patterns Modernes

// Records (immuables par défaut)
public record UserRecord(int Id, string Name, int Age);

var user = new UserRecord(1, "Jean", 30);
// user.Name = "Marie"; // Erreur!

// With expression
var updatedUser = user with { Age = 31 };

// Pattern matching
public string GetDescription(User user) => user.Age switch
{
< 18 => "Mineur",
>= 18 and < 65 => "Adulte",
>= 65 => "Senior",
};

ASP.NET Core Web API

// Minimal API (simple)
app.MapGet("/users/{id}", async (int id, AppDbContext db) =>
await db.Users.FindAsync(id) is User user
? Results.Ok(user)
: Results.NotFound());

app.MapPost("/users", async (User user, AppDbContext db) =>
{
db.Users.Add(user);
await db.SaveChangesAsync();
return Results.Created($"/users/{user.Id}", user);
});

Ressources

Microsoft Learn: https://learn.microsoft.com/dotnet
C# Guide: https://docs.microsoft.com/dotnet/csharp
NuGet: https://www.nuget.org