C#10 e ASP.NET 6, oque esperar dessa dupla?
Tags: csharp, programming, vaivoa, net6
Published: 2021-11-04 20:15:43

A Microsoft já anunciou que o lançamento do .Net6 está previsto para novembro de 2021, ou seja, para o próximo mês (ebaaa! 😊), pretendendo lançar uma nova versão todo ano nesta mesma data, como pode ser observado no cronograma abaixo.

![Cronograma de lançamento .Net](https://dev-to-uploads.s3.amazonaws.com/uploads/articles/dc4d2eze7a85zt901ly8.png)

Por conta dessa constante inovação da plataforma a empresa tende a realizar "poucas mudanças" e continuar com o suporte LTS de três anos, possibilitando migrações continuas de seus usuários para as novas atualizações de maneira mais fácil.

> Mais informações: [Microsoft: Política de suporte .NET](https://dotnet.microsoft.com/platform/support/policy/dotnet-core)

### > Ok, mas cadê as novidades? 🤔

Alguns dos principais pontos que chegaram com a nova versão estão elencados aqui, caso queria se aprofundar no assunto recomendo visualizar as postagens do `Daniel Roth` dentro do portal da Microsoft.

> Documentação e Posts sobre atualizações: [Daniel Roth](https://devblogs.microsoft.com/aspnet/author/danroth27/)

<img width="100%" style="width:100%" src="https://media.giphy.com/media/3o7TKUM3IgJBX2as9O/giphy.gif">

* **Minimal Api/hosting**: Está é a grande novidade que vai facilitar em muito a construção de pequenos Endpoints e melhorar a performance em geral do _warm-up_ (tempo de "aquecimento") para as Apis, esse ponto foi levado em consideração pela Microsoft pelo fato do BOOM do Serverless + functions que necessitam de um desempenho de inicialização maior. A Startup.cs "Morreu" 😥 e agora o Program.cs "faz tudo", sendo possível desenvolver apenas com ele, sim, com cara de Node.Js. Segue exemplo dos novos endpoints:

> Github com exemplo de uso: [DamianEdwards/MinimalApiPlayground](https://github.com/DamianEdwards/MinimalApiPlayground/blob/main/src/Todo.Dapper/Program.cs)

```

using System.ComponentModel.DataAnnotations;
using Microsoft.Data.Sqlite;
using Dapper;
 
var builder = WebApplication.CreateBuilder(args);
 
var connectionString = builder.Configuration.GetConnectionString("TodoDb") ?? "Data Source=todos.db";
builder.Services.AddScoped(_ => new SqliteConnection(connectionString));
builder.Services.AddEndpointsApiExplorer();
builder.Services.AddSwaggerGen();
 
var app = builder.Build();

app.MapPut("/todos/{id}/mark-incomplete", async (int id, SqliteConnection db) =>
    await db.ExecuteAsync("UPDATE Todos SET IsComplete = false WHERE Id = @Id", new { id }) == 1
        ? Results.NoContent()
        : Results.NotFound())
    .WithName("MarkIncomplete")
    .Produces(StatusCodes.Status204NoContent)
    .Produces(StatusCodes.Status404NotFound);

app.MapDelete("/todos/{id}", async (int id, SqliteConnection db) =>
    await db.ExecuteAsync("DELETE FROM Todos WHERE Id = @id", new { id }) == 1
        ? Results.NoContent()
        : Results.NotFound())
    .WithName("DeleteTodo")
    .Produces(StatusCodes.Status204NoContent)
    .Produces(StatusCodes.Status404NotFound);
```

* **MiniValidator / Metadata**: Com a chegada do conceito de Minimal Api o .Net6 também traz uma validação mais enxuta e performática, a biblioteca MiniValidator é uma versão minimalista dos DataAnnotations que adiciona suporte para as chamadas de validação de linha única e recursão com detecção de ciclo. E para fechar a concepção de Minimal foi desenvolvida diversas Metadatas para facilitar a documentação e estruturação dos novos recursos, como demostrado no exemplo a seguir.

```
app.MapPost("/todos", async (Todo todo, SqliteConnection db) =>
    {
            //Realiza a validação da DTO
        if (!MiniValidator.TryValidate(todo, out var errors))
            return Results.ValidationProblem(errors); 

        var newTodo = await db.QuerySingleAsync<Todo>(
            "INSERT INTO Todos(Title, IsComplete) Values(@Title, @IsComplete) RETURNING * ", todo);

        return Results.Created($"/todos/{newTodo.Id}", newTodo);
    })
    .WithName("CreateTodo") //Define nome para o endpoint
    .ProducesValidationProblem()
    .Produces<Todo>(StatusCodes.Status201Created) // Documenta o retorno;
```

* **Suporte a HTTP/3**: A Microsoft já introduziu nativamente o suporte a nova versão do nosso conhecido e querido protocolo de transferência, que por sua vez promete manter os padrões atuais e atribuir mais desempenho por meio do uso QUIC, visando tirar o bloqueio das transações em paralelo quando um pacote era "perdido".

> Mais informações: [HTTP/3 Support in .NET 6](https://devblogs.microsoft.com/dotnet/http-3-support-in-dotnet-6/)

* **Hot Reload**: Este é um recurso muito bacana para nós desenvolvedores pois permite atualizar o código em tempo real sem perder o estado da aplicação, auxiliando em muito as validações UI e funcionando também com o `dotnet watch run` no VSCode, já para o Visual Studio basta clicar sobre o ícone de "Fogo 🔥" na parte superior depois de realizar alguma mudança.

> Mais informações: [Introducing the .NET Hot Reload experience for editing code at runtime](https://devblogs.microsoft.com/dotnet/introducing-net-hot-reload/)

* **Blazor / .NET MAUI / SPA**: A nova sensação do front que virá com o .Net6 é o MAUI que tem o foco em criar Apps com visuais mais modernos e compartilhando mais código entre as plataformas, ao longo do tempo ele será compatível com macOS e Windows, mas no momento o suporte é para Android e iOS. Também é importante mencionar a chegada da biblioteca ´Xamarin.Essentials´ que possibilita acessar recursos nativos dos dispositivos, como sensores, armazenamentos e afins. Já para o SPA agora é possível separar o front-end do back-end em dois projetos e foi acrescentado o ecossistema de estruturas JavaScript SPA no Visual Studio, com teste de unidade, gerenciamento de GUI npm, modelos baseados em CLI e mais novidades a serem anunciadas.

> Mais informações: [ASP.NET Core updates in .NET 6 Release](https://devblogs.microsoft.com/aspnet/asp-net-core-updates-in-net-6-rc-2/)

* **Using Global**: Sim, ISSO MESMO!!🥳 Agora é possível definir usings globalmente, basta acrescentar a palavra global antes de declarar o using, muito útil quando usado em conjunto com arquivos de configuração geral da aplicação, permitindo que todos os outros arquivos possuam acesso aos usings.

```
global using System;
global using System.Collections.Generic;
global using System.IO;
global using System.Linq;
```

<img width="100%" style="width:100%" src="https://media.giphy.com/media/13hxeOYjoTWtK8/giphy.gif">

* **File-scoped namespace declaration**: Agora é possível declarar os namespaces de sua aplicação sem abrir e fechar as chaves, basta colocar um ; (ponto e virgula) no final, como no exemplo abaixo.

```
namespace MyNamespace;
```

* **Extended property patterns**: O novo C#10 já está apto para trabalhar com  referência a propriedades ou campos aninhados em uma propriedade, como pode ser visto abaixo.

```
{ Prop1: { Prop2: pattern } } // Antiga maneira
{ Prop1.Prop2: pattern } // Nova maneira
```

* **LINQ / CHUCK / MetodosBy**: Chegou também melhorias para os métodos OrDefault do Linq e afins, agora sendo possível definir no próprio método um valor default, um ponto muito interessante foi a vinda do IEnumerable Chunk para facilitar a paginação e manipulação de dados, em conjunto com diversos métodos *By para utilização de listas.

```
var list = Enumerable.Range(1, 100);
foreach(var chunk in list.Chunk(10))
  foreach(var item in chunk) 
    Console.WriteLine(item);

var foundValue = hayStack.FirstOrDefault(x => x == needle, -1);

Console.Write(people.MaxBy(x => x.Age));
```

> Mais informações: [.NET 6 / C# 10 Top New Features Recap](https://dotnetcoretutorials.com/2021/09/23/net-6-c-10-top-new-features-recap/)

### > Legal, mas existe algo para chegar ainda?

<img width="100%" style="width:100%" src="https://media.giphy.com/media/l0HlRnAWXxn0MhKLK/giphy.gif">

A Microsoft sempre tem projetos "escondidos" que estão sendo trabalhados por baixo dos panos para criar grandes mudanças na sua plataforma, aqui citarei dois desses projetos que estão sendo desenvolvidos para as próximas versões do .Net, o Houdini e o Bedrock.

* **Projeto Houdini**: A Microsoft quer modificar a sua Stack para deixa-la mais performática, e esse projeto vem com tudo para cima do MVC, com foco em ACABAR com ele, e tirar todo o peso que seus componentes geram para as Apis e afins.

> Mais informações: [The .NET Stacks, #28: The future of MVC and themes of .NET 6](https://www.daveabrock.com/2020/12/05/dotnet-stacks-28/)

* **Projeto BedRock**: Visando novamente a alta performance da plataforma, esse projeto tem o intuito de abstrair toda a camada de comunicação cliente-server, de forma que o .Net vai verificar as opções disponíveis e escolher a melhor forma de realizar essa troca de dados dependendo do ambiente e da situação. Esse projeto possui três pilares (transporte, middleware e protocolo) e será usado pelo IConnectionFactory e IConnectionListener.

> Mais informações: [BedrockFramework](https://github.com/davidfowl/BedrockFramework)

### > Por enquanto é isso, obrigado! ✌️

<img width="100%" style="width:100%" src="https://media.giphy.com/media/AeWoyE3ZT90YM/giphy.gif">

Qualquer dúvida pode me chamar para um bate-papo, e agradeço a sua atenção até aqui, espero te ver em outras publicações.

{% user lucastmp %}



.
![Linha Horizontal](https://dev-to-uploads.s3.amazonaws.com/uploads/articles/cz1xbk1xbzlg8kyfy6ri.png)

# Disclaimer

A VaiVoa incentiva seus Desenvolvedores em seu processo de crescimento e aceleração técnica. Os artigos publicados não traduzem a opinião da VaiVoa. A publicação obedece ao propósito de estimular o debate.

![logo vaivoa](https://dev-to-uploads.s3.amazonaws.com/uploads/articles/1wmziqv74ghhgyi9p0om.png)