Herunterladen und Installieren von Paketupdates aus dem StoreDownload and install package updates from the Store

Ab Windows 10 (Version 1607) kannst du Methoden der StoreContext-Klasse im Namespace Windows.Services.Store verwenden, um programmgesteuert nach Paketupdates für die aktuelle App im Microsoft Store zu suchen und diese herunterzuladen und zu installieren.Starting in Windows 10, version 1607, you can use methods of the StoreContext class in the Windows.Services.Store namespace to programmatically check for package updates for the current app from the Microsoft Store, and download and install the updated packages. Deine App kann auch Abfragen für Pakete ausführen, die in Partner Center als obligatorisch gekennzeichnet wurden, und Funktionen deaktivieren, bis das erforderliche Update installiert wurde.You can also query for packages that you have marked as mandatory in Partner Center and disable functionality in your app until the mandatory update is installed.

Mithilfe von zusätzlichen StoreContext-Methoden, die in Version 1803 von Windows 10 eingeführt wurden, kannst du Paketupdates im Hintergrund herunterladen und installieren (ohne dem Benutzer eine Benachrichtigung anzuzeigen), ein optionales Paket deinstallieren und Informationen zu Paketen im Download und zur Installationswarteschlange für deine App erhalten.Additional StoreContext methods introduced in Windows 10, version 1803 enable you to download and install package updates silently (without displaying a notification UI to the user), uninstall an optional package, and get info about packages in the download and install queue for your app.

Mithilfe dieser Features kannst du deine Benutzerbasis automatisch mit der neuesten Version deiner App, optionalen Paketen und verwandten Diensten im Store auf dem aktuellen Stand halten.These features help you automatically keep your user base up to date with the latest version of your app, optional packages, and related services in the Store.

Herunterladen und Installieren von Paketupdates mit Zustimmung des BenutzersDownload and install package updates with the user's permission

In diesem Codebeispiel wird veranschaulicht, wie du über die GetAppAndOptionalStorePackageUpdatesAsync-Methode alle verfügbaren Updates im Store ermittelst und dann die RequestDownloadAndInstallStorePackageUpdatesAsync-Methode aufrufst, um die Updates herunterzuladen und zu installieren.This code example demonstrates how to use the GetAppAndOptionalStorePackageUpdatesAsync method to discover all available package updates from the Store and then call the RequestDownloadAndInstallStorePackageUpdatesAsync method to download and install the updates. Bei Verwendung dieser Methode zum Herunterladen und Installieren von Updates zeigt das Betriebssystem ein Dialogfeld an, in dem die Berechtigung des Benutzers vor dem Herunterladen der Updates angefragt wird.When using this method to download and install updates, the OS displays a dialog that asks the user's permission before downloading the updates.

Hinweis

Diese Methoden unterstützen erforderliche und optionale Pakete für deine App.These methods support required and optional packages for your app. Optionale Pakete sind nützlich für DLC-Add-Ons (Downloadable Content, herunterladbare Inhalte), da große Apps so im Hinblick auf Größenbeschränkungen geteilt werden, oder auch, um zusätzliche Inhalte getrennt von der Haupt-App zu liefern.Optional packages are useful for downloadable content (DLC) add-ons, dividing your large app for size constraints, or for shipping additional content separate from your core app. Informationen zum Erhalt einer Berechtigung, eine App, die optionale Pakete (einschließlich DLC-Add-Ons) verwendet, an den Store zu übermitteln, findest du unter Windows-Support für Entwickler.To get permission to submit an app that uses optional packages (including DLC add-ons) to the Store, see Windows developer support.

