这个ref要怎么理解?

c#中ref是什么意思?怎么运用的?求列子~

可以理解为类似的传址引用，同时还有out。

在函数需要外部传入一个变量名，然后在程序内部可以将这个值进行修改，典型的传址引用！在定义时必要加ref或out说明！

public void MethodA(out string s )
{
s = "1";
}

调用时，应该先声明一个字符变量。

string temp;
MethodA(out temp);
此时可以打印temp的值会变作"1";

而ref与out基本是类同的，如果在程序中引用原值的话，必须使用ref防止传入未初始化的值。
public void MethodB(ref int s)
{
s = s*s;
}
因为该函数要使用形参的原值，所以这里必须使用ref声明，不要使用out声明。
使用时，
int temp = 8;
MethodB(ref temp);
打印temp的值会变为64。
ref因为对原值进行了引用，所以ref要求传入的一定是一个初始化后的值，不能是未初始化的值。

int temp;
MethodB(ref temp);
//原则上这样是会错的，但这里我使用了一个int，由于在声明时int temp与int temp =0 是等价的，所以不会出错，但如果是字符串，使用这种方式完全是可以报错的！因为string temp与string temp ="";是不等价的，你也可理解为必须赋值后才可以使用。

public void MethodC(ref string s)
{
.......
}

string temp;
MethodC(ref temp);//这种就是错误的方式。ref要求必须形参已经赋值（初始化）。
string temp = "";
MethodC(ref temp);//这种方式就是正确的。

我们定义成员方法时，如果有引用原值使用必须使用ref，防上对方传入一个未初始化的值，引发程序错误，而没有必要对形参的值有要求时，则尽量使用out，防止调用时增加客户端代码量。

REF是Reference的缩写，为参考尺寸的意思。
参考尺寸依ASME Y14.5上的定义是:在别处已有标示的尺寸,为了看图人的方便,在其他位置重复标示的尺寸。可以由现有尺寸计算出来的尺寸,但也是为了看图人的方便,而标示的尺寸。参考尺寸是不可量测的。

扩展资料：
尺寸标注基本规则：
1、机件的真实大小应以图样上所注的尺寸数值为依据，与图形的大小及绘图的准确度无关。
2、尺寸，以毫米为单位时，不需标注计量单位的代号或名称，如采用其他单位，则必须注明相应的计量单位的代号或名称。
3、机件的每一尺寸，一般只标注一次，并应标注在反映该结构最清晰的图形上。
参考资料：百度百科-REF

使用了Ref和Out的效果就几乎和C中使用了指针变量一样。它能够让你直接对原数进行操作，而不是对那个原数的Copy进行操作。举个小例子：

using System;
namespace ConsoleApplication4
{
///
/// Class1 的摘要说明。
///
class Class1
{
///
/// 应用程序的主入口点。
///
[STAThread]
static void Main(string[] args)
{
int a = 5;
int b;
squareRef(ref a);
squareOut(out b);
Console.WriteLine("The a in the Main is: " + a);
Console.WriteLine("The b in the Main is: " + b);
}
static void squareRef(ref int x)
{
x = x * x;
Console.WriteLine("The x in the squareRef is: " + x);
}
static void squareOut(out int y)
{
y = 10;
y = y * y;
Console.WriteLine("The y in the squareOut is: " + y);
}
}
}
显示的结果就是——25 100 25 100。

这样的话，就达到了和C中的指针变量一样的作用。
显示的结果就是——25 100 25 100。

这样的话，就达到了和C中的指针变量一样的作用。

对于引用类型。

对于引用类型就比较难理解了。

先要了解到这一层——就是当一个方法接收到一个引用类型的变量的时候，它将获得这个引用（Reference）的一个Copy。由于Ref关键字可以用来向方法传递引用。所以，如果这个功能被误用了——比如：当一个如数组类型的引用对象用关键字Ref传递的时候，被调用的方法实际上已经控制了传递过来的引用本身。这样将使得被调用方法能用不同的对象甚至NULL来代替调用者的原始引用！

如图。内存地址为2000的变量arrayA中其实存放着数组{1，2，3，4，……}的内存起始地址10000。如果一个方法fun()使用fun( arrayA[] )的话，它将顺利的获得数据10000，但这个10000将放在一个Copy中，不会放到内存的2000位置。而这个时候我们如果使用fun( ref arrayA[] )的话，我们得到的值就是2000啦（也就是说，被调用方法能够修改掉arrayA中的那个引用，使之不再指向10000，甚至可以用NULL来代替10000，这样的话，那个10000地址中的数据可能就要被垃圾回收机制清理了。）

有个例子：

