Web Account ManagerWeb Account Manager

In diesem Artikel wird beschrieben, wie Sie mit accountsettingspane ihre universelle Windows-Plattform-app (UWP) mit externen Identitäts Anbietern wie Microsoft oder Facebook verbinden, indem Sie die Windows 10-Webkonto-Manager-APIs verwenden.This article describes how to use the AccountsSettingsPane to connect your Universal Windows Platform (UWP) app to external identity providers, like Microsoft or Facebook, using the Windows 10 Web Account Manager APIs. Sie erfahren, wie Sie die Berechtigung eines Benutzers anfordern, seinen Microsoft-Konto zu verwenden, ein Zugriffs Token abzurufen und dieses zum Ausführen grundlegender Vorgänge (z. b. Abrufen von Profildaten oder Hochladen von Dateien in das onedrive-Konto) zu verwenden.You'll learn how to request a user's permission to use their Microsoft account, obtain an access token, and use it to perform basic operations (like get profile data or upload files to their OneDrive account). Die Schritte ähneln denen, die zum Abrufen einer Benutzerberechtigung und für den Zugriff über einen beliebigen Identitätsanbieter ausgeführt werden, der Web Account Manager unterstützt.The steps are similar for getting user permission and access with any identity provider that supports the Web Account Manager.

Hinweis

Ein umfassendes Codebeispiel finden Sie im webaccountmanagement-Beispiel auf GitHub.For a complete code sample, see the WebAccountManagement sample on GitHub.

VorbereitenGet set up

Erstellen Sie zunächst eine neue leere App in Visual Studio.First, create a new, blank app in Visual Studio.

Um eine Verbindung mit Identitätsanbietern herzustellen, müssen Sie die App als Nächstes mit dem Store verknüpfen.Second, in order to connect to identity providers, you'll need to associate your app with the Store. Klicken Sie dazu mit der rechten Maustaste auf Ihr Projekt, wählen Sie Store > -App mit Store verknüpfenaus, und befolgen Sie die Anweisungen des Assistenten.To do this, right click your project, choose Store > Associate app with the store, and follow the wizard's instructions.

Erstellen Sie drittens eine allgemein verwendete Benutzeroberfläche, die eine einfache XAML-Schaltfläche und zwei Textfelder umfasst.Third, create a very basic UI consisting of a simple XAML button and two text boxes.

<StackPanel HorizontalAlignment="Center" VerticalAlignment="Center">
    <Button x:Name="LoginButton" Content="Log in" Click="LoginButton_Click" />
    <TextBlock x:Name="UserIdTextBlock"/>
    <TextBlock x:Name="UserNameTextBlock"/>
</StackPanel>

Im CodeBehind ist ein Ereignishandler an die Schaltfläche angefügt:And an event handler attached to your button in the code-behind:

private void LoginButton_Click(object sender, RoutedEventArgs e)
{   
}

Fügen Sie zum Schluss die folgenden Namespaces hinzu, damit später keine Verweisprobleme auftreten:Lastly, add the following namespaces so you don't have to worry about any reference issues later:

using System;
using Windows.Security.Authentication.Web.Core;
using Windows.System;
using Windows.UI.ApplicationSettings;
using Windows.UI.Xaml;
using Windows.UI.Xaml.Controls;
using Windows.Data.Json;
using Windows.UI.Xaml.Navigation;
using Windows.Web.Http;

Fenster "Kontoeinstellungen" anzeigenShow the accounts settings pane

Das System verfügt über eine integrierte Benutzeroberfläche zum Verwalten von Identitäts Anbietern und Webkonten namens accountsettingspane.The system provides a built-in user interface for managing identity providers and web accounts called AccountsSettingsPane. Sie können sie wie folgt anzeigen:You can show it like this:

private void LoginButton_Click(object sender, RoutedEventArgs e)
{
    AccountsSettingsPane.Show(); 
}

