Encodage d'URL en C# (Comment ça marche pour les développeurs)

Introduction

Codage de l'URL et le décodage sont des techniques utilisées dans le C# pour garantir la sécurité de la transmission des données dans les URL. En C#, ces opérations sont couramment rencontrées lorsqu'il s'agit d'applications web, d'appels d'API ou de tout scénario dans lequel des données doivent être transmises via l'internet de manière sûre et fiable. Dans cet article, nous allons explorer la méthode d'encodage de l'URL et la fonction Bibliothèque IronPDF.

Encodage d'URL en C# ;

Lorsque vous encodez un URL, vous transformez ses caractères en une forme qui peut être envoyée en toute sécurité sur l'internet, évitant ainsi tout malentendu. En effet, les URL ne peuvent être envoyés sur l'internet qu'en utilisant le jeu de caractères ASCII. Caractères qui ne font pas partie de cet ensemble ou qui ont une signification particulière dans les URL (comme les espaces, les esperluettes et les signes égaux)doivent être représentées à l'aide d'un codage en pourcentage (par exemple, les espaces deviennent %20). C# fournit des méthodes intégrées pour accomplir cette tâche.

Décodage d'URL en C# ;

Le décodage de l'URL ramène les caractères codés à leur état d'origine lorsqu'ils arrivent à leur destination. Cela est essentiel pour que l'application réceptrice comprenne et traite correctement les données comme prévu. Le décodage ramène les caractères codés en pourcentage à leurs symboles d'origine, ce qui rend les données lisibles et utilisables à nouveau.

Méthodes de codage en C# ;

En C#, il existe plusieurs façons d'encoder les URL, chacune étant adaptée à des scénarios différents. Ces méthodes se trouvent principalement dans les espaces de noms System.Web et System.Net, offrant aux développeurs une certaine flexibilité dans la manière d'encoder les URL. Voici un bref aperçu des méthodes disponibles :

1. méthode HttpUtility.UrlEncode (System.Web)** : C'est peut-être la méthode la plus couramment utilisée pour l'encodage des URL dans une application web. Il convertit les caractères dans un format codé en pourcentage, ce qui rend la chaîne sûre pour la transmission par l'URL. Il est particulièrement utile dans les projets ASP.NET pour coder les chaînes de requête et les paramètres de formulaire.
2. méthode HttpUtility.UrlPathEncode (System.Web) : Contrairement à UrlEncode, UrlPathEncode** est conçu spécifiquement pour encoder la partie chemin d'une URL, en laissant la chaîne de requête intacte. Il est important de noter que cette méthode n'encode pas l'intégralité de l'URL, mais plutôt la partie du chemin, ce qui permet de préserver la structure hiérarchique de l'URL.
3. méthode Uri.EscapeUriString (Système) : Cette méthode est destinée à l'échappement des chaînes d'URI, en transformant tous les caractères non autorisés dans un URI en leurs équivalents codés en pourcentage. Cependant, il n'encode pas certains caractères, tels que la barre oblique (/) et point d'interrogation (?**)car ils sont considérés comme des caractères URI valides.

4. méthode Uri.EscapeDataString (Système) : Cette méthode est conçue pour encoder une chaîne de caractères à utiliser dans la partie requête d'un URI. Il encode tous les caractères à l'exception des caractères non réservés définis dans la RFC 3986. Il est plus agressif que EscapeUriString**, garantissant que les données sont encodées en toute sécurité pour être transmises dans les URL.

   Comprenons les trois premières méthodes d'encodage décrites ci-dessus et leur fonctionnement à l'aide d'exemples de code.

Exemple de code de la méthode HttpUtility.UrlEncode

using System;
using System.Web;
class Program
{
    static void Main()
    {
        string originalPath = "/api/search/Hello World!";
        string encodedPath = UrlEncode(originalPath);
        Console.WriteLine("Original Path: " + originalPath);
        Console.WriteLine("Encoded Path: " + encodedPath);
    }
    public static string UrlEncode(string originalString)
    {
        return HttpUtility.UrlEncode(originalString);
    }
}

