Icône de message
Passer au contenu du pied de page
  1. IronPDF
  2. Blog IronPDF
  3. .NET Aide
  4. Méthodes d'extension C#
.NET AIDE

Méthodes d'extension en C# (Comment ça fonctionne pour les développeurs)

Curtis Chau
Curtis Chau
Mis à jour:

Les méthodes d'extension sont une fonctionnalité puissante en C# qui vous permet d'ajouter de nouvelles fonctionnalités aux types existants sans modifier leur code source. Elles peuvent être extrêmement utiles pour rendre votre code plus lisible et maintenable. Dans ce guide, nous allons explorer les bases des méthodes d'extension et comment les implémenter.

Que sont les méthodes d'extension ?

Les méthodes d'extension sont des méthodes statiques spéciales qui peuvent être appelées comme si elles étaient des méthodes d'instance d'un type existant. Elles constituent un moyen pratique d'ajouter de nouvelles méthodes à une classe existante sans modifier le code source original ou sans hériter de la classe.

Pour créer une méthode d'extension, vous devez définir une méthode statique dans une classe statique. Le premier paramètre de la méthode doit être le type que vous souhaitez étendre, précédé du mot-clé this. Ce mot-clé spécial indique au compilateur C# qu'il s'agit d'une méthode d'extension.

Implémentation des méthodes d'extension en C#

Maintenant que nous savons ce que sont les méthodes d'extension, implémentons-en une. Imaginez que vous avez une chaîne de caractères que vous souhaitez inverser. Au lieu d'écrire une fonction distincte pour cela, vous pouvez créer une méthode d'extension pour la classe string.

Tout d'abord, créons une nouvelle classe statique appelée StringExtensions. Le nom de la classe n'est pas important, mais il est habituel d'utiliser le nom du type que l'on étend suivi de "Extensions". Dans cette classe, nous définirons une méthode statique appelée Reverse :

public static class StringExtensions
{
    // This extension method reverses a given string.
    public static string Reverse(this string input)
    {
        // Convert the string to a character array.
        char[] chars = input.ToCharArray();
        // Reverse the array in place.
        Array.Reverse(chars);
        // Create a new string from the reversed character array and return it.
        return new string(chars);
    }
}
public static class StringExtensions
{
    // This extension method reverses a given string.
    public static string Reverse(this string input)
    {
        // Convert the string to a character array.
        char[] chars = input.ToCharArray();
        // Reverse the array in place.
        Array.Reverse(chars);
        // Create a new string from the reversed character array and return it.
        return new string(chars);
    }
}
Public Module StringExtensions
	' This extension method reverses a given string.
	<System.Runtime.CompilerServices.Extension> _
	Public Function Reverse(ByVal input As String) As String
		' Convert the string to a character array.
		Dim chars() As Char = input.ToCharArray()
		' Reverse the array in place.
		Array.Reverse(chars)
		' Create a new string from the reversed character array and return it.
		Return New String(chars)
	End Function
End Module
$vbLabelText   $csharpLabel

Dans cet exemple, nous avons créé une méthode statique publique de type string appelée Reverse avec un seul paramètre. Le mot-clé this devant le type string indique qu'il s'agit d'une méthode d'extension pour la classe string.

Voyons maintenant comment utiliser cette nouvelle méthode d'extension dans notre classe Program :

class Program
{
    static void Main(string[] args)
    {
        string example = "Hello, World!";
        // Call the extension method as if it were an instance method.
        string reversed = example.Reverse();
        Console.WriteLine(reversed); // Output: !dlroW ,olleH
    }
}
class Program
{
    static void Main(string[] args)
    {
        string example = "Hello, World!";
        // Call the extension method as if it were an instance method.
        string reversed = example.Reverse();
        Console.WriteLine(reversed); // Output: !dlroW ,olleH
    }
}
Friend Class Program
	Shared Sub Main(ByVal args() As String)
		Dim example As String = "Hello, World!"
		' Call the extension method as if it were an instance method.
		Dim reversed As String = example.Reverse()
		Console.WriteLine(reversed) ' Output: !dlroW ,olleH
	End Sub
