public static async Task <FunqResult <Guid> > GetFunqyAsync(this Guid @this)
 {
     return(await Task.FromResult(@this == default(Guid)
                                  ?FunqFactory.Fail <Guid>("The Guid provided to get funqy was the default Guid value and invalid", null)
                                  : FunqFactory.KeepGroovin(@this))
            .ConfigureAwait(false));
 }
        public static FunqResult <TOutput> Finally <TOutput>(this FunqResult @this, Func <FunqResult, FunqResult <TOutput> > callback)
        {
            var result = @this.IsSuccessful
                ? callback(FunqFactory.KeepGroovin(@this.Message))
                : callback(FunqFactory.Fail(@this.Message));

            return(result);
        }
        public static async Task <FunqResult> FinallyAsync(this Task <FunqResult> thisAsync, Func <FunqResult, Task <FunqResult> > callback)
        {
            var @this = await thisAsync.ConfigureAwait(false);

            var result = @this.IsSuccessful
                             ? await callback(FunqFactory.KeepGroovin(@this)).ConfigureAwait(false)
                             : await callback(FunqFactory.Fail(@this.Message, @this)).ConfigureAwait(false);

            return(result);
        }
        public static FunqResult Catch(this FunqResult @this, Func <FunqResult> callback)
        {
            if (@this.IsSuccessful)
            {
                return(FunqFactory.KeepGroovin(@this.Message));
            }
            var errorFunq = callback();

            return(errorFunq);
        }
        public static FunqResult Catch <TInput>(this FunqResult <TInput> @this, Func <FunqResult> callback)
        {
            if (@this.IsSuccessful)
            {
                return(FunqFactory.KeepGroovin(@this.Message));
            }
            var funq = callback();

            return(funq);
        }
        public static FunqResult <TOutput> Catch <TOutput>(this FunqResult <TOutput> @this, Func <FunqResult <TOutput> > callback)
        {
            if (@this.IsSuccessful)
            {
                return(FunqFactory.KeepGroovin(@this.Result, @this.Message));
            }
            var errorFunq = callback();

            return(errorFunq);
        }
        public static async Task <FunqResult> CatchAsync(this Task <FunqResult> thisTask, Func <Task <FunqResult> > callback)
        {
            var @this = await thisTask.ConfigureAwait(false);

            if (@this.IsSuccessful)
            {
                return(await Task.FromResult(FunqFactory.KeepGroovin(@this.Message)).ConfigureAwait(false));
            }
            var errorFunq = await callback().ConfigureAwait(false);

            return(errorFunq);
        }
        public static async Task <FunqResult <T> > GetFunqyAsync <T>(this Task <T> thisTask)
        {
            var @this = await thisTask;

            return(await Task.FromResult(@this == null?FunqFactory.Fail <T>("Nothing to get Funqy with", null) : FunqFactory.KeepGroovin(@this))
                   .ConfigureAwait(false));
        }
 public static FunqResult <Guid> GetFunqy(this Guid @this)
 {
     return(@this == default(Guid)
                ? FunqFactory.Fail <Guid>("The Guid provided to get funqy was the default Guid value and invalid", null)
                : FunqFactory.KeepGroovin(@this));
 }
Пример #10
0
 public static FunqResult <T> GetFunqy <T>(this T @this)
 {
     return(@this == null?FunqFactory.Fail <T>("Nothing to get Funqy with", null) : FunqFactory.KeepGroovin(@this));
 }