Icône de message
Passer au contenu du pied de page
  1. IronPDF
  2. Blog IronPDF
  3. .NET Aide
  4. Dotnetopenauth .NET Core
.NET AIDE

Dotnetopenauth .NET Core (Fonctionnement pour développeurs)

Curtis Chau
Curtis Chau
Mis à jour:

DotNetOpenAuth .NET Core est une version de la bibliothèque DotNetOpenAuth originale adaptée pour .NET Core, fournissant une API publique robuste. Cette bibliothèque vous aide à ajouter l'authentification avec OAuth2 et OpenID à vos applications .NET. IronPDF est une bibliothèque pour créer, lire et éditer des fichiers PDF dans .NET. Elle est utile pour générer des documents tels que des rapports et des factures directement depuis vos applications .NET.

Vous pouvez utiliser DotNetOpenAuth .NET Core et IronPDF dans divers types de projets, tels que les applications web et de bureau, pour tirer parti du code partagé et implémenter de nouvelles fonctionnalités. Ils sont essentiels pour les développeurs cherchant à gérer l'authentification et la gestion de documents PDF dans leur logiciel.

Commencer avec DotNetOpenAuth .NET Core

Configurer DotNetOpenAuth .NET Core dans les projets .NET

Pour commencer à utiliser DotNetOpenAuth .NET Core dans vos projets .NET, soutenus par les technologies Microsoft, suivez ces étapes :

  1. Ouvrez votre projet dans Visual Studio.
  2. Allez dans l'Explorateur de solutions.
  3. Faites un clic droit sur le nom de votre projet.
  4. Sélectionnez Gérer les packages NuGet.
  5. Dans le Gestionnaire de packages NuGet, recherchez DotNetOpenAuth.NetCore et d'autres packages NuGet.
  6. Cliquez sur Installer pour l'ajouter à votre projet.

Cela ajoutera la bibliothèque DotNetOpenAuth .NET Core à votre projet, fournissant un support pour l'intégration des fonctionnalités d'authentification.

Un exemple de code de base utilisant DotNetOpenAuth .NET Core

Voici un exemple simple montrant comment mettre en place l'authentification OAuth2 dans votre application en utilisant DotNetOpenAuth .NET Core :

using DotNetOpenAuth.OAuth2;

// Initialize the OAuth2 client with the authorization server details
var client = new WebServerClient(new AuthorizationServerDescription
{
    TokenEndpoint = new Uri("https://your-auth-server.com/token"),
    AuthorizationEndpoint = new Uri("https://your-auth-server.com/authorize")
}, "your-client-id", "your-client-secret");

// Start the authentication process and get the authorization state
IAuthorizationState state = client.ProcessUserAuthorization();
if (state != null && state.IsAuthorized)
{
    // Authorized successfully, now you can access protected resources
}
using DotNetOpenAuth.OAuth2;

// Initialize the OAuth2 client with the authorization server details
var client = new WebServerClient(new AuthorizationServerDescription
{
    TokenEndpoint = new Uri("https://your-auth-server.com/token"),
    AuthorizationEndpoint = new Uri("https://your-auth-server.com/authorize")
}, "your-client-id", "your-client-secret");

// Start the authentication process and get the authorization state
IAuthorizationState state = client.ProcessUserAuthorization();
if (state != null && state.IsAuthorized)
{
    // Authorized successfully, now you can access protected resources
}
Imports DotNetOpenAuth.OAuth2

' Initialize the OAuth2 client with the authorization server details
Private client = New WebServerClient(New AuthorizationServerDescription With {
	.TokenEndpoint = New Uri("https://your-auth-server.com/token"),
	.AuthorizationEndpoint = New Uri("https://your-auth-server.com/authorize")
}, "your-client-id", "your-client-secret")

' Start the authentication process and get the authorization state
Private state As IAuthorizationState = client.ProcessUserAuthorization()
If state IsNot Nothing AndAlso state.IsAuthorized Then
	' Authorized successfully, now you can access protected resources
