Neste artigo, vamos analisar os mais novos recursos que estão sendo adicionados às linguagens de programação C# para dar aos desenvolvedores uma ideia melhor de como seu desenvolvimento de software será afetado.

Novos recursos em C# 10

No momento da redação, a lista a seguir mostra os novos recursos que os desenvolvedores podem esperar em C# 10. Eles são os seguintes: Parâmetro nulo verificando propriedades necessárias Palavra-chave global usando namespaces de arquivo

Vamos entrar em mais detalhes sobre cada recurso C# sharp para entender melhor as mudanças na linguagem .

Verificação de parâmetro nulo em C# 10

O infame erro : “Referência de objeto não definido para uma instância de um objeto” é um daqueles erros que podem ser bastante difíceis de antecipar e manusear. Este erro é um NullReferenceException, o que significa que quando você tenta acessar um membro, método ou propriedade que contém um valor nulo, a mensagem acima é lançada.

É aí que o novo recurso Verificação de Parâmetros Nulos pode nos ajudar tornando nosso código mais robusto e mais facilmente evitando (e manipulando) tais erros..

Atualmente, se quisermos verificar se há uma referência nula, precisaremos escrever código semelhante ao seguinte bloco de código C#:

public FunctionName(int Age, ClassName newClassNameObject)
{
  if (newClassNameObject == null)
  {
    throw new ArgumentNullException("newClassNameObject");
  }
}

No código acima, temos uma função com dois parâmetros: um inteiro de idade e um objeto (newClassNameObject) de uma classe chamada (ClassName). Começamos verificando se esse objeto de classe é nulo para lançar o ArgumentNullException. Se não fizermos uma verificação e o novoClassNameObject for nulo, ocorreria um NullreferenceException.

Com os novos recursos de C# 10, tudo o que você precisa fazer para verificar se um objeto é nulo é adicionar dois pontos de exclamação ao lado do objeto que deseja testar. Aqui está o mesmo exemplo, mas com os recursos recém-adicionados do C# 10 implementados:

public FunctionName(int Age, ClassName newClassNameObject!!)
{

}

Aqui, o novoClassnameObject é testado automaticamente para nulo, e o AgrumentNullException será automaticamente lançado se for nulo.

Propriedades Necessárias em C# 10

Como o nome indica, este novo recurso nos permite definir as propriedades necessárias. Isso significa que sempre que criamos um objeto, podemos garantir que algumas propriedades devem ser sempre definidas. Aqui está um exemplo mostrar o método antigo:

var newSong = new Song
{
	Title = "Spread Your Wings",
	Artist = "Queen",
	ReleaseDate =1997
}

Não há nada de errado com o exemplo acima, mas vamos dar um passo adiante:

Vamos adicionar o seguinte código:

var newSong = new Song
{
	Artist = "Queen",
	ReleaseDate =1997
}

Aqui, omitimos o Título,o que é aceitável, mas não muito correto. É aqui que o novo recurso de C#, Required Properties, vem para o resgate. Vamos pegar o mesmo exemplo e reescrever sua definição de classe em C# 10:

public class Song
{
  public required string Title { get; init; }
  public string Artist { get; init; }
  public DateTime ReleaseDate { get; init; }
}

Adicionando a bandeira necessária, garantimos que um Título sempre tem que ser inserido.

Palavra-chave de campo e acessórios init em C

C# 10 apresenta uma nova palavra-chave chamada field, juntamente com outro novo recurso chamado init acessórios. Essas duas adições permitem que objetos imutáveis sejam mais flexíveis e permitam que o chamador mute membros durante a construção. Vamos dar uma olhada em um exemplo C# mais antigo:


public class Song
{
  private string _title;
  public string Title
  {
    get
    {
      return _title;
    }
    set
    {
      if (value.Trim() == "")
        throw new ArgumentException("Title can't be empty");

      _title = value;
    }
  }
}

Neste exemplo, adicionamos o campo de apoio e somos forçados a escrever os métodos usuais relativos a essa adição. No entanto, em C# 10 podemos reescrever este mesmo exemplo da seguinte maneira:

public class Song
{
  public string Title
  {
    get;
    set
    {
      if (value.Trim() == "")
        throw new ArgumentException("Title can't be empty");
      field = value;
    }
  }
}

Nesta versão, não há necessidade de implementar camposde apoio . Aqui está outro exemplo C# 10, desta vez usando o acessório init:

public class Song
{
  public string Title
  {
    get;
    set
    {
      if (value.Trim() == "")
        throw new ArgumentException("Title can't be empty");
      field = value;
    }
  }

  public string Category { get; init; }
  public DateTime ReleaseDate{ get; init => field = value.Date(); }
}

Usos globais em C# 10

Cada arquivo C# geralmente tem um monte de usos associados a ele. Os usos são necessários para importar os recursos necessários para um arquivo, mas às vezes eles podem se tornar redundantes e adicionar ruídos desnecessários ao seu código.

Felizmente, o C# 10 introduz um novo recurso chamado Global Usings, onde, com a ajuda da palavra-chave global, você pode definir usos globais para todo o projeto! Você pode simplesmente configurar um arquivo chamado usos.cs, por exemplo, e adicionar todos os usos lá. Aqui está um exemplo mostrando essa prática:

global using Microsoft.AspNetCore.Builder;
global using Microsoft.AspNetCore.Hosting;
global using Microsoft.EntityFrameworkCore;
global using Microsoft.Extensions.Configuration;
global using Microsoft.Extensions.DependencyInjection;
global using Microsoft.Extensions.Hosting;
global using System;
global using System.Collections.Generic;
global using System.Linq;
global using System.Threading.Tasks;
These usings will be available for the entire project.

Espaços de nome do arquivo em C# 10

A adição de Namespaces de arquivo em C# 10 é mais uma mudança cosmética, adicionada para eliminar resíduos horizontais. Aqui está o método atual para definir uma classe em C#:

namespace Music
{
  	public class Song
  	{
	 }
}

Em C# 10 você define o namespace no nível do arquivo e pareceria:

namespace Music;
public class Song
{
}

Autor: Hannes DuPreez

Artigo Original