Ninject和Simple Injector都无法进行属性注入

Question

Update - turns out this was a bad configuration/wrong code in the wrong place problem. Got it working now.

I have scanned the other SO entries (some are really old) but there isn't an answer to be found. I am attempting to follow an example as provided by Adam Freeman's book, "Pro ASP.NET MVC 5" (yeah, it's a little dated but still good) and in the example he sets up a simple website with Dependency Injection (DI) using Ninject.

I followed the example after adapting to current web technologies (I'm using the .NET framework 4.7), updated the basic project (which starts as an empty MVC with Mvc and WebApi both checked) and everything works just fine, right up to the Inject a property example.

I thought to myself, "OK, Ninject is getting a little long in the tooth and I don't think it's being maintained anymore so I'll try a new gadget that I have heard is Really Fast - SimpleInjector".

Created a brand new project, moved only the example classes across (copied) and setup SI in the recommended fashion. SAME PROBLEM!

What's the problem, you ask? Simple, the value I wish injected into the created concrete class isn't being injected.

To replicate (or at least, follow along), you need to create a standard ASP.NET MVC application (Visual Studio 2017, Enterprise, 15.3.4, .NET Framework version 4.7 in a Windows 10 Creator environment, non-domain), select "Empty" and then check the MVC and Web API check boxes. Not quite as the book details, but I need both for another project which doesn't matter at this point. Again, following the example as laid out in the book works just fine, DI and all, with Ninject up to the point of property injection.

From that point, I have added a simple class to support a shopping card, a gadget that calculates total cost and a gadget that applies a discount. Really simple stuff. Following are the mods made for each using each DI container:

Ninject: In the NinjectWebCommon.cs file, RegisterServices method:

kernel.Bind<IDiscountHelper>()
.To<DiscountHelper>()
    .WithPropertyValue(nameof(DiscountHelper.DiscountSize), 15.0M);
kernel.Bind<ILinqValueCalculator>().To<LinqValueCalculator>();
kernel.Bind<IShoppingCart>().To<ShoppingCart>();

In SimpleInjector (created a separate class to perform "registration":

// Put all the aContainer.Register<ISomeInterface, SomeConcreteClass>(LifetimeScope) calls here
aContainer.Register<IDiscountHelper, DiscountHelper>(new AsyncScopedLifestyle());
// How to inject a property initializer
aContainer.RegisterInitializer<IDiscountHelper>
(
    i =>
        {
            i.DiscountSize = 15M;
            i.DiscountAmount = 30M;
        }
);
aContainer.Register<ILinqValueCalculator, LinqValueCalculator>(new AsyncScopedLifestyle());
aContainer.Register<IShoppingCart, ShoppingCart>(new AsyncScopedLifestyle());

The view takes in a really simple model, just a class with two properties, both decimal, one with the original total, one with the discounted total. Despite setting the Discount amount to a value of at least 15M, both numbers are the same. If I remove property injection and hard code a value in various places, the number comes out correctly. In short, the injection is failing in both DI containers. This should not be and I cannot figure out why this is happening.

An assist here would be much appreciated. If more code is needed, leave a comment and I'll upload the entire project in a .zip.

Answer 1

The answer was to ensure that all the right initializations are taking place in the correct order. Also needed to ensure that the correct version of IDependencyResolver was referenced (there are two and the other one doesn't play nice). The code that solved it for me for Ninject is this (thanks to Adam Freeman, the author of the book that generated this SO entry):

using Microsoft.Web.Infrastructure.DynamicModuleHelper;
using Ninject;
using Ninject.Web.Common;
using Ninject.Web.WebApi;
using System;
using System.Collections.Generic;
using System.Web;
using System.Web.Http;
using System.Web.Mvc;
using Web.Models;
[ assembly:WebActivatorEx.PreApplicationStartMethod(typeof(Web.App_Start.NinjectWebCommon), "Start")]
[ assembly: WebActivatorEx.ApplicationShutdownMethodAttribute(typeof(Web.App_Start.NinjectWebCommon), "Stop")]

namespace Web.App_Start {

public static class NinjectWebCommon {
    private static readonly Bootstrapper bootstrapper = new Bootstrapper();

    /// <summary>
    /// Starts the application
    /// </summary>
    public static void Start() {
        DynamicModuleUtility.RegisterModule(typeof(OnePerRequestHttpModule));
        DynamicModuleUtility.RegisterModule(typeof(NinjectHttpModule));
        bootstrapper.Initialize(CreateKernel);
    }

    /// <summary>
    /// Stops the application.
    /// </summary>
    public static void Stop() {
        bootstrapper.ShutDown();
    }

    /// <summary>
    /// Creates the kernel that will manage your application.
    /// </summary>
    /// <returns>The created kernel.</returns>
    private static IKernel CreateKernel() {
        var kernel = new StandardKernel();
        try {
            kernel.Bind<Func<IKernel>>().ToMethod(ctx => () => new Bootstrapper().Kernel);
            kernel.Bind<IHttpModule>().To<HttpApplicationInitializationHttpModule>();

            RegisterServices(kernel);
            GlobalConfiguration.Configuration.DependencyResolver =
                new NinjectDependencyResolver(kernel);
            return kernel;
        } catch {
            kernel.Dispose();
            throw;
        }
    }

    /// <summary>
    /// Load your modules or register your services here!
    /// </summary>
    /// <param name="kernel">The kernel.</param>
    private static void RegisterServices(IKernel kernel) {
        System.Web.Mvc.DependencyResolver.SetResolver(new
            MvcNinjectDependencyResolver(kernel));
    }
}

public class MvcNinjectDependencyResolver : IDependencyResolver {
    private IKernel kernel;

    public MvcNinjectDependencyResolver(IKernel kernelParam) {
        kernel = kernelParam;
        AddBindings();
    }

    public object GetService(Type serviceType) {
        return kernel.TryGet(serviceType);
    }

    public IEnumerable<object> GetServices(Type serviceType) {
        return kernel.GetAll(serviceType);
    }

    private void AddBindings() {
        kernel.Bind<IDiscountHelper>()
            .To<DiscountHelper>()
                .WithPropertyValue(nameof(DiscountHelper.DiscountSize), 15.0M);
        kernel.Bind<ILinqValueCalculator>().To<LinqValueCalculator>();
        kernel.Bind<IShoppingCart>().To<ShoppingCart>();
    }
}

}

And the SimpleInjector solution:

using Web;
using WebActivator;

[assembly: PostApplicationStartMethod(typeof(SimpleInjectorWebInitializer), nameof(SimpleInjectorWebInitializer.Initialize))]

namespace Web
{
using System.Reflection;
using System.Web.Http;
using System.Web.Mvc;
using Infrastructure;
using SimpleInjector;
using SimpleInjector.Integration.Web;
using SimpleInjector.Integration.Web.Mvc;
using SimpleInjector.Integration.WebApi;

public static class SimpleInjectorWebInitializer
{
    /// <summary>Initialize the container and register it as Web API Dependency Resolver.</summary>
    public static void Initialize()
    {
        var vContainer = new Container();
        // To use the "greediest constructor" paradigm, add the following line:
        vContainer.Options.ConstructorResolutionBehavior =
            new MostResolvableParametersConstructorResolutionBehavior(vContainer);

        vContainer.Options.DefaultScopedLifestyle = new WebRequestLifestyle();
        InitializeContainer(vContainer);

        // From the docs, these next two lines need to be added for MVC
        vContainer.RegisterMvcControllers(Assembly.GetExecutingAssembly());
        vContainer.RegisterMvcIntegratedFilterProvider();

        // This is for Web Api
        vContainer.RegisterWebApiControllers(GlobalConfiguration.Configuration);

        vContainer.Verify();

        // This is needed for MVC
        DependencyResolver.SetResolver
            (new SimpleInjectorDependencyResolver(vContainer));
        // This is needed for WebApi
        GlobalConfiguration.Configuration.DependencyResolver =
            new SimpleInjectorWebApiDependencyResolver(vContainer);
    }

    private static void InitializeContainer(Container aContainer)
    {
        // This is just a call to a regular static method of a static class
        // that performs the container.Register calls.
        InitializeContainerBindings.InitializeBindings(aContainer);
    }

}

}

Either will give a start to creating an MVC 5 project that will support both MVC and WebApi in the same project. The case I am working on is a simple example but at least it's a start rather than an error. Thanks to everyone (especially Adam Freeman) for their support.