.net Castle IoC未在服务器上注册服务类

在部署到服务器时，我的asp.net mvc web应用程序出现问题，但在通过visual studio运行它时却没有

这里是错误

无法创建组件“IndustrialRealEstate.Web.Controllers.ZoningController”，因为它需要满足依赖关系

所讨论的依赖关系是一个名为ZoningService的服务，它基于一个名为IDataService的通用接口

这是我正在使用的代码

控制器：

public class ZoningController : BaseController
{
    private readonly IDataService<ZoningWrapper> _zoningService;

    public ZoningController(IDataService<ZoningWrapper> service)
    {
        _zoningService = service;
    }
//functions
}

IDataService接口

public interface IDataService<T>
{
    T Get(string id);
    ICollection<T> GetAll();
    T Save(T dataWrapper);
    bool AlreadyExists(T dataWrapper);
    bool HasDependency(string id);
    bool Delete(string id);
}

公共接口IDataService
{
T Get（字符串id）；
i集合GetAll（）；
T保存（T数据包装器）；
bool-AlreadyExists（T-dataWrapper）；
bool-HasDependency（字符串id）；
bool Delete（字符串id）；
}

服务：

public class ZoningService : HasContext, IDataService<ZoningWrapper>
{
//Implemented functions from the interface
}

公共类ZoningService:HasContext，IDataService
{
//从接口实现的功能
}

服务安装程序：

public class ServicesInstaller : IWindsorInstaller
{
    public void Install(IWindsorContainer container, IConfigurationStore store)
    {
        container.Register(Component.For<IDataService<ZoningWrapper>>().ImplementedBy<ZoningService>());
    }
}

公共类服务安装程序：IWindsorInstaller
{
public void安装（IWindsorContainer、IConfigurationStore）
{
container.Register（Component.For（）.ImplementedBy（））；
}
}

现在，就像我说的，当我通过VisualStudio运行它时，它的功能是100%。直到我部署到服务器并且数据没有通过，我才意识到有问题。通过阅读日志，我得到了这个特别的信息，我无法确定问题是什么

如果任何人有任何见解或方向，他们可以告诉我，我将不胜感激

编辑-以下是控制器的接线方式

    public class ControllersInstaller : IWindsorInstaller
{
    public void Install(IWindsorContainer container, IConfigurationStore store)
    {
        container.Register(Castle.MicroKernel.Registration.Classes.FromThisAssembly()
            .BasedOn<BaseController>()
            .LifestylePerWebRequest()
            .Configure(x => x.Named(x.Implementation.FullName)));
        container.Register(Castle.MicroKernel.Registration.Classes.FromThisAssembly()
            .BasedOn<Controller>()
            .LifestylePerWebRequest()
            .Configure(x => x.Named(x.Implementation.FullName)));
    }
}

公共类控制器安装程序：IWindsorInstaller
{
public void安装（IWindsorContainer、IConfigurationStore）
{
container.Register（Castle.MicroKernel.registation.Classes.FromThisAssembly（））
.BasedOn（）
.LifestylePerWebRequest（）
.Configure（x=>x.Named（x.Implementation.FullName））；
container.Register（Castle.MicroKernel.registation.Classes.FromThisAssembly（））
.BasedOn（）
.LifestylePerWebRequest（）
.Configure（x=>x.Named（x.Implementation.FullName））；
}
}

做了一些类似于WebAPI项目的事情。需要添加以下内容

using System;
using System.Collections.Generic;
using System.Linq;
using System.Web.Http.Dependencies;
using Castle.MicroKernel;
using Castle.MicroKernel.Lifestyle;

namespace MyProject.DependencyInjection
{
    public class WindsorDependencyScope : IDependencyScope
    {
        private readonly IKernel container;
        private readonly IDisposable scope;

        public WindsorDependencyScope(IKernel container)
        {
            this.container = container;
            this.scope = container.BeginScope();
        }

