Icône de message
Passer au contenu du pied de page
  1. IronPDF
  2. Blog IronPDF
  3. .NET Aide
  4. Paramètres par défaut C#
.NET AIDE

Paramètres par défaut en C# (Comment ça fonctionne pour les développeurs)

Curtis Chau
Curtis Chau
Mis à jour:

Aujourd'hui, nous allons plonger dans le monde de C# et apprendre une fonctionnalité puissante - les paramètres par défaut. Nous allons la décomposer de manière facile à comprendre, en nous concentrant sur le concept de valeur d'argument par défaut et d'arguments optionnels en C#.

Quels sont les paramètres par défaut ?

En C#, les paramètres par défaut, également connus sous le nom de paramètres d'argument optionnel, vous permettent d'assigner une valeur à des arguments fixes dans la définition d'une méthode. Si un argument pour ce paramètre n'est pas fourni lors de l'appel de la fonction, il utilisera la valeur par défaut.

Une valeur de paramètre par défaut est définie dans la définition de la méthode comme indiqué dans l'extrait de code ci-dessous :

public void Greet(string name = "Friend")
{
    Console.WriteLine("Hello, " + name);
}
public void Greet(string name = "Friend")
{
    Console.WriteLine("Hello, " + name);
}
Public Sub Greet(Optional ByVal name As String = "Friend")
	Console.WriteLine("Hello, " & name)
End Sub
$vbLabelText   $csharpLabel

Ici, le paramètre name est un attribut optionnel. La chaîne "Friend" est la valeur par défaut. Si vous appelez Greet() sans passer d'argument, "Friend" sera utilisé comme valeur pour le name.

Paramètres requis et paramètres optionnels

Paramètres requis

Un paramètre requis est un paramètre qui doit être inclus lors de l'appel de la fonction ou de la méthode. Il n'a pas de valeur par défaut, donc un argument doit toujours être fourni. Le compilateur vérifie l'appel à la fonction ou à la méthode, et si le paramètre requis n'est pas fourni, il génère une erreur à la compilation.

Considérons un exemple :

// Method with required parameters
public void IntroduceYourself(string firstName, string lastName)
{
    Console.WriteLine("Hello, my name is " + firstName + " " + lastName);
}
// Method with required parameters
public void IntroduceYourself(string firstName, string lastName)
{
    Console.WriteLine("Hello, my name is " + firstName + " " + lastName);
}
' Method with required parameters
Public Sub IntroduceYourself(ByVal firstName As String, ByVal lastName As String)
	Console.WriteLine("Hello, my name is " & firstName & " " & lastName)
End Sub
$vbLabelText   $csharpLabel

Dans cette méthode, firstName et lastName sont tous deux des paramètres requis. Lorsque vous appelez IntroduceYourself, vous devez fournir des valeurs pour les deux paramètres. Si vous omettez des arguments, vous obtiendrez une erreur à la compilation.

IntroduceYourself("John", "Doe"); // Following call is correct
// IntroduceYourself("John"); // Error: lastName is missing
IntroduceYourself("John", "Doe"); // Following call is correct
// IntroduceYourself("John"); // Error: lastName is missing
IntroduceYourself("John", "Doe") ' Following call is correct
' IntroduceYourself("John"); // Error: lastName is missing
$vbLabelText   $csharpLabel

Paramètres optionnels

D'un autre côté, les paramètres optionnels permettent de la flexibilité. Ils ont une valeur par défaut définie dans la définition de la méthode, qui est utilisée lorsque la méthode est appelée sans ce paramètre.

Par exemple, modifions la méthode IntroduceYourself pour rendre le paramètre lastName optionnel :

// Method with an optional parameter
public void IntroduceYourself(string firstName, string lastName = "Doe")
{
    Console.WriteLine("Hello, my name is " + firstName + " " + lastName);
}
// Method with an optional parameter
public void IntroduceYourself(string firstName, string lastName = "Doe")
{
    Console.WriteLine("Hello, my name is " + firstName + " " + lastName);
}
' Method with an optional parameter
Public Sub IntroduceYourself(ByVal firstName As String, Optional ByVal lastName As String = "Doe")
	Console.WriteLine("Hello, my name is " & firstName & " " & lastName)
