一、“后退键”不会终止应用
关于 Windows Phone 8.1 的应用生命周期，第一个要知道的关键就是：“后退键”不会终止应用！
在 8.0 时代，不断的按下“后退键”就可以完全的关闭并且终止应用，但在 8.1 中，这样的行为只会让应用处在 Suspended（挂起）状态，可以通过长按“后退键”进入多任务界面查看。
那如果还想像 8.0 一样终止应用呢？（虽然不推荐也没有必要）可以在多任务界面点击应用右上角的“叉叉”或者向下滑。
二、应用生命周期
应用的三个状态分别是：
A：NotRunning
也就是还没开启过应用，在多任务界面没有该应用时。
B：Running
在屏幕上显示的应用就是 Running 状态，同时只会有 1 个应用处于 Running 状态。
C：Suspended
不在屏幕上显示并能在多任务界面查看的应用则处于 Suspended（挂起）状态。
三种状态间切换的操作：
（1）NotRunning -> Running
要从 NotRunning 切换到 Running 状态，其实也就是开启应用，可通过点击应用磁贴、应用间协议启动、Cortana等方式。
在状态的切换过程中会触发 OnLaunched 事件。
（2）Running -> Suspended
当应用不再占据屏幕时则从 Running 切换到 Suspended 状态，可以是“Win”键、“返回键”，有电话打来时也会挂起。
在状态的切换过程中会触发 OnSuspending 事件。
（3）Suspended -> Running
如果在应用挂起状态时没有因为某些原因（比如内存不足）导致应用终止的话，点击磁贴或者多任务切换都会让应用从 Suspender 返回到 Running 状态。
在状态的切换过程中会依次触发 OnResuming 和 OnLaunched 事件。
（4）Suspended -> NotRunning
如果在应用挂起状态时因为某些原因（比如内存不足）导致应用终止的话，则会从 Suspended 变成 NotRunning 状态。
在这过程不会触发任何事件。
三、OnSuspending
因为应用在挂起状态时，并不能预测应用是否会因为某些原因（比如内存不足）而终止，而在这终止过程中也没有事件让开发者处理应用数据，所以只能在应用将要挂起时准备。因此 OnSuspending 事件变得十分重要。
若要使用 OnSuspending 方法则先要在构造函数中添加对其的引用：
public App()
{
this.InitializeComponent();
this.Suspending += OnSuspending;
}
而在 OnSuspending 方法中可以根据需要保存页面数据，比如输入框内的文本、页面导航历史等，可以通过保存在应用独立存储中或利用 NavigationHelper 和 SuspensionManager 类等：
async void OnSuspending(object sender, SuspendingEventArgs e)
{
SuspendingDeferral deferral = e.SuspendingOperation.GetDeferral(); await this.SaveStateToLocalFile(Data.Value); await SuspensionManager.SaveAsync(); deferral.Complete();
}
如果只想保存某个页面的信息则可以在 SaveState 中保存：
private void NavigationHelper_SaveState(object sender, SaveStateEventArgs e)
{
e.PageState["isEditing"] = true;
e.PageState["currentText"] = this.viewModel.DataItem.Title;
}
NavigationHelper 和 SuspensionManager 类是添加基本页时 Visual Studio 自动添加的：
public class NavigationHelper : DependencyObject
{
private Page Page { get; set; }
private Frame Frame { get { return this.Page.Frame; } } public NavigationHelper(Page page)
{
this.Page = page; this.Page.Loaded += (sender, e) =>
{
WINDOWS_PHONE_APP
Windows.Phone.UI.Input.HardwareButtons.BackPressed += HardwareButtons_BackPressed;
e if
}; this.Page.Unloaded += (sender, e) =>
{
WINDOWS_PHONE_APP
Windows.Phone.UI.Input.HardwareButtons.BackPressed -= HardwareButtons_BackPressed;
e if
};
} #region Navigation support RelayCommand _goBackCommand;
RelayCommand _goForwardCommand; public RelayCommand GoBackCommand
{
get
{
if (_goBackCommand == null)
{
_goBackCommand = new RelayCommand(
() => this.GoBack(),
() => this.CanGoBack());
}
return _goBackCommand;
}
set
{
_goBackCommand = value;
}
} public RelayCommand GoForwardCommand
{
get
{
if (_goForwardCommand == null)
{
_goForwardCommand = new RelayCommand(
() => this.GoForward(),
() => this.CanGoForward());
}
return _goForwardCommand;
}
} public virtual bool CanGoBack()
{
return this.Frame != null && this.Frame.CanGoBack;
} public virtual bool CanGoForward()
{
return this.Frame != null && this.Frame.CanGoForward;
} public virtual void GoBack()
{
if (this.Frame != null && this.Frame.CanGoBack) this.Frame.GoBack();
} public virtual void GoForward()
{
if (this.Frame != null && this.Frame.CanGoForward) this.Frame.GoForward();
} #if WINDOWS_PHONE_APP
private void HardwareButtons_BackPressed(object sender, Windows.Phone.UI.Input.BackPressedEventArgs e)
{
if (this.GoBackCommand.CanExecute(null))
{
e.Handled = true;
this.GoBackCommand.Execute(null);
}
}
#else
private void CoreDispatcher_AcceleratorKeyActivated(CoreDispatcher sender,
AcceleratorKeyEventArgs e)
{
var virtualKey = e.VirtualKey; if ((e.EventType == CoreAcceleratorKeyEventType.SystemKeyDown ||
e.EventType == CoreAcceleratorKeyEventType.KeyDown) &&
(virtualKey == VirtualKey.Left || virtualKey == VirtualKey.Right ||
(int)virtualKey == || (int)virtualKey == ))
{
var coreWindow = Window.Current.CoreWindow;
var downState = CoreVirtualKeyStates.Down;
bool menuKey = (coreWindow.GetKeyState(VirtualKey.Menu) & downState) == downState;
bool controlKey = (coreWindow.GetKeyState(VirtualKey.Control) & downState) == downState;
bool shiftKey = (coreWindow.GetKeyState(VirtualKey.Shift) & downState) == downState;
bool noModifiers = !menuKey && !controlKey && !shiftKey;
bool onlyAlt = menuKey && !controlKey && !shiftKey; if (((int)virtualKey == && noModifiers) ||
(virtualKey == VirtualKey.Left && onlyAlt))
{
e.Handled = true;
this.GoBackCommand.Execute(null);
}
else if (((int)virtualKey == && noModifiers) ||
(virtualKey == VirtualKey.Right && onlyAlt))
{
e.Handled = true;
this.GoForwardCommand.Execute(null);
}
}
} private void CoreWindow_PointerPressed(CoreWindow sender,
PointerEventArgs e)
{
var properties = e.CurrentPoint.Properties; if (properties.IsLeftButtonPressed || properties.IsRightButtonPressed ||
properties.IsMiddleButtonPressed) return; bool backPressed = properties.IsXButton1Pressed;
bool forwardPressed = properties.IsXButton2Pressed;
if (backPressed ^ forwardPressed)
{
e.Handled = true;
if (backPressed) this.GoBackCommand.Execute(null);
if (forwardPressed) this.GoForwardCommand.Execute(null);
}
}
#endif #endregion #region Process lifetime management private String _pageKey;
public event LoadStateEventHandler LoadState;
public event SaveStateEventHandler SaveState; public void OnNavigatedTo(NavigationEventArgs e)
{
var frameState = SuspensionManager.SessionStateForFrame(this.Frame);
this._pageKey = "Page-" + this.Frame.BackStackDepth; if (e.NavigationMode == NavigationMode.New)
{
var nextPageKey = this._pageKey;
int nextPageIndex = this.Frame.BackStackDepth;
while (frameState.Remove(nextPageKey))
{
nextPageIndex++;
nextPageKey = "Page-" + nextPageIndex;
} if (this.LoadState != null)
{
this.LoadState(this, new LoadStateEventArgs(e.Parameter, null));
}
}
else
{
if (this.LoadState != null)
{
this.LoadState(this, new LoadStateEventArgs(e.Parameter, (Dictionary<String, Object>)frameState[this._pageKey]));
}
}
} public void OnNavigatedFrom(NavigationEventArgs e)
{
var frameState = SuspensionManager.SessionStateForFrame(this.Frame);
var pageState = new Dictionary<String, Object>();
if (this.SaveState != null)
{
this.SaveState(this, new SaveStateEventArgs(pageState));
}
frameState[_pageKey] = pageState;
} #endregion
} public delegate void LoadStateEventHandler(object sender, LoadStateEventArgs e);
public delegate void SaveStateEventHandler(object sender, SaveStateEventArgs e); public class LoadStateEventArgs : EventArgs
{
public Object NavigationParameter { get; private set; }
public Dictionary<string, Object> PageState { get; private set; } public LoadStateEventArgs(Object navigationParameter, Dictionary<string, Object> pageState)
: base()
{
this.NavigationParameter = navigationParameter;
this.PageState = pageState;
}
} public class SaveStateEventArgs : EventArgs
{
public Dictionary<string, Object> PageState { get; private set; }
public SaveStateEventArgs(Dictionary<string, Object> pageState)
: base()
{
this.PageState = pageState;
}
}
NavigationHelper
internal sealed class SuspensionManager
{
private static Dictionary<string, object> _sessionState = new Dictionary<string, object>();
private static List<Type> _knownTypes = new List<Type>();
private const string sessionStateFilename = "_sessionState.xml"; public static Dictionary<string, object> SessionState
{
get { return _sessionState; }
} public static List<Type> KnownTypes
{
get { return _knownTypes; }
} public static async Task SaveAsync()
{
try
{
foreach (var weakFrameReference in _registeredFrames)
{
Frame frame;
if (weakFrameReference.TryGetTarget(out frame))
{
SaveFrameNavigationState(frame);
}
} MemoryStream sessionData = new MemoryStream();
DataContractSerializer serializer = new DataContractSerializer(typeof(Dictionary<string, object>), _knownTypes);
serializer.WriteObject(sessionData, _sessionState); StorageFile file = await ApplicationData.Current.LocalFolder.CreateFileAsync(sessionStateFilename, CreationCollisionOption.ReplaceExisting);
using (Stream fileStream = await file.OpenStreamForWriteAsync())
{
sessionData.Seek(, SeekOrigin.Begin);
await sessionData.CopyToAsync(fileStream);
}
}
catch (Exception e)
{
throw new SuspensionManagerException(e);
}
} public static async Task RestoreAsync(String sessionBaseKey = null)
{
_sessionState = new Dictionary<String, Object>(); try
{
StorageFile file = await ApplicationData.Current.LocalFolder.GetFileAsync(sessionStateFilename);
using (IInputStream inStream = await file.OpenSequentialReadAsync())
{
DataContractSerializer serializer = new DataContractSerializer(typeof(Dictionary<string, object>), _knownTypes);
_sessionState = (Dictionary<string, object>)serializer.ReadObject(inStream.AsStreamForRead());
} foreach (var weakFrameReference in _registeredFrames)
{
Frame frame;
if (weakFrameReference.TryGetTarget(out frame) && (string)frame.GetValue(FrameSessionBaseKeyProperty) == sessionBaseKey)
{
frame.ClearValue(FrameSessionStateProperty);
RestoreFrameNavigationState(frame);
}
}
}
catch (Exception e)
{
throw new SuspensionManagerException(e);
}
} private static DependencyProperty FrameSessionStateKeyProperty =
DependencyProperty.RegisterAttached("_FrameSessionStateKey", typeof(String), typeof(SuspensionManager), null);
private static DependencyProperty FrameSessionBaseKeyProperty =
DependencyProperty.RegisterAttached("_FrameSessionBaseKeyParams", typeof(String), typeof(SuspensionManager), null);
private static DependencyProperty FrameSessionStateProperty =
DependencyProperty.RegisterAttached("_FrameSessionState", typeof(Dictionary<String, Object>), typeof(SuspensionManager), null);
private static List<WeakReference<Frame>> _registeredFrames = new List<WeakReference<Frame>>(); public static void RegisterFrame(Frame frame, String sessionStateKey, String sessionBaseKey = null)
{
if (frame.GetValue(FrameSessionStateKeyProperty) != null)
{
throw new InvalidOperationException("Frames can only be registered to one session state key");
} if (frame.GetValue(FrameSessionStateProperty) != null)
{
throw new InvalidOperationException("Frames must be either be registered before accessing frame session state, or not registered at all");
} if (!string.IsNullOrEmpty(sessionBaseKey))
{
frame.SetValue(FrameSessionBaseKeyProperty, sessionBaseKey);
sessionStateKey = sessionBaseKey + "_" + sessionStateKey;
} frame.SetValue(FrameSessionStateKeyProperty, sessionStateKey);
_registeredFrames.Add(new WeakReference<Frame>(frame)); RestoreFrameNavigationState(frame);
} public static void UnregisterFrame(Frame frame)
{
SessionState.Remove((String)frame.GetValue(FrameSessionStateKeyProperty));
_registeredFrames.RemoveAll((weakFrameReference) =>
{
Frame testFrame;
return !weakFrameReference.TryGetTarget(out testFrame) || testFrame == frame;
});
} public static Dictionary<String, Object> SessionStateForFrame(Frame frame)
{
var frameState = (Dictionary<String, Object>)frame.GetValue(FrameSessionStateProperty); if (frameState == null)
{
var frameSessionKey = (String)frame.GetValue(FrameSessionStateKeyProperty);
if (frameSessionKey != null)
{
if (!_sessionState.ContainsKey(frameSessionKey))
{
_sessionState[frameSessionKey] = new Dictionary<String, Object>();
}
frameState = (Dictionary<String, Object>)_sessionState[frameSessionKey];
}
else
{
frameState = new Dictionary<String, Object>();
}
frame.SetValue(FrameSessionStateProperty, frameState);
}
return frameState;
} private static void RestoreFrameNavigationState(Frame frame)
{
var frameState = SessionStateForFrame(frame);
if (frameState.ContainsKey("Navigation"))
{
frame.SetNavigationState((String)frameState["Navigation"]);
}
} private static void SaveFrameNavigationState(Frame frame)
{
var frameState = SessionStateForFrame(frame);
frameState["Navigation"] = frame.GetNavigationState();
}
}
public class SuspensionManagerException : Exception
{
public SuspensionManagerException()
{
} public SuspensionManagerException(Exception e)
: base("SuspensionManager failed", e)
{ }
}
SuspensionManager
四、OnResuming
既然在 OnSuspending 和 SaveState 方法中保存了必要数据，就可以在 OnResuming 和 LoadState 方法中获取之前保存的数据：
void OnResuming(object sender, object e)
{
Data.Value += this.CalculateOffsetTimeInDecimalSeconds(this.suspensionTime);
}
private void NavigationHelper_LoadState(object sender, LoadStateEventArgs e)
{
if ((e.PageState != null) && e.PageState.ContainsKey("isEditing"))
{
this.viewModel.SetEditMode();
this.viewModel.DataItem.Title = e.PageState["currentText"] as string;
}
}
五、OnLaunched
首先，在 OnLaunched 方法中可以通过 e.PreviousExecutionState 了解到应用之前的状态。
状态包括：
（1）CloseByUser：被用户主动在多任务界面中关闭
（2）NotRunning：没有启动过
（3）Running：启动中
（4）Terminated：挂起状态时因内存不足被系统终止
（5）Suspended：挂起状态
因此，可以通过对此的判断，根据不同情况处理应用：
protected async override void OnLaunched(LaunchActivatedEventArgs e)
{
Frame rootFrame = Window.Current.Content as Frame; if (rootFrame == null)
{
rootFrame = new Frame(); SuspensionManager.RegisterFrame(rootFrame, "AppFrame"); rootFrame.Language = Windows.Globalization.ApplicationLanguages.Languages[]; if (e.PreviousExecutionState == ApplicationExecutionState.Terminated)
{
try
{
await SuspensionManager.RestoreAsync();
}
catch (SuspensionManagerException)
{
}
} Window.Current.Content = rootFrame;
} if (rootFrame.Content == null)
{
rootFrame.Navigate(typeof(MainPage), e.Arguments);
} Window.Current.Activate();
}
六、注意
以上的方法尽量使用异步操作，不要进行大量的复杂操作。