TheDeveloperBlog.com


C# Parameter Passing, Ref and Out

Ref and out change the behavior of method parameters. Sometimes we want the actual value of a variable to be copied as the parameter. Other times we want a reference. These modifiers affect definite assignment analysis.

RefOut

Example. In addition to the Main method, this program introduces three methods. The Example1 method uses the default parameter passing technique. The Example2 method uses the ref modifier. And the Example3 method employs the out modifier.

Next: We pass the local int val to each of these three methods and examine the results.

Int
C# program that demonstrates parameter passing

using System;

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;
    }
}

Output

0
2
3

Example1 uses value-passing semantics for its declaration. Therefore, when it changes the value of its parameter int, that only affects the local state of the method. The int in Main retains its current value when Example1 returns.

In contrast to Example1, Example2 uses the ref modifier for its int parameter. This informs the compiler that a reference to the actual variable (int val) is to be passed to Example2.

Note: The ref keyword is used in the calling syntax in Main. When Example2 sets its parameter to 2, this is reflected in the Main method.

Finally, Example3 uses out on its parameter. This has compile-time checking features. These involve definite assignment rules. Example3 sets its parameter to 3—this is reflected in the calling location.


Ref, out. What is the difference between ref and out? They both indicate that the parameter is being passed by reference. The difference is in the compiler's application of the definite assignment analysis step.

Tip: The compiler demands that an out parameter be "definitely assigned" before any exit. There is no such restriction with the ref.

When a method uses the out modifier, you can be sure that after you invoke it, your variable is definitely assigned. This means you can write code that does not assign the variable before calling an out method.


References. There is no difference between references and values at some levels of compilation. References are actually values. Each is represented by a series of bytes that are stored together.

However: A reference is a value that points to a location elsewhere in memory. A value stores an immediate value such as a number.

Numbers

And: The compiler enforces rules on references. These avoid type safety issues and ensure your program doesn't do anything horrible.


Arguments, parameters. Arguments are values that are passed to a specific method call. You can call a method with many different arguments, as many times as you wish. The name of the argument variables (if any) does not affect the behavior of the method.

Program 1: C#

using System;

class Program
{
    static void Main()
    {
	// Argument = 5
	// Argument = Sam
	Perls(5, "Sam");
    }

    static void Perls(int id, string name)
    {
	Console.WriteLine(id);
	Console.WriteLine(name);
    }
}

Output

5
Sam

Also, parameters are called formal parameters and they are found in the method itself. The names they use are not affected by the argument names. When the arguments are passed to the method, they are received as formal parameters.

Program 2: C#

using System;

class Program
{
    static void Main()
    {
	Perls(5, "Sam");
    }

    static void Perls(int id, string name)
    {
	// Parameter = id
	// Parameter = name
	Console.WriteLine(id);
	Console.WriteLine(name);
    }
}

Output

5
Sam


Black-box abstractions. In the Structure and Interpretation of Computer Programs, procedures are described as black-box abstractions. Procedures do a specific task. They are concerned with tasks, not with how those tasks are done.

Formal parameters are important because their names do not matter. This means that they will not be affected by other names in the program, making procedures become good black-box abstractions as desired.

Also, formal parameters are bound variables, which means they have a specific meaning only within that function. Free variables, on the other hand, could conflict and create ambiguous meanings in programs. (See pages 26-29.)

Review: Arguments are specific values passed to a method. Parameters are the variables where those values are received.

And: This disconnect provides a profound level of abstraction, useful for developing complex yet understandable computer programs.


Summary. The C# language has strict rules regarding the passing of parameters by value and by reference. The default is to pass all parameters by value, even if those parameters are themselves references.

Thus: Out is often preferred to ref. It ensures that you can avoid assigning the variable before passing it as an argument.