C# 10 – Le prime 5 nuove caratteristiche della nuova versione per Visual Studio 2022

C# è ufficialmente uscito nel gennaio 2002 e quindi tra qualche mese potremo festeggiare il 20° compleanno di questo linguaggio di programmazione. Nell’attesa, sappiamo già che ci sarà una nuova versione, precisamente la decima. C# 10, insieme a Visual Studio 2022 e a .NET 6, è atteso verso novembre 2021. A vedere alcune fonti ufficiali e il blog del team di sviluppo sembra che ci saranno parecchie novità.

Questo può essere un po’ traumatizzante per tutto quello che bisogna imparare, ma seguendo un po’ le notizie che via via vengono pubblicate si possono trovare parecchie notizie interessanti. In particolare questa è una selezione delle 5 nuove caratteristiche che ci saranno nella nuova versione di C#:

  1. Null Parameter Checking
  2. Required Properties
  3. Field Keyword
  4. Global Usings
  5. File Namespaces

1. Null Parameter Checking (Controllo dei parametri nulli)

La Null Reference Exception è uno dei peggiori bug che potete avere nel vostro codice. Per proteggersi da questo tipo di eccezioni, è necessaria una progettazione a prova di bomba dell’applicazione e un sacco di controlli sui parametri delle funzioni. Questa nuova caratteristica dovrebbe aiutarci a prevenire questo problema e rendere il nostro codice più leggibile e robusto.

1.1 Problema attuale

Al momento se volete controllare che un certo parametro della vostra funzione sia nullo, dovreste fare qualcosa del genere

public SomeFunction(int id, SomeClass newObject)
{
  if (newObject == null)
  {
    throw new ArgumentNullException("newObject");
  }
  ...
}

In questo codice iniettiamo newObject di SomeClass in SomeFunction. Se l’oggetto menzionato è nullo non dovremmo procedere con il codice. Molte persone diranno che con la corretta progettazione dell’applicazione questo problema non dovrebbe esistere, ma a volte è necessario farlo.

1.2 Caratteristica di C# 10

La nuova versione di C# mira a semplificarci questo problema con: !!. Tutto quello che dovete fare è aggiungere due punti esclamativi (che vengono chiamati “Bang bang“) dopo il nome del parametro:

public SomeFunction(int id, SomeClass newObject!!)
{
	...
}

In questo esempio, il codice controllerà automaticamente se newObject è nullo. La ArgumentNullException sarà automaticamente lanciata se il valore newObject è nullo.

2. Required Properties (Proprietà richieste)

I costruttori non erano usati più esplicitamente in passato? Oggi non scriviamo costruttori pesanti, il più delle volte usiamo costruttori leggeri, cioè definiamo direttamente i valori delle proprietà.

2.1 Problema attuale

Da un paio di versioni di C#, possiamo creare oggetti usando costruttori leggeri come questo:

var newArticle = new Article
{
	Title = "C# 10 - Top 5 new features",
	Category = ".NET",
	ReleaseDate = DateTime.Now()
}

Il problema principale con questo approccio è che a volte abbiamo bisogno di inizializzare qualche proprietà e non lo facciamo. Per esempio, potremmo fare qualcosa del genere, anche se non ha senso creare un oggetto Article senza un titolo:

2.2 Caratteristica di C# 10

C#10 introduce una nuova parola chiave per le proprietà: required. In questo modo, quando si definisce una classe, possiamo rendere una proprietà obbligatoria. Se provi a creare un oggetto senza la proprietà required otterrai un errore in fase di compilazione.

public class Article
{
  public required string Title { get; init; }
  public string Category { get; init; }
  public DateTime ReleaseDate{ get; init; }
}


3. Field Keyword (Parola chiave di campo)

Le proprietà autoimplementate non sono una nuova caratteristica, infatti, sono apparse per la prima volta in C# 3. Questo significa che quando il codice viene compilato il compilatore crea un campo privato, anonimo, che può essere accessibile solo attraverso gli accessor get e set della proprietà.

Una delle caratteristiche interessanti che è arrivata con l’attuale versione di C# è un accessor init. Con questo accessor, gli oggetti immutabili sono più flessibili e permettono al chiamante di mutare i membri durante l’atto della costruzione.