End Class
$vbLabelText   $csharpLabel

Remarquez que nous n'avons pas eu besoin de créer une instance de la classe StringExtensions. Au lieu de cela, nous avons utilisé la méthode Reverse directement sur l'instance de string comme s'il s'agissait d'une méthode d'instance.

Syntaxe des méthodes d'extension

Les méthodes d'extension ressemblent et se comportent comme des méthodes d'instance, mais il y a quelques différences importantes à garder à l'esprit :

  • Les méthodes d'extension ne peuvent pas accéder aux membres privés du type étendu.
  • Elles ne participent pas non plus à l'héritage ou au polymorphisme.
  • Vous ne pouvez pas remplacer une méthode existante par une méthode d'extension.

Si le type étendu a une méthode avec la même signature qu'une méthode d'extension, la méthode d'instance aura toujours la priorité. Les méthodes d'extension ne sont appelées que lorsqu'il n'y a pas de méthode d'instance correspondante.

Exemples concrets de méthodes d'extension

Maintenant que nous avons compris les bases des méthodes d'extension en C#, regardons quelques exemples concrets.

Méthode d'extension des chaînes Compte de mots

Imaginez que vous voulez compter le nombre de mots dans une chaîne. Vous pouvez créer une méthode d'extension WordCount pour la classe string :

public static class StringExtensions
{
    // This extension method counts the number of words in a string.
    public static int WordCount(this string input)
    {
        // Split the string by whitespace characters and return the length of the resulting array.
        return input.Split(new[] { ' ', '\t', '\r', '\n' }, StringSplitOptions.RemoveEmptyEntries).Length;
    }
}
public static class StringExtensions
{
    // This extension method counts the number of words in a string.
    public static int WordCount(this string input)
    {
        // Split the string by whitespace characters and return the length of the resulting array.
        return input.Split(new[] { ' ', '\t', '\r', '\n' }, StringSplitOptions.RemoveEmptyEntries).Length;
    }
}
Imports Microsoft.VisualBasic

Public Module StringExtensions
	' This extension method counts the number of words in a string.
	<System.Runtime.CompilerServices.Extension> _
	Public Function WordCount(ByVal input As String) As Integer
		' Split the string by whitespace characters and return the length of the resulting array.
		Return input.Split( { " "c, ControlChars.Tab, ControlChars.Cr, ControlChars.Lf }, StringSplitOptions.RemoveEmptyEntries).Length
	End Function
End Module
$vbLabelText   $csharpLabel

Maintenant, vous pouvez facilement compter le nombre de mots dans une chaîne comme ceci :

string text = "Extension methods are awesome!";
int wordCount = text.WordCount();
Console.WriteLine($"The text has {wordCount} words."); // Output: The text has 4 words.
string text = "Extension methods are awesome!";
int wordCount = text.WordCount();
Console.WriteLine($"The text has {wordCount} words."); // Output: The text has 4 words.
Dim text As String = "Extension methods are awesome!"
Dim wordCount As Integer = text.WordCount()
Console.WriteLine($"The text has {wordCount} words.") ' Output: The text has 4 words.
$vbLabelText   $csharpLabel

Méthode d'extension IEnumerable Mediane

Supposons que vous ayez une collection de nombres et que vous souhaitiez calculer la valeur médiane. Vous pouvez créer une méthode d'extension pour IEnumerable<int> :

using System;
using System.Collections.Generic;
using System.Linq;

