Win32和UWP之间进行通信时，SendMessageAsync随机引发异常

Question

In my UWP App I need to continuously send data to a UWP app from a WinForms (Win32) component and vice versa. However, I have a weird bug in my WinForms component. Sometimes, upon launching the WinForm, I get a System.InvalidOperationException when calling await connection.SendMessageAsync(message) saying: A method was called at an unexpected time Other times, it works perfectly.

My Code:

private async void SendToUWPVoidAsync(object content)
{
    ValueSet message = new ValueSet();
    if (content != "request") message.Add("content", content);
    else message.Add(content as string, "");

    #region SendToUWP

    // if connection isn't inited
    if (connection == null)
    {
        // init
        connection = new AppServiceConnection();
        connection.PackageFamilyName = Package.Current.Id.FamilyName;
        connection.AppServiceName = "NotifyIconsUWP";
        connection.ServiceClosed += Connection_ServiceClosed;

        // attempt connection 
        AppServiceConnectionStatus connectionStatus = await connection.OpenAsync();
    }

    AppServiceResponse serviceResponse = await connection.SendMessageAsync(message);

    // get response
    if (serviceResponse.Message.ContainsKey("content"))
    {
        object newMessage = null;
        serviceResponse.Message.TryGetValue("content", out newMessage);

        // if message is an int[]
        if (newMessage is int[])
        {
            // init field vars
            int indexInArray = 0;
            foreach (int trueorfalse in (int[])newMessage)
            {
                // set bool state based on index
                switch (indexInArray)
                {
                    case 0:
                        notifyIcon1.Visible = Convert.ToBoolean(trueorfalse);
                        break;
                    case 1:
                        notifyIcon2.Visible = Convert.ToBoolean(trueorfalse);
                        break;
                    case 2:
                        notifyIcon3.Visible = Convert.ToBoolean(trueorfalse);
                        break;
                    default:
                        break;
                }
                indexInArray++;
            }
        }
    }
    #endregion
}

The method is called like this:

private void TCheckLockedKeys_Tick(object sender, EventArgs e)
{
    ...

    if (statusesChanged)
    {
        // update all bools
        bool1 = ...;
        bool2 = ...;
        bool3 = ...;

        // build int[] from bool values
        int[] statuses = new int[] { Convert.ToInt32(bool1), Convert.ToInt32(bool2), Convert.ToInt32(bool3) };

        // update UWP sibling
        SendToUWPVoidAsync(statuses);
    }

    // ask for new settings
    SendToUWPVoidAsync("request");
}

TCheckLockedKeys_Tick.Interval is set to 250 milliseconds.

Is there any way to prevent or to correctly handle this exception without the WinForm Component exiting but still establishing the vital communication path?

Any ideas?

Thanks

Answer 1

Okay, I have found a solution. One might actually call it a workaround.

In my WinForm, I changed the code as follows:

AppServiceResponse serviceResponse = await connection.SendMessageAsync(message);

to:

AppServiceResponse serviceResponse = null;
try
{
    // send message
    serviceResponse = await connection.SendMessageAsync(message);
}
catch (Exception)
{
     // exit 
     capsLockStatusNI.Visible = false;
     numLockStatusNI.Visible = false;
     scrollLockStatusNI.Visible = false;

     Application.Exit();
 }

I have also changed code in my App.xaml.cs file:

private async void OnTaskCanceled(IBackgroundTaskInstance sender, BackgroundTaskCancellationReason reason)
{
    if (this.appServiceDeferral != null)
    {
        // Complete the service deferral.
        this.appServiceDeferral.Complete();
    }
}

to:

private async void OnTaskCanceled(IBackgroundTaskInstance sender, BackgroundTaskCancellationReason reason)
{
    if (reason == BackgroundTaskCancellationReason.SystemPolicy)
    {
        // WinForm called Application.Exit()
        await FullTrustProcessLauncher.LaunchFullTrustProcessForCurrentAppAsync();
    }
    if (this.appServiceDeferral != null)
    {
        // Complete the service deferral.
        this.appServiceDeferral.Complete();
    }
}

I know all I'm doing is, technically, relaunching the Form till it succeeds which is not entirely the correct way of solving it. But, it works.

Answer 2

Some advice based on

Reference Async/Await - Best Practices in Asynchronous Programming

Avoid using async void except with event handlers. Prefer async Task methods over async void methods.

async void methods a fire an forget, which can cause the issues being encountered as exceptions are not being thrown in the correct context.

Async void methods have different error-handling semantics. When an exception is thrown out of an async Task or async Task method, that exception is captured and placed on the Task object. With async void methods, there is no Task object, so any exceptions thrown out of an async void method will be raised directly on the SynchronizationContext that was active when the async void method started.

Given that the method is being called within an event handler. then refactor the method to use an async Task

private async Task SendToUWPVoidAsync(object content) {

    //...

}

and update the event handler to be async

private async void TCheckLockedKeys_Tick(object sender, EventArgs e) {
    try {
        //...

        if (statusesChanged) {
            // update all bools
            bool1 = ...;
            bool2 = ...;
            bool3 = ...;

            // build int[] from bool values
            int[] statuses = new int[] { Convert.ToInt32(bool1), Convert.ToInt32(bool2), Convert.ToInt32(bool3) };

            // update UWP sibling
            await SendToUWPVoidAsync(statuses);
        }

        // ask for new settings
        await SendToUWPVoidAsync("request");

    }catch {
        //...handle error appropriately
    }
}

which should also allow for any exception to be caught as shown in the example above.