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 agit comme une référence à la variable passée dans la méthode. Contrairement aux paramètres de valeur standard, où seul un duplicata de la variable est passé, 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.

Considérez l'exemple suivant pour démontrer l'utilisation de base de ref, en se concentrant sur comment 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); // 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 changée à 200. Comme 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é à 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.

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

Différences entre ref et out

Bien que les mots-clés ref et out permettent 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 passée. De plus, une méthode utilisant un paramètre out est obligée d'assigner une valeur avant que la méthode ne se termine. 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 au sein de 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éthode, 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 comme paramètre out.

Considérez la surcharge des méthodes en fonction des paramètres 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 prenant un paramètre ref. La version ref incrémente la variable d'origine, tandis que la version normale ne change 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 PDFs à 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, supportant une large gamme 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 web. IronPDF ne supporte pas seulement la création de PDF mais offre également des fonctionnalités pour éditer, sécuriser et convertir des PDFs 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# offre un outil précieux pour gérer la façon dont les données sont passées entre les méthodes. En permettant aux méthodes de modifier directement les valeurs d'origine des paramètres qui leur sont passés, ref peut rendre vos méthodes plus flexibles et puissantes.

À mesure que vous acquérez de l'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 avec les capacités PDF et les prix commencent à partir de $799.