Use of 'ref' keyword in C# [duplicate]

Answer 1

There is a lot of confusing misinformation in the answers here. The easiest way to understand this is to abandon the idea that "ref" means "by reference". A better way to think about it is that "ref" means "I want this formal parameter on the callee side to be an alias for a particular variable on the caller side".

When you say

void M(ref int y) { y = 123; }
...
int x = 456;
M(ref x);

that is saying "during the call to M, the formal parameter y on the callee side is another name for the variable x on the caller side". Assigning 123 to y is exactly the same as assigning 123 to x because they are the same variable, a variable with two names.

That's all. Don't think about reference types or value types or whatever, don't think about passing by reference or passing by value. All "ref" means is "temporarily make a second name for this variable".

Answer 2

I believe the ref keyword indicates that you are passing the object by reference, not by value. For example:

void myfunction(ref object a) {
a = new Something();
}

would change the value of a in the calling function However,

void myfunction(object a) {
a = new Something();
}

would change the value of a locally, but not in the calling function. You can still change PROPERTIES of the item, but you cannot set the value of the item itself. For example; a.someproperty = value;

would work in both cases.

Answer 3

Using ref means that the reference is passed to the function.

The default behaviour is that the function receives a new reference to the same object. This means if you change the value of the reference (e.g. set it to a new object) then you are no longer pointing to the original, source object. When you pass using ref then changing the value of the reference changes the source reference - because they are the same thing.

Consider this:

public class Thing
{
    public string Property {get;set;}
}

public static void Go(Thing thing)
{
    thing = new Thing();
    thing.Property = "Changed";
}

public static void Go(ref Thing thing)
{
    thing = new Thing();
    thing.Property = "Changed";
}

Then if you run

var g = new Thing();

// this will not alter g
Go(g);

// this *will* alter g
Go(ref g);

Answer 4

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Diagnostics;

namespace InOutRef
{
    static class InOutRef
    {
        public static void In(int i)
        {
            Console.WriteLine(i);
            i=100;
            Console.WriteLine(i);
        }
        public static void Ref(ref int i)
        {
            Console.WriteLine(i);
            i=200;
            Console.WriteLine(i);
        }
        public static void Out(out int i)
        {
            //Console.WriteLine(i); //Error Unsigned Ref
            i=300;
            Console.WriteLine(i);
        }
    }

    class Program
    {
        static void Main(string[] args)
        {
            int i = 1;
            InOutRef.In(i); //passed by value (in only)
            Debug.Assert(i==1);
            InOutRef.Ref(ref i); //passed by ref (in or out)
            Debug.Assert(i == 200);
            InOutRef.Out(out i); //passed by as out ref (out only)
            Debug.Assert(i == 300);
        }
    }
}

I can't be any more literal on my answer. The code will not remember reference chanages such as the classic Java swap question when using in. However, when using ref, it will be similar to VB.NET as it will remember the changes in and out. If you use the out parameter it means that it must be declared before you return (this is enforced by the compiler).

Output:
1                                  //1 from main 
100                                //100 from in
1                                  //1 is NOT remembered from In
200                                //200 from ref
//should be 200 here but out enforces out param (not printed because commented out)
300                                //300 is out only
Press any key to continue . . .