The Fundamentals of .NET for Modern Application Development

Introduction to .NET

.NET is a free, open-source development platform created by Microsoft that lets you build many types of applications: web, mobile, desktop, games, IoT, and cloud. It is a complete ecosystem that gives developers the tools they need to create modern, high-performance, secure applications.

Why Choose .NET?

• Versatility: Develop for Windows, Linux, macOS, iOS, Android, and more
• Performance: Optimized for speed and resource consumption
• Security: Frequent updates and built-in security features
• Open source: An open-source project backed by Microsoft and an active community
• Rich ecosystem: Numerous libraries and high-quality tools

Installation and Setup

Installing the .NET SDK

The .NET SDK (Software Development Kit) is required to develop .NET applications.

Windows:

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

macOS (with 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

Verifying the Installation

dotnet --version

Core Concepts

Programming Languages

.NET supports several programming languages, the most popular being:

• C# - The main language, object-oriented and strongly typed
• F# - A functional language for more concise programs
• Visual Basic .NET - A modernized version of Visual Basic

Structure of a .NET Project

A .NET project typically contains the following elements:

• .csproj / .fsproj / .vbproj file - Project configuration
• Program.cs - The application entry point
• Folders: Models, Controllers, Views (for web apps), Services, etc.
• appsettings.json - Application configuration

Creating a New Project

# 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

The C# Language

Variables and Data Types

// 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 }
};

Control Structures

// 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--;
}

Functions and Methods

// 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);
    }
}

Object-Oriented Programming in C#

Classes and Objects

// 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());

Inheritance

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 for Web Development

ASP.NET Core is a high-performance, cross-platform, open-source web framework for building modern web applications.

Structure of an ASP.NET Core Web Application

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

Creating a Simple REST API

// 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 for Simple Views

// 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 for Data Access

Entity Framework Core is an ORM (Object-Relational Mapping) that lets you interact with a database using C# objects.

Basic Configuration

// 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")));

Simple CRUD Operations

// 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();
        }
    }
}

Best Practices in .NET

Layered Architecture

A typical structure for a .NET application:

1. Presentation layer: UI, API, etc.
2. Application layer: Services, business logic
3. Domain layer: Entities, core business logic
4. Infrastructure layer: Data access, external services

Dependency Injection

// 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;
    }
    
    // ...
}

Unit Testing

// 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 in the Cloud

Azure and .NET

Azure offers excellent support for .NET applications:

• Azure App Service: Easy deployment of web applications
• Azure Functions: Serverless functions
• Azure SQL Database: A SQL database compatible with Entity Framework
• Azure Storage: Cloud storage (blobs, tables, queues)

Docker and .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"]

Resources for Further Learning

• Official documentation: docs.microsoft.com/dotnet
• Microsoft Learn: learn.microsoft.com
• GitHub .NET: github.com/dotnet
• .NET YouTube channel: youtube.com/dotnet

Conclusion

.NET is a mature, high-performance platform that is constantly evolving and offers an excellent development environment for building modern applications. Its versatility lets you target different platforms and develop many types of applications, from web to mobile, including desktop and cloud. By mastering these fundamentals, you have a solid foundation for exploring the many possibilities the .NET ecosystem has to offer.