Autofac C#的依赖项注入-注册泛型类型时是否可以指定工厂方法

我对DI和Autofac非常陌生。我有一个单例类

ProducerService

，如下所示。这在BackgroundService的构造函数中用作依赖项。ProducerService有一个构造函数注入依赖项，

IKafkaProducerAggregate

，如下所示

如何创建一个

IKafkaProducerAggregate

的实例，该实例是为注入到ProducerService而创建的？这包含来自外部Kafka confluent dotnet库的

IProducer

实例，通过工厂方法

IProducer producer=new ProducerBuilder（Config.producer）.Build（）。我可以在Autofac中使用某种工厂方法来创建聚合实例并使用Kafka confluences工厂方法初始化
IProducer

到目前为止，我有一个注册生产商服务的Autofac模块，我很难理解如何使用类似于工厂方法的东西？？？这将在创建ProducerService时创建IKafkaProducerAggregate：

Assembly serializers = typeof(ConsumerService).GetTypeInfo().Assembly;

builder.RegisterGeneric(typeof(ProducerService<,>))
    .As(typeof(IKafkaProducer<,>))
    .SingleInstance();

Assembly serializers=typeof（ConsumerService）.GetTypeInfo（）.Assembly；
建造商注册通用（类型（生产服务））
.As（生产商类型）
.SingleInstance（）；

接口：IKafkaProducerAggregate

public interface IKafkaProducerAggregate<TKey, TValue>
{
    IProducer<TKey, TValue> Producer { get; }
    Action<DeliveryReport<TKey, TValue>> DeliveryReportAction { get; }
}

namespace WebApp.Kafka
{
    public class ProducerService<Key, Value> : IProducerService<Key, Value>, IDisposable
    {
        private bool Disposed { get; set; }
        private IKafkaProducerAggregate<Key, Value> ProducerAggregate { get; }
        private ILogger Logger { get; set; }


        ProducerService(
            IKafkaProducerAggregate<Key, Value> aggregate,
            ILogger<ProducerService<Key, Value>> logger)
        {
            Logger = logger ?? throw new ArgumentNullException(nameof(logger));
            ProducerAggregate = aggregate ?? throw new ArgumentNullException(nameof(aggregate));

            Disposed = false;

            Logger.LogInformation("ProducerService constructor called");
        }

        public void Produce(string topic, Key key, Value value)
        {
            ProducerAggregate.Producer.Produce(topic, new Message<Key, Value> { Key = key, Value = value }, ProducerAggregate.DeliveryReportAction);

            Logger.LogInformation("Produce topic : {}, key : {}, value : {}", topic, key.ToString(), value.ToString());
        }

        public void Dispose()
        {
            Dispose(true);
            GC.SuppressFinalize(this);
        }

        protected virtual void Dispose(bool disposing)
        {
            if (!Disposed)
            {
                if (disposing)
                {
                    Logger.LogInformation("Disposing Kafka producer...");
                    ProducerAggregate.Producer.Dispose();
                }

                Disposed = true;
            }
        }

        ~ProducerService()
        {
            Dispose(false);
        }
    }
}

公共接口IKafkaProducerAggregate
{
IProducer生产者{get；}
操作DeliveryReportAction{get；}
}

类别：产品服务

public interface IKafkaProducerAggregate<TKey, TValue>
{
    IProducer<TKey, TValue> Producer { get; }
    Action<DeliveryReport<TKey, TValue>> DeliveryReportAction { get; }
}

namespace WebApp.Kafka
{
    public class ProducerService<Key, Value> : IProducerService<Key, Value>, IDisposable
    {
        private bool Disposed { get; set; }
        private IKafkaProducerAggregate<Key, Value> ProducerAggregate { get; }
        private ILogger Logger { get; set; }


        ProducerService(
            IKafkaProducerAggregate<Key, Value> aggregate,
            ILogger<ProducerService<Key, Value>> logger)
        {
            Logger = logger ?? throw new ArgumentNullException(nameof(logger));
            ProducerAggregate = aggregate ?? throw new ArgumentNullException(nameof(aggregate));

            Disposed = false;

            Logger.LogInformation("ProducerService constructor called");
        }

        public void Produce(string topic, Key key, Value value)
        {
            ProducerAggregate.Producer.Produce(topic, new Message<Key, Value> { Key = key, Value = value }, ProducerAggregate.DeliveryReportAction);

            Logger.LogInformation("Produce topic : {}, key : {}, value : {}", topic, key.ToString(), value.ToString());
        }

        public void Dispose()
        {
            Dispose(true);
            GC.SuppressFinalize(this);
        }

        protected virtual void Dispose(bool disposing)
        {
            if (!Disposed)
            {
                if (disposing)
                {
                    Logger.LogInformation("Disposing Kafka producer...");
                    ProducerAggregate.Producer.Dispose();
                }

                Disposed = true;
            }
        }

        ~ProducerService()
        {
            Dispose(false);
        }
    }
}

namespace WebApp.Kafka
{
公共类ProducerService:IProducerService，IDisposable
{
私有布尔处理{get；set；}
私有IKafkaProducerAggregate ProducerAggregate{get；}
专用ILogger记录器{get；set；}
生产服务(
IKafkaProducerAggregate骨料，
ILogger（记录器）
{
Logger=Logger？？抛出新的ArgumentNullException（name of（Logger））；
ProducerAggregate=aggregate？？抛出新ArgumentNullException（nameof（aggregate））；
已处理=错误；
Logger.LogInformation（“调用了ProducerService构造函数”）；
}
公共void生成（字符串主题、键、值）
{
ProducerAggregate.Producer.product（主题，新消息{Key=Key，Value=Value}，ProducerAggregate.DeliveryReportAction）；
Logger.LogInformation（“生成主题：{}，键：{}，值：{}”，主题，键.ToString（），值.ToString（））；
}
公共空间处置（）
{
处置（真实）；
总干事（本）；
}
受保护的虚拟void Dispose（bool disposing）
{
如果（！已处置）
{
如果（处置）
{
Logger.LogInformation（“处置卡夫卡制作人…”）；
ProducerAggregate.Producer.Dispose（）；
}
这是真的；
}
}
~ProducerService（）
{
处置（虚假）；
}
}
}
在构造函数中创建依赖项的新实例不需要任何工厂，只需使用InstancePerDependence生存期范围，而不是SingleInstance

您好，谢谢您的回复。我在问题中补充了更多细节。
ProducerService
本身在
BackgroundService
中用作依赖项。因此，我只希望创建一个ProducerService实例。聚合中的
IProducer
实例需要通过外部Kafka confluent dotnet库的工厂创建。提供示例有点困难，我建议您查看文档。请看一看短语“您也可以使用委托来提供封闭的泛型类型…”引入的示例。您希望每个泛型实例化有一个实例，对吗？是的，
ProducerService
的单个实例，其参数为
IKafkaProducerAggregate
，使用某种工厂方法创建，以允许创建其
IProducer
属性。