blocks|key|2049045|text|您可以使用y更改foo指向的内容|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|2049046|Foo+foo+=+new+Foo("1");

void+Bar(ref+Foo+y)
{
++++y+=+new+Foo("2");
}

Bar(ref+foo);
//+foo.Name+==+"2"|code-block|syntax|javascript|2049047|entityMap^0|5|1|8|3|0|0^^$0|@$1|2|3|4|5|6|7|M|8|@$9|N|A|O|B|C]|$9|P|A|Q|B|C]]|D|@]|E|$]]|$1|F|3|G|5|H|7|R|8|@]|D|@]|E|$I|J]]|$1|K|3|-4|5|6|7|S|8|@]|D|@]|E|$]]]|L|$]]

You can change what <code>foo</code> points to using <code>y</code>:

<pre><code>Foo foo = new Foo("1");

void Bar(ref Foo y)
{
 y = new Foo("2");
}

Bar(ref foo);
// foo.Name == "2"
</code></pre>

blocks|key|1835020|text|当使用ref关键字传递引用类型时，将按引用传递引用，并且所调用的方法可以为参数分配新值。该更改将传播到调用作用域。如果没有ref，引用是通过值传递的，这种情况不会发生。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1835021|C#也有'out‘关键字，它与ref非常相似，除了使用'ref’时，参数必须在调用方法之前初始化，而使用'out‘时，必须在接收方法中赋值。|1835022|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|F|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|G|8|@]|9|@]|A|$]]|$1|D|3|-4|5|6|7|H|8|@]|9|@]|A|$]]]|E|$]]

When you pass a reference type with the ref keyword, you pass the reference by reference, and the method you call can assign a new value to the parameter. That change will propagate to the calling scope. Without ref, the reference is passed by value, and this doesn't happen.

C# also has the 'out' keyword which is a lot like ref, except that with 'ref', arguments must be initialized before calling the method, and with 'out' you must assign a value in the receiving method.

blocks|key|2049262|text|另一堆代码|type|unstyled|depth|inlineStyleRanges|entityRanges|data|2049263|class+O
{
++++public+int+prop+=+0;
}

class+Program
{
++++static+void+Main(string[]+args)
++++{
++++++++O+o1+=+new+O();
++++++++o1.prop+=+1;

++++++++O+o2+=+new+O();
++++++++o2.prop+=+2;

++++++++o1modifier(o1);
++++++++o2modifier(ref+o2);

++++++++Console.WriteLine("1+:+"+%2B+o1.prop.ToString());
++++++++Console.WriteLine("2+:+"+%2B+o2.prop.ToString());
++++++++Console.ReadLine();
++++}

++++static+void+o1modifier(O+o)
++++{
++++++++o+=+new+O();
++++++++o.prop+=+3;
++++}

++++static+void+o2modifier(ref+O+o)
++++{
++++++++o+=+new+O();
++++++++o.prop+=+4;
++++}
}|code-block|syntax|javascript|2049264|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

Another bunch of code

<pre><code>class O
{
 public int prop = 0;
}

class Program
{
 static void Main(string[] args)
 {
 O o1 = new O();
 o1.prop = 1;

 O o2 = new O();
 o2.prop = 2;

 o1modifier(o1);
 o2modifier(ref o2);

 Console.WriteLine("1 : " + o1.prop.ToString());
 Console.WriteLine("2 : " + o2.prop.ToString());
 Console.ReadLine();
 }

 static void o1modifier(O o)
 {
 o = new O();
 o.prop = 3;
 }

 static void o2modifier(ref O o)
 {
 o = new O();
 o.prop = 4;
 }
}
</code></pre>

blocks|key|2049347|text|一个方法中的参数似乎总是传递一个副本，问题是它是什么的副本。复制是由对象的复制构造函数完成的，因为在C#中所有变量都是对象，所以我相信所有变量都是如此。变量(对象)就像住在某些地址的人。我们要么改变住在这些地址的人，要么在电话簿中创建更多对住在这些地址的人的引用(制作浅层副本)。因此，多个标识符可以引用相同的地址。引用类型需要更多的空间，因此与通过箭头直接连接到堆栈中的标识符的值类型不同，它们具有堆中另一个地址的值(有更大的空间可供驻留)。此空间需要从堆中获取。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|2049348|取值类型:标识(包含值=堆栈值的地址)->取值类型的值|2049349|引用类型:标识符(包含堆栈值的value=address+)->(包含堆值的value=address+)->堆值(最常包含指向其他值的地址)，想象有更多的箭头在不同方向贴向数组、Array1、array2|2049350|更改值的唯一方法是跟随箭头。如果一个箭头丢失/更改，则无法访问该值。|2049351|entityMap^0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|J|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|K|8|@]|9|@]|A|$]]|$1|D|3|E|5|6|7|L|8|@]|9|@]|A|$]]|$1|F|3|G|5|6|7|M|8|@]|9|@]|A|$]]|$1|H|3|-4|5|6|7|N|8|@]|9|@]|A|$]]]|I|$]]

A parameter in a method seems to be always passing a copy, the question is a copy of what. A copy is done by a copy constructor for an object and since all variables are Object in C#, i believe this is the case for all of them. Variables(objects) are like people living at some addresses. We either change the people living at those addresses or we can create more references to the people living at those addresses in the phone book(make shallow copies). So, more than one identifier can refer to the same address. Reference types desire more space, so unlike value types that are directly connected by an arrow to their identifier in the stack, they have value for another address in the heap( a bigger space to dwell). This space needs to be taken from the heap. 

