DependencyResolutionException：在类型上找不到带有“Autofac.Core.Activators.Reflection.DefaultConstructorFinder”的构造函数

如何解决DependencyResolutionException：在类型上找不到带有“Autofac.Core.Activators.Reflection.DefaultConstructorFinder”的构造函数

它在添加类似于 actionedService 的 rejectionService 之前工作较早，引发以下错误

处理请求时发生未处理的异常。 DependencyResolutionException：在类型 'Sx.Workflow.Server.Controllers.ReportController' 上找到的带有 'Autofac.Core.Activators.Reflection.DefaultConstructorFinder' 的构造函数都不能用可用的服务和参数调用： 无法解析构造函数 'Void .ctor(NLog.ILogger,AutoMapper.IMapper,Sx.Workflow.Reporting.Services.IRejectionService,Sx.Workflow.Reporting.Services.IActionedService) 的参数 'Sx.Workflow.Reporting.Services.IActionedService actionedService' '。 Autofac.Core.Activators.Reflection.ReflectionActivator.GetValidConstructorBindings(ConstructorInfo[] availableConstructors,IComponentContext context,IEnumerable parameters) in ReflectionActivator.cs,line 160

控制器

namespace Sx.Workflow.Server.Controllers
{
    [MenuItem("report")]
    [ServiceFilter(typeof(SettingsFilter))]
    [Authorize(Policy = Security.Constants.RolePolicy)]
    public class ReportController : Controller
    {
        private readonly ILogger _logger;
        private readonly IMapper _mapper;
        private readonly IRejectionService _rejectionService;
        private readonly IActionedService _actionedService;

        public ReportController(ILogger logger,IMapper mapper,IRejectionService rejectionService,IActionedService actionedService)
        {
            _logger = logger;
            _mapper = mapper;
            _rejectionService = rejectionService;
            _actionedService = actionedService;
        }

        [HttpGet]
        public IActionResult Index()
        {
            _logger.Info("Report Controller");
            return View();
        }

        [HttpPost]
        [ApiExceptionFilter]
        public async Task<IActionResult> Reject(RejectionReportRequestDto criteria)
        {
            if (!ModelState.IsValid)
            {
                return BadRequest(ModelState);
            }

            _logger.Info("Generate Rejection Report");
            var result = await _rejectionService.Generate(criteria.From,criteria.To);
            var items = _mapper.Map<RejectionReportDto>(result);
            return Ok(items);
        }

        [HttpPost]
        [ApiExceptionFilter]
        public async Task<IActionResult> Actioned(ActionedReportRequestDto criteria)
        {
            if (!ModelState.IsValid)
            {
                return BadRequest(ModelState);
            }

            _logger.Info("Generate Actioned Report");
            var result = await _actionedService.Generate(criteria.From,criteria.To);
            var items = _mapper.Map<ActionedReportDto>(result);
            return Ok(items);
        }
    }
}

处理程序

namespace Sx.Workflow.Reporting.Handlers
{
    public class ActionedReportHandler : IHandleEvent<ApplicationActionedEvent>
    {
        private readonly IActionedService _service;

        public ActionedReportHandler(IActionedService service)
        {
            _service = service;
        }

        public Task Handle(ApplicationActionedEvent args)
        {
            var actioned = new Actioned
            {
                ApplicationNumber = args.ApplicationNumber,AssigneeFrom = args.AssigneeFrom,Assigneeto = args.Assigneeto,DepartmentFrom = args.DepartmentFrom.Name,DepartmentTo = args.DepartmentTo.Name,Reason = args.RejectReasonName,Comments = args.RejectReasonText,RejectionDate = DateTime.Now
            };

            return _service.Save(actioned);
        }
    }
}

服务

namespace Sx.Workflow.Reporting.Services
{
    public class ActionedService : IActionedService
    {
        private readonly ISaveActioned _saveActioned;
        private readonly IGenerateActionedReport _actionedReport;

        public ActionedService(ISaveActioned saveActioned,IGenerateActionedReport actionedReport)
        {
            _saveActioned = saveActioned;
            _actionedReport = actionedReport;
        }

        public Task<ActionedReport> Generate(DateTime from,DateTime to)
        {
            return _actionedReport.Generate(from,to);
        }

        public Task Save(Actioned actioned)
        {
            return _saveActioned.Save(actioned);
        }
    }
}

界面

namespace Sx.Workflow.Reporting.Services
{
    public interface IActionedService
    {
        Task Save(Actioned actioned);
        Task<ActionedReport> Generate(DateTime from,DateTime to);
    }
}

服务模块

public class ServiceModule : Module
{
    protected override void Load(ContainerBuilder builder)
    {
        builder.RegisterType<RejectionService>()
            .As<IRejectionService>()
            .InstancePerLifetimeScope();

        builder.RegisterType<ActionedService>()
            .As<IActionedService>()
            .InstancePerLifetimeScope();
    }
}

解决方法

有道理。当您在 DI 中注册类型时，您没有任何用途：

        public ActionedService(ISaveActioned saveActioned,IGenerateActionedReport actionedReport)

所以 autofac 假设 ActionedService 中必须有一个空的构造函数

所以有两种解决方案：

1. 移除构造函数参数并在没有 DI 的情况下创建它们
2. 为构造函数的两个参数创建注册。类似于以下内容：

protected override void Load(ContainerBuilder builder)
    {
        builder.RegisterType<RejectionService>()
            .As<IRejectionService>()
            .InstancePerLifetimeScope();

        builder.RegisterType<ActionedService>()
            .As<IActionedService>()
            .InstancePerLifetimeScope();

        builder.RegisterType<SaveActioned>()
            .As<ISaveActioned>()
            .InstancePerLifetimeScope();

        builder.RegisterType<GenerateActionedReport>()
            .As<IGenerateActionedReport>()
            .InstancePerLifetimeScope();
    }