public void CommandReturnsProperException(string message)
        {
            // Arrange
            using var busContext = new RabbitMqContextBuilder()
                                   .WithExchange("TestExchange")
                                   .WithConnectionString("amqp://*****:*****@localhost")
                                   .CreateContext();

            using var host = new MicroserviceHostBuilder()
                             .WithBusContext(busContext)
                             .WithQueueName("QueueName2")
                             .AddEventListener <ErrorEventListener>()
                             .CreateHost();

            host.Start();

            var command   = new DummyCommand(message);
            var publisher = new CommandPublisher(busContext);

            // Act
            Task <DummyCommand> Act() => publisher.PublishAsync <DummyCommand>(command);

            // Arrange
            var exception = Assert.ThrowsExceptionAsync <DestinationQueueException>(Act);

            Assert.AreEqual("Received error command from queue Test.Command.Listener", exception.Result.Message);
        }
        public void CreateContextCreatesProperContext(string connectionUrl, string exchangeName)
        {
            // Arrange
            var builder = new RabbitMqContextBuilder();

            var connectionFactoryMock = new Mock <IConnectionFactory>();

            connectionFactoryMock.SetupProperty(e => e.Uri, new Uri("amqp://localhost"));

            var connectionMock = new Mock <IConnection>();

            connectionFactoryMock.Setup(e => e.CreateConnection())
            .Returns(connectionMock.Object);

            var modelMock = new Mock <IModel>();

            connectionMock.Setup(e => e.CreateModel())
            .Returns(modelMock.Object);

            // Act
            builder.WithConnectionString(connectionUrl)
            .WithExchange(exchangeName)
            .CreateContext(connectionFactoryMock.Object);

            // Assert
            Assert.AreEqual(connectionUrl, connectionFactoryMock.Object.Uri.ToString());
            modelMock.Verify(e =>
                             e.ExchangeDeclare(exchangeName, ExchangeType.Topic, false, false, null));
        }
        public void CatEventDoesNotTriggerPersonEvent(string name)
        {
            // Arrange
            using var busContext = new RabbitMqContextBuilder()
                                   .WithExchange("TestExchange")
                                   .WithConnectionString("amqp://*****:*****@localhost")
                                   .CreateContext();

            using var host = new MicroserviceHostBuilder()
                             .WithBusContext(busContext)
                             .AddEventListener <PersonEventListener>()
                             .AddEventListener <CatEventListener>()
                             .CreateHost();

            host.Start();

            var publisher = new EventPublisher(busContext);

            var catEvent = new CatAddedEvent {
                Cat = new Cat {
                    Name = name
                }
            };

            // Act
            publisher.Publish(catEvent);
            Thread.Sleep(WaitTime);

            // Assert
            Assert.IsNull(PersonEventListener.ResultEvent);
            Assert.AreEqual(catEvent, CatEventListener.ResultEvent);
        }
        public void EventListenerHandlesMultipleEvents(params string[] names)
        {
            // Arrange
            using var busContext = new RabbitMqContextBuilder()
                                   .WithExchange("TestExchange")
                                   .WithConnectionString("amqp://*****:*****@localhost")
                                   .CreateContext();

            using var host = new MicroserviceHostBuilder()
                             .WithBusContext(busContext)
                             .WithQueueName("QueueName3")
                             .AddEventListener <SpamEventListener>()
                             .CreateHost();

            host.Start();

            var publisher = new EventPublisher(busContext);

            var catEvents = names.Select(e => new CatAddedEvent {
                Cat = new Cat {
                    Name = e
                }
            }).ToList();

            // Act
            foreach (var @event in catEvents)
            {
                publisher.Publish(@event);
            }

            Thread.Sleep(WaitTime);

            CollectionAssert.AreEquivalent(catEvents, SpamEventListener.ResultEvents);
        }
        public void CallbackIsCalledOnReceivedEvent(string queue, string message)
        {
            // Arrange
            using var context = new RabbitMqContextBuilder()
                                .WithConnectionString("amqp://*****:*****@localhost")
                                .WithExchange("HelloExchange")
                                .CreateContext();

            bool messageReceived = false;

            using var receiver = context.CreateMessageReceiver(queue, new [] { "#" });
            receiver.StartReceivingMessages();
            receiver.StartHandlingMessages(e => messageReceived = true);

            var eventMessage = new EventMessage
            {
                Body          = Encoding.Unicode.GetBytes(message),
                Timestamp     = 10,
                CorrelationId = Guid.NewGuid(),
                Topic         = "irrelevant",
                EventType     = "TestEvent"
            };

            // Act
            var sender = context.CreateMessageSender();

            sender.SendMessage(eventMessage);

            Thread.Sleep(WaitTime);

            // Assert
            Assert.AreEqual(true, messageReceived);
        }
