¿Cómo se pasan las cadenas en .NET?

Cuando paso una stringa una función, ¿se pasa un puntero al contenido de la cadena o se pasa toda la cadena a la función en la pila como lo structharía a?

Se pasa una referencia; sin embargo, técnicamente no se pasa por referencia. Ésta es una distinción sutil, pero muy importante. Considere el siguiente código:

void DoSomething(string strLocal)
{
    strLocal = "local";
}
void Main()
{
    string strMain = "main";
    DoSomething(strMain);
    Console.WriteLine(strMain); // What gets printed?
}

Hay tres cosas que necesita saber para comprender lo que sucede aquí:

1. Las cadenas son tipos de referencia en C #.
2. También son inmutables, por lo que cada vez que haces algo que parece que estás cambiando la cuerda, no lo estás. Se crea una cadena completamente nueva, se apunta la referencia a ella y se desecha la anterior.
3. Aunque las cadenas son tipos de referencia, strMainno se pasa por referencia. Es un tipo de referencia, pero la referencia en sí se pasa por valor . Cada vez que pasa un parámetro sin la refpalabra clave (sin contar los outparámetros), pasa algo por valor.

Eso debe significar que estás ... pasando una referencia por valor. Dado que es un tipo de referencia, solo se copió la referencia en la pila. Pero ¿qué significa eso?

Pasar tipos de referencia por valor: ya lo está haciendo

Las variables de C # son tipos de referencia o tipos de valor . Los parámetros de C # se pasan por referencia o por valor . La terminología es un problema aquí; estos suenan como lo mismo, pero no lo son.

Si pasa un parámetro de CUALQUIER tipo y no usa la refpalabra clave, entonces lo ha pasado por valor. Si lo pasó por valor, lo que realmente aprobó fue una copia. Pero si el parámetro era un tipo de referencia, entonces lo que copió fue la referencia, no lo que apuntaba.

Aquí está la primera línea del Mainmétodo:

string strMain = "main";

Hemos creado dos cosas en esta línea: una cadena con el valor mainalmacenado en la memoria en algún lugar, y una variable de referencia llamada strMainapuntando hacia ella.

DoSomething(strMain);

Ahora pasamos esa referencia a DoSomething. Lo pasamos por valor, lo que significa que hicimos una copia. Es un tipo de referencia, lo que significa que copiamos la referencia, no la cadena en sí. Ahora tenemos dos referencias que cada una apunta al mismo valor en la memoria.

Dentro del llamado

Aquí está la parte superior del DoSomethingmétodo:

void DoSomething(string strLocal)

Sin refpalabra clave, entonces strLocaly strMainson dos referencias diferentes que apuntan al mismo valor. Si reasignamos strLocal...

strLocal = "local";   

... no hemos cambiado el valor almacenado; Tomamos la referencia llamada strLocaly la apuntamos a una cuerda nueva. ¿Qué pasa con strMaincuando hacemos eso? Nada. Todavía apunta a la vieja cuerda.

string strMain = "main";    // Store a string, create a reference to it
DoSomething(strMain);       // Reference gets copied, copy gets re-pointed
Console.WriteLine(strMain); // The original string is still "main" 

Inmutabilidad

Cambiemos el escenario por un segundo. Imagina que no estamos trabajando con cadenas, sino con algún tipo de referencia mutable, como una clase que has creado.

class MutableThing
{
    public int ChangeMe { get; set; }
}

Si sigue la referencia objLocalal objeto al que apunta, puede cambiar sus propiedades:

void DoSomething(MutableThing objLocal)
{
     objLocal.ChangeMe = 0;
} 

Todavía hay solo uno MutableThingen la memoria, y tanto la referencia copiada como la referencia original todavía apuntan a él. Las propiedades del MutableThingmismo han cambiado :

void Main()
{
    var objMain = new MutableThing();
    objMain.ChangeMe = 5; 
    Console.WriteLine(objMain.ChangeMe); // it's 5 on objMain

    DoSomething(objMain);                // now it's 0 on objLocal
    Console.WriteLine(objMain.ChangeMe); // it's also 0 on objMain   
}

¡Ah, pero las cuerdas son inmutables! No hay ninguna ChangeMepropiedad que configurar. No puede hacer strLocal[3] = 'H'en C # como podría hacerlo con una charmatriz de estilo C ; tienes que construir una cadena completamente nueva en su lugar. La única forma de cambiar strLocales apuntar la referencia a otra cadena, y eso significa que nada de lo que haga strLocalpuede afectar strMain. El valor es inmutable y la referencia es una copia.

Pasando una referencia por referencia

Para demostrar que hay una diferencia, esto es lo que sucede cuando pasa una referencia por referencia:

void DoSomethingByReference(ref string strLocal)
{
    strLocal = "local";
}
void Main()
{
    string strMain = "main";
    DoSomethingByReference(ref strMain);
    Console.WriteLine(strMain);          // Prints "local"
}

Esta vez, la cadena en Mainrealmente se cambia porque pasó la referencia sin copiarla en la pila.

Entonces, aunque las cadenas son tipos de referencia, pasarlas por valor significa que lo que suceda en el destinatario de la llamada no afectará a la cadena en el llamador. Pero como son tipos de referencia, no es necesario que copie la cadena completa en la memoria cuando quiera pasarla.

Recursos adicionales:

• Este es el mejor artículo que he leído sobre la diferencia entre los tipos de referencia y los tipos de valor en C # , y por qué un tipo de referencia no es lo mismo que un parámetro de referencia pasada.
• Como de costumbre, Eric Lippert también tiene varias publicaciones de blog excelentes sobre el tema .
• También tiene cosas geniales sobre la inmutabilidad .

Las cadenas en C # son objetos de referencia inmutables. Esto significa que las referencias a ellos se pasan (por valor) y, una vez que se crea una cadena, no se puede modificar. Los métodos que producen versiones modificadas de la cadena (subcadenas, versiones recortadas, etc.) crean copias modificadas de la cadena original.

Las cadenas son casos especiales. Cada instancia es inmutable. Cuando cambia el valor de una cadena, está asignando una nueva cadena en la memoria.

Entonces, solo se pasa la referencia a su función, pero cuando se edita la cadena, se convierte en una nueva instancia y no modifica la instancia anterior.