Novidades do C# 7.3: utilizando Enums em constraints, sobrecarga com in parameters

Este segundo artigo da série sobre novidades do C# 7.3 aborda o uso de Enums em constraints, além da possibilidade de sobrecarga (overloading) de métodos empregando o modificador in.

Caso tenha interesse em acompanhar o primeiro artigo que publiquei sobre o C# 7.3, acesse o link a seguir:

Novidades do C# 7.3: como habilitar, utilizando os operadores == e != com Tuplas

Utilizando Enums em constraints

Com o C# 7.3 há agora a possibilidade de se indicar em uma constraint/restrição ao uso de um tipo Enum. É o que demonstra o exemplo a seguir:

O método GetValues da classe EnumHelper faz uso desta nova capacidade (a fim de receber como parâmetro apenas Enums). Esta operação retornará uma string com os diversos valores que compõem um Enum;
O tipo ExemploEnum será empregado nos testes do método GetValues.

using System;
using System.Linq;
using System.Text;

namespace ExemploEnumConstraint
{
    public static class EnumHelper
    {
        public static string GetValues<T>() where T : Enum
        {
            StringBuilder strbValores = new StringBuilder();
            strbValores.Append("[ ");

            var valores = Enum.GetValues(typeof(T))
                .Cast<T>()
                .Select(v => v.ToString());
            foreach (var valor in valores)
            {
                if (strbValores.Length > 2)
                    strbValores.Append(", ");
                strbValores.Append(valor);
            }

            strbValores.Append(" ]");

            return strbValores.ToString();
        }
    }

    public enum ExemploEnum
    {
        Status1,
        Status2,
        Status3
    }

    class Program
    {
        static void Main(string[] args)
        {
            Console.WriteLine(EnumHelper.GetValues<ExemploEnum>());
            Console.ReadKey();
        }
    }
}

Como resultado da execução deste código, teremos:

Sobrecarga com in parameters

Com o C# 7.2, métodos também podem receber como parâmetros referências somente leitura, com isto acontecendo através do modificado in. Já abordei inclusive esta funcionalidade no seguinte artigo:

Novidades do C# 7.2 – parte 1: como habilitar, ref readonly e in parameters

Uma limitação nesta versão era a impossibilidade de declaração de métodos sobrecarregados empregando a palavra-chave in. O release oficial do C# 7.3 corrigiu essa restrição, ao mesmo tempo em que permite também a sobrecarga de métodos em aplicações baseadas na versão 7.2.

Na listagem a seguir temos um exemplo de métodos sobrecarregados, com duas diferentes versões para a operação TesteSobrecarga:

using System;

namespace ExemploSobrecargaIn
{
    class Program
    {
        private static void TesteSobrecarga(int valor)
        {
            Console.WriteLine(quot;Sem o modificador in: {valor}");
        }

        public static void TesteSobrecarga(in int valor)
        {
            Console.WriteLine(quot;Com o modificador in: {valor}");
        }

        static void Main(string[] args)
        {
            TesteSobrecarga(5);

            int valorTeste = 10;
            TesteSobrecarga(in valorTeste);

            Console.ReadKey();
        }
    }
}

Ao executar este código, será apresentado como resultado: