public async Task CustomMessageHandler_WithContextFilter_UsesMessageTypeDuringSelection() { // Arrange var spyHandler = new StubTestMessageHandler <Purchase, MessageContext>(); var collection = new MessageHandlerCollection(new ServiceCollection()); collection.WithMessageHandler <StubTestMessageHandler <Order, MessageContext>, Order>(); collection.WithMessageHandler <StubTestMessageHandler <Purchase, TestMessageContext>, Purchase, TestMessageContext>(); collection.WithMessageHandler <StubTestMessageHandler <Purchase, MessageContext>, Purchase>(provider => spyHandler); IServiceProvider serviceProvider = collection.Services.BuildServiceProvider(); var router = new TestMessageRouter(serviceProvider, _logger); var purchase = new Purchase { CustomerName = _bogusGenerator.Name.FullName(), Price = _bogusGenerator.Commerce.Price() }; string purchaseJson = JsonConvert.SerializeObject(purchase); var context = new MessageContext("message-id", new Dictionary <string, object>()); var correlationInfo = new MessageCorrelationInfo("operation-id", "transaction-id"); // Act await router.RouteMessageAsync(purchaseJson, context, correlationInfo, CancellationToken.None); // Assert Assert.True(spyHandler.IsProcessed); }
public async Task CustomMessageHandler_WithContextFilter_UsesFilterDuringSelection() { // Arrange var messageId = Guid.NewGuid().ToString(); var message = new TestMessage { TestProperty = Guid.NewGuid().ToString() }; string messageJson = JsonConvert.SerializeObject(message); var context = new TestMessageContext(messageId, new Dictionary <string, object>()); var correlationInfo = new MessageCorrelationInfo("operation-id", "transaction-id"); var spyHandler1 = new TestMessageHandler(); var spyHandler2 = new TestMessageHandler(); var collection = new MessageHandlerCollection(new ServiceCollection()); collection.WithMessageHandler <TestMessageHandler, TestMessage, TestMessageContext>( messageContextFilter: ctx => ctx.MessageId == "some other ID", implementationFactory: provider => spyHandler2); collection.WithMessageHandler <TestMessageHandler, TestMessage, TestMessageContext>( messageContextFilter: ctx => ctx.MessageId == messageId, implementationFactory: provider => spyHandler1); collection.WithMessageHandler <TestMessageHandler, TestMessage, TestMessageContext>(); collection.WithMessageHandler <DefaultTestMessageHandler, TestMessage>(); IServiceProvider serviceProvider = collection.Services.BuildServiceProvider(); var router = new TestMessageRouter(serviceProvider, _logger); // Act await router.RouteMessageAsync(messageJson, context, correlationInfo, CancellationToken.None); // Assert Assert.True(spyHandler1.IsProcessed); Assert.False(spyHandler2.IsProcessed); }
public async Task WithMessageHandlerWithDefaultContext_WithMessageBodySerializerImplementationFactoryWithMessageBodyFilter_UsesSerializer(bool matches) { // Arrange var services = new MessageHandlerCollection(new ServiceCollection()); var expectedBody = $"test-message-body-{Guid.NewGuid()}"; var expectedMessage = new TestMessage(); var serializer = new TestMessageBodySerializer(expectedBody, expectedMessage); // Act services.WithMessageHandler <DefaultTestMessageHandler, TestMessage>( messageBodySerializerImplementationFactory: serviceProvider => serializer, messageBodyFilter: body => { Assert.Same(expectedMessage, body); return(matches); }); // Assert IServiceProvider provider = services.Services.BuildServiceProvider(); IEnumerable <MessageHandler> handlers = MessageHandler.SubtractFrom(provider, NullLogger.Instance); Assert.NotNull(handlers); MessageHandler handler = Assert.Single(handlers); Assert.NotNull(handler); bool actual = handler.CanProcessMessageBasedOnMessage(expectedMessage); Assert.Equal(matches, actual); MessageResult result = await handler.TryCustomDeserializeMessageAsync(expectedBody); Assert.NotNull(result); Assert.Same(expectedMessage, result.DeserializedMessage); }
public async Task CustomMessageHandlerFactory_WithCustomContext_SubtractsRegistration() { // Arrange var spyHandler = new TestMessageHandler(); var collection = new MessageHandlerCollection(new ServiceCollection()); collection.WithMessageHandler <TestMessageHandler, TestMessage, TestMessageContext>(provider => spyHandler); IServiceProvider serviceProvider = collection.Services.BuildServiceProvider(); // Act IEnumerable <MessageHandler> messageHandlers = MessageHandler.SubtractFrom(serviceProvider, _logger); // Assert MessageHandler messageHandler = Assert.Single(messageHandlers); Assert.NotNull(messageHandler); var message = new TestMessage(); var context = TestMessageContext.Generate(); var correlationInfo = new MessageCorrelationInfo("operation-id", "transaction-id"); await messageHandler.ProcessMessageAsync(message, context, correlationInfo, CancellationToken.None); Assert.True(spyHandler.IsProcessed); }
public void CustomMessageHandlerFactory_WithMessageBodyAndContextFilter_SubtractsRegistration(bool matchesBody, bool matchesContext) { // Arrange var collection = new MessageHandlerCollection(new ServiceCollection()); var spyHandler = new TestMessageHandler(); collection.WithMessageHandler <TestMessageHandler, TestMessage, TestMessageContext>( (TestMessageContext messageContext) => matchesContext, (TestMessage messageBody) => matchesBody, provider => spyHandler); ServiceProvider serviceProvider = collection.Services.BuildServiceProvider(); // Act IEnumerable <MessageHandler> messageHandlers = MessageHandler.SubtractFrom(serviceProvider, _logger); // Assert MessageHandler messageHandler = Assert.Single(messageHandlers); Assert.NotNull(messageHandler); var context = TestMessageContext.Generate(); Assert.Equal(matchesContext, messageHandler.CanProcessMessageBasedOnContext(messageContext: context)); Assert.Equal(matchesBody, messageHandler.CanProcessMessageBasedOnMessage(new TestMessage())); }
public void WithMessageHandlerWithCustomContext_WithMessageContextFilterWithMessageBodyFilter_UsesSerializer(bool matchesContext, bool matchesBody) { // Arrange var services = new MessageHandlerCollection(new ServiceCollection()); var expectedMessage = new TestMessage(); var expectedContext = TestMessageContext.Generate(); var expectedHandler = new DefaultTestMessageHandler(); // Act services.WithMessageHandler <TestMessageHandler, TestMessage, TestMessageContext>( messageContextFilter: context => { Assert.Same(expectedContext, context); return(matchesContext); }, messageBodyFilter: body => { Assert.Same(expectedMessage, body); return(matchesBody); }); // Assert IServiceProvider provider = services.Services.BuildServiceProvider(); IEnumerable <MessageHandler> handlers = MessageHandler.SubtractFrom(provider, NullLogger.Instance); Assert.NotNull(handlers); MessageHandler handler = Assert.Single(handlers); Assert.NotNull(handler); Assert.NotSame(expectedHandler, handler); Assert.Equal(matchesContext, handler.CanProcessMessageBasedOnContext(expectedContext)); Assert.Equal(matchesBody, handler.CanProcessMessageBasedOnMessage(expectedMessage)); }
public async Task WithMessageRouting_WithMessageHandlerContextFilter_GoesThroughRegisteredMessageHandlers() { // Arrange var services = new ServiceCollection(); var collection = new MessageHandlerCollection(services); var spyHandler = new StubTestMessageHandler <TestMessage, TestMessageContext>(); var ignoredSameTypeHandler = new StubTestMessageHandler <TestMessage, TestMessageContext>(); var ignoredDefaultHandler = new DefaultTestMessageHandler(); var ignoredHandler = new TestMessageHandler(); collection.WithMessageHandler <DefaultTestMessageHandler, TestMessage>(serviceProvider => ignoredDefaultHandler) .WithMessageHandler <StubTestMessageHandler <TestMessage, TestMessageContext>, TestMessage, TestMessageContext>( messageContextFilter: ctx => false, implementationFactory: serviceProvider => ignoredSameTypeHandler) .WithMessageHandler <StubTestMessageHandler <TestMessage, TestMessageContext>, TestMessage, TestMessageContext>(serviceProvider => spyHandler) .WithMessageHandler <TestMessageHandler, TestMessage, TestMessageContext>(serviceProvider => ignoredHandler); // Act services.AddMessageRouting(); // Assert IServiceProvider provider = services.BuildServiceProvider(); var router = provider.GetRequiredService <IMessageRouter>(); var correlationInfo = new MessageCorrelationInfo("operation-id", "transaction-id"); var context = TestMessageContext.Generate(); string json = JsonConvert.SerializeObject(new TestMessage()); await router.RouteMessageAsync(json, context, correlationInfo, CancellationToken.None); Assert.True(spyHandler.IsProcessed); Assert.False(ignoredSameTypeHandler.IsProcessed); Assert.False(ignoredDefaultHandler.IsProcessed); Assert.False(ignoredHandler.IsProcessed); }
public async Task WithMessageRouting_WithIgnoreMissingMembers_GoesThroughDifferentMessageHandler(AdditionalMemberHandling additionalMemberHandling) { // Arrange var services = new ServiceCollection(); var collection = new MessageHandlerCollection(services); var messageHandlerV1 = new OrderV1MessageHandler(); var messageHandlerV2 = new OrderV2MessageHandler(); collection.WithMessageHandler <OrderV1MessageHandler, Order>(provider => messageHandlerV1) .WithMessageHandler <OrderV2MessageHandler, OrderV2>(provider => messageHandlerV2); // Act services.AddMessageRouting(options => options.Deserialization.AdditionalMembers = additionalMemberHandling); // Assert IServiceProvider serviceProvider = services.BuildServiceProvider(); var router = serviceProvider.GetRequiredService <IMessageRouter>(); OrderV2 order = OrderV2Generator.Generate(); var context = new MessageContext("message-id", new Dictionary <string, object>()); var correlationInfo = new MessageCorrelationInfo("operation-id", "transaction-id"); string json = JsonConvert.SerializeObject(order); await router.RouteMessageAsync(json, context, correlationInfo, CancellationToken.None); Assert.Equal(additionalMemberHandling is AdditionalMemberHandling.Ignore, messageHandlerV1.IsProcessed); Assert.Equal(additionalMemberHandling is AdditionalMemberHandling.Error, messageHandlerV2.IsProcessed); }
public void WithMessageHandlerWithDefaultContext_WithMessageContextFilterWithMessageBodyFilterWithImplementationFactory_UsesSerializer(bool matchesContext, bool matchesBody) { // Arrange var services = new MessageHandlerCollection(new ServiceCollection()); var expectedMessage = new TestMessage(); var expectedContext = new MessageContext($"message-id-{Guid.NewGuid()}", new Dictionary <string, object>()); var expectedHandler = new DefaultTestMessageHandler(); // Act services.WithMessageHandler <DefaultTestMessageHandler, TestMessage>( messageContextFilter: context => { Assert.Same(expectedContext, context); return(matchesContext); }, messageBodyFilter: body => { Assert.Same(expectedMessage, body); return(matchesBody); }, implementationFactory: serviceProvider => expectedHandler); // Assert IServiceProvider provider = services.Services.BuildServiceProvider(); IEnumerable <MessageHandler> handlers = MessageHandler.SubtractFrom(provider, NullLogger.Instance); Assert.NotNull(handlers); MessageHandler handler = Assert.Single(handlers); Assert.NotNull(handler); Assert.NotSame(expectedHandler, handler); Assert.Equal(matchesContext, handler.CanProcessMessageBasedOnContext(expectedContext)); Assert.Equal(matchesBody, handler.CanProcessMessageBasedOnMessage(expectedMessage)); }
public void WithMessageHandlerDefaultContext_WithMessageBodyFilterWithImplementationFactory_UsesFilter(bool matches) { // Arrange var services = new MessageHandlerCollection(new ServiceCollection()); var expectedHandler = new DefaultTestMessageHandler(); var message = new TestMessage(); // Act services.WithMessageHandler <DefaultTestMessageHandler, TestMessage>(messageBodyFilter: body => { Assert.Same(message, body); return(matches); }, implementationFactory: serviceProvider => expectedHandler); // Assert IServiceProvider provider = services.Services.BuildServiceProvider(); IEnumerable <MessageHandler> handlers = MessageHandler.SubtractFrom(provider, NullLogger.Instance); MessageHandler handler = Assert.Single(handlers); Assert.NotNull(handler); Assert.NotSame(expectedHandler, handler); bool actual = handler.CanProcessMessageBasedOnMessage(message); Assert.Equal(matches, actual); }
public async Task WithMessageHandlerWithDefaultContext_WithMessageBodySerializerWithImplementationFactory_UsesSerializer() { // Arrange var services = new MessageHandlerCollection(new ServiceCollection()); var expectedBody = $"test-message-body-{Guid.NewGuid()}"; var expectedMessage = new TestMessage(); var serializer = new TestMessageBodySerializer(expectedBody, expectedMessage); var expectedHandler = new DefaultTestMessageHandler(); // Act services.WithMessageHandler <DefaultTestMessageHandler, TestMessage>( messageBodySerializer: serializer, implementationFactory: serviceProvider => expectedHandler); // Assert IServiceProvider provider = services.Services.BuildServiceProvider(); IEnumerable <MessageHandler> handlers = MessageHandler.SubtractFrom(provider, NullLogger.Instance); Assert.NotNull(handlers); MessageHandler handler = Assert.Single(handlers); Assert.NotNull(handler); Assert.NotSame(expectedHandler, handler); MessageResult result = await handler.TryCustomDeserializeMessageAsync(expectedBody); Assert.NotNull(result); Assert.Same(expectedMessage, result.DeserializedMessage); }
public void WithMessageHandlerTMessageHandlerTMessage_WithoutMessageContextFilterWithMessageBodyFilter_Fails() { // Arrange var services = new MessageHandlerCollection(new ServiceCollection()); // Act / Assert Assert.ThrowsAny <ArgumentException>(() => services.WithMessageHandler <DefaultTestMessageHandler, TestMessage>(messageContextFilter: null, messageBodyFilter: body => true)); }
public void WithMessageHandlerCustomContext_WithoutMessageBodyFilter_Fails() { // Arrange var services = new MessageHandlerCollection(new ServiceCollection()); // Act / Assert Assert.ThrowsAny <ArgumentException>(() => services.WithMessageHandler <TestMessageHandler, TestMessage, TestMessageContext>(messageBodyFilter: null)); }
public void WithMessageHandlerDefaultContext_WithMessageBodyFilterWithoutImplementationFactory_Fails() { // Arrange var services = new MessageHandlerCollection(new ServiceCollection()); // Act / Assert Assert.ThrowsAny <ArgumentException>(() => services.WithMessageHandler <DefaultTestMessageHandler, TestMessage>( messageBodyFilter: body => true, implementationFactory: null)); }
public void WithMessageHandlerCustomContext_WithoutMessageBodyFilterWithImplementationFactory_Fails() { // Arrange var services = new MessageHandlerCollection(new ServiceCollection()); // Act / Assert Assert.ThrowsAny <ArgumentException>(() => services.WithMessageHandler <TestMessageHandler, TestMessage, TestMessageContext>( messageBodyFilter: null, implementationFactory: serviceProvider => new TestMessageHandler())); }
public void WithMessageHandlerWithDefaultContext_WithoutMessageBodySerializer_Fails() { // Arrange var services = new MessageHandlerCollection(new ServiceCollection()); // Act / Assert Assert.ThrowsAny <ArgumentException>( () => services.WithMessageHandler <DefaultTestMessageHandler, TestMessage>(messageBodySerializer: null)); }
public void WithMessageHandlerWithCustomContext_WithMessageBodySerializerWithoutImplementationFactory_Fails() { // Arrange var services = new MessageHandlerCollection(new ServiceCollection()); // Act / Assert Assert.ThrowsAny <ArgumentException>( () => services.WithMessageHandler <TestMessageHandler, TestMessage, TestMessageContext>( messageBodySerializer: Mock.Of <IMessageBodySerializer>(), implementationFactory: null)); }
public void WithMessageHandlerTMessageHandlerTMessage_WithImplementationFactoryWithMessageContextFilterWithoutMessageBodyFilter_Fails() { // Arrange var services = new MessageHandlerCollection(new ServiceCollection()); // Act / Assert Assert.ThrowsAny <ArgumentException>( () => services.WithMessageHandler <DefaultTestMessageHandler, TestMessage>( context => true, messageBodyFilter: null, implementationFactory: serviceProvider => new DefaultTestMessageHandler())); }
public void WithMessageHandlerWithCustomContext_WithoutMessageBodySerializerImplementationFactoryWithMessageBodyFilter_Fails() { // Arrange var services = new MessageHandlerCollection(new ServiceCollection()); // Act / Assert Assert.ThrowsAny <ArgumentException>( () => services.WithMessageHandler <TestMessageHandler, TestMessage, TestMessageContext>( messageBodySerializerImplementationFactory: null, messageBodyFilter: body => true)); }
/// <summary> /// Adds a <see cref="IMessageHandler{TMessage}" /> implementation to process the messages from an Azure Service Bus. /// resources. /// </summary> /// <typeparam name="TMessageHandler">The type of the implementation.</typeparam> /// <typeparam name="TMessage">The type of the message that the message handler will process.</typeparam> /// <param name="services">The collection of services to use in the application.</param> /// <param name="messageContextFilter">The function that determines if the message handler should handle the message based on the context.</param> /// <exception cref="ArgumentNullException">Thrown when the <paramref name="services"/> or <paramref name="messageContextFilter"/> is <c>null</c>.</exception> public static MessageHandlerCollection WithMessageHandler <TMessageHandler, TMessage>( this MessageHandlerCollection services, Func <MessageContext, bool> messageContextFilter) where TMessageHandler : class, IMessageHandler <TMessage, MessageContext> where TMessage : class { Guard.NotNull(services, nameof(services), "Requires a set of services to add the message handler"); Guard.NotNull(messageContextFilter, nameof(messageContextFilter), "Requires a filter to restrict the message processing within a certain message context"); return(services.WithMessageHandler <TMessageHandler, TMessage, MessageContext>(messageContextFilter)); }
/// <summary> /// Adds a <see cref="IMessageHandler{TMessage}" /> implementation to process the messages from an Azure Service Bus. /// resources. /// </summary> /// <typeparam name="TMessageHandler">The type of the implementation.</typeparam> /// <typeparam name="TMessage">The type of the message that the message handler will process.</typeparam> /// <param name="services">The collection of services to use in the application.</param> /// <param name="messageBodySerializer">The custom <see cref="IMessageBodySerializer"/> to deserialize the incoming message for the <typeparamref name="TMessageHandler"/>.</param> public static MessageHandlerCollection WithMessageHandler <TMessageHandler, TMessage>( this MessageHandlerCollection services, IMessageBodySerializer messageBodySerializer) where TMessageHandler : class, IMessageHandler <TMessage, MessageContext> where TMessage : class { Guard.NotNull(services, nameof(services), "Requires a set of services to add the message handler"); Guard.NotNull(messageBodySerializer, nameof(messageBodySerializer), "Requires an custom message body serializer instance to deserialize incoming message for the message handler"); return(services.WithMessageHandler <TMessageHandler, TMessage, MessageContext>(messageBodySerializer)); }
public void WithMessageHandlerWithDefaultContext_WithMessageBodySerializerImplementationFactoryWithoutMessageHandlerImplementationFactory_Fails() { // Arrange var services = new MessageHandlerCollection(new ServiceCollection()); // Act / Assert Assert.ThrowsAny <ArgumentException>( () => services.WithMessageHandler <DefaultTestMessageHandler, TestMessage>( messageBodySerializerImplementationFactory: serviceProvider => new TestMessageBodySerializer(), messageHandlerImplementationFactory: null)); }
/// <summary> /// Adds a <see cref="IMessageHandler{TMessage}" /> implementation to process the messages from an Azure Service Bus. /// resources. /// </summary> /// <typeparam name="TMessageHandler">The type of the implementation.</typeparam> /// <typeparam name="TMessage">The type of the message that the message handler will process.</typeparam> /// <param name="services">The collection of services to use in the application.</param> /// <param name="messageContextFilter">The function that determines if the message handler should handle the message based on the context.</param> /// <param name="implementationFactory">The function that creates the service.</param> /// <exception cref="ArgumentNullException">Thrown when the <paramref name="services"/>, <paramref name="messageContextFilter"/>, or <paramref name="implementationFactory"/> is <c>null</c>.</exception> public static MessageHandlerCollection WithMessageHandler <TMessageHandler, TMessage>( this MessageHandlerCollection services, Func <MessageContext, bool> messageContextFilter, Func <IServiceProvider, TMessageHandler> implementationFactory) where TMessageHandler : class, IMessageHandler <TMessage, MessageContext> where TMessage : class { Guard.NotNull(services, nameof(services), "Requires a set of services to add the message handler"); Guard.NotNull(messageContextFilter, nameof(messageContextFilter), "Requires a filter to restrict the message processing within a certain message context"); Guard.NotNull(implementationFactory, nameof(implementationFactory), "Requires a function to create the message handler with dependent services"); return(services.WithMessageHandler <TMessageHandler, TMessage, MessageContext>(messageContextFilter, implementationFactory)); }
/// <summary> /// Adds a <see cref="IMessageHandler{TMessage, TMessageContext}" /> implementation to process the messages from an Azure Service Bus. /// resources. /// </summary> /// <typeparam name="TMessageHandler">The type of the implementation.</typeparam> /// <typeparam name="TMessage">The type of the message that the message handler will process.</typeparam> /// <typeparam name="TMessageContext">The type of the context in which the message handler will process the message.</typeparam> /// <param name="services">The collection of services to use in the application.</param> /// <param name="messageContextFilter">The function that determines if the message handler should handle the message based on the context.</param> /// <exception cref="ArgumentNullException">Thrown when the <paramref name="services"/> or <paramref name="messageContextFilter"/> is <c>null</c>.</exception> public static MessageHandlerCollection WithMessageHandler <TMessageHandler, TMessage, TMessageContext>( this MessageHandlerCollection services, Func <TMessageContext, bool> messageContextFilter) where TMessageHandler : class, IMessageHandler <TMessage, TMessageContext> where TMessage : class where TMessageContext : MessageContext { Guard.NotNull(services, nameof(services), "Requires a set of services to add the message handler"); Guard.NotNull(messageContextFilter, nameof(messageContextFilter), "Requires a filter to restrict the message processing within a certain message context"); return(services.WithMessageHandler <TMessageHandler, TMessage, TMessageContext>( messageContextFilter, serviceProvider => ActivatorUtilities.CreateInstance <TMessageHandler>(serviceProvider))); }
/// <summary> /// Adds a <see cref="IMessageHandler{TMessage}" /> implementation to process the messages from an Azure Service Bus. /// resources. /// </summary> /// <typeparam name="TMessageHandler">The type of the implementation.</typeparam> /// <typeparam name="TMessage">The type of the message that the message handler will process.</typeparam> /// <typeparam name="TMessageContext">The type of the context in which the message handler will process the message.</typeparam> /// <param name="services">The collection of services to use in the application.</param> /// <param name="messageBodySerializer">The custom <see cref="IMessageBodySerializer"/> to deserialize the incoming message for the <typeparamref name="TMessageHandler"/>.</param> public static MessageHandlerCollection WithMessageHandler <TMessageHandler, TMessage, TMessageContext>( this MessageHandlerCollection services, IMessageBodySerializer messageBodySerializer) where TMessageHandler : class, IMessageHandler <TMessage, TMessageContext> where TMessage : class where TMessageContext : MessageContext { Guard.NotNull(services, nameof(services), "Requires a set of services to add the message handler"); Guard.NotNull(messageBodySerializer, nameof(messageBodySerializer), "Requires an custom message body serializer instance to deserialize incoming message for the message handler"); return(services.WithMessageHandler <TMessageHandler, TMessage, TMessageContext>( messageBodySerializer, serviceProvider => ActivatorUtilities.CreateInstance <TMessageHandler>(serviceProvider))); }
/// <summary> /// Adds a <see cref="IMessageHandler{TMessage}" /> implementation to process the messages from an Azure Service Bus. /// </summary> /// <typeparam name="TMessageHandler">The type of the implementation.</typeparam> /// <typeparam name="TMessage">The type of the message that the message handler will process.</typeparam> /// <param name="services">The collection of services to use in the application.</param> /// <param name="messageBodySerializer">The function to create the custom <see cref="IMessageBodySerializer"/> that deserializes the incoming message for the <see cref="IMessageHandler{TMessage,TMessageContext}"/>.</param> /// <param name="implementationFactory">The function that creates the service.</param> public static MessageHandlerCollection WithMessageHandler <TMessageHandler, TMessage>( this MessageHandlerCollection services, IMessageBodySerializer messageBodySerializer, Func <IServiceProvider, TMessageHandler> implementationFactory) where TMessageHandler : class, IMessageHandler <TMessage, MessageContext> where TMessage : class { Guard.NotNull(services, nameof(services), "Requires a set of services to add the message handler"); Guard.NotNull(implementationFactory, nameof(implementationFactory), "Requires a function to create the message handler with dependent services"); Guard.NotNull(messageBodySerializer, nameof(messageBodySerializer), "Requires an custom message body serializer instance to deserialize incoming message for the message handler"); return(services.WithMessageHandler <TMessageHandler, TMessage, MessageContext>(messageBodySerializer, implementationFactory)); }
/// <summary> /// Adds a <see cref="IMessageHandler{TMessage}" /> implementation to process the messages from an Azure Service Bus. /// resources. /// </summary> /// <typeparam name="TMessageHandler">The type of the implementation.</typeparam> /// <typeparam name="TMessage">The type of the message that the message handler will process.</typeparam> /// <param name="services">The collection of services to use in the application.</param> /// <param name="messageContextFilter">The function that determines if the message handler should handle the message based on the context.</param> /// <param name="messageBodySerializerImplementationFactory">The custom <see cref="IMessageBodySerializer"/> that deserializes the incoming message for the <see cref="IMessageHandler{TMessage,TMessageContext}"/>.</param> public static MessageHandlerCollection WithMessageHandler <TMessageHandler, TMessage>( this MessageHandlerCollection services, Func <MessageContext, bool> messageContextFilter, Func <IServiceProvider, IMessageBodySerializer> messageBodySerializerImplementationFactory) where TMessageHandler : class, IMessageHandler <TMessage, MessageContext> where TMessage : class { Guard.NotNull(services, nameof(services), "Requires a set of services to add the message handler"); Guard.NotNull(messageContextFilter, nameof(messageContextFilter), "Requires a filter to restrict the message processing within a certain message context"); Guard.NotNull(messageBodySerializerImplementationFactory, nameof(messageBodySerializerImplementationFactory), "Requires a function to create an custom message body serializer to deserialize the incoming message for the message handler"); return(services.WithMessageHandler <TMessageHandler, TMessage, MessageContext>(messageContextFilter, messageBodySerializerImplementationFactory)); }
public void WithMultipleMessageHandlers_WithSameMessageType_RegistersBoth() { // Arrange var services = new MessageHandlerCollection(new ServiceCollection()); services.WithMessageHandler <TestMessageHandler, TestMessage, TestMessageContext>(message => message.TestProperty == "Some value"); // Act services.WithMessageHandler <TestMessageHandler, TestMessage, TestMessageContext>(message => message.TestProperty == "Some other value"); // Assert IServiceProvider provider = services.Services.BuildServiceProvider(); IEnumerable <MessageHandler> handlers = MessageHandler.SubtractFrom(provider, NullLogger.Instance); Assert.Collection( handlers, handler => Assert.True(handler.CanProcessMessageBasedOnMessage(new TestMessage { TestProperty = "Some value" })), handler => Assert.True(handler.CanProcessMessageBasedOnMessage(new TestMessage { TestProperty = "Some other value" }))); }
/// <summary> /// Adds a <see cref="IMessageHandler{TMessage}" /> implementation to process the messages from an Azure Service Bus. /// resources. /// </summary> /// <typeparam name="TMessageHandler">The type of the implementation.</typeparam> /// <typeparam name="TMessage">The type of the message that the message handler will process.</typeparam> /// <param name="services">The collection of services to use in the application.</param> /// <param name="messageContextFilter">The function that determines if the message handler should handle the message based on the context.</param> /// <param name="messageBodyFilter">The filter to restrict the message processing based on the incoming message body.</param> /// <param name="messageBodySerializer">The custom <see cref="IMessageBodySerializer"/> to deserialize the incoming message for the <typeparamref name="TMessageHandler"/>.</param> /// <exception cref="ArgumentNullException">Thrown when the <paramref name="services"/> or <paramref name="messageBodyFilter"/> is <c>null</c>.</exception> public static MessageHandlerCollection WithMessageHandler <TMessageHandler, TMessage>( this MessageHandlerCollection services, Func <MessageContext, bool> messageContextFilter, IMessageBodySerializer messageBodySerializer, Func <TMessage, bool> messageBodyFilter) where TMessageHandler : class, IMessageHandler <TMessage, MessageContext> where TMessage : class { Guard.NotNull(services, nameof(services), "Requires a set of services to add the message handler"); Guard.NotNull(messageContextFilter, nameof(messageContextFilter), "Requires a filter to restrict the message processing within a certain message context"); Guard.NotNull(messageBodySerializer, nameof(messageBodySerializer), "Requires an custom message body serializer instance to deserialize incoming message for the message handler"); Guard.NotNull(messageBodyFilter, nameof(messageBodyFilter), "Requires a filter to restrict the message processing based on the incoming message body"); return(services.WithMessageHandler <TMessageHandler, TMessage, MessageContext>(messageContextFilter, messageBodySerializer, messageBodyFilter)); }
/// <summary> /// Adds a <see cref="IMessageHandler{TMessage, TMessageContext}" /> implementation to process the messages from an Azure Service Bus. /// resources. /// </summary> /// <typeparam name="TMessageHandler">The type of the implementation.</typeparam> /// <typeparam name="TMessage">The type of the message that the message handler will process.</typeparam> /// <typeparam name="TMessageContext">The type of the context in which the message handler will process the message.</typeparam> /// <param name="services">The collection of services to use in the application.</param> /// <param name="messageBodyFilter">The filter to restrict the message processing based on the incoming message body.</param> /// <param name="messageBodySerializerImplementationFactory">The function to create an custom <see cref="IMessageBodySerializer"/> to deserialize the incoming message for the <typeparamref name="TMessageHandler"/>.</param> /// <exception cref="ArgumentNullException">Thrown when the <paramref name="services"/> or <paramref name="messageBodyFilter"/> is <c>null</c>.</exception> public static MessageHandlerCollection WithMessageHandler <TMessageHandler, TMessage, TMessageContext>( this MessageHandlerCollection services, Func <IServiceProvider, IMessageBodySerializer> messageBodySerializerImplementationFactory, Func <TMessage, bool> messageBodyFilter) where TMessageHandler : class, IMessageHandler <TMessage, TMessageContext> where TMessage : class where TMessageContext : MessageContext { Guard.NotNull(services, nameof(services), "Requires a set of services to add the message handler"); Guard.NotNull(messageBodySerializerImplementationFactory, nameof(messageBodySerializerImplementationFactory), "Requires a function to create an custom message body serializer to deserialize the incoming message for the message handler"); Guard.NotNull(messageBodyFilter, nameof(messageBodyFilter), "Requires a filter to restrict the message processing based on the incoming message body"); return(services.WithMessageHandler <TMessageHandler, TMessage, TMessageContext>( messageBodySerializerImplementationFactory, messageBodyFilter, serviceProvider => ActivatorUtilities.CreateInstance <TMessageHandler>(serviceProvider))); }