Apaixonado por tecnologia. Trabalho com tecnologia desde 2003.

Saiba mais sobre minha vida profissional aqui .

Fale comigo.
Siga-me no Twitter
Ultimos comentários
Calendário de Posts
<<  dezembro 2017  >>
stqqssd
27282930123
45678910
11121314151617
18192021222324
25262728293031
1234567

Siga o @DicaDoNerd no Twitter e acompanhe as novidades


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.

Exibição da Imagem com a Exibição do T como escolha do Tipo no parâmetro

Agora, vamos contruir 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:

Resultado Final: Impressão do Console.Writer com os nomes e valores das propriedades

Você pode baixar o exemplo completo clicando aqui: (Visual Studio 2010 – Framework 3.5).

Ícone de acessibilidade

A importância do preenchimento da propriedade alt nas imagens:
A partir de hoje, em todos os meus post’s vou fazer o possível para que haja acessibilidade. Tenho um colega de trabalho (Alexandre Teixera, vulgo Nano) que é programador com deficiência visual e ele sempre reclama da falta de acessibilidade. Vamos compartilhar conhecimento com TODOS.

Neste post, todas as imagens tem a propriedade alt preenchida, pois, assim, o software que lê as imagens, pode informar ao deficiente visual o que significa a imagem ou pelo menos uma breve descrição.

 

Até a próxima: 8-)

 

Minato

       Hoje, por incrível que pareça, poucas pessoas utilizam Tipo Anonimo e expressões lambdas. bem como, não utilizam as vantagens do Linq, e não estou dizendo do LinqToSql, mas sim do Linq To Objects Linq To XML. Neste artigo vou mostra que podemos criar de forma muito simples (e performática) a criação de tipos anônimos e como recupera-los.

       Vamos supor que você queira passar uma estrutura para o um método com 3 parâmetros. Vamos fazer isso com um tipo anonimo.

Criação do objeto do Tipo Anonimo.

object InformacoesCliente = new 
{
Idade = 27,
NomeCliente = "Alexandre Minato",
Ativo = true,
Site = "www.alexandreminato.com.br"
};

Beleza, agora como recuperar? Por reflection. Óbviamente você poderia cria rum método para devolver o tipo, mas, vamos fazer isso de uma forma simples:

public void IncluirInformacoes(object Parametros)
{

string NomeCliente = (string)Parametros.GetType().GetProperty("NomeCliente").GetValue(Parametros, null);
int Idade = (int)Parametros.GetType().GetProperty("Idade").GetValue(Parametros,null);
bool Ativo = (bool)Parametros.GetType().GetProperty("Ativo").GetValue(Parametros,null);

}

 

Vamos ver o que aconteceu? Notem que só estou passandro um parâmetro do tipo object !

anonimo

Agora, vejam o tipo do parâmetro.

tip

Muito bom né?

Até a próxima

Minato. 8-)

 
teste