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

Aujourd'hui, nous allons nous plonger dans le monde du C# et découvrir une fonctionnalité puissante : les paramètres par défaut. Nous allons le décomposer de manière à ce qu'il soit facile à comprendre, en nous concentrant sur le concept de valeur d'argument par défaut et d'arguments facultatifs en C#.

Que sont les paramètres par défaut ?

En C#,paramètres par défautégalement appelés paramètres d'argument optionnels, permettent d'attribuer une valeur à des arguments fixes dans la définition d'une méthode. Si aucun argument n'est fourni pour ce paramètre lors de l'appel de la fonction, celle-ci 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 le montre 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

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 nom.

Paramètres obligatoires et paramètres facultatifs

Paramètres requis

Un paramètre obligatoire 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, il faut donc toujours fournir un argument. 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 de compilation.

Prenons un exemple :

//pass arguments in the same order
public void IntroduceYourself(string firstName, string lastName)
{
    Console.WriteLine("Hello, my name is " + firstName + " " + lastName);
}

//pass arguments in the same order
public void IntroduceYourself(string firstName, string lastName)
{
    Console.WriteLine("Hello, my name is " + firstName + " " + lastName);
}

'pass arguments in the same order
Public Sub IntroduceYourself(ByVal firstName As String, ByVal lastName As String)
	Console.WriteLine("Hello, my name is " & firstName & " " & lastName)
End Sub

Dans cette méthode, firstName et lastName sont des paramètres obligatoires. Lorsque vous appelez IntroduceYourself, vous devez fournir des valeurs pour les deux paramètres. Si vous omettez des arguments, vous obtiendrez une erreur de 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

Paramètres optionnels

D'autre part, les paramètres optionnels permettent une certaine 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 :

//named arguments
public void IntroduceYourself(string firstName, string lastName = "Doe")
{
    Console.WriteLine("Hello, my name is " + firstName + " " + lastName);
}

//named arguments
public void IntroduceYourself(string firstName, string lastName = "Doe")
{
    Console.WriteLine("Hello, my name is " + firstName + " " + lastName);
}

'named arguments
Public Sub IntroduceYourself(ByVal firstName As String, Optional ByVal lastName As String = "Doe")
	Console.WriteLine("Hello, my name is " & firstName & " " & lastName)
End Sub

Maintenant, vous pouvez appeler IntroduceYourself avec seulement le paramètre firstName. Si vous le faites, lastName prendra par défaut la valeur "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

Lorsque vous fournissez des arguments facultatifs, la valeur par défaut est remplacée.

N'oubliez pas que dans la déclaration de la méthode, les paramètres obligatoires doivent toujours être énumérés avant les paramètres facultatifs.

Comprendre la différence

La distinction entre les paramètres obligatoires ou nommés et les paramètres facultatifs est importante car elle affecte la manière dont vous pouvez appeler une méthode. Les paramètres optionnels offrent une certaine souplesse, car ils permettent de ne pas saisir certains paramètres lorsqu'ils ne sont pas nécessaires. D'autre part, les paramètres obligatoires garantissent que les données nécessaires sont toujours fournies à la fonction ou à la méthode, ce qui permet d'éviter les erreurs d'exécution.

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

Lors de la définition d'une méthode avec des paramètres par défaut, il convient de se rappeler quelques règles essentielles :

1. La valeur par défaut doit être une expression constante. Vous ne pouvez pas utiliser de variables ou d'appels de méthodes.

2. Tous les paramètres facultatifs doivent être définis à la fin de la liste des paramètres, après les paramètres obligatoires.

3. Lorsque vous appelez une méthode avec des paramètres facultatifs, vous pouvez fournir des arguments omis pour les paramètres facultatifs 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 facultative n'est pas fournie.

   Considérons l'extrait de code suivant pour les arguments positionnels :

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

Dans la méthode statique void Main, nous appelons ShowMessage deux fois. La première fois, nous ne passons qu'un seul argument, et le paramètre name prend sa valeur par défaut, à savoir "Friend". La deuxième fois, nous transmettons deux arguments, de sorte que "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 facultatifs. Les paramètres nommés vous permettent de spécifier une valeur pour un paramètre par son nom plutôt que par sa position. Cela peut s'avérer utile lorsqu'une méthode comporte plusieurs paramètres facultatifs et que vous souhaitez fournir une valeur pour l'un d'entre eux, 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

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

ShowGreetings("Hi");

ShowGreetings("Hi");

ShowGreetings("Hi")

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

ShowGreetings(name: "John");

ShowGreetings(name: "John");

