AIDE .NET

Dotnetopenauth .NET Core (Comment ça marche pour les développeurs)

Regan Pun

juillet 1, 2024

DotNetOpenAuth .NET Core est une version de la bibliothèque originale DotNetOpenAuth adaptée à .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 permettant de créer, de lire et d'éditer des fichiers PDF en .NET. Il est utile pour générer des documents tels que des rapports et des factures directement à partir de vos applications .NET.

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

Démarrer avec DotNetOpenAuth .NET Core

Mise en place de DotNetOpenAuth .NET Core dans les projets .NET

Pour commencer à utiliser DotNetOpenAuth .NET Core dans vos projets .NET, pris en charge par les technologies Microsoft, suivez les étapes suivantes :

Ouvrez votre projet dans Visual Studio.
Accédez à l'explorateur de solutions.
Cliquez avec le bouton droit de la souris sur le nom de votre projet.
Sélectionnez Manage NuGet Packages.
Dans le gestionnaire de paquets NuGet, recherchez DotNetOpenAuth.NetCore et d'autres paquets NuGet.
Cliquez sur Install 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.

Exemple de code de base utilisant DotNetOpenAuth .NET Core

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

using DotNetOpenAuth.OAuth2;

// Initialize the OAuth2 client
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
IAuthorizationState state = client.ProcessUserAuthorization();
if (state != null && state.IsAuthorized)
{
    // Authorized successfully, now you can access protected resources
}

using DotNetOpenAuth.OAuth2;

// Initialize the OAuth2 client
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
IAuthorizationState state = client.ProcessUserAuthorization();
if (state != null && state.IsAuthorized)
{
    // Authorized successfully, now you can access protected resources
}

Imports DotNetOpenAuth.OAuth2

' Initialize the OAuth2 client
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
Private state As IAuthorizationState = client.ProcessUserAuthorization()
If state IsNot Nothing AndAlso state.IsAuthorized Then
	' Authorized successfully, now you can access protected resources
End If

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

Caractéristiques de la mise en œuvre de DotNetOpenAuth .NET Core

Intégration d'OpenID Connect

Pour intégrer OpenID Connect à l'aide de DotNetOpenAuth .NET Core, vous pouvez suivre cette approche de base :

using DotNetOpenAuth.OAuth2;

// Configure the OpenID Connect client
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
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
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)

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

Gestion des jetons d'accès

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

// After user is authenticated, process the authorization response
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 user is authenticated, process the authorization response
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 user is authenticated, process the authorization response
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

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

Jetons de rafraîchissement

Pour rafraîchir les jetons lorsqu'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

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

Révoquer des jetons

Si vous devez révoquer des jetons, procédez comme indiqué 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

Cet extrait révoque l'autorisation, ce qui a pour effet d'invalider le jeton d'accès.

Personnalisation des demandes de jetons

Pour adapter les demandes de jetons à des besoins spécifiques, par exemple en ajoutant des paramètres supplémentaires :

// Customize the token request
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
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
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

Ce code ajoute des paramètres personnalisés à la demande de jeton, ce qui peut être utile pour répondre 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 des environnements .NET. Il est particulièrement utile pour générer des PDF à partir de HTML ou directement à partir d'URL, ce qui peut s'avérer très utile pour établir des rapports, générer des factures ou simplement stocker des pages web dans un format statique. Lorsqu'il est intégré à DotNetOpenAuth .NET Core, il 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 la fusion d'IronPDF avec DotNetOpenAuth .NET Core se trouve dans une application web où les utilisateurs authentifiés doivent générer et télécharger des rapports personnalisés. Imaginez par exemple un scénario dans lequel les utilisateurs se connectent à votre application et accèdent à leurs rapports financiers au format PDF. DotNetOpenAuth veille à ce que les utilisateurs soient correctement authentifiés et autorisés à accéder à leurs documents, tandis qu'IronPDF se charge de la création et de la livraison de ces PDF personnalisés.

Exemple de code pour un cas d'utilisation

Examinons un exemple de code complet qui montre comment mettre en œuvre cette méthode. Nous allons créer une API web simple dans .NET Core qui authentifie un utilisateur et génère ensuite un rapport PDF à l'aide d'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

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

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

Conclusion

L'intégration de DotNetOpenAuth .NET Core avec IronPDF offre une solution puissante pour renforcer 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 PDF.

IronPDF est non seulement polyvalent mais aussi convivial pour les développeurs, offrant une approche directe de la création et de la gestion des fichiers PDF dans les applications .NET. Si vous envisagez d'intégrer IronPDF à votre projet, il est recommandé d'explorer les éléments suivantsSite officiel d'IronPDF pour un essai gratuit et des options de licence.

Regan Pun

Discutez avec l'équipe d'ingénierie maintenant

Ingénieur logiciel

Regan est diplômé de l'université de Reading, où il a obtenu une licence en ingénierie électronique. Avant de rejoindre Iron Software, il s'était concentré sur une seule tâche. Ce qu'il apprécie le plus chez Iron Software, c'est la diversité des tâches qu'il peut accomplir, qu'il s'agisse d'apporter une valeur ajoutée aux ventes, à l'assistance technique, au développement de produits ou à la commercialisation. Il aime comprendre comment les développeurs utilisent la bibliothèque d'Iron Software et utiliser ces connaissances pour améliorer continuellement la documentation et développer les produits.

< PRÉCÉDENT
Specflow C# (Comment ça marche pour les développeurs)

SUIVANT >
OpenTelemetry .NET (Comment ça marche pour les développeurs)