Parámetros opcionales en C# 4.0

Una de las nuevas características preparadas para C# 4.0 son los parámetros opcionales,
ya conocidos por Visual Basic .NET. El objetivo será declarar nuestros
métodos, constructores e indexadores con unos valores por defecto, en
el caso de no indicarlos en la llamada.

   1: using System;
   2: using System.Collections.Generic;
   3: using System.Linq;
   4: using System.Text;
   5:  
   6: namespace ParametrosOpcionales
   7: {
   8:     class Program
   9:     {
  10:         static void Main(string[] args)
  11:         {
  12:             DatosPersonales("Gisela");
  13:             DatosPersonales("Gisela","Perez");
  14:             DatosPersonales("Gisela", "Perez", 10);
  15:  
  16:             System.Console.ReadLine();
  17:         }
  18:  
  19:         static void DatosPersonales(string nombre, string apellido = "Torres", int edad = 20)
  20:         {
  21:             System.Console.WriteLine("Nombre:{0} Apellido:{1} Edad:{2}", nombre, apellido, edad);
  22:         }

Podemos
realizar distintas llamadas indicando únicamente el obligatorio, el
obligatorio y uno de los opcionales o todos ellos. Visto así, podemos
preguntarnos cuál sería la manera de llamar a nuestro método pasándole
como argumentos el primer parámetro y el último, sin querer saber nada
del segundo. ¿Esto es posible? Afortunamente si y aquí es donde entran
en juego los argumentos nombrados, pensados para casos como este.

   1: DatosPersonales(nombre: "Jose");
   2: DatosPersonales(nombre: "Pedro",apellido:"Leal");
   3: DatosPersonales(edad: 40, apellido: "Rodriguez", nombre: "Laura");

Si utilizamos este tipo de llamada, incluso es posible alterar el orden de los parámetros.

Podemos
llegar a pensar en la posibilidad de olvidarnos de la sobrecarga en
algunos casos, sobre todo por el ahorro de código que esto supone.
También es cierto que podemos necesitar que la sobrecarga y los
parámetros opcionales convivan.

   1: using System;
   2: using System.Collections.Generic;
   3: using System.Linq;
   4: using System.Text;
   5:  
   6: namespace ParametrosOpcionales
   7: {
   8:     class Program
   9:     {
  10:         static void Main(string[] args)
  11:         {
  12:             ejemplo("Hola");
  13:  
  14:             System.Console.ReadLine();
  15:         }
  16:  
  17:         static void ejemplo(object saludo)
  18:         {
  19:             System.Console.WriteLine("Object: {0}",saludo);
  20:         }
  21:         static void ejemplo(string saludo,string nombre = "Gisela")
  22:         {
  23:             System.Console.WriteLine("{0} {1}",saludo,nombre);
  24:         }
  25:         static void ejemplo(string saludo)
  26:         {
  27:             System.Console.WriteLine("Simplemente {0}", saludo);
  28:         }
  29:     }
  30: }

En este ejemplo, existen tres tipos de sobrecarga. Si nosotros únicamente pasamos como argumento un string (“Hola”) debemos tener claro cual de los tres métodos será el candidato. Hay que tener en cuenta lo siguiente:

Siempre se eligirá en primer lugar aquel método que no necesite convertir el dato que le estamos pasando a otro tipo.

Tendrá preferencia aquel método que no necesite omitir sus parámetros opcionales.

Asi
pues, si arrancamos este ejemplo comprobaremos que la sobrecarga
elegida será la tercera por ser el arguménto del mismo tipo y por no
contenter parámetros opcionales que no se están teniendo en cuenta en
nuestra llamada.


¡Saludos!

5 comentarios en “Parámetros opcionales en C# 4.0”

  1. Hola en el ultimo código de ejemplo, para demostrar tu punto, tendría que ser:

    static void ejemplo(string saludo,string nombre = Arturo)

    Aun así, como tu indicas, el compilar preferiría el ultimo método:

    static void ejemplo(string saludo)

    Muchas gracias por publicarlo, no sabia esto.

    Saludos

  2. Hola Arturo,

    Tienes toda la razón, en el último ejemplo se me olvidó dar valor al parámeto opcional del segundo método. Fallo mío.

    Ya está corregido 🙂

    ¡Muchas gracias por comentarlo!

    ¡Saludos!

  3. @preguntoncojonero
    No creo… 🙂
    Tipos anónimos no deberían ser interesantes para reflection salvo para usarlos como “diccionarios dinámicos”, lo que no va más allá de recojer todas sus propiedades y sus valores. De todos modos los tipos anónimos de .NET son de juguete, así que poca cosa se puede hacer con ellos 😉
    Los parámetros opcionales tampoco creo que afecten a reflection: ya existia antes la propiedad DefaultValue en ParameterInfo (para dar soporte a VB supongo), así que no creo que nada vaya a cambiar mucho.

    @Gisela
    Buen blog… bienvenida 😀

  4. Hola Edgardo,

    Se ve que cada lenguaje va a su ritmo :)… Mientras que no se queden estancados la cosa no va mal ^^

    ¡Gracias por tu comentario!

Deja un comentario

Tu dirección de correo electrónico no será publicada. Los campos obligatorios están marcados con *