C#设计模式:原型模式(Prototype Pattern)

Posted 叶丶梓轩

tags:

篇首语:本文由小常识网(cha138.com)小编为大家整理,主要介绍了C#设计模式:原型模式(Prototype Pattern)相关的知识,希望对你有一定的参考价值。

一,原型模式:通过将一个原型对象传给那个要发动创建的对象,这个要发动创建的对象通过请求原型对象拷贝它们自己来实施创建。(包含深度克隆和浅克隆)

主要面对的问题是:“某些结构复杂的对象”的创建工作;由于需求的变化,这些对象经常面临着剧烈的变化,但是他们却拥有比较稳定一致的接口。

先上代码,

PeoplePrototype.cs

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading;
using System.Threading.Tasks;

namespace PrototypePattern
{
    /// <summary>
    /// 如果序列化报错就加上Serializable这个特性
    /// </summary>
    [Serializable]
    public class PeoplePrototype
    {
        private static PeoplePrototype _peoplePrototype = null;
        private PeoplePrototype()
        {
            Console.WriteLine("{0}被创建了,线程ID{1}", this.GetType(), Thread.CurrentThread.ManagedThreadId);
        }

        static PeoplePrototype()
        {
            _peoplePrototype = new PeoplePrototype()
            {
                Name = "小明",
                Id = 1,
                Dept = new Dept()
                {
                    Id = 11,
                    Name = "技术部"
                }
            };
        }
        /// <summary>
        /// 克隆一个对象
        /// </summary>
        /// <returns></returns>
        public static PeoplePrototype CreateInstance()
        {
            PeoplePrototype peoplePrototype = (PeoplePrototype)_peoplePrototype.MemberwiseClone();;
            return peoplePrototype;
        }
        /// <summary>
        /// 克隆一个对象
        /// </summary>
        /// <returns></returns>
        public static PeoplePrototype CreateInstanceDeep()
        {
            PeoplePrototype peoplePrototype = (PeoplePrototype)_peoplePrototype.MemberwiseClone();
            //深度克隆,重新实例化一个对象和开辟一个内存,所以克隆的结果指向的地址每次都不一样
            //可是这样操作麻烦,我们优化一下
            peoplePrototype.Dept = new Dept()
            {
                Id = 11,
                Name = "技术部"
            };
            return peoplePrototype;
        }

        public static PeoplePrototype CreateInstanceSerializa()
        {
            //通过序列化生成实体
            return SerializaUtil.DeepClone<PeoplePrototype>(_peoplePrototype);
        }

        public int Id { get; set; }     //值类型保存的是地址
        /// <summary>
        /// 为什么string也是引用类型不被覆盖?String字符串的值是一个定存的,重新改值会实例化一个新的对象,所以在遍历中不建议使用string,因为损耗性能
        /// </summary>
        public string Name { get; set; }  //为什么string也是引用类型不被覆盖?
        public Dept Dept { get; set; }   //引用类型保存的是地址,所以克隆出来的值是一样的

    }

    /// <summary>
    /// 如果序列化报错就加上Serializable这个特性
    /// </summary>
    [Serializable]
    public class Dept
    {
        public int Id { get; set; }
        public string Name { get; set; }
    }
}

SerializaUtil.cs

using System;
using System.Collections.Generic;
using System.IO;
using System.Linq;
using System.Runtime.Serialization.Formatters.Binary;
using System.Text;
using System.Threading.Tasks;

namespace PrototypePattern
{
    /// <summary>
    /// 帮助类,创建对象
    /// </summary>
    public class SerializaUtil
    {
        /// <summary>
        /// 根据对象序列化
        /// </summary>
        /// <param name="target"></param>
        /// <returns></returns>
        public static string Serializa(object target)
        {
            using (MemoryStream stream = new MemoryStream())
            {
                new BinaryFormatter().Serialize(stream, target);
                return Convert.ToBase64String(stream.ToArray());
            }
        }
        /// <summary>
        /// 根据对象类型反序列化,生成新的实体对象
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="target"></param>
        /// <returns></returns>
        public static T Derializaable<T>(string target)
        {
            byte[] targetArray = Convert.FromBase64String(target);

            using (MemoryStream stream = new MemoryStream(targetArray))
            {
                return (T)new BinaryFormatter().Deserialize(stream);
            }
        }

