vs-mef

VS MEF is a high-performance Managed Extensibility Framework (MEF) implementation designed to overcome the performance and compatibility limitations of standard .NET MEF (System.ComponentModel.Composition) and NuGet MEF (System.Composition).

Key advantages include:

• High Throughput: Uses a fully precomputed and validated composition graph for maximum speed when constructing exports.
• Compositional Diagnostics: Provides a complete list of diagnostics that identify rejected MEF parts, including root causes and cascading effects.
• Fast Startup via Serialization: Both the catalog and composition can be serialized after creation and deserialized in subsequent application instances. This allows for extremely fast startup times by bypassing assembly loading, scanning, and composition computation.
• Cross-MEF Compatibility: Acts as a bridge between .NET MEF and NuGet MEF, allowing parts written for either system to share a common composition (e.g., a NuGet MEF part can import exports from a .NET MEF part and vice versa).
• Standalone Capability: Despite its name, VS MEF is a standalone library that can be hosted in unit tests or any application requiring high-performance extensibility, independent of Visual Studio.

A violation can occur even if you don't explicitly mix namespaces in your code, if you use a custom export attribute that inherits from a different MEF variety than your imports.

For example, if a custom attribute ExportFireAttribute inherits from the MEF v1 System.ComponentModel.Composition.ExportAttribute, but your class uses [Import] from the MEF v2 System.Composition namespace, the part will be defective. The engine will see the MEF v1 export but will fail to recognize the MEF v2 imports.

// Custom attribute inheriting from MEF v1
using System.ComponentModel.Composition;

public class ExportFireAttribute : ExportAttribute
{
    public ExportFireAttribute() : base(typeof(IFire)) { }
}

// Defective usage: Custom MEF v1 export + MEF v2 import
using System.Composition;
using MyVendor;

[ExportFireAttribute]
public class FastFire : IFire
{
    [Import]
    public IWater Water { get; set; }
}

An interface metadata view is the baseline model for consuming export metadata through a strongly-typed contract. It is the most predictable model when you want the metadata contract itself to define the filtering behavior during composition.

Filtering Rules:

• Properties without [DefaultValue] are considered required. Required properties filter exports by both presence and type compatibility.
• Properties with [DefaultValue] are considered optional. Optional properties allow the metadata key to be absent; however, if the key is present, its value must still be type-compatible.

// Baseline model: Interface metadata view
public interface IInterfaceMetadataView
{
    // Required: Export must have this key and it must be a string
    string RequiredProperty { get; }

    // Optional: Export can omit this, but if present, it must be an int
    [DefaultValue(0)]
    int OptionalProperty { get; }
}