C# 在泛型类中插入依赖项时出错

我有一个类和泛型接口，在尝试注入时会发生错误：

System.ArgumentException:'无法实例化实现类型 'Application.Process.ProcessIntegrationUseCase.GenericClass.HandlerManager

1[T]'
对于服务类型
“Application.Process.ProcessIntegrationUseCase.GenericClass.IHandlerManager

1[T]”

namespace Application.Process.ProcessIntegrationUseCase.GenericClass
{
公共抽象类HandlerManager:IHandlerManager
{
受保护的IHandlerManager成功者；
公共部门主管（IHandlerManager sucessor）
{
this.sucessor=sucessor；
}
公开摘要无效处理请求（T请求）；
}
}

接口IHandlerManager

namespace Application.Process.ProcessIntegrationUseCase.GenericClass
{
    public interface IHandlerManager<T> 
    {
        void SetSucessor(IHandlerManager<T> sucessor);

        void ProcessRequest(T request);

    }
}

using Domain.Meta;
using System;
using Microsoft.Extensions.Logging;
using Application.Process.ProcessIntegrationUseCase.GenericClass;

namespace Application.UseCases.Process.ProcessIntegrationUseCase.Habitacional
{
    public sealed class ProcessHabitacionalUseCase : IProcessHabitacionalUseCase
    {
        private readonly StartProcessHandler<HistoryHabitacional> _startProcessHandler;

        private readonly ILogger _iLogger;

        public ProcessHabitacionalUseCase(ILogger iLogger,
                                    StartProcessHandler<HistoryHabitacional> startProcessHandler)

        {
            _iLogger = iLogger;

            _startProcessHandler = startProcessHandler;

        }

        public void Execute(HistoryHabitacional history)
        {
            if (history == null)
                throw new ArgumentNullException();

            try
            {              

               _startProcessHandler.ProcessRequest(history);

            }
            catch (Exception ex)
            {

                throw ex;
            }

        }
     }

}

using System;
using System.Reflection;
using Microsoft.Extensions.Logging;
using Application.Repositories.History;
using Application.Repositories.I4Pro;
using Domain.Process.Enum;

namespace Application.Process.ProcessIntegrationUseCase.GenericClass
{

     public class StartProcessHandler<T> : HandlerManager<T> where T: class
    {
        private readonly ILogger _iLogger;
        private readonly IHistoryReadOnlyRepository _historyReadOnlyRepository;
        private readonly II4ProReadOnlyRepository _i4ProReadOnlyRepository;

         public StartProcessHandler(ILogger iLogger,
                               IHistoryReadOnlyRepository historyReadOnlyRepository,
                               II4ProReadOnlyRepository i4ProReadOnlyRepository)
        {
             _iLogger = iLogger;
             _historyReadOnlyRepository = historyReadOnlyRepository;
             _i4ProReadOnlyRepository = i4ProReadOnlyRepository;
         }

        public override void ProcessRequest(T history)
        {
            try
            {

                 TypeIntegration typeIntegration = (TypeIntegration)history.GetType().GetProperty("TypeIntegration").GetValue(history);

                _iLogger.LogInformation("Buscando execuções MetaIntegra");
                var item = _historyReadOnlyRepository.GetLastHistory(typeIntegration);

                _iLogger.LogInformation("Buscando execuções I4Pro");
                var i4Process = _i4ProReadOnlyRepository.ListLastExecutions();

                _iLogger.LogInformation("Executing Habitacional Integration_" + DateTime.Now.ToString());
                 if ((item != null && i4Process[0].Id_Processo_Log != item.LastIdI4Pro) || item == null)
                 { 
     history.GetType().GetProperty("LastIdI4Pro").SetValue(history, 
item.LastIdI4Pro);

     history.GetType().GetProperty("IdProcessoLog").SetValue(history, 
i4Process[0].Id_Processo_Log);

                    if (base.sucessor != null)
                    sucessor.ProcessRequest(history);

                }
            }
            catch (Exception ex)
            {
                _iLogger.LogError(ex.Message);

            }
        }
    }
}

namespace Application.Process.ProcessIntegrationUseCase.GenericClass
{
公共接口IHandlerManager
{
无效销售主管（IHandlerManager sucessor）；
无效处理请求（T请求）；
}
}

依赖性注射

public void Register(IServiceCollection services)
{

   // Injection History Use Cases Application


   services.AddTransient(typeof(IHandlerManager<>),
   typeof(HandlerManager<>));


}

公共作废登记簿（IServiceCollection服务）
{
//注入历史用例应用程序
服务。添加临时（类型为（IHandlerManager），
类型（HandlerManager））；
}

调用注入HandlerManager的代码

namespace Application.Process.ProcessIntegrationUseCase.GenericClass
{
    public interface IHandlerManager<T> 
    {
        void SetSucessor(IHandlerManager<T> sucessor);