Exemplo n.º 6
0
        public static void UseMicroserviceHost(this IServiceCollection services)
        {
            Enum.TryParse(Environment.GetEnvironmentVariable("LOG_LEVEL"), out LogLevel logLevel);

            var contextBuilder = new RabbitMqContextBuilder().ReadFromEnvironmentVariables();

            var context = Policy.Handle <BrokerUnreachableException>()
                          .WaitAndRetryForever(sleepDurationProvider => TimeSpan.FromSeconds(5))
                          .Execute(contextBuilder.CreateContext);

            var loggerFactory = LoggerFactory.Create(configure =>
            {
                configure.AddConsole().SetMinimumLevel(logLevel);
            });

            var microserviceHost = new MicroserviceHostBuilder()
                                   .SetLoggerFactory(loggerFactory)
                                   .RegisterDependencies(services)
                                   .WithQueueName(Environment.GetEnvironmentVariable("BROKER_QUEUE_NAME"))
                                   .WithBusContext(context)
                                   .UseConventions()
                                   .CreateHost();

            services.AddLogging(builder => builder.AddConsole().SetMinimumLevel(logLevel));
            services.AddSingleton(context);
            services.AddSingleton(microserviceHost);
            services.AddHostedService <Miffy>();
        }
        public void CallbackIsCalledOnReceivedEventWithSpecificTopic(string topicPattern, string topic, bool expected)
        {
            // Arrange
            using IBusContext <IConnection> context = new RabbitMqContextBuilder()
                                                      .WithConnectionString("amqp://*****:*****@localhost")
                                                      .WithExchange("HelloExchange")
                                                      .CreateContext();

            bool messageReceived = false;

            using var receiver = context.CreateMessageReceiver("topic.queue.test", new [] { topicPattern });
            receiver.StartReceivingMessages();
            receiver.StartHandlingMessages(e => messageReceived = true);

            var eventMessage = new EventMessage
            {
                Body          = Encoding.Unicode.GetBytes("TestMessage"),
                Timestamp     = 10,
                CorrelationId = Guid.NewGuid(),
                Topic         = topic,
                EventType     = "TestEvent"
            };

            // Act
            var sender = context.CreateMessageSender();

            sender.SendMessage(eventMessage);

            Thread.Sleep(WaitTime);

            // Assert
            Assert.AreEqual(messageReceived, expected);
        }
        public void EventListenerReceivesMessageAsync(string firstName, string lastName, string email, string phone)
        {
            // Arrange
            using var busContext = new RabbitMqContextBuilder()
                                   .WithExchange("TestExchange")
                                   .WithConnectionString("amqp://*****:*****@localhost")
                                   .CreateContext();

            using var host = new MicroserviceHostBuilder()
                             .WithBusContext(busContext)
                             .AddEventListener <PersonEventListener>()
                             .CreateHost();

            host.Start();

            var publisher = new EventPublisher(busContext);

            var personEvent = new PersonAddedEvent {
                Person = new Person
                {
                    FirstName   = firstName,
                    LastName    = lastName,
                    Email       = email,
                    PhoneNumber = phone
                }
            };

            // Act
            publisher.PublishAsync(personEvent);
            Thread.Sleep(WaitTime);

            // Assert
            Assert.AreEqual(personEvent, PersonEventListener.ResultEvent);
        }
        public void PausePausesReceivingMessages(long timestamp)
        {
            // Arrange
            using IBusContext <IConnection> context = new RabbitMqContextBuilder()
                                                      .WithConnectionString("amqp://*****:*****@localhost")
                                                      .WithExchange("HelloExchange")
                                                      .CreateContext();

            bool messageReceived = false;

            using var receiver = context.CreateMessageReceiver("topic.queue.test", new [] { "test" });
            receiver.StartReceivingMessages();
            receiver.StartHandlingMessages(e => messageReceived = true);

            var eventMessage = new EventMessage
            {
                Body          = Encoding.Unicode.GetBytes("TestMessage"),
                Timestamp     = timestamp,
                CorrelationId = Guid.NewGuid(),
                Topic         = "test",
                EventType     = "TestEvent"
            };

            // Act
            receiver.Pause();

            var sender = context.CreateMessageSender();

            sender.SendMessage(eventMessage);

            Thread.Sleep(WaitTime);

            // Assert
            Assert.AreEqual(false, messageReceived);
        }
