C# 8.0 – Um preview de suas novas funcionalidades

Fala Galera,

Recentemente a Microsoft (Channel 9) publicou um vídeo com Mads Togersen e Seth Juarez no qual eles divulgaram algumas novas funcionalidades ainda em planejamento para a nova versão da linguagem C# que está se encaminhando para a versão 8.

Este vídeo pode ser visto através deste link

Vamos abordar aqui algumas dessas novas funcionalidades.

• Nullable references types
• Async Streams
• Async Dispose
• Default Interface Implementations
• Extension Everything

Nullable References Types

Essa nova funcionalidade tenta minimizar o erro por referencia nula. Na verdade o compilador do irá dar um warning avisando a possibilidade da geração dessa exceção.

Veja no exemplo abaixo:

string x = null; // 
string x2 = s.Length; // Aqui o compilador irá avisar sobre o erro

string? s = null;
if (s != null) //Compilador não irá avisar sobre o erro de null reference
    var y = s.Length; 

string? s1 = null;
if (!s.IsNullOrWhiteSpace())
    var z = s.Length; // Compilador irá avisar sobre o erro de null reference

string? s2 = null;
if (!s.IsNullOrWhiteSpace()) {
    // Compilador não irá avisar sobre o erro de null reference, aqui estamos     
    //dizendo assim, "eu sei que estou fazendo, não precisa avisar"
    var z1 = s!.Length; 
}

//Resumindo
string s = null;
s?.Length; // Pede para o compilador verificar se está nulo
s!.Length; // Fala para o compilador não verificar se está nulo e que você sabe o que está fazendo

 

Async Stream (async foreach)

Esta nova funcionalidade introduz o await no foreach. Async stream é o equivalente ao IEnumerable porém assíncrono.

IAsyncEnumerable<result> results = engine.GetAllAsync();

foreach await (var result in results) { // ... }

 

Async Dispose (async using)

Esta nova funcionalidade introduz o await no using no qual só podemos usar em objeto IDisposable

using await (var trans = conn.BeginTransaction())
{
    trans.Commit();
}

 

 Default Interface Implementations

Com a Default Interface Implementation, você pode definir implementações que fazem sobre escritas dentro da própria interface, meio estranho isso, já que podemos usar uma classe abstrata para isso e ainda fica bem estranho colocar detalhe de implementação em interface.

Veja no exemplo:

public interface ILogger
{
    void Log(LogLevel level, string message);

    void Info(LogLevel level, string format, params object[] arguments)
    {
        Log(level, string.Format(format, arguments));
    }

    void Debug(string message)
    {
        Log(LogLevel.Debug, message);
    }

    void Debug(string format, params object[] arguments)
    {
        Log(LogLevel.Debug, string.Format(format, arguments));
    }
}

 

Extension Everything

Uma mudança no modo de como declarar os métodos de extensão. Esse novo conceito possibilitaria estender operadores e propriedades de uma classe, não mudando o seu comportamento mais sim estendendo. Hoje só podemos estender métodos (“Extension Methods”)

extension CustomerExtension extends Customer
{
    public string CustomerType
    {
            get { return "Supermercado"; }
    }
        
        public string Name()
        {
             return this.Name; // Podemos usar propriedades de quem estamos estendendo neste o Customer
        } 
}

 

Por enquanto esses são algumas das novidades, lembrando que muita coisa pode mudar já que estão em fase de planejamento e aceitando opiniões da comunidade.

Caso queira saber mais informações podemos ver o milestone da linguagem no github atráves deste link https://github.com/dotnet/csharplang/milestone/8

Abs e até a próxima