I tipi generici in C#

Benvenuto nella prima lezione sulle "Funzionalità avanzate di C#"! In questa lezione imparerà a conoscere i tipi generici, una potente funzionalità di C# che consente di creare codice flessibile e riutilizzabile. Iniziamo!

Cosa sono i tipi generici?

I tipi generici sono una funzionalità di C# che consente di definire classi, metodi e strutture dati con un segnaposto per il tipo di dati che memorizzano o utilizzano. I tipi generici consentono di garantire la sicurezza dei tipi e di riutilizzare il codice.

Esempio: Una lista generica (List<T>) può memorizzare elementi di qualsiasi tipo garantendo al contempo la sicurezza dei tipi.

Creazione di classi generiche

È possibile definire una classe generica utilizzando la sintassi <T>, dove T rappresenta un parametro di tipo. Esempio:

Punto chiave: Utilizzi i tipi generici per creare classi che funzionano con qualsiasi tipo di dati mantenendo la sicurezza dei tipi.

using System;

class GenericBox<T> {
    public T Value { get; set; }

    public void Display() {
        Console.WriteLine("Value: " + Value);
    }
}

class Program {
    static void Main() {
        GenericBox<int> intBox = new GenericBox<int> { Value = 42 };
        intBox.Display(); // Outputs: Value: 42

        GenericBox<string> stringBox = new GenericBox<string> { Value = "Hello, Generics!" };
        stringBox.Display(); // Outputs: Value: Hello, Generics!
    }
}

Creazione di metodi generici

È possibile definire un metodo generico all'interno di una classe. Esempio:

Suggerimento: Utilizzi i metodi generici per le operazioni applicabili a più tipi di dati.

using System;

class Program {
    static void Main() {
        PrintValue(42);
        PrintValue("Generics are powerful!");
    }

    static void PrintValue<T>(T value) {
        Console.WriteLine("Value: " + value);
    }
}

Vincoli dei tipi generici

I vincoli limitano i tipi che possono essere utilizzati come parametri di tipo. Esempio:

• where T : struct - T deve essere un tipo valore.
• where T : class - T deve essere un tipo riferimento.
• where T : new() - T deve avere un costruttore senza parametri.

Esempio:

Punto chiave: I vincoli rendono i tipi generici più flessibili e applicabili a scenari specifici.

using System;

class Program {
    static void Main() {
        DisplayDefault<int>();
        DisplayDefault<string>();
    }

    static void DisplayDefault<T>() where T : new() {
        T instance = new T();
        Console.WriteLine("Created instance of: " + typeof(T));
    }
}

Raccolte generiche

C# fornisce diverse raccolte generiche integrate:

• List<T>: Memorizza una raccolta di elementi in un array dinamico.
• Dictionary<TKey, TValue>: Memorizza coppie chiave-valore per ricerche rapide.
• Queue<T>: Implementa una struttura First In, First Out (FIFO).

Esempio: Utilizzo di una lista generica:

using System;
using System.Collections.Generic;

class Program {
    static void Main() {
        List<string> names = new List<string> { "Alice", "Bob", "Charlie" };
        names.Add("Diana");

        foreach (string name in names) {
            Console.WriteLine(name);
        }
    }
}

Esercizio pratico

Crei una classe generica Pair<TKey, TValue> che memorizzi una coppia chiave-valore e un metodo generico Swap() che scambi la chiave e il valore. Esempio:

using System;

class Pair<TKey, TValue> {
    public TKey Key { get; set; }
    public TValue Value { get; set; }

    public void Swap() {
        (Key, Value) = ((TKey)(object)Value, (TValue)(object)Key);
    }

    public void Display() {
        Console.WriteLine($"Key: {Key}, Value: {Value}");
    }
}

class Program {
    static void Main() {
        Pair<string, int> pair = new Pair<string, int> { Key = "Age", Value = 30 };
        pair.Display();
        pair.Swap();
        pair.Display();
    }
}

Buone pratiche per l'utilizzo dei tipi generici

Ecco alcune buone pratiche:

• Utilizzi i tipi generici per creare classi e metodi riutilizzabili e sicuri dal punto di vista dei tipi.
• Applichi i vincoli quando sono necessari requisiti specifici per i tipi.
• Preferisca le raccolte generiche a quelle non generiche per ottenere prestazioni e sicurezza migliori.

Suggerimento: Utilizzi nomi significativi per i parametri di tipo, come T per il tipo oppure TKey e TValue per le coppie chiave-valore.

Ottimo lavoro!

Congratulazioni! Ha imparato a utilizzare i tipi generici per creare codice riutilizzabile e flessibile in C#. Nella prossima lezione esploreremo la programmazione asincrona con async e await. Continuiamo a programmare!