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

Comprendre les paramètres ref

Un paramètre ref est un paramètre de méthode qui sert de référence à la variable passée à 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 passées.

Prenons l'exemple suivant pour illustrer l'utilisation de base de ref, en mettant l'accent sur la façon dont une variable de type référence conserve la valeur de son 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); // Output: 200
    }

    // Method that modifies the original number through 'ref'
    static void ModifyNumber(ref int number)
    {
        number = 200; // Modifies the original value
    }
}

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

    // Method that modifies the original number through 'ref'
    static void ModifyNumber(ref int number)
    {
        number = 200; // Modifies the original value
    }
}

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

	' Method that modifies the original number through 'ref'
	Private Shared Sub ModifyNumber(ByRef number As Integer)
		number = 200 ' Modifies the original value
	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. Dans ModifyNumber, la valeur de number est modifiée à 200. Étant donné que number est passé par référence, le changement est reflété dans la valeur d'origine dans la méthode Main, et 200 est affiché dans la console.

Comment fonctionnent les paramètres 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 d'origine plutôt qu'à une copie. Cela est réalisé en passant l'adresse mémoire de la variable, plutôt que la 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 appliquée à la variable d'origine.

Pour comprendre ref, il est essentiel de savoir qu'il peut être utilisé aussi bien avec des types valeur qu'avec des types référence. Les types valeur incluent les 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 réelle, et non 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. À l'inverse, un paramètre ref exige que la variable soit initialisée avant d'être passée. De plus, une méthode utilisant un paramètre out est obligée d'attribuer 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); // Output: 100
    }

    // Method that calculates a result and assigns it via 'out'
    static void CalculateResult(out int calculation)
    {
        calculation = 20 * 5; // Must initialize the out parameter
    }
}

class Program
{
    static void Main()
    {
        int result;
        CalculateResult(out result);
        Console.WriteLine(result); // Output: 100
    }

    // Method that calculates a result and assigns it via 'out'
    static void CalculateResult(out int calculation)
    {
        calculation = 20 * 5; // Must initialize the out parameter
    }
}

Friend Class Program
	Shared Sub Main()
		Dim result As Integer = Nothing
		CalculateResult(result)
		Console.WriteLine(result) ' Output: 100
	End Sub

	' Method that calculates a result and assigns it via 'out'
	Private Shared Sub CalculateResult(ByRef calculation As Integer)
		calculation = 20 * 5 ' Must initialize the out parameter
	End Sub
End Class

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

Utilisation pratique de ref dans la surcharge de méthode

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 sont composé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 de ref et des paramètres de valeur :

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

    // Method that increments a copy of the integer
    static void IncrementValue(int number)
    {
        number++;
    }

    // Method that increments the original integer using 'ref'
    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}"); // Output: Normal: 10, Ref: 11
    }

    // Method that increments a copy of the integer
    static void IncrementValue(int number)
    {
        number++;
    }

    // Method that increments the original integer using 'ref'
    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}") ' Output: Normal: 10, Ref: 11
	End Sub

	' Method that increments a copy of the integer
'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

	' Method that increments the original integer using 'ref'
'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 d'origine, tandis que la version normale ne modifie qu'une copie.

Introduction à IronPDF

IronPDF pour .NET PDF Solutions est une bibliothèque .NET complète conçue pour travailler avec des documents PDF. Elle est principalement construite en C# et se concentre sur la simplification de la création et de la manipulation de PDF à partir de contenu HTML. En utilisant un moteur de rendu Chrome, IronPDF fournit des documents PDF de haute qualité, au pixel près, qui capturent les nuances du HTML, du CSS, du JavaScript et du contenu d'image.

Cette bibliothèque est polyvalente, prenant en charge un large éventail d'environnements .NET, y compris .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 supporte pas seulement la création de PDF mais offre également des fonctionnalités pour éditer, sécuriser et convertir des PDF en 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, assurant une gestion complète des documents PDF au sein des applications .NET.

using IronPdf;
using System;

class Program
{
    static void Main(string[] args)
    {
        // Set your IronPDF license key
        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.");
    }

    // Method that adds a monthly bonus to sales using 'ref'
    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)
    {
        // Set your IronPDF license key
        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.");
    }

    // Method that adds a monthly bonus to sales using 'ref'
    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)
		' Set your IronPDF license key
		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

	' Method that adds a monthly bonus to sales using 'ref'
	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

Conclusion

Comprendre le mot-clé ref en C# fournit 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 gagnerez en expérience avec ref, vous comprendrez mieux quand et comment l'utiliser efficacement pour répondre à vos besoins de programmation. IronPDF propose un essai gratuit pour commencer à utiliser les fonctionnalités PDF et les prix commencent à partir de $999.