C# MassTransit RabbitMq调度消息未发送到使用者

我想使用MassTransit+RabbitMq总线来调度来自总线的消息。我编写了两个C#控制台应用程序，一个用于消息创建者并将消息发送到schedular，另一个用于消息使用者

class Program
{
    static void Main(string[] args)
    {
        var busControl = Bus.Factory.CreateUsingRabbitMq(rabbit =>
        {
            var host = rabbit.Host(new Uri("rabbitmq://localhost:5672"), settings =>
            {
                settings.Password("guest");
                settings.Username("guest");
            });

            rabbit.ReceiveEndpoint(host, "publisher", conf =>
            {
                conf.Consumer<Consumer>();
            });
        });

        busControl.Start();
        Console.ReadKey();
        busControl.Stop();
    }
}

public class Consumer : IConsumer<MessageCreated>
{
    public Task Consume(ConsumeContext<MessageCreated> context)
    {
        MessageCreated message = context.Message;
        Console.WriteLine(message.Text);

        context.Publish(new MessagePublished
        {
            Text = message.Text,
        });

        return Task.FromResult(context.Message);
    }
}

以下代码用于在总线中进行调度，以便每秒向调度程序发送一条消息，然后调度程序以10秒的延迟发送给消费者。我的问题是没有消息发送到rabbitMq客户机中的使用者或使用者队列。我的错在哪里

注意：UseInMemoryScheduler工作正常，但UseMessageScheduler不工作。

总线消息创建者

class Program
{
    public static void Main(string[] args)
    {
        MainAsync(args).GetAwaiter().GetResult();

        Console.ReadKey();
    }

    static async Task MainAsync(string[] args)
    {
        var busControl = Bus.Factory.CreateUsingRabbitMq(rabbit =>
        {
            var host = rabbit.Host(new Uri("rabbitmq://localhost:5672"), settings =>
            {
                settings.Username("guest");
                settings.Password("guest");
            });

            //rabbit.UseInMemoryScheduler(); // This works
            rabbit.UseMessageScheduler(new Uri("rabbitmq://localhost/quartz"));// This doesn't work,
        });

        busControl.Start();

        var sendEndpoint = await busControl.GetSendEndpoint(new Uri("rabbitmq://localhost/quartz"));

        for (int i = 0; i < 1000000; i++)
        {
            await sendEndpoint.ScheduleSend(new Uri("rabbitmq://localhost/publisher"), 
                DateTime.Now.AddSeconds(10), 
                new MessageCreated()
                {
                    Text = $"message {i}"
                });

            Thread.Sleep(1000);
        }

        Console.ReadKey();

        busControl.Stop();
    }
}

类程序
{
公共静态void Main（字符串[]args）
{
MainAsync（args）.GetAwaiter（）.GetResult（）；
Console.ReadKey（）；
}
静态异步任务mainsync（字符串[]args）
{
var busControl=Bus.Factory.CreateUsingRabbitMq（兔子=>
{
var host=rabbit.host（新Uri（“rabbitmq://localhost:5672“”，设置=>
{
设置。用户名（“来宾”）；
设置。密码（“来宾”）；
});
//rabbit.UseInMemoryScheduler（）；//这很有效
UseMessageScheduler（新Uri（“rabbitmq://localhost/quartz）；//这行不通，
});
busControl.Start（）；
var sendEndpoint=await busControl.GetSendEndpoint（新Uri（“rabbitmq://localhost/quartz"));
对于（int i=0；i<1000000；i++）
{
等待sendEndpoint.ScheduleSend（新Uri（“rabbitmq://localhost/publisher"), 
DateTime.Now.AddSeconds（10），
新建MessageCreated（）
{
Text=$“消息{i}”
});
睡眠（1000）；
}
Console.ReadKey（）；
busControl.Stop（）；
}
}

消息消费者

class Program
{
    static void Main(string[] args)
    {
        var busControl = Bus.Factory.CreateUsingRabbitMq(rabbit =>
        {
            var host = rabbit.Host(new Uri("rabbitmq://localhost:5672"), settings =>
            {
                settings.Password("guest");
                settings.Username("guest");
            });

            rabbit.ReceiveEndpoint(host, "publisher", conf =>
            {
                conf.Consumer<Consumer>();
            });
        });

        busControl.Start();
        Console.ReadKey();
        busControl.Stop();
    }
}

