Mi idea acá es con tres sencillos métodos aclarar un poco esta cuestión.
Quien es quien para el framework?
Vamos a aclarar cuales son las diferencias entre un parámetro que ingresa por valor y por referencia. Según lo que podemos leer en miles de libros que andan dando vuelta o incluso en miles de blogs en la web un parámetro por valor es aquel que a un determinado método ingresa una copia del valor, en pocas palabras si nuestra variable contiene el valor 3 (utilice un int por un motivo especial) cuando llamamos a un método el framework genera una copia del valor de la variable y se lo pasa como parámetro al método. Esto es sin mas un parámetro que ingresa por valor, cual es la ventaja? la primera la velocidad, ya que estas variables se encuentran en el sector de memoria conocido como heap, con lo cual utilizan mucha menos memoria y el acceso es mas rápido. porque utilice un valor numérico para mi ejemplo? bueno básicamente porque los llamados tipos base mas los structs se alojan en el heap con lo cual siempre ingresan en un método por valor.static void IncrementaValor(int a)
{
a++;
Console.WriteLine("El valor incrementado en el metodo: {0}", a);
}
En el ejemplo que vimos recién tenemos un método que recibe un número por parámetro, lo incrementa y lo muestra por pantalla. Cuando termina la ejecución por pantalla vemos al número que pasamos por valor incrementado. Ahora que pasa con nuestra variable fuera del método, la realidad es que como el framework paso una copia de nuestro valor nuestra variable quedo inmutable y conserva el valor previo a ingresar al método y eso lo podemos verificar con la siguiente prueba.
var num2 = 2;
Console.WriteLine("El valor de num2 antes de llamar al metodo: {0}", num2);
IncrementaValor(num2);
Console.WriteLine("El valor de num2 despues de llamar al metodo : {0}", num2);
Los parámetros por valor nunca se modifican?
Bueno esta es una pregunta capciosa, la realidad es que si podemos modificarlo haciendo una pequeña modificación a nuestro método.static void IncrementaValor(ref int a)
{
a++;
Console.WriteLine("El valor incrementado en el metodo: {0}", a);
}
Como podemos ver ahora nuestro método tiene un modificador en el parámetro que es la palabra reservada ref la misma nos permite decirle al framework que nuestra variable queremos que entre al método por referencia, es decir en lugar de hacer una copia del valor queremos que una referencia a nuestra variable sea enviada así podemos modificar el valor interno de la misma. Esto lo podemos comprobar fácilmente con el siguiente código.
var num2 = 2;
Console.WriteLine("El valor de num2 antes de llamar al metodo: {0}", num2);
IncrementaValor(num2);
Console.WriteLine("El valor de num2 despues de llamar al metodo : {0}", num2);
Y qué parámetros son por referencia?
Bueno para concluir con esta pregunta los parámetros que ingresan a los métodos por referencia (sin necesidad de utilizar la palabra reservada ref) son los objetos en general. Siempre que pasamos como parámetro un objeto este ingresa al método por referencia. Dicho esto, cada vez que modifiquemos algo de un objeto en un método cuando termine el ámbito de ejecución del método nuestro cambio va a seguir ahi.public class Numero
{
public int Valor { get; set; }
}
static void IncrementaValor(Numero num)
{
num.Valor++;
Console.WriteLine("El valor incrementado en el metodo: {0}", num.Valor);
}
En la modificación que hice al método anterior podemos ver que enviamos un objeto y en la validación vemos que el cambio tiene efecto al salir del método.
var num2 = new Numero();
Console.WriteLine("El valor de num2 antes de llamar al metodo: {0}", num2.Valor);
IncrementaValor(num2);
Console.WriteLine("El valor de num2 despues de llamar al metodo : {0}", num2.Valor);
La idea de esta pregunta es ver si sabemos los conceptos básicos del framework, como funciona internamente y si principalmente hemos ido mas allá del concepto general de los libros o la web.
