Ninject DependencyCreation and EventBroker extensions. Ensuring a one-to-one subscription

Question

I'm using Ninject Event Broker extensions and I have two services. ServiceOne is the Publisher of an event. ServiceTwo is the subscriber. ServiceOne doesn't have a hard dependency to ServiceTwo, I'm creating the dependency using the DependencyCreation extension.

Here are the requirements:

I want to define a one-to-one event between these two objects. Only the ServiceTwo instance created by DependencyCreation should receive the event.
If there are other instances of ServiceTwo further down in the object graph they shouldn't receive the event. (this shouldn't be the case but I want to account for it)
ServiceTwo should be disposed of when ServiceOne is disposed.
This is a web application and the life of ServiceOne should only be for one request.

Basically I'm just trying to recreate the behaviour of me writing:

var publisher = new Publisher();
var subscriber = new Subscriber();
var subscriber2 = new Subscriber();
publisher.MyEvent += subscriber.MyEventHandler;

One publisher. One subscriber. Subscriber2 doesn't get the event.

Here's my code:

this.Bind<IServiceOne, ServiceOne>().To<ServiceOne>().Named("ServiceOne").OwnsEventBroker("ServiceOne").RegisterOnEventBroker("ServiceOne");
this.Kernel.DefineDependency<IServiceOne, IServiceTwo>();
this.Bind<IServiceTwo>().To<ServiceTwo>().WhenParentNamed("ServiceOne").InDependencyCreatorScope().RegisterOnEventBroker("ServiceOne");

Two questions.

Does this fulfill my requirements? Is there a better way?

score 0 · Accepted Answer · answered Mar 20 '13 at 09:38

I don't normally like to answer my own question but seeing as this has been quiet for a while, I've been testing my code sample and it appears to work fine. To clean up the creation of these dependencies and the whole event broker registration process I created some extension methods. First off an IsPublisher extension that creates a scoped event broker:

    public static ISubscriberBuildingSyntax IsPublisher<TPublisher>(this IBindingWhenInNamedWithOrOnSyntax<TPublisher> syntax)
    {
        string name = Guid.NewGuid().ToString();
        syntax.Named(name);
        syntax.OwnsEventBroker(name).RegisterOnEventBroker(name);
        return new SubscriberBuildingSyntax<TPublisher>(syntax, name);
    }

Secondly, a generic CreateSubscriberDependency method that creates a dependency using Dependency Creator:

    public ISubscriberBuildingSyntax CreateSubscriberDependency<TSubscriber>() where TSubscriber : class
    {
        this.syntax.Kernel.DefineDependency<TPublisher, TSubscriber>();
        this.syntax.Kernel.Bind<TSubscriber>().ToSelf().WhenParentNamed(this.name).InDependencyCreatorScope().RegisterOnEventBroker(this.name);
        return this;
    }

I can then call this like so:

     this.Bind<IRegistrationService>().To<RegistrationService>()
            .IsPublisher()
            .CreateSubscriberDependency<RoleService>();

This creates an Event Broker scoped to the RegistrationService instance with a RoleService dependency that is tied to the life of RegistrationService.

I can then register RegistrationService with InRequestScope to limit this to the life of one request.

Ninject DependencyCreation and EventBroker extensions. Ensuring a one-to-one subscription

1 Answers1