Administrador de cuentas webWeb Account Manager

En este artículo se describe cómo usar AccountsSettingsPane para conectar la aplicación plataforma universal de Windows (UWP) con proveedores de identidades externos, como Microsoft o Facebook, mediante las API del administrador de cuentas web de Windows 10.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. Aprenderá a solicitar el permiso de un usuario para usar sus cuenta de Microsoft, obtener un token de acceso y usarlo para realizar operaciones básicas (como obtener datos de perfil o cargar archivos en su cuenta de OneDrive).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). Los pasos son similares para obtener permiso del usuario y acceso con cualquier proveedor de identidades que admita el Administrador de cuentas web.The steps are similar for getting user permission and access with any identity provider that supports the Web Account Manager.

Nota

Para obtener un ejemplo de código completo, vea el ejemplo de WebAccountManagement en github.For a complete code sample, see the WebAccountManagement sample on GitHub.

PrepárateGet set up

En primer lugar, crea una aplicación vacía en Visual Studio.First, create a new, blank app in Visual Studio.

En segundo lugar, para conectar con proveedores de identidades, deberás asociar la aplicación a la Tienda.Second, in order to connect to identity providers, you'll need to associate your app with the Store. Para ello, haga clic con el botón derecho en el proyecto, elija tienda > asociar aplicación con la tienday siga las instrucciones del asistente.To do this, right click your project, choose Store > Associate app with the store, and follow the wizard's instructions.

En tercer lugar, crea una interfaz de usuario muy básica que conste de un botón XAML simple y dos cuadros de texto.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>

Y un controlador de eventos adjunto al botón en el código subyacente:And an event handler attached to your button in the code-behind:

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

Por último, agrega los siguientes espacios de nombres para no tener que preocuparte por problemas de referencias más adelante: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;

Mostrar el panel de configuración de cuentasShow the accounts settings pane

El sistema proporciona una interfaz de usuario integrada para administrar proveedores de identidades y cuentas web llamadas AccountsSettingsPane.The system provides a built-in user interface for managing identity providers and web accounts called AccountsSettingsPane. Se puede mostrar de la siguiente manera:You can show it like this:

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

Si ejecutas la aplicación y haces clic en el botón "Iniciar sesión", debería mostrarse una ventana vacía.If you run your app and click the "Log in" button, it should display an empty window.

Captura de pantalla de la ventana elegir una cuenta sin enumerar cuentas.

El panel está vacío porque el sistema solo proporciona un shell de interfaz de usuario. El desarrollador es quien rellena mediante programación el panel con los proveedores de identidades.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.

Sugerencia

Opcionalmente, puede usar ShowAddAccountAsync en lugar de Show, que devolverá un IAsyncAction para consultar el estado de la operación.Optionally, you can use ShowAddAccountAsync instead of Show, which will return an IAsyncAction, to query for the status of the operation.

Registrarse para AccountCommandsRequestedRegister for AccountCommandsRequested

Para agregar comandos al panel, empezamos por el registro para el controlador de eventos AccountCommandsRequested.To add commands to the pane, we start by registering for the AccountCommandsRequested event handler. Esto indica al sistema que ejecute la lógica de compilación cuando el usuario le pida ver el panel (por ejemplo, haga clic en nuestro botón XAML).This tells the system to run our build logic when the user asks to see the pane (for example, clicks our XAML button).

En el código subyacente, invalida los eventos OnNavigatedTo y OnNavigatedFrom y agrégales el siguiente código: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; 
}

Los usuarios no interactúan con las cuentas muy a menudo, por lo que registrar y cancelar el registro del controlador de eventos de esta manera ayuda a evitar pérdidas de memoria.Users don't interact with accounts very often, so registering and deregistering your event handler in this fashion helps prevent memory leaks. De esta forma, el panel personalizado solo está en la memoria cuando existe una alta probabilidad de que un usuario lo solicite (porque está en una página de "configuración" o "inicio de sesión", por ejemplo).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).

Crear el panel de configuración de la cuentaBuild the account settings pane

