How to make an async call from within the Match function in C#

[ershadnozari]

Hello,

After having watched this video by Nich Chapsas, I started using the LanguageExt library to replace exceptions in our code. I'm primarily using the Match function like so:

    public async Task<Result<string>> Handle()
    {
        Result<Connection> result = // await async call

        return result.Match(connection =>
        {
            var outcome = // await another async call

            return outcome;
        }, exception =>
        {
            return new Result<string>(exception);
        });
    }

My question is, how do I make the second async call from within the Match function? Is this possible, or what's the alternative? I'm hoping I haven't hit a wall with the library.

Cheers,

[evermanwa]

Personally, I think something like this would be cleaner. I made a dummy Connection object above all of this to just to keep your types the best I can. I also over-loaded these so you can change those boolean values to true if you want to see how the errors are wrapped up in action.

        public static async Task<Result<string>> Handle()
        {
            var result = from a in GetConnection(false)
                         from b in AnotherAsyncCall(a, false)
                         select b;

            return await result.IfLeft(l => l);
        }

        private static EitherAsync<string, Connection> GetConnection(bool isError) =>
            isError ?
            "Error in GetConnection" :
            new Connection();

        private static EitherAsync<string, string> AnotherAsyncCall(Connection connection, bool isError) =>
            isError ?
            LeftAsync<string, string>("Error in AnotherAsyncCall") :
            RightAsync<string, string>("Success in AnotherAsyncCall");

I will also note, I'm no expert in all of this. Others may have a better suggestion, but this is how I would do it.

[ershadnozari]

Hey thanks for response. Your sussegstion seems to complicated for what I'm trying to achive. I need to make multiple async call in the Match function...

[evermanwa]

In my example, you could always chain them all together, but here is another solution using the original code you had. Is this more what you had in mind?

        public class Connection { }

        public static async Task<Result<string>> Handle()
        {
            Result<Connection> result = await GetConnection();

            return result.Match(
                (connection) =>
                {
                    var outcome1 =  AnotherAsyncCall1(connection).GetAwaiter().GetResult();
                    var outcome2 = AnotherAsyncCall2(connection).GetAwaiter().GetResult();
                    var outcome3 = AnotherAsyncCall3(connection).GetAwaiter().GetResult();

                    return $"{outcome1} {outcome2} {outcome3}";
                },
                exception =>
                {
                    return new Result<string>(exception);
                });
        }

        private static async Task<Result<Connection>> GetConnection() =>
            await new Connection().AsTask();

        private static async Task<Result<string>> AnotherAsyncCall1(Connection connection)
        {
            Thread.Sleep(3000);
            return await "outcomeValue1".AsTask();
        }

        private static async Task<Result<string>> AnotherAsyncCall2(Connection connection)
        {
            Thread.Sleep(3000);
            return await "outcomeValue2".AsTask();
        }

        private static async Task<Result<string>> AnotherAsyncCall3(Connection connection)
        {
            Thread.Sleep(3000);
            return await "outcomeValue3".AsTask();
        }

[evermanwa]

Keep in mind, this is a very rudimentary example.

[ershadnozari]

Yes, however Isn't GetResult() blocking? The whole reason I moved from throwing exceptions to using the LanguageExt library is to gain performance.

[evermanwa]

I'm not familiar with how I would do that from within a Match function otherwise, but this is another way I thought of that it could be done.

        public static async Task<Result<string>> Handle()
        {
            Either<Exception, Connection> result = await GetConnection();

            var returnVal = await result
                .MapAsync(async connection => (await AnotherAsyncCall1(connection)).IfLeft(l => l.Message));
            
            return returnVal.Match(
                r => r,
                l => l.Message
            );            
        }

[ershadnozari]

Thanks for asistance, I need to digest this. There's a fair bit of refactoring involved for us to move from Result ot Either :(.

[ershadnozari]

@evermanwa There's a problem with your code. I shouldn't need to perform the second async call if the first call fails. That's an unnecessary and costly IO operation

[ershadnozari]

Here is what I ended up with:

   public async Task<Result<string>> Handle()
    {
        var result = // await async call;

        var returnValue = result
            .Match<Either<Exception, string>>(
                connection => connection,
                exception => exception)
            .Match(connection => connection,
                exception => $"{exception.GetType().FullName}|{exception.Message}");

        if (result.IsFaulted)
        {
            var type = Type.GetType(returnValue!.Split("|")[0]);
            var ctor = type?.GetConstructor(new[] {typeof(string)});
            var exception = ctor?.Invoke(new object[] {returnValue!.Split("|")[1]});

            return new Result<string>(exception as ApplicationException);
        }
        else // Continue processing...
        {
	    // await the next async call

            return result;
        }
    }

@evermanwa Thanks a lot for your input, I certainly got inspiration from you with the Either type. Still keen to know if there's a nother/better way of doing this. Thanks alot.

[evermanwa]

Glad that you found a solution that you liked. Infinite ways to write the solution, and this library definitely adds to the complexity at times. You gave me a bit of inspiration with that first match function converting that to an either exception.