【设计模式】Unity3D 原型模式、浅复制和深复制_unity 物体monobehaviour 参数深层拷贝

Unity3D 原型模式

提示：个人学习总结，如有错误，敬请指正。

---

---

前言

---

提示：以下是本篇文章正文内容，下面案例可供参考

一、原型模式是什么？

原型模式其实就是从一个对象再创建另外一个可定制的对象，而且不需要知道任何创建的细节。

将一个或多个对象当做原型，通过统一的生成器克隆出很多类似原型的对象。将对象塑造成你想要的状态。你可以直接克隆系统内建的基本Object，然后向其中添加字段和方法。比如可以通过配置表更改克隆体属性，制造出很多具有自身个性的对象。

游戏中，代码只是驱动游戏的“引擎”，游戏是完全由数据定义的。
在《游戏设计模式》中提供一种方法：使用原型和委托来重用数据。
在json或者其他，在字段中添加prototype字段，相同的角色，如术士和弓箭手将grunt作为原型，我们就不需要在它们中重复血量，防御和弱点。为数据模型增加的逻辑超级简单——基本的单一委托——但已经成功摆脱了一堆冗余。

二、实现方式（抽象类）

1.原型类

抽象类的关键就是有这个Clone方法：

public abstract class Prototype 
{
    private int id;
    public int Id { get { return id; } }
    public Prototype(int id)
    {
        this.id = id;
    }
    //抽象类的关键就是有这个Clone方法
    public abstract Prototype Clone();
}
1
2
3
4
5
6
7
8
9
10
11

2.具体原型类

创建当前对象的浅表副本。方法是：创建一个对象，然后将当前对象的非静态字段复制到该新对象。

public class ConcreteProtypel : Prototype
{
    public ConcreteProtypel(int id) : base(id) { }
    public override Prototype Clone()
    {
        return (Prototype)this.MemberwiseClone();
    }
}
1
2
3
4
5
6
7
8

3.客户端代码

克隆类ConcreteProtypel 的对象就能得到新的实例

using UnityEngine;
public class PrototypeMain : MonoBehaviour
{
    void Start()
    {
        ConcreteProtypel p1 = new ConcreteProtypel(1);
        ConcreteProtypel p2 = new ConcreteProtypel(2);
    }
}
1
2
3
4
5
6
7
8
9

---

三、ICloneable接口实现

不重复造轮子了，链接里有
ICloneable接口实现

---

四、C#四种深拷贝方法（转）

//四种深拷贝方法
        public static T DeepCopyByReflect<T>(T obj)
        {
            //如果是字符串或值类型则直接返回
            if (obj is string || obj.GetType().IsValueType) return obj;

            object retval = Activator.CreateInstance(obj.GetType());
            FieldInfo[] fields = obj.GetType().GetFields(BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.Static);
            foreach (FieldInfo field in fields)
            {
                try { field.SetValue(retval, DeepCopyByReflect(field.GetValue(obj))); }
                catch { }
            }
            return (T)retval;
        }

        public static T DeepCopyByXml<T>(T obj)
        {
            object retval;
            using (MemoryStream ms = new MemoryStream())
            {
                XmlSerializer xml = new XmlSerializer(typeof(T));
                xml.Serialize(ms, obj);
                ms.Seek(0, SeekOrigin.Begin);
                retval = xml.Deserialize(ms);
                ms.Close();
            }
            return (T)retval;
        }

        public static T DeepCopyByBin<T>(T obj)
        {
            object retval;
            using (MemoryStream ms = new MemoryStream())
            {
                BinaryFormatter bf = new BinaryFormatter();
                //序列化成流
                bf.Serialize(ms, obj);
                ms.Seek(0, SeekOrigin.Begin);
                //反序列化成对象
                retval = bf.Deserialize(ms);
                ms.Close();
            }
            return (T)retval;
        }

        //需要silverlight支持
        public static T DeepCopy<T>(T obj)
        {
            object retval;
            using (MemoryStream ms = new MemoryStream())
            {
                DataContractSerializer ser = new DataContractSerializer(typeof(T));
                ser.WriteObject(ms, obj);
                ms.Seek(0, SeekOrigin.Begin);
                retval = ser.ReadObject(ms);
                ms.Close();
            }
            return (T)retval;
        }
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60

---

五、优点与缺点

1.优点

1. 使用原型模式可以简化对象的创建过程，通过复制一个已有实例可以提高新实例的创建效率。
2. 扩展性较好，由于在原型模式中提供了抽象原型类，在客户端可以针对抽象原型类进行编程，而将具体原型类写在配置文件中，增加或减少产品类对原有系统都没有任何影响。
3. 原型模式提供了简化的创建结构
4. 可以使用深克隆的方式保存对象的状态，使用原型模式将对象复制一份并将其状态保存起来，以便在需要的时候使用（如恢复到某一历史状态），可辅助实现撤销操作。

1.缺点

1. 修改类时违背了“开闭原则”。
2. 多个深克隆会使代码阅读性和实现较为麻烦

---

六、适用场景

1. 创建新对象成本较大

---

附

1.大话设计模式