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)));
}