In diesem Codebeispiel wird von Folgendem ausgegangen:This code example assumes:

  • Der Code wird im Kontext einer Seite ausgeführt.The code runs in the context of a Page.
  • Die Seite enthält eine ProgressBar mit dem Namen downloadProgressBar, um einen Status für den Downloadvorgang bereitzustellen.The Page contains a ProgressBar named downloadProgressBar to provide status for the download operation.
  • Die Codedatei enthält eine using-Anweisung für die Namespaces Windows.Services.Store, Windows.Threading.Tasks und Windows.UI.Popups.The code file has a using statement for the Windows.Services.Store, Windows.Threading.Tasks, and Windows.UI.Popups namespaces.
  • Die App ist eine Einzelbenutzer-App, die nur im Kontext des Benutzers ausgeführt wird, der die App gestartet hat.The app is a single-user app that runs only in the context of the user that launched the app. Verwenden Sie für eine Multi-User-App die GetForUser-Methode, um ein StoreContext-Objekt anstelle der GetDefault-Methode abzurufen.For a multi-user app, use the GetForUser method to get a StoreContext object instead of the GetDefault method.
private StoreContext context = null;

public async Task DownloadAndInstallAllUpdatesAsync()
{
    if (context == null)
    {
        context = StoreContext.GetDefault();
    }

    // Get the updates that are available.
    IReadOnlyList<StorePackageUpdate> updates =
        await context.GetAppAndOptionalStorePackageUpdatesAsync();

    if (updates.Count > 0)
    {
        // Alert the user that updates are available and ask for their consent
        // to start the updates.
        MessageDialog dialog = new MessageDialog(
            "Download and install updates now? This may cause the application to exit.", "Download and Install?");
        dialog.Commands.Add(new UICommand("Yes"));
        dialog.Commands.Add(new UICommand("No"));
        IUICommand command = await dialog.ShowAsync();

        if (command.Label.Equals("Yes", StringComparison.CurrentCultureIgnoreCase))
        {
            // Download and install the updates.
            IAsyncOperationWithProgress<StorePackageUpdateResult, StorePackageUpdateStatus> downloadOperation =
                context.RequestDownloadAndInstallStorePackageUpdatesAsync(updates);

            // The Progress async method is called one time for each step in the download
            // and installation process for each package in this request.
            downloadOperation.Progress = async (asyncInfo, progress) =>
            {
                await this.Dispatcher.RunAsync(Windows.UI.Core.CoreDispatcherPriority.Normal,
                () =>
                {
                    downloadProgressBar.Value = progress.PackageDownloadProgress;
                });
            };

            StorePackageUpdateResult result = await downloadOperation.AsTask();
        }
    }
}

Hinweis

Verwende die RequestDownloadStorePackageUpdatesAsync-Methode, um die verfügbaren Paketupdates nur herunterzuladen (jedoch nicht zu installieren).To only download (but not install) the available package updates, use the RequestDownloadStorePackageUpdatesAsync method.

Anzeigen von Statusinformationen für das Herunterladen und InstallierenDisplay download and install progress info

Wenn du die RequestDownloadStorePackageUpdatesAsync-Methode oder die RequestDownloadAndInstallStorePackageUpdatesAsync-Methode aufrufst, kannst du einen Progress-Handler zuweisen, der für jeden Schritt im Downloadvorgang (oder beim Download und der Installation) und jedes Paket in dieser Anforderung einmal aufgerufen wird.When you call the RequestDownloadStorePackageUpdatesAsync or RequestDownloadAndInstallStorePackageUpdatesAsync method, you can assign a Progress handler that is called one time for each step in the download (or download and install) process for each package in this request. Der Handler empfängt ein StorePackageUpdateStatus-Objekt, das Informationen zu dem Updatepaket enthält, das die Statusbenachrichtigung ausgelöst hat.The handler receives a StorePackageUpdateStatus object that provides info about the update package that raised the progress notification. Im vorherigen Beispiel wird das Feld PackageDownloadProgress des StorePackageUpdateStatus-Objekts verwendet, um den Fortschritt des Download- und Installationsvorgangs anzuzeigen.The previous example uses the PackageDownloadProgress field of the StorePackageUpdateStatus object to display the progress of the download and install process.

