Přidání dat a trvalosti

V tomto kroku požádejte asistenta o nevisuální části aplikace. Tato změna je oddělená od XAML, což usnadňuje izolaci chyb kompilátoru a problémů s návrhem.

Žádost o model a službu úložiště

Použijte tuto výzvu:

Add the data layer for TaskTally.

- Create a TaskItem model with an ID, title, and completion state.
- Use MVVM Toolkit observable properties.
- Create a TaskStorage service that serializes the task list to JSON.
- Store tasks in ApplicationData.Current.LocalFolder because this is
  a packaged WinUI 3 app.
- Return an empty list when the file doesn't exist.
- Serialize save operations so rapid changes don't write the file concurrently.
- Surface real read and write errors to the caller.
- Build the project after the change.

Porovnejte vygenerovaný model s touto implementací:

using CommunityToolkit.Mvvm.ComponentModel;

namespace TaskTally.Models;

public partial class TaskItem : ObservableObject
{
    public Guid Id { get; init; } = Guid.NewGuid();

    [ObservableProperty]
    public partial string Title { get; set; } = string.Empty;

    [ObservableProperty]
    public partial bool IsComplete { get; set; }
}

Atribut [ObservableProperty] generuje veřejné vlastnosti a mění oznámení. Třída musí být partial , aby zdrojový generátor MVVM Toolkit mohl tento kód přidat.

Služba úložiště by měla vypadat takto:

using System.Text.Json;
using System.Threading;
using TaskTally.Models;
using Windows.Storage;

namespace TaskTally.Services;

internal static class TaskStorage
{
    private const string FileName = "tasks.json";
    private static readonly SemaphoreSlim SaveLock = new(1, 1);

    public static async Task<IReadOnlyList<TaskItem>> LoadAsync()
    {
        StorageFile? file =
            await ApplicationData.Current.LocalFolder.TryGetItemAsync(FileName) as StorageFile;

        if (file is null)
        {
            return [];
        }

        string json = await FileIO.ReadTextAsync(file);
        return JsonSerializer.Deserialize<List<TaskItem>>(json) ?? [];
    }

    public static async Task SaveAsync(IEnumerable<TaskItem> tasks)
    {
        await SaveLock.WaitAsync();
        try
        {
            string json = JsonSerializer.Serialize(tasks, new JsonSerializerOptions
            {
                WriteIndented = true
            });

            StorageFile file = await ApplicationData.Current.LocalFolder.CreateFileAsync(
                FileName,
                CreationCollisionOption.ReplaceExisting);

            await FileIO.WriteTextAsync(file, json);
        }
        finally
        {
            SaveLock.Release();
        }
    }
}

ApplicationData.Current.LocalFolder je zde vhodné, protože aplikace má identitu balíčku. SaveLock zabraňuje tomu, aby operace přidání, odstranění a dokončení souběžně zapisovaly do stejného souboru. Pokud později změníte distribuční model, ověřte znovu předpoklad identity balíčku místo automatického kopírování této volby úložiště.

Další informace: Ukládání a načítání nastavení a dalších dat aplikací a ApplicationData.LocalFolder.

Požádat o model zobrazení

Dále použijte tuto výzvu:

Add MainPageViewModel.

- Expose an ObservableCollection<TaskItem>.
- Add observable properties for the new-task text and status message.
- Add asynchronous commands to add and delete tasks.
- Disable AddTaskCommand when the title is blank.
- Load tasks once when the page starts.
- Save after add, delete, or completion changes.
- Expose a summary and empty-state property for x:Bind.
- Catch storage exceptions only where the UI can report them.
- Build and fix all warnings.

Hlavní vzory pro kontrolu v odpovědi jsou:

public ObservableCollection<TaskItem> Tasks { get; } = [];

[ObservableProperty]
public partial string NewTaskTitle { get; set; } = string.Empty;

public string Summary =>
    Tasks.Count == 0
        ? "No tasks yet"
        : $"{Tasks.Count(task => !task.IsComplete)} of {Tasks.Count} remaining";

[RelayCommand(CanExecute = nameof(CanAddTask))]
private async Task AddTaskAsync()
{
    string title = NewTaskTitle.Trim();
    Tasks.Add(new TaskItem { Title = title });
    NewTaskTitle = string.Empty;
    RefreshTaskState();
    await SaveAsync($"Added \"{title}\".");
}

[RelayCommand]
private async Task DeleteTaskAsync(TaskItem task)
{
    Tasks.Remove(task);
    RefreshTaskState();
    await SaveAsync($"Deleted \"{task.Title}\".");
}

private bool CanAddTask() => !string.IsNullOrWhiteSpace(NewTaskTitle);

partial void OnNewTaskTitleChanged(string value)
{
    AddTaskCommand.NotifyCanExecuteChanged();
}

Zkontrolujte, jestli pomocník neblokuje asynchronní práci s .Wait() nebo .Result. Na operace úložiště by se mělo čekat.

Model zobrazení může zachytit výjimky úložiště, když je převede na zprávu pro stránku:

private async Task SaveAsync(string successMessage)
{
    try
    {
        await TaskStorage.SaveAsync(Tasks);
        ShowStatus(successMessage);
    }
    catch (Exception ex)
    {
        ShowStatus($"Changes couldn't be saved: {ex.Message}", hasError: true);
    }
}

Nejedná se o bezobslužnou záložní aplikaci: uživatel obdrží chybu a model zobrazení nehlásí, že uložení proběhlo úspěšně.

Příkazy a SaveAsync volají dvě malé pomocné funkce. RefreshTaskState vyvolá oznámení o změně vypočítané Summary vlastnosti, aby se uživatelské rozhraní po změně seznamu úkolů aktualizovalo a ShowStatus nastaví pozorovatelné vlastnosti stavu, na které stránka vytvoří vazbu:

[ObservableProperty]
public partial string StatusMessage { get; set; } = string.Empty;

[ObservableProperty]
public partial bool IsStatusOpen { get; set; }

[ObservableProperty]
public partial bool HasError { get; set; }

private void RefreshTaskState()
{
    OnPropertyChanged(nameof(Summary));
    OnPropertyChanged(nameof(HasNoTasks));
}

private void ShowStatus(string message, bool hasError = false)
{
    StatusMessage = message;
    HasError = hasError;
    IsStatusOpen = true;
}

Protože Summary je vypočítávaná vlastnost, a ne [ObservableProperty], ručně vyvoláte oznámení o její změně pokaždé, když se změní Tasks.

Sestavení a kontrola

Sestavení pro x64 Považujte varování za pracovní úkoly, zejména varování týkající se vazeb a nullable referencí:

dotnet build -p:Platform=x64

Požádejte asistenta, aby vysvětlil každý přidaný balíček. Pro tuto aplikaci by neměl být potřeba žádný nový balíček nad rámec odkazů Windows App SDK a MVVM Toolkit v šabloně.

Sestavení přístupného a adaptivního rozhraní