C#中ref引用传参怎么用？

1.out和ref引用参数的相同点:都是通过引用传递参数给函数;
2.out和ref引用参数的不同点是:用ref引用传递参数,该参数必须经过初始化,并且不能在调用它的函数中初始化,以下例子是错误的：
namespace refConsoleApp
{
　 　class MyRefClass
{
static void MyRefMethod(ref int i)
{
int i=20;
}
static void main(string[] args)
{
int value; //not initialized the value;
MyRefMethod(ref value);
Console.WriteLine("The value is {0}",value);
}
}
}
3.使用out引用多个参数来返回多个值,这允许方法任意地返回需要的值，以下例子：
namespace multi_outConsoleApp
{
class MyMultipleoutClass
{
static void MyMultipleMethod(out int i, out string str1, out string str2)
{
i = 20;
str1 = "I was born";
str2 = "zhaoqing";

}
static void Main(string[] args)
{
int value;
string s1, s2;
MyMultipleMethod(out value,out s1,out s2);
Console.WriteLine("The integer value is {0} The first string value is {1} The second string value is {2}", value, s1, s2);

}
}
}

显示的结果为：
The integer value is 20
The first string value is I was born
The second string value is zhaoqing
4. 如果一个方法使用ref引用参数,另一个方法使用out引用参数,则这两个相同方法名的函数不能重载,否则出现编译错误,以下例子出现: " cannot define overloaded methods that differ only on ref and out "
namespace overloadofConsoleApp
{
class overloadofclass
{
static void MyMethod(ref int i)
{
i = 20;
}
static void MyMethod(out int i)
{
i = 40;
}
static void Main(string[] args)
{
int refvalue=0;
MyMethod(ref refvalue);
Console.WriteLine("The value is {0}", refvalue);
int outvalue;
MyMethod(out outvalue);
Console.WriteLine("The value is {0}", outvalue);
}
}
}
以下例子是正确的:
namespace overloadofConsoleApp
{
class overloadofclass
{
static void MyMethod(ref int i)
{
i = 20;
}
static void MyMethod( int i)
{
i = 40;
}
static void Main(string[] args)
{
int refvalue=0;
MyMethod(ref refvalue);
Console.WriteLine("The value is {0}", refvalue);
int outvalue=0;
MyMethod(outvalue);
Console.WriteLine("The value is {0}", outvalue);
}
}
}
显示结果为:
The value is 20
The value is 0
5.通过ref参数来改变引用类型,因为引用类型作为ref参数来传递,同时该对象会被改变.以下例子:
namespace refConsoleApp
{
class refclass
{
static void RefMethod(ref string s)
{
s = "I was born in zhaoqing";
}
static void Main(string[] args)
{
string str = "I am goalbell";
RefMethod(ref str);
Console.WriteLine("The value is {0}", str);
}
}
}
显示结果：
The value is I was born in zhaoqing

6.通过ref和out来传递数组,用ref传递数组的时候，必须在main函数里面初始化一个数组，而在被调用的方法中可以指定一个数组为空值或者初始 化成一个不同的数组;用out 传递数组的时候，在被调用的方法中确定为一个数组赋值.以下例子来区别一下它们:
namespace refszConsoleApp
{
class refszclass
{
static void RefszMethod(ref int[] arr)
{
if (arr == null) //assigned the null value
{
arr = new int[5]; //initialized to a different array
}
}
static void Main(string[] args)
{
int[] theArray ={ 1, 2, 3, 4, 5 };//initialize the theArray
RefszMethod(ref theArray); // pass the value using of ref
Console.WriteLine("Array elements are:");
for (int i = 0; i < theArray.Length; i++)
{
Console.WriteLine(theArray[i] + "");
}
}
}
}
namespace outszConsoleApp
{
class outszclass
{
static void OutszMethod(out int[] arr)
{

arr = new int[5] { 1, 2, 3, 4, 5 };//initialize the arr
}
static void Main(string[] args)
{
int[] theArray ;
OutszMethod(out theArray);
Console.WriteLine("Array elements are:");
for (int i = 0; i < theArray.Length; i++)
{
Console.WriteLine(theArray[i] + "");
}
}
}
}

static void Main(string[] args)
{
int x = 0;
GetVal(x);
Console.WriteLine(x);
//x=0,很遗憾,传递的是值类型,x的值没有变化

GetRefVal(ref x);
Console.WriteLine(x);
//x=10, x的值已经改变啦
Console.ReadLine();
}

private static void GetVal(int x)//这里只是单纯的复制x=0这个变量.传说中的传值
{
x = 10;
}

private static void GetRefVal(ref int x)//参数x是1个指向堆栈中值类型为int的指针
//传说中的传址
{
x = 10;
}

方法的参数类型前加上ref关键字，调用时，在参数前加上ref关键字。具体的意义随便找本C#的书上都会讲

protected void Page_Load(object sender, EventArgs e)
{
int value = 0;//初始值
Test(ref value);

Response.Write(value.ToString());//值被改变，结果是9999
Response.End();

}
protected void Test(ref int value)
{
value = 999;
}

这么和你说，假如你在果园里，你跟果农说要吃苹果，这时候果农也许会给你一个现成的苹果，也许会告诉你那边有个苹果树，自己去摘！
在到程序里，你的参数如果是string str，那么你指是想得到一个string类型的str；就是苹果
但如果你这么写 ref string str，那么你是想得到一个string的地址，注意这里是要地址，也就是苹果树。
public void faction（string str）；调用的时候faction（“123”）；就完了；
public void faction（ref string str）；调用的时候你要faction（ref var）；这里的var是一个string类型的变量，比如string var = 18；用ref你首先得到了var这个变量，然后你就可以用18这个值了，就这意思。区别就在这，一个要值，一个要地址！