Mesclando Objetos em C# com Reflection

Vamos imaginar a seguinte situação: duas lojas de uma mesma rede que não se comunicam entre si e, por este motivo, cadastraram o mesmo cliente, uma vez em cada loja. Na Loja A, o cliente informou apenas o CPF, o Nome e o Telefone. Em outro dia, o cliente precisou realizar uma compra na Loja B e lá informou apenas o CPF, o Nome e o Email. Em certo momento, tornou-se necessário sincronizar os cadastros e então surgiu a questão: que cadastro devemos considerar como “melhor”? O da Loja A ou o da Loja B. Reparem que se consideramos apenas o cadastro da Loja A, perderemos a informação do Email do cliente e, considerando apenas o da Loja B, perderemos a informação do Telefone. Diante dessa situação, percebemos que o ideal seria “mesclar” os dois cadastros, preenchendo as informações em branco de uma loja com as informações existentes na outra, obtendo um cadastro único.

Existe ainda mais uma informação importante com relação ao cadastro. O cliente se chama “Joel Rodrigues de Lima Neto”, porém, na Loja A, ele informou apenas “Joel Rodrigues”. Já na Loja B, o cliente cadastrou seu nome completo, “Joel Rodrigues de Lima Neto”. Nesse caso, o cadastro da Loja B tem prioridade sobre o cadastro da Loja A, ou seja, no caso de haver a informação preenchida nas duas lojas, deve-se manter o conteúdo da Loja B.

Bem, vejamos agora na prática como fazer essa “mescla” em C#, utilizando reflection. Primeiramente, vejamos o código da classe Cliente:

Listagem 1: Classe Cliente

public class Cliente
    {
        private String _nome;
        private String _telefone;
        private String _cpf;
        private String _email;

        public String CPF
        {
            get { return _cpf; }
            set { _cpf = value; }
        }        

        public String Email
        {
            get { return _email; }
            set { _email = value; }
        }

        public String Nome
        {
            get { return _nome; }
            set { _nome = value; }
         }       

        public String Telefone
        {
            get { return _telefone; }
            set { _telefone = value; }
        }

        public override string ToString()
        {
            StringBuilder sb = new StringBuilder();
            sb.AppendLine("Nome: " + this._nome);
            sb.AppendLine("Telefone: " + this._telefone);
            sb.AppendLine("CPF: " + this._cpf);
            sb.AppendLine("Email: " + this._email);
            return sb.ToString();
        }
    }

Sobrecarregamos o método ToString apenas paraa nível de verificação. Após mesclar os dois objetos, chamaremos o método ToString para verificar os valores das propriedades do novo objeto.

Agora vejamos o código do método MesclarObjetos:

Listagem 2: Método MesclarClientes

public object MesclarObjetos(object p1, object p2)
{
if(p1.GetType() != p2.GetType())
{
throw new Exception("Os parâmetros deve ser do mesmo tipo.");
}

Object p3 = Activator.CreateInstance(p1.GetType());
foreach (PropertyInfo p in p1.GetType().GetProperties())
{
object v1 = p1.GetType().GetProperty(p.Name).GetValue(p1, null);
object v2 = p2.GetType().GetProperty(p.Name).GetValue(p2, null);
object v3 = (v1 == null || v1.ToString() == "" || v1.ToString() == "0"? v2 : v1);
p3.GetType().GetProperty(p.Name).SetValue(p3, v3, null);
            }
            return p3;
}

Bastante simples, não é mesmo?

Primeiramente, verificamos se os dois parâmetros são do mesmo tipo. Caso isso não se verifique, geramos uma exceção e encerramos o método.

Depois, criamos o objeto p3 do mesmo tipo do p1 (que é o mesmo do p2). Feito isso, verificamos cada propriedade dos objetos p1 e p2 e preenchemos o p3. Para cada iteração, v1 é o valor da propriedade de p1 e v2 é o valor da propriedade de p2. Caso v1 seja nulo, vazio ou zero, passamos para v3 (que é a propriedade de p3) o valor de v2, caso contrário, passamos o valor de v1.

Vale observar que, com essa estrutura, o objeto que é passado como primeiro parâmetro é priorizado na mescla dos valores conforme discutimos anteriormente.

Agora que já conhecemos como o método funciona, vamos testá-lo.

Listagem 3: Testando o método

Cliente c1 = new Cliente()
{
Nome = "Joel Rodrigues",
       	CPF = "000.000.000-00",
Telefone = "(000)0000-0000"

};

Cliente c2 = new Cliente()
{
Nome = "Joel Rodrigues de Lima Neto",
       	CPF = "000.000.000-00",
Email = "joelrlneto@gmail.com"
};

Cliente c3 = (Cliente)MesclarObjetos(c2, c1); MessageBox.Show(c3.ToString());

O conteúdo do MessageBox deve ser o seguinte:

Listagem 4: Resultado da mescla dos objetos

Nome: Joel Rodrigues de Lima Neto
Telefone: (000)0000-0000
CPF: 000.000.000-00
Email: joelrlneto@gmail.com

Bem, como vimos, o método é bem simples e isso só é possível graças aos recursos do Reflection do .NET.

Caso surja alguma dúvida com relação a este artigo, estou à disposição para saná-las. Um grande abraço a todos e até o próximo artigo.