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

Utiliser l’IA pour intégrer Auth0

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.

Installer :

npx skills add auth0/agent-skills --skill auth0-quickstart --skill auth0-wpf --skill auth0-winforms

Ensuite, demandez à votre assistant IA :

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 →

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

• .NET 8.0 SDK ou version ultérieure (ou .NET Framework 4.6.2 pour les projets existants)
• Visual Studio 2022 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.

​

Pour commencer

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 et WinForms.

1. Créez votre application

   Si vous avez déjà un projet WPF ou WinForms, passez à l’étape suivante.

   .NET CLI

   Créez un projet, puis ouvrez son répertoire :

   WPF

   dotnet new wpf -n MyApp
   cd MyApp
   

   WinForms

   dotnet new winforms -n MyApp
   cd MyApp
   

   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
2. Configurer Auth0

   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 → 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
   
3. Installer le SDK d’Auth0

   Auth0 propose des packages NuGet distincts pour WPF et WinForms. Installez celui qui correspond au type de votre projet.

   Gestionnaire de packages NuGet

   Ouvrez la Package Manager Console (Tools → NuGet Package Manager → Package Manager Console), puis exécutez :

   # WPF
   Install-Package Auth0.OidcClient.WPF
   
   # WinForms
   Install-Package Auth0.OidcClient.WinForms
   

   .NET CLI

   # WPF
   dotnet add package Auth0.OidcClient.WPF
   
   # WinForms
   dotnet add package Auth0.OidcClient.WinForms
   
4. Créer une instance d’Auth0Client

   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.

   WPF

   Ouvrez MainWindow.xaml.cs et mettez-le à jour comme suit :

   MainWindow.xaml.cs

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

   WinForms

   Ouvrez Form1.cs (ou le fichier de votre formulaire principal) et mettez-le à jour comme suit :

   Form1.cs

   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}"
           });
       }
   }
   
5. Ajoutez l’authentification à votre application

   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 :

   WPF

   Ouvrez MainWindow.xaml et ajoutez un Button dans <Grid> :

   MainWindow.xaml

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

   MainWindow.xaml.cs

   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;
       }
   }
   

   WinForms

   Ouvrez Form1.cs et ajoutez le bouton de connexion par programmation dans le constructeur, puis ajoutez le gestionnaire de clic :

   Form1.cs

   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;
           }
       }
   }
   

   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.

6. Ajoutez la déconnexion à votre application

   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 :

   WPF

   Ouvrez MainWindow.xaml et ajoutez un Button de déconnexion à côté du bouton de connexion :

   MainWindow.xaml

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

   MainWindow.xaml.cs

   private async void LogoutButton_Click(object sender, RoutedEventArgs e)
   {
       await _client.LogoutAsync();
   }
   

   WinForms

   Ouvrez Form1.cs et ajoutez le bouton de déconnexion dans le constructeur, puis ajoutez son gestionnaire de clic :

   Form1.cs

   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();
   }
   
7. Afficher les informations du profil de l’utilisateur

   La propriété LoginResult.User est un ClaimsPrincipal contenant le profil de l’utilisateur authentifié. Examinez les revendications pour afficher les renseignements sur l’utilisateur dans votre application.

   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 :

   if (loginResult.IsError == false)
   {
       foreach (var claim in loginResult.User.Claims)
       {
           Debug.WriteLine($"{claim.Type} = {claim.Value}");
       }
   }
   

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.

---

​

Utilisation avancée

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.

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.

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.

// 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;
}

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.

---

​

Ressources supplémentaires

Dépôt du SDK

Code source, notes de version et suivi des problèmes pour le client OIDC Auth0 pour .NET

Profils d’utilisateur

En savoir plus sur les revendications du profil utilisateur et le point de terminaison /userinfo

Forum communautaire

Obtenez de l’aide de la communauté Auth0

---

​

Problèmes courants

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

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.

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.

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 :

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

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 :

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