C# 快速应用程序恢复不工作

我正在尝试为Windows Phone 8实现快速应用程序恢复。我跟着

下面是XAML中的代码：

<Tasks>
  <DefaultTask Name="_default" NavigationPage="MainPage.xaml" ActivationPolicy="Resume"/>
</Tasks>

---

假设我在第三年龄。我按下Windows按钮。然后我在开始屏幕上按下我的应用程序图标。而不是应用程序从第三页恢复。它首先显示第三页，然后从主页开始

默认情况下，通过应用程序互动程序启动应用程序时，应用程序仍会导航到默认页面。 如果愿意，可以在RootFrame_导航方法中检查会话类型并取消该导航

默认模板向app.xaml.cs中添加一个CheckNavigation方法，该方法在导航模式重置后清除Backbackback

你可以在那里查看，你的应用程序是否应该停留在最后一页，或者是否最好重新设置并重新开始

处理不同激活类型的示例可在此处找到：

---

（方法：RootFrame_导航）

列出的代码将出错。它与评论不匹配。 查看RootFrame_导航-底部的mustClearPagesStack设置为false-但查看原始MSDN链接中的注释-上面两处表示必须清除页面堆栈。。。。但是因为标志被设置为false，所以它被弄糟了。因此，在顶部将标志设置为false，然后在表示to的两个“if条件”中将其设置为true。

---

然后它会像冠军一样工作。

