Icône de message
Passer au contenu du pied de page
  1. IronPDF
  2. Blog IronPDF
  3. .NET Aide
  4. Passage par référence en C#
.NET AIDE

C# Pass by Reference (Comment ça fonctionne pour les développeurs)

Curtis Chau
Curtis Chau
Mis à jour:

La gestion efficace de la mémoire et la manipulation des données sont des éléments essentiels pour créer un code à haute performance dans le monde de la programmation. Écrire un code efficace et sans erreur nécessite de comprendre comment les données sont transmises entre les méthodes et les fonctions dans des langages comme C#. Une idée qui est cruciale pour cette procédure est "le passage par référence". Nous explorerons la signification du passage par référence en C# et les scénarios d'utilisation appropriés dans cet article.

Comment utiliser le passage par référence en C

  1. Définir une méthode avec des paramètres en Ref.
  2. Initialiser une variable.
  3. Appeler la méthode avec le mot-clé Ref.
  4. Modifier la variable à l'intérieur de la méthode.
  5. Observer les changements dans la méthode principale.
  6. Définir une autre méthode avec un paramètre Out pour générer un PDF.
  7. Initialiser et appeler la méthode Out.

Qu'est-ce que le passage par référence en C#?

Utiliser une référence pour passer fait référence à la manière en C# d'envoyer des arguments à des fonctions ou des méthodes en fournissant une référence à la variable initiale de la méthode appelée au lieu d'une copie de sa valeur. Cela signifie que tout changement apporté au paramètre à l'intérieur de la méthode aura également un impact sur la variable initiale en dehors de la méthode.

Les variables de type valeur en C# (comme int, float, bool, etc.) sont généralement fournies par valeur, ce qui signifie que la méthode reçoit une copie de la valeur de la variable. Néanmoins, vous pouvez dire au compilateur de passer les arguments par référence en utilisant le mot-clé ref.

Utilisation du mot-clé ref

En C#, des arguments peuvent être faits pour des paramètres de référence passés par référence en utilisant le mot-clé ref. Toutes modifications apportées à un paramètre fourni par référence en utilisant le mot-clé ref auront un impact sur la variable originale.

class Program
{
    static void Main(string[] args)
    {
        int num = 10;
        Console.WriteLine("Before: " + num); // Output: Before: 10
        ModifyByRef(ref num);
        Console.WriteLine("After: " + num);  // Output: After: 20
    }

    // Method that modifies the integer by reference
    static void ModifyByRef(ref int x)
    {
        x = x * 2; // Modify the original value by reference
    }
}
class Program
{
    static void Main(string[] args)
    {
        int num = 10;
        Console.WriteLine("Before: " + num); // Output: Before: 10
        ModifyByRef(ref num);
        Console.WriteLine("After: " + num);  // Output: After: 20
    }

    // Method that modifies the integer by reference
    static void ModifyByRef(ref int x)
    {
        x = x * 2; // Modify the original value by reference
    }
}
Friend Class Program
	Shared Sub Main(ByVal args() As String)
		Dim num As Integer = 10
		Console.WriteLine("Before: " & num) ' Output: Before: 10
		ModifyByRef(num)
		Console.WriteLine("After: " & num) ' Output: After: 20
	End Sub

	' Method that modifies the integer by reference
	Private Shared Sub ModifyByRef(ByRef x As Integer)
		x = x * 2 ' Modify the original value by reference
	End Sub
End Class
$vbLabelText   $csharpLabel

La méthode ModifyByRef dans l'exemple ci-dessus utilise le mot-clé ref pour prendre un paramètre entier, x, par référence. Toutes modifications apportées au paramètre ref x à l'intérieur de la méthode ont un impact immédiat sur la variable num en dehors de la méthode lorsque la méthode est invoquée avec ref num.

Le mot-clé out

Le mot-clé out est utilisé pour passer des paramètres par référence à la méthode appelante, tout comme ref. En conséquence, les méthodes sont capables de retourner de nombreuses valeurs.

class Program
{
    static void Main(string[] args)
    {
        int result;
        Calculate(10, 5, out result);
        Console.WriteLine("Result: " + result); // Output: Result: 15
    }

