Les fondamentaux de .NET pour le développement d’applications modernes

Introduction à .NET

.NET est une plateforme de développement libre et open-source créée par Microsoft, permettant de construire différents types d’applications - web, mobile, desktop, jeux, IoT, et cloud. C’est un écosystème complet qui offre aux développeurs les outils nécessaires pour créer des applications modernes, performantes et sécurisées.

Pourquoi choisir .NET ?

• Polyvalence : Développez pour Windows, Linux, macOS, iOS, Android et plus
• Performance : Optimisé pour la vitesse et la consommation de ressources
• Sécurité : Mises à jour fréquentes et fonctionnalités de sécurité intégrées
• Open Source : Projet open-source soutenu par Microsoft et une communauté active
• Écosystème riche : Bibliothèques nombreuses et outils de qualité

Installation et configuration

Installer le SDK .NET

Le SDK (Software Development Kit) .NET est nécessaire pour développer des applications .NET.

Windows :

# Télécharger depuis le site officiel
https://dotnet.microsoft.com/download

macOS (avec Homebrew) :

brew install --cask dotnet-sdk

Linux (Ubuntu) :

wget https://packages.microsoft.com/config/ubuntu/20.04/packages-microsoft-prod.deb -O packages-microsoft-prod.deb
sudo dpkg -i packages-microsoft-prod.deb
sudo apt-get update
sudo apt-get install -y apt-transport-https
sudo apt-get install -y dotnet-sdk-6.0

Vérifier l’installation

dotnet --version

Les concepts fondamentaux

Les langages de programmation

.NET supporte plusieurs langages de programmation, les plus populaires étant:

• C# - Le langage principal, orienté objet et fortement typé
• F# - Un langage fonctionnel pour des programmes plus concis
• Visual Basic .NET - Une version modernisée de Visual Basic

Structure d’un projet .NET

Un projet .NET contient généralement les éléments suivants:

• Fichier .csproj / .fsproj / .vbproj - Configuration du projet
• Program.cs - Point d’entrée de l’application
• Dossiers: Models, Controllers, Views (pour les applis web), Services, etc.
• appsettings.json - Configuration de l’application

Créer un nouveau projet

# Créer une application console
dotnet new console -n MonApplication

# Créer une application web ASP.NET Core
dotnet new webapp -n MonAppWeb

# Créer une API web
dotnet new webapi -n MonAPI

Le langage C#

Variables et types de données

// Types de base
int nombre = 42;
double prix = 19.99;
bool estActif = true;
string nom = "Jean Dupont";
char lettre = 'A';

// Collections
int[] nombres = { 1, 2, 3, 4, 5 };
List<string> noms = new List<string> { "Alice", "Bob", "Charlie" };
Dictionary<string, int> ages = new Dictionary<string, int>
{
    { "Alice", 30 },
    { "Bob", 25 }
};

Structures de contrôle

// Conditions
if (age >= 18)
{
    Console.WriteLine("Majeur");
}
else
{
    Console.WriteLine("Mineur");
}

// Switch
switch (jour)
{
    case "Lundi":
        Console.WriteLine("Début de semaine");
        break;
    case "Vendredi":
        Console.WriteLine("Bientôt le weekend");
        break;
    default:
        Console.WriteLine("Un autre jour");
        break;
}

// Boucles
for (int i = 0; i < 5; i++)
{
    Console.WriteLine(i);
}

foreach (var nom in noms)
{
    Console.WriteLine(nom);
}

while (compteur > 0)
{
    Console.WriteLine(compteur);
    compteur--;
}

Fonctions et méthodes

// Méthode simple
void AfficherMessage(string message)
{
    Console.WriteLine(message);
}

// Méthode avec retour
int Additionner(int a, int b)
{
    return a + b;
}

// Méthode avec paramètres optionnels
void Configurer(string nom, int age = 18, bool estActif = true)
{
    // ...
}

// Méthode d'extension
public static class StringExtensions
{
    public static bool EstPalindrome(this string texte)
    {
        string inverse = new string(texte.Reverse().ToArray());
        return texte.Equals(inverse, StringComparison.OrdinalIgnoreCase);
    }
}

Programmation Orientée Objet en C#

Classes et objets

// Définition d'une classe
public class Personne
{
    // Propriétés
    public string Nom { get; set; }
    public string Prenom { get; set; }
    public int Age { get; set; }
    
    // Constructeur
    public Personne(string nom, string prenom, int age)
    {
        Nom = nom;
        Prenom = prenom;
        Age = age;
    }
    