public class Consumer : IConsumer<MessageCreated>
{
    public Task Consume(ConsumeContext<MessageCreated> context)
    {
        MessageCreated message = context.Message;
        Console.WriteLine(message.Text);

        context.Publish(new MessagePublished
        {
            Text = message.Text,
        });

        return Task.FromResult(context.Message);
    }
}

类程序
{
静态void Main（字符串[]参数）
{
var busControl=Bus.Factory.CreateUsingRabbitMq（兔子=>
{
var host=rabbit.host（新Uri（“rabbitmq://localhost:5672“”，设置=>
{
设置。密码（“来宾”）；
设置。用户名（“来宾”）；
});
ReceiveEndpoint（主机，“发布者”，conf=>
{
消费者形态（）；
});
});
busControl.Start（）；
Console.ReadKey（）；
busControl.Stop（）；
}
}
公共类消费者：IConsumer
{
公共任务消费（消费上下文）
{
MessageCreated message=context.message；
Console.WriteLine（message.Text）；
context.Publish（新消息已发布）
{
Text=message.Text，
});
返回Task.FromResult（context.Message）；
}
}

已更新 根据@maldworth的回答，我更改了以下代码。但问题并没有解决

class Program
{
    public static void Main(string[] args)
    {
        MainAsync(args).GetAwaiter().GetResult();

        Console.ReadKey();
    }

    private static async Task<IScheduler> CreateSchedulerAsync()
    {
        var schedulerFactory = new StdSchedulerFactory();

        var scheduler = await schedulerFactory.GetScheduler();

        return scheduler;
    }

    static async Task MainAsync(string[] args)
    {
        var busControl = Bus.Factory.CreateUsingRabbitMq(async cfg =>
        {
            var host = cfg.Host(new Uri("rabbitmq://localhost:5672"), settings =>
            {
                settings.Password("guest");
                settings.Username("guest");
            });

            var scheduler = await CreateSchedulerAsync();

            cfg.ReceiveEndpoint("quartz", e =>
            {
                cfg.UseMessageScheduler(e.InputAddress);

                e.Consumer(() => new ScheduleMessageConsumer(scheduler));
                e.Consumer(() => new CancelScheduledMessageConsumer(scheduler));
            });

            cfg.ReceiveEndpoint(host, "publisher", conf =>
            {
                conf.Consumer<PublisherConsumer>();
            });

            cfg.ReceiveEndpoint(host, "subscriber", conf =>
            {
                conf.Consumer<SubscriberConsumer>();
            });
        });

        busControl.Start();

        for (int i = 0; i < 1000000; i++)
        {
            var text = $"message {i}";

            Console.WriteLine($"Schedule: {text}");

            await busControl.ScheduleSend(new Uri("rabbitmq://localhost/publisher"),
                DateTime.Now.AddSeconds(30),
                new ScheduleMessage()
                {
                    Text = text
                });

            Thread.Sleep(10000);
        }

        Console.ReadKey();

        busControl.Stop();
    }
}

public class PublisherConsumer : IConsumer<ScheduleMessage>
{
    public Task Consume(ConsumeContext<ScheduleMessage> context)
    {
        Console.WriteLine($"In Publisher: {context.Message.Text}");

        context.Publish(new PublishMessage
        {
            Text = context.Message.Text,
        });

        return Task.FromResult(context.Message);
    }
}

public class SubscriberConsumer : IConsumer<PublishMessage>
{
    public Task Consume(ConsumeContext<PublishMessage> context)
    {
        Console.WriteLine($"In Subscriber: {context.Message.Text}");

        return Task.FromResult(context.Message);
    }
}

