using System;

using Autofac;

using Autofac.Features.OwnedInstances;

​

public interface IFoo1

{

}

​

public class Foo1 : IFoo1, IDisposable

{

    public Foo1()

    {

        Console.WriteLine("new Foo1");

    }

​

    public void Dispose()

    {

        Console.WriteLine("Foo1 disposed");

    }

}

​

public interface IFoo2

{

}

​

public class Foo2 : IFoo2, IDisposable

{

    public Foo2()

    {

        Console.WriteLine("new Foo2");

    }

​

    public void Dispose()

    {

        Console.WriteLine("Foo2 disposed");

    }

}

​

public class Bar

{

    public Bar(Func<IFoo1> foo1Factory, Func<Owned<IFoo2>> foo2Factory)

    {

        this._foo1Factory = foo1Factory;

        this._foo2Factory = foo2Factory;

    }

​

    private readonly Func<IFoo1> _foo1Factory;

    private readonly Func<Owned<IFoo2>> _foo2Factory;

    public void Do()

    {

        IFoo1 foo1 = this._foo1Factory();

        // can't dispose foo1 because foo is not IDisposable

        // how to garanty disposal of IFoo1 and its dependencies ?

        using (Owned<IFoo2> ownedFoo2 = this._foo2Factory())

        {

            IFoo2 foo2 = ownedFoo2.Value;

        }

    }

}

​

public class Program

{

    public static void Main()

    {

        ContainerBuilder builder = new ContainerBuilder();

        builder.RegisterType<Foo1>().As<IFoo1>();

        builder.RegisterType<Foo2>().As<IFoo2>();

        builder.RegisterType<Bar>().AsSelf().SingleInstance();

        using (IContainer container = builder.Build())

        {

            using (ILifetimeScope scope = container.BeginLifetimeScope())

            {

                Bar bar = scope.Resolve<Bar>();

                bar.Do();

                bar.Do();

                Console.WriteLine("end scope");

            }

​

            Console.WriteLine("end container");

        }

    }

}