/// <summary>
/// Executes the first command and then when it completes executes the second command. The second command
/// returns TOutput, and the returned command also returns TOutput when executed.
/// </summary>
/// <param name="first">The command to execute first</param>
/// <param name="second">The command to execute second</param>
/// <returns>The new command that executes both commands in turn.</returns>
public static IRxFunction <TOutput> Combine <TOutput>(this IRxCommand first, IRxFunction <TOutput> second)
{
return(RxFunction.CreateAsync(async() =>
{
await first.InvokeAsync();
return await second.InvokeAsync();
}));
}
/// <summary>
/// Executes the first command and then when it completes executes the second command. The first command returns
/// TOutput. The second command expects TInput as an argument. The returned command also expects TInput when executed
/// and returns TOutput.
/// </summary>
/// <param name="first">The command to execute first</param>
/// <param name="second">The command to execute second</param>
/// <returns>The new command that executes both commands in turn.</returns>
public static IRxFunction <TInput, TOutput> Combine <TInput, TOutput>(this IRxFunction <TOutput> first, IRxCommand <TInput> second)
{
return(RxFunction.CreateAsync <TInput, TOutput>(async x =>
{
var result = await first.InvokeAsync();
await second.InvokeAsync(x);
return result;
}));
}
/// <summary>
/// Converts an IRxFunction<TOutput> into an IRxCommand. This can be useful with methods such as
/// Combine which expect particular types of commands that may not fit the command you have in order to
/// get the behavor you otherwise expect. The value returned from the function is simply discarded.
/// </summary>
public static IRxCommand <TInput> AsCommand <TInput, TOutput>(this IRxFunction <TInput, TOutput> function)
{
return(RxCommand.Create <TInput>(x => function.InvokeAsync(x)));
}
/// <summary>
/// Converts an IRxFunction<TOutput> into an IRxCommand. This can be useful with methods such as
/// Combine which expect particular types of commands that may not fit the command you have in order to
/// get the behavor you otherwise expect. The value returned from the function is simply discarded.
/// </summary>
public static IRxCommand AsCommand <TOutput>(this IRxFunction <TOutput> function)
{
return(RxCommand.Create(() => function.InvokeAsync()));
}
/// <summary>
/// Converts an unparameterized command into a command parameterized by Unit. This can be useful with methods such
/// as Combine which expect particular types of commands that may not fit the command you have in order to
/// get the behavor you otherwise expect.
/// </summary>
public static IRxFunction <Unit, TOutput> AsParameterized <TOutput>(this IRxFunction <TOutput> command)
{
return(RxFunction.CreateAsync <Unit, TOutput>(_ => command.InvokeAsync()));
}
/// <summary>
/// Executes the first command and then when it completes executes the second command. TInput is passed to the
/// first command and the output of that command is fed in as the argument to the seond command. The returned command
/// expects TInput and returns TSecondOutput when executed.
/// </summary>
/// <param name="first">The command to execute first</param>
/// <param name="second">The command to execute second</param>
/// <returns>The new command that executes both commands in turn.</returns>
public static IRxFunction <TInput, TSecondOutput> Combine <TInput, TFirstOutput, TSecondOutput>(this IRxFunction <TInput, TFirstOutput> first, IRxFunction <TFirstOutput, TSecondOutput> second)
{
return(RxFunction.CreateAsync <TInput, TSecondOutput>(async x =>
{
var firstResult = await first.InvokeAsync(x);
return await second.InvokeAsync(firstResult);
}));
}
/// <summary>
/// Executes the command synchronously by directly returning Result on the async task. This should generally only be
/// called when you know the action will execute synchronously. Otherwise you will likely face potential
/// deadlocks.
/// </summary>
public static TOutput Invoke <TInput, TOutput>(this IRxFunction <TInput, TOutput> command, TInput input)
{
return(command.InvokeAsync(input).Result);
}
/// <summary>
/// Executes the command synchronously by returning Result on the async task. This should generally only be
/// called when you know the action will execute synchronously. Otherwise you will likely face potential
/// deadlocks.
/// </summary>
public static TOutput Invoke <TOutput>(this IRxFunction <TOutput> command)
{
return(command.InvokeAsync().Result);
}