End If
$vbLabelText   $csharpLabel

Cet extrait de code configure un client OAuth2 avec DotNetOpenAuth .NET Core, se connecte à un serveur d'autorisation et traite l'autorisation de l'utilisateur.

Implémenter les fonctionnalités de DotNetOpenAuth .NET Core

Intégrer OpenID Connect

Pour intégrer OpenID Connect en utilisant DotNetOpenAuth .NET Core, vous pouvez suivre cette approche de base :

using DotNetOpenAuth.OAuth2;

// Configure the OpenID Connect client with authority details
var openIdClient = new WebServerClient(new AuthorizationServerDescription
{
    TokenEndpoint = new Uri("https://your-openid-provider.com/token"),
    AuthorizationEndpoint = new Uri("https://your-openid-provider.com/authorize")
}, "your-client-id");

// Redirect user for authentication
Uri authUri = openIdClient.GetAuthorizationRequestUri("openid email profile");
Response.Redirect(authUri.AbsoluteUri);
using DotNetOpenAuth.OAuth2;

// Configure the OpenID Connect client with authority details
var openIdClient = new WebServerClient(new AuthorizationServerDescription
{
    TokenEndpoint = new Uri("https://your-openid-provider.com/token"),
    AuthorizationEndpoint = new Uri("https://your-openid-provider.com/authorize")
}, "your-client-id");

// Redirect user for authentication
Uri authUri = openIdClient.GetAuthorizationRequestUri("openid email profile");
Response.Redirect(authUri.AbsoluteUri);
Imports DotNetOpenAuth.OAuth2

' Configure the OpenID Connect client with authority details
Private openIdClient = New WebServerClient(New AuthorizationServerDescription With {
	.TokenEndpoint = New Uri("https://your-openid-provider.com/token"),
	.AuthorizationEndpoint = New Uri("https://your-openid-provider.com/authorize")
}, "your-client-id")

' Redirect user for authentication
Private authUri As Uri = openIdClient.GetAuthorizationRequestUri("openid email profile")
Response.Redirect(authUri.AbsoluteUri)
$vbLabelText   $csharpLabel

Ce code configure un client OpenID Connect et redirige l'utilisateur vers la page d'authentification du fournisseur OpenID.

Gérer les jetons d'accès

Voici comment vous pouvez gérer les jetons d'accès avec DotNetOpenAuth .NET Core :

// After the user is authenticated, process the authorization response to retrieve the token
IAuthorizationState authState = openIdClient.ProcessUserAuthorization();
if (authState != null && authState.IsAuthorized)
{
    // Access token is available, and you can use it to make authenticated requests
    string accessToken = authState.AccessToken;
}
// After the user is authenticated, process the authorization response to retrieve the token
IAuthorizationState authState = openIdClient.ProcessUserAuthorization();
if (authState != null && authState.IsAuthorized)
{
    // Access token is available, and you can use it to make authenticated requests
    string accessToken = authState.AccessToken;
}
' After the user is authenticated, process the authorization response to retrieve the token
Dim authState As IAuthorizationState = openIdClient.ProcessUserAuthorization()
If authState IsNot Nothing AndAlso authState.IsAuthorized Then
	' Access token is available, and you can use it to make authenticated requests
	Dim accessToken As String = authState.AccessToken
End If
$vbLabelText   $csharpLabel

Cet extrait traite la réponse d'autorisation de l'utilisateur pour récupérer et utiliser le jeton d'accès.

Rafraîchir les jetons

Pour rafraîchir les jetons quand ils expirent, utilisez le code suivant :