Beachte, dass beim Aufrufen von RequestDownloadAndInstallStorePackageUpdatesAsync zum Herunterladen und Installieren der Paketupdates in einem einzigen Vorgang der Wert des Felds PackageDownloadProgress während des Downloadvorgangs für ein Paket von 0,0 auf 0,8 und dann während der Installation von 0,8 auf 1,0 erhöht wird.Be aware that when you call RequestDownloadAndInstallStorePackageUpdatesAsync to download and install package updates in a single operation, the PackageDownloadProgress field increases from 0.0 to 0.8 during the download process for a package, and then it increases from 0.8 to 1.0 during the install. Wenn du den auf deiner benutzerdefinierten Statusanzeige angezeigten Prozentsatz direkt dem Wert des Felds PackageDownloadProgress zuordnest, wird daher 80 % angezeigt, wenn das Paket fertig herunterladen ist, und das Betriebssystem zeigt das Installationsdialogfeld an.Therefore, if you map the percentage shown in your custom progress UI directly to the value of the PackageDownloadProgress field, your UI will show 80% when the package is finished downloading and the OS displays the installation dialog. Wenn deine benutzerdefinierte Statusanzeige den Wert „100 %“ aufweisen soll, wenn das Paket heruntergeladen und bereit zum Installieren ist, kannst du den Code so ändern, dass der Statusanzeige 100 % zugewiesen werden, wenn das Feld PackageDownloadProgress den Wert 0,8 erreicht.If you want your custom progress UI to display 100% when the package is downloaded and ready to be installed, you can modify your code to assign 100% to your progress UI when the PackageDownloadProgress field reaches 0.8.

Herunterladen und Installieren aller Paketupdates im HintergrundDownload and install package updates silently

Ab Windows 10 Version 1803 kannst du die Methoden TrySilentDownloadStorePackageUpdatesAsync und TrySilentDownloadAndInstallStorePackageUpdatesAsync verwenden, um Paketupdates im Hintergrund herunterzuladen und zu installieren, ohne dem Benutzer eine Benachrichtigung anzuzeigen.Starting in Windows 10, version 1803, you can use the TrySilentDownloadStorePackageUpdatesAsync and TrySilentDownloadAndInstallStorePackageUpdatesAsync methods to download and install package updates silently, without displaying a notification UI to the user. Dieser Vorgang wird nur dann erfolgreich ausgeführt, wenn der Benutzer die Einstellung Apps automatisch aktualisieren im Store aktiviert hat und er sich nicht in einem getakteten Netzwerk befindet.This operation will succeed only if the user has enabled the Update apps automatically setting in the Store and the user is not on a metered network. Bevor du diese Methoden aufrufst, kannst du zunächst die CanSilentlyDownloadStorePackageUpdates-Eigenschaft überprüfen, um festzustellen, ob diese Bedingungen zurzeit erfüllt sind.Before calling these methods, you can first check the CanSilentlyDownloadStorePackageUpdates property to determine whether these conditions are currently met.

In diesem Codebeispiel wird veranschaulicht, wie du die GetAppAndOptionalStorePackageUpdatesAsync-Methode verwendest, um alle verfügbaren Paketupdates zu ermitteln, und dann die Methoden TrySilentDownloadStorePackageUpdatesAsync und TrySilentDownloadAndInstallStorePackageUpdatesAsync zum Herunterladen und Installieren im Hintergrund aufrufst.This code example demonstrates how to use the GetAppAndOptionalStorePackageUpdatesAsync method to discover all available package updates and then call the TrySilentDownloadStorePackageUpdatesAsync and TrySilentDownloadAndInstallStorePackageUpdatesAsync methods to download and install the updates silently.

In diesem Codebeispiel wird von Folgendem ausgegangen:This code example assumes:

  • Die Codedatei enthält eine using-Anweisung für die Namespaces Windows.Services.Store und System.Threading.Tasks.The code file has a using statement for the Windows.Services.Store and System.Threading.Tasks namespaces.
  • Die App ist eine Einzelbenutzer-App, die nur im Kontext des Benutzers ausgeführt wird, der die App gestartet hat.The app is a single-user app that runs only in the context of the user that launched the app. Verwenden Sie für eine Multi-User-App die GetForUser-Methode, um ein StoreContext-Objekt anstelle der GetDefault-Methode abzurufen.For a multi-user app, use the GetForUser method to get a StoreContext object instead of the GetDefault method.

