using System;

using System.Collections.Generic;

using Castle.Windsor;

using Castle.MicroKernel.Registration;

using Castle.Facilities.TypedFactory;

using Microsoft.Extensions.DependencyInjection;

public class Program

{

    public static void Main()

    {

        Console.WriteLine("--- start ---");     

        var e = new Experiment();

        e.UseWindsorTransient();

        e.Setup();

​

        e.Step();

        e.Step();

        e.Clear();

        Console.WriteLine("--- exit ---");

    }

​

​

    class Experiment{

        public List<(string,WeakReference)> _tracked = new ();

        Func<A> _factory;

        Action<object> _disposer;

        A _a;

        public void UseWindsorTransient(){

            var _container = new WindsorContainer().AddFacility<TypedFactoryFacility>();

            _container.Register(Component.For<A>().LifestyleTransient());       

            _container.Register(Component.For<B>().LifestyleTransient());

            _container.Register(Component.For<IBFactory>().AsFactory().LifestyleTransient());

            _factory = () => _container.Resolve<A>();

            _disposer = obj => _container.Release(obj);

        }

        public void UseMS(){

            var services = new ServiceCollection();

            services.AddTransient<A>();;

            services.AddTransient<Func<B>>(x => () => ActivatorUtilities.CreateInstance<B>(x) );

            var provider = services.BuildServiceProvider();

            _factory = () => provider.GetRequiredService<A>();

            _disposer = obj => {};

        }

        public void CheckLifeliness(){

            foreach (var (name, wref) in _tracked){

                Console.WriteLine($"{name} -> {wref.IsAlive}");

            }

        }

        private void Track(string name, object obj) => Track((name, obj));

        private void Track((string name, object obj) item){

            _tracked.Add((item.name+"-"+item.obj.GetHashCode().ToString(), new WeakReference(item.obj)));

        }

        public void Setup(){

            Console.WriteLine("--- setup ---");

            _a = _factory();

            Track("a", _a);

            Track("f", _a._b1f);

            GC.Collect();

            CheckLifeliness();

        }

        public void Step(){

            Console.WriteLine("--- step ---");

            Track(_a.CreateB1());

            Track(_a.CreateB2());

            GC.Collect();

            CheckLifeliness();

        }

        public void Clear(){

            Console.WriteLine("--- clear ---");

            _disposer(_a);

            _a = null;

            GC.Collect();

            CheckLifeliness();

        }

    }

    public class A//: IDisposable

    {       

        IDisposable _local;

        public IBFactory _b1f;

        Func<B> _b2f;

        B _b1;

        B _b2;

        public A(IBFactory b1f, Func<B> b2f){

            Console.WriteLine("Creating A");

            _b1f = b1f;

            _b2f = b2f;

        }

        ~A(){

            Console.WriteLine("Destroying A");

        }

        public void Dispose(){

            Console.WriteLine("Disposing A");

        }

        public (string, object) CreateB1(){

            _b1f.Release(_b1);

            _b1 = _b1f.Create();

            return ("b1", _b1);

        }

        public (string, object) CreateB2(){

            _b2 = _b2f();

            return ("b2", _b2);

        }

    }

    public interface IBFactory{

        B Create();

        void Release(B obj);

    }

    public class B//: IDisposable

    {   

        public B(){

            Console.WriteLine("Creating B");

        }

        ~B(){

            Console.WriteLine("Destroying B");

        }

        public void Dispose(){

            Console.WriteLine("Disposing B");

        }

    }

}