Em releases anteriores do C#, a utilização da palavra-chave ref se resumia à passagem de parâmetros por referência na invocação de métodos. Com o C# 7.0 esta capacidade foi estendida também para o retorno de métodos, sendo que este recurso foi batizado como Ref Returns.

Na próxima listagem, é possível observar um exemplo de uso de Ref Returns. A declaração do método ObterContador e o seu retorno foram marcados com a palavra-chave ref, indicando que o atributo privado _contador será devolvido como referência.

namespace ExemploRefReturns
{
    public class ClasseExemplo
    {
        private int _contador = 0;
 
        public void Incrementar()
        {
            _contador++;
        }
 
        public int ObterValorContador()
        {
            return _contador;
        }
 
        public ref int ObterContador()
        {
            return ref _contador;
        }
    }
}

Já na listagem a seguir o método ObterContador é invocado, com o retorno do mesmo sendo vinculado à variável teste:

• Importante destacar que em ambos os casos foi necessário utilizar a palavra-chave ref;
• Alterações em teste serão refletidas em ClasseExemplo, já que tal variável nada mais é do que uma referência apontando para o atributo privado _contador.

using System;
 
namespace ExemploRefReturns
{
    class Program
    {
        static void Main(string[] args)
        {
            ClasseExemplo exemplo = new ClasseExemplo();
            exemplo.Incrementar();
            Console.WriteLine(exemplo.ObterValorContador());
 
            ref int teste = ref exemplo.ObterContador();
            teste++;
            Console.WriteLine(exemplo.ObterValorContador());
            Console.ReadKey();
        }
    }
}

O resultado da execução deste último trecho de código pode ser observado na seguinte imagem:

Do ponto de vista prático, a utilização de Ref Internals tende a não acontecer com tanta frequência. Espera-se que a adoção deste recurso fique restrita a cenários bem específicos, nas quais a performance em termos de memória consumida constitui um fator crítico (em situações similares àquelas envolvendo o uso de ponteiros em C++).

Referências

• New Features in C# 7.0: https://blogs.msdn.microsoft.com/dotnet/2017/03/09/new-features-in-c-7-0/