Wenn Sie Ihre App ausführen und auf die Anmeldeschaltfläche klicken, sollte ein leeres Fenster angezeigt werden.If you run your app and click the "Log in" button, it should display an empty window.

Screenshot des Fensters "Konto auswählen", in dem keine Konten aufgeführt sind.

Der Bereich ist leer, weil das System nur eine UI-Shell bereitstellt. Der Entwickler kann den Bereich programmgesteuert mit Identitätsanbietern auffüllen.The pane is empty because the system only provides a UI shell - it's up to the developer to programatically populate the pane with the identity providers.

Tipp

Optional können Sie showaddaccountasync anstelle von Show verwenden, wodurch eine iasyncaction-Aktion zurückgegeben wird, um den Status des Vorgangs abzufragen.Optionally, you can use ShowAddAccountAsync instead of Show, which will return an IAsyncAction, to query for the status of the operation.

Registrieren für AccountCommandsRequestedRegister for AccountCommandsRequested

Um dem Bereich Befehle hinzuzufügen, führen wir zunächst eine Registrierung für den AccountCommandsRequested-Ereignishandler durch.To add commands to the pane, we start by registering for the AccountCommandsRequested event handler. Dadurch wird dem System mitgeteilt, dass die buildlogik ausgeführt werden soll, wenn der Benutzer aufgefordert wird, den Bereich anzuzeigen (z. b. Klicken auf unsere XAML-Schaltfläche)This tells the system to run our build logic when the user asks to see the pane (for example, clicks our XAML button).

Überschreiben Sie im CodeBehind das OnNavigatedTo-Ereignis und das OnNavigatedFrom-Ereignis, und fügen Sie ihnen den folgenden Code hinzu:In your code behind, override the OnNavigatedTo and OnNavigatedFrom events and add the following code to them:

protected override void OnNavigatedTo(NavigationEventArgs e)
{
    AccountsSettingsPane.GetForCurrentView().AccountCommandsRequested += BuildPaneAsync; 
}
protected override void OnNavigatedFrom(NavigationEventArgs e)
{
    AccountsSettingsPane.GetForCurrentView().AccountCommandsRequested -= BuildPaneAsync; 
}

