{"id":1165,"date":"2018-04-11T01:06:58","date_gmt":"2018-04-10T17:06:58","guid":{"rendered":"https:\/\/blogs.msdn.microsoft.com\/seteplia\/?p=1165"},"modified":"2019-06-11T21:48:16","modified_gmt":"2019-06-12T04:48:16","slug":"performance-traps-of-ref-locals-and-ref-returns-in-c","status":"publish","type":"post","link":"https:\/\/devblogs.microsoft.com\/premier-developer\/performance-traps-of-ref-locals-and-ref-returns-in-c\/","title":{"rendered":"Performance traps of ref locals and ref returns in C#"},"content":{"rendered":"

The C# language from the very first version supported passing arguments by value or by reference. But before C# 7 the C# compiler supported only one way of returning a value from a method (or a property) – returning by value. This has been changed in C# 7 with two new features: ref returns and ref locals.<\/p>\n

But unlike other features that were recently added to the C# language I’ve found these two a bit more controversial than the others.<\/p>\n

The motivation<\/h4>\n

There are many differences between the arrays and other collections from the CLR perspectives. The arrays were added to the CLR from the very beginning and you can think of them as of built-in generics. The CLR and the JIT-compiler are aware of the arrays but besides that, they’re special in one more aspect: the indexer of the array returns the element by reference, not by value<\/strong>.<\/p>\n

To demonstrate this behavior we have to go to the dark side — use a mutable value type:<\/p>\n

public struct Mutable\r\n{\r\n    private int _x;\r\n    public Mutable(int x) => _x = x;\r\n \r\n    public int X => _x;\r\n \r\n    public void IncrementX() { _x++; }\r\n}\r\n \r\n[Test]\r\npublic void CheckMutability()\r\n{\r\n    var ma = new[] {new Mutable(1)};\r\n    ma[0].IncrementX();\r\n    \/\/ X has been changed!\r\n    Assert.That(ma[0].X, Is.EqualTo(2));\r\n \r\n    var ml = new List<Mutable> {new Mutable(1)};\r\n    ml[0].IncrementX();\r\n    \/\/ X hasn't been changed!\r\n    Assert.That(ml[0].X, Is.EqualTo(1));\r\n}<\/pre>\n
The test will pass because the indexer of the array is quite different from the indexer of the List<T><\/code>.<\/p>\n
The C# compiler emits a special instruction for the arrays indexer – ldelema<\/code><\/a> that returns a managed reference to a given array’s element. Basically, array indexer returns an element by reference. But List<T><\/code> can’t have the same behavior because it wasn’t possible (*) to return an alias to the internal state in C#. That’s why the List<T><\/code> indexer returns the element by value, i.e. returning the copy of the given element.<\/p>\n
(*) As we’ll see in a moment, it is still impossible for the List<T><\/code>‘s indexer to return an element by reference.<\/p>\n
This means that ma[0].IncrementX()<\/code> calls a mutation method on the first element inside of the array, but ml[0].IncrementX()<\/code> calls a mutation method on a copy, keeping the original list unchanged.<\/p>\n
Ref locals and ref returns 101<\/h4>\n
The basic idea behind these features is very simple: ref return<\/code>allows to return an alias to an existing variable and ref local can store the alias in a local variable.<\/p>\n
    \n
  1. Simple example<\/li>\n<\/ol>\n
    [Test]\r\npublic void RefLocalsAndRefReturnsBasics()\r\n{\r\n    int[] array = { 1, 2 };\r\n \r\n    \/\/ Capture an alias to the first element into a local\r\n    ref int first = ref array[0];\r\n    first = 42;\r\n    Assert.That(array[0], Is.EqualTo(42));\r\n \r\n    \/\/ Local function that returns the first element by ref\r\n    ref int GetByRef(int[] a) => ref a[0];\r\n    \/\/ Weird syntax: the result of a function call is assignable\r\n    GetByRef(array) = -1;\r\n    Assert.That(array[0], Is.EqualTo(-1));\r\n}<\/pre>\n
      \n
    1. Ref returns and readonly ref returns<\/li>\n<\/ol>\n
      Ref returns can return an alias to instance fields and starting from C# 7.2 you can return a readonly alias using ref readonly<\/code>:<\/p>\n
      class EncapsulationWentWrong\r\n{\r\n    private readonly Guid _guid;\r\n    private int _x;\r\n \r\n    public EncapsulationWentWrong(int x) => _x = x;\r\n \r\n    \/\/ Return an alias to the private field. No encapsulation any more.\r\n    public ref int X => ref _x;\r\n \r\n    \/\/ Return a readonly alias to the private field.\r\n    public ref readonly Guid Guid => ref _guid;\r\n}\r\n \r\n[Test]\r\npublic void NoEncapsulation()\r\n{\r\n    var instance = new EncapsulationWentWrong(42);\r\n    instance.X++;\r\n \r\n    Assert.That(instance.X, Is.EqualTo(43));\r\n \r\n    \/\/ Cannot assign to property 'EncapsulationWentWrong.Guid' because it is a readonly variable\r\n    \/\/ instance.Guid = Guid.Empty;\r\n}<\/pre>\n