Se llama al método BuildPaneAsync siempre que se muestra AccountsSettingsPane .The BuildPaneAsync method is called whenever the AccountsSettingsPane is shown. Aquí es donde colocamos el código para personalizar los comandos que se muestran en el panel.This is where we'll put the code to customize the commands shown in the pane.

Comienza por obtener un aplazamiento.Start by obtaining a deferral. Esto indica al sistema que retrase la visualización del AccountsSettingsPane hasta que terminemos de compilarlo.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(); 
}

A continuación, obtén un proveedor con el método WebAuthenticationCoreManager.FindAccountProviderAsync.Next, get a provider using the WebAuthenticationCoreManager.FindAccountProviderAsync method. La dirección URL del proveedor varía según el proveedor y puede encontrarse en la documentación del proveedor.The URL for the provider varies based on the provider and can be found in the provider's documentation. En el caso de las cuentas de Microsoft y Azure Active Directory, es "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(); 
}

Ten en cuenta que también pasamos la cadena "consumers" al parámetro authority opcional.Notice that we also pass the string "consumers" to the optional authority parameter. Esto es porque Microsoft proporciona dos tipos diferentes de autenticación: cuentas Microsoft (MSA) para "consumers" y Azure Active Directory (AAD) para "organizations".This is because Microsoft provides two different types of authentication - Microsoft Accounts (MSA) for "consumers", and Azure Active Directory (AAD) for "organizations". La autoridad "consumers" indica que queremos la opción de MSA.The "consumers" authority indicates we want the MSA option. Si estás desarrollando una aplicación de empresa, usa en su lugar la cadena "organizations".If you're developing an enterprise app, use the string "organizations" instead.

Por último, agregue el proveedor a AccountsSettingsPane mediante la creación de un nuevo WebAccountProviderCommand similar al siguiente: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(); 
}

El método GetMsaToken que pasamos a nuestro nuevo WebAccountProviderCommand todavía no existe (lo compilaremos en el paso siguiente), así que no dude en agregarlo como un método vacío por ahora.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.

Ejecuta el código anterior y obtendrás un panel con un aspecto similar al siguiente:Run the above code and your pane should look something like this:

Captura de pantalla de la ventana elegir una cuenta con las cuentas enumeradas.

Solicitar un tokenRequest a token

Una vez que se muestra la opción cuenta de Microsoft en el AccountsSettingsPane, es necesario controlar lo que ocurre cuando el usuario la selecciona.Once we have the Microsoft Account option displaying in the AccountsSettingsPane, we need to handle what happens when the user selects it. Registramos nuestro método GetMsaToken para que se activara cuando el usuario eligiera iniciar sesión con su cuenta de Microsoft, por lo que obtendremos el token allí.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.

Para obtener un token, usa el método RequestTokenAsync de esta manera: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);
}

En este ejemplo, pasamos la cadena "WL. Basic" al parámetro de ámbito .In this example, we pass the string "wl.basic" to the scope parameter. El ámbito representa el tipo de información que estás solicitando desde el servicio proveedor en un usuario específico.Scope represents the type of information you are requesting from the providing service on a specific user. Ciertos ámbitos proporcionan acceso únicamente a la información básica de un usuario, como el nombre y la dirección de correo electrónico, mientras que otros ámbitos pueden conceder acceso a información confidencial, como las fotos del usuario o la bandeja de entrada de correo electrónico.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. Por lo general, la aplicación debe usar el ámbito menos permisivo necesario para lograr su función.Generally, your app should use the least permissive scope necessary to achieve its function. Los proveedores de servicios proporcionarán documentación sobre qué ámbitos son necesarios para obtener los tokens para su uso con sus servicios.Service providers will provide documentation on which scopes are needed to get tokens for use with their services.

Sugerencia

Opcionalmente, si la aplicación usa una sugerencia de inicio de sesión (para rellenar el campo de usuario con una dirección de correo electrónico predeterminada) u otra propiedad especial relacionada con la experiencia de inicio de sesión, escríbala en la propiedad WebTokenRequest. AppProperties .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. Esto hará que el sistema omita la propiedad al almacenar en caché la cuenta Web, lo que evita que se produzcan discrepancias de la cuenta en la memoria caché.This will cause the system to ignore the property when caching the web account, which prevents account mismatches in the cache.

