C# - Usando Generics (revisitado)  - I


 Neste artigo vamos rever o conceito de Generics e aplicar esses conceitos criando uma classe genérica.

O recurso Generics é uma maneira inteligente para definir tipos genéricos especiais (classes ou estruturas) do tipo seguro sem ter que se comprometer com um tipo específico de dados em tempo de projeto.  Ele pode ser visto como um template de tipos, onde alguns tipos usados em sua classe são preenchidos quando a classe é usada, não quando a classe é definida.

Abaixo segue os links sobre Generics que eu já publiquei:

Assim em um momento você vai precisar de uma lista de inteiros ou de strings e em outro momento você vai precisar de uma lista de objetos de um tipo como Pessoas, Clientes, Produtos, etc.

Podemos definir nossas próprias classes que usam Generics colocando o tipo genérico entre os símbolos <> , assim: <T> logo após a definição da classe.
Ex: public class ListaTarefas<T>() { }

Então para praticar vamos criar o nosso próprio tipo usando Generics.

Recursos Usados:

Criando seu próprio tipo Genérico

Abra o VS 2017 Community e crie um projeto do tipo Console Application com o nome chsp_Generics.

Vamos definir uma classe genérica conforme o código abaixo:

using static System.Console;
namespace cshp_Generics
{
    class ClasseGenerica<T>
    {
        T a;
        public ClasseGenerica(T x)
        {
            a = x;
        }
        public void ExibeValor()
        {
            WriteLine($"Valor do parâmetro é : {a}");
        }
        public void ExibeTipo()
        {
            WriteLine($"Tipo de T é : {typeof(T)} ");
        }
    }   
}

Observe que criamos uma classe normal com exceção que a nossa classe possui o tipo genérico <T> definido o que permite usar os recursos Generics. Usei a letra T mas poderia ter usado qualquer letra.

Agora este tipo pode ser usado para retornar tipos, tipos de parâmetros de métodos, tipos de variáveis de instância, tipos de propriedades.

Nota: Estou usando os recursos using static e a interpolação de strings ($) no código.

Como T é um tipo genérico nossa classe poderá tratar inteiros, strings, objetos , etc.

A seguir defini um construtor para receber um valor do tipo e dois métodos para exibir o valor do parâmetro e o tipo usado na classe.

Vamos agora usar essa classe concluindo o código conforme abaixo:

using static System.Console;
namespace cshp_Generics
{
    class ClasseGenerica<T>
    {
        T a;
        public ClasseGenerica(T x)
        {
            a = x;
        }
        public void ExibeValor()
        {
            WriteLine($"Valor do parâmetro é : {a}");
        }
        public void ExibeTipo()
        {
            WriteLine($"Tipo de T é : {typeof(T)} ");
        }
    }
    class Program
    {
        static void Main(string[] args)
        {
            ClasseGenerica<int> t1 = new ClasseGenerica<int>(999);
            t1.ExibeValor();
            t1.ExibeTipo();
            WriteLine("-------------------------------");
            ClasseGenerica<string> t2 = new ClasseGenerica<string>("Macoratti");
            t2.ExibeValor();
            t2.ExibeTipo();
            ReadLine();
        }
    }
}

Eu poderia ter usado mais de um tipo na definição da classe. Algo assim:

using static System.Console;
namespace cshp_Generics
{
    class ClasseGenerica<T1,T2 >
    {
        T1 a;
        T2 b;
        public ClasseGenerica(T1 x, T2 y)
        {
            a = x;
            b= y;
        }
        public void ExibeValor()
        {
            WriteLine($"Valor dos parâmetros é : {a} e {b}");
        }
        public void ExibeTipo()
        {
            WriteLine($"Tipos T1 e T2 : {typeof(T1)} e {typeof(T2)}");
        }
    }   
}

Para mostrar a nova classe funcionando usamos o código abaixo:

class Program
    {
        static void Main(string[] args)
        {
            ClasseGenerica<int,string> t1 = new ClasseGenerica<int,string>(999,"Macoratti");
            t1.ExibeValor();
            t1.ExibeTipo();
            WriteLine("-------------------------------");
            ClasseGenerica<string,string> t2 = new ClasseGenerica<string,string>("Macoratti","Visual C#");
            t2.ExibeValor();
            t2.ExibeTipo();
            ReadLine();
        }
    }

 

Percebeu que podemos usar vários tipos que poderão tratar diferentes tipos de informações. (É óbvio que para muitos items de tipos devemos usar uma lista)

Na próxima parte do artigo vou criar uma outra classe genérica mais elaborada e continuar mostrando os recursos do Generics.

Portanto, quer comais quer bebais, ou façais outra qualquer coisa, fazei tudo para glória de Deus.
 1 Coríntios 10:31

Veja os Destaques e novidades do SUPER DVD Visual Basic (sempre atualizado) : clique e confira !

Quer migrar para o VB .NET ?

Quer aprender C# ??

Quer aprender os conceitos da Programação Orientada a objetos ?

Quer aprender o gerar relatórios com o ReportViewer no VS 2013 ?

Referências:


José Carlos Macoratti