        public object GetService(Type serviceType)
        {
            return this.container.HasComponent(serviceType) ? this.container.Resolve(serviceType) : null;
        }

        public IEnumerable<object> GetServices(Type serviceType)
        {
            return this.container.ResolveAll(serviceType).Cast<object>();
        }

        public void Dispose()
        {
            this.scope.Dispose();
        }
    }
}

我的安装程序示例

using System.Web.Http;
using Castle.MicroKernel.Registration;
using Castle.MicroKernel.SubSystems.Configuration;
using Castle.Windsor;

namespace MyProject.DependencyInjection
{
    public class WindsorWebApiInstaller : IWindsorInstaller
    {
        public void Install(IWindsorContainer container, IConfigurationStore store)
        {
            container.Register(
                Types.FromThisAssembly().BasedOn<ApiController>().LifestyleScoped()
                , Component.For<MyProject.Database.IDataAccessMethods>().ImplementedBy<MyProject.Database.DataAccessMethods>().LifestylePerWebRequest()
            );
        }
    }
}

使用System.Web.Http；
使用Castle.MicroKernel.Registration；
使用Castle.MicroKernel.subsystem.Configuration；
使用温莎城堡；
命名空间MyProject.DependencyInjection
{
公共类WindsorWebApiInstaller:IWindsorInstaller
{
public void安装（IWindsorContainer、IConfigurationStore）
{
集装箱。登记(
Types.FromThisAssembly（）.BasedOn（）.LifestyleScoped（）类型
，Component.For（）.ImplementedBy（）.LifestylePerWebRequest（）实现
);
}
}
}

我将检查您的安装程序是否都位于同一个程序集中，并检查

container.Install

调用是否与您需要涵盖的程序集范围匹配。例如，初始化程序时可能未加载包含服务安装程序的程序集。也许记录安装的内容可以帮助您检查代码是否在程序启动时运行

---

Re：调试此类问题：

很难在服务器上确定您的容器缺少了什么。如果您可以在可以进行调试的机器上重现问题，我建议使用

在我看来，更好的是，您可以设置一个测试，检查Castle是否可以解决所有依赖项：

[SetUpFixture]
public class TestIOC
{
    public IWindsorContainer Target { get; set; }

    [SetUp()]
    public void before_all_tests()
    {
        Target = global::Main.Structure.IOC.Initialize();
    }

    public class GeneralTests : TestIOC
    {
        [Test()]
        public void should_never_have_a_potentially_misconfigured_component()
        {
            var host = (IDiagnosticsHost)Target.Kernel.GetSubSystem(SubSystemConstants.DiagnosticsKey);
            var diagnostics = host.GetDiagnostic<IPotentiallyMisconfiguredComponentsDiagnostic>();
            var misconfiguredHandlers = diagnostics.Inspect();

            if (misconfiguredHandlers.Any())
            {
                var message = new StringBuilder();
                var inspector = new DependencyInspector(message);
                foreach (IExposeDependencyInfo handler in misconfiguredHandlers)
                {
                    handler.ObtainDependencyDetails(inspector);
                }
                Console.WriteLine(message.ToString());
            }

            Assert.AreEqual(0, misconfiguredHandlers.Count());
        }
    }
}

[SetUpFixture]
公共类测试
{
公共IWindsorContainer目标{get；set；}
[设置（）]
所有测试前的公共无效（）
{
Target=global:：Main.Structure.IOC.Initialize（）；
}
公共类通用测试：TestIOC
{
[测试（）]
public void应该\u永远\u有\u潜在的\u错误配置\u组件（）
{
var host=（IDiagnosticsHost）Target.Kernel.GetSubSystem（SubSystemConstants.DiagnosticsKey）；
var diagnostics=host.getdiagnostics（）；
var配置错误的handlers=diagnostics.Inspect（）；
if（配置错误的handlers.Any（））
{
var message=新的StringBuilder（）；
var检查器=新的DependencyInspector（消息）；
foreach（配置错误的处理程序中的IEExposeDependencyInfo处理程序）
{
处理人。获取依赖性详细信息（检查员）；
}
Console.WriteLine（message.ToString（））；
}
AreEqual（0，配置错误的handlers.Count（））；
}
}
}