End Sub
$vbLabelText   $csharpLabel

Maintenant, vous pouvez appeler IntroduceYourself avec uniquement le paramètre firstName. Si vous le faites, lastName prendra la valeur par défaut "Doe".

IntroduceYourself("John", "Smith"); // Outputs: Hello, my name is John Smith
IntroduceYourself("John");          // Outputs: Hello, my name is John Doe
IntroduceYourself("John", "Smith"); // Outputs: Hello, my name is John Smith
IntroduceYourself("John");          // Outputs: Hello, my name is John Doe
IntroduceYourself("John", "Smith") ' Outputs: Hello, my name is John Smith
IntroduceYourself("John") ' Outputs: Hello, my name is John Doe
$vbLabelText   $csharpLabel

Lorsque vous fournissez les arguments optionnels, ils remplacent la valeur par défaut.

Rappelez-vous que dans la déclaration de la méthode, les paramètres requis doivent toujours être listés avant les paramètres optionnels.

Comprendre la différence

La distinction entre les paramètres requis et optionnels est importante car elle affecte la façon dont vous pouvez appeler une méthode. Les paramètres optionnels offrent de la flexibilité, vous permettant de sauter l'entrée de paramètres spécifiques quand ils ne sont pas nécessaires. D'un autre côté, les paramètres requis garantissent que les données nécessaires sont toujours fournies à la fonction ou à la méthode, ce qui aide à prévenir les erreurs d'exécution.

Règles pour l'utilisation des paramètres par défaut

Lors de la définition d'une méthode avec des paramètres par défaut, il y a quelques règles clés à retenir :

  1. La valeur par défaut doit être une expression constante. Vous ne pouvez pas utiliser de variables ou d'appels de méthode.
  2. Tous les paramètres optionnels doivent être définis à la fin de la liste des paramètres après tout paramètre requis.
  3. Lorsque vous appelez une méthode avec des paramètres optionnels, vous pouvez fournir des arguments omis pour les paramètres optionnels dans l'ordre où ils sont définis, ou vous pouvez utiliser des arguments nommés.
  4. La valeur par défaut sera utilisée si une valeur d'argument optionnel n'est pas fournie.

Considérez l'extrait de code suivant pour les arguments optionnels :

static void Main(string[] args)
{
    ShowMessage("Hello");
    ShowMessage("Hello", "John");
}

public static void ShowMessage(string msg, string name = "Friend")
{
    Console.WriteLine(msg + ", " + name);
}
static void Main(string[] args)
{
    ShowMessage("Hello");
    ShowMessage("Hello", "John");
}

public static void ShowMessage(string msg, string name = "Friend")
{
    Console.WriteLine(msg + ", " + name);
}
Shared Sub Main(ByVal args() As String)
	ShowMessage("Hello")
	ShowMessage("Hello", "John")
End Sub

Public Shared Sub ShowMessage(ByVal msg As String, Optional ByVal name As String = "Friend")
	Console.WriteLine(msg & ", " & name)
End Sub
$vbLabelText   $csharpLabel

Dans la méthode Main, nous appelons ShowMessage deux fois. Nous ne passons qu'un seul argument la première fois, donc le paramètre name utilise sa valeur par défaut de "Friend". Nous passons deux arguments la deuxième fois, donc "John" est utilisé à la place de la valeur par défaut.

Paramètres nommés et optionnels

C# prend également en charge les paramètres nommés et optionnels. Les paramètres nommés vous permettent de spécifier une valeur pour un paramètre par nom plutôt que par position. Cela peut être utile lorsqu'une méthode a plusieurs paramètres optionnels, et que vous souhaitez fournir une valeur pour l'un mais pas pour les autres.

