一:概念
内存:用来存储程序信息的介质。
指针:指向一块内存区域,通过它可以访问该内存区域中储存的程序信息。(C#也是有指针的)
值类型:struct(整形、浮点型、decimal的内部实现都是struct)、enum、可空类型
引用类型:class、interface、delegate、数组、object、string。
二:深拷贝和浅拷贝的认识:
举个例子:
Myclass a=new Myclass();
Myclass b=a;
首先,深、浅拷贝与上面的语句并没有任何关系,要区分深、浅拷贝,关键要看“=”是如何重载的。
深拷贝:不管是值类型还是引用类型,都在内存中新建一块储存块,该储存块的内容(由b指向)与被拷贝的储存块(由a指向)的内容相同,并新建一个指针(b)指向该新建的储存块。所以对b的操作是不会影响a。
浅拷贝:对于值类型,拷贝一份值的副本;对于引用类型,拷贝一份指针的副本(该副本仍然指向原指针指向的内存块,即a、b指向同一块内存)。对b的值类型进行操作,不会影响a;对b的引用类型进行操作,会影响a。
对于浅拷贝,有一种奇怪的现象,即:若a中包含一个string类型的字段,对a进行浅拷贝,赋值给b,在b中改变这个string类型的字段,a中string类型字段不受影响。string类型明明是引用类型,按照上面的理解,修改b中的string字段,a中的string字段也该作出相应的改变,这是为什么呢?
我们不妨看看string的定义,会发现string被readonly关键字修饰了,即改变string的值时,就会重新分配内存空间。有兴趣的话可以了解一下“C#字符串不可变性”。
三:string
String是引用类型。究其原因,是因为string对象是不可变的,包括长度和其中任何字符都是不可以改变的。
关于不可变数据类型,请参考:https://www.cnblogs.com/mushroom/p/4373951.html
string 对象称为不可变的(只读),因为一旦创建了该对象,就不能修改该对象的值。有的时候看来似乎修改了,实际是string经过了特殊处理,每次改变值时都会建立一个新的string对象,变量会指向这个新的对象,而原来的还是指向原来的对象,所以不会改变。这也是string效率低下的原因。如果经常改变string的值则应该使用StringBuilder而不使用string。
在例子中str1=”ab”,这时在内存中就将“ab”存下来,如果再创建字符串对象,其值也等于“ab”,str2=”ab”,则并非再重新分配内存空间,而是将之前保存的“ab”的地址赋给str2的引用,这就能印证例子2中的结果。而当str1=”abc”其值发生改变时,这时检查内存,发现不存在此字符串,则重新分配内存空间,存储“abc”,并将其地址赋给str1,而str2依然指向“ab”的地址。可以印证例子中的结果。
String是引用类型,只是编译器对其做了特殊处理。
四:实例(原型模式)
1)浅拷贝:
声明一个将要被克隆的类 clsShallow 和它将要包含的引用类型成员clsRefSalary类,clsShallow包含 CompanyName(静态字符串)、Age(值类型)、EmployeeName(字符串)、EmpSalary(引用类型)四个成员。
public class clsShallow { public static string CompanyName = "My Company"; public int Age; public string EmployeeName; public clsRefSalary EmpSalary; public clsShallow CreateShallowCopy(clsShallow inputcls) { return (clsShallow)inputcls.MemberwiseClone(); } } public class clsRefSalary { public clsRefSalary(int _salary) { Salary = _salary; } public int Salary; }
再看如何调用:
static void Main() { // Creates an instance of clsShallow and assign values to its fields. clsShallow objshallow = new clsShallow(); objshallow.Age = 25; objshallow.EmployeeName = "Ahmed Eid"; // add the ref value to the objshallow clsRefSalary clsref = new clsRefSalary(1000); objshallow.EmpSalary = clsref; // Performs a shallow copy of m1 and assign it to m2. clsShallow m2 = objshallow.CreateShallowCopy(objshallow); m2.Age = 20; m2.EmployeeName = "jay"; // then modify the clsref salary value to be 2000 clsref.Salary = 2000; // so the m1 object salary value become 2000 Console.WriteLine(m2 == objshallow); Console.WriteLine(objshallow.EmpSalary.Salary); Console.WriteLine(m2.EmpSalary.Salary); Console.WriteLine(objshallow.Age); Console.WriteLine(m2.Age); Console.WriteLine(objshallow.EmployeeName); Console.WriteLine(m2.EmployeeName); }
最后看运行结果:
根据结果我们进行分析:
浅拷贝:
1、浅拷贝创建了类的一个新实例。(由对象的同一性得知:如果两个引用如m2 、 objshallow指向同一个对象的实例,则(m2 == objshallow)为true,而结果显示为 false,所以m2 和objshallow分别指向不同的实例,而objshallow引用所指向的实例是新创建的。
2、对于对象(clsShallow)中的引用类型成员(clsRefSalary),引用被复制,但引用的实例没有被复制,即新创建实例中的引用成员(m2.EmpSalary)等于原实例的引用成员(objshallow.EmpSalary)。 因为改变 clsref.Salary 等于2000后,objshallow.EmpSalary 和m2.EmpSalary的Salary都改变了。其实可通过Console.WriteLine(objshallow.EmpSalary == m2.EmpSalary) 输出为true来解释。
3、值类型字段逐位复制到新实例。即改变m2.Age不影响objshallow.Age值。有人要问,string 为引用类型,为什么改变m2.EmployeeName = "jay"而objshallow.EmployeeName = "Ahmed Eid"没变呢?这是因为:字符串具有恒等性,一个字符串一旦被创建,我们就不能再将其变长、变短、或者改变其中的任何字符。
2) 深拷贝:
修改代码如下:
static void Main() { clsDeep objdeep = new clsDeep(); objdeep.Age = 25; objdeep.EmployeeName = "Ahmed Eid"; // add the ref value clsRefSalary clsref = new clsRefSalary(1000); objdeep.EmpSalary = clsref; // Performs a shallow copy of m1 and assign it to m2. clsDeep m2 = objdeep.CreateDeepCopy(objdeep); // then modify the clsref salary value to be 2000 clsref.Salary = 2000; // so the m1 object salary value become 2000 int EmpSalary = objdeep.EmpSalary.Salary; m2.Age = 20; m2.EmployeeName = "jay"; // then modify the clsref salary value to be 2000 clsref.Salary = 2000; // so the m1 object salary value become 2000 Console.WriteLine(m2 == objdeep); Console.WriteLine(objdeep.EmpSalary.Salary); Console.WriteLine(m2.EmpSalary.Salary); Console.WriteLine(objdeep.EmpSalary == m2.EmpSalary); Console.WriteLine(objdeep.Age); Console.WriteLine(m2.Age); Console.WriteLine(objdeep.EmployeeName); Console.WriteLine(m2.EmployeeName); } [Serializable] // serialize the classes in case of deep copy public class clsDeep { public static string CompanyName = "My Company"; public int Age; public string EmployeeName; public clsRefSalary EmpSalary; public clsDeep CreateDeepCopy(clsDeep inputcls) { MemoryStream m = new MemoryStream(); BinaryFormatter b = new BinaryFormatter(); b.Serialize(m, inputcls); m.Position = 0; return (clsDeep)b.Deserialize(m); } } [Serializable] public class clsRefSalary { public clsRefSalary(int _salary) { Salary = _salary; } public int Salary; }
记得加命名空间
using System.IO;
using System.Runtime.Serialization.Formatters.Binary;
查看结果:
深拷贝:
1、深拷贝创建了类的一个新实例
2、对于实例中的引用类型成员,创建引用类型成员对象的新副本。 ( objshallow.EmpSalary != m2.EmpSalary)
3、值类型字段逐位复制到新实例。
其实,浅拷贝和深拷贝的本质区别是实例中的引用类型成员如何拷贝, 浅拷贝复制引用,深拷贝创建新实例。
注:无论浅、深拷贝,静态成员都不会复制,因为静态成员属于类成员。
3)深复制方法
/// <summary> /// Perform a deep Copy of the object. /// </summary> /// <typeparam name="T">The type of object being copied.</typeparam> /// <param name="source">The object instance to copy.</param> /// <returns>The copied object.</returns> public static T Clone<T>(this T source) { if (!typeof(T).IsSerializable) { throw new ArgumentException("The type must be serializable.", "source"); } // Don't serialize a null object, simply return the default for that object if (Object.ReferenceEquals(source, null)) { return default(T); } IFormatter formatter = new BinaryFormatter(); Stream stream = new MemoryStream(); using (stream) { formatter.Serialize(stream, source); stream.Seek(0, SeekOrigin.Begin); return (T)formatter.Deserialize(stream); } }