Le design pattern Adapter est un modèle structurel qui permet à une interface existante d'être utilisée comme une autre interface. Il permet à des classes avec des interfaces incompatibles de travailler ensemble. L'Adapter agit comme un intermédiaire entre deux interfaces, convertissant les appels de l'une à l'autre.
En C#, un adaptateur peut être implémenté en utilisant une classe qui implémente l'interface requise tout en faisant appel à une instance d'une autre classe avec une interface différente.
Voici un exemple simple d'implémentation du design pattern Adapter en C# :
```csharp
using System;
// Interface cible (Target)
public interface ITarget
{
void Request();
}
// Classe Adaptee (à adapter)
public class Adaptee
{
public void SpecificRequest()
{
Console.WriteLine("Specific Request");
}
}
// Adapter
public class Adapter : ITarget
{
private Adaptee adaptee;
public Adapter(Adaptee adaptee)
{
this.adaptee = adaptee;
}
public void Request()
{
// Utilisation de l'Adaptee pour satisfaire l'interface cible
adaptee.SpecificRequest();
}
}
class Program
{
static void Main()
{
// Utilisation de l'Adapter pour permettre à Adaptee de satisfaire l'interface cible
Adaptee adaptee = new Adaptee();
ITarget adapter = new Adapter(adaptee);
// Appel de la méthode Request de l'interface cible
adapter.Request();
}
}
```
Dans cet exemple, `ITarget` est l'interface cible que notre client (le code client) utilise. `Adaptee` est une classe existante avec une interface incompatible, et `Adapter` est la classe d'adaptateur qui permet à `Adaptee` de satisfaire l'interface `ITarget`. Ainsi, le client peut appeler la méthode `Request` de l'interface cible sans se soucier de la classe `Adaptee` sous-jacente.
Ce modèle est utile lorsque vous avez des classes existantes avec des interfaces incompatibles, et vous voulez les intégrer dans un nouveau code sans modifier ces classes existantes.
Aucun commentaire:
Enregistrer un commentaire