internal static Task <T> PartialAsync <T>(PartialAccessor <Task <T> > partial)
{
Task <T> task = null;
partial(ref task);
return(task.Safe <T>());
}
internal static T GetPartial <T>(PartialAccessor <T> action)
{
T value = default(T);
action(ref value);
return(value);
}
internal static Task PartialAsync(PartialAccessor <Task> partial)
{
Task task = null;
partial(ref task);
return(task.Safe());
}
/// <summary>
/// Partial methods cannot return a value, so we instead make partial accessors
/// use ref params. This means you cannot effectively make a partial which is
/// async. This code helps create a design pattern where a partial takes a ref Task
/// param and we can await the PartialAsync of it. Given a partial method:
/// partial void FooAsync(ref Task<string> task)
/// we can say string foo = await PartialAsync<string>(FooAsync);
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="self"></param>
/// <param name="partial"></param>
/// <returns></returns>
internal static Task <T> PartialAsync <T>(this object self, PartialAccessor <Task <T> > partial)
{
return(PartialAsync(partial));
}
/// <summary>
/// Partial methods cannot return a value, so we instead make partial accessors
/// use ref params. This helper can be used to write code more normally so we get
/// the out-param or default when calling a partial method. Given a partial method:
/// partial void GetFoo(ref string foo)
/// we can say string foo = this.GetPartial<string>(GetFoo);
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="self"></param>
/// <param name="action"></param>
internal static T GetPartial <T>(this AVObject self, PartialAccessor <T> action)
{
return(GetPartial(action));
}