        void ProcessRequest(T request);

    }
}

using Domain.Meta;
using System;
using Microsoft.Extensions.Logging;
using Application.Process.ProcessIntegrationUseCase.GenericClass;

namespace Application.UseCases.Process.ProcessIntegrationUseCase.Habitacional
{
    public sealed class ProcessHabitacionalUseCase : IProcessHabitacionalUseCase
    {
        private readonly StartProcessHandler<HistoryHabitacional> _startProcessHandler;

        private readonly ILogger _iLogger;

        public ProcessHabitacionalUseCase(ILogger iLogger,
                                    StartProcessHandler<HistoryHabitacional> startProcessHandler)

        {
            _iLogger = iLogger;

            _startProcessHandler = startProcessHandler;

        }

        public void Execute(HistoryHabitacional history)
        {
            if (history == null)
                throw new ArgumentNullException();

            try
            {              

               _startProcessHandler.ProcessRequest(history);

            }
            catch (Exception ex)
            {

                throw ex;
            }

        }
     }

}

using System;
using System.Reflection;
using Microsoft.Extensions.Logging;
using Application.Repositories.History;
using Application.Repositories.I4Pro;
using Domain.Process.Enum;

namespace Application.Process.ProcessIntegrationUseCase.GenericClass
{

     public class StartProcessHandler<T> : HandlerManager<T> where T: class
    {
        private readonly ILogger _iLogger;
        private readonly IHistoryReadOnlyRepository _historyReadOnlyRepository;
        private readonly II4ProReadOnlyRepository _i4ProReadOnlyRepository;

         public StartProcessHandler(ILogger iLogger,
                               IHistoryReadOnlyRepository historyReadOnlyRepository,
                               II4ProReadOnlyRepository i4ProReadOnlyRepository)
        {
             _iLogger = iLogger;
             _historyReadOnlyRepository = historyReadOnlyRepository;
             _i4ProReadOnlyRepository = i4ProReadOnlyRepository;
         }

        public override void ProcessRequest(T history)
        {
            try
            {

                 TypeIntegration typeIntegration = (TypeIntegration)history.GetType().GetProperty("TypeIntegration").GetValue(history);

                _iLogger.LogInformation("Buscando execuções MetaIntegra");
                var item = _historyReadOnlyRepository.GetLastHistory(typeIntegration);

                _iLogger.LogInformation("Buscando execuções I4Pro");
                var i4Process = _i4ProReadOnlyRepository.ListLastExecutions();

                _iLogger.LogInformation("Executing Habitacional Integration_" + DateTime.Now.ToString());
                 if ((item != null && i4Process[0].Id_Processo_Log != item.LastIdI4Pro) || item == null)
                 { 
     history.GetType().GetProperty("LastIdI4Pro").SetValue(history, 
item.LastIdI4Pro);

     history.GetType().GetProperty("IdProcessoLog").SetValue(history, 
i4Process[0].Id_Processo_Log);

                    if (base.sucessor != null)
                    sucessor.ProcessRequest(history);

                }
            }
            catch (Exception ex)
            {
                _iLogger.LogError(ex.Message);

            }
        }
    }
}

使用Domain.Meta；
使用制度；
使用Microsoft.Extensions.Logging；
使用Application.Process.ProcessIntegrationUseCase.GenericClass；
命名空间Application.UseCases.Process.ProcessIntegrationUseCase.Habitacional
{
公共密封类ProcessHabitacionalUseCase:IPProcessHabitacionalUseCase
{
私有只读StartProcessHandler\u StartProcessHandler；
私有只读ILogger；
公共过程分析案例（ILogger ILogger，
StartProcessHandler（StartProcessHandler）
{
_iLogger=iLogger；
_startProcessHandler=startProcessHandler；
}
public void Execute（历史居住历史）
{
如果（历史==null）
抛出新ArgumentNullException（）；
尝试
{              
_ProcessRequest（历史记录）；
}
捕获（例外情况除外）
{
掷骰子；
}
}
}
}

类，该类重写HandlerManager中的方法

namespace Application.Process.ProcessIntegrationUseCase.GenericClass
{
    public interface IHandlerManager<T> 
    {
        void SetSucessor(IHandlerManager<T> sucessor);

        void ProcessRequest(T request);

    }
}

using Domain.Meta;
using System;
using Microsoft.Extensions.Logging;
using Application.Process.ProcessIntegrationUseCase.GenericClass;

namespace Application.UseCases.Process.ProcessIntegrationUseCase.Habitacional
{
    public sealed class ProcessHabitacionalUseCase : IProcessHabitacionalUseCase
    {
        private readonly StartProcessHandler<HistoryHabitacional> _startProcessHandler;

        private readonly ILogger _iLogger;

        public ProcessHabitacionalUseCase(ILogger iLogger,
                                    StartProcessHandler<HistoryHabitacional> startProcessHandler)