Value type:
Indentifier(contains value =address of stack value)---->Value of value type

Reference type:
Identifier(contains value=address of stack value)---->(contains value=address of heap value)---->Heap value(most often contains addresses to other values), imagine more arrows sticking in different directions to Array[0], Array[1], array[2]

The only way to change a value is to follow the arrows. If one arrow gets lost/changed in the way the value is unreachable.

blocks|key|2049389|text|除了现有的答案之外：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|2049390|正如您询问的两种方法的区别:使用ref或out时没有协方差|offset|length|style|CODE|2049391|class+Foo+{+}
class+FooBar+:+Foo+{+}

static+void+Bar(Foo+foo)+{+}
static+void+Bar(ref+Foo+foo)+{+foo+=+new+Foo();+}

void+Main()
{
++++Foo+foo+=+null;
++++Bar(foo);+++++++++++//+OK
++++Bar(ref+foo);+++++++//+OK

++++FooBar+fooBar+=+null;
++++Bar(fooBar);++++++++//+OK+(covariance)
++++Bar(ref+fooBar);++++//+compile+time+error
}|code-block|syntax|javascript|2049392|entityMap^0|0|G|3|K|3|0|0^^$0|@$1|2|3|4|5|6|7|O|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|P|8|@$D|Q|E|R|F|G]|$D|S|E|T|F|G]]|9|@]|A|$]]|$1|H|3|I|5|J|7|U|8|@]|9|@]|A|$K|L]]|$1|M|3|-4|5|6|7|V|8|@]|9|@]|A|$]]]|N|$]]

In addition to the existing answers:

As you asked for the difference of the 2 methods: There is no co(ntra)variance when using <code>ref</code> or <code>out</code>:

<pre><code>class Foo { }
class FooBar : Foo { }

static void Bar(Foo foo) { }
static void Bar(ref Foo foo) { foo = new Foo(); }

void Main()
{
 Foo foo = null;
 Bar(foo); // OK
 Bar(ref foo); // OK

 FooBar fooBar = null;
 Bar(fooBar); // OK (covariance)
 Bar(ref fooBar); // compile time error
}
</code></pre>

blocks|key|1835384|text|引用变量将地址从一个地方带到另一个地方，所以在任何地方对它们的任何更新都会反映所有的地方，那么REF的用途是什么。引用变量(405)是有效的，直到没有新的内存被分配给在该方法中传递的引用变量。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1835385|一旦分配了新的存储器(410)，则该对象上的值改变(408)将不会到处反映。因为这个裁判来了。Ref是引用的引用，所以每当新的内存分配它时，它就会知道，因为它指向那个位置，所以这个值可以被everyOne共享。你可以看到这张图片，看起来更清晰。|1835386|​|1835387|📷|atomic|offset|length|1835388|1835389|entityMap|0|IMAGE|mutability|IMMUTABLE|imageUrl|https://ask.qcloudimg.com/http-save/yehe-900000/14c73d48e34faad8c143d4b485fddd5f.jpeg|imageAlt^0|0|0|0|0|1|0|0|0^^$0|@$1|2|3|4|5|6|7|U|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|V|8|@]|9|@]|A|$]]|$1|D|3|E|5|6|7|W|8|@]|9|@]|A|$]]|$1|F|3|G|5|H|7|X|8|@]|9|@$I|Y|J|Z|1|10]]|A|$]]|$1|K|3|E|5|6|7|11|8|@]|9|@]|A|$]]|$1|L|3|-4|5|6|7|12|8|@]|9|@]|A|$]]]|M|$N|$5|O|P|Q|A|$R|S|T|-4]]]]

Reference Variables carry the address from one place to another so any updation on them at any place will reflect on all the places THEN what is the use of REF.
Reference variable (405) are good till no new memory is allocated to the reference variable passed in the method. 

Once new memory allocate (410) then the value change on this object (408) will not reflect everywhere.
For this ref comes. Ref is reference of reference so whenever new memory allocate it get to know because it is pointing to that location therefore the value can be shared by everyOne. You can see the image for more clearity.

<img src="https://i.stack.imgur.com/3GXKJ.jpg" alt="Ref in Reference Variable">

I understand that if I pass a value-type (<code>int</code>, <code>struct</code>, etc.) as a parameter (without the <code>ref</code> keyword), a copy of that variable is passed to the method, but if I use the <code>ref</code> keyword a reference to that variable is passed, not a new one.

But with reference-types, like classes, even without the <code>ref</code> keyword, a reference is passed to the method, not a copy. So what is the use of the <code>ref</code> keyword with reference-types?

<hr>

Take for example:

<pre><code>var x = new Foo();
</code></pre>

What is the difference between the following?

<pre><code>void Bar(Foo y) {
 y.Name = "2";
}
</code></pre>

and

<pre><code>void Bar(ref Foo y) {
 y.Name = "2";
}
</code></pre>

What is the use of "ref" for reference-type variables in C#?

我知道如果我传递一个值类型(int、struct等)作为参数(没有ref关键字)，该变量的副本被传递给该方法，但是如果我使用ref关键字，则传递的是对该变量的引用，而不是新的引用。但是，对于引用类型，即使没有ref关键字，也会将引用传递给方法，而不是复制。那么，ref关键字与引用类型有什么关系呢？举个例子：var x ...

问对于C#中的引用类型变量，"ref“的用途是什么？
EN

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问对于C#中的引用类型变量，"ref“的用途是什么？EN

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问对于C#中的引用类型变量，"ref“的用途是什么？
EN