using IronPdf;
// Disable local disk access or cross-origin requests
Installation.EnableWebSecurity = true;
// Instantiate Renderer
var renderer = new ChromePdfRenderer();
// Create a PDF from a HTML string using C#
var pdf = renderer.RenderHtmlAsPdf("<h1>Hello World</h1>");
// Export to a file or Stream
pdf.SaveAs("output.pdf");
// Advanced Example with HTML Assets
// Load external html assets: Images, CSS and JavaScript.
// An optional BasePath 'C:\site\assets\' is set as the file location to load assets from
var myAdvancedPdf = renderer.RenderHtmlAsPdf("<img src='icons/iron.png'>", @"C:\site\assets\");
myAdvancedPdf.SaveAs("html-with-assets.pdf");
Mots clés C# Ref (Comment ça marche pour les développeurs)
Regan Pun
novembre 13, 2023
Partager:
LesMot-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
}
}
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
$vbLabelText $csharpLabel
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
}
}
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
$vbLabelText $csharpLabel
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
}
}
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
$vbLabelText $csharpLabel
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
$vbLabelText $csharpLabel
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
$vbLabelText $csharpLabel
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
$vbLabelText $csharpLabel
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é
En savoir plus sur IronPDF le logiciel Iron Suite est un élément essentiel de l'Iron Suite. Il s'agit d'une bibliothèque qui permet aux développeurs de créer, lire et modifier des fichiers PDF au sein de C#. Si vous souhaitez convertir HTML en PDF, IronPDF possède les outils dont vous avez besoin. Consultez le sitetutoriel sur la conversion de HTML en 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, maisCaractéristiques d'IronXL simplifier 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
Reconnaissance optique de caractères(OCR) peut être complexe, maisdécouvrir IronOCR la traduction doit rester professionnelle et préserver l'exactitude technique tout en expliquant les caractéristiques et les avantages de ces outils de développement. 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 BarCodes sont couramment utilisés dans divers secteurs d'activité, et leur manipulation dans vos applications est désormais plus accessible grâce à l'applicationBibliothè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 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 uneessai gratuit d'Iron Suitevous 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.
Regan est diplômé de l'université de Reading, où il a obtenu une licence en ingénierie électronique. Avant de rejoindre Iron Software, il s'était concentré sur une seule tâche. Ce qu'il apprécie le plus chez Iron Software, c'est la diversité des tâches qu'il peut accomplir, qu'il s'agisse d'apporter une valeur ajoutée aux ventes, à l'assistance technique, au développement de produits ou à la commercialisation. Il aime comprendre comment les développeurs utilisent la bibliothèque d'Iron Software et utiliser ces connaissances pour améliorer continuellement la documentation et développer les produits.
< PRÉCÉDENT C# Datatable to List (Comment ça marche pour les développeurs)
SUIVANT > NLog C# (Comment ça marche pour les développeurs)
Des millions d'ingénieurs dans le monde entier lui font confiance
Réservez une démo en direct gratuite
Réservez une démonstration personnelle de 30 minutes.
Pas de contrat, pas de détails de carte, pas d'engagements.
Voici ce à quoi vous pouvez vous attendre :
Une démonstration en direct de notre produit et de ses principales fonctionnalités
Obtenez des recommandations de fonctionnalités spécifiques au projet
Toutes vos questions trouvent réponse pour vous assurer de disposer de toutes les informations dont vous avez besoin. (Aucun engagement de votre part.)
CHOISIR L'HEURE
VOS INFORMATIONS
Réservez votre démo en direct gratuite
Fiable par plus de 2 millions d'ingénieurs dans le monde entier