c#关键字，ref和out

ref 关键字使参数按引用传递。其效果是，当控制权传递回调用方法时，在方法中对参数的任何更改都将反映在该变量中。若要使用 ref 参数，则方法定义和调用方法都必须显式使用 ref 关键字。传递到 ref 参数的参数必须最先初始化。这与 out 不同，后者的参数在传递之前不需要显式初始化。这是out与ref的却别所在。
     有点像，c++中的函数传递引用，和传递值。比较经典的程序是交换两个数。

代码 

Code highlighting produced by Actipro CodeHighlighter (freeware)http://www.CodeHighlighter.com/-->using System;
using System.Collections.Generic;

public class MyClass
{
 public static void Main()
 {
 
  /// 通过测试发现，基类型的参数，在没有用ref 的声明后，其值并没有改变，说明此函数中传递的是值。
  /// 但是，当使用ref 参数是发现，其值发生了变化，说明在此函数中传递的是引用。
  int x=100;
  ChangeTheNumber(ref x);
  Console.WriteLine(x.ToString());
  
  
  ///通过测试发现，类的实例作为，参数，即使不用ref 参数，它的属性也发生了变化。那是因为，类的的实例，是一个引用。所以不用再使用ref了。
  /// 这让我想到了，几个月前的项目开发，在不同窗体之间传递参数，但是一直想着做个什么共有方法，然后互相调用。但是，其实很简单，
  /// 在构造函数中传入需要传入的类的实例就可以了，因为传递的是引用。其属性都会变化。不用再用什么麻烦的方法了。
  ///TestTheClass
     TestClass classInstance1=new TestClass("firstname");
  ChangeTheNumber(classInstance1);
  Console.WriteLine(classInstance1.Name);
  
  TestClass classInstance2=new TestClass("second");
  ChangeTheNumber(classInstance2);
  Console.WriteLine(classInstance2.Name);
  Console.Read();
 }
 
 #region Helper methods

 private static void WL(object text, params object[] args)
 {
  Console.WriteLine(text.ToString(), args); 
 }
 
 private static void RL()
 {
  Console.ReadLine(); 
 }
 
 private static void Break() 
 {
  System.Diagnostics.Debugger.Break();
 }

    private static void ChangeTheNumber(ref int number)
 {
  number=100;
 }
 
 private static void ChangeTheNumber(int x)
 {
  x=100;
 }
 
 private static void ChangeTheNumber(TestClass classInstance)
 {
  classInstance.Name="change to another name";
 }
 
 private static void ChangeTheNumber(ref TestClass classInstance)
 {
  classInstance.Name="change to another name";
 }
 #endregion
}

///
///测试类
///
public class TestClass
{
 public TestClass(string name)
 {
  this.name=name;
 }
 
 private string name;
 public string Name
 {
  get
  {
   return name;
  }
  set
  {
   name=value;
  }
 }
}