Exemplo n.º 10
0
        /// <summary>
        /// Entrypoint
        /// </summary>
        static void Main(string[] args)
        {
            /**
             * Logging is important, so first set up a logger factory
             */
            using var loggerFactory = LoggerFactory.Create(configure =>
            {
                configure.AddConsole().SetMinimumLevel(LogLevel.Information);
            });

            /**
             * Set up a context using environment variables
             */
            using var context = new RabbitMqContextBuilder()
                                .ReadFromEnvironmentVariables()
                                .CreateContext();

            /**
             * Build a host using the loggerfactory, context and register any event listeners in the package.
             */
            using var hostBuilder = new MicroserviceReplayHostBuilder()
                                    .SetLoggerFactory(loggerFactory)
                                    .WithBusContext(context)
                                    .UseConventions();

            /**
             * Now create the host and start it
             */
            using IMicroserviceReplayHost host = (MicroserviceReplayHost)hostBuilder.CreateHost();
            host.Start();

            /**
             * Start spamming events to the auditlogger as a demonstration
             */
            StartSpammingEvents(context);

            /**
             * Now let's start replaying, first create a replay command
             */
            Guid processId = Guid.NewGuid();
            ReplayEventsCommand replayEventsCommand = new ReplayEventsCommand(DateTime.Now.ToFileTimeUtc(), processId)
            {
                Types = new List <string> {
                    "AnimalAddedEvent"
                }
            };

            /**
             * Create the publishers
             */
            ICommandPublisher       publisher = new CommandPublisher(context);
            IReplayCommandPublisher replayCommandPublisher = new ReplayCommandPublisher(host, publisher, loggerFactory);

            /**
             * Commence a replay!
             */
            replayCommandPublisher.Initiate(replayEventsCommand);
        }
        public void WithExchangeSetsExchangeName(string exchange)
        {
            // Arrange
            var builder = new RabbitMqContextBuilder();

            // Act
            builder.WithExchange(exchange);

            // Assert
            Assert.AreEqual(exchange, builder.ExchangeName);
        }
        public void WithConnectionStringSetsConnectionStringUri(string connectionString)
        {
            // Arrange
            var builder = new RabbitMqContextBuilder();

            // Act
            builder.WithConnectionString(connectionString);

            // Assert
            Assert.AreEqual(new Uri(connectionString), builder.ConnectionString);
        }
        public static void UseRabbitMq(this IServiceCollection services)
        {
            var contextBuilder = new RabbitMqContextBuilder().ReadFromEnvironmentVariables();

            var context = Policy.Handle <BrokerUnreachableException>()
                          .WaitAndRetryForever(sleepDurationProvider => TimeSpan.FromSeconds(5))
                          .Execute(contextBuilder.CreateContext);

            services.AddSingleton(context);
            services.AddTransient <IModuleService, ModuleService>();
            services.AddSingleton <ICommandPublisher, CommandPublisher>();
            services.AddSingleton <ICsvLoader, CsvLoader>();
        }
        public void PersonFullNamerIsProperlyReceived(string destQueue, string firstName, string lastName)
        {
            // arrange
            using var context = new RabbitMqContextBuilder()
                                .WithConnectionString("amqp://*****:*****@localhost")
                                .WithExchange("HelloExchange")
                                .CreateContext();

            using var receiver = context.CreateCommandReceiver(destQueue);
            receiver.DeclareCommandQueue();

            var sender = context.CreateCommandSender();

            var nameObject = new Person
            {
                FirstName = firstName,
                LastName  = lastName
            };

            var command = new CommandMessage
            {
                DestinationQueue = destQueue,
                Timestamp        = 294859,
                CorrelationId    = Guid.NewGuid(),
                ReplyQueue       = "ReplyQueue",
                Body             = Encoding.Unicode.GetBytes(JsonConvert.SerializeObject(nameObject))
            };

            // Act
            receiver.StartReceivingCommands(commandMessage =>
            {
                Person person       = JsonConvert.DeserializeObject <Person>(Encoding.Unicode.GetString(commandMessage.Body));
                person.FullName     = $"{person.FirstName} {person.LastName}";
                string jsonResponse = JsonConvert.SerializeObject(person);

                return(new CommandMessage
                {
                    CorrelationId = commandMessage.CorrelationId,
                    Timestamp = commandMessage.Timestamp,
                    Body = Encoding.Unicode.GetBytes(jsonResponse)
                });
            });

            var result = sender.SendCommandAsync(command);

            // Assert
            var stringResult = Encoding.Unicode.GetString(result.Result.Body);
            var personResult = JsonConvert.DeserializeObject <Person>(stringResult);

            Assert.AreEqual($"{firstName} {lastName}", personResult.FullName);
        }
        public void ReadFromEnvironmentVariablesWorks(string connectionString, string exchangeName)
        {
            // Arrange
            var builder = new RabbitMqContextBuilder();

            Environment.SetEnvironmentVariable(EnvVarNames.BrokerConnectionString, connectionString);
            Environment.SetEnvironmentVariable(EnvVarNames.BrokerExchangeName, exchangeName);

            // Act
            builder.ReadFromEnvironmentVariables();

            // Assert
            Assert.AreEqual(new Uri(connectionString), builder.ConnectionString);
            Assert.AreEqual(exchangeName, builder.ExchangeName);
        }
        public void ReadFromEnvironmentVariablesThrowsExceptionOnMissingExchangeName()
        {
            // Arrange
            var builder = new RabbitMqContextBuilder();

            Environment.SetEnvironmentVariable(EnvVarNames.BrokerConnectionString, "amqp://*****:*****@localhost");
            Environment.SetEnvironmentVariable(EnvVarNames.BrokerExchangeName, null);

            // Act
            void Act() => builder.ReadFromEnvironmentVariables();

            // Assert
            var exception = Assert.ThrowsException <BusConfigurationException>(Act);

            Assert.AreEqual($"{EnvVarNames.BrokerExchangeName} env variable not set", exception.Message);
        }
