Administrar el estado de la aplicación de forma eficaz

En una aplicación de SDK de Aplicaciones para Windows de escritorio, el proceso continúa ejecutándose hasta que el usuario lo cierra explícitamente. Las aplicaciones de escritorio no pasan por el ciclo de vida de suspensión, reanudación y finalización automáticas que usan las aplicaciones para UWP. Esto le proporciona más control, pero también más responsabilidad para administrar el estado.

Prerequisites

• Un proyecto de escritorio de SDK de Aplicaciones para Windows. Para conocer los pasos de configuración, consulte Creación de la primera aplicación winUI 3.
• Familiaridad con la Microsoft.UI.Windowing.AppWindow clase y, para aplicaciones empaquetadas, Windows.Storage.ApplicationData.

¿Por qué es importante la administración de estados?

Aunque el sistema operativo no suspenda las aplicaciones de escritorio, todavía hay situaciones en las que la aplicación puede perder el estado no guardado:

• El usuario cierra la aplicación mientras el trabajo está en curso
• El sistema se reinicia para una actualización.
• La pérdida de energía o un bloqueo finaliza el proceso
• El usuario cierra sesión de Windows

Diseñe la aplicación para controlar estos casos correctamente guardando el estado importante con frecuencia y restablezándolo cuando se inicia la aplicación.

Guardar el estado incrementalmente

En lugar de guardar todo el estado en el apagado, guarde el estado incrementalmente a medida que el usuario funcione. Esto reduce el riesgo de pérdida de datos y distribuye el costo de E/S en toda la duración de la aplicación.

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>();
}

Uso de ApplicationData para aplicaciones empaquetadas

Si la aplicación se empaqueta con MSIX, puedes usar Windows.Storage.ApplicationData.Current.LocalSettings para almacenar configuraciones pequeñas y LocalFolder para datos más grandes. El sistema administra estas ubicaciones y se limpia cuando se desinstala la aplicación.

// 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;

Restaurar el estado al iniciar

Cuando se inicie la aplicación, compruebe el estado guardado anteriormente y restáurelo. Esto proporciona al usuario una experiencia fluida: puede retomar donde lo dejó.

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.
}

Control del evento AppWindow.Closing

Use el Closing evento en Microsoft.UI.Windowing.AppWindow para guardar el estado crítico antes de que finalice la aplicación. Esta es la última oportunidad de conservar el estado cuando el usuario cierra la ventana.

// 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.
}

Para pedir confirmación al usuario antes de cerrar la ventana, establezca args.Cancel = true para evitar que la ventana se cierre y, a continuación, ciérrela mediante programación después de que el usuario lo confirme. Utilice un indicador de guarda para evitar la reentrada, ya que llamar a this.Close() vuelve a activar el evento 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;
}

Prácticas recomendadas

Contenido relacionado

• Mantener la capacidad de respuesta del subproceso de la interfaz de usuario
• optimizar la actividad en segundo plano
• Planeamiento y medición del rendimiento