public override void Activate( IContext context, InstanceReference reference )
        {
            var messageBroker = context.Kernel.Components.Get<IMessageBroker>();

            List<PublicationDirective> publications = context.Plan.GetAll<PublicationDirective>().ToList();

            // I don't think this is needed in Ninject2
            //if (publications.Count > 0)
            //   context.ShouldTrackInstance = true;

            foreach ( PublicationDirective publication in publications )
            {
                IMessageChannel channel = messageBroker.GetChannel( publication.Channel );
                channel.AddPublication( reference.Instance, publication.Event );
            }

            List<SubscriptionDirective> subscriptions = context.Plan.GetAll<SubscriptionDirective>().ToList();

            // I don't think this is needed in Ninject2
            //if (subscriptions.Count > 0)
            //    context.ShouldTrackInstance = true;

            foreach ( SubscriptionDirective subscription in subscriptions )
            {
                IMessageChannel channel = messageBroker.GetChannel( subscription.Channel );
                channel.AddSubscription( reference.Instance, subscription.Injector, subscription.Thread );
            }
        }

        public void StrategyDoesNotAttemptToDisposeInstanceIfItIsNotDisposable()
        {
            var instance = new object();
            var reference = new InstanceReference { Instance = instance };

            strategy.Deactivate(contextMock.Object, reference);
        }

        public void InstanceIsRemovedFromCache()
        {
            var scope = new object();
            var sword = new Sword();
            var reference = new InstanceReference { Instance = sword };

            var writeContext = new Mock<IContext>();
            writeContext.SetupGet(x => x.Binding).Returns(bindingMock.Object);
            writeContext.SetupGet(x => x.HasInferredGenericArguments).Returns(true);
            writeContext.SetupGet(x => x.GenericArguments).Returns(new[] { typeof(int) });
            writeContext.Setup(x => x.GetScope()).Returns(scope);

            cache.Remember(writeContext.Object, reference);

            var readContext = new Mock<IContext>();
            readContext.SetupGet(x => x.Binding).Returns(bindingMock.Object);
            readContext.SetupGet(x => x.HasInferredGenericArguments).Returns(true);
            readContext.SetupGet(x => x.GenericArguments).Returns(new[] { typeof(int) });
            readContext.Setup(x => x.GetScope()).Returns(scope);

            object instance1 = cache.TryGet(readContext.Object);
            instance1.ShouldBeSameAs(reference.Instance);

            bool result = cache.Release(instance1);
            result.ShouldBeTrue();

            object instance2 = cache.TryGet(readContext.Object);
            instance2.ShouldBeNull();
        }

        public void StrategyDoesNotAttemptToInitializeInstanceIfItIsNotInitializable()
        {
            var instance = new object();
            var reference = new InstanceReference { Instance = instance };

            strategy.Activate(contextMock.Object, reference);
        }

 /// <summary>
 /// Activates the specified context.
 /// </summary>
 /// <param name="context">The context.</param>
 /// <param name="reference">The reference.</param>
 public override void Activate( IContext context, InstanceReference reference )
 {
     if ( ShouldProxy( context ) )
     {
         context.Kernel.Components.Get<IProxyFactory>().Wrap( context, reference );
     }
     base.Activate( context, reference );
 }

        public void StrategyStartsInstanceIfItIsStartable()
        {
            var instance = new StartableObject();
            var reference = new InstanceReference { Instance = instance };

            strategy.Activate(contextMock.Object, reference);
            instance.WasStarted.Should().BeTrue();
        }

        public void StrategyInitializesInstanceIfItIsInitializable()
        {
            var instance = new InitializableObject();
            var reference = new InstanceReference { Instance = instance };

            strategy.Activate(contextMock.Object, reference);
            instance.WasInitialized.ShouldBeTrue();
        }

 /// <summary>
 /// Deactivates the instance in the specified context.
 /// </summary>
 /// <param name="context">The context.</param>
 /// <param name="reference">The instance reference.</param>
 public void Deactivate(IContext context, InstanceReference reference)
 {
     Ensure.ArgumentNotNull(context, "context");
     if (!this.activationCache.IsDeactivated(reference.Instance))
     {
         this.Strategies.Map(s => s.Deactivate(context, reference));
     }
 }

        public void StrategyDisposesInstanceIfItIsDisposable()
        {
            var instance = new NotifiesWhenDisposed();
            var reference = new InstanceReference { Instance = instance };

            strategy.Deactivate(contextMock.Object, reference);
            instance.IsDisposed.ShouldBeTrue();
        }

 /// <summary>
 /// Injects values into the properties as described by <see cref="MethodInjectionDirective"/>s
 /// contained in the plan.
 /// </summary>
 /// <param name="context">The context.</param>
 /// <param name="reference">A reference to the instance being activated.</param>
 public override void Activate(IContext context, InstanceReference reference)
 {
     foreach (var directive in context.Plan.GetAll<MethodInjectionDirective>())
     {
         var arguments = directive.Targets.Select(target => target.ResolveWithin(context));
         directive.Injector(reference.Instance, arguments.ToArray());
     }
 }

        public void CallsDeactivateOnStrategies()
        {
            var contextMock = new Mock<IContext>();
            var reference = new InstanceReference();

            this.Pipeline.Deactivate(contextMock.Object, reference);

            this.StrategyMocks.Map(mock => mock.Verify(x => x.Deactivate(contextMock.Object, reference)));
        }

        /// <summary>
        /// Contributes to the deactivation of the instance in the specified context.
        /// </summary>
        /// <param name="context">The context.</param>
        /// <param name="reference">A reference to the instance being deactivated.</param>
        public override void Deactivate(IContext context, InstanceReference reference)
        {
            base.Deactivate(context, reference);

            if (this.Log != null)
            {
                this.Log.Info("Ninject binding deactivated: " + context.Binding.Service + " => " + reference.Instance.GetType());
            }
        }

 public void Activate(IContext context, InstanceReference reference)
 {
     Type instanceType = reference.Instance.GetType();
     LOGGER.Info("Component activation: " + instanceType.Name);
     if (!instanceType.IsAssignableFrom(typeof(Splashscreen))) {
         Splashscreen splashscreen = App.Kernel.Get<Splashscreen>();
         splashscreen.SetProgress(string.Format("{0} loading...", instanceType.Name));
     }
 }

        /// <summary>
        /// Activates the specified context.
        /// </summary>
        /// <param name="context">The context.</param>
        /// <param name="reference">The reference.</param>
        public override void Activate( IContext context, InstanceReference reference )
        {
            if ( ShouldProxy( context ) )
            {
                this.proxyFactory.Wrap( context, reference );
            }

            base.Activate( context, reference );
        }

        /// <summary>
        /// Activates the instance in the specified context.
        /// </summary>
        /// <param name="context">The context.</param>
        /// <param name="reference">The instance reference.</param>
        public void Activate(IContext context, InstanceReference reference)
        {
            Contract.Requires(context != null);
            Contract.Requires(reference != null);

            if (!this.activationCache.IsActivated(reference.Instance))
            {
                this.Strategies.Map(s => s.Activate(context, reference));
            }
        }

        public void WhenAlreadyActiavatedNothingHappens()
        {
            var contextMock = new Mock<IContext>();
            var reference = new InstanceReference();
            this.ActivationCacheMock.Setup(activationCache => activationCache.IsActivated(It.IsAny<object>())).Returns(true);

            this.Pipeline.Activate(contextMock.Object, reference);

            this.StrategyMocks.Map(mock => mock.Verify(x => x.Activate(contextMock.Object, reference), Times.Never()));
        }

 /// <summary>
 /// Activates the specified context.
 /// </summary>
 /// <param name="context">The context.</param>
 /// <param name="reference">The reference.</param>
 public override void Activate(IContext context, InstanceReference reference)
 {
     var namedScopeParameters = context.Parameters.OfType<NamedScopeParameter>();
     foreach (var namedScopeParameter in namedScopeParameters)
     {
         context.Kernel.Get<NamedScopeReference>(
             new NamedScopeReferenceScopeParameter(reference.Instance),
             new ConstructorArgument("scope", namedScopeParameter.Scope));
     }
 }

        /// <summary>
        /// Wraps the instance in the specified context in a proxy.
        /// </summary>
        /// <param name="context">The context in which the instance was activated.</param>
        /// <param name="reference">The <see cref="InstanceReference"/> to wrap.</param>
        public override void Wrap( IContext context, InstanceReference reference )
        {
            var wrapper = new LinFuWrapper( Kernel, context, reference.Instance );

            Type targetType = context.Request.Service;

            reference.Instance = targetType.IsInterface 
                ? this._factory.CreateProxy(typeof(object), wrapper, context.Request.Service) 
                : this._factory.CreateProxy(context.Request.Service, wrapper);
        }

        /// <summary>
        /// Injects values into the properties as described by <see cref="PropertyInjectionDirective"/>s
        /// contained in the plan.
        /// </summary>
        /// <param name="context">The context.</param>
        /// <param name="reference">A reference to the instance being activated.</param>
        public override void Activate(IContext context, InstanceReference reference)
        {
            Ensure.ArgumentNotNull(context, "context");
            Ensure.ArgumentNotNull(reference, "reference");

            foreach (var directive in context.Plan.GetAll<PropertyInjectionDirective>())
            {
                object value = GetValue(context, directive.Target);
                directive.Injector(reference.Instance, value);
            }
        }

        public void ReturnsNullIfScopeIsNull()
        {
            var reference = new InstanceReference { Instance = new Sword() };
            var context1 = CreateContext(new TestObject(42), this.bindingConfiguration);
            var context2 = CreateContext(null, this.bindingConfiguration);

            cache.Remember(context1, reference);
            object instance = cache.TryGet(context2);

            instance.Should().BeNull();
        }