> ## 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.

# Ajouter l’authentification à votre application WPF ou WinForms

> Ajoutez la connexion, la déconnexion et le profil utilisateur Auth0 à une application WPF ou WinForms à l’aide du client OIDC Auth0 pour .NET

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

<HowToSchema />

<Accordion title="Utiliser l’IA pour intégrer Auth0" icon="microchip-ai" iconType="solid" defaultOpen>
  Si vous utilisez un assistant de codage par IA comme Claude Code, Cursor ou GitHub Copilot, vous pouvez ajouter automatiquement l’authentification Auth0 en quelques minutes à l’aide des [agent skills](https://agentskills.io/home).

  **Installer :**

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

  **Ensuite, demandez à votre assistant IA :**

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

  Votre assistant IA créera automatiquement votre application Auth0, récupérera vos identifiants, installera le SDK Auth0 OidcClient, configurera les URL de rappel et implémentera les flux de connexion et de déconnexion. [Documentation complète sur les agent skills →](/fr-CA/docs/quickstart/agent-skills)
</Accordion>

<Note>
  **Prérequis :** Avant de commencer, assurez-vous de disposer des éléments suivants :

  * **[.NET 8.0 SDK](https://dotnet.microsoft.com/download/dotnet/8.0)** ou version ultérieure (ou .NET Framework 4.6.2 pour les projets existants)
  * **[Visual Studio 2022](https://visualstudio.microsoft.com/)** ou VS Code avec le kit de développement C#

  **Compatibilité des versions de .NET :** Ce guide de démarrage rapide fonctionne avec **.NET 8.0**, **.NET 9.0** et **.NET Framework 4.6.2**.
</Note>

<div id="get-started">
  ## Pour commencer
</div>

Ce guide de démarrage rapide explique comment ajouter l’authentification Auth0 à une application de bureau WPF ou WinForms. Vous configurerez Auth0, installerez le SDK et ajouterez la connexion, la déconnexion ainsi que l’affichage du profil de l’utilisateur à l’aide du client OIDC Auth0 pour [WPF](https://www.nuget.org/packages/Auth0.OidcClient.WPF/) et [WinForms](https://www.nuget.org/packages/Auth0.OidcClient.WinForms/).

<Steps>
  <Step title="Créez votre application" stepNumber={1}>
    Si vous avez déjà un projet WPF ou WinForms, passez à l’étape suivante.

    <Tabs>
      <Tab title=".NET CLI">
        Créez un projet, puis ouvrez son répertoire :

        <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. Ouvrez Visual Studio 2022, puis cliquez sur **Créer un projet**
        2. Recherchez **Application WPF** ou **Application Windows Forms**
        3. Sélectionnez le modèle C#, puis cliquez sur **Suivant**
        4. Saisissez un nom de projet et choisissez un emplacement, puis cliquez sur **Suivant**
        5. Sélectionnez **.NET 8.0** (ou une version ultérieure) comme framework cible, puis cliquez sur **Créer**
      </Tab>
    </Tabs>
  </Step>

  <Step title="Configurer Auth0" stepNumber={2}>
    Pour utiliser les services Auth0, vous devez avoir une application configurée dans Auth0 Dashboard. L’application Auth0 est l’endroit où vous configurez le fonctionnement de l’authentification pour votre projet.

    ### Configurer une application

    Accédez à [Auth0 Dashboard](https://manage.auth0.com) → **Applications** → **Applications** et créez une nouvelle application :

    1. Cliquez sur **Create Application**
    2. Saisissez un nom pour votre application
    3. Sélectionnez **Native** comme type d’application
    4. Cliquez sur **Create**

    Dans l’onglet **Settings**, notez votre **Domaine** et votre **ID client** — vous en aurez besoin pour initialiser le SDK.

    ### Configurer les URL de rappel

    Une URL de rappel est une URL de votre application vers laquelle Auth0 redirige les utilisateurs après leur authentification. Si elle n’est pas définie, les utilisateurs ne seront pas redirigés vers votre application après leur connexion.

    Dans les paramètres de votre application, ajoutez ce qui suit à **Allowed Callback URLs** :

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

    ### Configurer les URL de déconnexion

    Une URL de déconnexion est une URL de votre application vers laquelle Auth0 redirige les utilisateurs après leur déconnexion. Si elle n’est pas définie, les utilisateurs ne pourront pas se déconnecter de votre application et recevront un message d’erreur.

    Dans les paramètres de votre application, ajoutez les éléments suivants à **Allowed Logout URLs** :

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

  <Step title="Installer le SDK d’Auth0" stepNumber={3}>
    Auth0 propose des packages NuGet distincts pour WPF et WinForms. Installez celui qui correspond au type de votre projet.

    <Tabs>
      <Tab title="Gestionnaire de packages NuGet">
        Ouvrez la **Package Manager Console** (Tools → NuGet Package Manager → Package Manager Console), puis exécutez :

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

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

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

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

  <Step title="Créer une instance d’Auth0Client" stepNumber={4}>
    Pour intégrer Auth0 à votre application, instanciez un `Auth0Client` avec votre **Domaine** Auth0 et votre **ID client**. Ajoutez un champ privé et initialisez-le dans le constructeur existant de votre fenêtre principale ou de votre formulaire.

    <Tabs>
      <Tab title="WPF">
        Ouvrez `MainWindow.xaml.cs` et mettez-le à jour comme suit :

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

        // Si vous avez choisi un autre nom pour votre application,
        // assurez-vous de mettre à jour l'espace de noms en conséquence.
        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">
        Ouvrez `Form1.cs` (ou le fichier de votre formulaire principal) et mettez-le à jour comme suit :

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

        // Si vous avez choisi un autre nom pour votre application,
        // assurez-vous de mettre à jour l'espace de noms en conséquence.
        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="Ajoutez l’authentification à votre application" stepNumber={5}>
    Utilisez la méthode `LoginAsync()` du SDK pour ouvrir une session utilisateur. Lorsqu’elle est appelée, elle ouvre une fenêtre contextuelle affichant la page Universal Login d’Auth0. Une fois l’authentification réussie, Auth0 redirige vers l’URL de rappel et le SDK renvoie un `LoginResult`.

    Commencez par ajouter un bouton de connexion à votre interface utilisateur :

    <Tabs>
      <Tab title="WPF">
        Ouvrez `MainWindow.xaml` et ajoutez un `Button` dans `<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>
        ```

        Ajoutez ensuite le gestionnaire de clic dans `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">
        Ouvrez `Form1.cs` et ajoutez le bouton de connexion par programmation dans le constructeur, puis ajoutez le gestionnaire de 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>

    S’il n’y a pas d’erreur, vous pouvez accéder à `LoginResult.User`, `LoginResult.IdentityToken`, `LoginResult.AccessToken` et `LoginResult.RefreshToken` dans le résultat.
  </Step>

  <Step title="Ajoutez la déconnexion à votre application" stepNumber={6}>
    Utilisez la méthode `LogoutAsync()` du SDK pour déconnecter les utilisateurs. Cette opération ouvre une fenêtre contextuelle, redirige vers le point de terminaison de déconnexion d’Auth0 pour supprimer la session, puis vous redirige vers l’URL de déconnexion que vous avez configurée.

    Commencez par ajouter un bouton de déconnexion à votre interface utilisateur :

    <Tabs>
      <Tab title="WPF">
        Ouvrez `MainWindow.xaml` et ajoutez un `Button` de déconnexion à côté du bouton de connexion :

        ```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>
        ```

        Ajoutez ensuite le gestionnaire de clic dans `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">
        Ouvrez `Form1.cs` et ajoutez le bouton de déconnexion dans le constructeur, puis ajoutez son gestionnaire de clic :

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

        public Form1()
        {
            // ... code existant du constructeur ...

            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="Afficher les informations du profil de l’utilisateur" stepNumber={7}>
    La propriété `LoginResult.User` est un [ClaimsPrincipal](https://learn.microsoft.com/en-us/dotnet/api/system.security.claims.claimsprincipal) contenant le profil de l’utilisateur authentifié. Examinez les revendications pour afficher les renseignements sur l’utilisateur dans votre application.

    ```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}");
    }
    ```

    Pour voir toutes les revendications renvoyées dans l’ID Token :

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

<Check>
  **Point de contrôle**

  Vous devriez maintenant avoir une application WPF ou WinForms fonctionnelle intégrée à Auth0. Exécutez votre application et vérifiez que :

  * Un clic sur le bouton de connexion ouvre la page Universal Login d’Auth0 dans une fenêtre contextuelle.
  * Vous pouvez vous connecter ou vous inscrire.
  * Après l’authentification, vous pouvez accéder aux informations de l’utilisateur depuis `LoginResult.User`.
  * Un clic sur le bouton de déconnexion efface la session et vous redirige vers votre URL de déconnexion.
</Check>

***

<div id="advanced-usage">
  ## Utilisation avancée
</div>

<Accordion title="Gérer les erreurs de connexion">
  Vérifiez `LoginResult.IsError` avant d’accéder aux jetons ou aux propriétés de l’utilisateur. Les propriétés `Error` et `ErrorDescription` fournissent plus de détails lorsque l’authentification échoue.

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

  if (loginResult.IsError)
  {
      Debug.WriteLine($"An error occurred during login: {loginResult.Error}");
      // loginResult.ErrorDescription contient le message d’erreur complet
      return;
  }

  // Vous pouvez maintenant accéder aux jetons et à l’utilisateur en toute sécurité
  Debug.WriteLine($"id_token: {loginResult.IdentityToken}");
  Debug.WriteLine($"access_token: {loginResult.AccessToken}");
  ```

  Si l’utilisateur ferme la fenêtre de connexion sans s’authentifier, `LoginAsync()` renvoie un résultat avec `BrowserResultType.UserCancel`. Ce comportement est attendu — ne le traitez pas comme une erreur.
</Accordion>

<Accordion title="Jetons d’actualisation">
  Pour obtenir un nouveau jeton d’accès sans demander à l’utilisateur de se reconnecter, utilisez `RefreshTokenAsync()` avec le jeton d’actualisation obtenu dans le `LoginResult` initial.

  ```csharp lines theme={null}
  // Demandez le scope offline_access pour recevoir un jeton d’actualisation
  _client = new Auth0Client(new Auth0ClientOptions
  {
      Domain = "{yourDomain}",
      ClientId = "{yourClientId}",
      Scope = "openid profile email offline_access"
  });

  // Stockez le jeton d’actualisation de la connexion initiale
  var refreshToken = loginResult.RefreshToken;

  // Échangez-le plus tard contre de nouveaux jetons
  var refreshResult = await _client.RefreshTokenAsync(refreshToken);

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

  <Info>
    Les jetons d’actualisation nécessitent le scope `offline_access` et doivent être activés dans les paramètres de votre application Auth0, sous **Refresh Token Rotation**.
  </Info>
</Accordion>

***

<div id="additional-resources">
  ## Ressources supplémentaires
</div>

<CardGroup cols={3}>
  <Card title="Dépôt du SDK" icon="github" href="https://github.com/auth0/auth0-oidc-client-net">
    Code source, notes de version et suivi des problèmes pour le client OIDC Auth0 pour .NET
  </Card>

  <Card title="Profils d’utilisateur" icon="user" href="/fr-CA/docs/manage-users/user-accounts/user-profiles">
    En savoir plus sur les revendications du profil utilisateur et le point de terminaison /userinfo
  </Card>

  <Card title="Forum communautaire" icon="comments" href="https://community.auth0.com/">
    Obtenez de l’aide de la communauté Auth0
  </Card>
</CardGroup>

***

<div id="common-issues">
  ## Problèmes courants
</div>

<AccordionGroup>
  <Accordion title="La fenêtre contextuelle de connexion s’ouvre, mais l’authentification ne se termine jamais">
    **Problème :** La fenêtre contextuelle WebView2 s’ouvre et affiche la page de connexion, mais après la saisie des identifiants, rien ne se passe.

    **Solution :** Le runtime Microsoft Edge WebView2 n’est pas installé sur la machine. Installez-le à partir de la [page de téléchargement de Microsoft WebView2](https://developer.microsoft.com/en-us/microsoft-edge/webview2/). WebView2 est fourni avec Windows 11 et les versions récentes de Windows 10, mais doit être installé séparément sur les systèmes plus anciens.
  </Accordion>

  <Accordion title="Erreur de non-correspondance de l’URL de rappel">
    **Problème :** Après la connexion, Auth0 renvoie une erreur `callback URL mismatch`.

    **Solution :** L’URI de redirection utilisée par le SDK ne correspond à aucune des valeurs configurées dans **Allowed Callback URLs** de l’Auth0 Dashboard. Ajoutez `https://{yourDomain}/mobile` à **Allowed Callback URLs** dans les paramètres de votre application. Le SDK utilise cette URL par défaut.
  </Accordion>

  <Accordion title="Erreur de non-correspondance de l’URL de déconnexion">
    **Problème :** Après la déconnexion, Auth0 renvoie une erreur indiquant que l’URL de déconnexion n’est pas reconnue.

    **Solution :** Ajoutez `https://{yourDomain}/mobile` à **Allowed Logout URLs** dans les paramètres de votre application.
  </Accordion>

  <Accordion title="LoginResult.IsError est true après la connexion">
    **Problème :** `LoginResult.IsError` est `true`, mais la cause n’est pas clairement indiquée.

    **Solution :** Vérifiez `LoginResult.Error` et `LoginResult.ErrorDescription` pour plus de détails :

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

    Causes courantes :

    * Le type d’application dans l’Auth0 Dashboard n’est pas défini sur **Native**
    * **OIDC Conformant** n’est pas activé sous Advanced Settings → OAuth
    * **JSON Web Token Signature Algorithm** n’est pas défini sur **RS256**
  </Accordion>

  <Accordion title="RefreshToken est null après la connexion">
    **Problème :** `LoginResult.RefreshToken` est `null`.

    **Solution :** Le scope `offline_access` est requis pour recevoir un jeton d’actualisation. Ajoutez-le à l’option `Scope` :

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

    Assurez-vous également que **Refresh Token Rotation** est activé dans les paramètres de votre application dans l’Auth0 Dashboard.
  </Accordion>
</AccordionGroup>