public void UsingRequestFactory(FutureMessageFactory <TInput, TRequest> factoryMethod)
{
Task <TRequest> AsyncFactoryMethod(FutureConsumeContext <TInput> context)
{
return(Task.FromResult(factoryMethod(context)));
}
_requestEndpoint = new FactoryRequestEndpoint <TInput, TRequest>(_addressProvider, PendingRequestIdProvider, AsyncFactoryMethod);
}
public static EventActivityBinder <FutureState> SetVariable <TValue>(this EventActivityBinder <FutureState> binder, string key,
FutureMessageFactory <TValue> valueFactory)
where TValue : class
{
return(binder.Add(new ActionActivity <FutureState>(context =>
{
var futureContext = context.CreateFutureConsumeContext();
futureContext.SetVariable(key, valueFactory);
})));
}
public void SetCompletedUsingFactory(FutureMessageFactory <TInput, TResult> factoryMethod)
{
if (factoryMethod == null)
{
throw new ArgumentNullException(nameof(factoryMethod));
}
Task <TResult> AsyncFactoryMethod(FutureConsumeContext <TInput> context)
{
return(Task.FromResult(factoryMethod(context)));
}
_result.Factory = AsyncFactoryMethod;
}
public void SetCompletedUsingFactory(FutureMessageFactory <TResponse, TResult> factoryMethod)
{
GetResultConfigurator().SetCompletedUsingFactory(factoryMethod);
}
public static TResult SetResult <TResult>(this FutureConsumeContext context, Guid id, FutureMessageFactory <TResult> factory)
where TResult : class
{
if (!context.Instance.Completed.HasValue)
{
SetCompleted(context, id);
}
var result = factory(context);
context.Instance.Results[id] = new FutureMessage <TResult>(result);
return(result);
}
public static void SetFault <T, TFault>(this FutureConsumeContext <T> context, Guid id, FutureMessageFactory <T, TFault> factory)
where T : class
where TFault : class
{
SetFaulted(context, id);
var result = factory(context);
context.Instance.Faults[id] = new FutureMessage <TFault>(result);
}
public static TValue SetVariable <TValue>(this FutureConsumeContext context, string key, FutureMessageFactory <TValue> factory)
where TValue : class
{
var value = factory(context);
context.Instance.Variables[key] = value;
return(value);
}
/// <summary>
/// Set the result associated with the identifier using the message factory
/// </summary>
/// <param name="binder"></param>
/// <param name="getResultId">Should return the result identifier</param>
/// <param name="messageFactory">Should return the result message</param>
/// <typeparam name="T">The event type</typeparam>
/// <typeparam name="TResult">The result type</typeparam>
/// <returns></returns>
public static EventActivityBinder <FutureState, T> SetResult <T, TResult>(this EventActivityBinder <FutureState, T> binder,
Func <FutureConsumeContext <T>, Guid> getResultId, FutureMessageFactory <T, TResult> messageFactory)
where T : class
where TResult : class
{
return(binder.Then(context =>
{
FutureConsumeContext <T> consumeContext = context.CreateFutureConsumeContext();
var resultId = getResultId(consumeContext);
consumeContext.SetResult(resultId, messageFactory);
}));
}
/// <summary>
/// Set the result associated with the identifier using the message factory
/// </summary>
/// <param name="binder"></param>
/// <param name="messageFactory">Should return the result message</param>
/// <typeparam name="TResult">The result type</typeparam>
/// <returns></returns>
public static EventActivityBinder <FutureState, RoutingSlipFaulted> SetFault <TResult>(this EventActivityBinder <FutureState, RoutingSlipFaulted> binder,
FutureMessageFactory <RoutingSlipFaulted, TResult> messageFactory)
where TResult : class
{
return(binder.Then(context =>
{
FutureConsumeContext <RoutingSlipFaulted> consumeContext = context.CreateFutureConsumeContext();
var resultId = consumeContext.Message.TrackingNumber;
consumeContext.SetFault(resultId, messageFactory);
}));
}
