A simplicidade do TryGet Pattern

A simplicidade do TryGet Pattern

Com a simplicidade do TryGet Pattern, torna um código mais claro e que garante que ao menos um atributo de qualidade seja alcançado, o atributo testability. Além disso, tem a garantia que eventuais exceptions sejam lançadas por descuidos de desenvolvedores que se esquecem de fazer defensivas de código.

Talvez, você possa se perguntar. Com o Resharper não seria mais fácil? Sim, seria. Entretanto, embora o Resharper seja muito bom, ele torna o programador preguiçoso.

Com um pouco mais de clareza, trouxe, por exemplo, um método de consultar cliente pelo nome.

 public class Program
    {
        public static void Main(string[] args)
        {
            var name = Console.ReadLine();

            var customer = FindCustomerByName(name);
            Console.WriteLine($"Selected customer: {customer.Name}");

            Console.ReadKey();
        }

        public static Customer FindCustomerByName(string name)
        {
            var customers = new List<Customer>(5)
            {
                new() {Name = "Tiago"},
                new () {Name = "Flavia"},
                new () { Name = "Arthur"},
                new () {Name = "Ludmila"},
                new () {Name = "Sophia"},
                new () {Name = "Tina"}
            };

            var result = customers
                .FirstOrDefault(_ => _.Name.Equals(name));

            return result;
        }
    }

Propositalmente, ignorei a defensiva validando se o cliente é nulo, diga-se de passagem, algo muito comum. Na prática, o que acontece é que esse código tem um grande potencial para gerar um NullReferenceException.

Utilizando o padrão TryGet, o erro de NullReferenceException não aconteceria.

    {
        public static void Main(string[] args)
        {
            var name = Console.ReadLine();

            Console.WriteLine(TryGetCustomerByName(name, out var customer)
                ? $"Selected customer: {customer.Name}"
                : $"Customer {name} not found.");

            Console.ReadKey();
        }

        public static bool TryGetCustomerByName(string name, out Customer customer)
        {
            var customers = new List<Customer>(5)
            {
                new() {Name = "Tiago"},
                new () {Name = "Flavia"},
                new () { Name = "Arthur"},
                new () {Name = "Ludmila"},
                new () {Name = "Sophia"},
                new () {Name = "Tina"}
            };

            customer = customers
                .FirstOrDefault(_ => _.Name.Equals(name));

            return customer is not null;
        }
    }

É notório a clareza ao utilizar um código com o padrão TryGet. Para saber, nativamente o padrão é utilizado na struct Int32.

     public static bool TryParse([NotNullWhen(true)] string? s, out int result)
     {
         if (s == null)
         {
             result = 0;
             return false;
         }
 
         return Number.TryParseInt32IntegerStyle(s, NumberStyles.Integer, NumberFormatInfo.CurrentInfo, out result) == Number.ParsingStatus.OK;
     }

Algo simples que nos faz repensar a forma como escrevemos nossos códigos. Embora a simplicidade TryGet Patern traga uma boa leitura de código, não há impactos em performance, nem para melhor nem para pior.