    // Méthode
    public string ObtenirNomComplet()
    {
        return $"{Prenom} {Nom}";
    }
}

// Utilisation
Personne personne = new Personne("Dupont", "Jean", 30);
Console.WriteLine(personne.ObtenirNomComplet());

Héritage

public class Employe : Personne
{
    public string Poste { get; set; }
    public decimal Salaire { get; set; }
    
    public Employe(string nom, string prenom, int age, string poste, decimal salaire)
        : base(nom, prenom, age)
    {
        Poste = poste;
        Salaire = salaire;
    }
    
    public void AugmenterSalaire(decimal pourcentage)
    {
        Salaire += Salaire * (pourcentage / 100);
    }
}

Interfaces

public interface IPayable
{
    decimal CalculerPaiement();
}

public class Consultant : Personne, IPayable
{
    public decimal TarifHoraire { get; set; }
    public int HeuresTravaillees { get; set; }
    
    public Consultant(string nom, string prenom, int age, decimal tarifHoraire)
        : base(nom, prenom, age)
    {
        TarifHoraire = tarifHoraire;
    }
    
    public decimal CalculerPaiement()
    {
        return TarifHoraire * HeuresTravaillees;
    }
}

ASP.NET Core pour le développement web

ASP.NET Core est un framework web performant, multi-plateforme et open-source pour construire des applications web modernes.

Structure d’une application web ASP.NET Core

MonAppWeb/
├── Controllers/     # Contrôleurs MVC ou d'API
├── Models/          # Classes de modèles
├── Views/           # Vues Razor (pour MVC)
├── wwwroot/         # Fichiers statiques (CSS, JS, images)
├── appsettings.json # Configuration de l'application
├── Program.cs       # Point d'entrée
└── Startup.cs       # Configuration des services et du pipeline

Créer une API REST simple

// Controllers/PersonnesController.cs
[ApiController]
[Route("api/[controller]")]
public class PersonnesController : ControllerBase
{
    private static List<Personne> _personnes = new List<Personne>
    {
        new Personne { Id = 1, Nom = "Dupont", Prenom = "Jean", Age = 30 },
        new Personne { Id = 2, Nom = "Martin", Prenom = "Sophie", Age = 25 }
    };
    
    [HttpGet]
    public ActionResult<IEnumerable<Personne>> Get()
    {
        return _personnes;
    }
    
    [HttpGet("{id}")]
    public ActionResult<Personne> Get(int id)
    {
        var personne = _personnes.Find(p => p.Id == id);
        if (personne == null)
            return NotFound();
            
        return personne;
    }
    
    [HttpPost]
    public ActionResult<Personne> Post(Personne personne)
    {
        personne.Id = _personnes.Max(p => p.Id) + 1;
        _personnes.Add(personne);
        return CreatedAtAction(nameof(Get), new { id = personne.Id }, personne);
    }
}

Razor Pages pour des vues simples

// Pages/Index.cshtml.cs
public class IndexModel : PageModel
{
    public List<Personne> Personnes { get; set; }
    
    public void OnGet()
    {
        Personnes = new List<Personne>
        {
            new Personne { Id = 1, Nom = "Dupont", Prenom = "Jean", Age = 30 },
            new Personne { Id = 2, Nom = "Martin", Prenom = "Sophie", Age = 25 }
        };
    }
}

<!-- Pages/Index.cshtml -->
@page
@model IndexModel
@{
    ViewData["Title"] = "Liste des personnes";
}

<h1>Liste des personnes</h1>

<table class="table">
    <thead>
        <tr>
            <th>ID</th>
            <th>Prénom</th>
            <th>Nom</th>
            <th>Âge</th>
        </tr>
    </thead>
    <tbody>
        @foreach (var personne in Model.Personnes)
        {
            <tr>
                <td>@personne.Id</td>
                <td>@personne.Prenom</td>
                <td>@personne.Nom</td>
                <td>@personne.Age</td>
            </tr>
        }
    </tbody>
</table>

Entity Framework Core pour l’accès aux données

Entity Framework Core est un ORM (Object-Relational Mapping) qui permet d’interagir avec une base de données en utilisant des objets C#.

Configuration de base

// Models/Personne.cs
public class Personne
{
    public int Id { get; set; }
    public string Nom { get; set; }
    public string Prenom { get; set; }
    public int Age { get; set; }
}

// Data/ApplicationDbContext.cs
public class ApplicationDbContext : DbContext
{
    public ApplicationDbContext(DbContextOptions<ApplicationDbContext> options)
        : base(options)
    {
    }
    
