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

Utilisez l’IA pour intégrer Auth0

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.

Installer :

npx skills add auth0/agent-skills --skill auth0

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

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

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

​

Pour commencer

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

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

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

   Gestionnaire de packages NuGet

   Ouvrez la Package Manager Console (Tools → NuGet Package Manager → Package Manager Console) et 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 à 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.

   WPF

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

   MainWindow.xaml.cs

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

   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 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}"
           });
       }
   }
   
5. Ajouter la connexion à votre application

   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 :

   WPF

   Ouvrez MainWindow.xaml et ajoutez un Button à l’intérieur de <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. Ajouter la déconnexion à votre application

   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 :

   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()
   {
       // ... 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();
   }
   
7. Afficher les renseignements du profil utilisateur

   La propriété LoginResult.User est un ClaimsPrincipal qui contient le profil de l’utilisateur authentifié. Interrogez les claims afin d’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 claims renvoyées dans l’ID token :

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

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.

---

​

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 contiennent des renseignements 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 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.

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.

// 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 Application Settings 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 Auth0 OIDC Client for .NET

Profils utilisateur

Découvrez les claims de profil utilisateur et le point de terminaison /userinfo

Forum communautaire

Obtenez de l’aide auprès 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 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. 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.

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.

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.

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

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 vos Application Settings de l’Auth0 Dashboard.