> ## 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 la connexion à votre application WPF ou WinForms

> Ajoutez Auth0 connexion, déconnexion et le profil utilisateur à votre application WPF ou WinForms à l’aide d’Auth0 OIDC Client for .NET

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

<HowToSchema />

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

  **Installer :**

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

  **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 les identifiants, installera le SDK Auth0 OidcClient, configurera les URL de rappel et mettra en place les flux de connexion et de déconnexion. [Documentation complète sur Agent Skills →](/docs/fr-ca/quickstart/agent-skills)
</Accordion>

<Note>
  **Prérequis :** Avant de commencer, assurez-vous d’avoir ce qui suit :

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

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

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

Ce Quickstart montre comment ajouter l’authentification Auth0 à une application de bureau WPF ou WinForms. Vous configurerez Auth0, installerez le SDK et ajouterez le login, le logout, ainsi que l’affichage du profil utilisateur à l’aide d’Auth0 OIDC Client 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 et 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 et cliquez sur **Créer un projet**
        2. Recherchez **Application WPF** ou **Application Windows Forms**
        3. Sélectionnez le modèle C# et cliquez sur **Suivant**
        4. Entrez 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 l’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 **Domain** et votre **Client ID** — 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 s’être connectés.

    Dans vos **Application Settings**, 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 une fois déconnectés. Si elle n’est pas définie, les utilisateurs ne pourront pas se déconnecter de votre application et verront un message d’erreur.

    Dans les **Paramètres de l’application**, ajoutez ce qui suit aux **URL de déconnexion autorisées** :

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

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

    <Tabs>
      <Tab title="Gestionnaire de packages NuGet">
        Ouvrez la **Package Manager Console** (Tools → NuGet Package Manager → Package Manager Console) et 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` à l’aide de votre **Domain** Auth0 et de votre **Client ID**. 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 nom différent 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 nom différent 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="Ajouter la connexion à votre application" stepNumber={5}>
    Utilisez la méthode `LoginAsync()` du SDK pour permettre aux utilisateurs de se connecter. Lorsqu’elle est appelée, elle ouvre une fenêtre contextuelle contenant la page Auth0 Universal Login. Après une authentification réussie, Auth0 redirige vers l’URL de rappel, et le SDK renvoie un `LoginResult`.

    D’abord, ajoutez un bouton de connexion à votre interface utilisateur :

    <Tabs>
      <Tab title="WPF">
        Ouvrez `MainWindow.xaml` et ajoutez un `Button` à l’intérieur 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>
        ```

        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="Ajouter la déconnexion à votre application" stepNumber={6}>
    Utilisez la méthode `LogoutAsync()` du SDK pour déconnecter les utilisateurs. Cela ouvre une fenêtre contextuelle, redirige vers le point de terminaison de logout d’Auth0 pour effacer la session, puis redirige de nouveau vers l’URL de logout 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()
        {
            // ... existing constructor code ...

            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 renseignements du profil utilisateur" stepNumber={7}>
    La propriété `LoginResult.User` est un [ClaimsPrincipal](https://learn.microsoft.com/en-us/dotnet/api/system.security.claims.claimsprincipal) qui contient le profil de l’utilisateur authentifié. Interrogez les claims afin d’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 claims 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>
  **Vérification**

  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 Auth0 Universal Login dans une fenêtre contextuelle.
  * Vous pouvez vous connecter ou vous inscrire.
  * Après l’authentification, vous pouvez accéder aux renseignements de l’utilisateur dans `LoginResult.User`.
  * Un clic sur le bouton de déconnexion met fin à la session et 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` contiennent des renseignements 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 accéder aux jetons et à l’utilisateur ici en toute sécurité
  Debug.WriteLine($"id_token: {loginResult.IdentityToken}");
  Debug.WriteLine($"access_token: {loginResult.AccessToken}");
  ```

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

<Accordion title="Jetons d’actualisation">
  Pour obtenir un nouveau jeton d’accès sans obliger l’utilisateur à se connecter de nouveau, utilisez `RefreshTokenAsync()` avec le jeton d’actualisation du `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 Application Settings 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 Auth0 OIDC Client for .NET
  </Card>

  <Card title="Profils utilisateur" icon="user" href="/docs/fr-ca/manage-users/user-accounts/user-profiles">
    Découvrez les claims de profil utilisateur et le point de terminaison /userinfo
  </Card>

  <Card title="Forum communautaire" icon="comments" href="https://community.auth0.com/">
    Obtenez de l’aide auprès 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 avoir entré les 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 inclus 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 :** La Redirect URI utilisée par le SDK ne correspond à aucune des valeurs dans **Allowed Callback URLs** de votre Auth0 Dashboard. Ajoutez `https://{yourDomain}/mobile` à Allowed Callback URLs dans vos Application Settings. 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 une URL de déconnexion non reconnue.

    **Solution :** Ajoutez `https://{yourDomain}/mobile` à **Allowed Logout URLs** dans vos Application Settings.
  </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 fréquentes :

    * Le type d’Application dans l’Auth0 Dashboard n’est pas défini sur **Native**
    * **OIDC Conformant** n’est pas activé dans Advanced Settings → OAuth
    * L’**algorithme de signature JSON Web Token** 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 vos Application Settings de l’Auth0 Dashboard.
  </Accordion>
</AccordionGroup>