Da Benutzer nicht sehr häufig mit Konten interagieren, empfiehlt es sich, den Ereignishandler in der beschriebenen Weise zu registrieren bzw. seine Registrierung aufzuheben, um Arbeitsspeicherverluste zu vermeiden.Users don't interact with accounts very often, so registering and deregistering your event handler in this fashion helps prevent memory leaks. Dadurch wird der angepasste Bereich nur im Arbeitsspeicher vorgehalten, wenn eine hohe Wahrscheinlichkeit vorliegt, dass er vom Benutzer angefordert wird (der Benutzer befindet sich z. B. auf der Seite „Einstellungen“ oder „Anmelden“).This way, your customized pane is only in memory when there's a high chance a user is going to ask for it (because they're on a "settings" or "login" page, for example).

Erstellen des Bereichs mit KontoeinstellungenBuild the account settings pane

Die buildpaneasync-Methode wird immer dann aufgerufen, wenn accountsettingspane angezeigt wird.The BuildPaneAsync method is called whenever the AccountsSettingsPane is shown. Dort legen wir den Code zur Anpassung der im Bereich angezeigten Befehle ab.This is where we'll put the code to customize the commands shown in the pane.

Sie beginnen, indem Sie eine Verzögerung abrufen.Start by obtaining a deferral. Dies weist das System an, die accountorsettingspane zu verzögern, bis der Vorgang abgeschlossen ist.This tells the system to delay showing the AccountsSettingsPane until we're finished building it.

private async void BuildPaneAsync(AccountsSettingsPane s,
    AccountsSettingsPaneCommandsRequestedEventArgs e)
{
    var deferral = e.GetDeferral();
        
    deferral.Complete(); 
}

Als Nächstes rufen Sie einen Anbieter mit der WebAuthenticationCoreManager.FindAccountProviderAsync-Methode ab.Next, get a provider using the WebAuthenticationCoreManager.FindAccountProviderAsync method. Die Anbieter-URL ist je nach Anbieter verschieden und kann in der Anbieterdokumentation nachgeschlagen werden.The URL for the provider varies based on the provider and can be found in the provider's documentation. Bei Microsoft-Konten und Azure Active Directory ist das "HTTPS : //Login.Microsoft.com".For Microsoft Accounts and Azure Active Directory, it's "https://login.microsoft.com".

private async void BuildPaneAsync(AccountsSettingsPane s,
    AccountsSettingsPaneCommandsRequestedEventArgs e)
{
    var deferral = e.GetDeferral();
        
    var msaProvider = await WebAuthenticationCoreManager.FindAccountProviderAsync(
        "https://login.microsoft.com", "consumers"); 
        
    deferral.Complete(); 
}

Beachten Sie, dass auch die Zeichenfolge „consumers“ an den optionalen authority-Parameter übergeben wird.Notice that we also pass the string "consumers" to the optional authority parameter. Dies liegt daran, dass Microsoft zwei verschiedene Authentifizierungsmethoden bereitstellt: Microsoft-Konten (MSA) für „Heimanwender“ und Azure Active Directory (AAD) für „Organisationen“.This is because Microsoft provides two different types of authentication - Microsoft Accounts (MSA) for "consumers", and Azure Active Directory (AAD) for "organizations". Die Autorität „consumers“ gibt an, dass die MSA-Option verwendet werden soll.The "consumers" authority indicates we want the MSA option. Wenn Sie eine Unternehmens-App entwickeln, verwenden Sie stattdessen die Zeichenfolge „organizations“.If you're developing an enterprise app, use the string "organizations" instead.

Fügen Sie schließlich den Anbieter der accountsettingspane hinzu, indem Sie einen neuen webaccountprovidercommand wie den folgenden erstellen:Finally, add the provider to the AccountsSettingsPane by creating a new WebAccountProviderCommand like this:

private async void BuildPaneAsync(AccountsSettingsPane s,
    AccountsSettingsPaneCommandsRequestedEventArgs e)
{
    var deferral = e.GetDeferral();

    var msaProvider = await WebAuthenticationCoreManager.FindAccountProviderAsync(
        "https://login.microsoft.com", "consumers");

    var command = new WebAccountProviderCommand(msaProvider, GetMsaTokenAsync);  

    e.WebAccountProviderCommands.Add(command);

    deferral.Complete(); 
}

Die getmsatoken-Methode, die wir an unseren neuen webaccountprovidercommand weitergegeben haben, ist noch nicht vorhanden (wir erstellen dies im nächsten Schritt). Daher können Sie Sie jetzt als leere Methode hinzufügen.The GetMsaToken method we passed to our new WebAccountProviderCommand doesn't exist yet (we'll build that in the next step), so feel free to add it as an empty method for now.

Führen Sie den vorangehenden Code aus. Der Bereich sollte jetzt wie folgt aussehen:Run the above code and your pane should look something like this:

Screenshot des Fensters "Konto auswählen" mit aufgeführten Konten

Anfordern eines TokensRequest a token

Wenn die Option "Microsoft-Konto" in " accounzsettingspane" angezeigt wird, müssen wir behandeln, was geschieht, wenn der Benutzer die Option auswählt.Once we have the Microsoft Account option displaying in the AccountsSettingsPane, we need to handle what happens when the user selects it. Die GetMsaToken-Methode wurde so registriert, dass sie ausgelöst wird, wenn sich der Benutzer für die Anmeldung mit seinem Microsoft-Konto entscheidet. Deshalb fordern wir an dieser Stelle das Token an.We registered our GetMsaToken method to fire when the user chooses to log in with their Microsoft Account, so we'll obtain the token there.

