namespace EasyNetQ.HostedService.TestApp
{
    public struct EchoMessage
    {
        public string Text { get; set; }
    }
}

namespace EasyNetQ.HostedService.TestApp
{
    public struct EchoMessage
    {
        public string Text { get; set; }
    }

    public class MyInjectableRabbitMqConsumer : RabbitMqConsumer<MyInjectableRabbitMqConsumer>
    {
        // optional constructor with additional injected dependencies
        public MyInjectableRabbitMqConsumer(IHostEnvironment env)
        {
            // do something with env
        }
        
        protected override void Initialize()
        {
            // use initialized members like Bus and RabbitMqConfig (eg, Bus.QueueDeclare(...))
        }

        protected override void RegisterMessageHandlers(IHandlerRegistration handlers)
        {
            handlers.Add((IMessageHandler<string>) HandleMessage);
        }

        protected override ConsumerConfig GetConsumerConfig(CancellationToken cancellationToken)
        {
            return new ConsumerConfig
            {
                Queue = new Queue("MyQueueName")
            };
        }

        protected override void OnStartConsumingEvent(StartConsumingSucceededEvent @event)
        {
            // the consumer has successfully started to consume
        }

        protected override void OnStartConsumingEvent(StartConsumingFailedEvent @event)
        {
            // the consumer has failed to start consuming
        }

        private Task<AckStrategy> HandleMessage(IMessage<string> message, MessageReceivedInfo info,
            CancellationToken token)
        {
            Logger.LogDebug($"Received untyped message: {message.Body}");

            return Task.FromResult(AckStrategies.Ack);
        }
    }
}

using Microsoft.Extensions.Hosting;

namespace EasyNetQ.HostedService.TestApp
{
    public class MyInjectableRabbitMqProducer : RabbitMqProducer<MyInjectableRabbitMqProducer>
    {
        // optional constructor with additional injected dependencies
        public MyInjectableRabbitMqProducer(IHostEnvironment env)
        {
            // do something with env
        }

        protected override void Initialize()
        {
            // use initialized members like `Bus` and `RabbitMqConfig`
        }
    }
}

using System;
using System.Linq;
using System.Threading;
using System.Threading.Tasks;
using Microsoft.Extensions.Hosting;
using Microsoft.Extensions.Logging;

namespace EasyNetQ.HostedService.TestApp
{
    public class RabbitMqServiceTester : IHostedService
    {
        private readonly RabbitMqProducer<MyInjectableRabbitMqProducer> _producer;
        private readonly ILogger<RabbitMqServiceTester> _logger;

        // RabbitMqService<MyInjectableRabbitMqProducer> would work as well
        public RabbitMqServiceTester(MyInjectableRabbitMqProducer producer, ILogger<RabbitMqServiceTester> logger)
        {
            _producer = producer;
            _logger = logger;
        }

        public Task StartAsync(CancellationToken cancellationToken)
        {
            Task.Run(async () =>
            {
                while (true)
                {
                    var key = Console.ReadKey();

                    if (key.Key == ConsoleKey.Escape)
                    {
                        break;
                    }

                    await _producer.PublishAsync("", "test.queue", new EchoMessage {Text = "This is a test."});
                }

                Environment.Exit(0);
            }, cancellationToken);

            return Task.CompletedTask;
        }

        public Task StopAsync(CancellationToken cancellationToken)
        {
            return Task.CompletedTask;
        }
    }
}

using System;
using EasyNetQ.HostedService.DependencyInjection;
using EasyNetQ.HostedService.Models;
using Microsoft.Extensions.Configuration;
using Microsoft.Extensions.DependencyInjection;
using Microsoft.Extensions.Hosting;

namespace EasyNetQ.HostedService.TestApp
{
    public static class Program
    {
        public static void Main(string[] args)
        {
            CreateHostBuilder(args).Build().Run();
        }

        private static IHostBuilder CreateHostBuilder(string[] args) =>
            Host.CreateDefaultBuilder(args)
                .ConfigureServices((hostContext, services) =>
                {
                    var rabbitMqConfigConsumer =
                        hostContext.Configuration.GetSection("RabbitMQ").Get<RabbitMqConfig>();

                    // rabbitMqConfigConsumer.Id can be set through the relevant configuration section
                    // (default value: Anonymous)

                    new RabbitMqServiceBuilder<MyInjectableRabbitMqConsumer>()
                        .WithRabbitMqConfig(rabbitMqConfigConsumer)
                        .Build(services)
                        .Add(services, typeof(MyInjectedRabbitMqConsumerType),
                            typeof(MyInjectedRabbitMqConsumerOptionalExtraType));

                    var rabbitMqConfigProducer = rabbitMqConfigConsumer.Copy;
                    rabbitMqConfigProducer.Id = "Some Other Id";

                    new RabbitMqServiceBuilder<MyInjectableRabbitMqProducer>()
                        .WithRabbitMqConfig(rabbitMqConfigProducer)
                        .Build(services)
                        .Add(services, typeof(MyInjectedRabbitMqProducerType),
                            typeof(typeof(MyInjectedRabbitMqProducerOptionalExtraType)));

                    services.AddHostedService<RabbitMqServiceTester>();
                });
    }
}