public static async Task <MethodResult <TResult> > TryMapAsync <TSource, TResult>(
this Task <TSource> @this,
Func <TSource, MethodResult <TResult> > function
)
{
var t = await @this;
return(TryExtensions.Try(() => function(t)));
}
public static async Task <MethodResult <TResult> > TryMapAsync <TSource, TResult>(
this Task <TSource> @this,
Func <TSource, Task <MethodResult <TResult> > > function,
int numOfTry
)
{
var t = await @this;
return(await TryExtensions.TryAsync(() => function(t), numOfTry));
}
public static Task <MethodResult> ForEachUntilIsSuccessAsync <TSource, TResult>(
this Task <IEnumerable <TSource> > @this,
Func <TSource, Task <MethodResult <TResult> > > function) =>
TryExtensions.TryAsync(() => @this)
.OnSuccessAsync(async items => {
foreach (var item in items)
{
var result = await function(item);
if (!result.IsSuccess)
{
return(MethodResult.Fail(result.Detail));
}
}
return(MethodResult.Ok());
});
public static Task <MethodResult> ForEachUntilIsSuccessAsync <T>(
this Task <IEnumerable <T> > @this,
Func <T, Task> action) => TryExtensions.TryAsync(() => @this)
.OnSuccessAsync(async items => {
var list = items.ToList();
foreach (var item in list)
{
try {
await action(item);
}
catch (Exception e) {
return(MethodResult.Fail(new ExceptionError(e,
moreDetails: new { thisObj = list, targetItem = item })));
}
}
return(MethodResult.Ok());
});
public static Task <MethodResult> ForEachUntilIsSuccessAsync <T>(
this Task <IEnumerable <MethodResult <T> > > @this,
Func <T, Task <MethodResult> > function) =>
TryExtensions.TryAsync(() => @this)
.OnSuccessAsync(async items => {
foreach (var item in items)
{
if (!item.IsSuccess)
{
return(item.MapMethodResult());
}
var result = await function(item.Value);
if (!result.IsSuccess)
{
return(result);
}
}
return(MethodResult.Ok());
});
public static Task <MethodResult> TryTeeOnSuccessAsync(
this Task <MethodResult> @this,
Action action) => @this
.OnSuccessAsync(() => TryExtensions.Try(action));
public static MethodResult <T> TryTee <T>(
this T @this,
Action?action) => TryExtensions.Try(() => @this.Tee(action));
public static Task <MethodResult <TResult> > TryMapAsync <TSource, TResult>(
this TSource @this,
Func <TSource, Task <MethodResult <TResult> > > function,
int numOfTry
) => TryExtensions.TryAsync(() => function(@this), numOfTry);
public static MethodResult TryTee <TResult>(
Func <TResult> function) => TryExtensions.Try(() => TeeExtensions.Tee(function));
public static MethodResult <T> TryTeeUsing <T>(
this T obj,
Action <T> action) where T : IDisposable =>
TryExtensions.Try(() => obj.TeeUsing(action));
public static MethodResult TryOperateWhen(
bool predicate, Action action) =>
OperateWhen(predicate, () => TryExtensions.Try(action));
public static MethodResult <T> TryOperateWhen <T>(
this T @this,
Func <bool> predicateFun,
Func <T, MethodResult <T> > function
) => TryExtensions.Try(predicateFun)
.OnSuccess(predict => @this.OperateWhen(predict, function));
public static MethodResult TryTeeOnSuccess(
this MethodResult @this,
Action action) => @this
.OnSuccess(() => TryExtensions.Try(action));
public static Task <MethodResult <TSource> > TryTeeAsync <TSource, TResult>(
this Task <TSource> @this, Func <Task <TResult> > function,
int numOfTry) => TryExtensions.TryAsync(() => @this.TeeAsync(function), numOfTry);
public static Task <MethodResult <T> > TryTeeAsync <T>(
this Task <T> @this, Action?action, int numOfTry) =>
TryExtensions.TryAsync(() => @this.TeeAsync(action), numOfTry);
public static Task <MethodResult> TryTeeAsync <TResult>(
Func <Task <TResult> > function, int numOfTry) =>
TryExtensions.TryAsync(() => TeeAsync(function), numOfTry);
public static MethodResult TryTee(Action?action) => TryExtensions.Try(() => TeeExtensions.Tee(action));
public static MethodResult TryOperateWhen(
Func <bool> predicateFun, Action action) =>
TryExtensions.Try(predicateFun)
.OnSuccess(predict => TryOperateWhen(predict, action));
public static MethodResult <TResult> TryMap <TSource, TResult>(
this TSource _,
Func <TResult> onSuccessFunction
) => TryExtensions.Try(onSuccessFunction);
public static MethodResult <T> TryOperateWhen <T>(
this T @this,
bool predicate, Action action) =>
@this.OperateWhen(predicate, () => TryExtensions.Try(action));
public static MethodResult <TResult> TryMap <TSource, TResult>(
this TSource @this,
Func <TSource, MethodResult <TResult> > function) =>
TryExtensions.Try(() => function(@this));
public static MethodResult <TResult> TryMapMethodResult <TResult>(
this MethodResult @this,
Func <TResult> onSuccessFunction,
Func <ResultDetail, TResult> onFailFunction
) => TryExtensions.Try(() => @this.MapMethodResult(onSuccessFunction, onFailFunction));
public static Task <MethodResult <TResult> > TryMapAsync <TSource, TResult>(
this TSource @this,
Func <TSource, Task <TResult> > onSuccessFunction
) => TryExtensions.TryAsync(() => onSuccessFunction(@this));
public static Task <MethodResult <TResult> > TryUsingAsync <TSource, TResult>(
this TSource obj,
Func <TSource, Task <MethodResult <TResult> > > function,
int numOfTry) where TSource : IDisposable =>
TryExtensions.TryAsync(() => obj.UsingAsync(function), numOfTry);
public static Task <MethodResult> TryMapAsync <TSource>(
this TSource _,
Func <Task <MethodResult> > onSuccessFunction
) => TryExtensions.TryAsync(onSuccessFunction);
public static MethodResult <TSource> TryTeeUsing <TSource, TResult>(
this TSource obj,
Func <TSource, TResult> function) where TSource : IDisposable =>
TryExtensions.Try(() => obj.TeeUsing(function));
public static MethodResult <TSource> TryTee <TSource, TResult>(
this TSource @this,
Func <TResult> function) => TryExtensions.Try(() => @this.Tee(function));
