Bagaimana mencegah ReflectionTypeLoadException saat memanggil Assembly.GetTypes ()

Saya mencoba memindai rakitan untuk jenis yang menerapkan antarmuka tertentu menggunakan kode yang mirip dengan ini:

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

Masalah saya adalah, bahwa saya mendapatkan ReflectionTypeLoadExceptionketika memanggil asm.GetTypes()dalam beberapa kasus, misalnya jika assembly berisi jenis referensi assembly yang saat ini tidak tersedia.

Dalam kasus saya, saya tidak tertarik dengan jenis yang menyebabkan masalah. Tipe yang saya cari tidak memerlukan rakitan yang tidak tersedia.

Pertanyaannya adalah: apakah mungkin untuk melewati / mengabaikan tipe yang menyebabkan pengecualian tetapi masih memproses tipe lain yang terdapat dalam assembly?

Salah satu cara yang cukup buruk adalah:

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

Ini pasti menjengkelkan harus melakukan ini. Anda dapat menggunakan metode ekstensi untuk membuatnya lebih baik di kode "klien":

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

Anda mungkin ingin memindahkan returnpernyataan keluar dari blok tangkap - saya tidak terlalu tertarik untuk berada di sana sendiri, tetapi mungkin itu adalah kode terpendek ...

Meskipun tampaknya tidak ada yang dapat dilakukan tanpa menerima ReflectionTypeLoadException di beberapa titik, jawaban di atas terbatas karena setiap upaya untuk memanfaatkan jenis yang disediakan dari pengecualian akan tetap memberikan masalah dengan masalah asli yang menyebabkan jenis tersebut gagal dimuat.

Untuk mengatasi ini, kode berikut membatasi jenis yang terletak di dalam rakitan dan memungkinkan predikat untuk lebih membatasi daftar jenis.

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

Sudahkah Anda mempertimbangkan Assembly.ReflectionOnlyLoad ? Mempertimbangkan apa yang Anda coba lakukan, itu mungkin cukup.

Dalam kasus saya, masalah yang sama disebabkan oleh adanya rakitan yang tidak diinginkan di folder aplikasi. Cobalah untuk menghapus folder Bin dan membangun kembali aplikasi.