Hinweis

Die in diesem Code aufgerufenen Methoden IsNowAGoodTimeToRestartApp, RetryDownloadAndInstallLater und RetryInstallLater sind Platzhaltermethoden, die gemäß den Anforderungen deines eigenen App-Designs implementiert werden können.The IsNowAGoodTimeToRestartApp, RetryDownloadAndInstallLater, and RetryInstallLater methods called by the code in this example are placeholder methods that are intended to be implemented as needed according to your own app's design.

private StoreContext context = null;

public async Task DownloadAndInstallAllUpdatesInBackgroundAsync()
{
    if (context == null)
    {
        context = StoreContext.GetDefault();
    }

    // Get the updates that are available.
    IReadOnlyList<StorePackageUpdate> storePackageUpdates =
        await context.GetAppAndOptionalStorePackageUpdatesAsync();

    if (storePackageUpdates.Count > 0)
    {

        if (!context.CanSilentlyDownloadStorePackageUpdates)
        {
            return;
        }

        // Start the silent downloads and wait for the downloads to complete.
        StorePackageUpdateResult downloadResult =
            await context.TrySilentDownloadStorePackageUpdatesAsync(storePackageUpdates);

        switch (downloadResult.OverallState)
        {
            case StorePackageUpdateState.Completed:
                // The download has completed successfully. At this point, confirm whether your app
                // can restart now and then install the updates (for example, you might only install
                // packages silently if your app has been idle for a certain period of time). The
                // IsNowAGoodTimeToRestartApp method is not implemented in this example, you should
                // implement it as needed for your own app.
                if (IsNowAGoodTimeToRestartApp())
                {
                    await InstallUpdate(storePackageUpdates);
                }
                else
                {
                    // Retry/reschedule the installation later. The RetryInstallLater method is not  
                    // implemented in this example, you should implement it as needed for your own app.
                    RetryInstallLater();
                    return;
                }
                break;
            // If the user cancelled the download or you can't perform the download for some other
            // reason (for example, Wi-Fi might have been turned off and the device is now on
            // a metered network) try again later. The RetryDownloadAndInstallLater method is not  
            // implemented in this example, you should implement it as needed for your own app.
            case StorePackageUpdateState.Canceled:
            case StorePackageUpdateState.ErrorLowBattery:
            case StorePackageUpdateState.ErrorWiFiRecommended:
            case StorePackageUpdateState.ErrorWiFiRequired:
            case StorePackageUpdateState.OtherError:
                RetryDownloadAndInstallLater();
                return;
            default:
                break;
        }
    }
}

private async Task InstallUpdate(IReadOnlyList<StorePackageUpdate> storePackageUpdates)
{
    // Start the silent installation of the packages. Because the packages have already
    // been downloaded in the previous method, the following line of code just installs
    // the downloaded packages.
    StorePackageUpdateResult downloadResult =
        await context.TrySilentDownloadAndInstallStorePackageUpdatesAsync(storePackageUpdates);

    switch (downloadResult.OverallState)
    {
        // If the user cancelled the installation or you can't perform the installation  
        // for some other reason, try again later. The RetryInstallLater method is not  
        // implemented in this example, you should implement it as needed for your own app.
        case StorePackageUpdateState.Canceled:
        case StorePackageUpdateState.ErrorLowBattery:
        case StorePackageUpdateState.OtherError:
            RetryInstallLater();
            return;
        default:
            break;
    }
}

Obligatorische PaketupdatesMandatory package updates

