public Task <MessageData <TValue> > GetProperty <T>(InitializeContext <T, TInput> context)
where T : class
{
if (!context.HasInput)
{
return(TaskUtil.Default <MessageData <TValue> >());
}
Task <MessageData <TValue> > inputTask = _inputProvider.GetProperty(context);
if (inputTask.IsCompleted)
{
MessageData <TValue> messageData = inputTask.Result;
if (messageData is IInlineMessageData)
{
return(Task.FromResult(messageData));
}
if (messageData?.Address != null)
{
var repository = _repository;
if (repository != null || context.TryGetPayload(out repository))
{
return(Task.FromResult(_reader.GetMessageData(repository, messageData.Address, context.CancellationToken)));
}
}
return(Task.FromResult(EmptyMessageData <TValue> .Instance));
}
async Task <MessageData <TValue> > GetPropertyAsync()
{
MessageData <TValue> messageData = await inputTask.ConfigureAwait(false);
if (messageData is IInlineMessageData)
{
return(messageData);
}
if (messageData?.Address != null)
{
var repository = _repository;
if (repository != null || context.TryGetPayload(out repository))
{
return(_reader.GetMessageData(repository, messageData.Address, context.CancellationToken));
}
}
return(EmptyMessageData <TValue> .Instance);
}
return(GetPropertyAsync());
}
Task <TProperty> IPropertyConverter <TProperty, TProperty> .Convert <TMessage>(InitializeContext <TMessage> context, TProperty input)
{
if (input == null || !context.TryGetPayload(out TransformContext <TMessage> transformContext) || !transformContext.HasInput)
{
return(TaskUtil.Default <TProperty>());
}
var propertyTransformContext = new PropertyTransformContext <TMessage, TProperty>(transformContext, input);
InitializeContext <TProperty> messageContext = _initializer.Create(propertyTransformContext);
Task <InitializeContext <TProperty> > initTask = _initializer.Initialize(messageContext, input);
if (initTask.IsCompleted)
{
return(Task.FromResult(initTask.Result.Message));
}
async Task <TProperty> ConvertAsync()
{
InitializeContext <TProperty> result = await initTask.ConfigureAwait(false);
return(result.Message);
}
return(ConvertAsync());
}
public Task <TProperty> GetProperty <T>(InitializeContext <T, TInput> context)
where T : class
{
if (!context.TryGetPayload <TransformContext <TInput> >(out TransformContext <TInput> transformContext))
{
return(TaskUtil.Default <TProperty>());
}
if (!context.HasInput)
{
return(TaskUtil.Default <TProperty>());
}
Task <TProperty> inputTask = _inputProvider.GetProperty(context);
if (inputTask.IsCompleted)
{
var propertyContext = new MessageTransformPropertyContext <TProperty, TInput>(transformContext, inputTask.Result);
return(_valueProvider(propertyContext));
}
async Task <TProperty> GetPropertyAsync()
{
var inputValue = await inputTask.ConfigureAwait(false);
var propertyContext = new MessageTransformPropertyContext <TProperty, TInput>(transformContext, inputValue);
return(await _valueProvider(propertyContext).ConfigureAwait(false));
}
return(GetPropertyAsync());
}
public InitializeContext <TMessage> Create(InitializeContext context)
{
if (context.TryGetPayload(out TransformContext <TMessage> transformContext) && transformContext.HasInput)
{
return(context.CreateMessageContext(transformContext.Input));
}
throw new InvalidOperationException("The original message context was not available.");
}