    public DbSet<Personne> Personnes { get; set; }
}

// Program.cs
builder.Services.AddDbContext<ApplicationDbContext>(options =>
    options.UseSqlServer(builder.Configuration.GetConnectionString("DefaultConnection")));

Opérations CRUD simples

// Services/PersonneService.cs
public class PersonneService
{
    private readonly ApplicationDbContext _context;
    
    public PersonneService(ApplicationDbContext context)
    {
        _context = context;
    }
    
    public async Task<List<Personne>> ObtenirToutesAsync()
    {
        return await _context.Personnes.ToListAsync();
    }
    
    public async Task<Personne> ObtenirParIdAsync(int id)
    {
        return await _context.Personnes.FindAsync(id);
    }
    
    public async Task AjouterAsync(Personne personne)
    {
        _context.Personnes.Add(personne);
        await _context.SaveChangesAsync();
    }
    
    public async Task MettreAJourAsync(Personne personne)
    {
        _context.Entry(personne).State = EntityState.Modified;
        await _context.SaveChangesAsync();
    }
    
    public async Task SupprimerAsync(int id)
    {
        var personne = await _context.Personnes.FindAsync(id);
        if (personne != null)
        {
            _context.Personnes.Remove(personne);
            await _context.SaveChangesAsync();
        }
    }
}

Bonnes pratiques en .NET

Architecture en couches

Une structure classique d’une application .NET:

1. Couche Présentation : UI, API, etc.
2. Couche Application : Services, logique métier
3. Couche Domaine : Entités, logique métier essentielle
4. Couche Infrastructure : Accès aux données, services externes

Injection de dépendances

// Enregistrement des services dans Program.cs
builder.Services.AddScoped<IPersonneService, PersonneService>();
builder.Services.AddScoped<IPersonneRepository, PersonneRepository>();

// Utilisation dans un contrôleur
public class PersonnesController : ControllerBase
{
    private readonly IPersonneService _personneService;
    
    public PersonnesController(IPersonneService personneService)
    {
        _personneService = personneService;
    }
    
    // ...
}

Tests unitaires

// Tests/PersonneServiceTests.cs
public class PersonneServiceTests
{
    [Fact]
    public async Task ObtenirToutesAsync_RetourneToutesLesPersonnes()
    {
        // Arrange
        var mockRepository = new Mock<IPersonneRepository>();
        mockRepository.Setup(repo => repo.ObtenirToutesAsync())
            .ReturnsAsync(new List<Personne>
            {
                new Personne { Id = 1, Nom = "Dupont", Prenom = "Jean" },
                new Personne { Id = 2, Nom = "Martin", Prenom = "Sophie" }
            });
            
        var service = new PersonneService(mockRepository.Object);
        
        // Act
        var resultat = await service.ObtenirToutesAsync();
        
        // Assert
        Assert.Equal(2, resultat.Count);
    }
}

.NET dans le cloud

Azure et .NET

Azure offre un excellent support pour les applications .NET:

• Azure App Service : Déploiement facile d’applications web
• Azure Functions : Fonctions serverless
• Azure SQL Database : Base de données SQL compatible avec Entity Framework
• Azure Storage : Stockage cloud (blobs, tables, files d’attente)

Docker et .NET

# Dockerfile
FROM mcr.microsoft.com/dotnet/sdk:6.0 AS build
WORKDIR /src
COPY ["MonApp.csproj", "./"]
RUN dotnet restore "MonApp.csproj"
COPY . .
RUN dotnet publish "MonApp.csproj" -c Release -o /app/publish

FROM mcr.microsoft.com/dotnet/aspnet:6.0 AS final
WORKDIR /app
COPY --from=build /app/publish .
ENTRYPOINT ["dotnet", "MonApp.dll"]

Ressources pour continuer à apprendre

• Documentation officielle : docs.microsoft.com/dotnet
• Microsoft Learn : learn.microsoft.com
• GitHub .NET : github.com/dotnet
• Chaîne YouTube .NET : youtube.com/dotnet

Conclusion

.NET est une plateforme mature, performante et en constante évolution qui offre un excellent environnement de développement pour créer des applications modernes. Sa polyvalence permet de cibler différentes plateformes et de développer divers types d’applications, du web au mobile en passant par le desktop et le cloud. En maîtrisant ces fondamentaux, vous disposez d’une base solide pour explorer davantage les possibilités offertes par l’écosystème .NET.