UWP初始化了几次

Question

I developed a game for UWP with MonoGame. With the project I ran into a huge issue . The application gets initialized several times! The game crashed, probably because of heavy initialization code.

I did not recognize this before publishing the application, because this only happens with the release build mode, and I hadn't tested it in this mode because of long build time. I had made sure that the application did work properly with debug mode on both my own devices as well as on emulators, however when I downloaded it from the store the app crashed on startup so I decided to start analyzing.

I finally built it in release mode and debugged it and placed several breakpoints in both App.xaml.cs and GamePage.xaml.cs. I noticed that these breakpoints got hit in an illogical order, jumping back and forth, even skipping lines of code. Even static boolean values got ignored etc.

This happens only in release mode, not in debug mode!

This issue is not MonoGame related as I was able to recreate the same problem with a Blank App (Universal Windows). How to recreate :

1. Create a new Blank App (Universal Windows)
2. Create a method that takes long to excute and call it in the MainPage constructor (see my test method below).
3. Set breakpoints in both App.xaml.cs and MainPage.xaml.cs(practically at every line)
4. Test the application in debug mode, so that we have something to compare to
5. Test the application in release mode. The breakpoints should now be hit in a strange order.

The debug version runs the heavy method only once, when the release version runs it several times. This is probably caused by some kind of timeout exception, which in turn is caused by the long initialization of MainPage.

My test method(I know that it isn't a method that should be used to measure performance, but it did the trick anyways):

Random r=new Random();
while (true)
        {
            if (r.Next(100000) == 100)
                break;
        }

Does anyone have an idea on how to bypass this or why this is even happening in the first place?

I did also post this on the community.monogame.net. Help would be appreciated and thanks in advance!

Answer 1

In UWP, there are some differences between Debug and Release compile configuration:

When you build and run in " Debug " configuration, you are running IL code against the CoreCLR packaged within your application. The .NET system assemblies are packaged alongside your application code, and your application takes a dependency on the Microsoft.NET.CoreRuntime (CoreCLR) package.

When you switch to " Release " mode, by default your app utilizes the .NET Native toolchain . Since the package is compiled to native binaries, the package does not need to contain the .NET framework libraries. In addition, the package is dependent on the latest installed .NET Native runtime as opposed to the CoreCLR package. The .NET Native runtime on the device will always be compatible with your application package.

And it is important to test in Release mode.

A good rule of thumb is to test your app this way periodically throughout development to make sure you identify and correct any issues that may come from the .NET Native compiler. There should be no issues in the majority of cases; however, there are still a few things that don't play so nicely with .NET Native. Four+ dimensional arrays are one such example. Ultimately, your customers will be getting the .NET Native compiled version of your application, so it is always a good idea to test that version throughout development and before shipping.

For more info, please see .NET Native – What it means for Universal Windows Platform (UWP) developers .

Besides .NET Native toolchain, another important difference is that Release configurations by default optimize the code which loses some artifacts used for debugging. As a result, trying to debug a Release configuration can result in some issues.

It is important to note that the Release configuration is by default fully optimized code (eg code inlining will be applied in many places). These optimizations will have a significant impact on the debugging experience including unpredictable stepping and breakpoint behavior (due to code inlining) and the inability to inspect most variables due to memory optimizations.

To bypass this, we can create a custom configuration and enable the .NET Native toolchain for that configuration. Make sure to not optimize code. For more details please see Debugging .NET Native Windows Universal Apps .

As in my test, if I do not enable "Optimize code", the behavior in Release mode is the same as in Debug mode. Besides, putting a heavy initialization in constructor is not a good practice. You can start the initialization in some other place such as after page loaded etc.