Utilizando um Tipo T como parâmetro e recuperando seus valores

Nesse artigo veremos como utilizar T como parâmetro e recuperar valores por reflection.

por Alexandre Minato

Eu gosto muito de soluções genéricas e por isso abuso do tipo <T>. Para quem não conhece T é um tipo genérico, pois, hoje quando criamos um método precisamos informar qual é o tipo do parâmetro, por exemplo:

public void Teste(string Parametro)

Neste caso, o tipo é String. Agora, imagine que você precise criar uma solução genérica. Um impressor de dados por exemplo. Você trabalha com 20 entidades no seu projeto, para cada classe você precisaria sobrescrever o método ToString(). Seria um trabalhão certo? ERRADO!

Seguindo este modelo, vamos criar duas classes: Cliente e Fornecedor:

    public class Cliente

    {

        public int IDCliente { get; set; }

        public string NomeCliente { get; set; }

        public DateTime DataNascimento { get; set; }

    }

    public class Fornecedor

    {

        public int IDFornecedor { get; set; }

        public int NomeFornecedor { get; set; }

   

    }

Classes criadas, agora vamos criar uma nova classe chamada Impressao que será responsável por receber qualquer entidade e gerar uma string com o nome e valor de cada propriedade.

É necessário importar o namespace System.Reflection;

using System.Reflection;

Você deve observar que informamos o <T> antes da passagem do parâmetro, esta é a forma que o compilador entende que T será um tipo e assim podemos acessá-lo.

Agora, vamos construir a classe que será responsável pela impressão das entidades.

    public class Impressao

    {

        public string Imprimir<T>(T Entidade)

        {

            //"Pegamos" o tipo de T, para termos acessos as propriedades e valores.

            Type tipoEntidade = typeof(T);

            //Pegamos as propriedades da entidade.

            PropertyInfo[] propriedades = tipoEntidade.GetProperties();

            StringBuilder sb = new StringBuilder();

            object ValorDaPropriedade = null;

           

            //Passo por todas as propriedades

            foreach (PropertyInfo propriedade in propriedades)

            {

                //Pego o valor da propriedade.

                ValorDaPropriedade = propriedade.GetValue(Entidade, null);

                //Verifico se o valor é nulo, caso positivo, "imprimiremos NULL"

                ValorDaPropriedade = ValorDaPropriedade == null ? "NULL" : ValorDaPropriedade;

                sb.Append(String.Format("Nome da Propriedade {0} - Valor: {1} {2}",

                    propriedade.Name, ValorDaPropriedade, Environment.NewLine));

            }

            //Retorno a String

            return sb.ToString();

        }

Temos as entidades e o método de impressão genérico, vamos então sobrescrever o método ToString(), nas duas classes faremos o seguinte:

public override string ToString()

{

       Impressao impressao = new Impressao();

       return impressao.Imprimir(this);

}

Feito isto, agora vamos criar a classe de teste:

    class Program

    {

        static void Main(string[] args)

        {

            Cliente cliente = new Cliente();

            cliente.DataNascimento = DateTime.Today;

            cliente.IDCliente = 1;

            cliente.NomeCliente = "Alexandre Minato";

            Console.WriteLine(cliente.ToString());

            Console.ReadKey();

        }

    }

E o resultado final fica assim:

Sem dúvidas poderíamos criar uma classe que sobrescrevesse o método ToString() e utilizar a herança, mas, a idéia foi mostrar o funcionamento do <T>.

Dúvidas ou sugestões, entrem em contato.

Download do exemplo