    // Method that calculates the sum of two integers and outputs the result by reference
    static void Calculate(int x, int y, out int result)
    {
        result = x + y; // Assign the sum to the out parameter
    }
}
class Program
{
    static void Main(string[] args)
    {
        int result;
        Calculate(10, 5, out result);
        Console.WriteLine("Result: " + result); // Output: Result: 15
    }

    // Method that calculates the sum of two integers and outputs the result by reference
    static void Calculate(int x, int y, out int result)
    {
        result = x + y; // Assign the sum to the out parameter
    }
}
Friend Class Program
	Shared Sub Main(ByVal args() As String)
		Dim result As Integer = Nothing
		Calculate(10, 5, result)
		Console.WriteLine("Result: " & result) ' Output: Result: 15
	End Sub

	' Method that calculates the sum of two integers and outputs the result by reference
	Private Shared Sub Calculate(ByVal x As Integer, ByVal y As Integer, ByRef result As Integer)
		result = x + y ' Assign the sum to the out parameter
	End Sub
End Class
$vbLabelText   $csharpLabel

Deux paramètres entiers, x et y, ainsi qu'un paramètre supplémentaire result désigné par le mot-clé out, sont passés à la méthode Calculate dans cet exemple. Le résultat est assigné au paramètre result après que la procédure a calculé la somme de x et y. Le result n'a pas besoin d'être initialisé avant d'être envoyé à la méthode car il est marqué comme out.

Quand utiliser le passage par référence

Écrire un code efficace et maintenable nécessite de savoir quand utiliser le passage par référence. Les situations suivantes appellent l'utilisation du passage par référence:

Modification de plusieurs variables

Passer les paramètres par référence peut être utile lorsqu'une méthode doit modifier plusieurs variables et que ces modifications doivent se refléter en dehors de la méthode. Plutôt que d'avoir la procédure qui retourne plusieurs valeurs, les variables peuvent être envoyées par référence et modifiées directement au sein de la méthode.

// Method that modifies multiple variables by reference
static void ModifyMultipleByRef(ref int a, ref int b)
{
    a *= 2; // Double the first variable
    b *= 3; // Triple the second variable
}
// Method that modifies multiple variables by reference
static void ModifyMultipleByRef(ref int a, ref int b)
{
    a *= 2; // Double the first variable
    b *= 3; // Triple the second variable
}
' Method that modifies multiple variables by reference
Shared Sub ModifyMultipleByRef(ByRef a As Integer, ByRef b As Integer)
	a *= 2 ' Double the first variable
	b *= 3 ' Triple the second variable
End Sub
$vbLabelText   $csharpLabel

Structures de données volumineuses

En empêchant la duplication inutile de données, passer des structures de données volumineuses—comme des tableaux ou des objets complexes—par référence peut améliorer l'efficacité. Le passage par référence doit être utilisé avec prudence lorsqu'on travaille avec de grandes structures de données, car cela peut avoir des conséquences imprévues si ce n'est pas bien géré.

Interopérabilité avec le code externe

Il peut être nécessaire d'envoyer des arguments par référence afin de respecter la définition de la méthode et les exigences du code externe lorsqu'on interagit avec des bibliothèques externes ou qu'on intègre du code natif.

Qu'est-ce que IronPDF?

IronPDF permet aux programmeurs de créer, modifier et rendre des documents PDF dans les applications .NET. Son ensemble complet de fonctionnalités rend le travail avec les fichiers PDF simple. Vous pouvez créer des documents PDF à partir de HTML, d'images et d'autres formats; annoter des PDFs avec du texte, des images, et d'autres données; et diviser, fusionner, et modifier des documents PDF existants.

La principale fonctionnalité d'IronPDF est sa capacité à convertir HTML en PDF, garantissant que les mises en page et les styles sont préservés. Cette fonctionnalité est excellente pour générer des PDFs à partir de contenu web comme des rapports, des factures, et de la documentation. Il convertit des fichiers HTML, des URL, et des chaînes HTML en fichiers 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
$vbLabelText   $csharpLabel

Caractéristiques de IronPDF

Annotation de texte et d'images

IronPDF vous permet d'ajouter du texte, des images, et des annotations à des documents PDF par programmation. Vous pouvez annoter des fichiers PDF avec des signatures, des tampons, et des remarques grâce à cette fonctionnalité.