Wenn du eine Paketübermittlung in Partner Center für eine App für Windows 10 ab Version 1607 erstellst, kannst du das Paket als obligatorisch kennzeichnen und das Datum sowie die Uhrzeit angeben, wann es obligatorisch wird.When you create a package submission in Partner Center for an app that targets Windows 10, version 1607 or later, you can mark the package as mandatory and the date and time on which it becomes mandatory. Wenn diese Eigenschaft festgelegt wurde und deine App erkennt, dass das Paketupdate verfügbar ist, kann die App ermitteln, ob das Updatepaket obligatorisch ist, und ihr Verhalten ändern, bis das Update installiert ist. (Beispielsweise kann die App Features deaktivieren.)When this property is set and your app discovers that the package update is available, your app can determine whether the update package is mandatory and alter its behavior until the update is installed (for example, your app can disable features).

Hinweis

Der „Obligatorisch“-Status eines Pakets wird von Microsoft nicht erzwungen, und das Betriebssystem verfügt nicht über eine Benutzeroberfläche, die den Benutzer darauf hinweist, dass ein erforderliches App-Update installiert werden muss.The mandatory status of a package update is not enforced by Microsoft, and the OS does not provide a UI to indicate to users that a mandatory app update must be installed. Entwickler sollten die Einstellung „Obligatorisch” verwenden, um erforderliche App-Updates in ihrem eigenen Code zu erzwingen.Developers are intended to use the mandatory setting to enforce mandatory app updates in their own code.

So kennzeichnen Sie eine Paketübermittlung als obligatorisch:To mark a package submission as mandatory:

  1. Melde dich bei Partner Center an, und navigiere zur Übersichtsseite für deine App.Sign in to Partner Center and navigate to the overview page for your app.
  2. Klicken Sie auf den Namen der Übermittlung, die das Paketupdate enthält, das Sie erforderlich machen möchten.Click the name of the submission that contains the package update you want to make mandatory.
  3. Navigieren Sie zu der Pakete-Seite für die Übermittlung.Navigate to the Packages page for the submission. Wählen Sie im unteren Bereich der Seite Dieses Update als obligatorisch kennzeichnen aus, und wählen Sie dann den Tag und die Uhrzeit aus, wann das Paketupdate obligatorisch wird.Near the bottom of this page, select Make this update mandatory and then choose the day and time on which the package update becomes mandatory. Diese Option gilt für alle UWP-Pakete in der Übermittlung.This option applies to all UWP packages in the submission.

Weitere Informationen findest du unter Hochladen von App-Paketen.For more information, see Upload app packages.

Hinweis

Wenn du ein Flight-Paket erstellst, kannst du die Pakete über eine ähnliche Benutzeroberfläche auf der Seite Pakete für das Flight-Paket als obligatorisch kennzeichnen.If you create a package flight, you can mark the packages as mandatory using a similar UI on the Packages page for the flight. In diesem Fall gilt das obligatorische Paketupdate nur für die Kunden, die Teil der Flight-Gruppe sind.In this case, the mandatory package update applies only to the customers who are part of the flight group.

Codebeispiel für obligatorische PaketeCode example for mandatory packages

Im folgenden Codebeispiel wird veranschaulicht, wie du feststellst, ob Updatepakete obligatorisch sind.The following code example demonstrates how to determine whether any update packages are mandatory. In der Regel sollten Sie Ihre App-Funktionen kontrolliert für den Benutzer herabstufen, wenn ein obligatorisches Paketupdate nicht erfolgreich heruntergeladen oder installiert werden kann.Typically, you should downgrade your app experience gracefully for the user if a mandatory package update does not successfully download or install.

private StoreContext context = null;

// Downloads and installs package updates in separate steps.
public async Task DownloadAndInstallAllUpdatesAsync()
{
    if (context == null)
    {
        context = StoreContext.GetDefault();
    }  

    // Get the updates that are available.
    IReadOnlyList<StorePackageUpdate> updates =
        await context.GetAppAndOptionalStorePackageUpdatesAsync();

    if (updates.Count != 0)
    {
        // Download the packages.
        bool downloaded = await DownloadPackageUpdatesAsync(updates);

        if (downloaded)
        {
            // Install the packages.
            await InstallPackageUpdatesAsync(updates);
        }
    }
}

