/// <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 first command and then when it completes executes the second command. Both commands
/// expect TInput as a parameter. The second command returns TOutput. The returned command expects
/// TInput and 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 <TInput, TOutput> Combine <TInput, TOutput>(this IRxCommand <TInput> first, IRxFunction <TInput, TOutput> second)
{
return(RxFunction.CreateAsync <TInput, TOutput>(async x =>
{
await first.InvokeAsync(x);
return await second.InvokeAsync(x);
}));
}
/// <summary>
/// Executes the first command and then when it completes executes the second command. The first command
/// returns TOutput. The returned command also 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 <TOutput> Combine <TOutput>(this IRxFunction <TOutput> first, IRxCommand second)
{
return(RxFunction.CreateAsync(async() =>
{
var result = await first.InvokeAsync();
await second.InvokeAsync();
return result;
}));
}
/// <summary>
/// Creates a command that consumes input and produces output.
/// </summary>
/// <param name="action">The action to execute when invoking the command.</param>
/// <param name="canExecute">An observable that dictates whether or not the command may execute. If not
/// specified, an observable is created that produces true.</param>
/// <param name="defaultValue">A factory function to provide the return value for when the method fails to execute.</param>
/// <param name="allowSimultaneousExecution">If true, multiple execution of this command may be performed. If false,
/// then subsequent calls to ExecuteAsync return the defaultValue until the execution of the initial invocation completes.</param>
public static IRxFunction <TInput, TOutput> CreateAsync <TInput, TOutput>(Func <TInput, Task <TOutput> > action, IObservable <bool> canExecute = null, Func <TOutput> defaultValue = null, bool allowSimultaneousExecution = false)
{
return(RxFunction <TInput> .CreateAsync(action, canExecute, defaultValue, allowSimultaneousExecution));
}
/// <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()));
}