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
<<  novembro 2017  >>
stqqssd
303112345
6789101112
13141516171819
20212223242526
27282930123
45678910

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

Estou trabalhando em um projeto pessoal em parceria com um amigo para fazer o portal administrativo do site www.baladacerta.com.br, surgiu a necessidade de criarmos log de alterações do usuário. A idéia era logarmos as alterações dos clientes em um campo do tipo XML do SQLServer 2005.

Como estou desenvolvendo com LinqToSql e com conceitos de OO, pensei em como poderia fazer a geração do Log dinamicamente. Vai aí uma dica para quem gosta de soluções automatizadas.

Para garantir que as entidades que serão comparadas são do mesmo tipo, garanto no WHERE do próprio método (where T : Y), utilizando Reflection para gerar os elementos e atributos do XML (XElement)

Ficou bem dinâmico e reutilizável.

public enum Modulo
{
Casas,
CasasDetalhes,
Financeiro,
Parceiros,
}


public XElement GravarAlteracoes<T , Y >( T EntidadeAnterior, Y NovaEntidade, Modulo modulo ) where T : Y
{

XElement xml = new XElement(modulo.ToString()); // Crio o elemente referente ao módulo

//Pego as propriedades de uma das entidades (já que as duas são iguais).
PropertyInfo [] propriedades = EntidadeAnterior.GetType().GetProperties();
//Variável que armazena o valor das propriedades
object valorAntigo, valorNovo;

//passo por todas as propriedades da entidade
foreach (PropertyInfo propriedade in propriedades)
{
//Atribuo valor as entidades.
valorAntigo = propriedade.GetValue(EntidadeAnterior, null);
valorNovo = propriedade.GetValue(NovaEntidade, null);

//Se for Null, gravo o Literal NULL
valorAntigo = valorAntigo == null ? "NULL" : valorAntigo;
valorNovo = valorNovo == null ? "NULL" : valorNovo;

//Verifico se os valores são diferentes
if (!valorAntigo.Equals(valorNovo))
{
xml.Add(new XElement(propriedade.Name, // Crio um elemento com o nome da propriedade
new XAttribute("ValorAnterior", valorAntigo), // um atributo com o valor antigo
new XAttribute("ValorAtual", valorNovo))); // um atributo com o novo valor.
}

}

return xml;
}

Para utilizar você poderia fazer assim:

XElement xml = Log.GravarAlteracoes<CasaEntidade, CasaEntidade>(entCasaBanco, entCasaTela, Log.Modulo.Casas);

O interessante é que conseguimos garantir que as duas entidades são do mesmo tipo.

Simples não é mesmo?

 

Minato.

 
teste