Interface IDescription utilisant des génériques et des méthodes d'extension

Question

J'essaie de mettre en œuvre une interface IDescription. Le but de base de cette interface est d'avoir plusieurs classes différentes qui ont une liste de descriptions multilingues et je veux que la base de données AddDescription EditDescription et d'autres comportements basiques soient définis par l'interface et non implémentés individuellement par les classes qui héritent de l'interface. J'essaye d'assigner le comportement à l'interface en utilisant des méthodes d'extension.

J'ai des blocs de route tels que comment accéder à la collection de descriptions de l'entité que je transmets à l'interface IDescription (entity.Descriptions.Add)?

Je suis très nouveau pour les génériques, les méthodes d'extension, les types anonymes, etc, alors s'il vous plaît supportez-moi avec mes malentendus sur la façon dont ils sont utilisés. Appréciera si vous pouvez m'aider à corriger le code ci-dessous. Je l'ai écrit pour donner l'idée de ce que j'essaie de réaliser, c'est évidemment des erreurs fondamentales. Merci

public class Company : IDescription<Company, CompanyDescription> 
{ 
    public IList<CompanyDescription> Desriptions { get; set; } 
} 

public class Location : IDescription<Location, LocationDescription> 
{ 
    public IList<LocationDescription> Desriptions { get; set; } 
} 


public interface IDescription<eT, dT> 
{ 
    void AddDescription(eT, string text); 
    void EditDescription(eT, dT, string text); 
} 

public static DescriptionInterfaceExtensions 
{ 

    public static void AddDescription(this IDescription<eT, dT> description, eT entity, string text) 
    { 
     dT newDescription = new dT(text); 
     entity.Descriptions.Add(newDescription); 
    } 
} 

Answer 1

Une autre rewrite possible qui devrait fonctionner est d'enlever la Ajouter/Modifier méthodes à partir de l'interface et fournissent simplement le IList requis dans l'interface. Ensuite, pour faciliter l'utilisation, vous pouvez utiliser les méthodes d'extension pour le rendre plus facile.

Je ne dis pas cet exemple est une grande utilisation de médicaments génériques ou des méthodes d'extension, mais il fonctionnera:

public class CompanyDescription : IDescription { public string Text { get; set; } } 
public class LocationDescription : IDescription { public string Text { get; set; } } 

public class Company : IHaveDescriptions<CompanyDescription> 
{ 
    public IList<CompanyDescription> Desriptions { get; set; } 
} 

public class Location : IHaveDescriptions<LocationDescription> 
{ 
    public IList<LocationDescription> Desriptions { get; set; } 
} 

public interface IDescription 
{ 
    string Text { get; set; } 
} 
public interface IHaveDescriptions<T> 
    where T : class, IDescription, new() 
{ 
    IList<T> Desriptions { get; set; } 
} 

public static class DescriptionInterfaceExtensions 
{ 
    public static void AddDescription<T>(this IHaveDescriptions<T> entity, string text) 
     where T : class, IDescription, new() 
    { 
     T newDescription = new T(); 
     newDescription.Text = text; 
     entity.Desriptions.Add(newDescription); 
    } 
    public static void EditDescription<T>(this IHaveDescriptions<T> entity, T original, string text) 
     where T : class, IDescription, new() 
    { 
     T newDescription = new T(); 
     newDescription.Text = text; 
     entity.Desriptions.Remove(original); 
     entity.Desriptions.Add(newDescription); 
    } 
} 

Answer 2

Interface Vous ne pouvez pas ajouter implémentations aux classes en utilisant des méthodes d'extension, bien que cela semble être ce que vous essayez de faire.

Le but des méthodes d'extension est d'ajouter le comportement aux types existants (classes ou interfaces). Le problème avec votre code est que vous déclarez que Company et Location doivent implémenter l'interface IDescription; pourtant ils ne le font pas. Ils n'ont pas de méthodes AddDescription ou EditDescription, donc ça ne marchera pas. Pourquoi ne définissez-vous pas à la place une classe Description générique concrète et attachez cette classe à la société et à l'emplacement?

Answer 3

Dans votre exemple, il semble que le contrat est que les objets qui ont une description stockent une liste de descriptions. Donc, pour éviter d'avoir à déclarer Ajouter et supprimer des méthodes dans les classes directement, vous pouvez faire quelque chose comme ceci:

Interfaces

public interface IDescription<T> 
{ 
} 

public interface IHasDescription<THasDescription, TDescription> 
    where THasDescription : IHasDescription<THasDescription, TDescription> 
    where TDescription : IDescription<THasDescription> 
{ 
    IList<TDescription> Descriptions { get; } 
} 

implémentations concrètes

public class CompanyDescription : IDescription<Company> 
{ 
} 

public class Company : IHasDescription<Company, CompanyDescription> 
{ 
    private readonly IList<CompanyDescription> descriptions; 

    public IList<CompanyDescription> Descriptions 
    { 
     get { return this.descriptions; } 
    } 
} 

Extension méthodes

public static class DescriptionExtensions 
{ 
    public static void AddDescription<THasDescription, TDescription>(
      this THasDescription subject, 
      TDescription description) 
     where THasDescription : IHasDescription<THasDescription, TDescription> 
     where TDescription : IDescription<THasDescription> 
    { 
     subject.Descriptions.Add(description); 
    } 
} 

---

Mais je ne pense pas que cela vaut la peine de le faire juste pour avoir

mycompany.AddDescription(mydescription); 

au lieu de

mycompany.Descriptions.Add(mydescription);