Como as strings são passadas no .NET?

Quando passo a stringpara uma função, é passado um ponteiro para o conteúdo da sequência ou toda a sequência é passada para a função na pilha como structseria?

Uma referência é passada; no entanto, não é tecnicamente passado por referência. Esta é uma distinção sutil, mas muito importante. Considere o seguinte código:

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

Há três coisas que você precisa saber para entender o que acontece aqui:

1. Strings são tipos de referência em C #.
2. Eles também são imutáveis; portanto, sempre que você faz algo que parece que está mudando a corda, não está. Uma string completamente nova é criada, a referência é apontada para ela e a antiga é jogada fora.
3. Mesmo que as strings sejam tipos de referência, elas strMainnão são passadas por referência. É um tipo de referência, mas a própria referência é passada por valor . Sempre que você passa um parâmetro sem a refpalavra - chave (sem contar os outparâmetros), passa algo por valor.

Então isso deve significar que você está ... passando uma referência por valor. Como é um tipo de referência, apenas a referência foi copiada na pilha. Mas o que isso significa?

Passando tipos de referência por valor: você já está fazendo isso

Variáveis ​​C # são tipos de referência ou tipos de valor . Os parâmetros C # são passados ​​por referência ou passados ​​por valor . A terminologia é um problema aqui; estes parecem a mesma coisa, mas não são.

Se você passa um parâmetro de QUALQUER tipo e não usa a refpalavra - chave, passa-o por valor. Se você passou por valor, o que realmente passou foi uma cópia. Mas se o parâmetro era um tipo de referência, o que você copiava era a referência, não o que estava apontando.

Aqui está a primeira linha do Mainmétodo:

string strMain = "main";

Criamos duas coisas nessa linha: uma string com o valor mainarmazenado na memória em algum lugar e uma variável de referência chamada strMainapontando para ela.

DoSomething(strMain);

Agora passamos essa referência para DoSomething. Nós passamos por valor, o que significa que fizemos uma cópia. É um tipo de referência, o que significa que copiamos a referência, não a string em si. Agora, temos duas referências que apontam para o mesmo valor na memória.

Dentro do chamado

Aqui está o topo do DoSomethingmétodo:

void DoSomething(string strLocal)

Nenhuma refpalavra-chave, portanto, strLocale strMainsão duas referências diferentes apontando para o mesmo valor. Se reatribuirmos strLocal...

strLocal = "local";   

... não alteramos o valor armazenado; pegamos a referência chamada strLocale apontamos para uma nova string. O que acontece strMainquando fazemos isso? Nada. Ainda está apontando para a corda antiga.

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" 

Imutabilidade

Vamos mudar o cenário por um segundo. Imagine que não estamos trabalhando com strings, mas com algum tipo de referência mutável, como uma classe que você criou.

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

Se você seguir a referência objLocalao objeto para o qual ele aponta, poderá alterar suas propriedades:

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

Ainda existe apenas uma MutableThingna memória, e a referência copiada e a referência original ainda apontam para ela. As propriedades do MutableThingpróprio foram alteradas :

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, mas as cordas são imutáveis! Não há ChangeMepropriedade para definir. Você não pode fazer strLocal[3] = 'H'em C # como faria com uma charmatriz de estilo C ; você precisa construir uma sequência totalmente nova. A única maneira de mudar strLocalé apontar a referência para outra string, e isso significa que nada que você faça strLocalpode afetarstrMain . O valor é imutável e a referência é uma cópia.

Passando uma referência por referência

Para provar que há uma diferença, eis o que acontece quando você passa uma referência por referência:

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

Desta vez, a string Mainrealmente muda porque você passou a referência sem copiá-la na pilha.

Portanto, mesmo que as strings sejam tipos de referência, transmiti-las por valor significa que tudo o que acontece no receptor não afetará a string no chamador. Mas, como são tipos de referência, você não precisa copiar toda a cadeia de caracteres da memória quando quiser distribuí-la.

Mais recursos:

• Aqui está o melhor artigo que li sobre a diferença entre tipos de referência e tipos de valor em C # e por que um tipo de referência não é o mesmo que um parâmetro passado por referência.
• Como sempre, Eric Lippert também tem vários excelentes posts sobre o assunto .
• Ele também tem ótimas coisas sobre imutabilidade .

Strings em C # são objetos de referência imutáveis. Isso significa que as referências a eles são passadas (por valor) e, depois que uma string é criada, você não pode modificá-la. Os métodos que produzem versões modificadas da sequência (substrings, versões aparadas etc.) criam cópias modificadas da sequência original.

Strings são casos especiais. Cada instância é imutável. Quando você altera o valor de uma sequência, está alocando uma nova sequência na memória.

Portanto, apenas a referência é passada para sua função, mas quando a string é editada, ela se torna uma nova instância e não modifica a instância antiga.