// Helper method for downloading package updates.
private async Task<bool> DownloadPackageUpdatesAsync(IEnumerable<StorePackageUpdate> updates)
{
    bool downloadedSuccessfully = false;

    IAsyncOperationWithProgress<StorePackageUpdateResult, StorePackageUpdateStatus> downloadOperation =
        this.context.RequestDownloadStorePackageUpdatesAsync(updates);

    // The Progress async method is called one time for each step in the download process for each
    // package in this request.
    downloadOperation.Progress = async (asyncInfo, progress) =>
    {
        await this.Dispatcher.RunAsync(Windows.UI.Core.CoreDispatcherPriority.Normal,
        () =>
        {
            downloadProgressBar.Value = progress.PackageDownloadProgress;
        });
    };

    StorePackageUpdateResult result = await downloadOperation.AsTask();

    switch (result.OverallState)
    {
        case StorePackageUpdateState.Completed:
            downloadedSuccessfully = true;
            break;
        default:
            // Get the failed updates.
            var failedUpdates = result.StorePackageUpdateStatuses.Where(
                status => status.PackageUpdateState != StorePackageUpdateState.Completed);

            // See if any failed updates were mandatory
            if (updates.Any(u => u.Mandatory && failedUpdates.Any(
                failed => failed.PackageFamilyName == u.Package.Id.FamilyName)))
            {
                // At least one of the updates is mandatory. Perform whatever actions you
                // want to take for your app: for example, notify the user and disable
                // features in your app.
                HandleMandatoryPackageError();
            }
            break;
    }

    return downloadedSuccessfully;
}

// Helper method for installing package updates.
private async Task InstallPackageUpdatesAsync(IEnumerable<StorePackageUpdate> updates)
{
    IAsyncOperationWithProgress<StorePackageUpdateResult, StorePackageUpdateStatus> installOperation =
        this.context.RequestDownloadAndInstallStorePackageUpdatesAsync(updates);

    // The package updates were already downloaded separately, so this method skips the download
    // operatation and only installs the updates; no download progress notifications are provided.
    StorePackageUpdateResult result = await installOperation.AsTask();

    switch (result.OverallState)
    {
        case StorePackageUpdateState.Completed:
            break;
        default:
            // Get the failed updates.
            var failedUpdates = result.StorePackageUpdateStatuses.Where(
                status => status.PackageUpdateState != StorePackageUpdateState.Completed);

            // See if any failed updates were mandatory
            if (updates.Any(u => u.Mandatory && failedUpdates.Any(failed => failed.PackageFamilyName == u.Package.Id.FamilyName)))
            {
                // At least one of the updates is mandatory, so tell the user.
                HandleMandatoryPackageError();
            }
            break;
    }
}

// Helper method for handling the scenario where a mandatory package update fails to
// download or install. Add code to this method to perform whatever actions you want
// to take, such as notifying the user and disabling features in your app.
private void HandleMandatoryPackageError()
{
}

Deinstallieren optionaler PaketeUninstall optional packages

Ab Windows 10 Version 1803 kannst du die Methoden RequestUninstallStorePackageAsync oder RequestUninstallStorePackageByStoreIdAsync verwenden, um ein Optionales Paket (einschließlich eines DLC-Pakets) für die aktuelle App zu deinstallieren.Starting in Windows 10, version 1803, you can use the RequestUninstallStorePackageAsync or RequestUninstallStorePackageByStoreIdAsync methods to uninstall an optional package (including a DLC package) for the current app. Wenn du beispielsweise über eine App mit Inhalten verfügst, die über optionale Pakete installiert wurden, solltest du eine Benutzeroberfläche bereitstellen, über die Benutzer optionalen Pakete deinstallieren können, um Speicherplatz freizugeben.For example, if you have an app with content that is installed via optional packages, you might want to provide a UI that enables users to uninstall the optional packages to free up disk space.