Exemplo n.º 17
0
        static async Task Main(string[] args)
        {
            Console.Write("Enter RabbitMQ connection string: ");
            var connectionString = Console.ReadLine();

            Console.WriteLine($"Using RabbitMQ connection string: '{connectionString}'");
            Environment.SetEnvironmentVariable("BROKER_CONNECTION_STRING", connectionString);

            Console.WriteLine();

            Console.Write("Enter MSSQL connection string: ");
            connectionString = Console.ReadLine();
            Console.WriteLine($"Using MSSQL connection string: '{connectionString}'");
            Environment.SetEnvironmentVariable("DB_CONNECTION_STRING", connectionString);

            Console.WriteLine();

            using var loggerFactory = LoggerFactory.Create(configure =>
            {
                configure.AddConsole().SetMinimumLevel(LogLevel.Debug);
            });

            MiffyLoggerFactory.LoggerFactory    = loggerFactory;
            RabbitMqLoggerFactory.LoggerFactory = loggerFactory;

            using var context = new RabbitMqContextBuilder()
                                .ReadFromEnvironmentVariables()
                                .CreateContext();

            // using var host = new MicroserviceHostBuilder()
            //     .SetLoggerFactory(loggerFactory)
            //     .WithBusContext(context)
            //     .WithQueueName(QueueName)
            //     .UseConventions()
            //     .CreateHost();

            // host.Start();


            ICommandPublisher commandPublisher = new CommandPublisher(context);
            var klantId = new Guid("979F7437-F7F3-4662-7485-08D80D5821EA");

            // Export();
            await ImportDataIntoSystemFromFile(commandPublisher, klantId, @"C:\Users\Dirk-Jan\Dropbox\S6\prestaties beide.txt");
        }
        public void CommandIsProperlySentThrough(string destQueue, string message)
        {
            // arrange
            using var context = new RabbitMqContextBuilder()
                                .WithConnectionString("amqp://*****:*****@localhost")
                                .WithExchange("HelloExchange")
                                .CreateContext();

            using var receiver = context.CreateCommandReceiver(destQueue);
            receiver.DeclareCommandQueue();

            var sender = context.CreateCommandSender();

            var nameObject = new NameMessage(message);
            var command    = new CommandMessage
            {
                DestinationQueue = destQueue,
                Timestamp        = 294859,
                CorrelationId    = Guid.NewGuid(),
                ReplyQueue       = "ReplyQueue",
                Body             = Encoding.Unicode.GetBytes(JsonConvert.SerializeObject(nameObject))
            };

            // Act
            receiver.StartReceivingCommands(commandMessage =>
            {
                NameMessage name = JsonConvert.DeserializeObject <NameMessage>(Encoding.Unicode.GetString(commandMessage.Body));

                return(new CommandMessage
                {
                    CorrelationId = commandMessage.CorrelationId,
                    Timestamp = commandMessage.Timestamp,
                    Body = Encoding.Unicode.GetBytes($"Hallo {name.Name}")
                });
            });

            var result = sender.SendCommandAsync(command);

            // Assert
            var stringResult = Encoding.Unicode.GetString(result.Result.Body);

            Assert.AreEqual($"Hallo {message}", stringResult);
        }
