So verhindern Sie ReflectionTypeLoadException beim Aufruf von Assembly.GetTypes ()

Ich versuche, eine Assembly nach Typen zu scannen, die eine bestimmte Schnittstelle implementieren, indem ich folgenden Code verwende:

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;
}

Mein Problem ist, dass ich in einigen Fällen ReflectionTypeLoadExceptionbeim Aufruf eine bekomme asm.GetTypes(), z. B. wenn die Assembly Typen enthält, die auf eine Assembly verweisen, die derzeit nicht verfügbar ist.

In meinem Fall interessieren mich die Typen, die das Problem verursachen, nicht. Die Typen, nach denen ich suche, benötigen keine nicht verfügbaren Assemblys.

Die Frage ist: Ist es möglich, die Typen, die die Ausnahme verursachen, irgendwie zu überspringen / zu ignorieren, aber dennoch die anderen in der Assembly enthaltenen Typen zu verarbeiten?

Ein ziemlich böser Weg wäre:

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

Es ist definitiv ärgerlich, dies tun zu müssen. Sie können eine Erweiterungsmethode verwenden, um es im "Client" -Code schöner zu machen:

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);
    }
}

Sie können auch wünschen , die bewegen returnAnweisung aus dem catch - Block - ich bin schrecklich nicht so scharf auf sie selbst dort zu sein, aber es wahrscheinlich ist der kürzeste Code ...

Obwohl es den Anschein hat, dass irgendwann nichts mehr getan werden kann, ohne die ReflectionTypeLoadException zu erhalten, sind die obigen Antworten dahingehend begrenzt, dass jeder Versuch, die aus der Ausnahme bereitgestellten Typen zu verwenden, weiterhin Probleme mit dem ursprünglichen Problem verursacht, das dazu geführt hat, dass der Typ nicht geladen werden konnte.

Um dies zu überwinden, beschränkt der folgende Code die Typen auf diejenigen, die sich in der Assembly befinden, und ermöglicht es einem Prädikat, die Liste der Typen weiter einzuschränken.

    /// <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;
    }

Haben Sie über Assembly.ReflectionOnlyLoad nachgedacht ? In Anbetracht dessen, was Sie versuchen, könnte es ausreichen.

In meinem Fall wurde das gleiche Problem durch das Vorhandensein unerwünschter Assemblys im Anwendungsordner verursacht. Versuchen Sie, den Ordner Bin zu löschen und die Anwendung neu zu erstellen.