Dans l'exemple suivant, ShowGreetings a deux paramètres optionnels :

public static void ShowGreetings(string greeting = "Hello", string name = "Friend")
{
    Console.WriteLine(greeting + ", " + name);
}
public static void ShowGreetings(string greeting = "Hello", string name = "Friend")
{
    Console.WriteLine(greeting + ", " + name);
}
Public Shared Sub ShowGreetings(Optional ByVal greeting As String = "Hello", Optional ByVal name As String = "Friend")
	Console.WriteLine(greeting & ", " & name)
End Sub
$vbLabelText   $csharpLabel

Nous pouvons appeler cette méthode avec juste le premier paramètre :

ShowGreetings("Hi");
ShowGreetings("Hi");
ShowGreetings("Hi")
$vbLabelText   $csharpLabel

Ou nous pouvons utiliser des arguments nommés pour fournir une valeur pour le name tout en omettant l'argument greeting :

ShowGreetings(name: "John");
ShowGreetings(name: "John");
ShowGreetings(name:= "John")
$vbLabelText   $csharpLabel

Quel est l'avantage d'utiliser des paramètres nommés ?

Les paramètres nommés en C# offrent plusieurs avantages :

  1. Amélioration de la lisibilité : Les paramètres nommés peuvent rendre votre code plus facile à lire et à comprendre. En spécifiant le nom du paramètre, vous clarifiez ce que représente chaque argument. Cela peut être particulièrement bénéfique dans les méthodes avec de nombreux paramètres.
  2. Ordre d'argument flexible : Avec les paramètres nommés, vous pouvez fournir des arguments dans n'importe quel ordre, pas seulement l'ordre dans lequel les paramètres apparaissent dans la déclaration de méthode. Cela peut rendre votre code plus flexible et améliorer la lisibilité dans certains cas.
  3. Facilité avec les paramètres optionnels : Les paramètres nommés sont souvent utilisés avec des paramètres optionnels. Lorsqu'une méthode a plusieurs paramètres optionnels, vous pouvez utiliser les paramètres nommés pour fournir des valeurs pour certains paramètres optionnels, mais pas pour d'autres. De cette façon, vous n'avez pas besoin de fournir une valeur pour chaque paramètre optionnel, seulement ceux que vous souhaitez changer de leurs valeurs par défaut.

Voici un autre exemple de l'utilisation des paramètres nommés :

// Method Declaration
public void RegisterUser(string username, string password, string email = "", bool subscribeToNewsletter = false)
{
    // Method body
}

// Method Call
RegisterUser(username: "JohnDoe", password: "password123", subscribeToNewsletter: true);
// Method Declaration
public void RegisterUser(string username, string password, string email = "", bool subscribeToNewsletter = false)
{
    // Method body
}

// Method Call
RegisterUser(username: "JohnDoe", password: "password123", subscribeToNewsletter: true);
' Method Declaration
Public Sub RegisterUser(ByVal username As String, ByVal password As String, Optional ByVal email As String = "", Optional ByVal subscribeToNewsletter As Boolean = False)
	' Method body
End Sub

' Method Call
RegisterUser(username:= "JohnDoe", password:= "password123", subscribeToNewsletter:= True)
$vbLabelText   $csharpLabel

Dans le code ci-dessus, email est un paramètre optionnel que nous avons omis, et nous avons choisi de définir subscribeToNewsletter à true, même si c'est le dernier paramètre de la liste. Utiliser un paramètre nommé rend clair ce que chaque argument représente et nous permet de spécifier uniquement les arguments que nous voulons fournir.

Paramètres par défaut et surcharge de méthode

Qu'est-ce que la surcharge de méthode ?

En C#, la surcharge de méthode, ou surcharge de fonction, est une fonctionnalité qui vous permet de définir plusieurs méthodes avec le même nom mais avec un ensemble différent de paramètres. Cela vous permet d'effectuer différentes opérations en utilisant le même nom de méthode, rendant votre code plus intuitif et plus facile à utiliser.

