Parámetros por defecto en C# (Cómo funciona para los desarrolladores)

Hoy nos adentraremos en el mundo de C# y conoceremos una potente característica: los parámetros por defecto. Lo desglosaremos de una forma fácil de entender, centrándonos en el concepto de valor de argumento por defecto y argumentos opcionales en C#.

¿Qué son los parámetros por defecto?

En C#, parámetros por defecto también conocidos como parámetros de argumento opcionales, permiten asignar un valor a argumentos fijos en la definición de un método. Si no se proporciona un argumento para ese parámetro cuando se llama a la función, ésta utilizará el predeterminado.

Un valor de parámetro por defecto se establece en la definición del método como se muestra a continuación en ellos fragmento de código a continuación:

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

Aquí, el parámetro name es un atributo opcional. La cadena "Amigo" es el valor por defecto. Si llama a Greet() sin pasar un argumento, se utilizará "Friend" como valor para el name.

Parámetros obligatorios y parámetros opcionales

Parámetros obligatorios

Un parámetro obligatorio es un parámetro que debe incluirse cuando se llama a la función o al método. No tiene un valor por defecto, por lo que siempre debe proporcionarse un argumento. El compilador comprueba la llamada a la función o método y, si no se suministra el parámetro requerido, lanza un error de compilación.

Veamos un ejemplo:

//pasar los argumentos en el mismo orden
public void IntroduceYourself(string firstName, string lastName)
{
    Console.WriteLine("Hello, my name is " + firstName + " " + lastName);
}

//pasar los argumentos en el mismo orden
public void IntroduceYourself(string firstName, string lastName)
{
    Console.WriteLine("Hello, my name is " + firstName + " " + lastName);
}

'pasar los argumentos en el mismo orden
Public Sub IntroduceYourself(ByVal firstName As String, ByVal lastName As String)
	Console.WriteLine("Hello, my name is " & firstName & " " & lastName)
End Sub

En este método, firstName y lastName son parámetros obligatorios. Cuando llame a IntroduceYourself, debe proporcionar valores para ambos parámetros. Si omite los argumentos, obtendrá un error de compilación.

IntroduceYourself("John", "Doe"); //  La siguiente llamada es correcta
IntroduceYourself("John"); //  Error: falta lastName

IntroduceYourself("John", "Doe"); //  La siguiente llamada es correcta
IntroduceYourself("John"); //  Error: falta lastName

IntroduceYourself("John", "Doe") '  La siguiente llamada es correcta
IntroduceYourself("John") '  Error: falta lastName

Parámetros opcionales

Por otro lado, los parámetros opcionales permiten flexibilidad. Tienen un valor por defecto establecido dentro de la definición del método, que se utiliza cuando el método se llama sin ese parámetro.

Por ejemplo, vamos a modificar el método IntroduceYourself para que el parámetro lastName sea opcional:

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

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

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

Ahora, puedes llamar a IntroduceYourself sólo con el parámetro firstName. Si lo hace, lastName será por defecto "Doe".

IntroduceYourself("John", "Smith"); //  Salidas: Hola, me llamo John Smith
IntroduceYourself("John");          //  Salidas: Hola, me llamo John Doe

IntroduceYourself("John", "Smith"); //  Salidas: Hola, me llamo John Smith
IntroduceYourself("John");          //  Salidas: Hola, me llamo John Doe

IntroduceYourself("John", "Smith") '  Salidas: Hola, me llamo John Smith
IntroduceYourself("John") '  Salidas: Hola, me llamo John Doe

Cuando proporcione los argumentos opcionales, anulará el valor predeterminado.

Recuerde que en la declaración del método, los parámetros obligatorios siempre deben aparecer antes que los opcionales.

Entender la diferencia

La distinción entre parámetros obligatorios o con nombre y parámetros opcionales es significativa, ya que afecta a la forma en que se puede llamar a un método. Los parámetros opcionales proporcionan flexibilidad, ya que permiten omitir la entrada de parámetros específicos cuando no son necesarios. Por otro lado, los parámetros obligatorios garantizan que siempre se proporcionen los datos necesarios a la función o método, lo que ayuda a evitar errores en tiempo de ejecución.

Reglas de uso de los parámetros por defecto

Al definir un método con parámetros por defecto, hay que recordar algunas reglas clave:

1. El valor por defecto debe ser una expresión constante. No se pueden utilizar variables ni llamadas a métodos.
2. Todos los parámetros opcionales deben definirse al final de la lista de parámetros, después de los parámetros obligatorios.
3. Cuando se llama a un método con parámetros opcionales, se pueden proporcionar argumentos omitidos para los parámetros opcionales en el orden en que están definidos, o se pueden utilizar argumentos con nombre.