Um ein Token anzufordern, verwenden Sie die RequestTokenAsync-Methode wie folgt:To obtain a token, use the RequestTokenAsync method like this:

private async void GetMsaTokenAsync(WebAccountProviderCommand command)
{
    WebTokenRequest request = new WebTokenRequest(command.WebAccountProvider, "wl.basic");
    WebTokenRequestResult result = await WebAuthenticationCoreManager.RequestTokenAsync(request);
}

In diesem Beispiel übergeben wir die Zeichenfolge "wl. Basic" an den Scope -Parameter.In this example, we pass the string "wl.basic" to the scope parameter. „scope“ steht für den Typ von Informationen, die Sie vom bereitstellenden Dienst für einen bestimmten Benutzer anfordern.Scope represents the type of information you are requesting from the providing service on a specific user. Bestimmte Bereiche ermöglichen nur den Zugriff auf die grundlegenden Informationen eines Benutzers, z. b. Name und e-Mail-Adresse. andere Bereiche gewähren möglicherweise Zugriff auf vertrauliche Informationen, wie z. b. die Fotos oder den e-Mail-Certain scopes provide access only to a user's basic information, like name and email address, while other scopes might grant access to sensitive information such as the user's photos or email inbox. Im Allgemeinen sollte Ihre APP den geringsten Gültigkeitsbereich verwenden, der erforderlich ist, um ihre Funktion zu erreichen.Generally, your app should use the least permissive scope necessary to achieve its function. Dienstanbieter bieten Dokumentation dazu, welche Bereiche erforderlich sind, um Token für die Verwendung mit Ihren Diensten zu erhalten.Service providers will provide documentation on which scopes are needed to get tokens for use with their services.

Tipp

Wenn Ihre APP einen Anmelde Hinweis verwendet (zum Auffüllen des Benutzer Felds mit einer Standard-e-Mail-Adresse) oder eine andere spezielle Eigenschaft im Zusammenhang mit dem Anmeldevorgang, können Sie Sie optional in der Eigenschaft webtokenrequest. appproperties auflisten.Optionally, if your app uses a login hint (to populate the user field with a default email address) or other special property related to the sign-in experience, list it in the WebTokenRequest.AppProperties property. Dies bewirkt, dass das System die Eigenschaft ignoriert, wenn das Webkonto zwischengespeichert wird, wodurch nicht übereinstimmende Konten im Cache verhindert werden.This will cause the system to ignore the property when caching the web account, which prevents account mismatches in the cache.

Wenn Sie eine Unternehmens-App entwickeln, möchten Sie wahrscheinlich eine Verbindung mit einer Azure Active Directory (AAD)-Instanz herstellen und die Microsoft Graph-API anstelle regulärer MSA-Dienste verwenden.If you're developing an enterprise app, you'll likely want to connect to an Azure Active Directory (AAD) instance and use the Microsoft Graph API instead of regular MSA services. Verwenden Sie in diesem Szenario stattdessen folgenden Code:In this scenario, use the following code instead:

private async void GetAadTokenAsync(WebAccountProviderCommand command)
{
    string clientId = "your_guid_here"; // Obtain your clientId from the Azure Portal
    WebTokenRequest request = new WebTokenRequest(provider, "User.Read", clientId);
    request.Properties.Add("resource", "https://graph.microsoft.com");
    WebTokenRequestResult result = await WebAuthenticationCoreManager.RequestTokenAsync(request);
}

Im weiteren Verlauf dieses Artikels wird das MSA-Szenario beschrieben, der Code für AAD ist allerdings sehr ähnlich.The rest of this article continues describing the MSA scenario, but the code for AAD is very similar. Weitere Informationen zu AAD/Graph einschließlich eines vollständigen Beispiels auf GitHub finden Sie in der Microsoft Graph-Dokumentation.For more info on AAD/Graph, including a full sample on GitHub, see the Microsoft Graph documentation.