using System;
using System.Web;
class Program
{
    static void Main()
    {
        string originalPath = "/api/search/Hello World!";
        string encodedPath = UrlEncode(originalPath);
        Console.WriteLine("Original Path: " + originalPath);
        Console.WriteLine("Encoded Path: " + encodedPath);
    }
    public static string UrlEncode(string originalString)
    {
        return HttpUtility.UrlEncode(originalString);
    }
}

Imports System
Imports System.Web
Friend Class Program
	Shared Sub Main()
		Dim originalPath As String = "/api/search/Hello World!"
		Dim encodedPath As String = UrlEncode(originalPath)
		Console.WriteLine("Original Path: " & originalPath)
		Console.WriteLine("Encoded Path: " & encodedPath)
	End Sub
	Public Shared Function UrlEncode(ByVal originalString As String) As String
		Return HttpUtility.UrlEncode(originalString)
	End Function
End Class

Inclusion de l'espace de noms : L'espace de noms System.Web est inclus au début du code.

Chaîne originale : Nous définissons une variable de type chaîne originalString contenant les caractères à encoder pour une transmission sûre dans une URL. Cela inclut les espaces et les signes de ponctuation qui pourraient causer des problèmes s'ils étaient inclus dans une URL sans encodage.

Encodage : La méthode HttpUtility.UrlEncode est appelée avec originalString comme argument. Cette méthode traite la chaîne et renvoie une nouvelle chaîne dans laquelle les caractères non sûrs sont remplacés par leurs équivalents codés en pourcentage. Par exemple, les espaces sont remplacés par %20.

Sortie : Enfin, le programme imprime les chaînes originales et codées sur la console.

Exemple de code de la méthode HttpUtility.UrlPathEncode

using System;
using System.Web;
class Program
{
    static void Main()
    {
        // Define the original URL path, which includes spaces.
        string originalPath = "/api/search/Hello World!";
        // Use the HttpUtility.UrlPathEncode method to encode the path.
        string encodedPath = HttpUtility.UrlPathEncode(originalPath);
        // Output the original and encoded paths to the console.
        Console.WriteLine("Original Path: " + originalPath);
        Console.WriteLine("Encoded Path: " + encodedPath);
    }
}

using System;
using System.Web;
class Program
{
    static void Main()
    {
        // Define the original URL path, which includes spaces.
        string originalPath = "/api/search/Hello World!";
        // Use the HttpUtility.UrlPathEncode method to encode the path.
        string encodedPath = HttpUtility.UrlPathEncode(originalPath);
        // Output the original and encoded paths to the console.
        Console.WriteLine("Original Path: " + originalPath);
        Console.WriteLine("Encoded Path: " + encodedPath);
    }
}

Imports System
Imports System.Web
Friend Class Program
	Shared Sub Main()
		' Define the original URL path, which includes spaces.
		Dim originalPath As String = "/api/search/Hello World!"
		' Use the HttpUtility.UrlPathEncode method to encode the path.
		Dim encodedPath As String = HttpUtility.UrlPathEncode(originalPath)
		' Output the original and encoded paths to the console.
		Console.WriteLine("Original Path: " & originalPath)
		Console.WriteLine("Encoded Path: " & encodedPath)
	End Sub
End Class

Équivalents d'entités de caractères dans le codage d'URL: Le processus indiqué transforme la valeur de la chaîne d'un chemin d'URL, en convertissant les espaces en leurs équivalents d'entités de caractères (%20) pour la compatibilité web. Cette étape est cruciale car les URL ne peuvent pas contenir de caractères d'espacement.

La valeur de la chaîne de la variable originalPath** est "/api/search/Hello World"!", qui est un exemple typique d'une chaîne URL nécessitant un encodage en raison de l'inclusion d'espaces.

