Interface générique VS méthode générique?

Question

J'écris un type générique pour gérer les objets Active Directory sous-jacents tels que les groupes, les unités organisationnelles et les utilisateurs. J'utilise également l'injection de dépendance «manuelle» dans mon interface générique. Je voudrais savoir si, dans ma situation, quelle est la plus appropriée: interface générique ou méthode générique?

Voici un exemple de code simplifié pour vous montrer:

public interface IDirectorySource<T> where T : IDirectoryEntry { 
    IDirectorySearcher<T> Searcher { get; } 

    CustomSet<T> ToList(); // Related to my question, as I will here only return Searcher.ToList(); 
} 

public interface IDirectorySearcher<T> where T : IDirectoryEntry { 
    DirectorySearcher NativeSearcher { get; } 

    CustomSet<T> ToList(); // Related to my question... 
} 

public sealed class GroupSearcher : IDirectorySearcher<Group> { 
    public GroupSearcher(DirectoryEntry root, SearchScope scope) { 
     // Instantiating... 
    } 

    public DirectorySearcher NativeSearcher { get; private set; } 

    public CustomSet<T> ToList() { // That is the point of my question. 
     // Listing all T objects found in AD... 
    } 
} 

public sealed class DirectorySource<T> : IDirectorySource<T> where T : IDirectoryEntry { 

    public DirectorySource(IDirectorySearcher<T> searcher) { 
     Searcher = searcher; 
    } 

    public IDirectorySearcher<T> Searcher { get; private set; } 

    public CustomSet<T> ToList() { // Here's the point to my question. 
     return Searcher.ToList(); 
    } 
} 

Alors, voici mon point. Je voudrais rendre mon interface IDirectorySource non générique, car je vais promouvoir ma classe DirectorySource<T> à publique. Je voudrais donc seulement besoin de déclarer une source comme ceci:

GroupSearcher groupSearcher = new GroupSearcher(root, scope); 
IDirectorySource groups = new DirectorySource<Group>(groupSearcher); 

donc je pu retrive une liste des groupes:

groups.ToList(); // Getting all the existing groups in AD here... 

Mais je me demande si je devrais laisser mon interface IDirectorySource<T> générique, ou le rendre non générique et rendre ma méthode IDirectorySource.ToList() à la place, donc je n'aurais pas besoin de taper mon interface, mais seulement la classe qui me fournirait une instance de mon interface.

Serait-il préférable d'écrire mon interface comme ceci:

public interface IDirectorySource { 
    CustomSet<T> ToList<T>(); 
} // With all the appropriate changes, indeed. 

Je suis conscient que cela est peut-être pas assez claire. N'hésitez pas à me poser vos questions afin que je puisse vous aider à m'aider.

Merci d'avance! =)

Answer 1

Pour la même instance de IDirectorySource, auriez-vous besoin de plus d'appeler une méthode (comme ToList) en utilisant différents types?

Sinon, laissant IDirectorySource générique et les méthodes (ToList) pour faire non génériques serait un code plus propre, ce qui permet des objets de IDirectorySource sous-classées pour mettre en œuvre leur propre logique de type courant.