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

Le mot-clé C# ref est un outil essentiel que chaque débutant devrait apprendre. Il est utilisé pour passer des arguments ou des args par référence plutôt que par valeur, ce qui permet aux modifications apportées à la variable de type référence dans la méthode appelée de se répercuter à l'extérieur de celle-ci. Dans ce didacticiel, nous examinerons en détail le mot-clé ref et explorerons divers exemples de code sur console qui illustrent son fonctionnement.

Introduction au mot-clé ref

Lorsque vous passez un paramètre de méthode en C#, par défaut, il est passé par valeur. Cela signifie qu'une copie de la valeur du paramètre est créée et que toute modification apportée dans la méthode appelante n'affectera pas la variable originale en dehors de la méthode. Le mot-clé ref modifie ce comportement, vous permettant de passer un paramètre par référence. Lorsqu'un paramètre est transmis par référence, toute modification apportée au sein de la méthode affectera directement la variable d'origine en dehors de la méthode.

Concepts clés

• Mot-clé ref : Utilisé pour indiquer qu'une variable est passée par référence.
• Variables de référence : Types qui font référence à l'emplacement mémoire où les données sont stockées.
• Types de valeurs : Types qui contiennent les données réelles.
• Variable d'origine : La variable en dehors de la méthode qui reflète les modifications effectuées à l'intérieur de la méthode lors de l'utilisation des mots-clés ref.

Passage par référence

Commençons par comprendre le concept de transmission des variables par référence. Imaginez que vous ayez une méthode qui incrémente un nombre entier, comme le montre le code suivant :

class Program
{
//method returns incremented value
    static void IncrementByOne(int num)
    {
        num++;
    }

    static void Main()
    {
        int value = 5;
        IncrementByOne(value);
        Console.WriteLine(value);  // Output: 5
    }
}

class Program
{
//method returns incremented value
    static void IncrementByOne(int num)
    {
        num++;
    }

    static void Main()
    {
        int value = 5;
        IncrementByOne(value);
        Console.WriteLine(value);  // Output: 5
    }
}

Friend Class Program
'method returns incremented value
	Private Shared Sub IncrementByOne(ByVal num As Integer)
		num += 1
	End Sub

	Shared Sub Main()
		Dim value As Integer = 5
		IncrementByOne(value)
		Console.WriteLine(value) ' Output: 5
	End Sub
End Class

Dans le code ci-dessus, bien que nous ayons incrémenté num dans la méthode IncrementByOne, la valeur originale reste inchangée. Cela est dû au fait que num est une copie de la variable originale, et les modifications qui y sont apportées n'affectent pas l'originale.

Utilisation du mot-clé ref

Voyons maintenant comment le mot-clé ref peut modifier ce comportement. En utilisant ref, vous pouvez passer une variable par référence à la méthode comme illustré dans l'un des exemples de code ci-dessous.

class Program
{
//ref int
    static void IncrementByOneRef(ref int num)
    {
        num++;
    }

    static void Main()
    {
        int value = 5;
        IncrementByOneRef(ref value);
        Console.WriteLine(value);  // Output: 6
    }
}

class Program
{
//ref int
    static void IncrementByOneRef(ref int num)
    {
        num++;
    }

    static void Main()
    {
        int value = 5;
        IncrementByOneRef(ref value);
        Console.WriteLine(value);  // Output: 6
    }
}

Friend Class Program
'ref int
	Private Shared Sub IncrementByOneRef(ByRef num As Integer)
		num += 1
	End Sub

	Shared Sub Main()
		Dim value As Integer = 5
		IncrementByOneRef(value)
		Console.WriteLine(value) ' Output: 6
	End Sub
End Class

Remarquez le mot-clé ref à la fois dans la signature de la méthode et dans l'appel. Cela indique à C# que vous voulez passer la variable value par référence. En conséquence, les modifications apportées au sein de la méthode IncrementByOneRef se reflètent dans la variable d'origine value.

Travailler avec des types de valeurs

