Ref and Out Parameters Questions

Question

I thought I understood the difference, but now I'm not so sure. I've read the technical answer several times but I'm not understanding what is happening. I have this example.

class Program
   {
      static void Main()
      {
         int val = 0;

         Example1(val);
         Console.WriteLine(val); // Still 0!

         Example2(ref val);
         Console.WriteLine(val); // Now 2!

         Example3(out val);
         Console.WriteLine(val); // Now 3!
      }

      static void Example1(int value)
         {
             value = 1;
         }

      static void Example2(ref int value)
         {
             value = 2;
         }

      static void Example3(out int value)
         {
           value = 3;
         }
    }

I always thought the difference between default parameters is that if I am passing val into Example1, I can't use assignment.

But with the ref keyword val is still 0, but I have created a reference that is now treated as the variable "value" within Example2(ref val). Am I getting hung up on anything so far? if I had used

int value = 0;
Example1(value);
Console.WriteLine(value); // this would then return 1 correct?

Now then, what is happening with the out keyword? Same thing as ref?

Answer 1

In the first example you do not specify that the variable is a reference, and because it is a fundamental type, it just copies the provided number. So value inside Example1 is a copy of value in Main.

The second example uses a reference. This means the both inside the function Example2 and inside Main are refering to the same place in the memory, and therefore the value is transfered, when both entering and exiting the function.

In the third example, the out keyword does the same as the second except that is initialized to be 0 when entered into the function. As a result, it is just a parameter for returning some kind of data. The value is just transfered when exiting the function.

Answer 2

See if this helps:

No "decorators"

static void Example(int value)
{
    Console.WriteLine("Value is {0}", value);
    value = 99;
}

usage
{
    int value = 10;
    Example(notADefaultValue); // Will print <Value is 10>
    Console.WriteLine("Value is {0}", value); // will print <Value is 10>
}

Summary: Value types (structs/enums/int/double/etc) are not passed in as a reference by default so whatever you do to the variable within a method does not affect the caller. Thus, the "ref" keyword. If you pass a reference type to a method (i.e. a class) and change it's internals, these will affect the caller.

Default parameters:

static void Example(int value = 5)
{
    Console.WriteLine("Value is {0}", value);
}

usage
{
    int notADefaultValue = 10;
    Example(notADefaultValue); // Will print <Value is 10>
    Example(); // will print <Value is 5>
}

Summary: Default values allow you to call a method without explicitly needing to pass parameters, the default value is used.

Ref parameters:

static void Example(ref int value)
{
    Console.WriteLine("Value is {0}", value);
    value = 99;
}

usage
{
    int value = 10;
    Example(ref value); // Will print <Value is 10>
    Console.WriteLine("Value is {0}", value); // Will print <Value is 99>
}

Summary: If you pass a value type in as a ref (reference) the value itself gets changed. Allreference types are passed in as ref by default. FYI, int is a primitive types so needs an explicit "ref".

out parameters:

static void Example(out int value)
{
    value = 99;
    Console.WriteLine("Value is {0}", value);
}

usage
{
    int value; // no need to init it
    Example(out value); // Will print <Value is 99>
    Console.WriteLine("Value is {0}", value); // Will print <Value is 99>
}

Summary: Out parameters are like return variables but passed in via the signature of the method. Most common example is TryParse where the method returns vital information and depending on that information the out parameter is either valid or not (valid if it is true).

Answer 3

Ok, its a duplicate of the linked question in the comments but I'll try to explain it for you.

Undecorated Parameters

Case A: public void MyFunc(int x) { }

-or-

Case B: public void MyFunc(MyClass y) { }

In Case A, the parameter is a value type, and value types are, by default, passed as copies of the original value to the function. This doesn't mean you aren't allowed to modify the value, but the value will not be reflected back at the calling location. This is the same for all value types, the value is copied before it is passed to the function.

In Case B, the parameter is a reference type. These types are passed by default as they are. They are not copied, but you are not allowed to change the reference (by assigning a new or null value to the type). You can change the contents of the object (any property/field there-of) and it will be reflected back in the calling location.

The ref keyword

Case A: public void MyFunc(ref int x) { }

-or-

Case B: public void MyFunc(ref MyClass x) { }

In case A, you are telling the compiler that you want to pass the value by reference, which means the compiler will not copy the type, but passes a reference to that type. The function is allowed to change it.

In case B, you are telling the compiler that the function is allowed to change where the reference points to (you can create a new or set it to null and it will be reflected in the calling site.

The out keyword

Case A: public void MyFunc(out int x) { }

-or-

Case B: public void MyFunc(out MyClass x) { }

Here, you are basically defining additional return types for the function. Its the method parameter telling the caller to expect a result in the place of the x variable. This is the same for both. The caller should not expect, in any case, that any value that x was before, will be the same afterwards. In fact you can expect that it will not be the same, because the method is required to assign a new value to x before it is allowed to return.

out basically means you provide a place for a return value, for value types just use the default constructor and for reference types initialize the value to null before you pass it in.