Author avatar

Matt Ferderer

C# - Using in, out, and Ref with Parameters

Matt Ferderer

  • Jun 12, 2019
  • 6 Min read
  • 92 Views
  • Jun 12, 2019
  • 6 Min read
  • 92 Views
Programming languages
C#

Introduction

In this guide, we will look at the difference between using in, out, and ref when passing reference and value types as parameters in C# methods. These techniques allow you to change how C# handles altering data locally in the method as well as outside the method.

Before reading this article, you should have an understanding of passing reference and value types.

The in, ref, and out Modifiers

Method parameters have modifiers available to change the desired outcome of how the parameter is treated. Each method has a specific use case:

  • ref is used to state that the parameter passed may be modified by the method.

  • in is used to state that the parameter passed cannot be modified by the method.

  • out is used to state that the parameter passed must be modified by the method.

Both the ref and in require the parameter to have been initialized before being passed to a method. The out modifier does not require this and is typically not initialized prior to being used in a method.

The ref Modifier

By default, a reference type passed into a method will have any changes made to its values reflected outside the method as well. If you assign the reference type to a new reference type inside the method, those changes will only be local to the method. See my Pluralsight guide Passing a Reference vs. Value for examples. Using the ref modifier, you have the option to assign a new reference type and have it reflected outside the method.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
class ReferenceTypeExample
{
  static void Enroll(ref Student student)
  {
    // With ref, all three lines below alter the student variable outside the method.
    student.Enrolled = true;
    student = new Student();
    student.Enrolled = false;
  }

  static void Main()
  {
    var student = new Student
    {
      Name = "Susan",
      Enrolled = false
    };

    Enroll(ref student);

    // student.Name is now null since a value was not passed when declaring new Student() in the Enroll method
    // student.Enrolled is now false due to the ref modifier
  }
}

public class Student {
  public string Name {get;set;}
  public bool Enrolled {get;set;}
}
csharp

Using the ref modifier, you can also change value types outside the method as well.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
class ReferenceTypeExample
{
  static void IncrementExample(ref int num)
  {
    num = num + 1;
  }

  static void Main()
  {
    int num = 1;
    IncrementExample(ref num);
    // num is now 2
  }
}
csharp

The out Modifier

Using the out modifier, we initialize a variable inside the method. Like ref, anything that happens in the method alters the variable outside the method. With ref, you have the choice to not make changes to the parameter. When using out, you must initialize the parameter you pass inside the method. The parameter being passed in often is null.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
class ReferenceTypeExample
{
  static void Enroll(out Student student)
  {
    //We need to initialize the variable in the method before we can do anything
    student = new Student();
    student.Enrolled = false;
  }

  static void Main()
  {
    Student student;

    Enroll(out student); // student will be equal to the value in Enroll. Name will be null and Enrolled will be false.
  }
}

public class Student {
  public string Name {get;set;}
  public bool Enrolled {get;set;}
}
csharp

The out modifier works with value types as well. A useful example is using the out modifiermodifer to change a string to an int.

1
2
int x;
Int32.TryParse("3", out x);
csharp

The in Modifier

The in modifier is most often used for performance reasons and was introduced in C# 7.2. The motivation of in is to be used with a struct to improve performance by declaring that the value will not be modified. When useding with reference type,s it only prevents you from assigning a new reference.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
class ReferenceTypeExample
{
  static void Enroll(in Student student)
  {
    // With in assigning a new object would throw an error
    // student = new Student();

    // We can still do this with reference types though
    student.Enrolled = true;
  }

  static void Main()
  {
    var student = new Student
    {
      Name = "Susan",
      Enrolled = false
    };

    Enroll(student);
  }
}

public class Student
{
  public string Name { get; set; }
  public bool Enrolled { get; set; }
}
csharp

Modifiers Are Not Allowed on All Methods

It's important to note that in, out, and ref cannot be used in methods with the async modifier. You can use them in synchronous methods that return a Task, though.

You cannot use them in iterator methods that have a yield return or yield break either.

Overloading Methods Wwith Modifiers

When overloading a method in C#, using a modifier will be considered a different method signature than not using a modifier at all. You cannot overload a method if the only difference between methods is the type of modifier used. This will result in a compile error.

Summary

Knowing these simple techniques can make your code easier to understand &and simpler to read.

To learn more about passing reference types, value types, and other types in C# check out Accelerated C# Fundamentals by Scott Allen. Don't forget to try out the C# Path and see where your skills are at and where you can improve!

About the Author

Matt Ferderer is a software developer who tweets, posts and blogs about web development.

4