类程序
{
公共静态void Main（字符串[]args）
{
MainAsync（args）.GetAwaiter（）.GetResult（）；
Console.ReadKey（）；
}
专用静态异步任务CreateSchedulerAsync（）
{
var schedulerFactory=new StdSchedulerFactory（）；
var scheduler=await schedulerFactory.GetScheduler（）；
返回调度程序；
}
静态异步任务mainsync（字符串[]args）
{
var busControl=Bus.Factory.CreateUsingRabbitMq（异步cfg=>
{
var host=cfg.host（新Uri（“rabbitmq://localhost:5672“”，设置=>
{
设置。密码（“来宾”）；
设置。用户名（“来宾”）；
});
var scheduler=await CreateSchedulerAsync（）；
接收端点（“石英”，e=>
{
UseMessageScheduler（例如输入地址）；
e、 使用者（（）=>新的ScheduleMessageConsumer（scheduler））；
e、 使用者（（）=>新的CancelScheduledMessageConsumer（调度器））；
});
ReceiveEndpoint（主机，“发布者”，conf=>
{
消费者形态（）；
});
ReceiveEndpoint（主机，“订阅者”，conf=>
{
消费者形态（）；
});
});
busControl.Start（）；
对于（int i=0；i<1000000；i++）
{
var text=$“消息{i}”；
Console.WriteLine（$“Schedule:{text}”）；
等待busControl.ScheduleSend（新Uri（“rabbitmq://localhost/publisher"),
DateTime.Now.AddSeconds（30），
新建ScheduleMessage（）
{
文本=文本
});
睡眠（10000）；
}
Console.ReadKey（）；
busControl.Stop（）；
}
}
公共类发布者消费者：IConsumer
{
公共任务消费（消费上下文）
{
Publisher:{context.Message.Text}中的Console.WriteLine（$）；
context.Publish（新PublishMessage）
{
Text=context.Message.Text，
});
返回Task.FromResult（context.Message）；
}
}
公共类订阅用户：IConsumer
{
公共任务消费（消费上下文）
{
Subscriber:{context.Message.Text}中的Console.WriteLine（$）；
返回Task.FromResult（context.Message）；
}
}

而App.config文件内容为：

  <configSections>
    <section name="quartz" type="System.Configuration.NameValueSectionHandler, System, Version=1.0.5000.0,Culture=neutral, PublicKeyToken=b77a5c561934e089" />
  </configSections>
    <startup> 
        <supportedRuntime version="v4.0" sku=".NETFramework,Version=v4.6.2" />
    </startup>
    <quartz>
      <add key="quartz.scheduler.instanceName" value="MassTransit-Quartz" />
      <add key="quartz.scheduler.instanceId" value="AUTO" />
      <add key="quartz.threadPool.type" value="Quartz.Simpl.SimpleThreadPool, Quartz" />
      <add key="quartz.threadPool.threadCount" value="4" />
      <add key="quartz.jobStore.misfireThreshold" value="60000" />
      <add key="quartz.serializer.type" value="binary" />
      <add key="quartz.jobStore.type" value="Quartz.Impl.AdoJobStore.JobStoreTX, Quartz" />
      <add key="quartz.jobStore.useProperties" value="false" />
      <add key="quartz.jobStore.driverDelegateType" value="Quartz.Impl.AdoJobStore.SqlServerDelegate, Quartz" />
      <add key="quartz.jobStore.clustered" value="true" />
      <add key="quartz.jobStore.tablePrefix" value="QRTZ_" />
      <add key="quartz.jobStore.dataSource" value="quartzDS" />
      <add key="quartz.dataSource.quartzDS.connectionString" value="Server=.;Database=QuartzDB;Integrated Security=SSPI" />
      <add key="quartz.dataSource.quartzDS.provider" value="SqlServer" />
    </quartz>

---

所以您不必提及是否有第三个消费者正在运行（在第三个控制台应用程序中）。为了安排与Quartz的合作，您需要专门针对Quartz的第三个消费者。它必须正在运行，在这种情况下，quartz接收端点将侦听“quartz”队列

[更新]

以下是第三个控制台应用程序（quartz服务）的配置示例：

您还需要为我们配置quartz

busControl.Start();
scheduler.JobFactory = new MassTransitJobFactory(busControl);
scheduler.Start().Wait();

Console.ReadKey();
busControl.Stop();