public static class EnumerableExtensions
{
    // This extension method calculates the median of a collection of integers.
    public static double Median(this IEnumerable<int> source)
    {
        // Sort the collection and convert it to an array.
        int[] sorted = source.OrderBy(x => x).ToArray();
        int count = sorted.Length;

        if (count == 0)
        {
            throw new InvalidOperationException("The collection is empty.");
        }

        // If the count is even, return the average of the two middle elements.
        if (count % 2 == 0)
        {
            return (sorted[count / 2 - 1] + sorted[count / 2]) / 2.0;
        }
        else
        {
            // Otherwise, return the middle element.
            return sorted[count / 2];
        }
    }
}
using System;
using System.Collections.Generic;
using System.Linq;

public static class EnumerableExtensions
{
    // This extension method calculates the median of a collection of integers.
    public static double Median(this IEnumerable<int> source)
    {
        // Sort the collection and convert it to an array.
        int[] sorted = source.OrderBy(x => x).ToArray();
        int count = sorted.Length;

        if (count == 0)
        {
            throw new InvalidOperationException("The collection is empty.");
        }

        // If the count is even, return the average of the two middle elements.
        if (count % 2 == 0)
        {
            return (sorted[count / 2 - 1] + sorted[count / 2]) / 2.0;
        }
        else
        {
            // Otherwise, return the middle element.
            return sorted[count / 2];
        }
    }
}
Imports System
Imports System.Collections.Generic
Imports System.Linq

Public Module EnumerableExtensions
	' This extension method calculates the median of a collection of integers.
	<System.Runtime.CompilerServices.Extension> _
	Public Function Median(ByVal source As IEnumerable(Of Integer)) As Double
		' Sort the collection and convert it to an array.
		Dim sorted() As Integer = source.OrderBy(Function(x) x).ToArray()
		Dim count As Integer = sorted.Length

		If count = 0 Then
			Throw New InvalidOperationException("The collection is empty.")
		End If

		' If the count is even, return the average of the two middle elements.
		If count Mod 2 = 0 Then
			Return (sorted(count \ 2 - 1) + sorted(count \ 2)) / 2.0
		Else
			' Otherwise, return the middle element.
			Return sorted(count \ 2)
		End If
	End Function
End Module
$vbLabelText   $csharpLabel

Avec cette méthode d'extension, vous pouvez facilement trouver la valeur médiane d'une collection :

int[] numbers = { 5, 3, 9, 1, 4 };
double median = numbers.Median();
Console.WriteLine($"The median value is {median}."); // Output: The median value is 4.
int[] numbers = { 5, 3, 9, 1, 4 };
double median = numbers.Median();
Console.WriteLine($"The median value is {median}."); // Output: The median value is 4.
Dim numbers() As Integer = { 5, 3, 9, 1, 4 }
Dim median As Double = numbers.Median()
Console.WriteLine($"The median value is {median}.") ' Output: The median value is 4.
$vbLabelText   $csharpLabel

Méthode d'extension DateTime Début de semaine

Disons que vous voulez trouver le début de la semaine pour une date donnée. Vous pouvez créer une méthode d'extension pour la structure DateTime :

public static class DateTimeExtensions
{
    // This extension method calculates the start of the week for a given date.
    public static DateTime StartOfWeek(this DateTime dt, DayOfWeek startOfWeek = DayOfWeek.Monday)
    {
        // Calculate the difference in days between the current day and the start of the week.
        int diff = (7 + (dt.DayOfWeek - startOfWeek)) % 7;
        // Subtract the difference to get the start of the week.
        return dt.AddDays(-1 * diff).Date;
    }
}
public static class DateTimeExtensions
{
    // This extension method calculates the start of the week for a given date.
    public static DateTime StartOfWeek(this DateTime dt, DayOfWeek startOfWeek = DayOfWeek.Monday)
    {
        // Calculate the difference in days between the current day and the start of the week.
        int diff = (7 + (dt.DayOfWeek - startOfWeek)) % 7;
        // Subtract the difference to get the start of the week.
        return dt.AddDays(-1 * diff).Date;
    }
}
Public Module DateTimeExtensions
	' This extension method calculates the start of the week for a given date.
