C# 中ref 与 out 总结

　　参数的传递一般分为两种：一种是“值传递”即：传递实参的拷贝，既然是拷贝那么在函数中对这个形参所作的任何动作都不会反映到原来的实参中。另外一种是“引用传递”即：传递实参的地址（形参和实参指向同一块内存地址），那么在函数中对形参所作的任何改变都要反映到原来的实参中。

　　在C#中实现“引用传递”的两种方式为：ref 和 out。当然这两种方式也有他们的不同，下面将逐步讲解他们的不同之处。

1. 使用ref关键字进行“引用传递”时，传入的实参必须先被初始化，这就像C和C++中的指针一样，一定要先给它赋值（让它指向一个指定的内存位置），要不然它不一定会指向内存的哪里，这样很危险，不允许。而使用out关键字进行“引用传递”时，传入的实参不必先初始化。如下面的例子所示：

   using System;
   using System.Collections.Generic;
   using System.Linq;
   using System.Text;
   
   namespace RefAndOut
   {
      class RefAndOutTesting
      {
          static void Main(string[] args)
          {
              int x;
              int y;
              OutTest(out x, out y);
              Console.WriteLine(string.Format("x = {0}, y = {1}", x, y));
   
              int a = 100;
              int b = 200;
              RefTest(ref a, ref b);
              Console.WriteLine(string.Format("a = {0}, y = {1}", a, b));
          }
          //out参数在使用前不必初始化
          public static void OutTest(out int first, out int second)
          {
              first = 1;
              second = 2;
          }
          //ref参数在使用前必须初始化
          public static void RefTest(ref int first, ref int second)
          {
              first = 1111;
              second = 2222;
          }
      }
   }

2. 虽然使用out关键字进行“引用传递”时，传入的实参不必先初始化，但是在函数中一定要先对参数进行初始化，之后再使用。因为：在使用out参数的时候，程序首先将out的实参（形参）置空，（因此实质上实参先初始化了对此函数也没有用）然后再对参数进行相应的操作；由于置空了，所以在离开该函数之前必须完成参数的初始化（即使你不对参数做任何操作），要不然该参数的指针又不知道该指向何处了。假如变化一下上面的OutTest函数：

           public static void OutTest(out int first, out int second)
           {
               first = second;
               //first = 1;
               //second = 2;
            }

   便会提示你：Use of unassigned out parmeter 'second'。即使你先初始化实参再去调用也会出现同样的错误（原因就是out先对参数进行清空操作）

   using System;
    using System.Collections.Generic;
    using System.Linq;
    using System.Text;
   
    namespace OutAndRef
   {
       class Program
       {
           static void Main(string[] args)
           {
               //out变量在使用之前不必进行显示的赋值
               int x = 1111;
               int y = 2222;
               OutTest(out x, out y);
               Console.WriteLine("x = {0}, y = {1}", x, y);
           }
   
           public static void OutTest(out int first, out int second)
           {
               //离开这个函数前，必须对first和second赋值，否则会报错。 
               first = second;
               //上面这行会报错，因为使用了out后，first和second都清空了，需要重新赋值，即使调用函数前赋过值也不行 
               first = 1;
               second = 2;
           }
       }
   }
   

3. 因此上面的两点可以总结为：ref有出有进，out有出没进。
4. 使用ref和out进行“引用传递”，在定义方法和调用方法时，都要在参数前加ref和out关键字，以满足匹配。
5. 由于属性是方法，不是变量；而指针是变量。所以属性都不可以作为ref和out参数传递。如果在上面的RefAndOutTesting类中声明两个属性，传递给RefTest和OutTest方法中，则会出错！

    1 using System;
   using System.Collections.Generic;
   using System.Linq;
   using System.Text;
   
   namespace RefAndOut
   {
       class RefAndOutTesting
       {
           //属性(是方法，不是变量)所以不可以作为ref和out参数
           public static int firstNumber
           {
               get;
               set;
           }
           public static int secondNumber
           {
               get;
               set;
           }
   
           //字段可以作为ref和out参数
           public static int myNumber;
           public static int yourNumber;
   
           static void Main(string[] args)
           {
               //正确
               OutTest(out myNumber, out yourNumber);
               Console.WriteLine(  "myNumber = {0}, yourNumber = {1}", myNumber, yourNumber);
               RefTest(ref myNumber, ref yourNumber);
               Console.WriteLine( "myNumber = {0}, yourNumber = {1}", myNumber, yourNumber);
   
               //错误
               OutTest(out firstNumber, out secondNumber);
               Console.WriteLine("firstNumber = {0}, secondNumber = {1}", firstNumber, secondNumber);
               RefTest(ref firstNumber, ref secondNumber);
               Console.WriteLine("firstNumber = {0}, secondNumber = {1}", firstNumber, secondNumber);
           }
       }
   }