To check this, set a breakpoint within the OnSuspending method. After this you have to set the build target to some mobile emulator and run the application in debug mode. Select Suspend around the Lifecycle Occasions tool to verify the breakpoint is hit. Press F5 to carry on beyond the breakpoint and choose Resume around the tool to create the application back to view.
Now comes the enjoyment part. Hold lower the rear button before the software development company decreases within the mobile emulator’s screen. An X seems around the upper right corner from the application permitting us to shut it. Once the X is pressed, the breakpoint doesn’t get hit this time around.
This straightforward test informs you the application doesn’t get into suspend mode when it’s wiped out in the phone’s application switcher screen, but rather, it is going straight into a not running condition.
You’ll find there are occasions whenever you can’t quite recall the way the UWP lifecycle works in each and every circumstance. In individuals situations, it frequently will work better to simply test out your presumptions using the debugging tools Visual Studio provides rather than try working it by combing through online articles. You may also discover that you comprehend the UWP application lifecycle better whenever you check it out on your own.
When an application is suspended after which effectively came back towards the running condition, the applying.Returning to event is known as instead of Application.OnLaunched. What in the event you use Application.Resuming?
Oftentimes, it’s not necessary to complete anything whatsoever. Application.Suspending is usually used only to handle possibility the application could get ended. If you would like your application to become good UWP people, however, you may even use Application.Suspending to deallocate costly sources as the application adopts hibernation. Costly sources may include everything from images and seem files to products. If you opt to do that, it’s important to implement a handler for that Application.Resuming event and reinitialize individuals sources.
There’s another exceptional circumstance to bear in mind for the UWP apps: whenever a user starts an application which has really recently been suspended, therefore the software development company calls the applying.Returning to event rather. This happens once the application continues to be selected for prelaunch, that is for those intents and reasons transparent towards the user.
Prelaunch happens when the device has sufficient sources and also the application is decided to become frequently released through the current user. To enhance performance, apps selected for prelaunch are released without anyone’s knowledge in advance after which rapidly suspended.
Due to prelaunch, the app’s OnLaunched method might be started through the system instead of a person. Your particulars are often adopted with a call to Application.Suspending. Then, once the user does attempt to launch the application, the Resuming event is invoked along with the OnLaunched method.
Remarkably, no additional steps are usually needed to deal with prelaunch. The lifecycle code we’ve already covered handles everything good enough. In certain conditions, though, for example when an application uses heavy sources at launch to produce a visual impact, it might be helpful to differentiate a prelaunch from the normal launch therefore the effort doesn’t be wasted.
The LaunchActivatedEventArgs object includes a boolean property known as PrelaunchActivated that signifies whether OnLaunched is answering a genuine user in order to the prelaunch optimisation. This flag may be used to step over any actions that visits waste when nobody is around to determine them. Just like the conventional lifecycle occasions, Visual Studio also assists you to test a prelaunch scenario. Discover more about prelaunch on MSDN.