Pourquoi .NET ?
La technologie .NET est une plateforme de développement open source et multiplateforme, créée par Microsoft, qui permet aux développeurs de créer des applications modernes pour Windows, Mac, Linux, mobiles, IoT et jeux vidéo. Elle offre une grande variété d'options pour développer des applications en backend (API RESTful, services web, bases de données), frontend (UI/UX, microservices) et même des applications hybrides et natives.
Un cas d'usage concret est l'élaboration d'une application web moderne qui nécessite une interface utilisateur moderne, un back-end robuste et des fonctionnalités mobiles. Avec .NET, vous pouvez créer une telle application en utilisant le framework ASP.NET Core pour le backend, Blazor pour la partie frontend (front-end) et les technologies cross-platform comme React ou Angular pour les interfaces mobiles.
Prerequis
- Connaissance de base du langage C#
- Un éditeur de code moderne comme Visual Studio Code
- .NET SDK 6.0 ou ultérieur
- Git pour le contrôle de version (facultatif mais recommandé)
Pour installer .NET SDK sur Windows, Mac et Linux :
Windows :
dotnet install --version 6.0.100
Mac :
brew install dotnet-sdk
Linux :
sudo apt-get update; \
sudo apt-get install -y dotnet-sdk-6.0
Concepts fondamentaux
1. Projets .NET
Un projet .NET est un conteneur pour les fichiers de code source et les ressources nécessaires à la création d'une application. Voici comment créer un nouveau projet :
dotnet new console -n MonProjet
cd MonProjet
2. Program.cs
Le fichier Program.cs est le point d'entrée pour votre application .NET. Il contient une méthode Main qui sera exécutée au démarrage de l'application.
using System;
namespace MonProjet
{
class Program
{
static void Main(string[] args)
{
Console.WriteLine("Hello, World!");
}
}
}
3. Packages NuGet
NuGet est le gestionnaire de packages pour .NET. Il permet d'ajouter des bibliothèques tierces à votre projet.
dotnet add package Microsoft.Extensions.DependencyInjection
4. Services et Inversion of Control (IoC)
L'injection de dépendances (DI) et l'inversion de contrôle (IoC) facilitent le test unitaire et la maintenance du code en séparant les responsabilités.
using System;
using Microsoft.Extensions.DependencyInjection;
namespace MonProjet
{
public interface IGreetingService
{
void Greet();
}
public class GreetingService : IGreetingService
{
public void Greet()
{
Console.WriteLine("Hello, World!");
}
}
class Program
{
static void Main(string[] args)
{
var services = new ServiceCollection();
services.AddTransient<IGreetingService, GreetingService>();
var serviceProvider = services.BuildServiceProvider();
var greetingService = serviceProvider.GetService<IGreetingService>();
greetingService.Greet();
}
}
}
5. Asynchronous Programming
La programmation asynchrone permet d'exécuter des opérations en parallèle, ce qui améliore les performances.
using System;
using System.Threading.Tasks;
namespace MonProjet
{
class Program
{
static async Task Main(string[] args)
{
await GreetAsync();
}
static async Task GreetAsync()
{
await Task.Delay(1000); // Simule une tâche asynchrone
Console.WriteLine("Hello, World!");
}
}
}
Mise en pratique : projet fil rouge
Mini-Projet : Gestionnaire de Tâches
Le but est de créer un simple gestionnaire de tâches console qui permet d'ajouter et de lister les tâches.
Étape 1 : Création du projet
dotnet new console -n TaskManager
cd TaskManager
Étape 2 : Ajout des classes
Créez un fichier Task.cs :
namespace TaskManager
{
public class Task
{
public int Id { get; set; }
public string Description { get; set; }
public bool IsCompleted { get; set; }
public override string ToString()
{
return $"{Id}: {Description} - {(IsCompleted ? "Completed" : "Pending")}";
}
}
}
Créez un fichier TaskManager.cs :
using System;
using System.Collections.Generic;
namespace TaskManager
{
public class TaskManager
{
private List<Task> tasks = new List<Task>();
public void AddTask(string description)
{
var task = new Task { Id = tasks.Count + 1, Description = description };
tasks.Add(task);
Console.WriteLine($"Task added: {task}");
}
public void ListTasks()
{
if (tasks.Count == 0)
{
Console.WriteLine("No tasks found.");
return;
}
foreach (var task in tasks)
{
Console.WriteLine(task);
}
}
}
}
Étape 3 : Utilisation du gestionnaire de tâches
Modifiez Program.cs :
using System;
namespace TaskManager
{
class Program
{
static void Main(string[] args)
{
var taskManager = new TaskManager();
while (true)
{
Console.WriteLine("1. Add Task");
Console.WriteLine("2. List Tasks");
Console.WriteLine("3. Exit");
Console.Write("Enter your choice: ");
var choice = Console.ReadLine();
switch (choice)
{
case "1":
Console.Write("Enter task description: ");
var description = Console.ReadLine();
taskManager.AddTask(description);
break;
case "2":
taskManager.ListTasks();
break;
case "3":
return;
default:
Console.WriteLine("Invalid choice. Please try again.");
break;
}
}
}
}
}
Étape 4 : Exécution du projet
dotnet run
Erreurs frequentes et debugging
1. Erreur de compilation : Program.cs(3,27): error CS0103: The name 'Console' does not exist in the current context
Code incorrect :
using System;
namespace MonProjet
{
class Program
{
static void Main(string[] args)
{
Console.WriteLine("Hello, World!");
}
}
}
Correction :
using System;
using System.Text.Json;
namespace MonProjet
{
class Program
{
static void Main(string[] args)
{
Console.WriteLine("Hello, World!");
}
}
}
2. Erreur d'exécution : System.IO.FileNotFoundException: Could not load file or assembly 'Newtonsoft.Json'
Code incorrect :
using Newtonsoft.Json;
class Program
{
static void Main(string[] args)
{
var json = JsonConvert.SerializeObject(new { Name = "John", Age = 30 });
Console.WriteLine(json);
}
}
Correction :
dotnet add package Newtonsoft.Json
net
using System;
using Newtonsoft.Json;
class Program
{
static void Main(string[] args)
{
var json = JsonConvert.SerializeObject(new { Name = "John", Age = 30 });
Console.WriteLine(json);
}
}
3. Erreur de compilation : CS1502: The best overloaded method match for 'TaskManager.AddTask(string)' has some invalid arguments
Code incorrect :
using System;
namespace MonProjet
{
class Program
{
static void Main(string[] args)
{
var taskManager = new TaskManager();
taskManager.AddTask(123); // Erreur d'argument
}
}
}
Correction :
using System;
namespace MonProjet
{
class Program
{
static void Main(string[] args)
{
var taskManager = new TaskManager();
taskManager.AddTask("Complete the project"); // Correction
}
}
}
Pour aller plus loin
Découverte avancée des services et de l'injection de dépendances
Introduction à ASP.NET Core
Développement d'applications cross-platform avec .NET MAUI
Défi pratique :
Créez une application console qui utilise le service HttpClient pour récupérer des données JSON à partir d'une API publique et les afficher. Utilisez l'injection de dépendances pour gérer la création du HttpClient.