4. Se utilizará el valor por defecto si no se proporciona un argumento opcional.

   Considere el siguiente fragmento de código para argumentos posicionales:

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

En el método static void Main, llamamos a ShowMessage dos veces. La primera vez sólo pasamos un argumento, por lo que el parámetro name utiliza su valor por defecto "Friend". La segunda vez pasamos dos argumentos, por lo que se utiliza "Juan" en lugar del valor por defecto.

Parámetros nominales y opcionales

C# también admite parámetros con nombre y opcionales. Los parámetros con nombre permiten especificar el valor de un parámetro por su nombre en lugar de por su posición. Esto puede ser útil cuando un método tiene varios parámetros opcionales y se desea proporcionar un valor para uno pero no para los demás.

En el siguiente ejemplo, ShowGreetings tiene dos parámetros opcionales:

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

Podemos llamar a este método sólo con el primer parámetro:

ShowGreetings("Hi");

ShowGreetings("Hi");

ShowGreetings("Hi")

O podemos utilizar argumentos con nombre para proporcionar un valor para el nombre mientras omitimos el argumento saludo:

ShowGreetings(name: "John");

ShowGreetings(name: "John");

ShowGreetings(name:= "John")

¿Cuál es la ventaja de utilizar parámetros con nombre?

Los parámetros con nombre en C# ofrecen varias ventajas:

1. Mejora de la legibilidad: Los parámetros con nombre pueden facilitar la lectura y comprensión del código. Al especificar el nombre del parámetro, queda claro qué representa cada argumento. Esto puede ser especialmente beneficioso en métodos con múltiples parámetros.
2. Orden flexible de los argumentos Con los parámetros con nombre, puedes suministrar los argumentos en cualquier orden, no sólo en el orden en que aparecen en la declaración del método. Esto puede hacer que su código sea más flexible y mejorar la legibilidad en algunos casos.

3. Facilidad con parámetros opcionales: Los parámetros con nombre se utilizan a menudo con parámetros opcionales. Cuando un método tiene varios parámetros opcionales, puede utilizarlos para proporcionar valores para algunos parámetros opcionales, no para otros. De esta forma, no es necesario proporcionar un valor para cada parámetro opcional, sólo para aquellos que desee cambiar de sus valores predeterminados.

   He aquí otro ejemplo de tipo de valor de parámetros con nombre:

//  Declaración de método
public void RegisterUser(string username, string password, string email = "", bool subscribeToNewsletter = false)
{
    //  Cuerpo del método
}

//  Llamada al método
RegisterUser(username: "JohnDoe", password: "password123", subscribeToNewsletter: true);

//  Declaración de método
public void RegisterUser(string username, string password, string email = "", bool subscribeToNewsletter = false)
{
    //  Cuerpo del método
}

//  Llamada al método
RegisterUser(username: "JohnDoe", password: "password123", subscribeToNewsletter: true);

'  Declaración de método
Public Sub RegisterUser(ByVal username As String, ByVal password As String, Optional ByVal email As String = "", Optional ByVal subscribeToNewsletter As Boolean = False)
	'  Cuerpo del método
End Sub

'  Llamada al método
RegisterUser(username:= "JohnDoe", password:= "password123", subscribeToNewsletter:= True)

En el código anterior, email es un parámetro opcional que hemos omitido, y hemos elegido poner subscribeToNewsletter a true, aunque sea el último parámetro de la lista. El uso de parámetros con nombre deja claro qué representa cada argumento y nos permite especificar únicamente los argumentos que queremos proporcionar.

Parámetros por defecto y sobrecarga de métodos

¿Qué es la sobrecarga de métodos?

En C#, la sobrecarga de métodos, o sobrecarga de funciones, es una característica que permite definir varios métodos con el mismo nombre pero con un conjunto diferente de parámetros. Esto le permite realizar diferentes operaciones utilizando el mismo nombre de método, haciendo que su código sea más intuitivo y fácil de usar.

Considere el siguiente ejemplo de código de métodos sobrecargados:

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

En el ejemplo anterior, el método DisplayMessage está sobrecargado. Una versión del método toma un único parámetro string, y la otra toma dos parámetros string.

Uso de parámetros por defecto en lugar de sobrecarga

Los parámetros por defecto pueden utilizarse a menudo como alternativa a la sobrecarga. Al proporcionar un valor predeterminado para un parámetro en su método, puede permitir que la persona que llama elija si desea suministrar ese parámetro. Esto puede dar a su método la misma flexibilidad que la sobrecarga de métodos, pero con menos código.

A continuación se muestra cómo se podría reescribir el ejemplo anterior utilizando un parámetro por defecto en lugar de la sobrecarga:

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

Ahora, DisplayMessage puede ser llamado con uno o dos argumentos:

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

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

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

