.NET-Adaptermuster erklärt

Einführung in das Adaptermuster:

Konvertieren Sie die Schnittstelle einer Klasse in eine andere Schnittstelle, die der Kunde wünscht. Das Adaptermuster ermöglicht die Zusammenarbeit von Klassen, die andernfalls aufgrund inkompatibler Schnittstellen nicht zusammenarbeiten würden.

In der Computerprogrammierung passt das Adaptermuster (manchmal auch Wrapper-Stil oder Wrapper genannt) die Schnittstelle einer Klasse an die Erwartungen des Benutzers an. Eine Anpassung ermöglicht die Zusammenarbeit von Klassen, die normalerweise aufgrund inkompatibler Schnittstellen nicht zusammenarbeiten würden, indem die eigene Schnittstelle der Klasse in eine vorhandene Klasse eingeschlossen wird.

Adaptermuster-Strukturdiagramm:

Einführung von Beispielen zur Veranschaulichung:

Verwendung des Protokollierungsprogramms als Demo-Beschreibung in einem beliebigen Satz von Software Es gibt ein entsprechendes Protokollverwaltungsmodul in der Entwicklungssoftware. Wenn wir eine Protokollkomponente eines Drittanbieters verwenden, verwendet diese die Methode Log.Write("write log") Eine große Anzahl instanziierter Journalaufzeichnungsobjekte wird für die Protokollierung mit der Methode Log.Write() verwendet. Protokollkomponenten von Drittanbietern sind jedoch nicht mehr kostenlos und erfordern Gebühren, daher planen wir die Verwendung eines neuen Protokollverwaltungsmoduls, das nur verwendet wird. die uns zur Verfügung gestellte API-Schnittstelle verwendet Log.WriteLog („neue Art, Protokolle zu schreiben“); Zu diesem Zeitpunkt stellt sich die Frage, wie mit dieser Migrationsänderung umgegangen werden soll

Klassenadaptermuster

1. Die ursprüngliche Protokollschnittstelle verwendet die Methode „Write“ („Protokoll schreiben“);

/// <summary>
/// 原来的日志记录接口
/// </summary>
public interface ILogTarget
{
  /// <summary>
  /// 原来的写日志方法
  /// </summary>
  void Write(string info);
}

2. Die aktuelle Protokollierungsschnittstelle verwendet jedoch WriteLog („Protokoll schreiben“). Sie implementiert eine neue Art des Protokollierens: das Schreiben von Protokollen in Dateien und Datenbanken

/// <summary>
/// 抽象写日志类
/// </summary>
public abstract class LogAdaptee
{
  /// <summary>
  /// 写日志
  /// </summary>
  public abstract void WriteLog(string info);
}

/// <summary>
/// 写文件日志记录
/// </summary>
public class FileLog:LogAdaptee
{
  /// <summary>
  /// 写日志到文件中
  /// </summary>
  public override void WriteLog(string info)
  {
    Console.WriteLine("记录到文本文件："+info);
  }
}

/// <summary>
/// 往数据库中写日志
/// </summary>
public class DatabaseLog:LogAdaptee
{
  /// <summary>
  /// 重写写日志方法
  /// </summary>
  public override void WriteLog(string info)
  {
    Console.WriteLine("记录到数据库："+info);
  }
}

3. Wie kann die ursprüngliche Art, Protokolle zu schreiben, durch die Methoden in den beiden neuen Objekten ersetzt werden?

/// <summary>
/// 采用新的写日志的方式，写入到数据库中
/// </summary>
public class DatabaseLogAdapter:DatabaseLog,ILogTarget
{
  /// <summary>
  /// 在重写ILogTarget接口中的的Write方法里面调用新的写日志的方式WriteLog
  /// </summary>
  public void Write(string info)
  {
    WriteLog(info);
  }
}

/// <summary>
/// 采用新的写日志的方式，写入到文本文件
/// </summary>
public class FileLogAdapter : FileLog, ILogTarget
{
  /// <summary>
  /// 在重写ILogTarget接口中的的Write方法里面调用新的写日志的方式WriteLog
  /// </summary>
  public void Write(string info)
  {
    this.WriteLog(info);
  }
}

4. Aufruf basierend auf der ursprünglich verwendeten Protokollierungsmethode, es wird jedoch tatsächlich die neue Protokollierungsmethode verwendet:

/// <summary>
/// 类 .NET-Adaptermuster erklärt（Adapter Pattern）
/// </summary>
class Program
{
  static void Main(string[] args)
  {
    ILogTarget dbLog = new DatabaseLogAdapter();
    dbLog.Write("程序启动成功");
    dbLog = new FileLogAdapter();
    dbLog.Write("程序启动成功");
  }
}

Objektadaptermuster

1. Die Methode verwendet einen Klassenadapter, um die Migrationsänderungen der neuen Protokollfunktion zu implementieren. Im Folgenden können wir den Objektadapter unterscheiden und entdecken Sie die Besonderheiten der beiden Methoden. Die ursprüngliche Methode zum Schreiben von Protokollen bleibt dieselbe: Write("Write Log");

