.net中String是引用类型还是值类型 以及 C#深层拷贝浅层拷贝

http://www.cnblogs.com/yank/archive/2011/10/24/2204145.html

http://www.cnblogs.com/zwq194/archive/2012/08/06/2625403.html

 

关于String为值类型还是引用类型的讨论一直没有平息，最近一直在研究性能方面的问题，今天再次将此问题进行一次明确。希望能给大家带来点帮助。 如果有错误请指出。

来看下面例子：

            //值类型
            int a = 1;
            int b = a;
            a = 2;
            Console.WriteLine("a is {0},b is {1}", a, b);

            //字符串
            string str1 = "ab";
            string str2 = str1;
            str1 = "abc";
            Console.WriteLine("str1 is {0},str2 is {1}", str1, str2);
            Console.Read();    

根据上面的例子：你觉得输出结果应该是什么？

 

输出结果：

            //结果：
            //a is 2,b is 1
            //str1 is abc,str2 is ab

str2依然是ab,并没有随str1的改变而改变。

如果string是引用类型，按理Str1和Str指针都指向同一内存地址，如果Str的内容发生改变，Str1应该也会相应变化。

此例子，看着string更像是值类型。 

但是MSDN却说String是引用类型，

引用类型包括：  String

所有数组，即使其元素是值类型

类类型，如 Form

委托

可参考：http://msdn.microsoft.com/zh-cn/library/t63sy5hs(VS.80).aspx

查看具体引用是否相同

如果Net能够查看内存地址就容易了，但不允许，只能通过间接方法来实现，看下面：

        static void TestRefAddress()
        {
            String str1 = "abc";
            String str2 = "abc";
            int a = 1;
            int b = 1;
            StringBuilder strb1 = new StringBuilder("abc");
            StringBuilder strb2 = new StringBuilder("abc");
            Console.WriteLine("Reference equal for string: " + Object.ReferenceEquals(str1, str2)); //结果true
            Console.WriteLine("Reference equal for int: " + Object.ReferenceEquals(a, b)); //结果false
            Console.WriteLine("Reference equal for StringBuilder: " + Object.ReferenceEquals(strb1, strb2)); //结果false
            Console.WriteLine("Value equal for string: " + str1.Equals(str2)); //结果true，类似于值类型
            Console.Read();
        }

结果为何出现如此情况，分析如下：

    Console.WriteLine("Reference equal for string: " + Object.ReferenceEquals(str1, str2)); //结果true，不同对象，但引用地址相同
    Console.WriteLine("Reference equal for int: " + Object.ReferenceEquals(a, b)); //结果false,值类型装箱操作造成
    Console.WriteLine("Reference equal for StringBuilder: " + Object.ReferenceEquals(strb1, strb2)); //结果false，不同对象，引用地址不同
    Console.WriteLine("Value equal for string: " + str1.Equals(str2)); //结果true，类似于值类型

由第一条结果，可以判定不同的String的，相同的值，其引用地址相同，再由第四条结果，str1.Equals(str2),两者结合，可得出结论，两个String，如果赋值为同一个值，在内存中只有一个字符串存在，两个引用的地址相同。由此引出String的不变性。

String的不变性

string最为显著的一个特点就是它具有恒定不变性：我们一旦创建了一个string，在managed heap 上为他分配了一块连续的内存空间，我们将不能以任何方式对这个string进行修改使之变长、变短、改变格式。所有对这个string进行各项操作（比如调用ToUpper获得大写格式的string）而返回的string，实际上另一个重新创建的string，其本身并不会产生任何变化。 string   对象称为不可变的（只读），因为一旦创建了该对象，就不能修改该对象的值。有的时候看来似乎修改了，实际是string经过了特殊处理，每次改变值时都会建立一个新的string对象，变量会指向这个新的对象，而原来的还是指向原来的对象，所以不会改变。这也是string效率低下的原因。

String的不变，并非说string不能改变，而是其值不能改变。

在例子中str1="ab",这时在内存中就将“ab”存下来，如果再创建字符串对象，其值也等于“ab”，str2="ab",则并非再重新分配内存空间，而是将之前保存的“ab”的地址赋给str2的引用，这就能印证例子2中的结果。而当str1="abc"其值发生改变时，这时检查内存，发现不存在此字符串，则重新分配内存空间，存储“abc”，并将其地址赋给str1，而str2依然指向“ab”的地址。可以印证例子1中的结果。

 