3.1 Problema attuale

Tutto questo è ottimo, ma quando questo approccio non si adatta al vostro problema siete costretti ad aggiungere un campo e a scrivere i soliti metodi di proprietà. Qualcosa del genere:

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

      _title = value;
    }
  }
}


3.2 Caratteristica di C# 10

La nuova versione del linguaggio di programmazione C# introduce un’altra nuova parola chiave: field. Il codice di cui sopra può ora essere semplificato:

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

In sostanza, da C# 10 non ci sarà bisogno di implementare un campo aggiuntivo. Questa parola chiave può anche essere usata nell’accessor init:

public class Article
{
  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(); }
}


4. Global Using (Using globali)

Questa è una nuova caratteristica che semplificherà molto il codice. Come sapete, ogni file C# inizia con una lista di “using” che sono necessari per l’implementazione. Tuttavia, a volte questo è ridondante, specialmente se state lavorando con ASP.NET molto di questo codice è ripetuto e in generale è solo “rumore” per i programmatori.

4.1 Problema attuale

Se prendiamo per esempio un file ASP.NET, l’elenco degli usi è enorme:

using Microsoft.AspNetCore.Builder;
using Microsoft.AspNetCore.Hosting;
using Microsoft.AspNetCore.HttpsPolicy;
using Microsoft.AspNetCore.Identity;
using Microsoft.AspNetCore.Identity.UI;
using Microsoft.EntityFrameworkCore;
using Microsoft.Extensions.Configuration;
using Microsoft.Extensions.DependencyInjection;
using Microsoft.Extensions.Hosting;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Threading.Tasks;


4.2 Caratteristica di C# 10

Un’altra parola chiave che C# 10 introduce è global. Usando global, sarete in grado di definire using globali per l’intero progetto. In generale, si raccomanda di creare un file separato che conterrà queste importazioni, qualcosa come usings.cs. Questo significa che gli altri file del progetto possono essere semplificati poiché non hanno più bisogno di aggiungere tutti questi using. I progettisti C# si riferiscono a questo come all’eliminazione degli “sprechi (di spazio) verticali”.

global using Microsoft.AspNetCore.Builder;
global using Microsoft.AspNetCore.Hosting;
global using Microsoft.AspNetCore.HttpsPolicy;
global using Microsoft.AspNetCore.Identity;
global using Microsoft.AspNetCore.Identity.UI;
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;

5. File Namespaces (Spazi dei nomi dei file)

Usando la parola chiave global C# elimina lo “spreco verticale” e con gli spazi dei nomi dei file elimina lo “spreco orizzontale”. Fondamentalmente, questa caratteristica mira a risolvere il problema dell’indentazione ed è più di un cambiamento cosmetico: si spera che questo possa rendere il codice più pulito.

5.1 Problema attuale

Al giorno d’oggi, dopo la lista degli using, la prima cosa che si vede in un file C# è la definizione del namespace. Dopo di che viene la definizione della classe. L’implementazione della classe è già indentata a questo punto. Questo è ciò che consideriamo uno “spreco orizzontale”.

namespace Blog
{
  public class Article
  {
    ...
  }
}


5.2 Caratteristica C# 10

Con questa caratteristica potete definire il namespace a livello di file in questo modo:

namespace Blog;

public class Article
{
  ...
}

Conclusione

In questo articolo, abbiamo avuto la possibilità di familiarizzare con 5 nuove caratteristiche che la nuova versione di C# porterà. Alcune di esse sembrano un grande miglioramento e sembra che influenzeranno il modo in cui organizziamo e scriviamo i progetti C#.

Rispondi

Inserisci i tuoi dati qui sotto o clicca su un'icona per effettuare l'accesso:

Logo di WordPress.com

Stai commentando usando il tuo account WordPress.com. Chiudi sessione /  Modifica )

Google photo

Stai commentando usando il tuo account Google. Chiudi sessione /  Modifica )

Foto Twitter

Stai commentando usando il tuo account Twitter. Chiudi sessione /  Modifica )

Foto di Facebook

Stai commentando usando il tuo account Facebook. Chiudi sessione /  Modifica )

Connessione a %s...

Questo sito utilizza Akismet per ridurre lo spam. Scopri come vengono elaborati i dati derivati dai commenti.