设计模式系列—原型模式

public class DataTableDemo
{
    public void CloneTest()
    {
        string cmdText = "SELECT * FROM TABLE";
        DataTable dt = new DataTable();
        //通过执行上面的cmdText 返回一个dataTable对象；

        //这时候我们可以如下形式复制一个新的dataTable，而不用先创建一个dataTable，然后把每一列都显示的循环添加到新的 dataTable中，

        //这是很大的工作量。
        DataTable dt1 = dt.Clone();
        //克隆一个新的对象 dt1.

        #region 不采用克隆的形式复制一个新的dataTable
        DataTable dt2 = new DataTable();

        foreach (DataColumn column in dt.Columns)
        {
            dt2.Columns.Add(column.ColumnName);
        }
        #endregion
    }
}

// 摘要:
//     创建当前 System.Object 的浅表副本。
//
// 返回结果:
//     当前 System.Object 的浅表副本。
[SecuritySafeCritical]
protected object MemberwiseClone();

/// <summary>
/// 杯子类
/// </summary>
public class Cup : ICloneable
{
    private double _rl;
    private int _height;
    private Factory _factory;
    /// <summary>
    /// 高度
    /// </summary>
    public int Height
    {
        get
        {
            return _height;
        }
        set
        {
            _height = value;
        }
    }

    /// <summary>
    /// 容量
    /// </summary>
    public double RL
    {
        get
        {
            return _rl;
        }
        set
        {
            _rl = value;
        }
    }

    /// <summary>
    /// 生产厂家
    /// </summary>
    public Factory Factory
    {
        get
        {
            return _factory;
        }
        set
        {
            _factory = value;
        }
    }

    #region ICloneable 成员

    public object Clone()
    {
        return this.MemberwiseClone();
    }

    #endregion
}

class Program
{
    static void Main(string[] args)
    {
        Cup cup = new Cup();
        cup.Height = 2;
        Cup cup1 = (Cup)cup.Clone();

        cup1.Height = 1;
        Console.WriteLine(cup.Height == cup1.Height);
        System.Threading.Thread.Sleep(10000);
    }
}

public object Clone()
{
    Cup cup = (Cup)this.MemberwiseClone();
    Factory factory1 = new Factory();
    factory1.FactoryName = this.Factory.FactoryName;
    cup.Factory = factory1;

    return cup;
}

public interface IColorDemo
{
    IColorDemo Clone();

    int Red
    {
        get;
        set;
    }
    int Green
    {
        get;
        set;
    }
    int Blue
    {
        get;
        set;
    }
}
我们这里给出红色的具体实现代码：
public class RedColor : IColorDemo
{
    private int red;
    private int green;
    private int blue;
    public int Red
    {
        get
        {
            return this.red;
        }
        set
        {
            this.red = value;
        }
    }
    public int Green
    {
        get
        {
            return this.green;
        }
        set
        {
            this.green = value;
        }
    }
    public int Blue
    {
        get
        {
            return this.blue;
        }
        set
        {
            this.blue = value;
        }
    }

    #region IColorDemo 成员

    public IColorDemo Clone()
    {
        return (IColorDemo)this.MemberwiseClone();
    }

    #endregion
}
因为上面的对于颜色，都是通过RGB不同的比例配置出来的，所以我就定义了3个整形的变量，所以我这里只是演示说明。那么具体的测试代码如下：
static void Main(string[] args)
{
    IColorDemo color = new RedColor();
    color.Red = 255;

    IColorDemo color1 = color.Clone();
    color1.Blue = 255;

    Console.WriteLine(color.Blue == color1.Blue);
    System.Threading.Thread.Sleep(10000);
}
返回的结果为false。代表对象副本的修改不会影响对象本身的状态。

/// <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);
     }
}
下面给出简单的示例代码，还是使用上面的颜色对象为例。我们修改颜色类中的Clone方法：
#region IColorDemo 成员
public IColorDemo Clone()
{
    string target= SerializableHelper.Serializable(this);
    return SerializableHelper.Derializable<IColorDemo>(target);
}
#endregion
程序的测试代码如下：
static void Main(string[] args)
{
    IColorDemo color = new RedColor();
    color.Red = 255;

    IColorDemo color1 = color.Clone();
    color1.Red = 234;

    Console.WriteLine(color.Blue == color1.Blue);
    System.Threading.Thread.Sleep(10000);
}
程序的运行结果为false，肯定二个对象是不同的，通过序列化和反序列化形成新的对象。其实只要是项目中要使用原型模式进行对象复制的情况下，都可以通过序列化的形式来进行深复制。