'INSTANT VB NOTE: The parameter startOfWeek was renamed since Visual Basic will not allow parameters with the same name as their enclosing function or property:
	<System.Runtime.CompilerServices.Extension> _
	Public Function StartOfWeek(ByVal dt As DateTime, Optional ByVal startOfWeek_Conflict As DayOfWeek = DayOfWeek.Monday) As DateTime
		' Calculate the difference in days between the current day and the start of the week.
		Dim diff As Integer = (7 + (dt.DayOfWeek - startOfWeek_Conflict)) Mod 7
		' Subtract the difference to get the start of the week.
		Return dt.AddDays(-1 * diff).Date
	End Function
End Module
$vbLabelText   $csharpLabel

Maintenant, vous pouvez facilement trouver le début de la semaine pour n'importe quelle date :

DateTime today = DateTime.Today;
DateTime startOfWeek = today.StartOfWeek();
Console.WriteLine($"The start of the week is {startOfWeek.ToShortDateString()}.");
// Output will depend on the current date, e.g. The start of the week is 17/06/2024.
DateTime today = DateTime.Today;
DateTime startOfWeek = today.StartOfWeek();
Console.WriteLine($"The start of the week is {startOfWeek.ToShortDateString()}.");
// Output will depend on the current date, e.g. The start of the week is 17/06/2024.
Dim today As DateTime = DateTime.Today
Dim startOfWeek As DateTime = today.StartOfWeek()
Console.WriteLine($"The start of the week is {startOfWeek.ToShortDateString()}.")
' Output will depend on the current date, e.g. The start of the week is 17/06/2024.
$vbLabelText   $csharpLabel

Génération de PDF avec IronPDF et les méthodes d'extension

Dans cette section, nous allons introduire IronPDF, notre bibliothèque leader du marché pour la génération et le traitement des fichiers PDF en C#. Nous verrons également comment nous pouvons tirer parti des méthodes d'extension pour créer une expérience plus fluide et intuitive lors de l'utilisation de cette bibliothèque.

IronPDF convertit HTML en PDF de manière à préserver la disposition et le style du contenu tel qu'il apparaîtrait dans un navigateur Web. La bibliothèque peut travailler avec du HTML brut provenant de fichiers, d'URLs et de chaînes de caractères. Voici un aperçu rapide : 

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
$vbLabelText   $csharpLabel

Créer un PDF simple

Avant de plonger dans les méthodes d'extension, voyons comment créer un PDF simple à partir de HTML à l'aide d'IronPDF : 

using IronPdf;

class Program
{
    static void Main(string[] args)
    {
        var renderer = new ChromePdfRenderer();
        var PDF = renderer.RenderHtmlAsPdf("Hello, World!");
        PDF.SaveAs("HelloWorld.PDF");
    }
}
using IronPdf;

class Program
{
    static void Main(string[] args)
    {
        var renderer = new ChromePdfRenderer();
        var PDF = renderer.RenderHtmlAsPdf("Hello, World!");
        PDF.SaveAs("HelloWorld.PDF");
    }
}
Imports IronPdf

Friend Class Program
	Shared Sub Main(ByVal args() As String)
		Dim renderer = New ChromePdfRenderer()
		Dim PDF = renderer.RenderHtmlAsPdf("Hello, World!")
		PDF.SaveAs("HelloWorld.PDF")
	End Sub
End Class
$vbLabelText   $csharpLabel

Cet extrait de code crée un PDF avec le texte "Hello, World!" et le sauvegarde dans un fichier nommé "HelloWorld.PDF".

Méthodes d'extension pour IronPDF

Explorons maintenant comment nous pouvons utiliser les méthodes d'extension pour améliorer la fonctionnalité d'IronPDF et le rendre plus facile à utiliser. Par exemple, nous pouvons créer une méthode d'extension qui prend une instance de la classe string et génère un PDF directement à partir de celle-ci. 

using IronPdf;