Das folgende Codebeispiel veranschaulicht, wie du die RequestUninstallStorePackageAsync-Methode aufrufst.The following code example demonstrates how to call RequestUninstallStorePackageAsync. In diesem Beispiel wird von Folgendem ausgegangen:This example assumes:

  • Die Codedatei enthält eine using-Anweisung für die Namespaces Windows.Services.Store und System.Threading.Tasks.The code file has a using statement for the Windows.Services.Store and System.Threading.Tasks namespaces.
  • Die App ist eine Einzelbenutzer-App, die nur im Kontext des Benutzers ausgeführt wird, der die App gestartet hat.The app is a single-user app that runs only in the context of the user that launched the app. Verwenden Sie für eine Multi-User-App die GetForUser-Methode, um ein StoreContext-Objekt anstelle der GetDefault-Methode abzurufen.For a multi-user app, use the GetForUser method to get a StoreContext object instead of the GetDefault method.
public async Task UninstallPackage(Windows.ApplicationModel.Package package)
{
    if (context == null)
    {
        context = StoreContext.GetDefault();
    }

    var storeContext = StoreContext.GetDefault();
    IAsyncOperation<StoreUninstallStorePackageResult> uninstallOperation =
        storeContext.RequestUninstallStorePackageAsync(package);

    // At this point, you can update your app UI to show that the package
    // is installing.

    uninstallOperation.Completed += (asyncInfo, status) =>
    {
        StoreUninstallStorePackageResult result = uninstallOperation.GetResults();
        switch (result.Status)
        {
            case StoreUninstallStorePackageStatus.Succeeded:
                {
                    // Update your app UI to show the package as uninstalled.
                    break;
                }
            default:
                {
                    // Update your app UI to show that the package uninstall failed.
                    break;
                }
        }
    };
}

Abrufen von Informationen aus DownloadwarteschlangenGet download queue info

Ab Windows 10 Version 1803 kannst du die Methoden GetAssociatedStoreQueueItemsAsync und GetStoreQueueItemsAsync zum Abrufen von Informationen zu den Paketen verwenden, die sich in der aktuellen Download- und Installationswarteschlange des Store befinden.Starting in Windows 10, version 1803, you can use the GetAssociatedStoreQueueItemsAsync and GetStoreQueueItemsAsync methods to get info about the packages that are in the current download and installation queue from the Store. Diese Methoden sind hilfreich, wenn die App oder das Spiel große optionale Pakete (einschließlich DLCs) unterstützt, deren Download und Installation Stunden oder Tage dauern kann, und du reibungslos reagieren möchtest, wenn ein Kunde deine App oder dein Spiel vor dem Abschluss des Downloads und der Installation schließt.These methods are useful if your app or game supports large optional packages (including DLCs) that can take hours or days to download and install, and you want to gracefully handle the case where a customer closes your app or game before the download and installation process is complete. Wenn der Kunde die App oder das Spiel erneut startet, kann dein Code diese Methoden zum Abrufen von Informationen zum Zustand der Pakete verwenden, die noch in der Download- und Installationswarteschlange sind, damit du dem Kunden den Status der einzelnen Pakete anzeigen kannst.When the customer starts your app or game again, your code can use these methods to get info about the state of the packages that are still in the download and installation queue so you can display the status of each package to the customer.

Im folgenden Codebeispiel wird veranschaulicht, wie GetAssociatedStoreQueueItemsAsync zum Abrufen der Liste der aktiven Paketupdates für die aktuelle App sowie der Statusinformationen für die einzelnen Pakete aufgerufen wird.The following code example demonstrates how to call GetAssociatedStoreQueueItemsAsync to get the list of in-progress package updates for the current app and retrieve status info for each package. In diesem Beispiel wird von Folgendem ausgegangen:This example assumes:

  • Die Codedatei enthält eine using-Anweisung für die Namespaces Windows.Services.Store und System.Threading.Tasks.The code file has a using statement for the Windows.Services.Store and System.Threading.Tasks namespaces.
  • Die App ist eine Einzelbenutzer-App, die nur im Kontext des Benutzers ausgeführt wird, der die App gestartet hat.The app is a single-user app that runs only in the context of the user that launched the app. Verwenden Sie für eine Multi-User-App die GetForUser-Methode, um ein StoreContext-Objekt anstelle der GetDefault-Methode abzurufen.For a multi-user app, use the GetForUser method to get a StoreContext object instead of the GetDefault method.