Bien que cet exemple utilise une version spécifique de HttpUtility.UrlPathEncode sans surcharge de méthode, il est important de noter l'intention de conception de la méthode pour l'encodage des chemins d'URL. Les développeurs doivent être conscients des surcharges de méthodes lorsqu'elles existent, car elles fournissent d'autres façons d'utiliser une méthode, souvent en acceptant d'autres types d'entrées ou en fournissant des fonctionnalités supplémentaires.

**L'objet d'encodage dans ce contexte est implicite dans l'opération de la méthode HttpUtility.UrlPathEncode, qui prend une chaîne d'URL et renvoie sa forme encodée. Cette méthode garantit que la structure du chemin d'accès à l'URL reste intacte tout en encodant les caractères spéciaux dans leurs représentations appropriées.

**Le programme démontre la transformation du chemin d'origine en chemin codé. Il s'agit d'un exemple direct d'encodage d'une chaîne d'URL pour l'adapter à la transmission sur le web, en tenant compte des problèmes potentiels que les espaces et autres caractères spéciaux peuvent poser.

Exemple de code de la méthode Uri.EscapeUriString

using System;
class Program
{
    static void Main()
    {
        string originalUri = "https://example.com/search?query=Hello World!";
        string escapedUri = Uri.EscapeUriString(originalUri);
        Console.WriteLine("Original URI: " + originalUri);
        Console.WriteLine("Escaped URI: " + escapedUri);
    }
}

using System;
class Program
{
    static void Main()
    {
        string originalUri = "https://example.com/search?query=Hello World!";
        string escapedUri = Uri.EscapeUriString(originalUri);
        Console.WriteLine("Original URI: " + originalUri);
        Console.WriteLine("Escaped URI: " + escapedUri);
    }
}

Imports System
Friend Class Program
	Shared Sub Main()
		Dim originalUri As String = "https://example.com/search?query=Hello World!"
		Dim escapedUri As String = Uri.EscapeUriString(originalUri)
		Console.WriteLine("Original URI: " & originalUri)
		Console.WriteLine("Escaped URI: " & escapedUri)
	End Sub
End Class

URI original : La variable originalUri est initialisée avec une chaîne représentant un URI complet, y compris une chaîne de requête avec des espaces et des caractères spéciaux. Pour que l'URI soit correctement traité par les navigateurs et les serveurs, ces caractères spéciaux doivent être "échappés".

Échapper l'URI : La méthode Uri.EscapeUriString est invoquée avec originalUri comme argument. Cette méthode analyse la chaîne de l'URI et échappe les caractères non autorisés ou susceptibles de créer une ambiguïté dans un URI.

Sortie : Le programme imprime l'URI original et l'URI échappé sur la console.

IronPDF : C&num ; Bibliothèque PDF

IronPDF est une bibliothèque PDF qui simplifie la création, l'édition et la manipulation de fichiers PDF dans les applications .NET. Conçu pour s'intégrer de manière transparente à C# et VB.NET, IronPDF offre aux développeurs les fonctions suivantes générer des PDF à partir de HTML ou directement à partir du texte. Que vous ayez besoin d'automatiser la génération de factures, de créer des rapports dynamiques ou de gérer des documents dans un environnement .NET, IronPDF se distingue par sa facilité d'utilisation et son ensemble complet de fonctionnalités.

Le point fort d'IronPDF est son HTML vers PDF en conservant vos mises en page et vos styles. Cela permet de créer des PDF à partir de contenu web, ce qui est parfait pour les rapports, les factures et la documentation. Les fichiers HTML, les URL et les chaînes HTML peuvent être facilement convertis en PDF.

