浅拷贝：给对象拷贝一份新的对象。定义——只对值类型（或 string）类型分配新的内存地址。
深拷贝：给对象拷贝一份全新的对象。定义——对值类型分配新的内存地址，引用类型、以及引用类型的内部字段分配的新的地址。
觉得这样有点绕口了。
我是这么定义的：浅拷贝，换汤不换药。
问题起源：
只是，那时的在校生，又有几个能对书本上那写的尽量让鬼都看不懂知识能清晰的理解呢。
工作后虽然也有用到Clone相关的内容，不过也仅是应用，基础的概念还是没去仔细的理解，以于后来DataTable内部那不深不浅的架构拷贝都混和这些概念混在一起了。
曾经的以为：
当我答出这样错误的答案时，对方没有纠正，反而似乎对我的答案还挺满意的。
唉，面试管自己不懂还问我这问题，还让我一直以为到现在都是这个样。
同事的质问：
网上乱七杂八的答案，让我得一个模糊的似乎正确的答案：浅拷贝不拷贝内部类的对象
引申出的错乱：
最后，为了解惑，还是用示例来说话了：
{
public int intValue = 1;
public string strValue = "1";
public PersonEnum pEnum = PersonEnum.EnumA;
public PersonStruct pStruct = new PersonStruct();
public Person pClass = new Person("1");
public string[] pArray = new string[] { "1" };
#region ICloneable 成员
public DemoClass()
{
pStruct.StructValue = 1;
}
public object Clone()
{
return this.MemberwiseClone();
}
#endregion
}
class Person
{
public string Name;
public Person(string name)
{
Name = name;
}
}
public enum PersonEnum
{
EnumA=1,
EnumB=2
}
public struct PersonStruct
{
public int StructValue;
}
说明：
int
string
string[]
enum
struct
class
然后接下来会产生实例A和克隆实例B。
接着改变B的值，看A的值会不会被改变。
接下我们看main方法
{
Demo();
}
public static void Demo()
{
DemoClass A = new DemoClass();
DemoClass B = (DemoClass)A.Clone();
B.intValue = 2;
Write(string.Format(" int->[A:{0}] [B:{1}]", A.intValue, B.intValue));
B.strValue = "2";
Write(string.Format(" string->[A:{0}] [B:{1}]", A.strValue, B.strValue));
B.pEnum = PersonEnum.EnumB;
Write(string.Format(" Enum->[A:{0}] [B:{1}]", (int)A.pEnum, (int)B.pEnum));
B.pStruct.StructValue = 2;
Write(string.Format(" struct->[A:{0}] [B:{1}]", A.pStruct.StructValue, B.pStruct.StructValue));
B.pIntArray[0] = 2;
Write(string.Format(" intArray->[A:{0}] [B:{1}]", A.pIntArray[0], B.pIntArray[0]));
B.pStringArray[0] = "2";
Write(string.Format("stringArray->[A:{0}] [B:{1}]", A.pStringArray[0], B.pStringArray[0]));
B.pClass.Name = "2";
Write(string.Format(" Class->[A:{0}] [B:{1}]", A.pClass.Name, B.pClass.Name));
System.Console.Read();
}
static void Write(string msg)
{
System.Console.WriteLine(msg);
}
说明：
打印结果如下：
从最后输出的结果我们得知：
最后，我试着百度寻找浅拷贝最原生的定义，浅搜了一下找不到，那这个定义，就留给读者解答一下了。
接着，我顺手比较了一下浅拷贝和深拷贝的性能测试：
先在DemoClass加入一个函数：
{
return new DemoClass();
}
接着我们写示例代码比较：
{
DemoClass baseClass = new DemoClass();
DateTime start
= DateTime.Now;for (int i = 0; i < 1000000; i++)
{
DemoClass newClass = (DemoClass)baseClass.Clone();
}
TimeSpan ts = DateTime.Now - start;
System.Console.WriteLine("浅拷贝：" + ts.Ticks);
DateTime start2
= DateTime.Now;for (int j = 0; j < 1000000; j++)
{
DemoClass newClass = (DemoClass)baseClass.CloneNew();
}
TimeSpan ts2 = DateTime.Now - start2;
System.Console.WriteLine("深拷贝：" + ts2.Ticks);
System.Console.Read();
}
最后得出结果：
附言：