Exemplo n.º 19
0
        static void Main(string[] args)
        {
            using ILoggerFactory loggerFactory = LoggerFactory.Create(configure =>
            {
                string logLevelString = Environment.GetEnvironmentVariable(EnvVarNames.LogLevel) ?? "Information";
                LogLevel logLevel     = Enum.Parse <LogLevel>(logLevelString);
                configure.AddConsole().SetMinimumLevel(logLevel);
            });

            MiffyLoggerFactory.LoggerFactory    = loggerFactory;
            RabbitMqLoggerFactory.LoggerFactory = loggerFactory;

            using IBusContext <IConnection> context = new RabbitMqContextBuilder()
                                                      .ReadFromEnvironmentVariables()
                                                      .CreateContext();

            using IMicroserviceHost host = new MicroserviceHostBuilder()
                                           .SetLoggerFactory(loggerFactory)
                                           .WithBusContext(context)
                                           .RegisterDependencies(services =>
            {
                services.AddDbContext <AuditLogContext>(config =>
                {
                    config.UseMySql(Environment.GetEnvironmentVariable(EnvVarNames.DatabaseConnectionString));
                    config.UseLoggerFactory(loggerFactory);
                }, ServiceLifetime.Singleton);

                services.AddTransient <IAuditLogItemRepository, AuditLogItemRepository>();
                services.AddTransient <IEventPublisher, EventPublisher>();

                using var serviceScope = services.BuildServiceProvider().GetRequiredService <IServiceScopeFactory>().CreateScope();
                var auditLogContext    = serviceScope.ServiceProvider.GetService <AuditLogContext>();
                auditLogContext.Database.Migrate();
            })
                                           .UseConventions()
                                           .CreateHost();

            host.Start();

            // Keep app running
            new ManualResetEvent(false).WaitOne();
        }
        public void ResumeResumesReceivingMessagesAfterItWasPaused(long timestamp)
        {
            // Arrange
            using IBusContext <IConnection> context = new RabbitMqContextBuilder()
                                                      .WithConnectionString("amqp://*****:*****@localhost")
                                                      .WithExchange("HelloExchange")
                                                      .CreateContext();

            bool messageReceived = false;

            using var receiver = context.CreateCommandReceiver("topic.queue.test");
            receiver.DeclareCommandQueue();
            receiver.StartReceivingCommands(e =>
            {
                messageReceived = true;
                return(null);
            });

            var eventMessage = new CommandMessage
            {
                Body             = Encoding.Unicode.GetBytes("TestMessage"),
                Timestamp        = timestamp,
                CorrelationId    = Guid.NewGuid(),
                DestinationQueue = "topic.queue.test",
                EventType        = "TestEvent"
            };

            receiver.Pause();

            // Act
            var sender = context.CreateCommandSender();

            sender.SendCommandAsync(eventMessage);

            receiver.Resume();

            // Assert
            Thread.Sleep(WaitTime);

            Assert.AreEqual(true, messageReceived);
        }
        public void EventListenerDoesCallListenerOnInvalidJson(string body)
        {
            // Arrange
            using var busContext = new RabbitMqContextBuilder()
                                   .WithExchange("TestExchange")
                                   .WithConnectionString("amqp://*****:*****@localhost")
                                   .CreateContext();

            using var host = new MicroserviceHostBuilder()
                             .WithBusContext(busContext)
                             .AddEventListener <PersonEventListener>()
                             .CreateHost();

            host.Start();

            EventPublisher publisher = new EventPublisher(busContext);

            // Act
            publisher.Publish(242424, "PeopleApp.Persons.New", Guid.NewGuid(), "PersonEvent", body);
            Thread.Sleep(WaitTime);

            // Assert
            Assert.IsNull(PersonEventListener.ResultEvent);
        }
