C# 7: Tuplas, parâmetros, condicionais, e estilo de código | Alura Cursos Online
Primeiras aulas do curso C# 7: Tuplas, parâmetros, condicionais, e estilo de código
C# 7: Tuplas, parâmetros, condicionais, e estilo de código
Melhorias em Parâmetros - Introdução
Eu sou o Marcelo Oliveira. Bem-vindos ao nosso novo curso na Alura, curso de atualizações do Csharp. Vamos ver coisas legais que vieram com a versão 7.0, 7.1 e 7.2 da linguagem. Vamos começar vendo as melhorias em parâmetros, com as variáveis out. Você pode utilizar declaração de variáveis out na chamada de parâmetros out.
Também vamos ver locais e retornos de ref. Você vai ver que pode trabalhar com retorno de um método que vai retornar o endereço de memória, e você vai alterar diretamente essa memória. Também vamos ver como trabalhar com parâmetros in para fazer com que seu método não possa modificar o valor que está sendo passado como parâmetro. Veremos argumentos nomeados, que são uma maneira de passar argumentos, parâmetros dentro do método, trocando a ordem para ter mais flexibilidade.
Vamos ver as tuplas, que são uma forma de retornar múltiplos valores a partir de um método. Já tínhamos os parâmetros ref/out, o pair, class, struct e o tuple. Agora temos o valuetuple. Com esse novo valor, você pode retornar múltiplos retornos. Quando chama esse método, você pode obter como retorno a declaração de uma série de variáveis, assim não precisa ficar declarando uma classe para armazenar esses valores.
Também veremos os descartes, uma maneira de desprezar alguns valores dessa tupla quando você está declarando as variáveis. Vamos ver as melhorias em condicionais. Veremos um exemplo em que temos uma calculadora que vai calcular vários valores diferentes. Vamos pegar um código bem confuso e vamos utilizar correspondência de padrão para fazer conversão e declaração dessas variáveis utilizando uma sintaxe alternativa.
Também vamos ver as expressões throw, que são para lançamento de exceções. Tínhamos antes somente como utilizar o throw através de instrução. Podemos utilizar agora com Csharp7 o throw através de uma expressão. Também vamos ver na aula 4 literais e valores padrões.
Antes você tinha que declarar, por exemplo, valores que eram binários você não tinha como representar. Agora você tem a sintaxe utilizando o prefixo 0b para indicar que é uma representação em binário de um número inteiro. Você também vai ver o separador alternativo, que é o underscore e você pode colocar para visualizar melhor os números grandes na sua aplicação.
Vamos ver o método main async, que vai permitir que o seu método seja marcado com um operador async. Você tem como retornar um valor, fazer uma chamada assíncrona sem precisar esperar e obter o resultado. Também vamos ver expressão literal padrão. Você tinha como declarar de algumas formas o valor default utilizando a palavra default, e agora de maneira uniforme você pode utilizar para todo tipo de declaração. Ele vai obter o valor default para cada tipo de dado.
Vamos ver estilo de código, começando com funções locais. Antes não tinha como colocar um método dentro de outro no Csharp. Com o Csharp7 isso é possível através da função local. Você pode colocar dentro de um método principal e ela vai visualizar, enxergar o escopo do método principal, e não só os parâmetros, como também as variáveis que forem declaradas dentro do método principal.
Vamos ver mais membros com corpo de expressão. Você pode agora utilizar sintaxe de expressão no construtor, no finalizador, no get e no set das suas propriedades. E também vai ver o estilo de código. Temos o visual studio 2017, a opção de reforçar regras de estilo de código, se você quer ou não utilizar sintaxe de expressão e se você vai gerar um alerta, um erro, outro tipo de aviso quando a regra for violada. Você também vai ver como trabalhar com um arquivo de configuração de código para que toda sua equipe trabalhe sempre com o mesmo estilo, de maneira padronizada.
Espero que vocês gostem do curso. Não deixe de participar do fórum.
Melhorias em Parâmetros - Variáveis Out
Tudo bem com vocês? Eu sou o Marcelo Oliveira, bem-vindos a mais um curso na Alura. Nosso curso de atualizações Csharp. Vamos ver as novidades que foram introduzidas com as versões 7.0, 7.1 e 7.2 da linguagem Csharp. Vamos começar vendo as melhorias em parâmetros, começando pelas variáveis out. Mas primeiro vamos ter que trabalhar com código. Vamos colocar a mão na massa, e para isso quero que vocês baixem o arquivo zip de exemplo que contém as soluções necessárias para poder acompanhar esse curso. Dentro dele, vamos começar a trabalhar com o código e não precisar digitar tudo desde o começo.
Temos um projeto Csharp7, que é um console application, e dentro dele temos uma classe programa, que acompanha uma aplicação console. Esse programa vai exibir na tela um menu, em que cada item vai apresentar um pedaço da aula com novidades do Csharp7. Para cada aula, vamos apresentar uma pasta diferente. Vamos sempre preservar a pasta antes e alterar os arquivos da pasta depois, para poder comparar as versões.
Para começar, vamos criar variáveis out. Vamos abrir a pasta 01 e depois. Dentro temos o arquivo cliente.cs, com o código que vai sempre estar na classe chamada menuitem. Dentro dela, terá um método, chamado main, que vai ser chamado pelo menu principal para executar o código que vamos usar ao longo do curso. Ele vai abrir um arquivo de clientes. É separado por vírgulas. Chamamos de cliente.csv. Está como recurso do projeto. O programa vai interpretar cada um dos campos separados por vírgula para poder exibir na tela de forma amigável.
Esse programa vai rodar e para cada linha ele vai começar a interpretar, transformando em valores dentro de um array de strings. No final das contas, ele vai jogar esses valores dentro de uma instância de uma classe clientes. Ele transforma os valores em id, nome, telefone, endereço de cada cliente.
Para rodar esse código, vamos usar o F5, escolher a opção de menu número 1. Ele vai exibir duas partes. Na cor verde, o código referente ao programa que está na pasta antes, que é a versão antiga do Csharp. Em amarelo, vamos exibir o código após. Podemos comparar para ver se não teve nenhum problema.
Para falar de variável out, temos que relembrar os parâmetros. Um parâmetro out é um tipo que permite que o método retorne valores, não somente através do return, mas também através do parâmetro. Poderíamos até criar uma classe com parâmetros out, mas podemos simplesmente usar como exemplo métodos de conversão de valores de string para inteiro.
No código, a classe int expõe esse método, chamado tryParse. Ele vai tomar um valor de conversão, que vai ser aqui uma string. Vai ser o primeiro elemento de um array chamado campos. Esse array foi lido do arquivo csv. É aquela linha que foi lida. Ele pegou o primeiro elemento que vem antes da primeira linha. Ele tenta fazer o tryParse e converter para inteiro, fazendo isso através do out.
Antes da versão 7, tínhamos que declarar a variável que era passada para dentro de um método que toma um parâmetro out. temos a declaração da variável id em cima da linha anterior. Isso era necessário para passarmos um parâmetro como out. Declarávamos a variável e separávamos a declaração da utilização desse parâmetro out.
O que temos nessa versão do Csharp é uma facilidade de colocar a declaração dentro da própria utilização do parâmetro out. Ao invés de colocar int id igual a zero, posso eliminar essa linha e colocar out int id, declarando diretamente dentro da própria chamada do método. Roda sem nenhum problema.
Vimos uma pequena amostra das variáveis out. Como declaramos internamente, isso é uma declaração de variável. Ela pode ser declarada com o tipo definido, mas também podemos declarar com a palavra var. fazemos isso para obter uma inferência de tipos. Quando o compilador infere o tipo, ele descobre através do valor. Se colocarmos, por exemplo, var id igual a zero, ele vai fazer uma inferência, vai deduzir que estamos declarando uma variável inteira e vai utilizar essa dedução para poder armazenar o id como inteiro.
Da mesma forma, posso trocar out int id por out var id. Também vale. Roda sem problemas.
Agora, como será que o compilador do Csharp faz para gerar esse código internamente? Podemos abrir no browser um site chamado sharplab.io. Ele vai fazer uma compilação online do código para mostrar como o compilador gera o código internamente. Vou copiar o código da nossa classe, pegando só o que interessa, e vou colar dentro do método que ele traz.
O código que ele gerou criou na verdade uma variável para mim. Ele chamou de out num, que é o parâmetro out, e declarou numa linha antes como inteira. O que temos aqui é como o compilador trata internamente uma variável out. Ele simplesmente cria uma variável, mas não vemos isso porque ele traz o que chamamos de açúcar sintático, uma facilidade. É deixar a vida dos desenvolvedores mais doce.
Outra coisa que temos que mostrar com relação às variáveis é o escopo. Essa variável está declarada dentro da chamada do método tryParse. O que acontece se eu colocar essa instrução dentro de um if? Se ele retornar verdadeiro, significa que a conversão foi bem sucedida, e aí vai executar o código para exibir os dados do cliente.
Se eu declaro a variável na chamada TryParse dentro de um if, será que a variável é visível ou conseguimos utilizar também depois? Essa variável out também é visível fora do escopo do bloco if. Isso é importante para sabermos que podemos utilizar dentro da condição if, mas o escopo vaza para fora. Acabamos de ver como trabalhar com variáveis out utilizando o Csharp7.
Melhorias em Parâmetros - Locais e Retornos de Ref
Vamos ver agora outro recurso do Csharp7, que são os locais e retornos de ref, que é um tipo de recurso que foi adicionado ao Csharp7, mais indicado para quem busca melhor performances na hora de trabalhar com valores. Vamos abrir o visual studio, na aula 01, R02, temos a pasta depois com o menuitem.cs. Dentro temos o código que vai declarar a variável, que é um array de inteiros, em seguida vai inicializar esse array com valores fixos.
Temos os elementos, os valores inteiros fixos. Em seguida vamos pegar essa array e passar para o método para localizar um determinado elemento. Esse método é localizar índice. Como o nome diz, ele vai procurar aquele elemento dentro do array e vai retornar o índice desse elemento.
Estamos procurando o elemento doze. Ele está no índice quatro do nosso array. Em seguida, obtemos o índice e vamos fazer a modificação do elemento do array, números, através do índice que foi encontrado, e modificamos o elemento que está lá dentro por um valor. Vamos trocar o doze pelo menos doze e depois vamos imprimir no console o valor que está na posição de índice quatro, que inicialmente era o doze.
Essa é uma maneira de fazer a modificação de um elemento na array. Vimos o índice primeiro, modificamos a posição dentro da memória e trocamos o valor inteiro que estava lá dentro.
A partir do Csharp7 temos outra maneira de fazer esse tipo de alteração, porque até agora estávamos trabalhando simplesmente com valores. Posso fazer a mesma coisa trabalhando com referência. Vamos transformar em valor a partir de um método. Mas nesse caso, mesmo sendo inteiro, posso retornar uma referência para aquela posição da memória, aquele endereço onde está localizado o valor que estou retornando.
Vou simplesmente declarar o método com o modificador ref, de referência. Quando faço isso estou dizendo ao compilador que esse método vai retornar não o valor inteiro, mas a posição da memória que armazena aquele inteiro. Estamos trabalhando na verdade com o ponteiro de memória. Vamos ter que modificar o retorno do método localizar índice também por um return ref.
Agora que estou retornando uma referência para a nossa posição, não posso mais retornar o índice, então vou retornar diretamente número. Por isso vou renomear esse método para localizar número. Ao invés de retornar o i, que é o índice, vou retornar diretamente números índice i. É meu valor que foi encontrado. Só que como estou retornando com referência, vou retornar na verdade o endereço daquela posição dentro do array onde foi encontrado o valor.
Vamos fazer a modificação no nosso código. Trocando de int índice para int número. Também vou trocar a atribuição, que eu estava atribuindo menos doze para números índice. Agora vou modificar e atribuir para número, que é a variável que está sendo retornada.
Em seguida vamos imprimir, como fizemos antes. Não teve alteração na posição onde o elemento doze foi encontrado, então nosso código está errado. Também tenho que declarar minha variável local como ref, como referência. Só que quando faço isso o computador reclama porque ele exige que eu coloque antes também o modificador ref. Agora sim ele trocou.
Estamos acessando diretamente a memória daquela posição, daquele elemento dentro do array. Vamos olhar aquele site sharplab.io. Ele gera o localizar número, mas retorna na verdade uma coisa diferente, um unsafe int. O int significa um ponteiro para um valor inteiro. E o unsafe é o modificador que vai dizer que esse código não é gerenciado. Não usamos o unsafe normalmente no Csharp.
Internamente, o que o ref está fazendo é retornar um ponteiro para aquela posição na memória. Esse tipo de código é mais indicado para quando vai obter, está procurando mais performance nas aplicações, porque com isso você evita de passar valor. Acessa diretamente a memória daquela posição do array, como no caso que vimos.
Sobre o curso C# 7: Tuplas, parâmetros, condicionais, e estilo de código
O curso C# 7: Tuplas, parâmetros, condicionais, e estilo de código possui 152 minutos de vídeos, em um total de 57 atividades. Gostou? Conheça nossos outros cursos de .NET em Programação, ou leia nossos artigos de Programação.