Comment les chaînes sont-elles transmises dans .NET?

Lorsque je passe un stringà une fonction, un pointeur vers le contenu de la chaîne est-il passé ou la chaîne entière est-elle transmise à la fonction sur la pile comme le structserait un?

Une référence est passée; cependant, il n'est pas techniquement passé par référence. Il s'agit d'une distinction subtile mais très importante. Considérez le code suivant:

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

Il y a trois choses que vous devez savoir pour comprendre ce qui se passe ici:

1. Les chaînes sont des types de référence en C #.
2. Ils sont également immuables, donc chaque fois que vous faites quelque chose qui semble changer la chaîne, vous ne l'êtes pas. Une chaîne complètement nouvelle est créée, la référence est pointée dessus et l'ancienne est jetée.
3. Même si les chaînes sont des types de référence, elles strMainne sont pas passées par référence. C'est un type de référence, mais la référence elle-même est passée par valeur . Chaque fois que vous passez un paramètre sans le refmot - clé (sans compter les outparamètres), vous avez transmis quelque chose par valeur.

Cela doit donc signifier que vous ... passez une référence par valeur. Puisqu'il s'agit d'un type de référence, seule la référence a été copiée sur la pile. Mais qu'est ce que ça veut dire?

Passer des types de référence par valeur: vous le faites déjà

Les variables C # sont des types référence ou des types valeur . Les paramètres C # sont passés par référence ou par valeur . La terminologie est un problème ici; cela ressemble à la même chose, mais ce n'est pas le cas.

Si vous passez un paramètre de type ANY et que vous n'utilisez pas le refmot - clé, vous l'avez passé par valeur. Si vous l'avez passé par valeur, ce que vous avez vraiment transmis était une copie. Mais si le paramètre était un type de référence, alors la chose que vous avez copiée était la référence, pas celle vers laquelle elle pointait.

Voici la première ligne de la Mainméthode:

string strMain = "main";

Nous avons créé deux choses sur cette ligne: une chaîne avec la valeur mainstockée quelque part en mémoire, et une variable de référence appelée strMainpointant vers elle.

DoSomething(strMain);

Maintenant, nous passons cette référence à DoSomething. Nous l'avons passé par valeur, ce qui signifie que nous en avons fait une copie. C'est un type de référence, ce qui signifie que nous avons copié la référence, pas la chaîne elle-même. Nous avons maintenant deux références qui pointent chacune vers la même valeur en mémoire.

À l'intérieur de l'appelé

Voici le top de la DoSomethingméthode:

void DoSomething(string strLocal)

Pas de refmot-clé, donc strLocalet strMainsont deux références différentes pointant sur la même valeur. Si nous réaffectons strLocal...

strLocal = "local";   

... nous n'avons pas changé la valeur stockée; nous avons pris la référence appelée strLocalet l' avons dirigée vers une toute nouvelle chaîne. Qu'arrive-t-il strMainlorsque nous faisons cela? Rien. Il pointe toujours vers l'ancienne chaîne.

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" 

Immutabilité

Changeons le scénario une seconde. Imaginez que nous ne travaillons pas avec des chaînes, mais avec un type de référence mutable, comme une classe que vous avez créée.

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

Si vous suivez la référence objLocalà l'objet vers lequel il pointe, vous pouvez modifier ses propriétés:

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

Il n'y en a encore qu'un MutableThingen mémoire, et la référence copiée et la référence d'origine pointent toujours vers elle. Les propriétés de MutableThinglui-même ont changé :

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, mais les cordes sont immuables! Il n'y a aucune ChangeMepropriété à définir. Vous ne pouvez pas faire strLocal[3] = 'H'en C # comme vous pourriez le faire avec un chartableau de style C ; vous devez plutôt construire une toute nouvelle chaîne. La seule façon de changer strLocalest de pointer la référence sur une autre chaîne, et cela signifie que rien de ce que vous faites ne strLocalpeut affecter strMain. La valeur est immuable et la référence est une copie.

Passer une référence par référence

Pour prouver qu'il y a une différence, voici ce qui se passe lorsque vous passez une référence par référence:

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

Cette fois, la chaîne dans est Mainvraiment modifiée parce que vous avez passé la référence sans la copier sur la pile.

Ainsi, même si les chaînes sont des types de référence, les passer par valeur signifie que tout ce qui se passe dans l'appelé n'affectera pas la chaîne de l'appelant. Mais comme ce sont des types de référence, vous n'avez pas à copier la chaîne entière en mémoire lorsque vous souhaitez la transmettre.

Autres ressources:

• Voici le meilleur article que j'ai lu sur la différence entre les types de référence et les types de valeur en C # , et pourquoi un type de référence n'est pas le même qu'un paramètre passé par référence.
• Comme d'habitude, Eric Lippert a également plusieurs excellents articles de blog sur le sujet .
• Il a aussi de bonnes choses sur l'immuabilité .

Les chaînes en C # sont des objets de référence immuables. Cela signifie que les références à celles-ci sont transmises (par valeur) et qu'une fois qu'une chaîne est créée, vous ne pouvez pas la modifier. Les méthodes qui produisent des versions modifiées de la chaîne (sous-chaînes, versions découpées, etc.) créent des copies modifiées de la chaîne d'origine.

Les chaînes sont des cas particuliers. Chaque instance est immuable. Lorsque vous modifiez la valeur d'une chaîne, vous allouez une nouvelle chaîne en mémoire.

Ainsi, seule la référence est passée à votre fonction, mais lorsque la chaîne est modifiée, elle devient une nouvelle instance et ne modifie pas l'ancienne instance.