public static class StringExtensions
{
    // This extension method converts a string containing HTML to a PDF and saves it.
    public static void SaveAsPdf(this string htmlContent, string filePath)
    {
        var renderer = new ChromePdfRenderer();
        var PDF = renderer.RenderHtmlAsPdf(htmlContent);
        PDF.SaveAs(filePath);
    }
}
using IronPdf;

public static class StringExtensions
{
    // This extension method converts a string containing HTML to a PDF and saves it.
    public static void SaveAsPdf(this string htmlContent, string filePath)
    {
        var renderer = new ChromePdfRenderer();
        var PDF = renderer.RenderHtmlAsPdf(htmlContent);
        PDF.SaveAs(filePath);
    }
}
Imports IronPdf

Public Module StringExtensions
	' This extension method converts a string containing HTML to a PDF and saves it.
	<System.Runtime.CompilerServices.Extension> _
	Public Sub SaveAsPdf(ByVal htmlContent As String, ByVal filePath As String)
		Dim renderer = New ChromePdfRenderer()
		Dim PDF = renderer.RenderHtmlAsPdf(htmlContent)
		PDF.SaveAs(filePath)
	End Sub
End Module
$vbLabelText   $csharpLabel

Avec cette méthode d'extension, nous pouvons maintenant générer un PDF directement à partir d'une chaîne : 

string html = "<h1>Extension Methods and IronPDF</h1><p>Generating PDFs has never been easier!</p>";
html.SaveAsPdf("ExtensionMethodsAndIronPDF.PDF");
string html = "<h1>Extension Methods and IronPDF</h1><p>Generating PDFs has never been easier!</p>";
html.SaveAsPdf("ExtensionMethodsAndIronPDF.PDF");
Dim html As String = "<h1>Extension Methods and IronPDF</h1><p>Generating PDFs has never been easier!</p>"
html.SaveAsPdf("ExtensionMethodsAndIronPDF.PDF")
$vbLabelText   $csharpLabel

Générer des PDFs depuis des URLs

Une autre méthode d'extension utile que nous pouvons créer est une qui génère un PDF à partir d'une URL. Nous pouvons étendre la classe Uri pour y parvenir : 

using IronPdf;

public static class UriExtensions
{
    // This extension method converts a web URL to a PDF and saves it.
    public static void SaveAsPdf(this Uri url, string filePath)
    {
        var renderer = new ChromePdfRenderer();
        var PDF = renderer.RenderUrlAsPdf(url.AbsoluteUri);
        PDF.SaveAs(filePath);
    }
}
using IronPdf;

public static class UriExtensions
{
    // This extension method converts a web URL to a PDF and saves it.
    public static void SaveAsPdf(this Uri url, string filePath)
    {
        var renderer = new ChromePdfRenderer();
        var PDF = renderer.RenderUrlAsPdf(url.AbsoluteUri);
        PDF.SaveAs(filePath);
    }
}
Imports IronPdf

Public Module UriExtensions
	' This extension method converts a web URL to a PDF and saves it.
	<System.Runtime.CompilerServices.Extension> _
	Public Sub SaveAsPdf(ByVal url As Uri, ByVal filePath As String)
		Dim renderer = New ChromePdfRenderer()
		Dim PDF = renderer.RenderUrlAsPdf(url.AbsoluteUri)
		PDF.SaveAs(filePath)
	End Sub
End Module
$vbLabelText   $csharpLabel

Maintenant, nous pouvons facilement générer un PDF à partir une URL comme ceci : 

Uri url = new Uri("https://www.ironpdf.com/");
url.SaveAsPdf("UrlToPdf.PDF");
Uri url = new Uri("https://www.ironpdf.com/");
url.SaveAsPdf("UrlToPdf.PDF");
Dim url As New Uri("https://www.ironpdf.com/")
url.SaveAsPdf("UrlToPdf.PDF")
$vbLabelText   $csharpLabel