using System;
using System.Drawing;
using System.Collections;
using System.ComponentModel;
using System.Windows.Forms;
using System.Data;
namespace RefOut
{
///
/// Form1 的摘要说明。
///
public class Form1 : System.Windows.Forms.Form
{
private System.Windows.Forms.Button button1;
private System.Windows.Forms.Label label1;
///
/// 必需的设计器变量。
///
private System.ComponentModel.Container components = null;
public Form1()
{
//
// Windows 窗体设计器支持所必需的
//
InitializeComponent();
//
// TODO: 在 InitializeComponent 调用后添加任何构造函数代码
//
}
///
/// 清理所有正在使用的资源。
///
protected override void Dispose( bool disposing )
{
if( disposing )
{
if (components != null)
{
components.Dispose();
}
}
base.Dispose( disposing );
}
#region Windows 窗体设计器生成的代码
///
/// 设计器支持所需的方法 - 不要使用代码编辑器修改
/// 此方法的内容。
///
private void InitializeComponent()
{
this.button1 = new System.Windows.Forms.Button();
this.label1 = new System.Windows.Forms.Label();
this.SuspendLayout();
//
// button1
//
this.button1.Dock = System.Windows.Forms.DockStyle.Top;
this.button1.Location = new System.Drawing.Point(0, 0);
this.button1.Name = "button1";
this.button1.Size = new System.Drawing.Size(480, 32);
this.button1.TabIndex = 0;
this.button1.Text = "显示输出";
this.button1.Click += new System.EventHandler(this.button1_Click);
//
// label1
//
this.label1.Location = new System.Drawing.Point(8, 48);
this.label1.Name = "label1";
this.label1.Size = new System.Drawing.Size(456, 336);
this.label1.TabIndex = 1;
this.label1.Text = "label1";
//
// Form1
//
this.AutoScaleBaseSize = new System.Drawing.Size(6, 14);
this.ClientSize = new System.Drawing.Size(480, 405);
this.Controls.Add(this.label1);
this.Controls.Add(this.button1);
this.MaximizeBox = false;
this.MinimizeBox = false;
this.Name = "Form1";
this.Text = "Ref & Out";
this.ResumeLayout(false);
}
#endregion
///
/// 应用程序的主入口点。
///
[STAThread]
static void Main()
{
Application.Run(new Form1());
}
private void button1_Click(object sender, System.EventArgs e)
{
int[] firstArray = {1, 2, 3};
int[] firstArrayCopy = firstArray;
this.label1.Text = "Test Passing firstArray reference by value";
this.label1.Text += "\n\nContents of firstArray before calling FirstDouble:\n\t";

for(int i = 0;i < firstArray.Length; i++)
{
this.label1.Text += firstArray[i] + " ";
}
FirstDouble(firstArray);
this.label1.Text += "\n\nContents of firstArray after calling FirstDouble.\n\t";
for(int i=0;i {
this.label1.Text += firstArray[i] + " ";
}
if(firstArray == firstArrayCopy)
this.label1.Text +="\n\nThe references refer to the same array.\n";
else
this.label1.Text +="\n\nThe reference refer to different arrays.\n";
int[] secondArray = {1, 2, 3};
int[] secondArrayCopy = secondArray;

this.label1.Text += "\nTest passing secondArray reference by reference.";
this.label1.Text += "\n\nContents of secondArray before calling SecondDouble:\n\t";
for(int i=0;i {
this.label1.Text += secondArray[i] + " ";
}
SecondDouble(ref secondArray);
this.label1.Text +="\n\nContents of secondArray after calling SecondDouble:\n\t";

for(int i=0; i {
this.label1.Text += secondArray[i] + " ";
}
if(secondArray== secondArrayCopy)
this.label1.Text += "\n\nThe reference refer to the same array.";
else
this.label1.Text += "\n\nThe reference refer to different arrays.";
this.label1.Text += "\n___________________heshi_________________\nsecondarray\n";
for(int i = 0;i {
this.label1.Text += secondArray[i] + " ";
}
this.label1.Text +="\nsecondarraycopy\n";
for(int i=0;i {
this.label1.Text += secondArrayCopy[i] + " ";
}

}
void FirstDouble(int[] array)
{
for(int i = 0;i array[i] *= 2;
array = new int[] {11, 12, 13};
}
void SecondDouble(ref int[] array)
{
for(int i=0;i {
array[i] *= 2;
}
array = new int[] {11, 12, 13};
}
}
}运行后的结果是：

这个就说明了被调用的程序已经改变了原有的Reference。

总结

总的说来，Ref和Out这两个关键字都能够提供相似的功效，其作用也很像C中的指针变量。稍有不同之处是：

使用Ref型参数时，传入的参数必须先被初始化。而Out则不需要，对Out而言，就必须在方法中对其完成初始化。
使用Ref和Out时都必须注意，在方法的参数和执行方法时，都要加Ref或Out关键字。以满足匹配。
Out更适合用在需要Return多个返回值的地方，而Ref则用在需要被调用的方法修改调用者的引用的时候。

---

源城区19258468393： 这个ref要怎么理解? - ？
鄣满垂盆： 使用了Ref和Out的效果就几乎和C中使用了指针变量一样.它能够让你直接对原数进行操作,而不是对那个原数的Copy进行操作.举个小例子:using System; namespace ConsoleApplication4 {/// /// Class1 的摘要说明./// class Class1 {/// /// 应用...

源城区19258468393： ref.是什么意思? - ？
鄣满垂盆： Our Reference 可能指参考号,比如在税务部门的注册号之类的.也可能指可供参考的人/公司,外国公司往往比较注重这个,他们会在自己网站上链接一些比较知名的公司,而且一定都是他们的客户,这样就可以让别人通过侧面了解他们公司是如何有实力.

源城区19258468393： 三次元操作盘的REF是什么意思 - ？
鄣满垂盆： 三次元操作盘的REF是重置的意思,即把量测点归零 三次元是一种测量软件 基本操作很简单,可以这么说,没读过书的人我能在三天内教会他基本操作 你可以 一、学习检测理论知识 二、学习形位公差 三、把ASME Y14.5看一下 四、把GDT看一下 对于编程这一环,需要理解每个测量要素的定义和计算功能的定义,再是掌握形位公差和尺寸公差的定义,最后就是要多操作了,正所谓熟能生巧,菜鸟也能变高手.

源城区19258468393： 博易大师代码中的REF(向前引用)是什么意思？
鄣满垂盆： 这个问题我知道!就是引用当前周期前面的数据的意思.举例说明: 昨天的收盘价:REF(C,1); 前天的开盘价:REF(O,2); 10天前的最高价:REF(H,10);

源城区19258468393： c#中ref 有什么意义 说的通俗点哈 - ？
鄣满垂盆： 对于对象类型来说.没意义.加不加一样.对于值类型..比如是一个结构..在方法体内操作这个结构.加REF就会同步修改这个结构.如果不加.则不影响外面的

源城区19258468393： ref和out的作用于区别是什么? - ？
鄣满垂盆： ref和out都是引用地址 ref可以理解为引用传值,一个构造器或方法里含有ref参数,任何使用这个构造器或方法的地方操纵的都是同一个变量,ref所修饰的变量,也就是说...和你定义全局变量或者static变量差不多的[效果].out我个人感觉和ref使用差不多啊,网上有人说值传递,还说传递之前必须初始化,不明白...ref相当于把值引进来,也能传出去.out是只传出去,从最初定义的地方引用了,每当调用这个含有out参数的构造器或方法时,out所修饰的变量的值都会【清空】,会被这个新的构造器实例或方法重新赋值. out不想ref一样可以将传来的值引用再赋值,out是将原值清空再赋值!个人理解

源城区19258468393： ref和out的区别 - ？
鄣满垂盆： 一、两者词性不同 ref是名词中;out可做副词,可做动词 二、释义也不同 ref 英 [ref] 美 [ref]n. 裁判员 out 英 [aʊt] 美 [aʊt]adv. 出;在外;完;prep. 向外;在外面;v. 出来;暴露;驱逐;熄灭;伸出;公开…的同性恋身份 三、用法不同 ...

源城区19258468393： 如何理解面向对象编程语言中的“reference” - ？
鄣满垂盆： ref理解为引用,传引用其实没真的把参数传进来,只是穿了这个参数的地址,注意,是地址,其实和指针一样,只是表达形式不同 这样做对大对象参数传递很有用,避免把大对象复制一遍,提高效率

源城区19258468393： C语言中out和ref的区别是什么? - ？
鄣满垂盆： ref:相当于c语言的引用参数 实参和形参一起变.out:多用于输出参数 就是在return之前必须给out标示的参数赋值.C语言的基本特性:1、C是高级语言:它把高级语言的基本结构和语句与低级语言的实用性结合起来.C 语言可以像汇编语言...

源城区19258468393： 在c#中Ref关键字的作用是啥? - ？
鄣满垂盆： 方法参数上的 ref 方法参数关键字使方法引用传递到方法的同一个变量.当控制传递回调用方法时,在方法中对参数所做的任何更改都将反映在该变量中. 若要使用 ref 参数,必须将参数作为 ref 参数显式传递到方法.ref 参数的值被传递到 ref 参数. 传递到 ref 参数的参数必须最先初始化.将此方法与 out 参数相比,后者的参数在传递到 out 参数之前不必显式初始化. 属性不是变量,不能作为 ref 参数传递.