26 03 2014

Olá caro(a) leitor(a)!

Depois de pouco mais de um mês sem atividade aqui no blog, estou de volta. Esse “hiato” nas postagens ocorreu devido a um nobre motivo. Como mencionei no meu post com a revisão do ano passado e metas para este ano, eu e minha esposa estávamos esperando a chegada da nossa primeira filha. E ela chegou! No dia 30 de Março de 2014, com 50cm e 3220g, chegou ao mundo nossa querida Sophie! Somente agora que as coisas estão estabilizando e estou conseguindo retomar as atividades por aqui. Durante as próximas semanas vou recuperar os quatro artigos que acabaram ficando para trás.

Enfim, chega de papo e vamos ao assunto do post de hoje. Vocês provavelmente devem ter ficado sabendo sobre o acontecimento do evento Microsoft Build 2014, que ocorreu durante a minha ausência aqui pelo blog (a propósito, você encontra todos os vídeos do Build desse ano neste link). Nesse evento, como sempre, a Microsoft divulgou inúmeras novidades no ecossistema de desenvolvimento para a sua plataforma. Uma das novidades foi o anúncio do novo preview do Roslyn, que expõe o novo compilador de C# e VB.NET. Além disso, deu a louca na Microsoft e ela resolveu tornar o código desse compilador open source!

Com o novo preview do Roslyn, podemos começar a brincar com as novidades da próxima versão do C# (que ainda não tem nome, mas, ao que tudo indica, será C# 6.0). Neste post do blog do time de C#, você pode conferir como instalar o novo compilador no Visual Studio 2013. E nesta página da documentação do Roslyn no CodePlex, você encontra uma tabela com as novas funcionalidades que já estão implementadas e as que estão por vir, tanto no novo C# quanto no novo VB.NET.

Ainda não decidi se vou fazer uma série com as novidades mais bacanas da próxima versão do C#, mas, uma nova funcionalidade que eu não pude deixar passar são as chamadas declaration expressions. Não sei vocês, mas, essa é uma funcionalidade que eu vou conseguir tirar muito proveito na code base aqui da empresa onde trabalho atualmente.

Primeiro vamos analisar um cenário que pode ser melhorado com essa nova implementação do C# vNext. Na code base que eu trabalho diariamente, foram implementadas muitas funções que se utilizam de um parâmetro de saída (out) para retornar uma mensagem de erro. A ideia é que o retorno da função é um bool que retorna true (caso a função tenha sido executada com sucesso) ou false (caso algum erro tenha ocorrido dentro da função). Em caso de erro, o parâmetro de saída contém uma mensagem amigável para o erro. Caso contrário, o parâmetro de saída não serve para nada. Nem vou discutir aqui se isso é uma boa prática ou não. O fato é que eu lido com funções que seguem essa metodologia todo dia.

        public bool FuncaoMirabolante(int algumParametro, bool outroParametro, out string msgErro)
        {
            bool sucesso = true;
            msgErro = string.Empty;

            // Faz alguma coisa mirabolante...
            {
                // Ops, algo deu errado!
                sucesso = false;
                msgErro = "Desculpe, algo deu errado... :(";
            }

            return sucesso;
        }

Até aqui tudo bem. O problema é a chamada dessa função. Sempre precisamos criar uma variável extra para passar no parâmetro out, e ter que sempre fazer isso é simplesmente um saco:

            string msgErro;
            if (!FuncaoMirabolante(15, false, out msgErro))
            {
                Console.WriteLine(msgErro);
            }

A boa notícia é que, com o novo compilador do C#, nós não precisamos mais declarar essa variável para passar no parâmetro out. Ou melhor, nós podemos declará-la diretamente no parâmetro:

            if (!FuncaoMirabolante(15, false, out string msgErro))
            {
                Console.WriteLine(msgErro);
            }

E ao invés de utilizarmos “string” explicitamente, poderíamos até mesmo utilizar “var” e o compilador tenta inferir o tipo sempre que possível.

Outro lugar em que essa melhoria pode ser amplamente utilizada é nos métodos “TryParse” (por exemplo, int.TryParse, short.TryParse, etc). Veja o antes:

            int resultado;
            if (int.TryParse("5234", out resultado))
            {
                int valorFinal = resultado * 2;
                Console.WriteLine(valorFinal.ToString());
            }

E o depois:

            if (int.TryParse("5234", out var resultado))
            {
                int valorFinal = resultado * 2;
                Console.WriteLine(valorFinal.ToString());
            }

E quando queremos fazer um cast seguro (utilizando o operador “as“) e só prosseguir caso o cast tenha sido feito com sucesso?

            AlgumTipo valorConvertido = valorASerConvertido as AlgumTipo;
            if (valorConvertido != null)
            {
                // Faça alguma coisa com o valor convertido...
            }

Na nova versão, fica tudo dentro do próprio “if“:

            if ((var valorConvertido = valorASerConvertido as AlgumTipo) != null)
            {
                // Faça alguma coisa com o valor convertido...
            }

E, finalmente, algo que realmente não era possível até agora, e que na nova versão do C# será possível: utilizar funções com parâmetros de saída em cláusulas “select” de LINQ queries:

            var valores = new[] { "3", "5", "12" };
            var total = (from valor in valores
                        select int.TryParse(valor, out var valorConvertido) ? valorConvertido : 0).Sum();

E aí? Convencido que essa melhoria realmente vai ajudar um bocado a simplificar o nosso código de cada dia? Eu estou! Espero que vocês tenham gostado!

Até o próximo post!

André Lima

Problemas no modo apresentador do Visual Studio após instalar o ReSharper 8.1 Novidades do C# vNext – Primary Constructors