        /// <summary>
        /// 实体对象
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="t"></param>
        /// <returns></returns>
        public static T DeepClone<T>(T t)
        {
            return Derializaable<T>(Serializa(t));
        }
    }
}

Program.cs

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace PrototypePattern
{
    class Program
    {
        static void Main(string[] args)
        {

            Console.WriteLine("---------------------------------------");
            PeoplePrototype peoplePrototype1 = PeoplePrototype.CreateInstance();
            PeoplePrototype peoplePrototype2 = PeoplePrototype.CreateInstance();
            Console.WriteLine("{0},{1}", peoplePrototype1.Name, peoplePrototype1.Id);
            Console.WriteLine("{0},{1}", peoplePrototype2.Name, peoplePrototype2.Id);

            Console.WriteLine("---------------------------------------");
            PeoplePrototype peoplePrototype3 = PeoplePrototype.CreateInstance();
            PeoplePrototype peoplePrototype4 = PeoplePrototype.CreateInstance();
            peoplePrototype3.Name = "测试";  //修改peoplePrototype3,不影响peoplePrototype4的值,证明他们不是同一个引用对象
            Console.WriteLine("{0},{1}", peoplePrototype3.Name, peoplePrototype3.Id);
            Console.WriteLine("{0},{1}", peoplePrototype4.Name, peoplePrototype4.Id);


            Console.WriteLine("---------------------------------------");
            Console.WriteLine("浅克隆");
            PeoplePrototype peoplePrototype5 = PeoplePrototype.CreateInstance();
            PeoplePrototype peoplePrototype6 = PeoplePrototype.CreateInstance();
            peoplePrototype5.Dept.Name = "测试";  //修改peoplePrototype5的Dept.Name,影响peoplePrototype6的值,证明Dept同一个引用对象
            peoplePrototype5.Dept.Id = 55;  //修改peoplePrototype5的Dept.Id ,影响peoplePrototype6的值,证明Dept同一个引用对象
            Console.WriteLine("{0},{1}", peoplePrototype5.Dept.Name, peoplePrototype5.Dept.Id);
            Console.WriteLine("{0},{1}", peoplePrototype6.Dept.Name, peoplePrototype6.Dept.Id);

            Console.WriteLine("---------------------------------------");
            Console.WriteLine("深克隆");
            PeoplePrototype peoplePrototype7 = PeoplePrototype.CreateInstanceDeep();
            PeoplePrototype peoplePrototype8 = PeoplePrototype.CreateInstanceDeep();
            peoplePrototype7.Dept.Name = "测试";  //修改peoplePrototype5的Dept.Name,影响peoplePrototype6的值,证明Dept同一个引用对象
            peoplePrototype7.Dept.Id = 55;  //修改peoplePrototype5的Dept.Id ,影响peoplePrototype6的值,证明Dept同一个引用对象
            Console.WriteLine("{0},{1}", peoplePrototype7.Dept.Name, peoplePrototype7.Dept.Id);
            Console.WriteLine("{0},{1}", peoplePrototype8.Dept.Name, peoplePrototype8.Dept.Id);

            Console.WriteLine("---------------------------------------");
            Console.WriteLine("深克隆");
            PeoplePrototype peoplePrototype9 = PeoplePrototype.CreateInstanceSerializa();
            PeoplePrototype peoplePrototype10 = PeoplePrototype.CreateInstanceSerializa();
            peoplePrototype9.Dept.Name = "测试";  //修改peoplePrototype5的Dept.Name,影响peoplePrototype6的值,证明Dept同一个引用对象
            peoplePrototype9.Dept.Id = 55;  //修改peoplePrototype5的Dept.Id ,影响peoplePrototype6的值,证明Dept同一个引用对象
            Console.WriteLine("{0},{1}", peoplePrototype9.Dept.Name, peoplePrototype9.Dept.Id);
            Console.WriteLine("{0},{1}", peoplePrototype10.Dept.Name, peoplePrototype10.Dept.Id);

            Console.WriteLine();
        }
    }
}