using IronPdf;
class Program
{
    static void Main(string[] args)
    {
        var renderer = new ChromePdfRenderer();
        // 1. Convert HTML String to PDF
        var htmlContent = "<h1>Hello, IronPDF!</h1><p>This is a PDF from an HTML string.</p>";
        var pdfFromHtmlString = renderer.RenderHtmlAsPdf(htmlContent);
        pdfFromHtmlString.SaveAs("HTMLStringToPDF.pdf");
        // 2. Convert HTML File to PDF
        var htmlFilePath = "path_to_your_html_file.html"; // Specify the path to your HTML file
        var pdfFromHtmlFile = renderer.RenderHtmlFileAsPdf(htmlFilePath);
        pdfFromHtmlFile.SaveAs("HTMLFileToPDF.pdf");
        // 3. Convert URL to PDF
        var url = "http://ironpdf.com"; // Specify the URL
        var pdfFromUrl = renderer.RenderUrlAsPdf(url);
        pdfFromUrl.SaveAs("URLToPDF.pdf");
    }
}

using IronPdf;
class Program
{
    static void Main(string[] args)
    {
        var renderer = new ChromePdfRenderer();
        // 1. Convert HTML String to PDF
        var htmlContent = "<h1>Hello, IronPDF!</h1><p>This is a PDF from an HTML string.</p>";
        var pdfFromHtmlString = renderer.RenderHtmlAsPdf(htmlContent);
        pdfFromHtmlString.SaveAs("HTMLStringToPDF.pdf");
        // 2. Convert HTML File to PDF
        var htmlFilePath = "path_to_your_html_file.html"; // Specify the path to your HTML file
        var pdfFromHtmlFile = renderer.RenderHtmlFileAsPdf(htmlFilePath);
        pdfFromHtmlFile.SaveAs("HTMLFileToPDF.pdf");
        // 3. Convert URL to PDF
        var url = "http://ironpdf.com"; // Specify the URL
        var pdfFromUrl = renderer.RenderUrlAsPdf(url);
        pdfFromUrl.SaveAs("URLToPDF.pdf");
    }
}

Imports IronPdf
Friend Class Program
	Shared Sub Main(ByVal args() As String)
		Dim renderer = New ChromePdfRenderer()
		' 1. Convert HTML String to PDF
		Dim htmlContent = "<h1>Hello, IronPDF!</h1><p>This is a PDF from an HTML string.</p>"
		Dim pdfFromHtmlString = renderer.RenderHtmlAsPdf(htmlContent)
		pdfFromHtmlString.SaveAs("HTMLStringToPDF.pdf")
		' 2. Convert HTML File to PDF
		Dim htmlFilePath = "path_to_your_html_file.html" ' Specify the path to your HTML file
		Dim pdfFromHtmlFile = renderer.RenderHtmlFileAsPdf(htmlFilePath)
		pdfFromHtmlFile.SaveAs("HTMLFileToPDF.pdf")
		' 3. Convert URL to PDF
		Dim url = "http://ironpdf.com" ' Specify the URL
		Dim pdfFromUrl = renderer.RenderUrlAsPdf(url)
		pdfFromUrl.SaveAs("URLToPDF.pdf")
	End Sub
End Class

Exemple de code de travail avec codage URL

Dans l'exemple suivant, nous verrons comment utiliser IronPDF en conjonction avec l'encodage d'URL pour générer un PDF à partir d'une page web. Le scénario consiste à encoder une URL pour s'assurer qu'elle est correctement formatée pour les requêtes web, puis à utiliser IronPDF pour convertir le contenu de cette URL en document PDF.

Installer la bibliothèque IronPDF

Tout d'abord, assurez-vous qu'IronPDF est installé dans votre projet. Si vous utilisez NuGet Package Manager, vous pouvez l'installer en exécutant :

Install-Package IronPdf

Exemple de code

Maintenant, plongeons dans le code :

