Hantera apptillstånd effektivt

I ett skrivbord Windows App SDK program fortsätter processen att köras tills användaren uttryckligen stänger den. Skrivbordsappar går inte igenom den automatiska pausa, återuppta och avsluta livscykeln som UWP-appar använder. Detta ger dig mer kontroll, men också mer ansvar för att hantera tillstånd.

Förutsättningar

• Ett Windows App SDK skrivbordsprojekt. Installationssteg finns i Skapa din första WinUI 3-app.
• Kunskaper om Microsoft.UI.Windowing.AppWindow klassen och, för paketerade appar, Windows.Storage.ApplicationData.

Varför statlig hantering är viktig

Även om skrivbordsappar inte pausas av operativsystemet finns det fortfarande situationer där appen kan förlora osparat tillstånd:

• Användaren stänger appen medan arbetet pågår
• Systemet startas om för en uppdatering
• Strömförlust eller krasch avslutar processen
• Användaren loggar ut från Windows

Utforma din app så att den hanterar dessa fall på ett korrekt sätt genom att spara viktiga tillstånd ofta och återställa den när appen startar.

Spara tillstånd stegvis

I stället för att spara allt tillstånd vid avstängning sparar du tillståndet stegvis när användaren fungerar. Detta minskar risken för dataförlust och fördelar I/O-kostnaden under appens livslängd.

private async void OnThemeChanged(object sender, SelectionChangedEventArgs e)
{
    var selectedTheme = (sender as ComboBox)?.SelectedItem?.ToString();
    if (selectedTheme != null)
    {
        await SaveSettingAsync("AppTheme", selectedTheme);
    }
}

private async Task SaveSettingAsync(string key, string value)
{
    // Use local file storage, a database, or ApplicationData for packaged apps.
    var localFolder = Environment.GetFolderPath(Environment.SpecialFolder.LocalApplicationData);
    var settingsDir = System.IO.Path.Combine(localFolder, "MyApp");
    Directory.CreateDirectory(settingsDir);
    var settingsPath = System.IO.Path.Combine(settingsDir, "settings.json");

    // Read existing settings, update, and save asynchronously.
    var settings = LoadSettings(settingsPath);
    settings[key] = value;
    await File.WriteAllTextAsync(settingsPath, System.Text.Json.JsonSerializer.Serialize(settings));
}

private Dictionary<string, string> LoadSettings(string path)
{
    // Read and deserialize the settings file, or return an empty set if it doesn't exist yet.
    if (!File.Exists(path))
    {
        return new Dictionary<string, string>();
    }

    var json = File.ReadAllText(path);
    return System.Text.Json.JsonSerializer.Deserialize<Dictionary<string, string>>(json)
        ?? new Dictionary<string, string>();
}

Använda ApplicationData för paketerade appar

Om din app paketeras med MSIX kan du använda Windows.Storage.ApplicationData.Current.LocalSettings för att lagra små inställningar och LocalFolder för större data. Dessa platser hanteras av systemet och rensas när appen avinstalleras.

// For packaged apps with package identity:
string filePath = "C:\\Users\\Example\\Documents\\report.docx";
var localSettings = Windows.Storage.ApplicationData.Current.LocalSettings;
localSettings.Values["LastOpenedFile"] = filePath;

Återställ tillstånd vid start

När appen startar, kontrollera om det finns ett tidigare sparat tillstånd och återställ det. Detta ger användaren en sömlös upplevelse – de fortsätter där de slutade.

private void MainWindow_Loaded(object sender, RoutedEventArgs e)
{
    // Restore the last opened file, if any.
    var localSettings = Windows.Storage.ApplicationData.Current.LocalSettings;
    if (localSettings.Values.TryGetValue("LastOpenedFile", out var path))
    {
        OpenFile(path.ToString());
    }
}

private void OpenFile(string path)
{
    // Load the document at the given path and update the UI.
}

Hantera händelsen AppWindow.Closing

Använd händelsen Closing på Microsoft.UI.Windowing.AppWindow för att spara kritiskt tillstånd innan appen avslutas. Det här är din sista möjlighet att bevara tillståndet när användaren stänger fönstret.

// In your Window constructor or initialization code:
var appWindow = this.AppWindow;
appWindow.Closing += AppWindow_Closing;

void AppWindow_Closing(AppWindow sender, AppWindowClosingEventArgs args)
{
    // See the following examples for what to do here.
}

private void AppWindow_Closing(AppWindow sender, AppWindowClosingEventArgs args)
{
    SaveCurrentDocument();
    SaveWindowPosition();
}

private void SaveCurrentDocument()
{
    // Persist the current document to disk.
}

private void SaveWindowPosition()
{
    // Persist the window's current size and position.
}

Om du vill uppmana användaren innan du stänger ställer du in args.Cancel = true för att förhindra att fönstret stängs och stänger det programmatiskt när användaren har bekräftat det. Använd en skyddsflagga för att förhindra återaktivering, eftersom anropet this.Close() utlöser händelsen igen Closing :

private bool _isClosing = false;
private bool HasUnsavedChanges { get; set; }

private async void AppWindow_Closing(AppWindow sender, AppWindowClosingEventArgs args)
{
    if (_isClosing) return;

    if (HasUnsavedChanges)
    {
        args.Cancel = true; // Prevent the window from closing.

        // ShowSaveDialog returns true if the user chose to save.
        var shouldSave = await ShowSaveDialog();
        if (shouldSave)
        {
            await SaveCurrentDocumentAsync();
        }

        // Set the guard flag before closing to prevent re-entrancy.
        _isClosing = true;
        this.Close();
    }
}

private Task<bool> ShowSaveDialog()
{
    // Prompt the user to save, discard, or cancel.
    return Task.FromResult(true);
}

private Task SaveCurrentDocumentAsync()
{
    // Persist the current document to disk asynchronously.
    return Task.CompletedTask;
}

Metodtips

Relaterat innehåll

• Håll användargränssnittstråden responsiv
• Optimera bakgrundsaktivitet
• Planera och mäta prestanda