Exemplo n.º 22
0
        /**
         * An example implementation on how to set up a
         * MicroserviceHost with RabbitMQ in the Main method
         *
         * Setting up a functioning RabbitMQ instance with docker is as easy as running:
         * docker run -d -p 15672:15672 -p 5672:5672 rabbitmq:3-management
         */
        static void Main(string[] args)
        {
            /*
             * Logging is quite important, for this reason we first create
             * a loggerfactory that will be used in the rest of the application
             *
             * This one outputs to the console
             */
            using ILoggerFactory loggerFactory = LoggerFactory.Create(configure =>
            {
                configure.AddConsole().SetMinimumLevel(LogLevel.Error);
            });

            /*
             * To reach the library classes, a static class has been put in place
             * to register a logger
             */
            MiffyLoggerFactory.LoggerFactory    = loggerFactory;
            RabbitMqLoggerFactory.LoggerFactory = loggerFactory;

            /*
             * Now that the logger is done, let's create a RabbitMq context with
             * an exchange called MVM.EventExchange and a connection string
             * that connects to a local RabbitMQ instance
             */
            RabbitMqContextBuilder contextBuilder = new RabbitMqContextBuilder()
                                                    .WithExchange("MVM.EventExchange")
                                                    .WithConnectionString("amqp://*****:*****@localhost");

            /*
             * Now instantiate the context and ensure that it's disposed of by using a
             * 'using' statement.
             */
            using IBusContext <IConnection> context = contextBuilder.CreateContext();


            /**
             * Create a dummy database context for testing with an in-memory database
             */
            PolisContext databaseContext = new PolisContext();

            /**
             * Now create a builder that will build our microservice host.
             *
             * First, register our logger by setting the logger factory,
             * next we register any dependencies we might need, like a DBContext
             * that is injected into our CommandListeners and EventListeners
             *
             * Since most of the inner workings of this framework are asynchronous, we
             * strongly urge you to set up a loggerfactory to quickly find any errors going over the bus.
             *
             * Then, throw our context into the builder and lastly, ensure that
             * all our event/command listeners are registered by calling UseConventions().
             *
             * UseConventions could be replaced by multiple AddEventListener calls.
             */
            MicroserviceHostBuilder builder = new MicroserviceHostBuilder()
                                              .SetLoggerFactory(loggerFactory)
                                              // This method also accepts a service collection as input
                                              .RegisterDependencies(services =>
            {
                services.AddSingleton(databaseContext);
            })
                                              .WithQueueName("ExampleService.Queue")
                                              .WithBusContext(context)
                                              .UseConventions();

            /**
             * Lastly, instantiate a host and ensure it starts
             */
            using IMicroserviceHost host = builder.CreateHost();
            host.Start();

            /**
             * Let's add a C# event listener for fun
             */
            host.EventMessageReceived += (message, eventArgs) =>
            {
                Console.WriteLine("Received a EventMessage!");
            };

            /**
             * Now let's pretend this service is running somewhere in a cluster
             * and is receiving events, let's fire some events at it
             */
            string[]        names     = { "Jack", "Jake", "Penny", "Robin", "Rick", "Vinny", "Spencer" };
            IEventPublisher publisher = new EventPublisher(context, loggerFactory);

            foreach (string name in names)
            {
                PolisToegevoegdEvent toegevoegdEvent = new PolisToegevoegdEvent
                {
                    Polis = new Polis {
                        Klantnaam = name
                    }
                };
                publisher.PublishAsync(toegevoegdEvent);
            }

            /**
             * Now let's wait 1 second for all the events to arrive and be processed
             */
            Thread.Sleep(2000);

            /**
             * Now let's fire a command and retrieve a list of polissen
             */
            ICommandPublisher           commandPublisher = new CommandPublisher(context, loggerFactory);
            HaalPolissenOpCommand       command          = new HaalPolissenOpCommand();
            HaalPolissenOpCommandResult commandResult    = commandPublisher.PublishAsync <HaalPolissenOpCommandResult>(command).Result;

            /**
             * Now, print the result!
             */
            foreach (Polis polis in commandResult.Polissen)
            {
                Console.WriteLine($"Found polis for {polis.Klantnaam} with ID {polis.Id}");
            }

            /**
             * Now let's see what happens if we send a mangled json event
             *
             * This should log a critical error in the console and tell you how you might be able to diagnose the problem.
             */
            publisher.Publish(0, "MVM.Polisbeheer.PolisToegevoegd", Guid.Empty, "PolisToegevoegdEvent", "{[somerandomjson}]");

            /**
             * Lastly, let's see how the queue deals with exceptions on the other side
             */
            ExceptionCommand exceptionCommand = new ExceptionCommand();

            try
            {
                /**
                 * This will throw an exception in the receiver
                 */
                _ = commandPublisher.PublishAsync <ExceptionCommand>(exceptionCommand).Result;
            }
            catch (AggregateException expectedException)
            {
                DestinationQueueException destinationQueueException = expectedException.InnerExceptions.First() as DestinationQueueException;

                /**
                 * Now the expectedException.Innerexception will reveal all the info we need
                 */
                Console.WriteLine($"{destinationQueueException?.InnerException?.GetType().Name} {destinationQueueException?.InnerException?.Message}");
                Console.WriteLine($"Destination queue: {destinationQueueException?.DestinationQueueName}, " +
                                  $"Reply queue: {destinationQueueException?.ReplyQueueName}, " +
                                  $"Id: {destinationQueueException?.CorrelationId}");
            }
        }