C# Ref (Comment ça marche pour les développeurs)

En C#, l'optionmot-clé de référence est une fonctionnalité puissante qui permet aux méthodes de modifier la valeur des paramètres des variables de type référence passées. Comprendre comment utiliser ref peut améliorer votre capacité à gérer et à manipuler des données dans vos applications.

Cet article vous guidera à travers les bases du mot-clé ref, son application et les nuances de son utilisation avec différents types de données. Nous découvrirons également le mot-clé ref, son application et les nuances de son utilisation avec différents types de donnéesBibliothèque IronPDF pour .NET qui est une bibliothèque PDF.

Comprendre les paramètres de réf

Un paramètre ref est un paramètre de méthode qui agit comme une référence à la variable passée dans la méthode. Contrairement aux paramètres de valeur standard, où seule une copie de la variable est transmise, les paramètres ref permettent à la méthode appelée de modifier la valeur de la variable d'origine. Ce comportement est crucial lorsque vous avez besoin qu'une méthode mette à jour l'état des variables qui lui sont transmises.

L'exemple suivant illustre l'utilisation de base de ref, en mettant l'accent sur la manière dont une variable de type référence conserve sa valeur de paramètre dans le même objet tout au long des appels de méthode :

class Program
{
    static void Main()
    {
        int number = 100;
        ModifyNumber(ref number);
        Console.WriteLine(number);
    }
    static void ModifyNumber(ref int number)
    {
        number = 200;
    }
}

class Program
{
    static void Main()
    {
        int number = 100;
        ModifyNumber(ref number);
        Console.WriteLine(number);
    }
    static void ModifyNumber(ref int number)
    {
        number = 200;
    }
}

Friend Class Program
	Shared Sub Main()
		Dim number As Integer = 100
		ModifyNumber(number)
		Console.WriteLine(number)
	End Sub
	Private Shared Sub ModifyNumber(ByRef number As Integer)
		number = 200
	End Sub
End Class

Dans cet exemple, la méthode Main déclare un entier number et l'initialise à 100. Elle appelle ensuite ModifierNombre, en passant nombre comme paramètre ref. Dans ModifyNumber, la valeur de number est changée en 200. Comme number est passé par référence, la modification est répercutée sur la valeur originale dans la méthode Main, et 200 est imprimé sur la console.

Fonctionnement des paramètres de ref

Lorsque vous déclarez un paramètre de méthode avec le mot-clé ref, vous indiquez au compilateur que le paramètre fera référence à la variable originale plutôt qu'à une copie. Pour ce faire, on transmet l'adresse mémoire de la variable plutôt que sa valeur réelle. La méthode appelée et la méthode appelante accèdent toutes deux au même emplacement mémoire, ce qui signifie que toute modification apportée au paramètre est directement répercutée sur la variable d'origine.

Pour comprendre ref, il faut savoir qu'il peut être utilisé à la fois avec les types de valeur et les types de référence. Les types de valeur comprennent les types de données simples tels que les entiers et les structures, tandis que les types de référence comprennent les objets et les tableaux. Cependant, même si les variables de type référence contiennent intrinsèquement des adresses mémoire, l'utilisation de ref avec les types de référence vous permet de modifier la référence réelle, et pas seulement le contenu de l'objet.

Différences entre ref et out

Les mots-clés ref et out permettent tous deux de modifier les variables d'origine, mais il existe des distinctions importantes. Un paramètre out n'a pas besoin d'être initialisé avant d'être transmis à une méthode. À l'inverse, un paramètre ref exige que la variable soit initialisée avant d'être transmise. De plus, une méthode utilisant un paramètre out est obligée d'assigner une valeur avant que la méthode ne revienne. Cette exigence ne s'applique pas aux paramètres ref.

Voici comment vous pourriez utiliser le mot-clé out :

class Program
{
    static void Main()
    {
        int result;
        CalculateResult(out result);
        Console.WriteLine(result);
    }
    static void CalculateResult(out int calculation)
    {
        calculation = 20 * 5;
    }
}

class Program
{
    static void Main()
    {
        int result;
        CalculateResult(out result);
        Console.WriteLine(result);
    }
    static void CalculateResult(out int calculation)
    {
        calculation = 20 * 5;
    }
}