ShowGreetings(name:= "John")

Quel est l'intérêt d'utiliser des paramètres nommés ?

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

1. amélioration de la lisibilité : Les paramètres nommés peuvent faciliter la lecture et la compréhension de votre code. En spécifiant le nom du paramètre, vous indiquez clairement ce que chaque argument représente. Cela peut s'avérer particulièrement utile pour les méthodes comportant plusieurs paramètres.

2. Ordre d'Argument Flexible : Avec les paramètres nommés, vous pouvez fournir des arguments dans n'importe quel ordre, et pas seulement dans l'ordre dans lequel les paramètres apparaissent dans la déclaration de la 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 comporte plusieurs paramètres facultatifs, vous pouvez utiliser ces paramètres pour fournir des valeurs à certains paramètres facultatifs, mais pas à d'autres. Ainsi, il n'est pas nécessaire de fournir une valeur pour chaque paramètre facultatif, mais seulement pour ceux que vous souhaitez modifier par rapport à leur valeur par défaut.

   Voici un autre exemple de type de valeur 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)

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

Paramètres par défaut et surcharge des méthodes

Qu'est-ce que la surcharge des méthodes ?

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

Prenons l'exemple 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

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.

Utiliser des paramètres par défaut au lieu de surcharger

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 de fournir 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 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

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

DisplayMessage("Hello");
DisplayMessage("Hello", "John");

DisplayMessage("Hello");
DisplayMessage("Hello", "John");

DisplayMessage("Hello")
DisplayMessage("Hello", "John")

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

N'oubliez pas que la valeur par défaut d'un paramètre par défaut doit être une expression constante, ce qui signifie qu'il ne peut s'agir d'une variable ou d'un appel de méthode. En effet, la valeur doit être connue au moment de la compilation.

Iron Software Suite

Jetons un coup d'œil à la suite Iron Software, qui comprend les éléments suivantsBibliothèque IronPDF pour les solutions PDF, IronXL pour les opérations C# Excel, IronOCR pour une reconnaissance de texte avancéeetIronBarcode pour la génération de codes-barres. Ces puissantes bibliothèques sont spécialement conçues pour vous aider à étendre les capacités de vos applications C#. Ils peuvent facilement être reliés aux concepts que nous avons abordés dans l'article, notamment les paramètres par défaut, les spécifications d'arguments nommés et la surcharge des méthodes.

IronPDF: Il s'agit d'une bibliothèque C# permettant deconversion de HTML en PDF avec IronPDF. La compréhension des paramètres par défaut et optionnels peut s'avérer cruciale lors de l'utilisation d'IronPDF. De nombreuses méthodes d'IronPDF ont des paramètres facultatifs, ce qui permet une personnalisation poussée sans compliquer excessivement les signatures de méthodes. Pour en savoir plus, consultez le site IronPDFTutoriel HTML vers 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");
    }
}

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

IronXL: Cette bibliothèque permet à votre application C# de lire, écrire et manipuler des fichiers Excel dans différents formats. Les méthodes dans IronXL peuvent avoir des paramètres différents pour des choses comme le format dans lequel enregistrer un fichier, ou s'il faut inclure des en-têtes lors de l'importation de données. Vous constaterez peut-être aussi que les paramètres nommés et facultatifs sont largement utilisés pour spécifier des plages de cellules, des options de formatage, etc.

IronOCR: Une reconnaissance optique de caractères avancée(OCR) qui permet de lire du texte et des codes-barres à partir d'images et de PDF dans vos applications C#. Les méthodes d'IronOCR peuvent comporter des paramètres facultatifs permettant de contrôler certains aspects du processus d'OCR, tels que la langue du texte, le niveau de correction des erreurs à appliquer, etc. La compréhension de ces paramètres peut vous permettre de mieux contrôler le processus d'OCR.

IronBarcode: Cette bibliothèque est un outil polyvalent permettant de lire et de générer des codes-barres dans les applications .NET. Ici aussi, la compréhension des paramètres par défaut est cruciale. Lors de la génération d'un code-barres, par exemple, vous pouvez disposer de paramètres facultatifs pour spécifier la taille, le format ou la valeur du code-barres.

Conclusion

En conclusion, la maîtrise de l'utilisation des paramètres par défaut et facultatifs en C# peut considérablement 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 d'entre elles commencent à partir de $749, et que ces bibliothèques offrent également une licence de typeessai gratuit des produits Iron Software. Iron Software propose toutefois une offre groupée : vous pouvez acquérir l'ensemble de la suite pour le prix de deux licences individuelles seulement.