Verwenden des TokensUse the token

Die RequestTokenAsync-Methode gibt ein WebTokenRequestResult-Objekt zurück, das die Ergebnisse für Ihre Anforderung enthält.The RequestTokenAsync method returns a WebTokenRequestResult object, which contains the results of your request. Wenn die Anforderung erfolgreich war, enthält sie ein Token.If your request was successful, it will contain a token.

private async void GetMsaTokenAsync(WebAccountProviderCommand command)
{
    WebTokenRequest request = new WebTokenRequest(command.WebAccountProvider, "wl.basic");
    WebTokenRequestResult result = await WebAuthenticationCoreManager.RequestTokenAsync(request);
    
    if (result.ResponseStatus == WebTokenRequestStatus.Success)
    {
        string token = result.ResponseData[0].Token; 
    }
}

Hinweis

Wenn Sie beim Anfordern eines Tokens einen Fehler erhalten, stellen Sie sicher, dass Sie die APP mit dem Store verknüpft haben, wie in Schritt 1 beschrieben.If you receive an error when requesting a token, make sure you've associated your app with the Store as described in step one. Ihre App wird nicht in der Lage sein, ein Token abzurufen, wenn Sie diesen Schritt übersprungen haben.Your app won't be able to get a token if you skipped this step.

Sobald Sie im Besitz des Tokens sind, können Sie darüber die API Ihres Anbieters aufrufen.Once you have a token, you can use it to call your provider's API. Im folgenden Code wird die Microsoft Live-API für Benutzerinformationen aufgerufen, um grundlegende Informationen über den Benutzer zu erhalten und in der Benutzeroberfläche anzuzeigen.In the code below, we'll call the user info Microsoft Live API to obtain basic information about the user and display it in our UI. Beachten Sie jedoch, dass es in den meisten Fällen empfehlenswert ist, das Token nach dem Abruf zu speichern und dann in einer separaten Methode zu verwenden.Note however that in most cases it is recommended that you store the token once obtained and then use it in a separate method.

private async void GetMsaTokenAsync(WebAccountProviderCommand command)
{
    WebTokenRequest request = new WebTokenRequest(command.WebAccountProvider, "wl.basic");
    WebTokenRequestResult result = await WebAuthenticationCoreManager.RequestTokenAsync(request);
    
    if (result.ResponseStatus == WebTokenRequestStatus.Success)
    {
        string token = result.ResponseData[0].Token; 
        
        var restApi = new Uri(@"https://apis.live.net/v5.0/me?access_token=" + token);

        using (var client = new HttpClient())
        {
            var infoResult = await client.GetAsync(restApi);
            string content = await infoResult.Content.ReadAsStringAsync();

            var jsonObject = JsonObject.Parse(content);
            string id = jsonObject["id"].GetString();
            string name = jsonObject["name"].GetString();

            UserIdTextBlock.Text = "Id: " + id; 
            UserNameTextBlock.Text = "Name: " + name;
        }
    }
}

Die Methode zum Aufrufen verschiedener REST-APIs ist je nach Anbieter verschieden. Informationen zur Verwendung des Tokens finden Sie in der API-Dokumentation des Anbieters.How you call various REST APIs varies between providers; see the provider's API documentation for information on how to use your token.

Speichern Sie das Konto für die spätere Verwendung.Store the account for future use

Token sind hilfreich, um sofort Informationen über einen Benutzer abzurufen, in der Regel haben sie jedoch unterschiedliche Ablaufzeiten. MSA-Token sind beispielsweise nur wenige Stunden gültig.Tokens are useful for immediately obtaining information about a user, but they usually have varying lifespans - MSA tokens, for instance, are only valid for a few hours. Glücklicherweise müssen Sie die accountionsettingspane nicht jedes Mal erneut anzeigen, wenn ein Token abläuft.Fortunately, you don't need to re-show the AccountsSettingsPane each time a token expires. Nachdem Ihre App einmal von einem Benutzer autorisiert wurde, können Sie die Kontoinformationen des Benutzers für die zukünftige Verwendung speichern.Once a user has authorized your app once, you can store the user's account information for future use.

