Le design pattern Observer est un modèle de conception comportemental qui permet à un objet, appelé sujet (subject), de notifier automatiquement ses dépendants, appelés observateurs (observers), lorsque son état change. Cela permet aux observateurs de rester synchronisés avec le sujet sans nécessiter de couplage direct entre eux.
Voici un exemple en C# illustrant le design pattern Observer :
```csharp
using System;
using System.Collections.Generic;
// Définition de l'interface de l'observateur
public interface IObserver
{
void Update(string message);
}
// Définition de l'interface du sujet
public interface ISubject
{
void Attach(IObserver observer);
void Detach(IObserver observer);
void Notify();
}
// Implémentation de l'observateur
public class ConcreteObserver : IObserver
{
private string _name;
public ConcreteObserver(string name)
{
_name = name;
}
public void Update(string message)
{
Console.WriteLine($"Observer {_name} received message: {message}");
}
}
// Implémentation du sujet
public class ConcreteSubject : ISubject
{
private List<IObserver> _observers = new List<IObserver>();
private string _message;
public void Attach(IObserver observer)
{
_observers.Add(observer);
}
public void Detach(IObserver observer)
{
_observers.Remove(observer);
}
public void Notify()
{
foreach (var observer in _observers)
{
observer.Update(_message);
}
}
public void ChangeMessage(string newMessage)
{
_message = newMessage;
Notify();
}
}
class Program
{
static void Main(string[] args)
{
// Création des observateurs
var observer1 = new ConcreteObserver("Observer 1");
var observer2 = new ConcreteObserver("Observer 2");
// Création du sujet
var subject = new ConcreteSubject();
// Attachement des observateurs au sujet
subject.Attach(observer1);
subject.Attach(observer2);
// Changement de l'état du sujet
subject.ChangeMessage("Hello World!");
// Détachement d'un observateur du sujet
subject.Detach(observer2);
// Changement de l'état du sujet
subject.ChangeMessage("Goodbye!");
Console.ReadLine();
}
}
```
Dans cet exemple, nous avons un sujet (`ConcreteSubject`) qui maintient une liste d'observateurs (`ConcreteObserver`). Lorsque l'état du sujet change, il notifie automatiquement tous ses observateurs en appelant leur méthode `Update`. Les observateurs, à leur tour, réagissent au changement d'état en exécutant une action spécifique, dans cet exemple, en affichant le message reçu à la console.
Aucun commentaire:
Enregistrer un commentaire