Si estás desarrollando una aplicación de empresa, probablemente querrás conectarte a una instancia de Azure Active Directory (AAD) y usar la API de Microsoft Graph en lugar de los servicios de MSA habituales.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. En este escenario, usa el siguiente código en su lugar: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);
}

El resto de este artículo sigue describiendo el escenario de MSA, pero el código de AAD es muy similar.The rest of this article continues describing the MSA scenario, but the code for AAD is very similar. Para obtener más información sobre AAD o Graph, incluida una muestra completa en GitHub, consulta la documentación de Microsoft Graph.For more info on AAD/Graph, including a full sample on GitHub, see the Microsoft Graph documentation.

Uso del tokenUse the token

El método RequestTokenAsync devuelve un objeto WebTokenRequestResult, que contiene los resultados de la solicitud.The RequestTokenAsync method returns a WebTokenRequestResult object, which contains the results of your request. Si la solicitud se realizó correctamente, contendrá un 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; 
    }
}

Nota

Si recibe un error al solicitar un token, asegúrese de que ha asociado la aplicación a la tienda tal y como se describe en el paso uno.If you receive an error when requesting a token, make sure you've associated your app with the Store as described in step one. La aplicación no podrá obtener un token si omites este paso.Your app won't be able to get a token if you skipped this step.

Cuando tengas un token, podrás usarlo para llamar a la API de tu proveedor.Once you have a token, you can use it to call your provider's API. En el código siguiente, llamaremos a la información de usuario Microsoft Live API para obtener información básica sobre el usuario y mostrarla en la interfaz de usuario.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. Sin embargo, tenga en cuenta que en la mayoría de los casos se recomienda almacenar el token una vez obtenido y usarlo en un método independiente.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;
        }
    }
}

El método para llamar a las distintas API de REST varía según el proveedor; consulta la documentación de la API del proveedor para obtener información sobre cómo usar el token.How you call various REST APIs varies between providers; see the provider's API documentation for information on how to use your token.

Almacenar la cuenta para su uso futuroStore the account for future use

Los tokens son útiles para obtener información acerca de un usuario de inmediato, pero suelen tener distintas duraciones; los tokens de MSA, por ejemplo, solo son válidos para unas pocas horas.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. Afortunadamente, no es necesario volver a mostrar el AccountsSettingsPane cada vez que expire un token.Fortunately, you don't need to re-show the AccountsSettingsPane each time a token expires. Una vez que un usuario ha autorizado la aplicación una vez, puedes almacenar la información de la cuenta del usuario para usarla posteriormente.Once a user has authorized your app once, you can store the user's account information for future use.

Para ello, use la clase WebAccount .To do this, use the WebAccount class. Una cuenta webse devuelve mediante el mismo método que se usó para solicitar el token: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; 
    }
}

Una vez que tenga una instancia de WebAccount , puede almacenarla fácilmente.Once you have a WebAccount instance, you can easily store it. En el ejemplo siguiente, usamos LocalSettings.In the following example, we use LocalSettings. Para obtener más información sobre el uso de LocalSettings y otros métodos para almacenar datos de usuario, vea almacenar y recuperar la configuración y los datosde la aplicación.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; 
}

A continuación, podemos usar un método asincrónico como el siguiente para intentar obtener un token en segundo plano con la cuentawebalmacenada.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; 
    }
}

Coloque el método anterior justo antes del código que compila el AccountsSettingsPane.Place the above method just before the code that builds the AccountsSettingsPane. Si el token se obtiene en segundo plano, no es necesario mostrar el panel.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();
    }
}

Dado que es muy sencillo obtener un token de forma silenciosa, debes usar este proceso para actualizar el token entre sesiones, en lugar de almacenar en caché un token existente (ya que ese token podría expirar en cualquier momento).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).

Nota

En el ejemplo anterior solo se tratan los casos de éxito y error básicos.The example above only covers basic success and fail cases. La aplicación también debe tener en cuenta los escenarios inusuales (por ejemplo, que un usuario revoque el permiso de la aplicación o quite su cuenta de Windows) y controlarlos correctamente.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.

