> ## Documentation Index
> Fetch the complete documentation index at: https://translations.mintlify.site/llms.txt
> Use this file to discover all available pages before exploring further.

# Agrega el inicio de sesión a tu aplicación WPF o WinForms

> Agrega el inicio de sesión, el cierre de sesión y el perfil de usuario de Auth0 a una aplicación WPF o WinForms con Auth0 OIDC Client para .NET

export const HowToSchema = () => <script type="application/ld+json">
    {'{"@context":"https://schema.org","@type":"HowTo"}'}
  </script>;

<HowToSchema />

<Accordion title="Usa IA para integrar Auth0" icon="microchip-ai" iconType="solid" defaultOpen>
  Si usas un asistente de programación con IA como Claude Code, Cursor o GitHub Copilot, puedes agregar la autenticación de Auth0 automáticamente en cuestión de minutos con [agent skills](https://agentskills.io/home).

  **Instala:**

  ```bash theme={null}
  npx skills add auth0/agent-skills --skill auth0-quickstart --skill auth0-wpf --skill auth0-winforms
  ```

  **Luego, pídele a tu asistente de IA:**

  ```text theme={null}
  Add Auth0 authentication to my WPF or WinForms app
  ```

  Tu asistente de IA creará automáticamente tu aplicación de Auth0, obtendrá las credenciales, instalará el SDK Auth0 OidcClient, configurará las URL de callback e implementará los flujos de inicio y cierre de sesión. [Consulta la documentación completa de agent skills →](/es/docs/quickstart/agent-skills)
</Accordion>

<Note>
  **Requisitos previos:** Antes de comenzar, asegúrate de tener lo siguiente:

  * **[.NET 8.0 SDK](https://dotnet.microsoft.com/download/dotnet/8.0)** o una versión posterior (o .NET Framework 4.6.2 para proyectos heredados)
  * **[Visual Studio 2022](https://visualstudio.microsoft.com/)** o VS Code con C# Dev Kit

  **Compatibilidad de versiones de .NET:** Esta guía de inicio rápido funciona con **.NET 8.0**, **.NET 9.0** y **.NET Framework 4.6.2**.
</Note>

<div id="get-started">
  ## Primeros pasos
</div>

Esta guía de inicio rápido muestra cómo agregar la autenticación de Auth0 a una aplicación de escritorio WPF o WinForms. Configurará Auth0, instalará el SDK y añadirá el inicio de sesión, el cierre de sesión y la visualización del perfil del usuario mediante Auth0 OIDC Client para [WPF](https://www.nuget.org/packages/Auth0.OidcClient.WPF/) y [WinForms](https://www.nuget.org/packages/Auth0.OidcClient.WinForms/).

<Steps>
  <Step title="Crea tu aplicación" stepNumber={1}>
    Si ya tiene un proyecto de WPF o WinForms, pase al siguiente paso.

    <Tabs>
      <Tab title=".NET CLI">
        Cree un proyecto nuevo y abra su directorio:

        <Tabs>
          <Tab title="WPF">
            ```bash theme={null}
            dotnet new wpf -n MyApp
            cd MyApp
            ```
          </Tab>

          <Tab title="WinForms">
            ```bash theme={null}
            dotnet new winforms -n MyApp
            cd MyApp
            ```
          </Tab>
        </Tabs>
      </Tab>

      <Tab title="Visual Studio">
        1. Abra Visual Studio 2022 y haga clic en **Crear un proyecto**
        2. Busque **Aplicación WPF** o **Aplicación Windows Forms**
        3. Seleccione la plantilla de C# y haga clic en **Siguiente**
        4. Escriba un nombre para el proyecto y elija una ubicación; luego haga clic en **Siguiente**
        5. Seleccione **.NET 8.0** (o una versión posterior) como framework de destino y haga clic en **Crear**
      </Tab>
    </Tabs>
  </Step>

  <Step title="Configurar Auth0" stepNumber={2}>
    Para usar los servicios de Auth0, debes tener una aplicación configurada en el Auth0 Dashboard. En la aplicación de Auth0 configuras cómo funciona la autenticación de tu proyecto.

    ### Configurar una aplicación

    Ve a [Auth0 Dashboard](https://manage.auth0.com) → **Applications** → **Applications** y crea una aplicación nueva:

    1. Haz clic en **Create Application**
    2. Introduce un nombre para tu aplicación
    3. Selecciona **Native** como tipo de aplicación
    4. Haz clic en **Create**

    En la pestaña **Settings**, toma nota de tu **dominio** y tu **ID de cliente**; los necesitarás para inicializar el SDK.

    ### Configurar las URL de callback

    Una URL de callback es una URL de tu aplicación a la que Auth0 redirige a los usuarios después de autenticarse. Si no se configura, los usuarios no volverán a tu aplicación después de iniciar sesión.

    En la configuración de tu aplicación, agrega lo siguiente a **Allowed Callback URLs**:

    ```
    https://{yourDomain}/mobile
    ```

    ### Configurar las URL de cierre de sesión

    Una URL de cierre de sesión es una URL de tu aplicación a la que Auth0 redirige a los usuarios después de cerrar sesión. Si no se configura, los usuarios no podrán cerrar sesión en tu aplicación y recibirán un error.

    En la configuración de tu aplicación, agrega lo siguiente en **Allowed Logout URLs**:

    ```
    https://{yourDomain}/mobile
    ```
  </Step>

  <Step title="Instala el SDK de Auth0" stepNumber={3}>
    Auth0 ofrece paquetes NuGet independientes para WPF y WinForms. Instala el que corresponda al tipo de proyecto.

    <Tabs>
      <Tab title="Administrador de paquetes NuGet">
        Abre la **Consola del Administrador de paquetes** (Tools → NuGet Package Manager → Package Manager Console) y ejecuta:

        ```powershell theme={null}
        # WPF
        Install-Package Auth0.OidcClient.WPF

        # WinForms
        Install-Package Auth0.OidcClient.WinForms
        ```
      </Tab>

      <Tab title="CLI de .NET">
        ```bash theme={null}
        # WPF
        dotnet add package Auth0.OidcClient.WPF

        # WinForms
        dotnet add package Auth0.OidcClient.WinForms
        ```
      </Tab>
    </Tabs>
  </Step>

  <Step title="Crear una instancia de Auth0Client" stepNumber={4}>
    Para integrar Auth0 en su aplicación, cree una instancia de `Auth0Client` con su **dominio** de Auth0 y su **ID de cliente**. Agregue un campo privado e inicialícelo dentro del constructor existente de la ventana principal o el formulario.

    <Tabs>
      <Tab title="WPF">
        Abra `MainWindow.xaml.cs` y actualícelo de la siguiente manera:

        ```csharp MainWindow.xaml.cs lines theme={null}
        using Auth0.OidcClient;

        // Si eligió un nombre diferente para su aplicación,
        // asegúrese de actualizar el espacio de nombres según corresponda.
        namespace MyApp; 

        public partial class MainWindow : Window
        {
            private Auth0Client _client;

            public MainWindow()
            {
                InitializeComponent();

                _client = new Auth0Client(new Auth0ClientOptions
                {
                    Domain = "{yourDomain}",
                    ClientId = "{yourClientId}"
                });
            }
        }
        ```
      </Tab>

      <Tab title="WinForms">
        Abra `Form1.cs` (o el archivo del formulario principal) y actualícelo de la siguiente manera:

        ```csharp Form1.cs lines theme={null}
        using Auth0.OidcClient;

        // Si eligió un nombre diferente para su aplicación,
        // asegúrese de actualizar el espacio de nombres según corresponda.
        namespace MyApp;

        public partial class Form1 : Form
        {
            private Auth0Client _client;

            public Form1()
            {
                InitializeComponent();

                _client = new Auth0Client(new Auth0ClientOptions
                {
                    Domain = "{yourDomain}",
                    ClientId = "{yourClientId}"
                });
            }
        }
        ```
      </Tab>
    </Tabs>
  </Step>

  <Step title="Agrega el inicio de sesión a tu aplicación" stepNumber={5}>
    Use el método `LoginAsync()` del SDK para iniciar sesión. Al llamarlo, se abre una ventana emergente con la página de Universal Login de Auth0. Después de autenticarse correctamente, Auth0 redirige a la URL de callback y el SDK devuelve un `LoginResult`.

    Primero, agregue un botón de inicio de sesión a la interfaz de usuario:

    <Tabs>
      <Tab title="WPF">
        Abra `MainWindow.xaml` y agregue un `Button` dentro de `<Grid>`:

        ```xml MainWindow.xaml lines theme={null}
        <Grid>
            <Button x:Name="LoginButton"
                    Content="Log In"
                    Width="120" Height="40"
                    HorizontalAlignment="Center" VerticalAlignment="Center"
                    Click="LoginButton_Click" />
        </Grid>
        ```

        Luego agregue el controlador del clic en `MainWindow.xaml.cs`:

        ```csharp MainWindow.xaml.cs lines theme={null}
        private async void LoginButton_Click(object sender, RoutedEventArgs e)
        {
            var loginResult = await _client.LoginAsync();

            if (loginResult.IsError == false)
            {
                var user = loginResult.User;
                var name = user.FindFirst(c => c.Type == "name")?.Value;
                var email = user.FindFirst(c => c.Type == "email")?.Value;
                var picture = user.FindFirst(c => c.Type == "picture")?.Value;
            }
        }
        ```
      </Tab>

      <Tab title="WinForms">
        Abra `Form1.cs` y agregue el botón de inicio de sesión mediante programación en el constructor; luego agregue el controlador del clic:

        ```csharp Form1.cs lines theme={null}
        using Auth0.OidcClient;

        namespace MyApp;

        public partial class Form1 : Form
        {
            private Auth0Client _client;
            private Button loginButton;

            public Form1()
            {
                InitializeComponent();

                _client = new Auth0Client(new Auth0ClientOptions
                {
                    Domain = "{yourDomain}",
                    ClientId = "{yourClientId}"
                });

                loginButton = new Button
                {
                    Text = "Log In",
                    Width = 120,
                    Height = 40,
                    Left = (ClientSize.Width - 120) / 2,
                    Top = (ClientSize.Height - 40) / 2
                };
                loginButton.Click += loginButton_Click;
                Controls.Add(loginButton);
            }

            private async void loginButton_Click(object sender, EventArgs e)
            {
                var loginResult = await _client.LoginAsync();

                if (loginResult.IsError == false)
                {
                    var user = loginResult.User;
                    var name = user.FindFirst(c => c.Type == "name")?.Value;
                    var email = user.FindFirst(c => c.Type == "email")?.Value;
                    var picture = user.FindFirst(c => c.Type == "picture")?.Value;
                }
            }
        }
        ```
      </Tab>
    </Tabs>

    Si no hay errores, puede acceder a `LoginResult.User`, `LoginResult.IdentityToken`, `LoginResult.AccessToken` y `LoginResult.RefreshToken` en el resultado.
  </Step>

  <Step title="Agregue el cierre de sesión a su aplicación" stepNumber={6}>
    Usa el método `LogoutAsync()` del SDK para cerrar la sesión de los usuarios. Esto abre una ventana emergente, redirige al endpoint de cierre de sesión de Auth0 para borrar la sesión y, a continuación, vuelve a redirigir a la URL de cierre de sesión que configuraste.

    Primero, agrega un botón de cierre de sesión a la interfaz de usuario:

    <Tabs>
      <Tab title="WPF">
        Abre `MainWindow.xaml` y agrega un `Button` de cierre de sesión junto al botón de inicio de sesión:

        ```xml MainWindow.xaml lines theme={null}
            <Grid>

                <StackPanel HorizontalAlignment="Center" VerticalAlignment="Center">
                    <Button x:Name="LoginButton" Content="Login" Width="200" Height="40" 
                            Margin="10" Click="LoginButton_Click" FontSize="16"/>
                    <Button x:Name="LogoutButton" Content="Logout" Width="200" Height="40" 
                            Margin="10" Click="LogoutButton_Click" FontSize="16"/>
                </StackPanel>
            </Grid>
        ```

        Luego, agrega el controlador del clic en `MainWindow.xaml.cs`:

        ```csharp MainWindow.xaml.cs lines theme={null}
        private async void LogoutButton_Click(object sender, RoutedEventArgs e)
        {
            await _client.LogoutAsync();
        }
        ```
      </Tab>

      <Tab title="WinForms">
        Abre `Form1.cs` y agrega el botón de cierre de sesión en el constructor; luego, agrega su controlador del clic:

        ```csharp Form1.cs lines theme={null}
        private Button logoutButton;

        public Form1()
        {
            // ... código existente del constructor ...

            logoutButton = new Button
            {
                Text = "Log Out",
                Width = 120,
                Height = 40,
                Left = (ClientSize.Width - 120) / 2,
                Top = (ClientSize.Height - 40) / 2 + 50
            };
            logoutButton.Click += logoutButton_Click;
            Controls.Add(logoutButton);
        }

        private async void logoutButton_Click(object sender, EventArgs e)
        {
            await _client.LogoutAsync();
        }
        ```
      </Tab>
    </Tabs>
  </Step>

  <Step title="Mostrar la información del perfil del usuario" stepNumber={7}>
    La propiedad `LoginResult.User` es un [ClaimsPrincipal](https://learn.microsoft.com/en-us/dotnet/api/system.security.claims.claimsprincipal) que contiene el perfil del usuario autenticado. Consulta las notificaciones para mostrar la información del usuario en tu aplicación.

    ```csharp lines theme={null}
    if (loginResult.IsError == false)
    {
        Debug.WriteLine($"name: {loginResult.User.FindFirst(c => c.Type == "name")?.Value}");
        Debug.WriteLine($"email: {loginResult.User.FindFirst(c => c.Type == "email")?.Value}");
    }
    ```

    Para ver todas las claims devueltas en el token de ID:

    ```csharp lines theme={null}
    if (loginResult.IsError == false)
    {
        foreach (var claim in loginResult.User.Claims)
        {
            Debug.WriteLine($"{claim.Type} = {claim.Value}");
        }
    }
    ```
  </Step>
</Steps>

<Check>
  **Punto de control**

  Ahora deberías tener una aplicación WPF o WinForms integrada con Auth0 y en funcionamiento. Ejecuta la aplicación y verifica lo siguiente:

  * Al hacer clic en el botón de inicio de sesión, se abre la página de Universal Login de Auth0 en una ventana emergente.
  * Puedes iniciar sesión o registrarte.
  * Después de la autenticación, puedes acceder a la información del usuario desde `LoginResult.User`.
  * Al hacer clic en el botón de cierre de sesión, se cierra la sesión y se te redirige a la URL de cierre de sesión.
</Check>

***

<div id="advanced-usage">
  ## Uso avanzado
</div>

<Accordion title="Gestionar errores de inicio de sesión">
  Comprueba `LoginResult.IsError` antes de acceder a los tokens o a las propiedades del usuario. Las propiedades `Error` y `ErrorDescription` contienen detalles cuando la autenticación falla.

  ```csharp lines theme={null}
  var loginResult = await _client.LoginAsync();

  if (loginResult.IsError)
  {
      Debug.WriteLine($"An error occurred during login: {loginResult.Error}");
      // loginResult.ErrorDescription contiene el mensaje de error completo
      return;
  }

  // Es seguro acceder aquí a los tokens y al usuario
  Debug.WriteLine($"id_token: {loginResult.IdentityToken}");
  Debug.WriteLine($"access_token: {loginResult.AccessToken}");
  ```

  Si el usuario cierra la ventana emergente de inicio de sesión sin autenticarse, `LoginAsync()` devuelve un resultado con `BrowserResultType.UserCancel`. Este comportamiento es esperado; no lo trates como un error.
</Accordion>

<Accordion title="Tokens de actualización">
  Para obtener un nuevo token de acceso sin que el usuario tenga que volver a iniciar sesión, usa `RefreshTokenAsync()` con el token de actualización del `LoginResult` inicial.

  ```csharp lines theme={null}
  // Solicita el scope offline_access para recibir un token de actualización
  _client = new Auth0Client(new Auth0ClientOptions
  {
      Domain = "{yourDomain}",
      ClientId = "{yourClientId}",
      Scope = "openid profile email offline_access"
  });

  // Almacena el token de actualización del inicio de sesión inicial
  var refreshToken = loginResult.RefreshToken;

  // Intercámbialo por nuevos tokens más adelante
  var refreshResult = await _client.RefreshTokenAsync(refreshToken);

  if (refreshResult.IsError == false)
  {
      var newAccessToken = refreshResult.AccessToken;
  }
  ```

  <Info>
    Los tokens de actualización requieren el scope `offline_access` y deben habilitarse en la configuración de tu aplicación de Auth0, en **Refresh Token Rotation**.
  </Info>
</Accordion>

***

<div id="additional-resources">
  ## Recursos adicionales
</div>

<CardGroup cols={3}>
  <Card title="Repositorio del SDK" icon="github" href="https://github.com/auth0/auth0-oidc-client-net">
    Código fuente, notas de lanzamiento y seguimiento de incidencias de Auth0 OIDC Client for .NET
  </Card>

  <Card title="Perfiles de usuario" icon="user" href="/es/docs/manage-users/user-accounts/user-profiles">
    Más información sobre las reclamaciones del perfil de usuario y el endpoint /userinfo
  </Card>

  <Card title="Foro de la comunidad" icon="comments" href="https://community.auth0.com/">
    Obtenga ayuda de la comunidad de Auth0
  </Card>
</CardGroup>

***

<div id="common-issues">
  ## Problemas comunes
</div>

<AccordionGroup>
  <Accordion title="La ventana emergente de inicio de sesión se abre, pero la autenticación nunca se completa">
    **Problema:** La ventana emergente de WebView2 se abre y muestra la página de inicio de sesión, pero después de introducir las credenciales no sucede nada.

    **Solución:** Microsoft Edge WebView2 Runtime no está instalado en el equipo. Instálalo desde la [página de descarga de Microsoft WebView2](https://developer.microsoft.com/en-us/microsoft-edge/webview2/). WebView2 viene incluido con Windows 11 y las versiones recientes de Windows 10, pero debe instalarse por separado en sistemas más antiguos.
  </Accordion>

  <Accordion title="Error de discrepancia en la URL de callback">
    **Problema:** Después de iniciar sesión, Auth0 devuelve un error `callback URL mismatch`.

    **Solución:** El URI de redirección que usa el SDK no coincide con ningún valor de **Allowed Callback URLs** en el Auth0 Dashboard. Agrega `https://{yourDomain}/mobile` a Allowed Callback URLs en la configuración de tu aplicación. El SDK usa esta URL de forma predeterminada.
  </Accordion>

  <Accordion title="Error de discrepancia en la URL de cierre de sesión">
    **Problema:** Después de cerrar sesión, Auth0 devuelve un error sobre una URL de cierre de sesión no reconocida.

    **Solución:** Agrega `https://{yourDomain}/mobile` a **Allowed Logout URLs** en la configuración de tu aplicación.
  </Accordion>

  <Accordion title="LoginResult.IsError es true después de iniciar sesión">
    **Problema:** `LoginResult.IsError` es `true`, pero no hay ninguna indicación clara de la causa.

    **Solución:** Revisa `LoginResult.Error` y `LoginResult.ErrorDescription` para obtener más información:

    ```csharp lines theme={null}
    if (loginResult.IsError)
    {
        Debug.WriteLine($"Error: {loginResult.Error}");
        Debug.WriteLine($"Description: {loginResult.ErrorDescription}");
    }
    ```

    Causas comunes:

    * El tipo de aplicación en el Auth0 Dashboard no está configurado como **Native**
    * **OIDC Conformant** no está habilitado en Advanced Settings → OAuth
    * **JSON Web Token Signature Algorithm** no está configurado como **RS256**
  </Accordion>

  <Accordion title="RefreshToken es null después de iniciar sesión">
    **Problema:** `LoginResult.RefreshToken` es `null`.

    **Solución:** El scope `offline_access` es necesario para recibir un Token de actualización. Agrégalo a la opción `Scope`:

    ```csharp lines theme={null}
    _client = new Auth0Client(new Auth0ClientOptions
    {
        Domain = "{yourDomain}",
        ClientId = "{yourClientId}",
        Scope = "openid profile email offline_access"
    });
    ```

    Asegúrate también de que **Refresh Token Rotation** esté habilitado en la configuración de tu aplicación en el Auth0 Dashboard.
  </Accordion>
</AccordionGroup>