        {
            _iLogger = iLogger;

            _startProcessHandler = startProcessHandler;

        }

        public void Execute(HistoryHabitacional history)
        {
            if (history == null)
                throw new ArgumentNullException();

            try
            {              

               _startProcessHandler.ProcessRequest(history);

            }
            catch (Exception ex)
            {

                throw ex;
            }

        }
     }

}

using System;
using System.Reflection;
using Microsoft.Extensions.Logging;
using Application.Repositories.History;
using Application.Repositories.I4Pro;
using Domain.Process.Enum;

namespace Application.Process.ProcessIntegrationUseCase.GenericClass
{

     public class StartProcessHandler<T> : HandlerManager<T> where T: class
    {
        private readonly ILogger _iLogger;
        private readonly IHistoryReadOnlyRepository _historyReadOnlyRepository;
        private readonly II4ProReadOnlyRepository _i4ProReadOnlyRepository;

         public StartProcessHandler(ILogger iLogger,
                               IHistoryReadOnlyRepository historyReadOnlyRepository,
                               II4ProReadOnlyRepository i4ProReadOnlyRepository)
        {
             _iLogger = iLogger;
             _historyReadOnlyRepository = historyReadOnlyRepository;
             _i4ProReadOnlyRepository = i4ProReadOnlyRepository;
         }

        public override void ProcessRequest(T history)
        {
            try
            {

                 TypeIntegration typeIntegration = (TypeIntegration)history.GetType().GetProperty("TypeIntegration").GetValue(history);

                _iLogger.LogInformation("Buscando execuções MetaIntegra");
                var item = _historyReadOnlyRepository.GetLastHistory(typeIntegration);

                _iLogger.LogInformation("Buscando execuções I4Pro");
                var i4Process = _i4ProReadOnlyRepository.ListLastExecutions();

                _iLogger.LogInformation("Executing Habitacional Integration_" + DateTime.Now.ToString());
                 if ((item != null && i4Process[0].Id_Processo_Log != item.LastIdI4Pro) || item == null)
                 { 
     history.GetType().GetProperty("LastIdI4Pro").SetValue(history, 
item.LastIdI4Pro);

     history.GetType().GetProperty("IdProcessoLog").SetValue(history, 
i4Process[0].Id_Processo_Log);

                    if (base.sucessor != null)
                    sucessor.ProcessRequest(history);

                }
            }
            catch (Exception ex)
            {
                _iLogger.LogError(ex.Message);

            }
        }
    }
}

使用系统；
运用系统反思；
使用Microsoft.Extensions.Logging；
使用Application.Repositories.History；
使用Application.Repositories.I4Pro；
使用Domain.Process.Enum；
命名空间Application.Process.ProcessIntegrationUseCase.GenericClass
{
公共类StartProcessHandler:HandlerManager其中T:class
{
私有只读ILogger；
私有只读IHistoryReadOnlyRepository\u historyReadOnlyRepository；
私有只读II4只读存储库—只读存储库；
公共启动进程处理程序（ILogger ILogger，
I History ReadOnly Repository History ReadOnly Repository，
II4只读存储I4只读存储）
{
_iLogger=iLogger；
_historyReadOnlyRepository=historyReadOnlyRepository；
_i4ProReadOnlyRepository=i4ProReadOnlyRepository；
}
公共覆盖无效处理请求（T历史记录）
{
尝试
{
TypeIntegration TypeIntegration=（TypeIntegration）history.GetType（）.GetProperty（“TypeIntegration”）.GetValue（history）；
_iLogger.物流信息（“Buscando Executuções MetaIntegra”）；
var item=\u historyReadOnlyRepository.GetLastHistory（类型集成）；
_iLogger.物流信息（“Buscando Executuções I4Pro”）；
var i4Process=_i4ProReadOnlyRepository.ListLastExecutions（）；
_iLogger.LogInformation（“执行人居集成”+DateTime.Now.ToString（））；
if（（item！=null&&i4Process[0].Id_Processo_Log！=item.lastid4pro）| item==null）
{ 
history.GetType（）.GetProperty（“LastIdI4Pro”）.SetValue（历史，
项目：LastIdI4Pro）；
history.GetType（）.GetProperty（“IdProcessoLog”）.SetValue（历史，
I4进程[0]。Id\u进程\u日志）；
if（base.sucessor！=null）
sucessor.ProcessRequest（历史记录）；
}
}
捕获（例外情况除外）
{
_iLogger.LogError（例如消息）；
}
}
}
}

不能像这样使用泛型类型

AddTransient（）

要求可以将指定的第二种类型的实例分配给第一种类型的引用。通用的

HandlerManager

不能分配给

IHandlerManager

；您需要指定隐式类型，并以一致的方式进行指定

---

此外，

HandlerManager

是抽象的，您无法创建它的实例。

这是运行时异常吗？是的。当调用继承IHandlerManager的类时，这是一个运行时异常