De forma bem simples e prática mostrarei como criar Interfaces genéricas com C#.

Como muito de nós sabemos, usar interfaces em nossos sistemas nos trás mais controle quando se trata das funcionalidades essenciais que devem ser desenvolvidas, sua ideia traz o mesmo sentido de um “contrato”. Uma classe que implementa uma Interface deve conter todas as assinaturas de métodos que a interface possui.

Deste modo, é comum termos várias interfaces em nossos projetos com várias assinaturas diferentes. Não utilizando interfaces genéricas, pode ser comum estruturas como esta abaixo:

  • Interfaces
public interface IProduct
{
   bool Create(Product prod);
   bool Update(Product prod);
   List<Product> List();
   bool Delete(int productId);
}
publicinterfaceIUser
{
   boolCreate(User user);
   boolUpdate(User user);
   List<User> List();
   boolDelete(intuserId);
}
  • Classes
publicclassProduct : IProduct
{
   publicboolCreate(Product prod)
   {
      //[funcionalidade]
   }
   publicboolUpdate(Product prod)
   {
      //[funcionalidade]
   }
publicList<Product> List()
   {
      //[funcionalidade]
   }
   publicboolDelete()
   {
       //[funcionalidade]
   }
}
publicclassUser : IUser
{
   publicboolCreate(User user)
   {
      //[funcionalidade]
   }
   publicboolUpdate(User user)
   {
      //[funcionalidade]
   }
   publicList<User> List()
   {
      //[funcionalidade]
   }
   publicboolDelete(intuserId)
   {
      //[funcionalidade]
   }
}
Note que, estas classes e interfaces são muito semelhantes em sua essência, basicamente o que muda é apenas a entidade manipulada. Pensando que haja necessidade de manutenção nestas interfaces, provavelmente acabe sendo preciso altera em vários lugares diferentes dependendo da alteração na assinaturas. Em casos como estes é possível fazer uma abordagem mais elegante e mais fácil para manutenção através de Interfaces Genéricas, que veremos agora.
  • Interface Genérica
publicinterfaceIGenericCRUD<T> whereT : class
{
   boolCreate(T entity);
   boolUpdate(T entity);
List<T> List();
   boolDelete(intentityId);
}
Desta forma, acabamos de criar uma classe que tem como suas assinaturas básicas do CRUD (Create, Retrieve, Update e Delete). Com ela, a classe que a implementar poderá conter qualquer objeto T, se tornando mais fácil a manutenção.
Agora basta que você implemente das interfaces comuns esta interface genérica, ficando da seguinte forma:
publicinterfaceIProduct : IGenericsCRUD<Product>
{
   intGenerateNewId(); //nova assinatura criada
}
publicinterfaceIUser : IGenericsCRUD<User>
{
   boolIsRepeated(intuserId); //nova assinatura criada
}

Você deve ter percebido o quão enxuto ficou agora o código, não é?

Criamos novas assinaturas de métodos para as interfaces IProduct e IUser, apenas para simular novas características nestas classes, mas ambas estão reutilizado todas as assinaturas da IGenericsCRUD, com código mais coeso o tornando mais fácil para manutenção.

Deixe uma resposta

Post Navigation