new与clone的比较

　　简单来说，new仅申请开辟内存，而后调用类的构造函数来初始化对象。clone也是先开辟内存，但不会调用构造函数来初始化，而是将源对象值复制给目标对象。若是深拷贝，则还需要一同拷贝源对象引用类型指向的内存，浅拷贝则只是拷贝引用本身。

　　如下小示例：

    /// <summary>
    /// 围棋子（棋盘共19×19=361个交叉点，对象可能有三百多个）
    /// </summary>
    [Serializable]
    public class PiecesGo : ICloneable
    {
        /// <summary>
        /// 棋子颜色（Black、White）
        /// </summary>
        public string Color { get; set; }

        /// <summary>
        /// 棋子位置（X）
        /// </summary>
        public int PointX { get; set; }

        /// <summary>
        /// 棋子位置（Y）
        /// </summary>
        public int PointY { get; set; }

        /// <summary>
        /// 构造棋子
        /// </summary>
        /// <param name="color">颜色：Black、White</param>
        /// <param name="x">X坐标</param>
        /// <param name="y">Y坐标</param>
        public PiecesGo(string color, int x, int y)
        {
            //Guid.NewGuid().ToString();
            Color = color;
            PointX = x;
            PointY = y;
        }

        /// <summary>
        /// 创建当前object的浅表副本
        /// 返回Object
        /// </summary>
        /// <returns>object</returns>
        public object Clone()
        {
            return base.MemberwiseClone();
        }

        /// <summary>
        /// 浅拷贝
        /// 返回PiecesGo
        /// </summary>
        /// <returns>PiecesGo</returns>
        public PiecesGo ShallowClone()
        {
            return this.Clone() as PiecesGo;
        }

        /// <summary>
        /// 深拷贝
        /// 返回PiecesGo
        /// </summary>
        /// <returns></returns>
        public PiecesGo DeepClone()
        {
            using (Stream objectStream = new MemoryStream())
            {
                IFormatter formatter = new BinaryFormatter();
                formatter.Serialize(objectStream, this);
                objectStream.Seek(0, SeekOrigin.Begin);
                return formatter.Deserialize(objectStream) as PiecesGo;
            }
        }
    }

    /// <summary>
    /// 1.new与clone的性能差别主要在构造函数和对象包含的引用（浅拷贝可忽略）；
    /// 2.若构造函数功能简单，则new耗时更少；
    /// 3.若构造函数比较耗时，则clone（浅）耗时更少（克隆不用走构造）；
    /// 4.无论两者情况如何，深拷贝耗时都是最多的。
    /// </summary>
    class Program
    {
        static void Main(string[] args)
        {
            int cnt = 100000;

            //New
            DateTime dt1 = DateTime.Now;
            for (int i = 0; i < cnt; i++)
            {
                PiecesGo go = new PiecesGo("black", i, i);
            }
            DateTime dt2 = DateTime.Now;
            Console.WriteLine("New:" + (dt2 - dt1).TotalMilliseconds);

            //ShallowClone
            DateTime dt3 = DateTime.Now;
            PiecesGo pieces = new PiecesGo("black", 0, 0);
            for (int i = 0; i < cnt; i++)
            {
                PiecesGo go = pieces.ShallowClone();
                go.Color = "white";
                go.PointX = i;
                go.PointY = i;
            }
            DateTime dt4 = DateTime.Now;
            Console.WriteLine("ShallowClone:" + (dt4 - dt3).TotalMilliseconds);

            //DeepClone
            DateTime dt5 = DateTime.Now;
            PiecesGo pieces2 = new PiecesGo("black", 0, 0);
            for (int i = 0; i < cnt; i++)
            {
                PiecesGo go = pieces2.DeepClone();
                go.Color = "black";
                go.PointX = i;
                go.PointY = i;
            }
            DateTime dt6 = DateTime.Now;
            Console.WriteLine("DeepClone:" + (dt6 - dt5).TotalMilliseconds);

            //NewGuidToString
            DateTime dt7 = DateTime.Now;
            for (int i = 0; i < cnt; i++)
            {
                Guid.NewGuid().ToString();
            }
            DateTime dt8 = DateTime.Now;
            Console.WriteLine("NewGuidToString:" + (dt8 - dt7).TotalMilliseconds);

            //NewGuid
            DateTime dt9 = DateTime.Now;
            for (int i = 0; i < cnt; i++)
            {
                Guid.NewGuid();
            }
            DateTime dt10 = DateTime.Now;
            Console.WriteLine("NewGuid:" + (dt10 - dt9).TotalMilliseconds);

            Console.Read();
        }
    }

　　1.new与clone的性能差别主要在构造函数和对象包含的引用（浅拷贝可忽略）；
　　2.若构造函数功能简单，则new耗时更少；
　　3.若构造函数比较耗时，则clone（浅）耗时更少（克隆不用走构造）；
　　4.无论两者情况如何，大部分情况下深拷贝耗时都是最多的。