C# code is being executed before getting to the lines before in DEBUG build

Question

I'm at a loss. I have a Task factory that is starting a function:

        Task.Factory.StartNew(() => ServerGetSecureLog(ServerAndProjectorArchive);

        private static void ServerGetSecureLog(string archivePath)
        {
            var localClientManager = InitializeConnection();
            var destinationPath = $"{ServerSecureLogFile}";

            var result = ServerGetBasicSecureLogAsync(localClientManager);
            var sw = StartStopwatch();
            //Wait upto 120s
            if (!result.Wait(TimeSpan.FromSeconds(120))) // <<< Exception thrown here.
            {
                StopStopwatch(sw);
                log.Warn($"{MethodBase.GetCurrentMethod().Name} took too long to execute (timeout exceeded).");
            }
            else
            {
                StopStopwatch(sw);

Thing is, I'm getting an System.AggregateException being thrown as shown above. I must be going insane., because to debug this, I put breakpoints on EVERY line of code before that, on that same line the exception is being thrown and even the line that starts the thread and the lambda that is called, yet NONE of them are getting hit. Going up one stack frame and I get to the call of the lambda that I put the breakpoint on.

Variable state: localClientManager looks to be uninitialized, so seems that the IP got hijacked somehow.

I wouldn't expect the optimizer would do anything on a DEBUG build and there are no unsafe areas in the code. What could cause such bazar behaviour?

Edit

Could Remote Debugging be an issue? Unfortunately, I can't put a debugger on that system, and can't really run the app from a local machine.

Answer 1

Whenever a Task run to completion in failed state - that is, when method that run that task somehow failed - it throws AggregateException.

This is due to the fact that a Task can be continued:

var t = SomeAsyncMethod().ContinueWith(a=> { });

If SomeAsyncMethod throws an exception and ContinueWith also throws an exception, the aggregated exception would have all exceptions for that call.

However, when you're using async/await calls and does try/catch, c# async state unrolls aggregated exceptions and throws original exception on your code.

The problem in your code is related with the fact that GetServerLog method is synchronous and is calling an Task method. You can:

var localClientManager = InitializeConnection();
var destinationPath = $"{ServerSecureLogFile}";
//Wait upto 120s
var cts = new CancellationTokenSource(TimeSpan.FromSeconds(120));
// assumes that this method will look at the token to stop processing and bubbling up a OperationCancelledException/TimeoutException if token expires.
// localClientManager can be null if InitializeConnection returns null or depends on other lazy/async initialization steps.

var result = ServerGetBasicSecureLogAsync(localClientManager, cts.Token);

var sw = Stopwatch.StartNew();
try 
{
    // This can cause deadlocks it Thread pool threads are waiting for a free thread and other locations are doing Waits: https://stackoverflow.com/questions/13140523/await-vs-task-wait-deadlock

    //result.WaitOne(TimeSpan.FromSeconds(120));
    result.GetAwaiter().GetResult();

}
catch(MySimpleException)
{
}
catch(OperationCancelledException)
{
}
finally
{
   sw.Stop();
    // could enclose cts in using statement
   cts.Dispose();
}

Because GetAwaiter().GetResult() is the same method called by async state, it also unrolls the aggregated exception and by using try/catch, you can look at operation cancelled as well.

Also, you don't need to create a Task to run an async method:

async Task SomeAsyncMethod()
{
    var localClientManager = InitializeConnection();
    var destinationPath = $"{ServerSecureLogFile}";
    //Wait upto 120s
    var cts = new CancellationTokenSource(TimeSpan.FromSeconds(120));
    // assumes that this method will look at the token to stop processing and bubbling up a OperationCancelledException/TimeoutException if token expires.
    // localClientManager can be null if InitializeConnection returns null or depends on other lazy/async initialization steps.
    var sw = Stopwatch.StartNew();
    try 
    {
        await ServerGetBasicSecureLogAsync(localClientManager, cts.Token);
    }
    catch(MySimpleException)
    {
    }
    catch(OperationCancelledException)
    {
    }
    finally
    {
        sw.Stop();
        // could enclose cts in using statement
       cts.Dispose();
    }
}

// this call will never throw as long as method is catching and handling exceptions
SomeAsyncMethod().GetAwaiter().GetResult();