Considérons l'exemple de code suivant de méthodes surchargées :

public void DisplayMessage(string message)
{
    Console.WriteLine(message);
}

public void DisplayMessage(string message, string name)
{
    Console.WriteLine(message + ", " + name);
}
public void DisplayMessage(string message)
{
    Console.WriteLine(message);
}

public void DisplayMessage(string message, string name)
{
    Console.WriteLine(message + ", " + name);
}
Public Sub DisplayMessage(ByVal message As String)
	Console.WriteLine(message)
End Sub

Public Sub DisplayMessage(ByVal message As String, ByVal name As String)
	Console.WriteLine(message & ", " & name)
End Sub
$vbLabelText   $csharpLabel

Dans l'exemple ci-dessus, la méthode DisplayMessage est surchargée. Une version de la méthode prend un seul paramètre string, et l'autre prend deux paramètres string.

Utilisation des paramètres par défaut au lieu de la surcharge

Les paramètres par défaut peuvent souvent être utilisés comme alternative à la surcharge. En fournissant une valeur par défaut pour un paramètre dans votre méthode, vous pouvez permettre à l'appelant de choisir d'approvisionner ou non ce paramètre. Cela peut donner à votre méthode la même flexibilité que la surcharge de méthode mais avec moins de code.

Voici comment vous pourriez réécrire l'exemple ci-dessus en utilisant un paramètre par défaut au lieu d'une surcharge :

public void DisplayMessage(string message, string name = "Friend")
{
    Console.WriteLine(message + ", " + name);
}
public void DisplayMessage(string message, string name = "Friend")
{
    Console.WriteLine(message + ", " + name);
}
Public Sub DisplayMessage(ByVal message As String, Optional ByVal name As String = "Friend")
	Console.WriteLine(message & ", " & name)
End Sub
$vbLabelText   $csharpLabel

Maintenant, DisplayMessage peut être appelé avec soit un soit deux arguments :

DisplayMessage("Hello");
DisplayMessage("Hello", "John");
DisplayMessage("Hello");
DisplayMessage("Hello", "John");
DisplayMessage("Hello")
DisplayMessage("Hello", "John")
$vbLabelText   $csharpLabel

Dans le premier appel, le paramètre name utilise sa valeur par défaut de "Friend". Dans le deuxième appel, l'argument fourni "John" est utilisé à la place.

Rappelez-vous, la valeur par défaut d'un paramètre par défaut doit être une expression constante, ce qui signifie qu'elle ne peut pas être une variable ou un appel de méthode. Ceci est parce que la valeur doit être connue à la compilation.

Suite Iron Software

Let's dive into the Iron Software suite, which includes IronPDF library for PDF solutions, IronXL for C# Excel operations, IronOCR for advanced text recognition, and IronBarcode for barcode generation. Ces puissantes bibliothèques sont conçues spécifiquement pour vous aider à étendre les capacités de vos applications C#. Elles peuvent facilement être reliées aux concepts que nous avons discutés dans l'article, y compris les paramètres par défaut, les spécifications d'arguments nommés et la surcharge de méthode.

IronPDF : Il s'agit d'une bibliothèque C# pour convertir HTML en PDF avec IronPDF. Comprendre les paramètres par défaut et optionnels peut être crucial lors de l'utilisation d'IronPDF. Beaucoup des méthodes dans IronPDF auront des paramètres optionnels, qui permettent une personnalisation étendue sans complexifier les signatures de méthode. Plus à ce sujet peut être trouvé dans le tutoriel HTML vers PDF d'IronPDF.

using IronPdf;

