using System;

using DryIoc;

using MediatR;

using System.Reflection;

using System.Threading.Tasks;

using System.Linq;

​

public class Program

{

    public static void Main()

    {

        var c = new Container();

​

        //c.RegisterMany(new[] { typeof(IMediator).GetAssembly(), typeof(SomeRequestHandler).GetAssembly() }, type => type.GetTypeInfo().IsInterface);

        //c.RegisterDelegate<SingleInstanceFactory>(r => serviceType => r.Resolve(serviceType));

        //c.RegisterDelegate<MultiInstanceFactory>(r => serviceType => r.ResolveMany(serviceType));

        // swapping ResolveMany with Resolve will instantiate the notification handler

        // c.RegisterDelegate<MultiInstanceFactory>(r => serviceType => new [] {r.Resolve(serviceType)});

        c.Register<IAsyncNotificationHandler<Notification>, SomeNotificationHandler>();

        // notification message is printed, this way, but we want to have the same DbContext instance

        // in the scope of a request or a notification

        //c.Register<DbContext, Model1>();

        // we want different instances of Model1 for each IAsyncRequestHandler<,> and IAsyncNotificationHandler<>

        // but there's no printed message from the notification

        //c.Register<DbContext, Model1>(reuse: Reuse.InResolutionScopeOf(typeof(SomeNotificationHandler)));

        c.Register<DbContext, Model1>(reuse: Reuse.InResolutionScopeOf(typeof(IAsyncNotificationHandler<Notification>)));

        //var mediator = c.Resolve<IMediator>();

        //mediator.SendAsync(new RequestCommand()).Wait();

        var f = c.ResolveMany<object>(typeof(IAsyncNotificationHandler<Notification>)).First();

        Console.WriteLine(f);

    }

    public interface IActionHandler 

    {

        DbContext DbContext { get; }

    }

​

    public class DbContext {

    }

​

    public class Model1 : DbContext {}

​

    public class RequestCommand : IAsyncRequest<string>

    {

    }

    public class Notification : IAsyncNotification

    {

    }

    public class SomeRequestHandler : IAsyncRequestHandler<RequestCommand, string> 

    {

        public DbContext DbContext { get; private set; }

        public IMediator Mediator { get; private set; }

​

        public SomeRequestHandler(DbContext dbContext, IMediator mediator) 

        {

            DbContext = dbContext;

            Mediator = mediator;

        }

        public Task<string> Handle(RequestCommand message)

        {

            Console.WriteLine("request called");

            Mediator.PublishAsync(new Notification()).Wait();

            return Task.FromResult("ret");

        }

    }

    public class SomeNotificationHandler : IAsyncNotificationHandler<Notification> 

    {

        public DbContext DbContext { get; private set; }

​

        //if i remove the dependency on DbContext the message is printed

        public SomeNotificationHandler(DbContext dbContext) 

        {

            DbContext = dbContext;

        }

        public Task Handle(Notification notification)

        {

            Console.WriteLine("notification called");

            return Task.FromResult(0);

        }

    }

}