Le mot-clé ref est particulièrement utile lors du travail avec des types tels que les entiers, les doubles et les structures. Ces types sont stockés directement en mémoire, et le fait de les passer par référence peut permettre d'améliorer les performances et d'exercer un contrôle plus précis sur la manipulation des données.

Modification des variables de référence

Bien que le mot-clé ref soit couramment associé aux types de valeur, il peut également être utilisé avec des variables de type référence. Les types de référence, comme les classes et les tableaux, stockent une référence aux données réelles en mémoire plutôt que les données elles-mêmes. Cela signifie que vous avez affaire à une structure de type pointeur et que le passage par référence peut donner des résultats différents, comme le montre l'exemple suivant :

class Person
{
    public string Name { get; set; }
}

class Program
{
    //method
    static void ChangeName(ref Person person)
    {
        //new object
        person = new Person { Name = "Alice" };
    }

    static void Main()
    {
        Person person = new Person { Name = "Bob" };
        ChangeName(ref person);
        Console.WriteLine(person.Name);  // Output: Alice
    }
}

class Person
{
    public string Name { get; set; }
}

class Program
{
    //method
    static void ChangeName(ref Person person)
    {
        //new object
        person = new Person { Name = "Alice" };
    }

    static void Main()
    {
        Person person = new Person { Name = "Bob" };
        ChangeName(ref person);
        Console.WriteLine(person.Name);  // Output: Alice
    }
}

Friend Class Person
	Public Property Name() As String
End Class

Friend Class Program
	'method
	Private Shared Sub ChangeName(ByRef person As Person)
		'new object
		person = New Person With {.Name = "Alice"}
	End Sub

	Shared Sub Main()
		Dim person As New Person With {.Name = "Bob"}
		ChangeName(person)
		Console.WriteLine(person.Name) ' Output: Alice
	End Sub
End Class

Dans cet exemple, la méthode ChangeName modifie la référence de la variable person vers un nouvel objet Person. En conséquence, la variable person d'origine pointe maintenant vers un objet différent, et son nom est "Alice".

Surcharge des méthodes avec des paramètres de type référence

Vous pouvez avoir plusieurs méthodes portant le même nom mais avec des paramètres différents. C'est ce qu'on appelle la surcharge des méthodes. Lors de l'utilisation du mot-clé ref, la surcharge de méthode devient plus puissante.

class Calculator
{
    public static void Add(ref int x, int y)
    {
        x += y;
    }

    public static void Add(ref double x, double y)
    {
        x += y;
    }
}

class Program
{
    static void Main()
    {
        int intValue = 5;
        double doubleValue = 7.5;
        //ref parameter
        Calculator.Add(ref intValue, 3);
        Calculator.Add(ref doubleValue, 2.5);

        Console.WriteLine(intValue);      // Output: 8
        Console.WriteLine(doubleValue);   // Output: 10.0
    }
}

class Calculator
{
    public static void Add(ref int x, int y)
    {
        x += y;
    }

    public static void Add(ref double x, double y)
    {
        x += y;
    }
}

class Program
{
    static void Main()
    {
        int intValue = 5;
        double doubleValue = 7.5;
        //ref parameter
        Calculator.Add(ref intValue, 3);
        Calculator.Add(ref doubleValue, 2.5);

        Console.WriteLine(intValue);      // Output: 8
        Console.WriteLine(doubleValue);   // Output: 10.0
    }
}

Friend Class Calculator
	Public Shared Sub Add(ByRef x As Integer, ByVal y As Integer)
		x += y
	End Sub

	Public Shared Sub Add(ByRef x As Double, ByVal y As Double)
		x += y
	End Sub
End Class

Friend Class Program
	Shared Sub Main()
		Dim intValue As Integer = 5
		Dim doubleValue As Double = 7.5
		'ref parameter
		Calculator.Add(intValue, 3)
		Calculator.Add(doubleValue, 2.5)

		Console.WriteLine(intValue) ' Output: 8
		Console.WriteLine(doubleValue) ' Output: 10.0
	End Sub