class Program
{
    static void Main(string[] args)
    {
        var renderer = new ChromePdfRenderer();

        // 1. Convert HTML String to PDF
        var htmlContent = "<h1>Hello, IronPDF!</h1><p>This is a PDF from an HTML string.</p>";
        var pdfFromHtmlString = renderer.RenderHtmlAsPdf(htmlContent);
        pdfFromHtmlString.SaveAs("HTMLStringToPDF.pdf");

        // 2. Convert HTML File to PDF
        var htmlFilePath = "path_to_your_html_file.html"; // Specify the path to your HTML file
        var pdfFromHtmlFile = renderer.RenderHtmlFileAsPdf(htmlFilePath);
        pdfFromHtmlFile.SaveAs("HTMLFileToPDF.pdf");

        // 3. Convert URL to PDF
        var url = "http://ironpdf.com"; // Specify the URL
        var pdfFromUrl = renderer.RenderUrlAsPdf(url);
        pdfFromUrl.SaveAs("URLToPDF.pdf");
    }
}
using IronPdf;

class Program
{
    static void Main(string[] args)
    {
        var renderer = new ChromePdfRenderer();

        // 1. Convert HTML String to PDF
        var htmlContent = "<h1>Hello, IronPDF!</h1><p>This is a PDF from an HTML string.</p>";
        var pdfFromHtmlString = renderer.RenderHtmlAsPdf(htmlContent);
        pdfFromHtmlString.SaveAs("HTMLStringToPDF.pdf");

        // 2. Convert HTML File to PDF
        var htmlFilePath = "path_to_your_html_file.html"; // Specify the path to your HTML file
        var pdfFromHtmlFile = renderer.RenderHtmlFileAsPdf(htmlFilePath);
        pdfFromHtmlFile.SaveAs("HTMLFileToPDF.pdf");

        // 3. Convert URL to PDF
        var url = "http://ironpdf.com"; // Specify the URL
        var pdfFromUrl = renderer.RenderUrlAsPdf(url);
        pdfFromUrl.SaveAs("URLToPDF.pdf");
    }
}
Imports IronPdf

Friend Class Program
	Shared Sub Main(ByVal args() As String)
		Dim renderer = New ChromePdfRenderer()

		' 1. Convert HTML String to PDF
		Dim htmlContent = "<h1>Hello, IronPDF!</h1><p>This is a PDF from an HTML string.</p>"
		Dim pdfFromHtmlString = renderer.RenderHtmlAsPdf(htmlContent)
		pdfFromHtmlString.SaveAs("HTMLStringToPDF.pdf")

		' 2. Convert HTML File to PDF
		Dim htmlFilePath = "path_to_your_html_file.html" ' Specify the path to your HTML file
		Dim pdfFromHtmlFile = renderer.RenderHtmlFileAsPdf(htmlFilePath)
		pdfFromHtmlFile.SaveAs("HTMLFileToPDF.pdf")

		' 3. Convert URL to PDF
		Dim url = "http://ironpdf.com" ' Specify the URL
		Dim pdfFromUrl = renderer.RenderUrlAsPdf(url)
		pdfFromUrl.SaveAs("URLToPDF.pdf")
	End Sub
End Class
$vbLabelText   $csharpLabel

IronXL : Cette bibliothèque permet à votre application C# de lire, écrire et manipuler des fichiers Excel dans divers formats. Les méthodes dans IronXL peuvent avoir différents paramètres pour des choses comme le format dans lequel enregistrer un fichier ou l'opportunité d'inclure les en-têtes lors de l'importation des données. Vous pourriez également découvrir que les paramètres nommés et optionnels sont utilisés intensivement pour spécifier des plages de cellules, des options de formatage, et plus encore.
IronOCR : Une bibliothèque avancée de Reconnaissance Optique de Caractères (OCR) qui peut lire du texte et des codes à barres à partir d'images et de PDFs dans vos applications C#. Les méthodes d'IronOCR peuvent avoir des paramètres optionnels pour contrôler les aspects du processus OCR, tels que la langue du texte, le niveau de correction d'erreur à appliquer, et ainsi de suite. Comprendre ces paramètres peut vous donner un meilleur contrôle sur le processus OCR.
IronBarcode : Cette bibliothèque est un outil polyvalent pour lire et générer des codes à barres dans les applications .NET. Ici aussi, comprendre les paramètres par défaut est crucial. Lors de la génération d'un code à barres, par exemple, vous pourriez avoir des paramètres optionnels pour spécifier la taille, le format, ou la valeur du code à barres.