// Check if the access token is expired and refresh it
if (authState.AccessTokenExpirationUtc <= DateTime.UtcNow)
{
    if (openIdClient.RefreshAuthorization(authState))
    {
        // Token refreshed successfully
    }
}
// Check if the access token is expired and refresh it
if (authState.AccessTokenExpirationUtc <= DateTime.UtcNow)
{
    if (openIdClient.RefreshAuthorization(authState))
    {
        // Token refreshed successfully
    }
}
' Check if the access token is expired and refresh it
If authState.AccessTokenExpirationUtc <= DateTime.UtcNow Then
	If openIdClient.RefreshAuthorization(authState) Then
		' Token refreshed successfully
	End If
End If
$vbLabelText   $csharpLabel

Ce code vérifie si le jeton actuel a expiré et tente de le rafraîchir.

Révoquer les jetons

Si vous avez besoin de révoquer des jetons, implémentez-le comme montré ci-dessous :

// Revoke the access token
bool success = openIdClient.RevokeAuthorization(authState);
if (success)
{
    // Token revoked successfully
}
// Revoke the access token
bool success = openIdClient.RevokeAuthorization(authState);
if (success)
{
    // Token revoked successfully
}
' Revoke the access token
Dim success As Boolean = openIdClient.RevokeAuthorization(authState)
If success Then
	' Token revoked successfully
End If
$vbLabelText   $csharpLabel

Cet extrait révoque l'autorisation, invalidant ainsi le jeton d'accès.

Personnaliser les requêtes de jetons

Pour personnaliser les requêtes de jetons pour des besoins spécifiques, tels que l'ajout de paramètres supplémentaires :

// Customize the token request with additional parameters
var additionalParams = new Dictionary<string, string>
{
    {"custom_parameter", "value"}
};
IAuthorizationState customizedState = openIdClient.ProcessUserAuthorization(additionalParams);
if (customizedState != null && customizedState.IsAuthorized)
{
    // Token request customized and processed successfully
}
// Customize the token request with additional parameters
var additionalParams = new Dictionary<string, string>
{
    {"custom_parameter", "value"}
};
IAuthorizationState customizedState = openIdClient.ProcessUserAuthorization(additionalParams);
if (customizedState != null && customizedState.IsAuthorized)
{
    // Token request customized and processed successfully
}
' Customize the token request with additional parameters
Dim additionalParams = New Dictionary(Of String, String) From {
	{"custom_parameter", "value"}
}
Dim customizedState As IAuthorizationState = openIdClient.ProcessUserAuthorization(additionalParams)
If customizedState IsNot Nothing AndAlso customizedState.IsAuthorized Then
	' Token request customized and processed successfully
End If
$vbLabelText   $csharpLabel

Ce code ajoute des paramètres personnalisés à la requête de jeton, ce qui peut être utile pour faire face aux exigences spécifiques d'un serveur d'autorisation.

DotNetOpenAuth .NET Core avec IronPDF

IronPDF est une bibliothèque complète qui permet aux développeurs de créer, lire et manipuler des fichiers PDF dans les environnements .NET. Elle est particulièrement utile pour générer des PDFs à partir de HTML ou directement à partir d'URLs, ce qui peut être excellent pour les rapports, la génération de factures ou simplement le stockage de pages web dans un format statique. Lorsqu'elle est intégrée à DotNetOpenAuth .NET Core, elle garantit que ces capacités sont sécurisées et accessibles uniquement aux utilisateurs authentifiés.

Cas d'utilisation de la fusion d'IronPDF avec DotNetOpenAuth .NET Core

Un cas d'utilisation pratique pour fusionner IronPDF avec DotNetOpenAuth .NET Core est dans une application web où les utilisateurs authentifiés ont besoin de générer et télécharger des rapports personnalisés. Par exemple, imaginez un scénario dans lequel les utilisateurs se connectent à votre application et accèdent à leurs rapports financiers sous forme de PDFs. DotNetOpenAuth s'assure que les utilisateurs sont correctement authentifiés et autorisés à accéder à leurs documents, tandis qu'IronPDF gère la création et la livraison de ces PDFs personnalisés.

Exemple de code de cas d'utilisation