using System.Web;
using IronPdf;
License.LicenseKey = "License-Key";
string baseUrl = "https://example.com/search";
// The query parameter with spaces that needs to be encoded
string query = "Hello World!";
// Encoding the query parameter to ensure the URL is correctly formatted
string encodedQuery = HttpUtility.UrlEncode(query);
// Constructing the full URL with the encoded query parameter
string fullUrl = $"{baseUrl}?query={encodedQuery}";
// Initialize the IronPDF HtmlToPdf renderer
var renderer = new ChromePdfRenderer();
// Convert the web page at the encoded URL to a PDF document
var pdf = renderer.RenderUrlAsPdf(fullUrl);
// Save the PDF to a file
string filePath = "webpage.pdf";
pdf.SaveAs(filePath);
Console.WriteLine($"PDF successfully created from: {fullUrl}");
Console.WriteLine($"Saved to: {filePath}");

using System.Web;
using IronPdf;
License.LicenseKey = "License-Key";
string baseUrl = "https://example.com/search";
// The query parameter with spaces that needs to be encoded
string query = "Hello World!";
// Encoding the query parameter to ensure the URL is correctly formatted
string encodedQuery = HttpUtility.UrlEncode(query);
// Constructing the full URL with the encoded query parameter
string fullUrl = $"{baseUrl}?query={encodedQuery}";
// Initialize the IronPDF HtmlToPdf renderer
var renderer = new ChromePdfRenderer();
// Convert the web page at the encoded URL to a PDF document
var pdf = renderer.RenderUrlAsPdf(fullUrl);
// Save the PDF to a file
string filePath = "webpage.pdf";
pdf.SaveAs(filePath);
Console.WriteLine($"PDF successfully created from: {fullUrl}");
Console.WriteLine($"Saved to: {filePath}");

Imports System.Web
Imports IronPdf
License.LicenseKey = "License-Key"
Dim baseUrl As String = "https://example.com/search"
' The query parameter with spaces that needs to be encoded
Dim query As String = "Hello World!"
' Encoding the query parameter to ensure the URL is correctly formatted
Dim encodedQuery As String = HttpUtility.UrlEncode(query)
' Constructing the full URL with the encoded query parameter
Dim fullUrl As String = $"{baseUrl}?query={encodedQuery}"
' Initialize the IronPDF HtmlToPdf renderer
Dim renderer = New ChromePdfRenderer()
' Convert the web page at the encoded URL to a PDF document
Dim pdf = renderer.RenderUrlAsPdf(fullUrl)
' Save the PDF to a file
Dim filePath As String = "webpage.pdf"
pdf.SaveAs(filePath)
Console.WriteLine($"PDF successfully created from: {fullUrl}")
Console.WriteLine($"Saved to: {filePath}")

Explication du code

L'exemple commence par une URL de base et une chaîne de requête contenant des espaces. La chaîne de requête est encodée à l'aide de HttpUtility.UrlEncode pour s'assurer qu'elle est transmise en toute sécurité dans l'URL. Après avoir encodé la requête, elle est ajoutée à l'URL de base pour former l'URL complète à laquelle on accède.

Une fois l'URL complète et codée prête, le moteur de rendu ChromePdfRenderer d'IronPDF est utilisé pour récupérer la page web à cette URL et la convertir en document PDF. Il s'agit de créer une instance de la classe ChromePdfRenderer et d'appeler RenderUrlAsPdf avec l'URL encodée. Enfin, le PDF généré est enregistré dans un fichier à l'aide de la méthode SaveAs. Le fichier résultant est un document PDF du contenu de la page web, accessible via l'URL encodée. Voici le fichier PDF de sortie :

Conclusion

En résumé, C# offre de puissantes capacités d'encodage et de décodage d'URL, garantissant ainsi une transmission sûre et efficace des données sur l'internet. Grâce aux méthodes intégrées dans les espaces de noms System.Web et System.Net, les développeurs peuvent encoder les URL pour éviter les problèmes liés aux caractères spéciaux et les décoder dans leur forme originale pour une interprétation précise des données.

Pour ceux qui souhaitent explorer IronPDF est disponible, ce qui permet d'évaluer directement sa fonctionnalité. Si vous décidez d'intégrer IronPDF à vos projets, les licences commencent à $749, offrant une suite complète de fonctionnalités pour répondre à vos besoins de manipulation de PDF au sein du framework .NET.