Cách ngăn ReflectionTypeLoadException khi gọi Assembly.GetTypes ()

Tôi đang cố gắng quét một assembly để tìm các kiểu triển khai giao diện cụ thể bằng cách sử dụng mã tương tự như sau:

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

Vấn đề của tôi là, tôi nhận được một ReflectionTypeLoadExceptionkhi gọi asm.GetTypes()trong một số trường hợp, ví dụ: nếu hợp ngữ chứa các kiểu tham chiếu đến một hợp ngữ hiện không khả dụng.

Trong trường hợp của tôi, tôi không quan tâm đến các loại gây ra sự cố. Các loại tôi đang tìm kiếm không cần các cụm không có sẵn.

Câu hỏi đặt ra là: có thể bằng cách nào đó bỏ qua / bỏ qua các kiểu gây ra ngoại lệ nhưng vẫn xử lý các kiểu khác có trong assembly không?

Một cách khá khó chịu sẽ là:

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

Tuy nhiên, nó chắc chắn khó chịu khi phải làm điều này. Bạn có thể sử dụng một phương pháp mở rộng để làm cho nó đẹp hơn trong mã "khách hàng":

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

Bạn cũng có thể muốn di chuyển returncâu lệnh ra khỏi khối bắt - bản thân tôi không quan tâm lắm đến việc nó ở đó, nhưng có lẽ nó là mã ngắn nhất ...

Mặc dù có vẻ như không thể làm gì nếu không nhận được ReflectionTypeLoadException tại một số điểm, các câu trả lời ở trên bị hạn chế ở chỗ bất kỳ nỗ lực nào để sử dụng các loại được cung cấp từ ngoại lệ sẽ vẫn gây ra sự cố ban đầu khiến loại không tải được.

Để khắc phục điều này, đoạn mã sau đây giới hạn các kiểu đối với những kiểu nằm trong hợp ngữ và cho phép một vị từ hạn chế thêm danh sách các kiểu.

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

Bạn đã xem xét Assembly.ReflectionOnlyLoad chưa? Xem xét những gì bạn đang cố gắng làm, nó có thể là đủ.

Trong trường hợp của tôi, vấn đề tương tự do sự hiện diện của các cụm không mong muốn trong thư mục ứng dụng. Cố gắng xóa thư mục Bin và xây dựng lại ứng dụng.