Quitar una cuenta almacenadaRemove a stored account

Si conserva una cuenta Web, puede que desee ofrecer a los usuarios la posibilidad de desasociar su cuenta con la aplicación.If you persist a web account, you may want to give your users the ability to disassociate their account with your app. De esta manera, pueden "cerrar sesión" de la aplicación: la información de su cuenta ya no se cargará automáticamente al iniciarse.This way, they can effectively "log out" of the app: their account information will no longer be loaded automatically upon launch. Para ello, quite primero cualquier información de proveedor y cuenta guardada del almacenamiento.To do this, first remove any saved account and provider information from storage. Después, llame a SignOutAsync para borrar la memoria caché e invalidar los tokens existentes que pueda tener la aplicación.Then 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(); 
}

Agregar proveedores que no admitan WebAccountManagerAdd providers that don't support WebAccountManager

Por ejemplo, si desea integrar la autenticación desde un servicio en la aplicación, pero ese servicio no es compatible con WebAccountManager-Google + o Twitter, puede Agregar manualmente ese proveedor a AccountsSettingsPane.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. Para ello, cree un nuevo objeto WebAccountProvider y proporcione su propio nombre y el icono. png y agréguelo a la lista WebAccountProviderCommands.To do so, create a new WebAccountProvider object and provide your own name and .png icon, then and add it to the WebAccountProviderCommands list. Este es un ejemplo de código auxiliar: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
}

Nota

Esto solo agrega un icono a AccountsSettingsPane y ejecuta el método especificado al hacer clic en el icono (GetTwitterTokenAsync, en este caso).This only adds an icon to the AccountsSettingsPane and runs the method you specify when the icon is clicked (GetTwitterTokenAsync, in this case). Debes proporcionar el código que controla la autenticación real.You must provide the code that handles the actual authentication. Para obtener más información, vea agente de autenticación Web, que proporciona métodos auxiliares para la autenticación mediante servicios REST.For more information, see Web authentication broker, which provides helper methods for authenticating using REST services.

Agregar un encabezado personalizadoAdd a custom header

Puedes personalizar el panel de configuración de la cuenta mediante la propiedad HeaderText, de esta manera: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
}

Captura de pantalla de la ventana elegir una cuenta sin cuentas enumeradas y un mensaje que dice que mi aplicación maravilla funciona mejor si ha iniciado sesión.

No te excedas con el texto del encabezado; mantenlo breve y simple.Don't go overboard with header text; keep it short and sweet. Si el proceso de inicio de sesión es complicado y necesitas mostrar más información, vincula el usuario a otra página con un vínculo personalizado.If your login process is complicated and you need to display more information, link the user to a separate page using a custom link.

Puedes agregar comandos personalizados a la interfaz AccountsSettingsPane, que aparecerán como vínculos debajo de la colección de WebAccountProviders admitidos.You can add custom commands to the AccountsSettingsPane, which appear as links below your supported WebAccountProviders. Los comandos personalizados son geniales para tareas simples relacionadas con las cuentas de usuario, como mostrar una directiva de privacidad o iniciar una página de soporte técnico para los usuarios que tienen problemas.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.

Este es un ejemplo: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
}

Captura de pantalla de la ventana elegir una cuenta sin enumerar cuentas y un vínculo a una directiva de privacidad.

En teoría, puedes usar comandos de configuración para cualquier cosa.Theoretically, you can use settings commands for anything. Sin embargo, se recomienda limitar su uso a escenarios intuitivos relacionados con las cuentas como las descritas anteriormente.However, we suggest limiting their use to intuitive, account-related scenarios like those described above.

Consulte tambiénSee also

Windows.Security.Authentication.Web.Core namespace (Espacio de nombres Windows.Security.Authentication.Web.Core)Windows.Security.Authentication.Web.Core namespace

Windows.Security.Credentials Namespace (Espacio de nombres Windows.Security.Credentials)Windows.Security.Credentials namespace

Clase AccountsSettingsPaneAccountsSettingsPane class

Agente de autenticación webWeb authentication broker

Ejemplo de administración de cuentas webWeb account management sample

Aplicación del programador del almuerzoLunch Scheduler app