W jaki sposób przekazywane są ciągi znaków w .NET?

Kiedy przekazuję a stringdo funkcji, czy wskaźnik do zawartości ciągu jest przekazywany, czy też cały ciąg jest przekazywany do funkcji na stosie, tak jak structbyłby to?

Odwołanie jest przekazywane; jednak nie jest to technicznie przekazywane przez odniesienie. To subtelne, ale bardzo ważne rozróżnienie. Rozważ następujący kod:

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

Aby zrozumieć, co się tutaj dzieje, musisz wiedzieć trzy rzeczy:

1. Ciągi są typami odwołań w C #.
2. Są również niezmienne, więc za każdym razem, gdy robisz coś, co wygląda tak, jakbyś zmieniał ciąg, tak nie jest. Tworzony jest zupełnie nowy ciąg, wskazywany jest na niego odnośnik, a stary jest wyrzucany.
3. Mimo że ciągi są typami referencyjnymi, strMainnie są przekazywane przez odwołanie. Jest to typ referencyjny, ale samo odwołanie jest przekazywane przez wartość . Za każdym razem, gdy przekazujesz parametr bez refsłowa kluczowego (nie licząc outparametrów), przekazujesz coś według wartości.

To musi oznaczać, że ... przekazujesz odwołanie według wartości. Ponieważ jest to typ referencyjny, tylko referencja została skopiowana na stos. Ale co to znaczy?

Przekazywanie typów referencyjnych według wartości: już to robisz

Zmienne C # są typami odwołań lub typami wartości . Parametry języka C # są przekazywane przez odwołanie lub przez wartość . Terminologia jest tutaj problemem; brzmią jak to samo, ale tak nie jest.

Jeśli przekazujesz parametr DOWOLNEGO typu i nie używasz refsłowa kluczowego, to przekazujesz go według wartości. Jeśli przekazałeś to według wartości, tak naprawdę przekazałeś kopię. Ale jeśli parametr był typem referencyjnym, to skopiowana rzecz była referencją, a nie tym, na co wskazywała.

Oto pierwsza linia Mainmetody:

string strMain = "main";

Stworzyliśmy w tej linii dwie rzeczy: ciąg znaków z wartością mainprzechowywaną gdzieś w pamięci oraz zmienną referencyjną o nazwie strMainwskazującą na nią.

DoSomething(strMain);

Teraz przekazujemy to odniesienie do DoSomething. Przekazaliśmy to według wartości, więc oznacza to, że utworzyliśmy kopię. Jest to typ referencyjny, co oznacza, że ​​skopiowaliśmy referencję, a nie sam ciąg. Teraz mamy dwa odniesienia, z których każdy wskazuje na tę samą wartość w pamięci.

Wewnątrz callee

Oto początek DoSomethingmetody:

void DoSomething(string strLocal)

Brak refsłowa kluczowego, więc strLocali strMainsą dwa różne odwołania wskazujące tę samą wartość. Jeśli zmienimy przypisanie strLocal...

strLocal = "local";   

... nie zmieniliśmy przechowywanej wartości; wzięliśmy odwołanie o nazwie strLocali wycelowaliśmy go w zupełnie nowy ciąg. Co się stanie, strMaingdy to zrobimy? Nic. Wciąż wskazuje na stary sznurek.

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" 

Niezmienność

Zmieńmy na chwilę scenariusz. Wyobraź sobie, że nie pracujemy z ciągami, ale jakimś zmiennym typem referencyjnym, takim jak utworzona przez Ciebie klasa.

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

Jeśli podążasz za odniesieniem objLocaldo obiektu, na który wskazuje, możesz zmienić jego właściwości:

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

W MutableThingpamięci wciąż jest tylko jeden i zarówno skopiowane odniesienie, jak i oryginalne odniesienie nadal do niego wskazują. Właściwości MutableThingsamego siebie uległy zmianie :

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   
}

Ach, ale struny są niezmienne! Nie ma ChangeMewłaściwości do ustawienia. Nie możesz tego zrobić strLocal[3] = 'H'w C # tak, jak w przypadku chartablicy w stylu C ; musisz zamiast tego skonstruować cały nowy ciąg. Jedynym sposobem zmiany strLocaljest wskazanie referencji na inny ciąg, a to oznacza, że ​​nic, co robisz, nie ma strLocalwpływu strMain. Wartość jest niezmienna, a odwołanie jest kopią.

Przekazywanie referencji przez referencje

Aby udowodnić, że istnieje różnica, oto co się dzieje, gdy przekazujesz referencję przez referencję:

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

Tym razem ciąg w Mainnaprawdę się zmienia, ponieważ przekazałeś referencję bez kopiowania jej na stos.

Więc nawet jeśli łańcuchy są typami referencyjnymi, przekazywanie ich przez wartość oznacza, że ​​cokolwiek dzieje się w wywoływanym, nie wpłynie na ciąg w wywołującym. Ale ponieważ są to typy referencyjne, nie musisz kopiować całego ciągu do pamięci, gdy chcesz go przekazać.

Dalsze zasoby:

• Oto najlepszy artykuł, jaki przeczytałem, na temat różnicy między typami odwołań a typami wartości w C # oraz dlaczego typ referencyjny nie jest tym samym, co parametr przekazany przez odwołanie.
• Jak zwykle Eric Lippert ma również kilka znakomitych postów na blogu na ten temat .
• Ma też świetne rzeczy na temat niezmienności .

Ciągi w języku C # są niezmiennymi obiektami referencyjnymi. Oznacza to, że odniesienia do nich są przekazywane (według wartości), a po utworzeniu ciągu nie można go modyfikować. Metody, które tworzą zmodyfikowane wersje ciągu (podciągi, wersje przycięte itp.) Tworzą zmodyfikowane kopie oryginalnego ciągu.

Ciągi znaków to szczególne przypadki. Każda instancja jest niezmienna. Kiedy zmieniasz wartość ciągu, przydzielasz nowy ciąg w pamięci.

Więc tylko referencja jest przekazywana do twojej funkcji, ale kiedy ciąg jest edytowany, staje się nową instancją i nie modyfikuje starej instancji.