Friend Class Program
	Shared Sub Main()
		Dim result As Integer = Nothing
		CalculateResult(result)
		Console.WriteLine(result)
	End Sub
	Private Shared Sub CalculateResult(ByRef calculation As Integer)
		calculation = 20 * 5
	End Sub
End Class

Dans ce cas, CalculateResult initialise le calcul dans la méthode, et Main reflète le résultat.

Utilisation pratique de ref dans la surcharge des méthodes

ref peut également être utilisé dans la surcharge de méthodes, où la signature de la méthode est modifiée par le mot-clé ref. Les signatures de méthode comprennent le nom de la méthode et les types de paramètres, y compris si les paramètres sont transmis par référence(ref)par valeur ou en tant que paramètre out.

Envisager la surcharge des méthodes basées sur les paramètres ref et value :

class Program
{
    static void Main()
    {
        int normalParameter = 10, refParameter = 10;
        IncrementValue(normalParameter);
        IncrementValue(ref refParameter);
        Console.WriteLine($"Normal: {normalParameter}, Ref: {refParameter}");
    }
    static void IncrementValue(int number)
    {
        number++;
    }
    static void IncrementValue(ref int number)
    {
        number++;
    }
}

class Program
{
    static void Main()
    {
        int normalParameter = 10, refParameter = 10;
        IncrementValue(normalParameter);
        IncrementValue(ref refParameter);
        Console.WriteLine($"Normal: {normalParameter}, Ref: {refParameter}");
    }
    static void IncrementValue(int number)
    {
        number++;
    }
    static void IncrementValue(ref int number)
    {
        number++;
    }
}

Friend Class Program
	Shared Sub Main()
		Dim normalParameter As Integer = 10, refParameter As Integer = 10
		IncrementValue(normalParameter)
		IncrementValue(refParameter)
		Console.WriteLine($"Normal: {normalParameter}, Ref: {refParameter}")
	End Sub
'INSTANT VB TODO TASK: VB does not allow method overloads which differ only in parameter ByVal/ByRef:
'ORIGINAL LINE: static void IncrementValue(int number)
	Private Shared Sub IncrementValue(ByVal number As Integer)
		number += 1
	End Sub
'INSTANT VB TODO TASK: VB does not allow method overloads which differ only in parameter ByVal/ByRef:
'ORIGINAL LINE: static void IncrementValue(ref int number)
	Private Shared Sub IncrementValue(ByRef number As Integer)
		number += 1
	End Sub
End Class

Ici, IncrementValue est surchargé avec une version prenant un paramètre normal et une autre prenant un paramètre ref. La version ref incrémente la variable originale, alors que la version normale ne modifie qu'une copie.

Introduction à IronPDF

IronPDF for .NET PDF Solutions (en anglais) est une bibliothèque .NET complète conçue pour travailler avec des documents PDF. Il est construit principalement en C# et se concentre sur la simplification de la création et de la manipulation dePDF à partir de contenu HTML. En employant un moteur de rendu Chrome, IronPDF produit des documents PDF de haute qualité, parfaits au pixel près, qui capturent les nuances du HTML, du CSS, du JavaScript et du contenu des images.

Cette bibliothèque est polyvalente et prend en charge un large éventail d'environnements .NET, notamment .NET Framework, .NET Core et .NET Standard, ce qui la rend adaptée à diverses applications, des systèmes de bureau aux systèmes basés sur le web. IronPDF ne se contente pas de prendre en charge la création de PDF, mais offre également des fonctionnalités d'édition, de sécurisation et de conversion des PDF dans d'autres formats.

Cette capacité s'étend à l'extraction de texte et d'images, au remplissage de formulaires et même à l'application de signatures numériques, ce qui garantit une gestion complète des documents PDF dans les applications .NET.

Intégration d'IronPDF avec C# ; et ref Keyword

IronPDF peut être intégré à C# pour tirer parti des fonctionnalités robustes du langage, notamment l'utilisation du mot-clé ref pour le passage de paramètres par référence. Cette intégration permet de générer des PDF dynamiques dont le contenu peut dépendre de variables dont les valeurs sont déterminées au moment de l'exécution.

Pour illustrer l'intégration d'IronPDF avec C# à l'aide du mot-clé ref, considérons un scénario dans lequel nous voulons générer un rapport PDF qui inclut une valeur calculée dynamiquement. Cette valeur sera calculée dans une méthode qui accepte un paramètre ref, permettant à la méthode de modifier cette valeur, qui sera ensuite reflétée dans le PDF généré.

