Dependency injection 如何在windsor容器中注入依赖项MassTransit消费者

如何在使用者类中使用依赖项注入。我收到的错误消息为“类型'Esb.Masstransit.RabbitMq.Application.IEventConsumerService'不能用作泛型类型或方法'Masstransit.ConsumerExtensions.Consumer'中的类型参数'TConsumer'（Masstransit.IRecieveEndPointConfigurator，System.Action）“。没有从“Esb.masstTransit.RabbitMq.Application.IEventConsumerService”到“masstTransit.IConsumer”的隐式引用转换”

这是容器类

container.Register(Component.For<IEventConsumerService>().ImplementedBy<EventConsumerService>().LifestyleSingleton());
container.Register(Component.For<ICommandConsumerService>().ImplementedBy<CommandConsumerService>().LifestyleSingleton());

var busControl = Bus.Factory.CreateUsingRabbitMq(rabbit =>
        {
            var host = rabbit.Host(new Uri(rabbitMqHost), settings =>
            {
                settings.Password(rabbitMqUserName);
                settings.Username(rabbitMqPassword); 
            }); 

            rabbit.ReceiveEndpoint(host, eventQueue1, e =>
            {
                e.BindMessageExchanges = false; 
               e.Consumer<EventConsumerService>(); // I getting error here
                e.Bind(typeof(IPublishMessage).FullName.Split('.').LastOrDefault(), x =>
                {
                    x.RoutingKey = "1";
                    x.ExchangeType = ExchangeType.Direct;
                });
            }); 
        }); 
        container.Register(Component.For<IBus, IBusControl>().Instance(busControl));

container.Register（Component.For（）.ImplementedBy（）.LifestyleSingleton（））；
container.Register（Component.For（）.ImplementedBy（）.LifestyleSingleton（））；
var busControl=Bus.Factory.CreateUsingRabbitMq（兔子=>
{
var host=rabbit.host（新Uri（rabbitMqHost），设置=>
{
设置.密码（rabbitMqUserName）；
用户名（rabbitMqPassword）；
}); 
ReceiveEndpoint（主机，eventQueue1，e=>
{
e、 bindMessageExchange=false；
e、 Consumer（）；//我在这里遇到错误
e、 Bind（typeof（ippublishmessage）.FullName.Split（'.'）.LastOrDefault（），x=>
{
x、 RoutingKey=“1”；
x、 ExchangeType=ExchangeType.Direct；
});
}); 
}); 
Register（Component.For（）.Instance（busControl））；

这是消费类

public class EventConsumerService : BaseLogger, IEventConsumerService, IConsumer<IPublishMessage>
{
    private readonly ICommandConsumerService _service;

    public EventConsumerService(ICommandConsumerService service)
    {
        _service = service;
    }

    public Task Consume(ConsumeContext<IPublishMessage> context)
    {
        try
        { 
            Console.WriteLine("In event consumer " + context.MessageId + " _" + context.Message.MessageId + ", " + context.Message.Message + " " + context.Message.CreationDate);
            return Task.CompletedTask;
        }
        catch (Exception ex)
        {
           Logger.Error("EventConsumerService", ex);
        }
        return Task.CompletedTask;
    } 
}

公共类EventConsumerService:BaseLogger、IEventConsumerService、IConsumer
{
专用只读ICommandConsumerService\u服务；
公共事件消费者服务（ICommandConsumerService服务）
{
_服务=服务；
}
公共任务消费（消费上下文）
{
尝试
{ 
Console.WriteLine（“事件内使用者”+context.MessageId+“”+context.Message.MessageId+”，“+context.Message.Message+”+context.Message.CreationDate）；
返回Task.CompletedTask；
}
捕获（例外情况除外）
{
Logger.Error（“EventConsumerService”，ex）；
}
返回Task.CompletedTask；
} 
}

您应该使用容器集成包，并按照中所示配置容器

此外，使用者应注册为具体类型，而不是接口

根据你的例子：

var container = new WindsorContainer();
container.AddMassTransit(x =>
{
    x.AddConsumer<EventConsumerService>();

    x.UsingRabbitMq(cfg =>
    {
        cfg.Host(new Uri(rabbitMqHost), settings =>
        {
            settings.Password(rabbitMqUserName);
            settings.Username(rabbitMqPassword); 
        }); 

        cfg.ReceiveEndpoint(eventQueue1, ec =>
        {
            ec.ConfigureConsumeTopology = false; 
            ec.Bind(typeof(IPublishMessage).FullName.Split('.').LastOrDefault(), b =>
            {
                b.RoutingKey = "1";
                b.ExchangeType = ExchangeType.Direct;
            });

            ec.ConfigureConsumer<EventConsumerService>(context);
        });
    });
});

var容器=新的WindsorContainer（）；
container.AddMassTransit（x=>
{
x、 AddConsumer（）；
x、 使用RabbitMQ（cfg=>
{
主机（新Uri（rabbitMqHost），设置=>
{
设置.密码（rabbitMqUserName）；
用户名（rabbitMqPassword）；
}); 
接收端点（eventQueue1，ec=>
{
ec.ConfigureConsumeTopology=false；
ec.Bind（typeof（ippublishmessage）.FullName.Split（'.'）.LastOrDefault（），b=>
{
b、 RoutingKey=“1”；
b、 ExchangeType=ExchangeType.Direct；
});
ec.配置消费者（上下文）；
});
});
});

消费者不应该是单身，他们应该被限定范围。上面的代码将为您在容器中注册消费者