执行结果如下

二,总结下

1,什么是浅克隆和深克隆,看代码运行结果解释

1》浅克隆没有克隆我们对象中的引用类型,如我们的实体PeoplePrototype中的Dept,如下图

 

可是这个时候我们就会疑惑了,string也是引用类型,为什么也会被克隆呢?

2》我们理解下string的运行机制,string是特殊的引用类型,字符串的值是一个定存的,重新改值会实例化一个新的对象,所以在遍历中不建议使用string,因为损耗性能

string ss = "33";
ss = "44"; //此时 ss = "33";和ss = "44"; 的存储地址不一样的

3》那Dept引用类型在克隆中的是怎样的逻辑呢?

Dept引用类型在克隆中是他们没有初始化,但是都是指向一个内存空间,所以我们将浅克隆的dept属性更改是会同时更改其他克隆出来的对象的dept属性,如下图

 4》浅克隆的值类型不受影响

5》那什么是深克隆呢?如下图结果

深克隆的引用类型互不影响,实现的方法有两种

1,在复制中操作引用类型初始化

        /// <summary>
        /// 深克隆一个对象
        /// </summary>
        /// <returns></returns>
        public static PeoplePrototype CreateInstanceDeep()
        {
            PeoplePrototype peoplePrototype = (PeoplePrototype)_peoplePrototype.MemberwiseClone();
            //深度克隆,重新实例化一个对象和开辟一个内存,所以克隆的结果指向的地址每次都不一样
            //可是这样操作麻烦,我们优化一下
            peoplePrototype.Dept = new Dept()
            {
                Id = 11,
                Name = "技术部"
            };
            return peoplePrototype;
        }

2,使用序列化和反序列化创建对象(帮助类SerializaUtil)

        /// <summary>
        /// 深克隆一个对象
        /// </summary>
        /// <returns></returns>
        public static PeoplePrototype CreateInstanceSerializa()
        {
            //通过序列化生成实体
            return SerializaUtil.DeepClone<PeoplePrototype>(_peoplePrototype);
        }

三,原型模式:“某些结构复杂的对象”的创建工作;由于需求的变化,这些对象经常面临着剧烈的变化,但是他们却拥有比较稳定一致的接口。

1》复杂对象的指的是当创建该对象消耗资源过多

2》面临的剧烈变化,比如发邮件,我们需要发N条,但是这N条邮件的对象每个人发送的信息也不同,所以导致实力出的的对象的也不完全一样

3》稳定的接口值得是都是通过同一个方法将该对象发送出去,既是调用方法一般不存在变化,而是对象改变

四,在什么情况下该选择原型模式?

1》是类初始化需要消化非常多的资源,这个资源包括数据、硬件资源等,如上结果所示,我们在初始化时消耗过多资源,这是就体现出原型模式的优势

2》是通过 new 产生一个对象需要非常繁琐的数据准备或访问权限,则可以使用原型模式

五,原型模式的浅度克隆和深度克隆是什么意思?

1》浅度复制(Shallow Copy):将原来对象中的所有字段逐个复制到一个新对象,如果字段是值类型,则简单地复制一个副本到新对象,改变新对象的值类型字段不会影响原对象;如果字段是引用类型,则复制的是引用,改变目标对象中引用类型字段的值将会影响原对象。

2》深度复制(Deep Copy):与浅复制不同之处在于对引用类型的处理,深复制将新对象中引用类型字段指向复制过的新对象,改变新对象中引用的任何对象,不会影响到原来的对象中对应字段的内容。

以上是关于C#设计模式:原型模式(Prototype Pattern)的主要内容,如果未能解决你的问题,请参考以下文章

c# 24种设计模式5原型模式(Prototype)

C#设计模式——原型模式(Prototype Pattern)

设计模式——10.原型模式

C#设计模式之五原型模式(Prototype Pattern)创建型

设计模式:原型模式(Prototype)

设计模式---对象创建模式之原型模式(prototype)