.NET-Prototypmodus erklärt

Definition des Prototypmusters:

Verwenden Sie Prototypinstanzen, um die zu erstellenden Objekttypen anzugeben, und erstellen Sie neue Objekte durch Kopieren dieser Prototypen.

Strukturdiagramm des Prototypmodus:

Ein spezieller Modus im Kreativmodus – der Prototypmodus. Eine der größten Funktionen besteht darin, dort ein vorhandenes Objekt zu klonen Es gibt zwei Ergebnisse dieses Klonens, eines ist eine flache Kopie und das andere ist eine tiefe Kopie.

Der Kreativmodus wird im Allgemeinen zum Erstellen eines neuen Objekts verwendet. Anschließend können wir mit diesem Objekt einige Objektoperationen ausführen, ohne dass eine spezielle new()-Operation erforderlich ist Schließen Sie die Erstellung von Objekten schnell ab. Dies ist zweifellos eine sehr effektive Möglichkeit, schnell ein neues Objekt zu erstellen.

1. Prototypmodus: Flache Kopie

Definieren Sie eine Schnittstelle, um alle Farbobjektschnittstellen auszudrücken

/// <summary>
/// 颜色接口
/// </summary>
public interface IColor
{
  IColor Clone();
  int Red { get; set; }
  int Green { get; set; }
  int Blue { get; set; }
}

Gibt Der spezifische Implementierungscode von Rot:

public class RedColor:IColor
{
  public int Red { get; set; }
  public int Green { get; set; }
  public int Blue { get; set; }
 
  public IColor Clone()
  {
    return (IColor)this.MemberwiseClone();
  }
}

Der spezifische Testcode lautet wie folgt:

static void Main(string[] args)
{
  IColor color = new RedColor();
  color.Red = 255;
  Console.WriteLine("color -red " + color.Red); //225
  IColor color1 = color.Clone();
  color1.Red = 224;
  Console.WriteLine("color1-red " + color1.Red);//224
  Console.WriteLine("color -red " + color.Red); //225
}

Es kann festgestellt werden, dass es keine Auswirkung auf die Attributparameter der Farbe hat, wenn wir den roten Attributwert des Objekts color1 ändern, d. h. die Änderung Das Kopieren des Objekts hat keinen Einfluss auf den Status des Objekts selbst.

2. Prototyp-Modus: Deep Copy

Die bei Deep Copy betrachtete Situation ist relativ kompliziert, da zwischen Objekten Vererbungsbeziehungen oder Referenzbeziehungen bestehen können. Sie müssen dabei aufpassen Deep Copying kann im Allgemeinen eine einfache Deep Copy-Methode für Objekte verwenden, oder Sie können Objekte auch in Form einer Serialisierung kopieren. Das Prototypmuster wird in Form einer Serialisierung implementiert:

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
namespace ConsoleApplication4
{
  /// <summary>
  /// 颜色接口
  /// </summary>
  public interface IColor
  {
    IColorDemo Clone();
 
    int Red { get; set; }
    int Green { get; set; }
    int Blue { get; set; }
    Factroy f{get;set;}
  }
 
  /// <summary>
  /// 生产颜色的工厂信息
  /// </summary>
  [Serializable]
  public class Factroy
  {
    public string name { get; set; }
  }
}
 
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
namespace ConsoleApplication4
{
  /// <summary>
  /// 颜色
  /// </summary>
  [Serializable]
  public class RedColor:IColor
  {
    public int Red { get; set; }
    public int Green { get; set; }
    public int Blue { get; set; }
    public Factroy f { get; set; }
 
    public IColor Clone()
    {
      SerializableHelper s = new SerializableHelper();
      string target = s.Serializable(this);
      return s.Derializable<IColor>(target);
    }
  }
}

Serialisierungshilfsklasse:

/// <summary>
  /// 序列化和反序列化辅助类
  /// </summary>
  public class SerializableHelper
  {
    public string Serializable(object target)
    {
      using (MemoryStream stream = new MemoryStream())
      {
        new BinaryFormatter().Serialize(stream, target);
 
        return Convert.ToBase64String(stream.ToArray());
      }
    }
 
    public object Derializable(string target)
    {
      byte[] targetArray = Convert.FromBase64String(target);
 
      using (MemoryStream stream = new MemoryStream(targetArray))
      {
        return new BinaryFormatter().Deserialize(stream);
      }
    }
 
    public T Derializable<T>(string target)
    {
      return (T)Derializable(target);
    }
  }

Test:

static void Main(string[] args)
{
  IColor color = new RedColor();
  color.Red = 255;
  color.f = new Factroy() { name="湖北工厂" };
  Console.WriteLine("color - Factroy:" + color.f.name); //湖北工厂
 
  IColor color1 = color.Clone();
  color1.Red = 234;
  color1.f.name = "北京工厂";
  Console.WriteLine("color1- Factroy:" + color1.f.name); //北京工厂
  Console.WriteLine("color - Factroy:" + color.f.name); //湖北工厂
  Console.Read();
}

Die laufenden Ergebnisse des Programms sind wie folgt:

Fazit: Durch Serialisierung und Deserialisierung entstehen neue Objekte. Solange im Projekt der Prototypmodus zum Kopieren von Objekten verwendet wird, kann ein tiefes Kopieren in Form einer Serialisierung durchgeführt werden.