In .NET there are 4 different types of parameter modifiers, some used more than others, and each used for a specific purpose.

None - This is when the parameter is not marked with any modifier. The value is passed by value, meaning that the parameter is a copy of the original.

out - An output parameter must be assigned by the method being called. The value is passed by reference, meaning that the parameter is the original, so any changes in the method will effect the original value. If the output parameter is not assigned by the called method a compilation error will occur.

ref - The caller assigns the value, which can then be reassigned by the called method. The value is passed by reference. There is no compiler error if the called method does not assign a value to the ref parameter.

params - This allows you to send in multiple number of arguments as a single parameter. This must the last parameter and a method can only have one params modifier. This modifier is used a lot within the base class libraries, but you will most likely not have an everyday use for it.

Here is an example of each modifier used.

No Modifier:

This is the most commonly used modifier.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17

public static void Main(){
  int x = 10, y = 5;
  Console.WriteLine(x + " " + y);
  Console.WriteLine(ChangeNumbers(x, y));
  Console.WriteLine(x + " " + y);
}

public void ChangeNumbers(int x, int y){
  x = 100;
  y = 500;
  Console.WriteLine(x + " " + y);
}

//Output:
//10 5
//100 500
//10 5

Here we can see that since there is no modifier on the parameters for ChangeNumbers(x, y)  the parameters are passed by value, leaving the original values of x and y in Main()  unchanged.

out:

The main purpose of using the out parameter is to get multiple return values from a method call.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14

public static void Main(){
  int x, y, z;
  Console.WriteLine(GetValues(x, y));
  Console.WriteLine(x + " " + y + " " + z);
}

public void GetValues(out int x, out int y, out int z){
  x = 100;
  y = 500;
  z = 600;
}

//Output:
//100 500 600

All three values are assigned a value in the GetValues() and can be used in the Main method. In the GetValues() method all three values must be initialized, if not then an error will be thrown.

ref:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16

public static void Main(){
  int x = 10, y = 50, z = 60;
  Console.WriteLine(GetValues(x, y));
  Console.WriteLine(x + " " + y + " " + z);
}

public void GetValues(int x, reg int y, ref int z){
  x = 100;
  y = 500;
  z = 600;
}

//Output:
//10
//500
//600

The ref modifier is very similar to the out parameter, but there are a few differences. A ref parameter must be initialized before passing to a method, if it is not initialized then an unassigned parameter is passed. Also inside the method it is not mandatory to change the value of the ref parameter.

params:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15

public static void Main(){
  int result = AddValues(1,2,3,4);
  Console.WriteLine(result);
}

public int AddValues(params int[] values){
  int result;    
  foreach(int v in values){
      result += v;
  }
  return result;
}

//Output:
//10

Even though AddValues() takes one parameter, we passed in 4. The four numbers will automatically be converted into an array and passed in the values array.