Avoid memory leak for IDisposable/NonShared exports

Consider the sample below. When the exported type implements IDisposable the container keeps a reference to all created values, even if they are non-shared. This easily causes significant memory leaks.

What is the recommended pattern here?

using System;
using System.ComponentModel.Composition;
using System.Reflection;
using System.Threading.Tasks;
using Microsoft.VisualStudio.Composition;
using CreationPolicy = System.ComponentModel.Composition.CreationPolicy;

namespace MefTest
{
    [Export(typeof(ViewModel)), PartCreationPolicy(CreationPolicy.NonShared)]
    public class ViewModel : IDisposable
    {
        private byte[] bytes;
        public ViewModel() => bytes = new byte[100000]; // Leak
        public void Dispose() {}
    }

    class Program
    {
        static void Main(string[] args)
        {
            var t = InitMef();
            t.Wait();

            var container = t.Result;

            for (var i = 0; i < 100; i++)
            {
                var model = container.GetExportedValue<ViewModel>();
                model.Dispose(); // Container keeps a reference here!
            }

            // NOTE: I want to keep my container.
            // How do I release the memory allocated above?
            // container.Dispose();
        }

        private static async Task<ExportProvider> InitMef()
        {
            var discovery = PartDiscovery.Combine(new AttributedPartDiscoveryV1(Resolver.DefaultInstance));

            var catalog = ComposableCatalog.Create(Resolver.DefaultInstance)
                .AddParts(await discovery.CreatePartsAsync(Assembly.GetExecutingAssembly()))
                .WithCompositionService();

            var config = CompositionConfiguration.Create(catalog);
            var epf = config.CreateExportProviderFactory();
            var exportProvider = epf.CreateExportProvider();

            return exportProvider;
        }
    }
}

[AArnott]

Yes, it’s by design that the container maintains references to disposable values. But once a NonShared disposable value has been disposed of by itself, I believe there’s no reason for the container to retain its reference.

I imagine the ExportLifetimeContext<T> or Export<T> Dispose() method should not only dispose the T value but remove the reference from the container.

But now that I look at your code a bit more, I see you don’t have either of those wrappers, since you’re calling GetExportedValue<T> so all you get back is a T. So in fact this “leak” may in fact be by design. We’ll have to review.

In the meantime, can you try using an ExportFactory<T> instead to create the instances you need? That will give you the wrapper, and that wrapper may already release the container’s reference when you dispose the value.

[AArnott]

I’m taking a look at this now.