Comment empêcher ReflectionTypeLoadException lors de l'appel de Assembly.GetTypes ()

J'essaie de scanner un assembly pour les types implémentant une interface spécifique en utilisant un code similaire à celui-ci:

public List<Type> FindTypesImplementing<T>(string assemblyPath)
{
    var matchingTypes = new List<Type>();
    var asm = Assembly.LoadFrom(assemblyPath);
    foreach (var t in asm.GetTypes())
    {
        if (typeof(T).IsAssignableFrom(t))
            matchingTypes.Add(t);
    }
    return matchingTypes;
}

Mon problème est que j'obtiens un ReflectionTypeLoadExceptionlors de l'appel asm.GetTypes()dans certains cas, par exemple si l'assembly contient des types référençant un assembly qui n'est actuellement pas disponible.

Dans mon cas, je ne suis pas intéressé par les types qui causent le problème. Les types que je recherche n'ont pas besoin des assemblys non disponibles.

La question est la suivante: est-il possible d'ignorer / ignorer d'une manière ou d'une autre les types qui provoquent l'exception tout en traitant les autres types contenus dans l'assembly?

Une manière assez désagréable serait:

Type[] types;
try
{
    types = asm.GetTypes();
}
catch (ReflectionTypeLoadException e)
{
    types = e.Types;
}
foreach (var t in types.Where(t => t != null))
{
    ...
}

C'est vraiment ennuyeux d'avoir à faire ça. Vous pouvez utiliser une méthode d'extension pour le rendre plus agréable dans le code "client":

public static IEnumerable<Type> GetLoadableTypes(this Assembly assembly)
{
    // TODO: Argument validation
    try
    {
        return assembly.GetTypes();
    }
    catch (ReflectionTypeLoadException e)
    {
        return e.Types.Where(t => t != null);
    }
}

Vous pouvez bien souhaitez déplacer la returndéclaration sur le bloc catch - Je ne suis pas terriblement vif à ce sujet d' être moi - même, mais il probablement est le plus court code ...

Bien qu'il semble que rien ne puisse être fait sans recevoir l'exception ReflectionTypeLoadException à un moment donné, les réponses ci-dessus sont limitées en ce que toute tentative d'utiliser les types fournis par l'exception posera toujours un problème avec le problème d'origine qui a entraîné l'échec du chargement du type.

Pour surmonter cela, le code suivant limite les types à ceux situés dans l'assembly et permet à un prédicat de restreindre davantage la liste des types.

    /// <summary>
    /// Get the types within the assembly that match the predicate.
    /// <para>for example, to get all types within a namespace</para>
    /// <para>    typeof(SomeClassInAssemblyYouWant).Assembly.GetMatchingTypesInAssembly(item => "MyNamespace".Equals(item.Namespace))</para>
    /// </summary>
    /// <param name="assembly">The assembly to search</param>
    /// <param name="predicate">The predicate query to match against</param>
    /// <returns>The collection of types within the assembly that match the predicate</returns>
    public static ICollection<Type> GetMatchingTypesInAssembly(this Assembly assembly, Predicate<Type> predicate)
    {
        ICollection<Type> types = new List<Type>();
        try
        {
            types = assembly.GetTypes().Where(i => i != null && predicate(i) && i.Assembly == assembly).ToList();
        }
        catch (ReflectionTypeLoadException ex)
        {
            foreach (Type theType in ex.Types)
            {
                try
                {
                    if (theType != null && predicate(theType) && theType.Assembly == assembly)
                        types.Add(theType);
                }
                // This exception list is not exhaustive, modify to suit any reasons
                // you find for failure to parse a single assembly
                catch (BadImageFormatException)
                {
                    // Type not in this assembly - reference to elsewhere ignored
                }
            }
        }
        return types;
    }

Avez-vous envisagé Assembly.ReflectionOnlyLoad ? Compte tenu de ce que vous essayez de faire, cela pourrait suffire.

Dans mon cas, le même problème a été causé par la présence d'assemblys indésirables dans le dossier de l'application. Essayez d'effacer le dossier Bin et de reconstruire l'application.