Conclusion

En conclusion, maîtriser l'utilisation des paramètres par défaut et optionnels en C# peut significativement améliorer votre efficacité de programmation et la polyvalence de votre code. Ces concepts sont fondamentaux pour C#.

En parlant de ces bibliothèques, rappelez-vous que les licences individuelles pour chacune commencent à partir de $799, et ces bibliothèques offrent également un essai gratuit des produits Iron Software. Cependant, Iron Software propose une offre groupée : vous pouvez acquérir l'ensemble de la suite pour le prix de seulement deux licences individuelles.

Questions Fréquemment Posées

Comment les paramètres par défaut améliorent-ils l'efficacité du code en C# ?

Les paramètres par défaut en C# permettent aux développeurs d'assigner des valeurs prédéfinies aux arguments de méthode, réduisant ainsi le besoin de surcharge de méthodes multiples et simplifiant la maintenance du code.

Les paramètres par défaut peuvent-ils être utilisés avec des paramètres nommés en C# ?

Oui, les paramètres par défaut peuvent être combinés avec des paramètres nommés en C#, permettant aux développeurs de spécifier uniquement les arguments nécessaires par nom, améliorant ainsi la lisibilité et la flexibilité du code.

Quels sont les avantages d'utiliser des paramètres optionnels en C# ?

Les paramètres optionnels en C# offrent de la flexibilité en permettant aux appels de méthode d'omettre certains arguments, qui prennent la valeur prédéfinie, simplifiant ainsi l'appel de méthode et réduisant la redondance du code.

Comment la surcharge de méthode diffère-t-elle de l'utilisation de paramètres par défaut en C# ?

La surcharge de méthode implique la création de plusieurs méthodes portant le même nom mais avec des paramètres différents, alors que les paramètres par défaut permettent à une seule méthode de gérer plusieurs scénarios en fournissant des valeurs de secours pour les arguments omis.

Quelles règles doivent être suivies lors de l'utilisation de paramètres par défaut en C# ?

Les règles essentielles incluent l'assurance que les valeurs par défaut sont des expressions constantes, le placement des paramètres optionnels après ceux qui sont obligatoires, et l'utilisation des arguments nommés pour spécifier les paramètres omis.

Comment les paramètres par défaut peuvent-ils optimiser l'utilisation de la bibliothèque IronPDF ?

Dans IronPDF, les paramètres par défaut peuvent rationaliser la génération de PDF en permettant aux développeurs d'ajuster des réglages tels que le contenu HTML ou les chemins de fichiers sans spécifier chaque argument, personnalisant ainsi la sortie de manière efficace.

Quel rôle jouent les paramètres nommés dans l'amélioration de la lisibilité du code ?

Les paramètres nommés permettent de spécifier les arguments par nom plutôt que par position, rendant le code plus lisible et réduisant les erreurs liées à l'ordre des arguments.

Pourquoi la maîtrise des paramètres par défaut est-elle cruciale pour les développeurs ?

Maîtriser les paramètres par défaut est crucial car cela améliore l'efficacité de la programmation en fournissant une flexibilité dans les appels de méthode, assurant que les données nécessaires sont fournies et simplifiant la structure du code.

Curtis Chau
Curtis Chau
  Discutez maintenant avec l'équipe d'ingénierie
Rédacteur technique

Curtis Chau détient un baccalauréat en informatique (Université de Carleton) et se spécialise dans le développement front-end avec expertise en Node.js, TypeScript, JavaScript et React. Passionné par la création d'interfaces utilisateur intuitives et esthétiquement plaisantes, Curtis aime travailler avec des frameworks modernes ...

Lire la suite

Articles connexes

Essai de 30 jours → Produit complet. Pas de limites. Pas de carte. Démarrer l'essai gratuit