Verwenden Sie hierzu die WebAccount -Klasse.To do this, use the WebAccount class. Ein Webkonto wird von derselben Methode zurückgegeben, die Sie zum Anfordern des Tokens verwendet haben:A WebAccount is returned by the same method you used to request the token:

private async void GetMsaTokenAsync(WebAccountProviderCommand command)
{
    WebTokenRequest request = new WebTokenRequest(command.WebAccountProvider, "wl.basic");
    WebTokenRequestResult result = await WebAuthenticationCoreManager.RequestTokenAsync(request);
    
    if (result.ResponseStatus == WebTokenRequestStatus.Success)
    {
        WebAccount account = result.ResponseData[0].WebAccount; 
    }
}

Sobald Sie über eine WebAccount -Instanz verfügen, können Sie Sie problemlos speichern.Once you have a WebAccount instance, you can easily store it. Im folgenden Beispiel verwenden wir LocalSettings.In the following example, we use LocalSettings. Weitere Informationen zur Verwendung von LocalSettings und anderen Methoden zum Speichern von Benutzerdaten finden Sie unter Speichern und Abrufen von App-Einstellungen und Daten.For more information on using LocalSettings and other methods to store user data, see Store and retrieve app settings and data.

private async void StoreWebAccount(WebAccount account)
{
    ApplicationData.Current.LocalSettings.Values["CurrentUserProviderId"] = account.WebAccountProvider.Id;
    ApplicationData.Current.LocalSettings.Values["CurrentUserId"] = account.Id; 
}

Anschließend können Sie eine asynchrone Methode wie die folgende verwenden, um zu versuchen, ein Token im Hintergrund mit dem gespeicherten Webkontoabzurufen.Then, we can use an asynchronous method like the following to attempt to obtain a token in the background with the stored WebAccount.

private async Task<string> GetTokenSilentlyAsync()
{
    string providerId = ApplicationData.Current.LocalSettings.Values["CurrentUserProviderId"]?.ToString();
    string accountId = ApplicationData.Current.LocalSettings.Values["CurrentUserId"]?.ToString();

    if (null == providerId || null == accountId)
    {
        return null; 
    }

    WebAccountProvider provider = await WebAuthenticationCoreManager.FindAccountProviderAsync(providerId);
    WebAccount account = await WebAuthenticationCoreManager.FindAccountAsync(provider, accountId);

    WebTokenRequest request = new WebTokenRequest(provider, "wl.basic");

    WebTokenRequestResult result = await WebAuthenticationCoreManager.GetTokenSilentlyAsync(request, account);
    if (result.ResponseStatus == WebTokenRequestStatus.UserInteractionRequired)
    {
        // Unable to get a token silently - you'll need to show the UI
        return null; 
    }
    else if (result.ResponseStatus == WebTokenRequestStatus.Success)
    {
        // Success
        return result.ResponseData[0].Token;
    }
    else
    {
        // Other error 
        return null; 
    }
}

Platzieren Sie die obige Methode direkt vor dem Code, der accounzsettingspaneerstellt.Place the above method just before the code that builds the AccountsSettingsPane. Wenn das Token im Hintergrund abgerufen wird, muss der Bereich nicht angezeigt werden.If the token is obtained in the background, there is no need to show the pane.

private void LoginButton_Click(object sender, RoutedEventArgs e)
{
    string silentToken = await GetMsaTokenSilentlyAsync();

    if (silentToken != null)
    {
        // the token was obtained. store a reference to it or do something with it here.
    }
    else
    {
        // the token could not be obtained silently. Show the AccountsSettingsPane
        AccountsSettingsPane.Show();
    }
}