/// <summary>
/// 原来的日志记录接口
/// </summary>
public interface ILogTarget
{
  /// <summary>
  /// 原来的写日志方法
  /// </summary>
  void Write(string info);
}

2 Die aktuelle Protokollschreibschnittstelle verwendet WriteLog(" „Protokoll schreiben“); Es implementiert eine neue Art des Protokollschreibens: das Schreiben von Protokollen in Dateien und Datenbanken:

/// <summary>
/// 抽象写日志类
/// </summary>
public abstract class LogAdaptee
{
  /// <summary>
  /// 写日志
  /// </summary>
  public abstract void WriteLog(string info);
}

/// <summary>
/// 写文件日志记录
/// </summary>
public class FileLog:LogAdaptee
{
  /// <summary>
  /// 写日志到文件中
  /// </summary>
  public override void WriteLog(string info)
  {
    Console.WriteLine("记录到文本文件："+info);
  }
}

/// <summary>
/// 往数据库中写日志
/// </summary>
public class DatabaseLog:LogAdaptee
{
  /// <summary>
  /// 重写写日志方法
  /// </summary>
  public override void WriteLog(string info)
  {
    Console.WriteLine("记录到数据库："+info);
  }
}

3. Oben haben wir die FileLogAdapter-Klasse und die DatabaseLogAdapter-Klasse hinzugefügt, die die Schnittstellen FileLog, DatabaseLog und ILogTarget erben, die Write-Methode neu geschrieben, um die neue Protokollschreibmethode WriteLog aufzurufen, und diese Methode zum Durchführen von Migrationsänderungen verwendet. Verwenden Sie die Objektanpassung unten:

/// <summary>
/// 对象适配，继承ILogTarget，里面有LogAdaptee抽象日志类对象。
/// </summary>
public class LogAdapter:ILogTarget
{
  /// <summary>
  /// 抽象写日志类
  /// </summary>
  private LogAdaptee _adaptee;
 
  public LogAdapter(LogAdaptee adaptee)
  {
    this._adaptee = adaptee;
  }
 
  public void Write(string info)
  {
    _adaptee.WriteLog(info);
  }
}

4. Rufen Sie das Programm auf:

/// <summary>
/// 对象.NET-Adaptermuster erklärt（Adapter Pattern）
/// </summary>
class Program
{
  static void Main(string[] args)
  {
    ILogTarget dbLog = new LogAdapter(new DatabaseLog());
    dbLog.Write("程序启动成功");
    ILogTarget fileLog = new LogAdapter(new FileLog());
    fileLog.Write("程序启动成功");
  }
}

Vergleicht man die Migrationsänderungen zwischen den beiden, so haben in der Klassenanpassungsmethode die Adapterklassen DatabaseLogAdapter und FileLogAdapter, die wir erhalten, alle Verhaltensweisen der übergeordneten Klasse, die sie erben, und auch alle Verhaltensweisen der Schnittstelle ILogTarget, also In Tatsächlich verstößt es gegen das Einzelverantwortungsprinzip von Klassen in den objektorientierten Entwurfsprinzipien, während Objektadapter eher dem objektorientierten Geist entsprechen, sodass eine Klassenanpassung in praktischen Anwendungen nicht empfohlen wird. Nehmen wir an, dass die angepasste Klasse, die wir beim Aufzeichnen von Protokollen gleichzeitig in die Datei und die Datenbank schreiben möchten, dann mit dem Objektadapter so schreiben wir:

/// <summary>
/// 对象适配，继承ILogTarget，里面有LogAdaptee抽象日志类对象。
/// </summary>
public class LogAdapter:ILogTarget
{
  /// <summary>
  /// 抽象写日志类
  /// </summary>
  private LogAdaptee _adapteed;
 
  /// <summary>
  /// 抽象写日志类
  /// </summary>
  private LogAdaptee _adapteef;
 
  public LogAdapter(LogAdaptee adapteed, LogAdaptee adapteef)
  {
    this._adapteed = adapteed;
    this._adapteef = adapteef;
  }
 
  public void Write(string info)
  {
    _adapteed.WriteLog(info);
    _adapteef.WriteLog(info);
  }
}

Aufruf:

/// <summary>
/// 对象.NET-Adaptermuster erklärt（Adapter Pattern）
/// </summary>
class Program
{
  static void Main(string[] args)
  {
    //同时写日志到文件和数据库
    ILogTarget dbLog = new LogAdapter(new FileLog(), new DatabaseLog());
    dbLog.Write("程序启动成功");
  }
}

Wenn Sie stattdessen einen Klassenadapter verwenden: Nutzen wir diese Schreibmethode, um das Ziel zu erreichen?

public class DatabaseLogAdapter : DatabaseLog, FileLog, ILogTarget
{
  public void Write(string info)
  {
    this.WriteLog(info);
  }
}

Das Ergebnis ist definitiv nicht möglich. Beim Schreiben der Details ist ein Fehler aufgetreten. Für verschiedene Situationen sollten wir geeignete Methoden verwenden, um eine adaptive Planung durchzuführen.

Das Obige ist der gesamte Inhalt dieses Artikels. Ich hoffe, dass er zum Lernen aller beiträgt. Ich hoffe auch, dass jeder die PHP-Chinesisch-Website unterstützt.