public async Task SendResponse(FutureConsumeContext <TResponse> context, params FutureSubscription[] subscriptions)
{
context.SetCompleted(context.Instance.CorrelationId);
InitializeContext <TResult> initializeContext = await MessageInitializerCache <TResult> .Initialize(new
{
context.Instance.Completed,
context.Instance.Created,
context.Instance.Faulted,
context.Instance.Location,
}, context.CancellationToken);
var request = context.Instance.GetCommand <TCommand>();
if (request != null)
{
initializeContext = await MessageInitializerCache <TResult> .Initialize(initializeContext, request);
}
if (context.Message != null)
{
initializeContext = await MessageInitializerCache <TResult> .Initialize(initializeContext, context.Message);
}
// this is due to the way headers are propagated via the initializer
var values = _provider(context);
IMessageInitializer <TResult> initializer = MessageInitializerCache <TResult> .GetInitializer(values.GetType());
var result = await context.SendMessageToSubscriptions(subscriptions, initializer, initializeContext, values).ConfigureAwait(false);
if (result == null)
{
// initialize the message and save it as the response
InitializeContext <TResult> messageContext = await initializer.Initialize(initializeContext, values).ConfigureAwait(false);
result = messageContext.Message;
}
context.SetResult(context.Instance.CorrelationId, result);
}
public async Task Execute(BehaviorContext <TInstance, TData> context, Behavior <TInstance, TData> next)
{
ConsumeEventContext <TInstance, TData> consumeContext = context.CreateConsumeContext();
InitializeContext <RequestStarted <TData> > initializeContext = await MessageInitializerCache <RequestStarted <TData> > .Initialize(new
{
context.Instance.CorrelationId,
consumeContext.RequestId,
consumeContext.ResponseAddress,
consumeContext.FaultAddress,
consumeContext.ExpirationTime,
PayloadType = TypeMetadataCache <TData> .MessageTypeNames,
Payload = context.Data
}).ConfigureAwait(false);
object message = initializeContext.Message;
await consumeContext.Publish(message, typeof(RequestStarted)).ConfigureAwait(false);
await next.Execute(context).ConfigureAwait(false);
}
public async Task SendFault(FutureConsumeContext <TInput> context, params FutureSubscription[] subscriptions)
{
InitializeContext <TFault> initializeContext;
if (context.Message is Fault fault)
{
var request = context.Instance.GetCommand <TCommand>();
context.SetFaulted(context.Instance.CorrelationId, fault.Timestamp);
initializeContext = await MessageInitializerCache <TFault> .Initialize(new
{
fault.FaultId,
fault.FaultedMessageId,
fault.Timestamp,
fault.Exceptions,
fault.Host,
fault.FaultMessageTypes,
Message = request
}, context.CancellationToken);
initializeContext = await MessageInitializerCache <TFault> .Initialize(initializeContext, context.Message);
}
else
{
context.SetFaulted(context.Instance.CorrelationId);
initializeContext = await MessageInitializerCache <TFault> .Initialize(context.Message, context.CancellationToken);
}
var values = _provider(context);
IMessageInitializer <TFault> initializer = MessageInitializerCache <TFault> .GetInitializer(values.GetType());
InitializeContext <TFault> messageContext = await initializer.Initialize(initializeContext, values).ConfigureAwait(false);
context.SetFault(context.Instance.CorrelationId, messageContext.Message);
await context.SendMessageToSubscriptions(subscriptions, initializer, initializeContext, values).ConfigureAwait(false);
}
async Task RespondAsyncInternal <T>(object values, IPipe <SendContext <T> > responsePipe = default)
where T : class
{
if (values == null)
{
throw new ArgumentNullException(nameof(values));
}
var context = await MessageInitializerCache <T> .Initialize(Message, _context.CancellationToken).ConfigureAwait(false);
IMessageInitializer <T> initializer = MessageInitializerCache <T> .GetInitializer(values.GetType());
var responseEndpoint = await GetResponseEndpoint <T>().ConfigureAwait(false);
if (responsePipe.IsNotEmpty())
{
await ConsumeTask(initializer.Send(responseEndpoint, context, values, responsePipe)).ConfigureAwait(false);
}
else
{
await ConsumeTask(initializer.Send(responseEndpoint, context, values)).ConfigureAwait(false);
}
}
async Task RespondAsyncInternal <T>(object values, IPipe <SendContext <T> > responsePipe)
where T : class
{
if (values == null)
{
throw new ArgumentNullException(nameof(values));
}
var context = await MessageInitializerCache <T> .Initialize(Message, _context.CancellationToken).ConfigureAwait(false);
IMessageInitializer <T> initializer = MessageInitializerCache <T> .GetInitializer(values.GetType());
if (_context.ResponseAddress != null)
{
var endpoint = await _context.GetSendEndpoint(_context.ResponseAddress).ConfigureAwait(false);
await ConsumeTask(initializer.Send(endpoint, context, values, responsePipe)).ConfigureAwait(false);
}
else
{
await ConsumeTask(initializer.Publish(_context, context, values, responsePipe)).ConfigureAwait(false);
}
}
public async Task Should_convert_value_types_to_strings()
{
InitializeContext <TestStringMessage> context = await MessageInitializerCache <TestStringMessage> .Initialize(new { Text = _intValue });
Assert.That(context.Message.Text, Is.EqualTo(_intValue.ToString()));
}
public async Task Should_initialize_object_with_readonly_property()
{
var model1 = new { ReadWrite = "Some Property Value" };
await MessageInitializerCache <ReadWriteReadOnly> .Initialize(model1);
}