Hinweis

Die vom Code in diesem Beispiel aufgerufenen Methoden MarkUpdateInProgressInUI, RemoveItemFromUI, MarkInstallCompleteInUI, MarkInstallErrorInUI und MarkInstallPausedInUI sind Platzhaltermethoden, die gemäß den Anforderungen deines eigenen App-Entwurfs implementiert werden können.The MarkUpdateInProgressInUI, RemoveItemFromUI, MarkInstallCompleteInUI, MarkInstallErrorInUI, and MarkInstallPausedInUI methods called by the code in this example are placeholder methods that are intended to be implemented as needed according to your own app's design.

private StoreContext context = null;

private async Task GetQueuedInstallItemsAndBuildInitialStoreUI()
{
    if (context == null)
    {
        context = StoreContext.GetDefault();
    }

    // Get the Store packages in the install queue.
    IReadOnlyList<StoreQueueItem> storeUpdateItems = await context.GetAssociatedStoreQueueItemsAsync();

    foreach (StoreQueueItem storeItem in storeUpdateItems)
    {
        // In this example we only care about package updates.
        if (storeItem.InstallKind != StoreQueueItemKind.Update)
            continue;

        StoreQueueItemStatus currentStatus = storeItem.GetCurrentStatus();
        StoreQueueItemState installState = currentStatus.PackageInstallState;
        StoreQueueItemExtendedState extendedInstallState =
            currentStatus.PackageInstallExtendedState;

        // Handle the StatusChanged event to display current status to the customer.
        storeItem.StatusChanged += StoreItem_StatusChanged;

        switch (installState)
        {
            // Download and install are still in progress, so update the status for this  
            // item and provide the extended state info. The following methods are not
            // implemented in this example; you should implement them as needed for your
            // app's UI.
            case StoreQueueItemState.Active:
                MarkUpdateInProgressInUI(storeItem, extendedInstallState);
                break;
            case StoreQueueItemState.Canceled:
                RemoveItemFromUI(storeItem);
                break;
            case StoreQueueItemState.Completed:
                MarkInstallCompleteInUI(storeItem);
                break;
            case StoreQueueItemState.Error:
                MarkInstallErrorInUI(storeItem);
                break;
            case StoreQueueItemState.Paused:
                MarkInstallPausedInUI(storeItem, installState, extendedInstallState);
                break;
        }
    }
}

private void StoreItem_StatusChanged(StoreQueueItem sender, object args)
{
    StoreQueueItemStatus currentStatus = sender.GetCurrentStatus();
    StoreQueueItemState installState = currentStatus.PackageInstallState;
    StoreQueueItemExtendedState extendedInstallState = currentStatus.PackageInstallExtendedState;

    switch (installState)
    {
        // Download and install are still in progress, so update the status for this  
        // item and provide the extended state info. The following methods are not
        // implemented in this example; you should implement them as needed for your
        // app's UI.
        case StoreQueueItemState.Active:
            MarkUpdateInProgressInUI(sender, extendedInstallState);
            break;
        case StoreQueueItemState.Canceled:
            RemoveItemFromUI(sender);
            break;
        case StoreQueueItemState.Completed:
            MarkInstallCompleteInUI(sender);
            break;
        case StoreQueueItemState.Error:
            MarkInstallErrorInUI(sender);
            break;
        case StoreQueueItemState.Paused:
            MarkInstallPausedInUI(sender, installState, extendedInstallState);
            break;
    }
}