C#中out和ref之间的区别_百度文库
两大类热门资源免费畅读
续费一年阅读会员，立省24元！
C#中out和ref之间的区别
你可能喜欢博客分类：
C#中的输出参数有两种：ref和out。
其实称他们为输出参数不是特别的准确，因为他们并不是像函数返回值一样“输出”一个值，而是将原先存在的值进行编辑。
举个例子(伪代码)：
1、一般参数
int i = 1;
int j = 2;
int add(int i, int j)
return i +
print(add(i, j))
2、使用ref
int i = 1;
int j = 2;
void add(ref int i, ref int j)
add(i, j);
两个函数都是用来计算两个值的和，不同的是一般参数传递进函数的是参数的拷贝值，
而ref和out直接修改内存中的数据。
对于值类型数据，ref和out相当于指针。
对于引用类型数据，就直接传递指向原数据的指针。
那么ref和out有什么区别呢？
区别在于对参数对象的初始化。
ref要求参数在传递之前进行初始化，而out要求在函数中对参数进行初始化，
所以，ref是个输入输出参数，而out是个输出参数。
镭风【CHN】
浏览: 87279 次
来自: 上海
qiqiandfei 写道请问Orderbiz类 在哪里定义的 ...
请问Orderbiz类 在哪里定义的 没有找到啊
左键单击图标右边的下箭头，在下拉菜单中选择Hibernate
w 写道请问下博主，如果我的记录是这样的呢6 ...
使用了如上所说的方法之后，原来的错误提示没了，换成了The r ...
(window.slotbydup=window.slotbydup || []).push({
id: '4773203',
container: s,
size: '200,200',
display: 'inlay-fix'&&&&&& 在C#中通过使用方法来获取返回值时，通常只能得到一个返回值。因此，当一个方法需要返回多个值的时候，就需要用到ref和out，那么这两个方法区别在哪儿呢？
MSDN：&&&&&& ref&关键字使参数按引用传递。其效果是，当控制权传递回调用方法时，在方法中对参数所做的任何更改都将反映在该变量中。若要使用&ref&参数，则方法定义和调用方法都必须显式使用&ref&关键字。&&&&& out&关键字会导致参数通过引用来传递。这与&ref&关键字类似，不同之处在于&ref&要求变量必须在传递之前进行初始化。若要使用&out&参数，方法定义和调用方法都必须显式使用&out&关键字。&
&&&&& 定义一个方法，求一个整数数组中的最大值，最小值，和，平均数。如果是一个方法只能有一个返回值，那只能每一个都得定义一个方法来实现，不过有了ref和out这实现起来就方便多了。
static int GetIntResult(int[] arry, ref float avg, ref int max, ref int min)
int sum = 0;
max = arry[0];
min = arry[0];
for (int i = 0; i & arry.L i++)
sum += arry[i];
if (max & arry[i])
max = arry[i];
if (min & arry[i])
min = arry[i];
avg = sum / arry.L
&&&&& 然后在控制台中试着调用该方法：
static void Main(string[] args)
int[] arr = { 1,2,3,4,5,6,7,8,9};
int sum = GetIntResult(arr, ref avg, ref max, ref min);
&&&&& 此时编译器就会提示画红线，错误：使用了未赋值的avg,max,min
static void Main(string[] args)
int[] arr = { 1, 2, 3, 4, 5, 6, 7, 8, 9 };
float avg = 0;
int max = 0;
int min = 0;
int sum = GetIntResult(arr, ref avg, ref max, ref min);
Console.WriteLine("和：{0}\t平均值：{1}\t最大值：{2}\t最小值：{3}", sum, avg, max, min);
Console.Read();
运行结果：
&&&& &ref这个关键字告诉c#编译器被传递的参数值指向与调用代码中变量相同的内存。这样，如果被调用的方法修改了这些值然后返回的话，调用代码的变量也就被修改了。
&&&&& ref&关键字使参数按引用传递。其效果是，当控制权传递回调用方法时，在方法中对参数所做的任何更改都将反映在该变量中（avg，max，min的初始值为0，调用方法后值改变）。若要使用&ref&参数，则方法定义和调用方法都必须显式使用&ref&关键字。
&&&&& 换成out之后，上面的方法不再适用，报错，错误&：&控制离开当前方法之前必须对 out 参数&min&和"max"赋值。你会发现这里max和min在循环外并未初始化。所以才会出错。
修改后代码：
2 using System.Collections.G
3 using System.L
4 using System.T
5 using System.Threading.T
7 namespace Wolfy.RefAndOut
class Program
static void Main(string[] args)
int[] arr = { 1, 2, 3, 4, 5, 6, 7, 8, 9 };
float//在使用out关键字时，不需要在此处初始化，初始化也不会影响到方法内部的值，所以你初始化没用
int sum = GetIntResult(arr, out avg, out max, out min);
Console.WriteLine("和：{0}\t平均值：{1}\t最大值：{2}\t最小值：{3}", sum, avg, max, min);
Console.Read();
static int GetIntResult(int[] arry, out float avg, out int max, out int min)
int sum = 0;
max = arry[0];
min = arry[0];//使用out关键字时，必须在离开方法前对out关键字修饰的参数初始化
for (int i = 0; i & arry.L i++)
sum += arry[i];
if (max & arry[i])
max = arry[i];
if (min & arry[i])
min = arry[i];
avg = sum / arry.L
&&&& 结果和上面一样。
总结：&&&&&& out&关键字会导致参数通过引用来传递。这与&ref&关键字类似，不同之处在于&ref&要求变量必须在传递之前进行初始化。若要使用&out&参数，方法定义和调用方法都必须显式使用&out&关键字。
&&&&&& 关键字&ref&和&out&之间的唯一区别就是关键字&out&不要求调用代码初始化要传递的参数值。那么关键字&ref&什么时候用呢？当您需要确保调用方法已经初始化参数值的时候，您就应该使用关键字&ref&。在上面例子中，能够使用&out&是因为被调用的方法并不依赖于被传递的变量的值。个中滋味慢慢体会......
&&&&& 在一论坛里面，偶然看到有这样的帖子，就顺便总结了一下，也算是回忆一下c#基础知识吧。
&&&& 想深入了解的可以看这篇文章：
阅读(...) 评论()&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&
&& class Program&&& {&&&&&&& static void Main(string[] args)&&&&&&& {
　　　　　&&&&//先声明，但不初始化
　　　　　User _user=new User();&&&&&&
　　　　　_user.Name(out&tmp);&&&&&&&&//调用Name方法
&&&&&&&&&&&&& Console.WriteLine("{0}",tmp);　//这时tmp的值为&在这里面赋值了&
&&&&&&&&&&&&& Console.ReadKey(true);
　　class User
　　　　public&void Name(out&string&tmps)
&&&&&&&&&& {
　　　　　& tmps="在这里面赋值了";
&&&&&&&&&&&}
&&&&&&&结果：
&&&&&&&&&&&&& 在这里面赋值了
&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&
&ref的使用
&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&
&& class Program&&& {&&&&&&& static void Main(string[] args)&&&&&&& {
　　　　　string tmp="传值之前";&&&&//声明并初始化&&&&&&& 这时如果输出tmp值为"传值之前"
　　&&&&&&&&User _user=new User();
&&&&&&&&&&&&& _user.Name(ref&tmp);
&&&&&&&&&&&&& Console.WriteLine("{0}",tmp);
&&&&&&&&&&&&& Console.ReadKey(true);
&&& class User
&&&&&&&& public void Name(ref&string&tmps)
&&&&&&&& {
&&&&&&&&&&&&&&tmps="传值之后";
&&&&&&&&&}
&&&&结果：
&&&&&&&&&&传值之后
&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&
ref和out的区别在C# 中，既可以通过值也可以通过引用传递参数。通过引用传递参数允许函数成员更改参数的值，并保持该更改。若要通过引用传递参数， 可使用ref或out关键字。ref和out这两个关键字都能够提供相似的功效，其作用也很像C中的指针变量。它们的区别是：
1、使用ref型参数时，传入的参数必须先被初始化。对out而言，必须在方法中对其完成初始化。
2、使用ref和out时，在方法的参数和执行方法时，都要加Ref或Out关键字。以满足匹配。
3、out适合用在需要retrun多个返回值的地方，而ref则用在需要被调用的方法修改调用者的引用的时候。
方法参数上的 out 方法参数关键字使方法引用传递到方法的同一个变量。当控制传递回调用方法时，在方法中对参数所做的任何更改都将反映在该变量中。
当希望方法返回多个值时，声明 out 方法非常有用。使用 out 参数的方法仍然可以返回一个值。一个方法可以有一个以上的 out 参数。
若要使用 out 参数，必须将参数作为 out 参数显式传递到方法。out 参数的值不会传递到 out 参数。
不必初始化作为 out 参数传递的变量。然而，必须在方法返回之前为 out 参数赋值。
属性不是变量，不能作为 out 参数传递。
ref是&&& 有进有出，而out是&&&&&& 只出不进。
阅读(...) 评论()首先：两者都是按地址传递的，使用后都将改变原来参数的数值。
其次：ref可以把参数的数值传递进函数，但是out是要把参数清空，就是说你无法把一个数值从out传递进去的，out进去后，参数的数值为空，所以你必须初始化一次。这个就是两个的区别，或者说就像有的网友说的，ref是有进有出，out是只出不进。
ref（C#&参考）
ref&关键字使参数按引用传递。其效果是，当控制权传递回调用方法时，在方法中对参数的任何更改都将反映在该变量中。若要使用&ref&参数，则方法定义和调用方法都必须显式使用&ref&关键字。
class RefExample
static void Method(ref int i)
static void Main()
int val = 0;
Method(ref val);
// val is now 44
传递到&ref&参数的参数必须最先初始化。这与&out&不同，后者的参数在传递之前不需要显式初始化。
尽管&ref&和&out&在运行时的处理方式不同，但在编译时的处理方式相同。因此，如果一个方法采用&ref&参数，而另一个方法采用&out&参数，则无法重载这两个方法。例如，从编译的角度来看，以下代码中的两个方法是完全相同的，因此将不会编译以下代码：
class CS0663_Example
// Compiler error CS0663: "cannot define overloaded
// methods that differ only on ref and out".
public void SampleMethod(ref int i) { }
public void SampleMethod(out int i) { }
&但是，如果一个方法采用&ref&或&out&参数，而另一个方法不采用这两个参数，则可以进行重载，如下例所示：
class RefOutOverloadExample
public void SampleMethod(int i) { }
public void SampleMethod(ref int i) { }
out（C#&参考）
out&关键字会导致参数通过引用来传递。这与&ref&关键字类似，不同之处在于&ref&要求变量必须在传递之前进行初始化。若要使用&out&参数，方法定义和调用方法都必须显式使用out&关键字。
class OutExample
static void Method(out int i)
static void Main()
Method(out value);
// value is now 44
&尽管作为&out&参数传递的变量不必在传递之前进行初始化，但需要调用方法以便在方法返回之前赋值。
ref&和&out&关键字在运行时的处理方式不同，但在编译时的处理方式相同。因此，如果一个方法采用&ref&参数，而另一个方法采用&out&参数，则无法重载这两个方法。例如，从编译的角度来看，以下代码中的两个方法是完全相同的，因此将不会编译以下代码：
class CS0663_Example
// Compiler error CS0663: "Cannot define overloaded
// methods that differ only on ref and out".
public void SampleMethod(out int i) { }
public void SampleMethod(ref int i) { }
&但是，如果一个方法采用&ref&或&out&参数，而另一个方法不采用这两类参数，则可以进行重载，如下所示：
class RefOutOverloadExample
public void SampleMethod(int i) { }
public void SampleMethod(out int i) { }
下面是本人的一些心得：
ref和out的区别在C# 中，既可以通过值也可以通过引用传递参数。通过引用传递参数允许函数成员更改参数的值，并保持该更改。若要通过引用传递参数， 可使用ref或out关键字。ref和out这两个关键字都能够提供相似的功效，其作用也很像C中的指针变量。它们的区别是：
1、使用ref型参数时，传入的参数必须先被初始化。对out而言，必须在方法中对其完成初始化。
2、使用ref和out时，在方法的参数和执行方法时，都要加Ref或Out关键字。以满足匹配。
3、out适合用在需要retrun多个返回值的地方，而ref则用在需要被调用的方法修改调用者的引用的时候。
方法参数上的 out 方法参数关键字使方法引用传递到方法的同一个变量。当控制传递回调用方法时，在方法中对参数所做的任何更改都将反映在该变量中。
当希望方法返回多个值时，声明 out 方法非常有用。使用 out 参数的方法仍然可以返回一个值。一个方法可以有一个以上的 out 参数。
若要使用 out 参数，必须将参数作为 out 参数显式传递到方法。out 参数的值不会传递到 out 参数。
不必初始化作为 out 参数传递的变量。然而，必须在方法返回之前为 out 参数赋值。
属性不是变量，不能作为 out 参数传递。
ref是&&& 有进有出，而out是&&&&&& 只出不进。
阅读(...) 评论()
Powered By: