从静态函数调用InsertAsync会引发ThreadAbortException

Question

I expect there's probably a simple fix for this but I just can't see it.

I'm trying to insert data into an Azure Mobile Services DB from a C# Console program. However when the program is run from within VS (via F5), the data is not being inserted nor is an exception being thrown (that I can see) during the regular course of running the program. When I set a breakpoint to the await dataModel.InsertAsync(data) line and run that in the Immediate Window it throws a ThreadAbortException. Any help is appreciated.

Namespace TestApp {
class Program
{
    public static MobileServiceClient MobileService = new MobileServiceClient(
    "https://x.azure-mobile.net/",
    "API key");

    public static IMobileServiceTable<performance> dataModel = Program.MobileService.GetTable<performance>();

    static void Main(string[] args)
    {
        try
        {
            var test = new performance("http://www.example.com");
            var x = InsertItem(test);
        }
        catch (Exception ex)
        {
            System.Diagnostics.Debug.WriteLine(ex.StackTrace);
        }
    }
static public async Task InsertItem(performance data)
{
        await dataModel.InsertAsync(data).ConfigureAwait(false);
}
}

class performance
{
    [JsonProperty(PropertyName = "id")]
    string Id { get; set; }
    [JsonProperty(PropertyName = "uri")]
    string Uri { get; set; }

    public performance(string uri)
    {
        Uri = uri;
    }

}
}

Answer 1

Your problem comes from the fact that var x = InsertItem(test); is a non blocking call. When you get to await dataModel.InsertAsync(data).ConfigureAwait(false); the function InsertItem immediately returns with a Task .

Normally the correct approach would be do await InsertItem(test); however because your code is being called from Main you can't make the function async . So for this console application (it would not be the correct choice if running in WinForms or WPF app) You need to put a x.Wait() before the end of your try-catch block.

static void Main(string[] args)
{
    try
    {
        var test = new performance("http://www.example.com");
        var x = InsertItem(test);

        //This makes the program wait for the returned Task to complete before continuing.
        x.Wait();
    }
    catch (Exception ex)
    {
        System.Diagnostics.Debug.WriteLine(ex.StackTrace);
    }
}

However if you where to do this in a WPF or WinForms app you would just make the calling function (Assuming the function was a event) async.

private async void Button1_OnClick(object sender, EventArgs e)
{
    try
    {
        var test = new performance("http://www.example.com");

        //The code now waits here for the function to finish.
        await InsertItem(test);
    }
    catch (Exception ex)
    {
        System.Diagnostics.Debug.WriteLine(ex.StackTrace);
    }
}

Do not do async void function calls unless you are in a event delegate function

Answer 2

I created a small test to (somewhat) simulate what you're doing. When the awaited task in InsertItem takes very little or no time at all, the task returned by the var x = InsertItem(test) line returns a task in the RanToCompletion state and the debugger acts as expected.

However, when I make the awaited task do something substantial, such as Thread.Sleep(5000), then I get the behavior you're describing and the task returned by the var x = InsertItem(test) line returns a task in the WaitingForActivation state.

When I put Task.WaitAll(x) following the var x = InsertItem(test) line, then I get the behavior that I think we both expect and x.Status is RanToCompletion.