Sécurité des PDF

IronPDF vous permet de spécifier différentes autorisations, notamment l'impression, la copie de contenu, et l'édition du document, et il peut chiffrer des documents PDF avec des mots de passe. Cela vous aide à contrôler l'accès aux fichiers PDF et à protéger les données sensibles.

Remplissage de formulaires PDF interactifs

IronPDF vous permet de remplir des formulaires PDF interactifs par programmation. Cette capacité est utile pour créer des documents personnalisés à l'aide d'informations utilisateurs ou pour automatiser les soumissions de formulaires.

Compression et optimisation des PDF

Pour minimiser la taille des fichiers sans sacrifier la qualité, IronPDF propose des solutions pour la compression et l'optimisation des fichiers PDF. Cela réduit la quantité de stockage nécessaire pour les documents PDF tout en améliorant les performances.

Compatibilité multiplateforme

IronPDF est conçu pour fonctionner sans faille avec les applications .NET destinées à Windows, Linux, et macOS, entre autres plateformes. Il est intégré aux cadres .NET populaires comme ASP.NET, .NET Core, et Xamarin.

Créer un Nouveau Projet Visual Studio

Créer un projet console avec Visual Studio est facile. Pour créer une application Console, procédez comme suit dans Visual Studio:

Avant de commencer le développement Visual Studio, assurez-vous de l'avoir installé sur votre ordinateur.

Démarrer un Nouveau Projet

Sélectionnez Fichier, puis Nouveau, et enfin Projet.

Passage par référence en C# (Comment cela fonctionne pour les développeurs) : Figure 1

