How do I handle logical and exception errors when calling synchronously using .Result?

[ptr727]

My console app does not use async, and I use .Result for any async methods I have to call.

What is the correct pattern to use for detecting execution errors when calling Command.ExecuteAsync or ExecuteBufferedAsync?

Do I always wrap in a try{}catch()?

Do I test for Task.IsFaulted before and after waiting for .Result?

Or do I test for Task.IsCompletedSuccessfully?

If I use a cancellation token, will it trigger IsFaulted or throw an exception?

E.g. a variant of the wrapper being used:

  public bool Execute(Command command, out BufferedCommandResult result)
  {
      // TODO: do we need to wrap in try/catch?

      // Start execution to get the process id or error
      result = null;
      CommandTask<BufferedCommandResult> task = command.ExecuteBufferedAsync();
      if (task.Task.IsFaulted)
      {
          Log.Error(
              "Error executing {ToolType} : {Parameters}",
              GetToolType(),
              command.Arguments
          );
          // TODO: Will IsFaulted always have an exception?
          Log.Error("{Error}", task.Task.Exception);
          return false;
      }
      Log.Information(
          "Executing {ToolType} : ProcessId: {ProcessId}, {Parameters}",
          GetToolType(),
          task.ProcessId,
          command.Arguments
      );

      // Wait for the process to complete
      result = task.Task.Result;

      // TODO: Is IsFaulted always true if the process fails or is cancelled?
      return !task.Task.IsFaulted;
  }

[Tyrrrz]

If you call GetAwaiter().GetResult() instead of .Result, it should propagate exceptions correctly. But I would recommend just making everything async instead. Console app's main method can be async as well.

[ptr727]

[Edit]
I misread, after some research, when I use GetAwaiter().GetResult() exceptions WILL be thrown, so I must wrap in try/catch, where using .Result the exception will be captured in Task.Exception, but may have deadlock consequences.

Unfortunately it is a slippery slope to make things async, will require large refactor to have the async make it from main to where this code is being executed, so going async is not an option, I have to make do with just "properly" handle CliWrap's async calls.

[Tyrrrz]

GetAwaiter().GetResult() is as close as you will get to running an async method synchronously. You will have to try/catch the errors as you would with a normal sync method.