Unity3D 原型模式

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

文章目录

Unity3D 原型模式
前言
一、原型模式是什么？
二、实现方式（抽象类）
三、ICloneable接口实现
四、C#四种深拷贝方法（转）
五、优点与缺点
- 1.优点
- 1.缺点
六、适用场景
附

前言

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

一、原型模式是什么？

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

将一个或多个对象当做原型，通过统一的生成器克隆出很多类似原型的对象。将对象塑造成你想要的状态。你可以直接克隆系统内建的基本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();
}

2.具体原型类

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

public class ConcreteProtypel : Prototype
{
    public ConcreteProtypel(int id) : base(id) { }
    public override Prototype Clone()
    {
        return (Prototype)this.MemberwiseClone();
    }
}

3.客户端代码

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

using UnityEngine;
public class PrototypeMain : MonoBehaviour
{
    void Start()
    {
        ConcreteProtypel p1 = new ConcreteProtypel(1);
        ConcreteProtypel p2 = new ConcreteProtypel(2);
    }
}

三、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;
        }