Voyons un exemple de code complet qui démontre comment implémenter cela. Nous créerons une API web simple dans .NET Core qui authentifie un utilisateur puis génère un rapport PDF en utilisant IronPDF :

using IronPdf;
using Microsoft.AspNetCore.Mvc;
using Microsoft.AspNetCore.Authorization;

[Route("api/[controller]")]
[ApiController]
public class ReportController : ControllerBase
{
    [Authorize]
    [HttpGet("download-pdf")]
    public IActionResult DownloadPdfReport()
    {
        // Authentication is handled by DotNetOpenAuth .NET Core
        var currentUser = HttpContext.User.Identity.Name;

        // Generate PDF content using IronPDF
        var Renderer = new ChromePdfRenderer();
        var PDF = Renderer.RenderHtmlAsPdf($"<h1>Report for {currentUser}</h1><p>This is your personalized financial report.</p>");

        // Set file name and content type for the PDF
        var outputFileName = $"Report-{currentUser}.pdf";
        Response.Headers.Add("Content-Disposition", $"attachment; filename={outputFileName}");
        Response.ContentType = "application/pdf";

        // Return the generated PDF file
        return File(PDF.Stream.ToArray(), "application/pdf");
    }
}
using IronPdf;
using Microsoft.AspNetCore.Mvc;
using Microsoft.AspNetCore.Authorization;

[Route("api/[controller]")]
[ApiController]
public class ReportController : ControllerBase
{
    [Authorize]
    [HttpGet("download-pdf")]
    public IActionResult DownloadPdfReport()
    {
        // Authentication is handled by DotNetOpenAuth .NET Core
        var currentUser = HttpContext.User.Identity.Name;

        // Generate PDF content using IronPDF
        var Renderer = new ChromePdfRenderer();
        var PDF = Renderer.RenderHtmlAsPdf($"<h1>Report for {currentUser}</h1><p>This is your personalized financial report.</p>");

        // Set file name and content type for the PDF
        var outputFileName = $"Report-{currentUser}.pdf";
        Response.Headers.Add("Content-Disposition", $"attachment; filename={outputFileName}");
        Response.ContentType = "application/pdf";

        // Return the generated PDF file
        return File(PDF.Stream.ToArray(), "application/pdf");
    }
}
Imports IronPdf
Imports Microsoft.AspNetCore.Mvc
Imports Microsoft.AspNetCore.Authorization

<Route("api/[controller]")>
<ApiController>
Public Class ReportController
	Inherits ControllerBase

	<Authorize>
	<HttpGet("download-pdf")>
	Public Function DownloadPdfReport() As IActionResult
		' Authentication is handled by DotNetOpenAuth .NET Core
		Dim currentUser = HttpContext.User.Identity.Name

		' Generate PDF content using IronPDF
		Dim Renderer = New ChromePdfRenderer()
		Dim PDF = Renderer.RenderHtmlAsPdf($"<h1>Report for {currentUser}</h1><p>This is your personalized financial report.</p>")

		' Set file name and content type for the PDF
		Dim outputFileName = $"Report-{currentUser}.pdf"
		Response.Headers.Add("Content-Disposition", $"attachment; filename={outputFileName}")
		Response.ContentType = "application/pdf"

		' Return the generated PDF file
		Return File(PDF.Stream.ToArray(), "application/pdf")
	End Function
End Class
$vbLabelText   $csharpLabel

Dans cet exemple, nous utilisons l'attribut [Authorize] pour nous assurer que seuls les utilisateurs authentifiés peuvent accéder au point de terminaison de génération de PDF. La classe ChromePdfRenderer de IronPDF est utilisée pour créer un PDF à partir de contenu HTML, qui dans ce cas, est personnalisé dynamiquement avec le nom de l'utilisateur.

DotNetOpenAuth .NET Core (Comment cela fonctionne pour les développeurs) : Figure 1

Conclusion