End Class

Dans l'exemple ci-dessus, nous surchargeons la méthode Add pour fonctionner avec les types int et double. Le mot-clé ref permet aux méthodes de modifier directement les variables originales.

Utiliser le mot clé out

Un autre mot clé associé est out. C'est similaire au ref mais a un objectif légèrement différent. Alors que ref attend que la variable soit initialisée avant d'être passée, le mot-clé out est utilisé lorsqu'on veut qu'une méthode assigne une valeur à un paramètre qui n'a pas nécessairement de valeur initiale :

class Program
{
    static void Divide(int dividend, int divisor, out int quotient)
    {
        quotient = dividend / divisor;
    }

    static void Main()
    {
        int result;
        Divide(10, 2, out result);
        Console.WriteLine(result);  // Output: 5
    }
}

class Program
{
    static void Divide(int dividend, int divisor, out int quotient)
    {
        quotient = dividend / divisor;
    }

    static void Main()
    {
        int result;
        Divide(10, 2, out result);
        Console.WriteLine(result);  // Output: 5
    }
}

Friend Class Program
	Private Shared Sub Divide(ByVal dividend As Integer, ByVal divisor As Integer, ByRef quotient As Integer)
		quotient = dividend \ divisor
	End Sub

	Shared Sub Main()
		Dim result As Integer = Nothing
		Divide(10, 2, result)
		Console.WriteLine(result) ' Output: 5
	End Sub
End Class

Dans cet exemple, la méthode Divide calcule le quotient et l'assigne à la variable quotient en utilisant le mot-clé out. Il convient de noter que vous n'avez pas besoin d'initialiser le result avant de le passer à la méthode.

Différence entre les mots-clés ref et out

Le mot-clé out est similaire au mot-clé ref mais est significativement différent. Un paramètre out n'a pas besoin d'une valeur initiale, alors qu'un paramètre ref doit avoir des valeurs initiales avant l'appel de la méthode.

Pièges potentiels

Bien que les mots-clés ref et out puissent être des outils puissants, ils doivent être utilisés judicieusement. L'utilisation incorrecte de ces mots-clés peut entraîner un code confus et un comportement inattendu. Par exemple, vous ne pouvez pas utiliser une variable non ref dans un paramètre ref ou out sans l'initialiser d'abord, car cela entraînerait une erreur de compilation.

Utilisation avancée du mot-clé ref

Travailler avec des types de référence et des types de valeur

Comprendre la différence entre deux références et les types de valeurs est crucial lorsque vous travaillez avec le mot-clé ref.

• Type de référence : La variable se réfère à l'emplacement en mémoire où les données sont stockées, par exemple, objets, tableaux, etc.

• Type de valeur : La variable contient directement les données, par exemple, des entiers, des flottants, etc.

  L'utilisation de ref avec les types de valeur permet aux modifications d'être reflétées à l'extérieur de la méthode, tandis que les variables de type référence se comportent naturellement de cette manière.

Méthode d'extension avec mot-clé ref

Vous pouvez également utiliser le mot-clé ref avec des méthodes d'extension. Un exemple :

public static class StringExtensions
{
//example
    public static void AppendValue(ref this string input, string value)
    {
        input += value;
    }
}

public static class StringExtensions
{
//example
    public static void AppendValue(ref this string input, string value)
    {
        input += value;
    }
}

Public Module StringExtensions
'example
	Public Sub AppendValue(ByRef Me input As String, ByVal value As String)
		input &= value
	End Sub
End Module

Erreur de compilation et mot-clé ref

Si vous oubliez d'inclure le mot-clé ref soit dans la signature de la méthode, soit lors de l'appel de la méthode, cela entraînera une erreur de compilation à la compilation.

Méthodes Async et paramètres ref

Notez que vous ne pouvez pas utiliser les paramètres ref avec les méthodes d'itérateur ou les méthodes async, car ceux-ci nécessitent le passage du paramètre par valeur.

Présentation d'Iron Suite

