Queuing up an exit event.

Gavin Williams 761

In my app code I have:

     if (args.VirtualKey == Windows.System.VirtualKey.Escape)
         ExitApplication();

    private void ExitApplication()
    {
        gfxTest.Stop();
    }

The gfxTest class is running a thread:

        public void Start()
        {
            CoreWindow.GetForCurrentThread().Dispatcher.ProcessEvents(CoreProcessEventsOption.ProcessAllIfPresent);

            IAsyncAction mainLoopWorker;
            WorkItemHandler workHandler = new WorkItemHandler((IAsyncAction action) =>
            {
                while (action.Status == AsyncStatus.Started && TaskState != TaskState.Exiting)
                {    
                    bool swapChainResized = CoreGraphics.SwapChain.UpdateSize();
                    if (CoreGraphics.SwapChain.Width == 0 || CoreGraphics.SwapChain.Height == 0)
                        continue;

                    CoreGraphics.SwapChain.ClearRTV(Color8bit.CornflowerBlue);
                    CoreGraphics.SwapChain.ClearDSV(0);

                    // Graphics test code here

                    CoreGraphics.Present();

                }

                // signal application quit or else ProcessUntilQuit will wait for windows close button press
                Exit();
            });
            mainLoopWorker = ThreadPool.RunAsync(workHandler, WorkItemPriority.High, WorkItemOptions.TimeSliced);

            // ProcessUntilQuit will block the UI thread and process events as they appear until the App terminates.
            CoreWindow.GetForCurrentThread().Dispatcher.ProcessEvents(CoreProcessEventsOption.ProcessUntilQuit); 
        }

My Exit function:

        public void Exit()
        {
            CoreGraphics.Dispose();
            Application.Current.Exit();
        }

Application.Current.Exit will cause a catastrophic failure. So what I want is some way to queue up a normal application exit event for the event processor to catch.

Fay Wang - MSFT 5,211 Reputation points

2020-08-26T06:42:14.96+00:00

Do you mean when you called Application.Current.Exit() method, you received "catastrophic failure" exception? You could try to use ApplicationView.TryConsolidateAsync() to close your current window which is equivalent to a user initiating a close gesture for the app view.
Gavin Williams 761 Reputation points

2020-08-26T06:55:44.577+00:00
Yes, that's right. I also tried

public void Exit() { CoreGraphics.Dispose(); ApplicationView.GetForCurrentView().TryConsolidateAsync(); }

But that throws an exception - Element not found.

It's interesting, because I've handled programmatic shutdown in the past - but it seems it's a little fragile (not thread safe?)
Gavin Williams 761 Reputation points

2020-08-26T07:07:52.907+00:00

If I put the call to TryConsolidateAsync() call back in the app class (this is a CoreWindow stub) it does shutdown properly, but then the question remains. What happens to my async action loop? Does it's status get changed to completed or cancelled - so that I can predict when that thread will exit (hopefully at the natural terminus of the loop. I wouldn't want that thread shutdown by force in the middle because that could leave state invalid. I would want the action to complete and the while to see that it's condition fails. That way execution will fall out of the while and I will have a chance to perform any saves and shutdown procedure.

I guess a naive test would be to log a message at the call to Exit - just after the while loop.
Gavin Williams 761 Reputation points

2020-08-26T07:42:05.933+00:00

So using TryConsolidateAsync interrupts the async action. Yeah, I don't think that's good. Take the case where I was doing some kind of update of state, and that was interrupted, or if there were other background threads in flight. I can imagine corruption of state could occur.

So I actually need to shutdown that thread first don't I.
Gavin Williams 761 Reputation points

2020-08-26T08:16:57.227+00:00

So ApplicationView.GetForCurrentView().TryConsolidateAsync(); seems OK to use if it's called from the app class, not from a threadpool thread.

A separate issue then, is how to correctly tear down the thread before making this call, or else corruption will occur.
Fay Wang - MSFT 5,211 Reputation points

2020-08-26T08:50:46.907+00:00

I'm a little confused, when the Status of action is completed/canceled or TaskState is equal to Exiting, the while loop will finish and the Exit() method will be triggered, what does "using TryConsolidateAsync interrupts the async action" mean? When the Exit() method is triggered, the thread has completed/canceled. In addition, when I used TryConsolidateAsync or Application.Current.Exit method, I didn't receive the same exception, could you please provide us a simple repo code by using OneDrive or Github?
Fay Wang - MSFT 5,211 Reputation points

2020-08-27T06:16:50.177+00:00

Maybe you could try to handle it in a synchronous method, close threads or release elements. Then calling the api to close the application after the execution is complete.
Fay Wang - MSFT 5,211 Reputation points

2020-09-01T03:13:21.707+00:00

In addition, could you please tell us what your process is like? Can you provide more information about what is trying to do and what you would hope to achieve with it?

Share via

Queuing up an exit event.

Your answer