Intégrer DotNetOpenAuth .NET Core avec IronPDF offre une solution puissante pour améliorer la sécurité et la fonctionnalité de vos applications .NET. En tirant parti de ces technologies, vous pouvez protéger efficacement les données sensibles et offrir une expérience utilisateur personnalisée grâce à la génération dynamique de PDFs.

IronPDF n'est pas seulement polyvalent mais aussi convivial pour les développeurs, offrant une approche simple pour créer et gérer des fichiers PDF dans les applications .NET. Si vous envisagez d'intégrer IronPDF dans votre projet, il est recommandé d'explorer le site officiel de IronPDF pour un essai gratuit et des options de licence.

Questions Fréquemment Posées

À quoi sert DotNetOpenAuth .NET Core ?

DotNetOpenAuth .NET Core est utilisé pour intégrer les fonctionnalités d'authentification OAuth2 et OpenID dans les applications .NET, permettant des processus d'authentification sécurisés dans les environnements web et de bureau.

Comment puis-je ajouter l'authentification OAuth2 à mon application .NET ?

Pour ajouter l'authentification OAuth2, utilisez DotNetOpenAuth .NET Core pour initialiser un WebServerClient avec les détails de votre serveur d'autorisation, puis guidez les utilisateurs à travers le processus d'authentification et gérez leur réponse d'autorisation.

Puis-je créer des PDF dans une application .NET avec authentification ?

Oui, en intégrant DotNetOpenAuth .NET Core pour l'authentification et IronPDF pour la génération de PDF, vous pouvez créer des documents PDF sécurisés et authentifiés tels que des rapports personnalisés et des factures.

Comment gérer les jetons d'accès dans une application .NET ?

DotNetOpenAuth .NET Core gère les jetons d'accès en traitant les réponses d'autorisation, vous permettant de récupérer et d'utiliser des jetons d'accès pour des requêtes sécurisées et authentifiées.

Comment puis-je rafraîchir un jeton d'accès dans .NET Core ?

Pour rafraîchir un jeton d'accès dans .NET Core, vérifiez si le jeton a expiré et utilisez la méthode `RefreshAuthorization` pour obtenir un nouveau jeton, assurant un accès sécurisé continu.

Quel est l'avantage d'intégrer DotNetOpenAuth avec la génération de PDF ?

L'intégration de DotNetOpenAuth avec la génération de PDF permet un accès sécurisé aux documents sensibles, en permettant aux utilisateurs authentifiés de générer et de télécharger des PDF personnalisés, tels que des rapports et des factures.

Comment révoquer des jetons dans une application .NET ?

Révoquez les jetons en implémentant la méthode `RevokeAuthorization` dans DotNetOpenAuth .NET Core, ce qui invalide le jeton d'accès, empêchant les requêtes non autorisées ultérieures.

Comment les requêtes de jetons peuvent-elles être personnalisées dans l'authentification .NET ?

Vous pouvez personnaliser les requêtes de jetons en ajoutant des paramètres supplémentaires au code de traitement des jetons pour répondre aux exigences spécifiques de votre serveur d'autorisation.

Quelles sont les étapes à suivre pour configurer OpenID Connect dans un projet .NET ?

Pour configurer OpenID Connect, configurez un client OpenID Connect avec les détails d'autorité requis et dirigez les utilisateurs à s'authentifier via le fournisseur OpenID, en intégrant DotNetOpenAuth .NET Core pour une authentification transparente.

Curtis Chau
Curtis Chau
  Discutez maintenant avec l'équipe d'ingénierie
Rédacteur technique

Curtis Chau détient un baccalauréat en informatique (Université de Carleton) et se spécialise dans le développement front-end avec expertise en Node.js, TypeScript, JavaScript et React. Passionné par la création d'interfaces utilisateur intuitives et esthétiquement plaisantes, Curtis aime travailler avec des frameworks modernes ...

Lire la suite

Articles connexes

Essai de 30 jours → Produit complet. Pas de limites. Pas de carte. Démarrer l'essai gratuit