这直接来自我使用的测试套件：如果您的IOC设置无法解析某些元素，它将写入std输出。在NUnit中，这将转化为失败的测试，其中包含一些缺少的细节。全局：：Main.Structure.IOC.Initialize（）调用在设置后返回容器，我也在主代码中使用它

以下是一个诊断输出示例，可帮助您查找缺少的配置：

*Main.Structure.TestIOC+GeneralTests.不应该\u有\u潜在的\u错误配置\u组件

“Main.Configuration.NotificationManagementConfiguration”正在等待 以下依赖项： -未提供参数“每日通知时间”。您忘记设置依赖项了吗

---

您甚至可以在程序开始时添加代码作为健全性检查，并尽可能快地记录任何错误以失败。

如何连接来自Windsor的控制器？你能出示相关代码吗？另外，

IREDbContext

也不受Windsor控制，是否有原因？编辑以添加控制器安装程序。至于IREDbContext，我从来没有想过它是诚实的。我是新来城堡的。

BaseController

继承自

Controller吗<
using System.Web.Http;
using System.Web.Mvc;
using System.Web.Routing;
using Castle.Windsor;
using Castle.Windsor.Installer;
using MyProject.DependencyInjection;

namespace MyProject
{
    // Note: For instructions on enabling IIS6 or IIS7 classic mode, 
    // visit http://go.microsoft.com/?LinkId=9394801

    public class WebApiApplication : System.Web.HttpApplication
    {
        protected void Application_Start()
        {
            var container = new WindsorContainer();
            container.Install(FromAssembly.This());
            GlobalConfiguration.Configuration.DependencyResolver = new WindsorDependencyResolver(container.Kernel);

            AreaRegistration.RegisterAllAreas();
            WebApiConfig.Register(GlobalConfiguration.Configuration);
            FilterConfig.RegisterGlobalFilters(GlobalFilters.Filters);
            RouteConfig.RegisterRoutes(RouteTable.Routes);
        }
    }
}

using System.Web.Http;
using Castle.MicroKernel.Registration;
using Castle.MicroKernel.SubSystems.Configuration;
using Castle.Windsor;

namespace MyProject.DependencyInjection
{
    public class WindsorWebApiInstaller : IWindsorInstaller
    {
        public void Install(IWindsorContainer container, IConfigurationStore store)
        {
            container.Register(
                Types.FromThisAssembly().BasedOn<ApiController>().LifestyleScoped()
                , Component.For<MyProject.Database.IDataAccessMethods>().ImplementedBy<MyProject.Database.DataAccessMethods>().LifestylePerWebRequest()
            );
        }
    }
}

[SetUpFixture]
public class TestIOC
{
    public IWindsorContainer Target { get; set; }

    [SetUp()]
    public void before_all_tests()
    {
        Target = global::Main.Structure.IOC.Initialize();
    }

    public class GeneralTests : TestIOC
    {
        [Test()]
        public void should_never_have_a_potentially_misconfigured_component()
        {
            var host = (IDiagnosticsHost)Target.Kernel.GetSubSystem(SubSystemConstants.DiagnosticsKey);
            var diagnostics = host.GetDiagnostic<IPotentiallyMisconfiguredComponentsDiagnostic>();
            var misconfiguredHandlers = diagnostics.Inspect();

            if (misconfiguredHandlers.Any())
            {
                var message = new StringBuilder();
                var inspector = new DependencyInspector(message);
                foreach (IExposeDependencyInfo handler in misconfiguredHandlers)
                {
                    handler.ObtainDependencyDetails(inspector);
                }
                Console.WriteLine(message.ToString());
            }

            Assert.AreEqual(0, misconfiguredHandlers.Count());
        }
    }
}