Les implémentations de l'interface par le biais de la Réflexion

Comment puis-je obtenir toutes les implémentations de l'interface par le biais de la réflexion en C#?

InformationsquelleAutor | 2008-09-17
  1. 58

    La réponse est celle-ci; il recherche à travers l'ensemble du domaine d'application -- qui est, à chaque assemblée est actuellement chargé par votre application.

    ///<summary>
///Returns all types in the current AppDomain implementing the interface or inheriting the type. 
///</summary>
public static IEnumerable<Type> TypesImplementingInterface(Type desiredType)
{
    return AppDomain
           .CurrentDomain
           .GetAssemblies()
           .SelectMany(assembly => assembly.GetTypes())
           .Where(type => desiredType.IsAssignableFrom(type));
}

    Il est utilisé comme cela;

    var disposableTypes =  TypesImplementingInterface(typeof(IDisposable));

    Vous pouvez également cette fonction pour rechercher la réelle types de béton -- c'est à dire, en filtrant les résumés, les interfaces et les génériques des définitions de type.

    public static bool IsRealClass(Type testType)
{
    return testType.IsAbstract == false
         && testType.IsGenericTypeDefinition == false
         && testType.IsInterface == false;
}
    • Notez que ce code ne peut pas voir les années à venir-il ne peut pas trouver de mise en œuvre de cette interface dans les interfaces qui n'ont pas encore été chargé.
    • Je pense que je pourrais en faire une méthode d'extension pour le Type, peut-être très utile.
    • Steve: Pouvez-vous nous donner un indice sur un problème similaire, je vais avoir: stackoverflow.com/questions/5849210/...
    • Vous pouvez simplifier IsRealClass à return !(testType.IsAbstract || testType.IsGenericTypeDefinition || testType.IsInterface);
    • .SelectMany(assembly => assemblée.GetTypes()) cette ligne m'a donné une exception suivante: {"impossible de charger le fichier ou l'assembly" Microsoft.WindowsAzure.MobileServices.Gestion, Version=1.0.0.0, Culture=neutral, PublicKeyToken=f300afd708cefcd3' ou une de ses dépendances. Le système ne peut pas trouver le fichier spécifié.":"Microsoft.WindowsAzure.MobileServices.Gestion, Version=1.0.0.0, Culture=neutral, PublicKeyToken=f300afd708cefcd3"}
    • ma conjecture est que (un) de votre projet, des références de fichiers, (b) Dans les propriétés du projet, il est marqué "copie locale=false', et peut-être (c) pas de code fait référence à quoi que ce soit. Ainsi, votre code compile, mais quand réflexion vient de charger le type, il ne peut pas trouver l'assemblée en question et craps. Je te suggère de supprimer la référence, si elle n'est pas utilisée. J'espère que c'est un peu d'aide...

    InformationsquelleAutor Steve Cooper
  2. 5

    Ont un coup d'oeil à Assembly.GetTypes() méthode. Elle retourne tous les types qui peuvent être trouvés dans une assemblée. Tout ce que vous avez à faire est de parcourir chaque type retourné et vérifier si elle implémente l'interface nécessaire.

    Sur la façon de le faire est d'utiliser Type.IsAssignableFrom méthode.

    Ici est l'exemple. myInterface est l'interface, les implémentations de qui vous êtes la recherche pour.

    Assembly myAssembly;
Type myInterface;
foreach (Type type in myAssembly.GetTypes())
{
    if (myInterface.IsAssignableFrom(type))
        Console.WriteLine(type.FullName);
}

    Je crois qu'il n'est pas un moyen très efficace pour résoudre votre problème, mais au moins, c'est un bon endroit pour commencer.

    InformationsquelleAutor Anton
  3. 4
    Assembly assembly = Assembly.GetExecutingAssembly();
List<Type> types = assembly.GetTypes();
List<Type> childTypes = new List<Type>();
foreach (Type type in Types) {
  foreach (Type interfaceType in type.GetInterfaces()) {
       if (interfaceType.Equals(typeof([yourinterfacetype)) {
            childTypes.Add(type)
            break;
       }
  }
}

    Peut-être quelque chose comme ça....

    • Ce n'est pas trouver de types de autres assemblées que de mettre en œuvre ladite interface.
    InformationsquelleAutor Adam Driscoll
  4. 3

    Voici quelques Type des méthodes d'extension qui peut être utile pour cela, comme l'a suggéré Simon Farrow. Ce code est juste une restructuration de la accepté de répondre.

    Code

    ///<summary>
///Returns all types in <paramref name="assembliesToSearch"/> that directly or indirectly implement or inherit from the given type. 
///</summary>
public static IEnumerable<Type> GetImplementors(this Type abstractType, params Assembly[] assembliesToSearch)
{
    var typesInAssemblies = assembliesToSearch.SelectMany(assembly => assembly.GetTypes());
    return typesInAssemblies.Where(abstractType.IsAssignableFrom);
}

///<summary>
///Returns the results of <see cref="GetImplementors"/> that match <see cref="IsInstantiable"/>.
///</summary>
public static IEnumerable<Type> GetInstantiableImplementors(this Type abstractType, params Assembly[] assembliesToSearch)
{
    var implementors = abstractType.GetImplementors(assembliesToSearch);
    return implementors.Where(IsInstantiable);
}

///<summary>
///Determines whether <paramref name="type"/> is a concrete, non-open-generic type.
///</summary>
public static bool IsInstantiable(this Type type)
{
    return !(type.IsAbstract || type.IsGenericTypeDefinition || type.IsInterface);
}

    Exemples

    Pour obtenir le instanciables réalisateurs dans la convocation de l'assemblée:

    var callingAssembly = Assembly.GetCallingAssembly();
var httpModules = typeof(IHttpModule).GetInstantiableImplementors(callingAssembly);

    Pour obtenir les réalisateurs dans l'actuel domaine d'application:

    var appDomainAssemblies = AppDomain.CurrentDomain.GetAssemblies();
var httpModules = typeof(IHttpModule).GetImplementors(appDomainAssemblies);
    InformationsquelleAutor Sam
  5. 1

    Voulez-vous dire toutes les interfaces d'un Type implémente?

    Comme ceci:

    ObjX foo = new ObjX();
Type tFoo = foo.GetType();
Type[] tFooInterfaces = tFoo.GetInterfaces();
foreach(Type tInterface in tFooInterfaces)
{
  //do something with it
}

    Espère tha helpts.

    InformationsquelleAutor Alex Duggleby
  6. 1

    Vous devez faire une boucle sur tous les assemblys qui vous intéresse. De l'assemblée, vous pouvez obtenir tous les types qu'il définit. Notez que lorsque vous faites de l'AppDomain.CurrentDomain.Assemblées les assemblées qui sont chargés. Les assemblées ne sont pas chargés jusqu'à ce qu'ils sont nécessaires, ce qui signifie que vous devez charger explicitement les assemblées avant de lancer la recherche.

    InformationsquelleAutor Hallgrim