En plus de comprendre des concepts clés tels que le mot-clé ref en C#, il existe un ensemble d'outils puissants qui peuvent faciliter grandement la vie d'un développeur. La Suite Iron est une collection d'outils et de bibliothèques robustes comprenant IronPDF, IronXL, IronOCR et IronBarcode. Explorons ces outils et voyons comment ils peuvent améliorer votre expérience du codage sans aucun argument.

IronPDF : le traitement des PDF en toute simplicité

En savoir plus sur IronPDF comme une partie essentielle de l'Iron Suite. C'est une bibliothèque qui permet aux développeurs de créer, lire et éditer des fichiers PDF avec C#. Si vous souhaitez convertir HTML en PDF, IronPDF possède les outils dont vous avez besoin. Consultez le tutoriel sur la conversion de HTML en PDF pour en savoir plus sur cette fonctionnalité.

La manipulation d'IronXL au bout des doigts

Travailler avec des fichiers Excel en C# peut être compliqué, mais les fonctionnalités d'IronXL simplifient cette tâche. Il vous permet de lire, d'écrire, d'éditer et de manipuler des fichiers Excel sans avoir installé Excel. De l'importation de données à la création de nouvelles feuilles de calcul, IronXL rend la manipulation d'Excel en C#.

IronOCR Reconnaissance optique de caractères pour C# ;

La reconnaissance optique de caractères (OCR) peut être complexe, mais découvrez IronOCR pour simplifier le processus. Cette bibliothèque permet de lire du texte à partir d'images et de le convertir en texte lisible par une machine. Qu'il s'agisse d'extraire du texte d'un document numérisé ou de reconnaître des caractères à partir d'une image, IronOCR dispose des fonctionnalités nécessaires.

Génération et lecture de codes-barres IronBarcode

Les codes-barres sont couramment utilisés dans diverses industries, et leur gestion dans vos applications est maintenant plus accessible avec la bibliothèque IronBarcode. Cette bibliothèque vous permet de créer, de lire et de travailler avec des codes-barres en C#. IronBarcode prend en charge un large éventail de formats de QR et de codes-barres.

Quel est le lien entre Iron Suite et le mot-clé ref ?

Vous pourriez vous demander comment ces outils se rapportent au mot-clé ref que nous avons discuté. Lors de la réalisation de projets complexes impliquant PDF, Excel, OCR ou des codes-barres, l'utilisation efficace du mot-clé ref et d'autres principes C# sera cruciale pour gérer votre code efficacement.

Par exemple, lors de la manipulation de grands fichiers Excel avec IronXL, passer des objets par référence en utilisant le mot-clé ref peut rendre votre code plus efficace et plus facile à maintenir. De même, travailler avec des documents PDF en utilisant IronPDF pourrait impliquer des méthodes où le mot-clé ref peut jouer un rôle.

Comprendre les fonctionnalités de base du langage comme le mot-clé ref et avoir accès à des outils comme l'Iron Suite vous offre une combinaison puissante pour créer des applications efficaces, robustes et polyvalentes. La suite Iron est conçue pour fonctionner de manière transparente avec vos connaissances C# existantes, et ensemble, ils peuvent vous aider à créer des solutions plus professionnelles et plus sophistiquées.

Conclusion

Le langage C#, avec des fonctionnalités comme le mot-clé ref, offre des capacités puissantes aux développeurs. Combiné à la suite Iron, comprenant IronPDF, IronXL, IronOCR et IronBarcode, les possibilités deviennent encore plus étendues.

Chaque produit dans l'Iron Suite offre une version d'essai gratuite de l'Iron Suite, vous permettant d'explorer et d'utiliser les fonctionnalités étendues sans aucun investissement immédiat. Si vous décidez d'opter pour une licence complète, le tarif commence à partir de $749 pour les composants individuels.

Si la totalité de la Suite Iron vous convient, une excellente affaire vous attend. Vous pouvez acquérir la suite complète pour le prix de seulement deux composants individuels.