c#引用传递，值传递，引用传递实际上也是属于值传递

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;

namespace ConsoleApplication1
{
    class Program
    {
        static void Main(string[] args)
        {
            int num = 0;
            Person p = new Person("Li");
            A1( p, num);
            //A1(ref p,num);
            Console.WriteLine("{0},{1}", p.name, num);
            Console.Read();
        }
        static void A1( Person p1, int num)
        {
           // p1 = new Person("Wang");
            p1.name = "Wang";
            num = 1;
        }
    }
    public class Person
    {
        public string name;
        public Person(string name)
        {
            this.name = name;
        }
    }
}

P是以引用形式传进来的，num是以值形式传进来的，所以在Al()中对num的修改不会返回到调用Al（）的函数中; 
Al()函数中的p是引用，所以对P的修改会影响p的值，但引用也是复制后传到Al()函数中的，所以对P的副本重新赋值不会影响到p，但对p副本的属性赋值会影响到p，这大概就是引用；
这里的p已经不是原始的P。原来的如果是P1的话，这个就当作P2吧。
P1和P2都是引用，他们指向的对象都是一样的，设为obj吧。
如果用p.name="wang",就直接修改了所指向的对象obj。
而p=new Person("Wang")，则是创建了新的对象obj2，然后把p2指向obj2。

//static void Main(string[] args)
//{
//    int num = 0;
//    Person p = new Person("Li");
//    string name = p.name;
//    A1(p, name, num);
//    Console.WriteLine("{0},{1},{2}", p.name, name, num);//结果应该是 Wang,Li,0...
//}

//static void A1(Person p, string name, int num)
//{
//    name = "Wang";//按值传递的引用类型参数不可更改...
//    p.name = name;//按值传递的引用类型参数其成员可更改...
//    num = 1;//按值传递的值类型参数不可更改...
//}

以前一直误以为引用类型，在作为参数传递时，都是引用传递（类似于值传递中的ref），也就是说，把引用类型的变量作为参数传递给方法，在方法中修改该参数，会改变这个变量的值，

后来通过一些事例发现，上面的认识是片面的，引用类型传递实际上也是属于值传递的，只是引用类型传递的是一个堆地址。

 

先来个例子吧：

1. using System;
2. public class test{
3.     public static void Main(){
4.         testClass a = new testClass();
5.         ChangeToNull(a);
6.         Console.WriteLine(string.Format("a不是null，它的属性值为：{0}", a.field));
7.         
8.         ChangeField(a);
9.         Console.WriteLine(string.Format("a的属性值为：{0}", a.field));
11.         ChangeToNull(ref a);
12.         Console.WriteLine(string.Format("a是不是null：{0}", (a == null)));
13.     }
14.     
15.     static void ChangeToNull(testClass b){
16.         b = null;
17.         if(b == null){
18.             Console.WriteLine("在ChangeToNull方法中，参数已经被修改成null了！");
19.         }
20.     }
21.     
22.     static void ChangeField(testClass b){
23.         b.field = 0;
24.         Console.WriteLine("在ChangeField方法中，参数的成员已经被修改成0了！");
25.     }
26.     
27.     static void ChangeToNull(ref testClass b){
28.         b = null;
29.         if(b == null){
30.             Console.WriteLine("在ChangeToNull使用ref的重载方法中，参数已经被修改成null了！");
31.         }
32.     }
33. }
35. class testClass{
36.     public int field;
37.     public testClass(){
38.         field = 123;
39.     }
40. }

上面的代码，执行后的结果是：

在ChangeToNull方法中，参数已经被修改成null了！
a不是null，它的属性值为：123
在ChangeField方法中，参数的成员已经被修改成0了！
a的属性值为：0
在ChangeToNull使用ref的重载方法中，参数已经被修改成null了！
a是不是null：True

由此可见，引用类型作为参数时：

1、在修改变量本身时，结果类似于值传递，即不会改变传递前的变量的值

2、在修改变量的属性或字段时，才是引用传递，会影响到传递前的变量的值

3、参数使用了ref后，才是真正的引用传递，不管修改变量本身还是修改变量的属性或字段，都会影响到传递前的变量的值

 

究其原因，我们知道，值类型和引用类型，在运行时，它们存放的位置是不同的，值类型是存储在进程的栈上的

而引用类型是存储在进程堆（Heap）上的，在进程的栈上存储了这个引用类型在堆上的地址

而在调用方法时，是把栈上的参数的值复制一份传递给方法，所以值类型作为参数传递时，不会改变原变量值很明显

引用类型传递时，也是一样，把栈上的这个堆地址复制一份传递给方法，

所以在方法里修改这个复制的地址的值，当然不会改变原变量的值，

但是修改这个复制的地址所指向的堆里的内容，那原变量指向的地址的内容当然也跟着改变了。

如果参数加了ref，那传递的就是栈的地址的，此时不管是值类型还是引用类型，都会改变原变量的内容

 

综上所述，我们可以知道，引用类型作为参数传递，不能单纯的说它就是引用传递，如果直接这么认为，在开发中难免会犯错误的，深入的理解一下值类型和引用类型的传递，还是很有必要的。

 

 

详细链接:http://blog.csdn.net/youbl/article/details/3338378

http://topic.csdn.net/u/20090402/14/1127eb2a-3693-4d2c-8705-18c08e216177_3.html