En la primera llamada, el parámetro name utiliza su valor por defecto "Friend". En la segunda llamada, se utiliza en su lugar el argumento suministrado "Juan".

Recuerda que el valor por defecto de un parámetro por defecto debe ser una expresión constante, lo que significa que no puede ser una variable o una llamada a un método. Esto se debe a que el valor debe conocerse en tiempo de compilación.

Paquete de software Iron

Vamos a sumergirnos en la suite de software Iron, que incluye IronPDF, IronXL, IronOCR y IronBarcode. Estas potentes bibliotecas están diseñadas específicamente para ayudarle a ampliar las capacidades de sus aplicaciones C#. Pueden relacionarse fácilmente con los conceptos que hemos tratado en el artículo, incluidos los parámetros por defecto, las especificaciones de argumentos con nombre y la sobrecarga de métodos.

IronPDF: Se trata de una biblioteca en C# para convertir HTML a PDF. Comprender los parámetros predeterminados y opcionales puede ser fundamental al utilizar IronPDF. Muchos de los métodos en IronPDF tendrán parámetros opcionales, que permiten una amplia personalización sin complicar demasiado las firmas de los métodos. Más información en IronPDF Tutorial de HTML a PDF página.

using IronPdf;

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

        //  1. Convertir cadena HTML a 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. Convertir archivo HTML a PDF
        var htmlFilePath = "path_to_your_html_file.html"; //  Especifique la ruta a su archivo HTML
        var pdfFromHtmlFile = renderer.RenderHtmlFileAsPdf(htmlFilePath);
        pdfFromHtmlFile.SaveAs("HTMLFileToPDF.pdf");

        //  3. Convertir URL a PDF
        var url = "http://ironpdf.com"; // Especificar la URL
        var pdfFromUrl = renderer.RenderUrlAsPdf(url);
        pdfFromUrl.SaveAs("URLToPDF.pdf");
    }
}

using IronPdf;

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

        //  1. Convertir cadena HTML a 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. Convertir archivo HTML a PDF
        var htmlFilePath = "path_to_your_html_file.html"; //  Especifique la ruta a su archivo HTML
        var pdfFromHtmlFile = renderer.RenderHtmlFileAsPdf(htmlFilePath);
        pdfFromHtmlFile.SaveAs("HTMLFileToPDF.pdf");

        //  3. Convertir URL a PDF
        var url = "http://ironpdf.com"; // Especificar la 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. Convertir cadena HTML a 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. Convertir archivo HTML a PDF
		Dim htmlFilePath = "path_to_your_html_file.html" '  Especifique la ruta a su archivo HTML
		Dim pdfFromHtmlFile = renderer.RenderHtmlFileAsPdf(htmlFilePath)
		pdfFromHtmlFile.SaveAs("HTMLFileToPDF.pdf")

		'  3. Convertir URL a PDF
		Dim url = "http://ironpdf.com" ' Especificar la URL
		Dim pdfFromUrl = renderer.RenderUrlAsPdf(url)
		pdfFromUrl.SaveAs("URLToPDF.pdf")
	End Sub
End Class

IronXL: Esta librería permite a su aplicación C# leer, escribir y manipular archivos Excel en varios formatos. Los métodos en IronXL pueden tener diferentes parámetros para cosas como el formato para guardar un archivo o si se deben incluir encabezados al importar datos. También puede encontrar que los parámetros con nombre y opcionales se utilizan mucho para especificar rangos de celdas, opciones de formato, etc.

IronOCR: Reconocimiento óptico de caracteres avanzado (OCR) que puede leer texto y códigos de barras de imágenes y PDFs en sus aplicaciones C#. Los métodos de IronOCR pueden tener parámetros opcionales para controlar aspectos del proceso de OCR, como el idioma del texto, el nivel de corrección de errores a aplicar, etc. Comprender estos parámetros puede proporcionarle un mejor control sobre el proceso de OCR.

IronBarcode: Esta librería es una herramienta versátil para la lectura y generación de códigos de barras en aplicaciones .NET. También en este caso es fundamental conocer los parámetros por defecto. Al generar un código de barras, por ejemplo, puede tener parámetros opcionales para especificar el tamaño, el formato o el valor del código de barras.

Conclusión

En conclusión, dominar el uso de parámetros por defecto y opcionales en C# puede mejorar significativamente la eficiencia de tu programación y la versatilidad de tu código. Estos conceptos son fundamentales para C#.

Hablando de estas librerías, recuerde que las licencias individuales de cada una empiezan por $749, y estas librerías también ofrecen un prueba gratuita. Sin embargo, Iron Software ofrece un paquete: puede adquirir el paquete completo por el precio de sólo dos licencias individuales.