我使用相同的代码。我面临这个问题。在RootFrame_导航中，您是否更改了/MainPage.xaml的测试以匹配您的主页名称？您是否更改了应用程序中其他位置的所有导航以添加“DeepLink=true”参数？为了让示例代码为您工作，需要执行这些步骤。做了这件事后，它对我来说很好。

    public static PhoneApplicationFrame RootFrame { get; private set; }
    bool wasRelaunched = false;      
    bool mustClearPagestack = false;      
    IsolatedStorageSettings settings = IsolatedStorageSettings.ApplicationSettings;

    enum SessionType
    {
        None,
        Home,
        DeepLink
    }

    private SessionType sessionType = SessionType.None;

    public App()
    {           
        UnhandledException += Application_UnhandledException;         
        InitializeComponent();           
        InitializePhoneApplication();        
        InitializeLanguage();       
        if (Debugger.IsAttached)
        {               
            Application.Current.Host.Settings.EnableFrameRateCounter =true;  
           PhoneApplicationService.Current.UserIdleDetectionMode = IdleDetectionMode.Disabled;
        }
    }

    private void Application_Launching(object sender, LaunchingEventArgs e)
    {
        RemoveCurrentDeactivationSettings();
    }

    private void Application_Activated(object sender, ActivatedEventArgs e)
    {

        mustClearPagestack = CheckDeactivationTimeStamp();

        if (!e.IsApplicationInstancePreserved)
        {
            RestoreSessionType();
        }
    }

     private void Application_Deactivated(object sender, DeactivatedEventArgs e)
     {
        SaveCurrentDeactivationSettings();
    }

    private void Application_Closing(object sender, ClosingEventArgs e)
    {
        RemoveCurrentDeactivationSettings();
    }

    private void RootFrame_NavigationFailed(object sender, NavigationFailedEventArgs e)
    {
        if (Debugger.IsAttached)
        {

            Debugger.Break();
        }
    }

    private void Application_UnhandledException(object sender,ApplicationUnhandledExceptionEventArgs e)
    {
        if (Debugger.IsAttached)
        {

            Debugger.Break();
        }
    }

    private bool phoneApplicationInitialized = false;

    private void InitializePhoneApplication()
    {
        if (phoneApplicationInitialized)
            return;


        RootFrame= new PhoneApplicationFrame();

        RootFrame.Background = new SolidColorBrush(Color.FromArgb(255, 27, 200, 174));
        RootFrame.Navigated += CompleteInitializePhoneApplication;


        RootFrame.NavigationFailed += RootFrame_NavigationFailed;


        RootFrame.Navigated += CheckForResetNavigation;
        RootFrame.Navigating += RootFrame_Navigating;


        phoneApplicationInitialized = true;
    }

    void RootFrame_Navigating(object sender, NavigatingCancelEventArgs e)
    {
        if (e.Uri.ToString().Contains(@"/MainPage.xaml") == true && !AppPrefManager.Instance.IsFastAppResumeEnabled)
        {
            RootFrame.Dispatcher.BeginInvoke(delegate
            {
                if (!AppPrefManager.Instance.IsVirginLaunchCompleted)
                {
                    RootFrame.Navigate(new Uri(Constants.kIntroPage, UriKind.Relative));
                }
                else
                {
                    RootFrame.Navigate(new Uri(Constants.kMainPage, UriKind.Relative));
                }
            });
            e.Cancel = true;
        }


        if (sessionType == SessionType.None && e.NavigationMode == NavigationMode.New)
        {

            if (e.Uri.ToString().Contains("DeepLink=true"))
            {
                sessionType = SessionType.DeepLink;
            }
            else if (e.Uri.ToString().Contains("/MainPage.xaml"))
            {
                sessionType = SessionType.Home;
            }
        }


        if (e.NavigationMode == NavigationMode.Reset)
        {

            wasRelaunched = true;
        }
        else if (e.NavigationMode == NavigationMode.New && wasRelaunched)
        {

            wasRelaunched = false;

            if (e.Uri.ToString().Contains("DeepLink=true"))
            {


                sessionType = SessionType.DeepLink;

            }
            else if (e.Uri.ToString().Contains("/MainPage.xaml"))
            {

                if (sessionType == SessionType.DeepLink)
                {

                    sessionType = SessionType.Home;
                }
                else
                {
                    if (!mustClearPagestack)
                    {

                        e.Cancel = true;
                        RootFrame.Navigated -= ClearBackStackAfterReset;
                    }
                }
            }

            mustClearPagestack = false;
        }
    }

    private void CompleteInitializePhoneApplication(object sender, NavigationEventArgs e)
    {

        if (RootVisual != RootFrame)
            RootVisual = RootFrame;

        RootFrame.Navigated -= CompleteInitializePhoneApplication;
    }

    private void CheckForResetNavigation(object sender, NavigationEventArgs e)
    {

        if (e.NavigationMode == NavigationMode.Reset)
            RootFrame.Navigated += ClearBackStackAfterReset;
    }

    private void ClearBackStackAfterReset(object sender, NavigationEventArgs e)
    {

        RootFrame.Navigated -= ClearBackStackAfterReset;


        if (e.NavigationMode != NavigationMode.New && e.NavigationMode != NavigationMode.Refresh)
            return;


        while (RootFrame.RemoveBackEntry() != null)
        {
            ; 
        }
    }

     private void InitializeLanguage()
    {
        try
        {
            FlowDirection flow = (FlowDirection)Enum.Parse(typeof(FlowDirection), AppResources.ResourceFlowDirection);
            RootFrame.FlowDirection = flow;
        }
        catch
        {
            if (Debugger.IsAttached)
            {
                Debugger.Break();
            }

            throw;
        }
    }

    bool CheckDeactivationTimeStamp()
    {
        DateTimeOffset lastDeactivated;

        if (settings.Contains("DeactivateTime"))
        {
            lastDeactivated = (DateTimeOffset)settings["DeactivateTime"];
        }

        var currentDuration = DateTimeOffset.Now.Subtract(lastDeactivated);

        return TimeSpan.FromSeconds(currentDuration.TotalSeconds) > TimeSpan.FromSeconds(30);
    }

    public bool AddOrUpdateValue(string Key, Object value)
    {
        bool valueChanged = false;


        if (settings.Contains(Key))
        {

            if (settings[Key] != value)
            {

                settings[Key] = value;
                valueChanged = true;
            }
        }

        else
        {
            settings.Add(Key, value);
            valueChanged = true;
        }
        return valueChanged;
    }

    public void RemoveValue(string Key)
    {

        if (settings.Contains(Key))
        {
            settings.Remove(Key);
        }
    }

    public void SaveCurrentDeactivationSettings()
    {
        if (AddOrUpdateValue("DeactivateTime", DateTimeOffset.Now))
        {
            settings.Save();
        }

        if (AddOrUpdateValue("SessionType", sessionType))
        {
            settings.Save();
        }

    }

    public void RemoveCurrentDeactivationSettings()
    {
        RemoveValue("DeactivateTime");
        RemoveValue("SessionType");
        settings.Save();
    }

    void RestoreSessionType()
    {
        if (settings.Contains("SessionType"))
        {
            sessionType = (SessionType)settings["SessionType"];
        }
    }