.net - 如何防止 'bad' 实现使 MEF 中的 GetExportedValues 中毒？

Question

我正在使用 MEF发现和实例化插件并希望使过程尽可能健壮。特别是我不希望一个写得不好的插件对主机或其他插件的执行产生不利影响。

不幸的是，我在使用 GetExportedValues() 时发现了这一点从任何实现类构造函数抛出的异常有效地“毒害”了容器，阻止返回所有“好的”实现。

下面的代码演示了这一点:

using System;
using System.ComponentModel.Composition;
using System.ComponentModel.Composition.Hosting;
using System.Linq;

namespace MefPoisoning {
    class Program {
        static void Main(string[] args) {
            var catalog = new TypeCatalog(
                typeof(GoodImplementation), 
                typeof(BadImplementation));

            using (var container = new CompositionContainer(catalog)) {
                try {
                    var implementations =
                        container.GetExportedValues<IInterface>();
                    Console.WriteLine("Found {0} implementations",
                        implementations.Count());
                }
                catch (CompositionException e) {
                    Console.WriteLine(e.Message);
                }
            }
        }
    }

    [InheritedExport]
    public interface IInterface {
    }

    public sealed class GoodImplementation : IInterface {
    }

    public sealed class BadImplementation : IInterface {
        public BadImplementation() {
            throw new InvalidOperationException();
        }
    }
}

随着 BadImplementation从其构造函数中抛出异常 GetExportedValues()抛出异常，因此甚至不返回良好的实现。该错误清楚地表明潜在问题是由于 BadImplementation 引起的。构造函数:

The composition produced a single composition error. The root cause is 
provided below. Review the CompositionException.Errors property for more 
detailed information.

1) Operation is not valid due to the current state of the object.

Resulting in: An exception occurred while trying to create an instance 
of type 'MefPoisoning.BadImplementation'.

...

[注意 GetExports()同样失败，但后来，当它的 Lazy<IInterface>查询返回值]。

有什么方法可以解决这个明显的限制吗？

Answer 1

完成这项工作的关键是使用 GetExports()而不是 GetExportedValues() .如问题 GetExports() 中所述返回 IEnumerable<Lazy<T>> .这可以迭代并在 try-catch 中一次实例化一个实现。阻止检查他们是否表现良好。如果不是，则可以简单地忽略它们。

下面的代码演示了这一点并且可以替换 using问题中的示例中的 block :

using (var container = new CompositionContainer(catalog)) {
    var goodImplementations = new List<IInterface>();
    var lazyImplementations = container.GetExports<IInterface>();

    foreach (var lazyImplementation in lazyImplementations) {
        try {
            goodImplementations.Add(lazyImplementation.Value);
        }
        catch (CompositionException e) {
            // Failed to create implementation, ignore it
        }
    }

    Console.WriteLine("Found {0} implementations", goodImplementations.Count());
}