MEF vs. IAsyncDisposable or iterate over all instantiated exports

Question

I've shared MEF exports that implement IAsyncDisposable. If an export in MEF implements IDisposable it will be disposed when the composition container (or maybe the catalog) is disposed.

IAsyncDisposable is not recognized from MEF. Is there any solution to that problem?

If not: If the application will be shut down I try to iterate over all already created exports that implement IAsyncDisposable but there seems to be no possibility to do that.

Let's assume that I've a typed method (maybe created via reflection) I'm able to call CompositionContainer.GetExport<T>() that returns a Lazy<T>. The problem is that IsValueCreated is false - even if that import has a running shared instance.

Is there any way to iterate over all exports that have been already instantiated?

This code shows that the Lazy<T>-instance does not contain the already known exported value:

public class Program
{
    public static void Main()
    {
        using var catalog = new AssemblyCatalog(typeof(Program).Assembly);
        using var container = new CompositionContainer(catalog);
        
        var dummyInstance = container.GetExport<Foo>().Value;
        Console.WriteLine($"HasInstance: {dummyInstance is not null}");
        
        var export = container.GetExport<Foo>();
        Console.WriteLine($"IsValueCreated: {export.IsValueCreated}");
    }
}

[Export]
[PartCreationPolicy(CreationPolicy.Shared)]
public class Foo 
{
}

The output is:

HasInstance: True
IsValueCreated: False

DEMO

EDIT

I found a "solution" to that problem using a lot of reflection and magic field names:

var catalogExportProviderProperty = compositionContainer
                                    .GetType()
                                    .GetProperty("CatalogExportProvider", BindingFlags.Instance | BindingFlags.NonPublic) ??
                                    throw ReflectionErrors.MissingProperty(
                                        compositionContainer.GetType(),
                                        "CatalogExportProvider");
var catalogExportProvider =
    catalogExportProviderProperty.GetValue(compositionContainer) ??
    throw new InvalidOperationException(
        $@"Uninitialized property 'CatalogExportProvider' in {compositionContainer.GetType().Name}.");
var partsToDisposeField =
    catalogExportProvider.GetType().GetField("_partsToDispose", BindingFlags.Instance | BindingFlags.NonPublic) ??
    throw ReflectionErrors.MissingField(catalogExportProvider.GetType(), "_partsToDispose");
var partsToDispose = partsToDisposeField.GetValue(catalogExportProvider) as IEnumerable ??
                     throw new InvalidOperationException($@"Unable to retrieve disposable parts from {catalogExportProvider.GetType()}.");
foreach (var item in partsToDispose.OfType<object>())
{
    var cachedInstanceProperty = item.GetType().GetProperty("CachedInstance", BindingFlags.Instance | BindingFlags.NonPublic) ??
                                 throw ReflectionErrors.MissingProperty(item.GetType(), "CachedInstance");
    var cachedInstance = cachedInstanceProperty.GetValue(item, index: null);
    if (cachedInstance is IAsyncDisposable asyncDisposable)
    {
        await asyncDisposable.DisposeAsync();
    }
}

This works because there is an implementation specification that every type that implements IAsyncDisposable should also implement IDisposable.

BUT: This solution doesn't feel right. I'm still looking for an official solution to that problem.