Ref local re-assignment – C# 7.3 in Rider and ReSharper

Maarten Balliauw

The Early Access Preview (EAP) versions of ReSharper 2018.2 and Rider 2018.2 come with support for C# 7.3. In this series, we are looking at these new language features in C# 7.3. Today, we let’s check out ref local re-assignment.

This post is part of a series:

• Declaration expressions in initializers and queries
• Tuple equality
• Unmanaged, delegate and enum type constraints
• Ref local re-assignment
• Fixed pattern and simplified access to fixed size buffer elements
• C# updates for stackalloc

Ref local re-assignment

In C#, it’s been possible for a while to work with references, using the ref keyword. For example, it’s possible to return a reference to a Person that is already in memory, rather than return a by-value version that will be copied.

public ref Person GetPerson(int id)
{
    // ...
}

If we’d call our method and assign the variable locally, this would essentially read the value of what was returned, and then assign it to a new variable:

var person = people.GetPerson(123);

Whenever we now make a change to the person, that change is made to the local copy of person, not to the one that was originally returned by GetPerson(). Even though that method returned a Person by reference.

C# 7.2 and C# 7.3 added a number of additions to working with references and the ref keyword. In C# 7.2, the ability to replace a referenced variable was added. Consider the following example:

void Example()
{
    var people = new[]
    {
        new Person { Name = "Person 1" },
        new Person { Name = "Person 2" }
    };

    ref var personRef = ref GetPerson(people, 0);

    // C# 7.2 - Assigning personRef to a new Person will *replace* the original element in our array
    personRef = new Person { Name = "Person X" };
    // people[0] will now be the new person we just assigned
}

public static ref Person GetPerson(Person[] people, int id)
{
    return ref people[id]; 
}

We have effectively re-assigned people[0] in this case, which may (or may not) be intentional. Use with caution!

Perhaps this was unintentional after all, and all we wanted to do was to re-use the personRef variable to hold a reference to another object. For those cases, C# 7.3 adds ref local re-assignment (spec), to make it possible to re-assign an existing reference:

void Example()
{
    var people = new[]
    {
        new Person { Name = "Person 1" },
        new Person { Name = "Person 2" }
    };

    ref var personRef = ref GetPerson(people, 0);

    // C# 7.3 ref re-assignment - note the 'ref' keyword in front of the assigned value
    // This will not change the value it points to, just update the reference itself.
    personRef = ref GetPerson(people, 1);

    // Now people[0] and people[1] are still the same. personRef holds a reference to people[1].
}

public static ref Person GetPerson(Person[] people, int id)
{
    return ref people[id]; 
}

Do keep in mind that, for example, changing personRef.Name will update the original person in our array as well.

Download ReSharper 2018.2 EAP now! Or give Rider 2018.2 EAP a try. We’d love to hear your feedback!

Subscribe to a monthly digest curated from the .NET Tools blog:

Subscribe form

By submitting this form, I agree to the JetBrains Privacy Policy Notification icon

By submitting this form, I agree that JetBrains s.r.o. ("JetBrains") may use my name, email address, and location data to send me newsletters, including commercial communications, and to process my personal data for this purpose. I agree that JetBrains may process said data using third-party services for this purpose in accordance with the JetBrains Privacy Policy. I understand that I can revoke this consent at any time in my profile. In addition, an unsubscribe link is included in each email.

Submit

Thanks, we've got you!