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

Les Mot-clé ref en C# est un outil essentiel que tout débutant devrait connaître. 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 tutoriel, nous verrons les détails du mot-clé **ref et explorerons divers exemples de code de la 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 transmise par référence.
• Variables de référence : Types qui font référence à l'emplacement de la mémoire où les données sont stockées.
• Types de valeurs : Types qui contiennent les données réelles.
• Variable originale : La variable extérieure à la méthode qui reflète les changements effectués à 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
    }
}

IRON VB CONVERTER ERROR developers@ironsoftware.com

Dans le code ci-dessus, même si nous avons incrémenté num dans la méthode IncrementByOne, la valeur originale value reste inchangée. En effet, num est une copie de la variable originale, et les modifications qui lui sont apportées n'affectent pas l'original.

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 le montre 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
    }
}

IRON VB CONVERTER ERROR developers@ironsoftware.com

Remarquez le mot-clé ref dans la signature de la méthode et dans l'appel. Cela indique à C# que vous voulez passer la variable valeur par référence. Par conséquent, les changements effectués dans la méthode IncrementByOneRef sont reflétés dans la variable value d'origine.

Travailler avec des types de valeurs

Le mot-clé ref est particulièrement utile pour travailler 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 généralement associé aux types de valeurs, 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
    }
}

IRON VB CONVERTER ERROR developers@ironsoftware.com

Dans cet exemple, la méthode ChangeName change la référence de la variable person en un nouvel objet Person. Par conséquent, la variable originale person 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. En utilisant le mot-clé ref, la surcharge des méthodes 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 qu'elle fonctionne 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é apparenté est out. Il est similaire à ref mais a un but légèrement différent. Alors que ref s'attend à ce que la variable soit initialisée avant d'être passée, le mot-clé out est utilisé lorsque vous voulez 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'affecte à la variable quotient en utilisant le mot-clé out. Il est intéressant de noter qu'il n'est pas nécessaire d'initialiser le résultat 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 en est très différent. Un paramètre out n'a pas besoin de valeur initiale, alors qu'un paramètre ref doit avoir des valeurs initiales avant l'appel de la méthode.

Pièges potentiels

Les mots-clés ref et out peuvent être des outils puissants, mais 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-réf dans un paramètre ref ou out sans l'initialiser au préalable, 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

Il est essentiel de comprendre la différence entre deux références et les types de valeurs lorsque l'on travaille avec le mot-clé ref.

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

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

  L'utilisation de ref avec les types de valeur permet de répercuter les changements en dehors de la méthode, alors que les variables de type référence se comportent intrinsèquement de cette manière.

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

Vous pouvez également utiliser le mot-clé ref avec les 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 dans la signature de la méthode ou dans l'appel de la méthode, cela entraînera une erreur de compilation.

méthodes Async et paramètres ref

Notez que vous ne pouvez pas utiliser les paramètres ref avec les méthodes iterator ou les méthodes async, car elles nécessitent de passer le paramètre par sa valeur.

Présentation d'Iron Suite

Outre la compréhension de concepts clés tels que le mot-clé ref en C#, il existe un ensemble d'outils puissants qui peuvent rendre la vie d'un développeur beaucoup plus facile. 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é

IronPDF est un élément essentiel de la Iron Suite. Il s'agit d'une bibliothèque qui permet aux développeurs de créer, de lire et de modifier des fichiers PDF en C#. Si vous souhaitez convertir HTML en PDF, IronPDF possède les outils dont vous avez besoin. Consultez le site Tutoriel HTML vers PDF pour en savoir plus sur cette fonction.

La manipulation d'IronXL au bout des doigts

Travailler avec des fichiers Excel en C# peut s'avérer difficile, mais IronXL simplifie 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 permet de manipuler Excel en C# ;

IronOCR Reconnaissance optique de caractères pour C# ;

Reconnaissance optique de caractères (OCR) peut être complexe, mais IronOCR rationalise 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 divers secteurs, et leur utilisation dans vos applications est désormais plus accessible grâce à 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 vous demandez peut-être quel est le lien entre ces outils et le mot-clé ref dont nous avons parlé. Lorsque vous travaillez sur des projets complexes impliquant des fichiers PDF, Excel, OCR ou des codes-barres, l'utilisation efficace du mot-clé ref et d'autres principes C# sera cruciale pour la gestion efficace de votre code.

Par exemple, lorsque vous manipulez de gros fichiers Excel avec IronXL, le passage d'objets par référence à l'aide du mot-clé ref peut rendre votre code plus efficace et plus facile à maintenir. De même, travailler avec des documents PDF à l'aide d'IronPDF pourrait impliquer des méthodes où le mot-clé ref peut jouer un rôle.

Comprendre les caractéristiques essentielles du langage, comme le mot-clé ref, et avoir accès à des outils comme Iron Suite, c'est disposer d'une combinaison puissante pour construire 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 telles que le mot-clé ref, offre de puissantes possibilités aux développeurs. Combiné à la suite Iron, comprenant IronPDF, IronXL, IronOCR et IronBarcode, les possibilités deviennent encore plus étendues.

Chaque produit de la Iron Suite offre une essai gratuitvous pouvez ainsi explorer et utiliser les fonctionnalités étendues sans investissement immédiat. Si vous décidez d'acquérir une licence complète, les prix commencent à 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.