Exemple de code : Générer un PDF avec un contenu dynamique à l'aide de ref

Le code C# suivant montre comment utiliser IronPDF en conjonction avec le mot-clé ref pour générer un document PDF. Le code calcule une valeur, la modifie via une méthode qui accepte un paramètre ref, puis utilise IronPDF pour générer un PDF qui inclut ce contenu dynamique.

using IronPdf;
using System;
class Program
{
    static void Main(string [] args)
    {
        License.LicenseKey = "License-Key";
        // Initialize the value
        int totalSales = 150;
        // Modify the value within the method using 'ref'
        AddMonthlyBonus(ref totalSales);
        // Use IronPDF to generate a PDF report
        var Renderer = new ChromePdfRenderer();
        var PDF = Renderer.RenderHtmlAsPdf($"<h1>Monthly Sales Report</h1><p>Total Sales, including bonus: {totalSales}</p>");
        // Save the PDF to a file
        PDF.SaveAs("MonthlySalesReport.pdf");
        // Confirm the PDF has been generated
        Console.WriteLine("PDF generated successfully. Check your project directory.");
    }
    static void AddMonthlyBonus(ref int sales)
    {
        // Assume a bonus of 10% of the sales
        sales += (int)(sales * 0.1);
    }
}

using IronPdf;
using System;
class Program
{
    static void Main(string [] args)
    {
        License.LicenseKey = "License-Key";
        // Initialize the value
        int totalSales = 150;
        // Modify the value within the method using 'ref'
        AddMonthlyBonus(ref totalSales);
        // Use IronPDF to generate a PDF report
        var Renderer = new ChromePdfRenderer();
        var PDF = Renderer.RenderHtmlAsPdf($"<h1>Monthly Sales Report</h1><p>Total Sales, including bonus: {totalSales}</p>");
        // Save the PDF to a file
        PDF.SaveAs("MonthlySalesReport.pdf");
        // Confirm the PDF has been generated
        Console.WriteLine("PDF generated successfully. Check your project directory.");
    }
    static void AddMonthlyBonus(ref int sales)
    {
        // Assume a bonus of 10% of the sales
        sales += (int)(sales * 0.1);
    }
}

Imports IronPdf
Imports System
Friend Class Program
	Shared Sub Main(ByVal args() As String)
		License.LicenseKey = "License-Key"
		' Initialize the value
		Dim totalSales As Integer = 150
		' Modify the value within the method using 'ref'
		AddMonthlyBonus(totalSales)
		' Use IronPDF to generate a PDF report
		Dim Renderer = New ChromePdfRenderer()
		Dim PDF = Renderer.RenderHtmlAsPdf($"<h1>Monthly Sales Report</h1><p>Total Sales, including bonus: {totalSales}</p>")
		' Save the PDF to a file
		PDF.SaveAs("MonthlySalesReport.pdf")
		' Confirm the PDF has been generated
		Console.WriteLine("PDF generated successfully. Check your project directory.")
	End Sub
	Private Shared Sub AddMonthlyBonus(ByRef sales As Integer)
		' Assume a bonus of 10% of the sales
		sales += CInt(Math.Truncate(sales * 0.1))
	End Sub
End Class

Dans cet exemple, totalSales commence à 150. La méthode AddMonthlyBonus prend cette valeur en référence à l'aide du mot-clé ref, calcule un bonus de 10 % et l'ajoute à la valeur initiale des ventes. IronPDF génère ensuite un document PDF contenant un extrait HTML qui indique le total des ventes, y compris la prime. Le document final est enregistré localement sous le nom de "MonthlySalesReport.pdf".

Conclusion

La compréhension du mot-clé ref dans C# constitue un outil précieux pour gérer la manière dont les données sont transmises entre les méthodes. En permettant aux méthodes de modifier directement les valeurs originales des paramètres qui leur sont transmis, ref peut rendre vos méthodes plus flexibles et plus puissantes.

Au fur et à mesure que vous acquerrez de l'expérience avec ref, vous comprendrez mieux quand et comment l'utiliser efficacement pour répondre à vos besoins de programmation. IronPDF offre un service deessai gratuit pour commencer à utiliser les fonctionnalités PDF et les prix commencent à partir de 749 $.