private async Task BasicPubSub(int concurrency, int subscribers) { // arrange var pingConsumer = new PingConsumer(); MessageBusBuilder .WithDependencyResolver(new LookupDependencyResolver(f => { if (f == typeof(PingConsumer)) { return(pingConsumer); } throw new InvalidOperationException(); })); var messageBus = MessageBus.Value; // act // publish var stopwatch = Stopwatch.StartNew(); var producedMessages = Enumerable .Range(0, NumberOfMessages) .Select(i => new PingMessage { Counter = i, Value = Guid.NewGuid() }) .ToList(); var messageTasks = producedMessages.Select(m => messageBus.Publish(m)); // wait until all messages are sent await Task.WhenAll(messageTasks).ConfigureAwait(false); stopwatch.Stop(); Log.InfoFormat(CultureInfo.InvariantCulture, "Published {0} messages in {1}", producedMessages.Count, stopwatch.Elapsed); // consume stopwatch.Restart(); var consumersReceivedMessages = await ConsumeAll(pingConsumer, subscribers *producedMessages.Count); stopwatch.Stop(); Log.InfoFormat(CultureInfo.InvariantCulture, "Consumed {0} messages in {1}", consumersReceivedMessages.Count, stopwatch.Elapsed); // assert // ensure number of instances of consumers created matches consumersReceivedMessages.Count.Should().Be(subscribers * producedMessages.Count); // ensure all messages arrived // ... the count should match consumersReceivedMessages.Count.Should().Be(subscribers * producedMessages.Count); // ... the content should match foreach (var producedMessage in producedMessages) { var messageCopies = consumersReceivedMessages.Count(x => x.Counter == producedMessage.Counter && x.Value == producedMessage.Value); messageCopies.Should().Be(subscribers); } }
private async Task BasicPubSub(int concurrency, int subscribers, int expectedMessageCopies) { // arrange var consumersCreated = new ConcurrentBag <PingConsumer>(); var consumedMessages = new List <(PingMessage Message, string MessageId)>(); MessageBusBuilder .WithDependencyResolver(new LookupDependencyResolver(f => { if (f != typeof(PingConsumer)) { throw new InvalidOperationException(); } var pingConsumer = new PingConsumer(_loggerFactory.CreateLogger <PingConsumer>(), consumedMessages); consumersCreated.Add(pingConsumer); return(pingConsumer); })); var messageBus = MessageBus.Value; // act // publish var stopwatch = Stopwatch.StartNew(); var producedMessages = Enumerable .Range(0, NumberOfMessages) .Select(i => new PingMessage { Counter = i, Value = Guid.NewGuid() }) .ToList(); var messageTasks = producedMessages.Select(m => messageBus.Publish(m)); // wait until all messages are sent await Task.WhenAll(messageTasks).ConfigureAwait(false); stopwatch.Stop(); _logger.LogInformation("Published {0} messages in {1}", producedMessages.Count, stopwatch.Elapsed); // consume stopwatch.Restart(); await WaitUntilArriving(consumedMessages); stopwatch.Stop(); // assert // ensure number of instances of consumers created matches consumersCreated.Count.Should().Be(producedMessages.Count * expectedMessageCopies); consumedMessages.Count.Should().Be(producedMessages.Count * expectedMessageCopies); // ... the content should match foreach (var producedMessage in producedMessages) { var messageCopies = consumedMessages.Count(x => x.Message.Counter == producedMessage.Counter && x.Message.Value == producedMessage.Value && x.MessageId == GetMessageId(x.Message)); messageCopies.Should().Be(expectedMessageCopies); } }
private async Task BasicReqResp() { // arrange var consumersCreated = new ConcurrentBag <EchoRequestHandler>(); MessageBusBuilder .WithDependencyResolver(new LookupDependencyResolver(f => { if (f != typeof(EchoRequestHandler)) { throw new InvalidOperationException(); } var consumer = new EchoRequestHandler(); consumersCreated.Add(consumer); return(consumer); })); var messageBus = MessageBus.Value; // act // publish var stopwatch = Stopwatch.StartNew(); var requests = Enumerable .Range(0, NumberOfMessages) .Select(i => new EchoRequest { Index = i, Message = $"Echo {i}" }) .ToList(); var responses = new List <Tuple <EchoRequest, EchoResponse> >(); var responseTasks = requests.Select(async req => { var resp = await messageBus.Send(req).ConfigureAwait(false); lock (responses) { responses.Add(Tuple.Create(req, resp)); } }); await Task.WhenAll(responseTasks).ConfigureAwait(false); stopwatch.Stop(); Log.InfoFormat(CultureInfo.InvariantCulture, "Published and received {0} messages in {1}", responses.Count, stopwatch.Elapsed); // assert // all messages got back responses.Count.Should().Be(NumberOfMessages); responses.All(x => x.Item1.Message == x.Item2.Message).Should().BeTrue(); }
public static MessageBusBuilder WithDependencyResolverAsServiceLocator(this MessageBusBuilder builder) { return(builder.WithDependencyResolver(new ServiceLocatorMessageBusDependencyResolver())); }
public static MessageBusBuilder WithDependencyResolverAsUnity(this MessageBusBuilder builder) { return(builder.WithDependencyResolver(new UnityMessageBusDependencyResolver())); }
public static MessageBusBuilder WithDependencyResolverAsAutofac(this MessageBusBuilder builder) { return(builder.WithDependencyResolver(new AutofacMessageBusDependencyResolver())); }