The best way to use the in, out, and ref key phrases in .NET Core

The in, out, and ref key phrases are extensively used key phrases in C#. They permit us to create higher abstractions for knowledge sorts and strategies, which in flip makes our code extra readable and maintainable.

Each the in key phrase and the out key phrase will let you cross parameters to a technique by reference. The out key phrase lets you change the parameter values, whereas the in key phrase doesn’t will let you change them.

You should use the ref key phrase to cross enter and output parameters by reference, permitting the referred to as methodology to vary these arguments if wanted. By passing parameters by reference, the ref key phrase ensures that modifications to the parameters inside the methodology are mirrored outdoors of the strategy as nicely.

On this article, we’ll discover every of those key phrases in additional element in order that you’ll understand how and when to make use of them when working with C#. To work with the code examples offered on this article, it is best to have Visible Studio 2022 Preview put in in your system. For those who don’t have already got a replica, you may obtain Visible Studio 2022 Preview right here.

Create a console utility challenge in Visible Studio

First off, let’s create a .NET Core console utility challenge in Visible Studio. Assuming Visible Studio 2022 Preview is put in in your system, observe the steps outlined under to create a brand new .NET Core console utility challenge in Visible Studio.

1. Launch the Visible Studio 2022 Preview IDE.
2. Click on on “Create new challenge.”
3. Within the “Create new challenge” window, choose “Console App (.NET Core)” from the checklist of templates displayed.
4. Click on Subsequent.
5. Within the “Configure your new challenge” window proven subsequent, specify the title and site for the brand new challenge.
6. Click on Subsequent
7. Within the “Further info” window proven subsequent, specify .NET 7 because the .NET model you want to use. 
8. Click on Create.

It will create a brand new .NET Core 7 console utility challenge in Visible Studio 2022 Preview. We’ll use this challenge to work with the in, out, and ref key phrases within the subsequent sections of this text.

The ref key phrase in C#

In C#, the passing of an object or variable by reference is achieved with the usage of the ref key phrase. Ordinarily, when a variable is distributed to a technique, the worth of the variable is copied into the strategy in order that it might be used additional on.

Nevertheless, if we use ref to cross the variable by reference, the variable isn’t copied into the strategy. As an alternative, the strategy follows the reference to entry the unique variable. Therefore any change the referred to as methodology makes to the worth of the variable will likely be made to the unique variable.

It needs to be famous that you need to specify the ref key phrase each within the methodology signature and on the level the place the strategy known as. Think about the next code:

void RefDemo(ref int refParameter) 
{
    refParameter = refParameter + 1; 
} 
int quantity = 1; 
RefDemo(ref quantity); 
Console.WriteLine(quantity);

Once you execute the previous code, the quantity 2 will likely be displayed on the console. It’s because the variable referred to as quantity has been handed by reference and the worth of the refParameter has been elevated by 1 contained in the RefDemo methodology.

The next code snippet demonstrates how you should utilize the ref key phrase with objects.

void RefDemo(ref int refParameter)
{
    refParameter = refParameter + 1;
}
int quantity = 1;
RefDemo(ref quantity);
Console.WriteLine(quantity);

Once you execute the previous code, the textual content “Hey World” will likely be displayed on the console.

Right here is an attention-grabbing level. For those who execute the next piece of code, the RefDemo methodology will return true as a result of the references of the str and refParameter objects are the identical.

string str = "Hey";
string str = "Hey";
bool RefDemo(ref string refParameter)
{
    refParameter = "Hey World";
    return ReferenceEquals(str, refParameter);
}
bool isEqual = RefDemo(ref str);
Console.WriteLine(isEqual? "The 2 references are equal":"The 2 references will not be equal");

The in key phrase in C#

The in key phrase in C# is used to specify {that a} methodology parameter is handed by reference, however the referred to as methodology can’t modify the argument. That is helpful for parameters that aren’t modified by the referred to as methodology, however have to be handed by reference to ensure that the calling methodology to entry the outcomes.

Determine 1 exhibits you may’t change the worth of an in parameter.

IDG

The out key phrase in C#

The out key phrase works a lot the identical means because the ref key phrase; it lets you cross parameters utilizing references and to vary the values of these parameters as nicely. The out key phrase is similar to the ref key phrase, with the exception that ref wants the variable to be initialized previous to being handed. When working with the out key phrase in C#, each the strategy signature and the calling methodology should explicitly specify the out key phrase.

For instance, a technique would possibly must return each a hit code and a price. By utilizing an output parameter for the variable (say, retValue), the strategy can return the success code immediately and use the output parameter for the worth.

The next code snippet illustrates how one can work with the out key phrase in C#.

int quantity;
OutDemo(out quantity);
Console.WriteLine(quantity); //The worth is now 100
void OutDemo(out int quantity)
{
    quantity = 100;
}

Once you execute the previous code, the worth 100 will likely be displayed on the console.

Limitations of in, out, and ref

You can not use the in, out, and ref key phrases in async strategies or iterator strategies, akin to those who use a yield return or yield break assertion. Moreover, you can’t use the in key phrase within the first parameter to an extension methodology until the parameter is a struct.

It’s pertinent to notice that the key phrases in, ref, and out don’t kind a part of the strategy signature when figuring out overloads. Therefore, you can’t overload strategies that differ in signature solely with respect to those key phrases.

In different phrases, you probably have two strategies with the identical title, however certainly one of them accepts an integer as an in parameter and the opposite accepts an integer as an out parameter, your code gained’t compile in any respect.