C# / Inmutabilidad

Bienvenidos sean a este post, hoy vamos a tratar un tema conocido como inmutabilidad y como se aplica a nuestras variables.

Pero que es la inmutabilidad? Citemos la siguiente explicacion:

Es la capacidad que poseen las variables de tipo referencia que no cambian su valor ante una modificacion salvo que se lo asignemos

El Tinchicus

Para entender el concepto vamos a crear un ejemplo mediante el siguiente programa:

inmutable.cs

using System;

public class Program
{
	static public int Main()
	{
		string cadena = "Texto de prueba";
		cadena.ToUpper();
		Console.WriteLine(cadena);
		return 0;
	}
}

En este caso creamos una variable de tipo string, el tipo por excelencia para probar inmutabildiad, a la cual llamaremos cadena y le pasaremos un texto, luego usaremos el metodo ToUpper para convertir todo el texto en mayusculas y luego finalmente mostraremos a cadena, que creen que sucedera? cadena seguira igual o se habra cambiado a mayusculas?, compilemos y veamos:

C:\Users\tinchicus\Documents\Visual Studio 2019>inmutable.exe
Texto de prueba

C:\Users\tinchicus\Documents\Visual Studio 2019>

Si pensaste que lo habia modificado te equivocaste a medias, porque en realidad el metodo si lo cambio pero cual fue el inconveniente? que a ese resultado no lo asignamos a una ninguna variable y quedo en la nada, para ver ese cambio debemos hacer dos modificaciones, esta es la primera:

using System;

public class Program
{
	static public int Main()
	{
		string cadena = "Texto de prueba";
		cadena = cadena.ToUpper();
		Console.WriteLine(cadena);
		return 0;
	}
}

Como pueden ver ahora las modificaciones que hagamos se asignaran nuevamente a la variable cadena, si lo compilamos y probamos veremos la siguiente salida:

C:\Users\tinchicus\Source\Repos\Tipos\Tipos\bin\Debug>Tipos.exe
TEXTO DE PRUEBA
C:\Users\tinchicus\Source\Repos\Tipos\Tipos\bin\Debug>

Otra forma de obtener el mismo resultado hubiera sido haciendo lo siguiente:

using System;

public class Program
{
	static public int Main()
	{
		string cadena = "Texto de prueba";
		Console.WriteLine(cadena.ToUpper());
		return 0;
	}
}

Aca lo que decimos es que directamente nos muestre la modificacion realizada y el resultado es el mismo pero vamos a chequear si cadena se modifico o no, para eso volvamos a modificar el codigo de la siguiente manera:

using System;

public class Program
{
	static public int Main()
	{
		string cadena = "Texto de prueba";
		Console.WriteLine(cadena.ToUpper());
                Console.Write(cadena);
		return 0;
	}
}

En este bloque vemos lo mismo que antes pero le agregamos una nueva linea para mostrar el valor de cadena, si lo compilamos y probamos veremos lo siguiente:

C:\Users\tinchicus\Source\Repos\Tipos\Tipos\bin\Debug>Tipos.exe
TEXTO DE PRUEBA
Texto de prueba
C:\Users\tinchicus\Source\Repos\Tipos\Tipos\bin\Debug>

Como pueden observar en el primer caso se realizo correctamente pero en la segunda linea vemos que cadena aun mantiene su valor porque a diferencia de la primer modificacion no lo asignamos, esto es lo que se llama inmutabilidad, es decir al hecho de que podemos utilizar cualquier metodo sobre una variable pero mientras no la asignamos a si misma esta no se modificara, lo mismo ocurre con las variables que son creadas de una clase, vamos a tomar como ejempla una clase llamada Referencia.cs y la modificaremos para agregar a la siguiente variable en esa clase:

public string nombre;

Debemos agregarlo de la siguiente manera:

class Referencias
{
    List<string> listado;
    public string nombre;
.... el resto de la clase

Ahora nuestra clase tendra una variable de tipo string publica, en nuestro ejemplo vamos a suponer la existencia de una clase llamada Program.cs e iremos a Main donde lo modificaremos de la siguiente manera:

        static void Main(string[] args)
        {
            Varios.Referencias empleado = new Varios.Referencias();
            empleado.nombre = "Texto de prueba";
            empleado.nombre.ToUpper();
            Console.WriteLine(empleado.nombre);
        }

En este codigo creamos un objeto llamado empleado e implementamos con el new, de esto hablaremos mas adelante como es la creacion de objetos, luego le asignamos un valor a nombre (propiedad de la clase) despues tomamos a ese valor y usamos ToUpper para finalmente mostrar el valor de nombre en el objeto empleado, compilemos y veamos su salida:

C:\Users\tinchicus\Source\Repos\Tipos\Tipos\bin\Debug>Tipos.exe
Texto de prueba

C:\Users\tinchicus\Source\Repos\Tipos\Tipos\bin\Debug>

Como pueden observar volvio a ocurrir lo mismo, mientras nosotros no asignemos la modificacion a esta variable u otra, esa modificacion no se reflejara porque nuestras variables son inmutables a estas modificaciones sin asignar.

Como ven la inmutabilidad se aplica a todos los tipos de variables, ya sean de valor, de referencia, externas o propias (mediante struct o clases) porque no permiten que su valor sea modificado por ningun metodo, salvo que esa moditficacion se la asignemos a la variable nuevamente o alguna nueva, tengan esto en cuenta porque durante este post hablamos del metodo ToUpper, del cual hablaremos mas adelante, pero en realidad aplica a cualquier metodo que realice una modificacion de nuestro contenido.

En resumen, hoy hemos visto que es la inmutabilidad, que es, como trabaja, para que sirve, en que nos ayuda, como se come, en que nos perjudica, como podemos trabajarlo, y alguna excepcion, espero les haya sido util sigueme en tumblr, Twitter o Facebook para recibir una notificacion cada vez que subo un nuevo post en este blog, nos vemos en el proximo post.

Tengo un Patreon donde podes acceder de manera exclusiva a material para este blog antes de ser publicado, sigue los pasos del link para saber como.