Da der Tokenabruf im Hintergrund sehr einfach ist, sollten Sie diese Methode verwenden, um Ihr Token zwischen Sitzungen zu aktualisieren, anstatt ein vorhandenes Token zwischenzuspeichern (da das Token jederzeit ablaufen kann).Because obtaining a token silently is very simple, you should use this process to refresh your token between sessions rather than caching an existing token (since that token might expire at any time).

Hinweis

Im obigen Beispiel werden nur grundlegende Erfolgs-und Fehlerfälle behandelt.The example above only covers basic success and fail cases. Ihre App sollte auch außergewöhnliche Szenarien berücksichtigen (z. B. wenn ein Benutzer die Berechtigung für die App widerruft oder das Konto aus Windows entfernt) und sie angemessen behandeln.Your app should also account for unusual scenarios (like a user revoking your app's permission or removing their account from Windows, for example) and handle them gracefully.

Entfernen eines gespeicherten KontosRemove a stored account

Wenn Sie ein Webkonto persistent speichern, können Sie Ihren Benutzern die Möglichkeit einräumen, Ihr Konto mit Ihrer APP zu trennen.If you persist a web account, you may want to give your users the ability to disassociate their account with your app. Auf diese Weise können Sie die APP effektiv "Abmelden": Ihre Kontoinformationen werden beim Start nicht mehr automatisch geladen.This way, they can effectively "log out" of the app: their account information will no longer be loaded automatically upon launch. Entfernen Sie zu diesem Zweck zunächst alle gespeicherten Konto-und Anbieter Informationen aus dem Speicher.To do this, first remove any saved account and provider information from storage. Anschließend können Sie signoutasync aufrufen, um den Cache zu löschen und alle vorhandenen Token, die Ihre APP möglicherweise besitzt, ungültig zu machenThen call SignOutAsync to clear the cache and invalidate any existing tokens your app may have.

private async Task SignOutAccountAsync(WebAccount account)
{
    ApplicationData.Current.LocalSettings.Values.Remove("CurrentUserProviderId");
    ApplicationData.Current.LocalSettings.Values.Remove("CurrentUserId"); 
    account.SignOutAsync(); 
}

Hinzufügen von Anbietern, die WebAccountManager nicht unterstützenAdd providers that don't support WebAccountManager

Wenn Sie die Authentifizierung von einem Dienst in Ihre APP integrieren möchten, der Dienst webaccountmanager-Google + oder Twitter jedoch nicht unterstützt, können Sie den Anbieter trotzdem manuell zu accountionsettingspanehinzufügen.If you want to integrate authentication from a service into your app but that service doesn't support WebAccountManager - Google+ or Twitter, for example - you can still manually add that provider to the AccountsSettingsPane. Erstellen Sie dazu ein neues webaccountprovider-Objekt, geben Sie einen eigenen Namen und ein. PNG-Symbol an, und fügen Sie es der webaccountprovidercommands-Liste hinzu.To do so, create a new WebAccountProvider object and provide your own name and .png icon, then and add it to the WebAccountProviderCommands list. Stubcode-Beispiel:Here's some stub code:

private async void BuildPaneAsync(AccountsSettingsPane s, AccountsSettingsPaneCommandsRequestedEventArgs e)
{
   // other code here 

   var twitterProvider = new WebAccountProvider("twitter", "Twitter", new Uri(@"ms-appx:///Assets/twitter-auth-icon.png")); 
   var twitterCmd = new WebAccountProviderCommand(twitterProvider, GetTwitterTokenAsync);
   e.WebAccountProviderCommands.Add(twitterCmd);   
   
   // other code here
}

private async void GetTwitterTokenAsync(WebAccountProviderCommand command)
{
   // Manually handle Twitter login here
}

Hinweis

Dadurch wird der accountsettingspane nur ein Symbol hinzugefügt, und die Methode wird ausgeführt, die Sie beim Klicken auf das Symbol angeben (in diesem Fall gettwitterdekenasync).This only adds an icon to the AccountsSettingsPane and runs the method you specify when the icon is clicked (GetTwitterTokenAsync, in this case). Sie müssen den Code angeben, durch den die eigentliche Authentifizierung behandelt wird.You must provide the code that handles the actual authentication. Weitere Informationen finden Sie unter Web Authentication Broker, der Hilfsmethoden zum Authentifizieren mithilfe von Rest-Diensten bereitstellt.For more information, see Web authentication broker, which provides helper methods for authenticating using REST services.

Hinzufügen eines benutzerdefinierten HeadersAdd a custom header

Sie können den Bereich mit den Kontoeinstellungen mithilfe der HeaderText-Eigenschaft wie folgt anpassen:You can customize the account settings pane using the HeaderText property, like this:

private async void BuildPaneAsync(AccountsSettingsPane s, AccountsSettingsPaneCommandsRequestedEventArgs e)
{
    // other code here 
    
    args.HeaderText = "MyAwesomeApp works best if you're signed in.";   
    
    // other code here
}

Screenshot des Fensters "Konto auswählen" ohne aufgeführten Konten und eine Meldung, die besagt, dass meine tolle App am besten funktioniert, wenn Sie angemeldet sind.

Halten Sie Headertext kurz und einfach, und vermeiden Sie überflüssige Informationen.Don't go overboard with header text; keep it short and sweet. Wenn der Anmeldevorgang komplex ist und weitere Informationen angezeigt werden müssen, verknüpfen Sie den Benutzer über einen benutzerdefinierten Link mit einer separaten Seite.If your login process is complicated and you need to display more information, link the user to a separate page using a custom link.

Sie können dem AccountsSettingsPane benutzerdefinierte Befehle hinzufügen, die als Links unter den unterstützten WebAccountProviders angezeigt werden.You can add custom commands to the AccountsSettingsPane, which appear as links below your supported WebAccountProviders. Benutzerdefinierte Befehle eignen sich hervorragend für einfache Aufgaben in Verbindung mit Benutzerkonten, z. B. das Anzeigen einer Datenschutzrichtlinie oder das Öffnen einer Supportseite, wenn auf Benutzerseite ein Problem auftritt.Custom commands are great for simple tasks related to user accounts, like displaying a privacy policy or launching a support page for users having trouble.

Hier sehen Sie ein Beispiel:Here's an example:

private async void BuildPaneAsync(AccountsSettingsPane s, AccountsSettingsPaneCommandsRequestedEventArgs e)
{
    // other code here 
    
    var settingsCmd = new SettingsCommand(
        "settings_privacy", 
        "Privacy policy", 
        async (x) => await Launcher.LaunchUriAsync(new Uri(@"https://privacy.microsoft.com/en-US/"))); 

    e.Commands.Add(settingsCmd); 
    
    // other code here
}

Screenshot des Fensters "Konto auswählen" ohne die aufgeführten Konten und einen Link zu einer Datenschutzrichtlinie.

Einstellungsbefehle lassen sich grundsätzlich überall verwenden.Theoretically, you can use settings commands for anything. Es wird jedoch empfohlen, diese Art Befehle auf die oben beschriebenen intuitiven Kontoszenarien zu beschränken.However, we suggest limiting their use to intuitive, account-related scenarios like those described above.

Siehe auchSee also

Windows.Security.Authentication.Web.Core-NamespaceWindows.Security.Authentication.Web.Core namespace

Windows.Security.Credentials-NamespaceWindows.Security.Credentials namespace

Accountorsettingspane-KlasseAccountsSettingsPane class

WebauthentifizierungsbrokerWeb authentication broker

Beispiel für die Webkonto VerwaltungWeb account management sample

Lunch Scheduler-AppLunch Scheduler app