Desde o seu lançamento, a linguagem C# tem evoluído a passos largos e, assim, seu uso por desenvolvedores de diversas áreas tem crescido.
A linguagem possui tantos recursos que muitas vezes usamos somente os mais comuns em nossa tarefa diária. Neste artigo, eu vou mostrar 5 recursos que a linguagem C# tem disponível que talvez você não conheça, mas que existem a partir da versão 6.0 da linguagem C#.
Todos os exemplos mostrados neste artigo foram testados no Visual Studio Community 2015 usando a versão 4.6 do .NET Framework.
Nota: para criar um projeto do tipo console no Visual Studio faça o seguinte:
- Abra o VS Community 2015 e clique em New Project;
- A seguir selecione Visual C# -> Console Application;
- Informe o nome do projeto e clique no botão OK.
Recursos usados:
-
Linguagem C# 6.0
1. Expression-bodied Function
Quantas vezes você teve que escrever um método de apenas uma linha de código?
Agora, com C# 6, você pode simplesmente criar um membro expression bodied contendo somente a expressão, sem usar as chaves {} ou ter um retorno explícito.
Antes, você só podia usar expressões lambdas em corpo de métodos que compunham uma classe. Agora, com as expressions bodied, é possível implementar métodos e propriedades somente de leitura a partir de expressões lambdas.
Para deixar claro o recurso, abaixo temos o código comparando a forma anterior e a forma usando expression-bodied:
C# 5.0
public class Item { public int Quantidade { get; set; } public double Preco { get; set; } public double Total { get { return Quantidade * Preco; } } }
C# 6.0
public class Item { public int Quantidade { get; set; } public double Preco { get; set; } public double Total => Quantidade * Preco; }
Exemplo de utilização:
class Program { static void Main(string[] args) { Item item = new Item(); item.Preco = 5.00; item.Quantidade = 15; Console.WriteLine(String.Format( "*** Item de Venda ***\n" + "Quantidade: {0}\nPreco: {1}\nValor Total: {2}", item.Quantidade, item.Preco, item.Total)); Console.ReadKey(); } }
Os membros de função das expression-bodied permitem que as propriedades, métodos, operadores e outros membros de função tenham corpos como expressões lambda (=>) ao invés de blocos de instrução, reduzindo assim a quantidade de código e dando uma visão mais claras sobre as expressões.
2. Operador Null Condicional
Nas versões anteriores da C#, você sempre tinha que escrever código para checar explicitamente a condição NULL antes de poder usar um objeto ou suas propriedades.
Da mesma forma que os tipos anuláveis (nullabe types), os operadores null-conditional podem ser usados para obter o mesmo resultado, bastando apenas usar o sinal ? depois da instância e antes de chamar a propriedade.
Dessa forma, a produtividade aumenta e a possibilidade de erros diminui.
Antes você fazia assim:
using System; namespace OperadorNullCondicional { class Program { static void Main(string[] args) { Funcionario funci = new Funcionario() { Nome = "Macoratti", Endereco = new Endereco() { Residencial = "Rua Projetada, 100", Trabalho = "Rua Peru, 300" } }; if (funci != null && funci.Endereco != null) { Console.WriteLine((funci.Nome) + " " + (funci.Endereco.Residencial ?? "Sem endereço")); } Console.ReadLine(); } } public class Funcionario { public string Nome { get; set; } public Endereco Endereco { get; set; } } public class Endereco { public string Residencial { get; set; } public string Trabalho { get; set; } } }
Agora, usando o recurso do operador Null Condicional(?) podemos fazer assim:
using static System.Console; namespace OperadorNullCondicional { class Program { static void Main(string[] args) { Funcionario funci = new Funcionario() { Nome = "Macoratti", Endereco = new Endereco() { Residencial = "Rua Projetada, 100", Trabalho = "Rua Peru, 300" } }; WriteLine((funci?.Nome) + " " + (funci?.Endereco?.Residencial ?? "Sem endereço")); ReadLine(); } } public class Funcionario { public string Nome { get; set; } public Endereco Endereco { get; set; } } public class Endereco { public string Residencial { get; set; } public string Trabalho { get; set; } } }
Assim, o operador verifica se a instância é null antes de chamar o método ou propriedade.
3. Inicializando auto propriedades e propriedades somente leitura a partir do construtor
Com C# 6.0, você pode inicializar as propriedades e propriedades somente de leitura a partir do construtor diretamente:
using static System.Console; using System; namespace InicialiarPropriedadesConstrutor { class Program { static void Main(string[] args) { Aluno aluno = new Aluno(); WriteLine("Nome " + aluno.Nome); WriteLine("Sobrenome " + aluno.SobreNome); WriteLine("Idade " + aluno.Idade); WriteLine("Registro " + aluno.DataRegistro); ReadLine(); } } public class Aluno { public string Nome { get; set; } = "Jose Carlos"; public string SobreNome { get; set; } = "Macoratti"; public int Idade = 45; public DateTime DataRegistro { get; } = DateTime.Now; } }
Resultado:
Menos código a digitar, menos erros a cometer.
4. Usando expressões lambdas para definir propriedades Get
Da mesma forma que usamos as expressões lambdas nas expression-bodied, a C# 6.0 permite que você utilize expressões lambdas para implementar o valor get de propriedades somente-leitura.
Sempre que uma expressão lambda for encontrada, o compilador C# a identifica como uma propriedade contendo somente o método get e não como um campo.
using static System.Console; using System.Linq; namespace ExpressaoLambda_Get { class Program { static void Main(string[] args) { Aluno aluno = new Aluno(); WriteLine("Nome Completo " + aluno.NomeCompleto); WriteLine("Nome Reverso " + aluno.NomeReverso); ReadLine(); } } public class Aluno { public string Nome { get; set; } = "Jose Carlos"; public string SobreNome { get; set; } = "Macoratti"; public string NomeCompleto => new string((Nome + " " + SobreNome).ToArray()); public string NomeReverso => new string(NomeReverso.Reverse().ToArray()); } }
Resultado:
Simplificando a codificação.
5. Usando diretivas com classes estáticas
Você já deve saber que pode importar um namespace ou espaços de nomes usando a cláusula using. Isso nos dá a capacidade de usar um tipo citando apenas o seu nome no código e sem a necessidade de qualificá-lo totalmente usando o seu namespace completo.
Agora, na C# 6, podemos ir um passo além, e importar os membros estáticos de uma classe para o nosso namespace. Isto significa que podemos usar os membros estáticos de uma classe diretamente, sem necessidade de qualificá-los com o seu espaço para nome ou nome do tipo.
A sintaxe é ‘using static’ seguido do tipo cujos métodos estáticos desejamos importar.
Assim, esse recurso permite que todos os membros estáticos acessíveis de um tipo sejam importados, tornando-os disponíveis sem ter que utilizar o namespace completo no código.
Nota: eu já usei esse recurso nos exemplos anteriores.
Exemplo de uso:
using static System.Console; using static System.Math; using static System.DayOfWeek; using static System.Linq.Enumerable; namespace Using_Static { class Program { static void Main(string[] args) { var numeros = Range(1, 10).ToArray(); WriteLine("A raiz quadrada de 4 é : " + Sqrt(4)); WriteLine(" 3 * 3 + 4 * 4 = " + Sqrt(3 * 3 + 4 * 4)); WriteLine("Sexta-Feira " + Friday + "Segunda-feira : " + Monday); foreach (int num in numeros) { WriteLine(num); } ReadLine(); } } }
Resultado:
Essas são apenas algumas das novidades da C# 6.0. Aguarde, em breve, outro artigo com mais novidades.
Pegue o projeto completo aqui: CSharp_6.zip