Sur le côté gauche de la boîte « Créer un nouveau projet », sélectionnez votre langage de programmation préféré (C#, par exemple).

Le modèle « Application Console » ou « Application Console (.NET Core) » peut être choisi dans la liste suivante de modèles de projets.

Fournissez un nom pour votre projet dans le champ « Nom ».

Passage par référence en C# (Comment cela fonctionne pour les développeurs) : Figure 2

Sélectionnez l'emplacement de stockage où vous souhaitez conserver le projet.

Appuyez sur « Créer » pour démarrer le projet d'application console.

Passage par référence en C# (Comment cela fonctionne pour les développeurs) : Figure 3

Installation d'IronPDF

Sous Outils dans les outils de Visual Studio, vous pouvez trouver l'interface de commande visuelle. Sélectionnez le gestionnaire de paquets pour NuGet. Dans l'onglet terminal de gestion des paquets, vous devez taper la commande suivante.

Install-Package IronPdf

Une alternative supplémentaire consiste à utiliser le gestionnaire de paquets. L'installation du paquet directement dans la solution est possible avec l'option NuGet Package Manager. Utilisez la zone de recherche sur le site NuGet pour trouver des paquets. L'exemple de capture d'écran suivant illustre à quel point il est facile de rechercher "IronPDF" dans le gestionnaire de paquets:

Passage par référence en C# (Comment cela fonctionne pour les développeurs): Figure 4 - Installation d'IronPDF depuis le gestionnaire de paquets NuGet

La liste des résultats de recherche pertinents peut être vue sur l'image ci-dessus. Pour permettre l'installation du logiciel sur votre machine, veuillez ajuster ces paramètres.

Une fois le paquet téléchargé et installé, il peut maintenant être utilisé dans le projet actuel.

Utilisation du passage par référence avec IronPDF

Voici une illustration de la façon d'utiliser la fonction de passage par référence d'IronPDF.

using IronPdf;
using System;

class Program
{
    static void Main(string[] args)
    {
        // Create a PDF document
        var pdf = new IronPdf.HtmlToPdf();
        // HTML content to be converted to PDF
        string htmlContent = "<h1>Hello, IronPDF!</h1>";
        // Create a byte array to store the PDF content
        byte[] pdfBytes;
        // Convert HTML to PDF and pass the byte array by reference
        ConvertHtmlToPdf(pdf, htmlContent, out pdfBytes);
        // Save or process the PDF content
        // For demonstration, let's print the length of the PDF content
        Console.WriteLine("Length of PDF: " + pdfBytes.Length);
    }

    // Method that converts HTML content to PDF and stores it in a byte array by reference
    static void ConvertHtmlToPdf(IronPdf.HtmlToPdf pdfConverter, string htmlContent, out byte[] pdfBytes)
    {
        // Convert HTML to PDF and store the result in the byte array
        var pdfDoc = pdfConverter.RenderHtmlAsPdf(htmlContent);
        pdfBytes = pdfDoc.BinaryData;
    }
}
using IronPdf;
using System;

class Program
{
    static void Main(string[] args)
    {
        // Create a PDF document
        var pdf = new IronPdf.HtmlToPdf();
        // HTML content to be converted to PDF
        string htmlContent = "<h1>Hello, IronPDF!</h1>";
        // Create a byte array to store the PDF content
        byte[] pdfBytes;
        // Convert HTML to PDF and pass the byte array by reference
        ConvertHtmlToPdf(pdf, htmlContent, out pdfBytes);
        // Save or process the PDF content
        // For demonstration, let's print the length of the PDF content
        Console.WriteLine("Length of PDF: " + pdfBytes.Length);
    }

    // Method that converts HTML content to PDF and stores it in a byte array by reference
    static void ConvertHtmlToPdf(IronPdf.HtmlToPdf pdfConverter, string htmlContent, out byte[] pdfBytes)
    {
        // Convert HTML to PDF and store the result in the byte array
        var pdfDoc = pdfConverter.RenderHtmlAsPdf(htmlContent);
        pdfBytes = pdfDoc.BinaryData;
    }
}
Imports IronPdf
Imports System

Friend Class Program
	Shared Sub Main(ByVal args() As String)
		' Create a PDF document
		Dim pdf = New IronPdf.HtmlToPdf()
		' HTML content to be converted to PDF
		Dim htmlContent As String = "<h1>Hello, IronPDF!</h1>"
		' Create a byte array to store the PDF content
		Dim pdfBytes() As Byte = Nothing
		' Convert HTML to PDF and pass the byte array by reference
		ConvertHtmlToPdf(pdf, htmlContent, pdfBytes)
		' Save or process the PDF content
		' For demonstration, let's print the length of the PDF content
		Console.WriteLine("Length of PDF: " & pdfBytes.Length)
	End Sub

	' Method that converts HTML content to PDF and stores it in a byte array by reference
	Private Shared Sub ConvertHtmlToPdf(ByVal pdfConverter As IronPdf.HtmlToPdf, ByVal htmlContent As String, ByRef pdfBytes() As Byte)
		' Convert HTML to PDF and store the result in the byte array
		Dim pdfDoc = pdfConverter.RenderHtmlAsPdf(htmlContent)
		pdfBytes = pdfDoc.BinaryData
	End Sub
End Class
$vbLabelText   $csharpLabel

La fonction ConvertHtmlToPdf dans cet exemple prend trois paramètres : contenu HTML, un tableau d'octets appelé pdfBytes, et un objet IronPDF HtmlToPdf. Le mot-clé out indique que le paramètre pdfBytes est fourni par référence et sera modifié au sein de la méthode.

Passage par référence en C# (Comment cela fonctionne pour les développeurs): Figure 5

Le contenu HTML est rendu en tant que document PDF à l'aide d'IronPDF dans la fonction ConvertHtmlToPdf, et les données binaires qui en résultent sont stockées dans le tableau pdfBytes.

Nous utilisons de nouveau la conversion HTML en PDF d'IronPDF dans la fonction Main, en passant le tableau pdfBytes par référence. Après l'appel de la méthode, le contenu PDF d'IronPDF est stocké dans l'emplacement mémoire du tableau pdfBytes.

Passage par référence en C# (Comment cela fonctionne pour les développeurs): Figure 6

Cela vous montre comment créer et travailler avec des documents PDF de manière efficace en utilisant IronPDF et le passage par référence en C#.

Conclusion

En résumé, utiliser IronPDF avec le passage par référence en C# améliore considérablement les capacités de création et de modification des documents PDF dans les programmes .NET. L'utilisation efficace des mots-clés ref et out permet aux développeurs de transmettre les arguments par référence avec facilité, permettant de modifier rapidement et efficacement les variables et le contenu au sein des méthodes. La large gamme de fonctionnalités d'IronPDF, qui incluent la capacité de convertir HTML en PDF, de générer des PDFs basés sur des images, et d'effectuer des tâches de modification PDF étendues, permet aux développeurs de construire facilement des documents PDF dynamiques et interactifs.

IronPDF offre les outils et les API nécessaires pour accélérer les processus de traitement de documents, y compris la division, la fusion, l'annotation, et l'optimisation de fichiers PDF. De plus, l'interopérabilité multiplateforme d'IronPDF garantit que les applications C# peuvent intégrer des fonctionnalités PDF avec facilité dans une variété d'environnements. Essentiellement, les développeurs peuvent créer de nouvelles voies pour créer, modifier, et afficher des documents PDF dans leurs applications en fusionnant la puissance du passage par référence de C# avec l'abondante gamme de fonctionnalités d'IronPDF.

Enfin, vous pouvez travailler efficacement avec Excel, créer des PDFs, effectuer une reconnaissance optique de caractères, et utiliser des codes-barres. Le prix de chaque bibliothèque commence à partir de $799. Les développeurs peuvent choisir le meilleur modèle avec confiance s'il existe des options de licence claires qui sont adaptées aux besoins du projet. Avec ces avantages, les développeurs peuvent faire face à une variété de défis avec efficacité et transparence.

Questions Fréquemment Posées

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

Vous pouvez utiliser la méthode RenderHtmlAsPdf de IronPDF pour convertir des chaînes HTML en PDF. Cette méthode vous permet de transformer facilement des pages web ou du contenu HTML en documents PDF de haute qualité, préservant la mise en page et le formatage d'origine.

Qu'est-ce que le passage par référence en C# ?

Le passage par référence en C# se réfère à une méthode de transmission des arguments aux fonctions ou méthodes en fournissant une référence à la variable originale au lieu d'une copie de sa valeur. Cela permet à toute modification effectuée sur le paramètre à l'intérieur de la méthode d'affecter la variable originale.

Comment utilisez-vous les mots clés 'ref' et 'out' en C# ?

En C#, le mot clé 'ref' est utilisé pour passer des arguments par référence, permettant aux modifications au sein de la méthode d'affecter la variable originale. Le mot clé 'out' est similaire mais ne nécessite pas que la variable soit initialisée au préalable, permettant aux méthodes de renvoyer plusieurs valeurs.

Quand devriez-vous utiliser le passage par référence en C# ?

Le passage par référence doit être utilisé lorsque vous avez besoin de modifier plusieurs variables, de gérer de grandes structures de données pour éviter des copies inutiles, ou lors de l'interaction avec des bibliothèques externes nécessitant des paramètres de référence.

Comment une bibliothèque de traitement PDF peut-elle utiliser le passage par référence ?

Une bibliothèque de traitement PDF comme IronPDF peut utiliser le passage par référence pour stocker les données PDF dans un tableau d'octets à l'aide du mot clé 'out'. Cela permet un traitement et une modification efficaces du contenu PDF dans les méthodes, tel que convertir du HTML en PDF et stocker le résultat dans un tableau d'octets.

Quels sont les avantages d'utiliser une bibliothèque de traitement PDF dans .NET ?

Une bibliothèque de traitement PDF comme IronPDF offre des fonctionnalités telles que la conversion HTML en PDF, l'annotation de texte et d'images, la sécurité PDF, le remplissage de formulaires, la compression et l'optimisation. Elle est compatible avec les applications .NET, améliorant la fonctionnalité et la compatibilité multiplateformes.

Comment installer une bibliothèque de traitement PDF dans un projet Visual Studio ?

Une bibliothèque de traitement PDF peut être installée dans un projet Visual Studio en utilisant le gestionnaire de packages NuGet. Utilisez la commande appropriée dans le terminal de gestion des packages ou recherchez la bibliothèque dans l'interface du gestionnaire de packages NuGet.

IronPDF peut-il être utilisé avec ASP.NET et .NET Core ?

Oui, IronPDF est conçu pour s'intégrer parfaitement aux applications ASP.NET et .NET Core, permettant aux développeurs de créer, modifier et rendre des documents PDF sur diverses plateformes.

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