title: DependencyResolutionException: None of the constructors found with 'Autofac.Core.Activators.Reflection.DefaultConstructorFinder' on type
body: <p>It was working earlier before adding <code>actionedService</code> which is similar to <code>rejectionService</code>, throws following error</p>
  <blockquote>
  <p>An unhandled exception occurred while processing the request.
  DependencyResolutionException: None of the constructors found with 'Autofac.Core.Activators.Reflection.DefaultConstructorFinder' on type 'Sx.Workflow.Server.Controllers.ReportController' can be invoked with the available services and parameters:
  Cannot resolve parameter 'Sx.Workflow.Reporting.Services.IActionedService actionedService' of constructor 'Void .ctor(NLog.ILogger, AutoMapper.IMapper, Sx.Workflow.Reporting.Services.IRejectionService, Sx.Workflow.Reporting.Services.IActionedService)'.
  Autofac.Core.Activators.Reflection.ReflectionActivator.GetValidConstructorBindings(ConstructorInfo[] availableConstructors, IComponentContext context, IEnumerable parameters) in ReflectionActivator.cs, line 160</p>
  </blockquote>
  <p><strong>Controller</strong></p>
  <pre><code>namespace Sx.Workflow.Server.Controllers
  {
      [MenuItem(&quot;report&quot;)]
      [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(&quot;Report Controller&quot;);
              return View();
          }
  
          [HttpPost]
          [ApiExceptionFilter]
          public async Task&lt;IActionResult&gt; Reject(RejectionReportRequestDto criteria)
          {
              if (!ModelState.IsValid)
              {
                  return BadRequest(ModelState);
              }
  
              _logger.Info(&quot;Generate Rejection Report&quot;);
              var result = await _rejectionService.Generate(criteria.From, criteria.To);
              var items = _mapper.Map&lt;RejectionReportDto&gt;(result);
              return Ok(items);
          }
  
          [HttpPost]
          [ApiExceptionFilter]
          public async Task&lt;IActionResult&gt; Actioned(ActionedReportRequestDto criteria)
          {
              if (!ModelState.IsValid)
              {
                  return BadRequest(ModelState);
              }
  
              _logger.Info(&quot;Generate Actioned Report&quot;);
              var result = await _actionedService.Generate(criteria.From, criteria.To);
              var items = _mapper.Map&lt;ActionedReportDto&gt;(result);
              return Ok(items);
          }
      }
  }
  </code></pre>
  <p><strong>Handler</strong></p>
  <pre><code>namespace Sx.Workflow.Reporting.Handlers
  {
      public class ActionedReportHandler : IHandleEvent&lt;ApplicationActionedEvent&gt;
      {
          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);
          }
      }
  }
  </code></pre>
  <p><strong>Service</strong></p>
  <pre><code>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&lt;ActionedReport&gt; Generate(DateTime from, DateTime to)
          {
              return _actionedReport.Generate(from, to);
          }
  
          public Task Save(Actioned actioned)
          {
              return _saveActioned.Save(actioned);
          }
      }
  }
  </code></pre>
  <p><strong>Interface</strong></p>
  <pre><code>namespace Sx.Workflow.Reporting.Services
  {
      public interface IActionedService
      {
          Task Save(Actioned actioned);
          Task&lt;ActionedReport&gt; Generate(DateTime from, DateTime to);
      }
  }
  </code></pre>
  <p><strong>Service Module</strong></p>
  <pre><code>public class ServiceModule : Module
  {
      protected override void Load(ContainerBuilder builder)
      {
          builder.RegisterType&lt;RejectionService&gt;()
              .As&lt;IRejectionService&gt;()
              .InstancePerLifetimeScope();
  
          builder.RegisterType&lt;ActionedService&gt;()
              .As&lt;IActionedService&gt;()
              .InstancePerLifetimeScope();
      }
  }
  </code></pre>