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

En C#, le mot-clé ref 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 les données au sein de 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 la bibliothè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 transmise à la méthode. Contrairement aux paramètres de valeur standard, où seule une copie de la variable est passée, les paramètres ref permettent à la méthode appelée de modifier la valeur de la variable originale. Ce comportement est crucial lorsque vous avez besoin qu'une méthode mette à jour l'état des variables qui lui sont transmises.

Considérez l'exemple suivant pour démontrer l'utilisation de base de ref, en se concentrant sur la manière dont une variable de type référence conserve sa valeur de paramètre dans le même objet lors 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 ModifyNumber, en passant number comme paramètre ref. À l'intérieur de ModifyNumber, la valeur de number est changée à 200. Étant donné que number est passé par référence, le changement est répercuté 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.

La clé pour comprendre ref est de reconnaître qu'il peut être utilisé avec à la fois des types valeur et des types référence. Les types valeur incluent des types de données simples comme les entiers et les structures, tandis que les types référence incluent 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 des types de référence vous permet de modifier la référence elle-même, et pas seulement le contenu de l'objet.

Différences entre ref et out

Bien que les mots-clés ref et out permettent tous deux de modifier les variables d'origine, il existe des distinctions importantes. Un paramètre out ne nécessite pas d'initialisation avant d'être passé à une méthode. Inversement, 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 retourne. 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 calculation à l'intérieur de 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éthode, où la signature de la méthode est modifiée par le mot-clé ref. Les signatures de méthode sont constituées du nom de la méthode et de ses types de paramètres, y compris si les paramètres sont passés par référence (ref), par valeur, ou en tant que paramètre out.

Envisagez de surcharger les méthodes en fonction des paramètres ref et valeur :

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ée avec une version prenant un paramètre normal et une prenant un paramètre ref. La version ref incrémente la variable originale, tandis que la version normale ne modifie qu'une copie.

Introduction à IronPDF

IronPDF for .NET PDF Solutions est une bibliothèque .NET complète conçue pour travailler avec des documents PDF. Il est principalement développé en C# et se concentre sur la simplification de la création et de la manipulation de PDF à 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é avec C# pour tirer parti des fonctionnalités robustes du langage, y compris l'utilisation du mot-clé ref pour passer des 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 de IronPDF avec C# en utilisant le mot-clé ref, considérons un scénario où nous voulons générer un rapport PDF incluant 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, laquelle est 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 incluant 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 par référence en utilisant le mot-clé ref, calcule une prime de 10 %, et l'ajoute à la valeur de ventes initiale. 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

Comprendre le mot-clé ref en C# offre 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 passés, ref peut rendre vos méthodes plus flexibles et puissantes.

À mesure que vous gagnez 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 essai gratuit pour commencer avec les capacités PDF et les prix commencent à partir de $749.