Aprende los parámetros en C#
Aprende los parámetros en C#. Los parámetros en C# son el modo típico que tienen los métodos de intercambiar algún tipo de información con otros métodos o elementos del programa. Veamos las diversas maneras que tenemos de de transferir estos parámetros de un lado a otro.
Aprende los parámetros en C#
Por Valor
El modo más sencillo de pasar el valor de una variable a un método se puede ver en el siguiente ejemplo:
using System;class Parametros {
static void Main () {
int a = 2;
int b = 3;
int c = Suma (a, b);
Console.WriteLine ("{0} + {1} = {2}", a, b, c);
}
static int Suma (int a, int b) {
return a + b;
}
}
Se escriben el nombre de las variables a la hora de invocar el método, y cuando se define, la precedemos por su tipo. Así, al ejecutar el código obtenemos:
2 + 3 = 5
Por referencia
Supongamos ahora que queremos definir un método que intercambie el valor de sus dos argumentos. De acuerdo con el ejemplo anterior, sería hacer lo siguiente:
using System;
class Parametros {
static void Main () {
int a = 2;
int b = 3;
Console.WriteLine ("a = {O}, b = {1}", a, b);
Intercambia (a, b);
Console.WriteLine ("a = {O}, b = {1}",a, b);
}
static void Intercambia (int a, int b) {
int temp = a;
a = b;
b = temp;
}
}
Sin embargo, nos veremos contrariados al comprobar que el programa no ejecuta ninguna acción:
a = 2, b = 3
a = 2, b = 3
Lo que ha pasado es que las operaciones que hemos realizado con las variables dentro del método Intercambia o no han tenido efecto. Pese a que nosotros hemos asignado nuevos valores que intercambiaban los antiguos, todo ha seguido como al principio. Lo que ocurre es que el método no altera el valor de las variables originales, ya que trabaja sobre una copia de éstas.Precisamente esto es lo que se soluciona con la llamada por referencia de parámetros. Si cambiamos la definición del método por:
static void Intercambia (ref int a, ref int b) {
...
}
y si, por consiguiente, lo invocamos incluyendo las palabras clave ref.
Intercambia (ref a, ref b);
el resultado ahora sí es el deseado:
a = 2, b = 3
a = 3, b = 2
Al introducir ref como prefijo de invocación dé los parámetros, evitamos el efecto que comentábamos al principio. Por lo tanto, lo que hagamos sobre las variables en el método, afecta a las variables originales.
Parámetros exteriores
Un tercer tipo de parámetros, parecido al anterior, es aquél que viene precedido por la palabra clave out. En este caso, permitimos que sea el método de destino el que realice la primera asignación a la variable.
A modo de ejemplo, tomaremos una funcion que divida en dos una palabra y devuelva las dos partes resultantes, para ello haríamos lo siguiente:
using System;
class Parametros {
static void Main () {
string cadena = "Me van a cortar a la mitad";
Console.WriteLine ("Cadena original = '{0}'", cadena);
Divide (cadena, out izquierda, out derecha);
Console.WriteLine ("Primera parte = '{0}'", izquierda);
Console.WriteLine ("Segunda parte = '{0}'", segunda);
}
static void Divide (string cadena, out string izquierda, out string derecha); {
izquierda = cadena.Substring (0, cadena.Length / 2);
derecha = cadena.Substring (cadena.Length / 2);
}
}
Al ejecutarlo, resultaría lo siguiente:
Cadena original = 'Me van a cortar a la mitad'
Primera parte = 'Me van a cort'
Segunda parte = 'ar a la mitad''
Nótese que el programa hace uso del método Substring, mientro de System.String que permite extraer fácilmente subconjunto de cadenas de texto. Como vemos, pese a que las cadenas izquierda y derecha no estaban incializadas, el compilador no ha puesto en que el método Divide () realizara esta tarea.
Parámetros múltiples
No siempre sabemos con certeza el número de parámetros que vamos a enviar a un método. En ese caso podemos emplear la palabra clave params para denotar que el número de parámetros será en realidad un array de parámetros 
de tamaño inicialmente desconocido, teniendo:
using System;
class Parametros {
static void Main () {
int[] parametros = {l, 2, 3, 4, 5};
CuentaArgumentos (parametros);
CuentaArgumentos (1, 2, 3);
CuentaArgumentos ();
}
static void CuentaArgumentos (params int[] parametros) {
Console.Write ("He recibido {O} argumentos:", parametros.Length);
for (int i = O; i < parametros.Length; i++)
Console.Write (" {0}", parametros[i]);
Console.WriteLine ();
}
}
En el programa hemos definido un método llamado CuentaArgumentos al que le hemos añadido params en su definición. Esto nos permite invocarlo de tres maneras distintas en el método principal. Da igual si lo llamamos con un array como argumento, una lista de números o sencillamente nada. El método será capaz de controlar adecuadamente cada situación:
He recibido 5 argumentos: 1 2 3 4 5
He recibido 3 argumentos: 1 2 3
He recibido 0 argumentos:
Cabe preguntarse qué pasaría si elimináramos params de la definición, puesto que formalmente seguiría siendo correcta. El resultado es el esperado, tal como se muestra a continuación:
Params.cs (8) error CS1501: No overload for method 'CuentaArgumentos' takes '3' arguments
Params.cs(8) error CS8006: Could not find any applicable functíon for this argument list
Params.cs(9) error CS1501: No overload for method 'CuentaArgumentos' takes 'O' arguments
Params.cs(9) error CS8006: Could not find any applicable function for this argument list
Compilation failed: 4 error(s), 0 warnings
Esto significa que puede que la definición del método sea válida, pero sus invocaciones no lo son.
Continua en Ocultación de Métodos en C#
Fuente: Revista "Todo Programación". Año 1. Número 6.
Deja una respuesta