结论：

String是引用类型，只是编译器对其做了特殊处理。

 

关于讨论：http://social.msdn.microsoft.com/Forums/zh-CN/visualcshartzhchs/thread/ce580186-86d9-45f7-b5ff-20302caf1324

 

 

关于C#深层拷贝浅层拷贝：

　　C#中有两种类型变量，一种是值类型变量，一种是引用类型变量。【浅拷贝就是表面上拷贝了地址;深拷贝就是拷贝了内容 】 对于值类型变量，copy是属于全盘复制； 而对于引用类型变量，一般的copy只是浅copy，相当于只传递一个引用指针一样。 因此对于引用类型变量进行真正copy的时候，也是最费事的。

---

　　浅拷贝 只是复制本身,它包含的对象只是复制引用，其中包含的对象就直接拿来用了,这样产生的问题就是：如果一个被修改了，另一个也跟着变。是这样的，但是除了string类型外，string类型，本来属于引用类型，因此在进行复制的时候，采用的是浅拷贝，但当发生变化的时候，系统会自动生成进行深copy。 对象的字段如果是值类型，那么无论是浅拷贝还是深拷贝都是原样复制。

　　深拷贝 不仅要复制本身，还要复制他所包含对象。对象的字段如果是引用类型，那么浅拷贝是复制引用，深拷贝是复制引用的对象。

 　　拷贝 将对象在内存中重新创建一份

 

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Runtime.Serialization.Formatters.Binary;
using System.IO;

namespace t3_copy
{
    class Program
    {
        static void Main(string[] args)
        {
            Person p1 = new Person() { Name = "sk", Gender = "male", Age = 18 };
            Person p2 = p1;//没有发生拷贝，只是变量指向了一个对象的引用

            //拷贝
            Person p2 = new Person();
            p2.Name = p1.Name;
            p2.Gender = p1.Gender;
            p2.Age = p1.Age;

            //序列化完成拷贝
            Person p2;
            BinaryFormatter bf = new BinaryFormatter();
            byte[] bs = new byte[1000];
            using (MemoryStream ms = new MemoryStream(bs))
            {
                bf.Serialize(ms, p1);
            }
            using (MemoryStream ms = new MemoryStream(bs))
            {
                p2 = bf.Deserialize(ms) as Person;
            }

            //浅拷贝
            p1.MyCar = new Car() { Brand = "audi" };
            Person p2 = new Person();
            p2.Name = p1.Name;
            p2.Gender = p1.Gender;
            p2.Age = p1.Age;
            p2.MyCar = p1.MyCar;//这段代码表示是浅拷贝

            //深拷贝
            p1.MyCar = new Car() { Brand = "audi" };
            Person p2 = new Person();
            p2.Name = p1.Name;
            p2.Age = p1.Age;
            p2.Gender = p1.Gender;
            p2.MyCar = new Car();//这段代码是深拷贝
            p2.MyCar.Brand = p1.MyCar.Brand;

            //通过序列化完成深拷贝（所有的序列化操作都是进行的深拷贝）
            p1.MyCar = new Car() { Brand = "qq" };
            BinaryFormatter bf = new BinaryFormatter();
            byte[] bs = new byte[2000];
            using (MemoryStream ms = new MemoryStream(bs))
            {
                bf.Serialize(ms, p1);
            }
            Person p2;
            using (MemoryStream ms = new MemoryStream(bs))
            {
                p2 = bf.Deserialize(ms) as Person;
            }

            Console.ReadKey();
        }
    }
    [Serializable]
    class Person
    {
        private string name;

        public string Name
        {
            get { return name; }
            set { name = value; }
        }
        private string gender;


        public string Gender
        {
            get { return gender; }
            set { gender = value; }
        }
        private int age;

        public int Age
        {
            get { return age; }
            set { age = value; }
        }

        private Car myCar;

        internal Car MyCar
        {
            get { return myCar; }
            set { myCar = value; }
        }
    }
    [Serializable]
    class Car
    {
        private string brand;


        public string Brand
        {
            get { return brand; }
            set { brand = value; }
        }
    }
}

 

 

 

---