Conclusion

Et voilà - nous avons exploré le concept des méthodes d'extension en C#, appris comment les implémenter à l'aide de méthodes et de classes statiques, et utilisé des exemples concrets pour différents types. De plus, nous avons introduit IronPDF, une bibliothèque pour la génération et le traitement des fichiers PDF en C#. Lorsque vous commencez à utiliser les méthodes d'extension et IronPDF ensemble, vous verrez à quel point votre code peut devenir plus propre, lisible et efficace.

Prêt à mettre la main sur IronPDF ? Vous pouvez commencer par notre essai gratuit de 30 jours d'IronPDF. C'est aussi totalement gratuit à utiliser à des fins de développement afin que vous puissiez vraiment voir ce dont il est fait. Et si vous aimez ce que vous voyez, IronPDF commence à aussi bas que liteLicense pour les détails de licence IronPDF. Pour encore plus d'économies, consultez les options d'achat pour la suite Iron Software où vous pouvez obtenir les neuf outils Iron Software pour le prix de deux. Bonne programmation !

Csharp Extension Methods 1 related to Conclusion

Questions Fréquemment Posées

Quelles sont les méthodes d'extension C# et comment sont-elles utiles ?

Les méthodes d'extension C# sont des méthodes statiques qui permettent aux développeurs d'ajouter de nouvelles fonctionnalités à des types existants sans modifier leur code source. Elles rendent le code plus lisible et plus facile à maintenir en vous permettant d'appeler ces méthodes comme s'il s'agissait de méthodes d'instance du type.

Comment créer une méthode d'extension en C# ?

Pour créer une méthode d'extension, définissez une méthode statique dans une classe statique. Le premier paramètre de la méthode doit être le type que vous souhaitez étendre, précédé du mot-clé this.

Les méthodes d'extension peuvent-elles être utilisées pour créer des PDFs en C# ?

Oui, les méthodes d'extension peuvent simplifier la génération de PDFs en C#. Par exemple, vous pouvez développer une méthode d'extension pour les chaînes de caractères afin de convertir directement le contenu HTML en PDF en utilisant une bibliothèque PDF.

Comment puis-je convertir le contenu HTML en PDF en C# ?

Vous pouvez utiliser la méthode d'une bibliothèque PDF pour convertir des chaînes HTML en PDFs. Des méthodes d'extension peuvent être implémentées pour faciliter ce processus en vous permettant de convertir le contenu HTML en PDF avec un simple appel de méthode.

Quelles sont les limites de l'utilisation des méthodes d'extension en C# ?

Les méthodes d'extension ne peuvent pas accéder aux membres privés des types qu'elles étendent. Elles ne participent pas non plus à l'héritage ou au polymorphisme, et ne peuvent pas remplacer les méthodes d'instance existantes.

Comment les méthodes d'extension peuvent-elles améliorer le travail avec une bibliothèque PDF ?

Les méthodes d'extension peuvent améliorer le travail avec une bibliothèque PDF en fournissant des moyens simplifiés d'interagir avec les fonctions de la bibliothèque. Par exemple, vous pouvez créer des méthodes pour convertir directement des URL ou du contenu HTML en PDFs, rationalisant ainsi le processus de codage.

Comment pouvez-vous convertir une URL en PDF à l'aide de méthodes d'extension en C# ?

En étendant la classe Uri avec une méthode d'extension, vous pouvez utiliser une bibliothèque PDF pour convertir une URL web en fichier PDF. Cette méthode peut prendre l'URL et enregistrer le PDF résultant dans un chemin de fichier spécifié.

Quels sont quelques exemples pratiques de méthodes d'extension en C# ?

Les exemples pratiques de méthodes d'extension en C# incluent l'ajout d'une méthode Reverse pour les chaînes, une méthode WordCount pour les chaînes, une méthode Median pour les collections d'entiers et une méthode StartOfWeek pour les structures DateTime.

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