Genéricos em C#

Boas-vindas à primeira lição sobre "Recursos avançados do C#"! Nesta lição, você aprenderá sobre genéricos, um recurso avançado do C# que permite criar código flexível e reutilizável. Vamos começar!

O que são genéricos?

Genéricos são um recurso do C# que permite definir classes, métodos e estruturas de dados com um marcador de posição para o tipo de dados que armazenam ou usam. Os genéricos proporcionam segurança de tipos e reutilização de código.

Exemplo: uma lista genérica (List<T>) pode armazenar elementos de qualquer tipo, garantindo a segurança de tipos.

Criando classes genéricas

Você pode definir uma classe genérica usando a sintaxe <T>, em que T representa um parâmetro de tipo. Exemplo:

Ponto principal: use genéricos para criar classes que funcionem com qualquer tipo de dados, mantendo a segurança de tipos.

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!
    }
}

Criando métodos genéricos

Você pode definir um método genérico dentro de uma classe. Exemplo:

Dica: use métodos genéricos para operações aplicáveis a vários tipos de dados.

using System;

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

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

Restrições de genéricos

As restrições limitam os tipos que podem ser usados como parâmetros de tipo. Exemplo:

• where T : struct - T deve ser um tipo de valor.
• where T : class - T deve ser um tipo de referência.
• where T : new() - T deve ter um construtor sem parâmetros.

Exemplo:

Ponto principal: as restrições tornam os genéricos mais flexíveis e aplicáveis a cenários específicos.

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));
    }
}

Coleções genéricas

O C# fornece várias coleções genéricas integradas:

• List<T>: armazena uma coleção de elementos em um vetor dinâmico.
• Dictionary<TKey, TValue>: armazena pares chave-valor para consultas rápidas.
• Queue<T>: implementa uma estrutura Primeiro a Entrar, Primeiro a Sair (FIFO).

Exemplo: usando uma lista genérica:

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);
        }
    }
}

Desafio prático

Crie uma classe genérica Pair<TKey, TValue> que armazene um par chave-valor e um método genérico Swap() que troque a chave e o valor. Exemplo:

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();
    }
}

Práticas recomendadas para usar genéricos

Estas são algumas práticas recomendadas:

• Use genéricos para criar classes e métodos reutilizáveis e seguros quanto aos tipos.
• Aplique restrições quando forem necessários requisitos específicos de tipo.
• Prefira coleções genéricas a coleções não genéricas para obter mais desempenho e segurança.

Dica: use nomes significativos para os parâmetros de tipo, como T para tipo ou TKey e TValue para pares chave-valor.

Ótimo trabalho!

Parabéns! Você aprendeu a usar genéricos para criar código reutilizável e flexível em C#. Na próxima lição, exploraremos a programação assíncrona com async e await. Vamos continuar programando!