Comment sont les chaînes de transmission .NET?

Lorsque je passe un string à une fonction est un pointeur vers la chaîne du contenu transmis, ou est l'ensemble de la chaîne de caractères passée à la fonction sur la pile comme un struct serait?

InformationsquelleAutor Cole Johnson | 2012-05-29
  1. 252

    Pour répondre à votre question, considérons le code suivant:

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

    Il y a trois choses que vous devez savoir afin de prédire ce qui va se passer ici, et de comprendre pourquoi il le fait.

    1. Chaînes de caractères sont des types référence en C#. Mais ce n'est qu'une partie de l'image.
    2. Ils sont aussi immuables, donc à chaque fois que vous faites quelque chose qui vous ressemble sommes en train de changer la chaîne, vous ne l'êtes pas. Une complètement nouvelle chaîne est créé, la référence est signalée, et l'ancien se jette pas.
    3. Même si les chaînes sont des types référence, strMain n'est pas passé par référence. C'est un type de référence, mais la référence est passé par valeur. C'est une délicate distinction, mais il est d'une importance cruciale. Tout le temps que vous passez un paramètre sans le ref mot-clé (sans compter out paramètres), vous avez réussi quelque chose de valeur.

    Mais qu'est-ce que cela signifie?

    De référence passant types par valeur: Vous êtes déjà faire

    Il y a deux groupes de types de données en C#: types de référence et types de valeur. Il y a aussi deux façons de passer des paramètres en C#: par référence et en valeur. Ces sonner de la même façon et sont facilement confondus. Ils ne sont PAS la même chose!

    Si vous passez un paramètre de n'IMPORTE quel type, et que vous n'utilisez pas le ref mot-clé, vous avez passé par valeur. Si vous avez passé par valeur, ce que vous avez vraiment passé était une copie. Mais si le paramètre est un type de référence, alors la chose que vous avez copié est la référence, pas ce qu'il pointait.

    Voici la première ligne de notre Main méthode:

    string strMain = "main";

    Il y a deux choses que nous avons créé sur cette ligne: une chaîne de caractères avec la valeur main stockées en mémoire quelque part, et une variable de référence appelé strMain pointant vers elle. 

    DoSomething(strMain);

    Maintenant nous transmettre cette référence à DoSomething. Nous avons passé par valeur, ce qui signifie que nous avons fait une copie. Mais c'est un type de référence, ce qui signifie que nous avons copié la référence, et non la chaîne elle-même. Maintenant, nous avons deux références que chaque point de la même valeur dans la mémoire.

    À l'intérieur de l'appelant

    Voici le haut de la DoSomething méthode:

    void DoSomething(string strLocal)

    Pas ref mot-clé, comme d'habitude. Donc strLocal n'est pas strMain, mais ils pointent vers le même endroit. Si l'on peut "changer" strLocal, comme ça...

    strLocal = "local";

    ...nous n'avons pas changé la valeur stockée en soi. Nous avons re-signalé la référence. Nous avons pris la référence strLocal et il vise à une nouvelle marque de la chaîne. Ce qui se passe à strMain quand nous faisons cela? Rien. Il pointe toujours à la vieille chaîne!

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

    Immutabilité est important

    Nous allons changer le scénario pour une seconde. Imaginez que nous ne travaillez pas avec des chaînes, mais certains mutable type de référence, comme une classe que vous avez créé. 

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

    Si vous suivre la référence objLocal à l'objet de points, vous pouvez modifier ses propriétés:

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

    Il n'y a toujours qu'un seul MutableThing dans la mémoire, et à la fois la copie de référence et la référence d'origine pointent toujours vers elle. Les propriétés de l' MutableThing lui-même ont changé:

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

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

    Ah, mais...

    ...les chaînes sont immuables! Il n'y a pas ChangeMe propriété à définir. Vous ne pouvez pas faire strLocal[3] = 'H'; comme vous pouvez avec un style C char tableau; vous avez à construire une toute nouvelle chaîne à la place. La seule façon de changer strLocal est-à-point de la référence à une autre chaîne, et qui ne signifie rien vous faire pour strLocal peut affecter strMain. La valeur est immuable, et la référence est une copie.

    Ainsi, même si les chaînes sont des types référence, en passant par la valeur, c'est tout ce qui se passe dans le destinataire de l'appel ne sera pas affecter la chaîne en l'appelant. Mais, depuis qu'ils sont types de référence, vous n'avez pas à copier l'ensemble de la chaîne de caractères en mémoire lorsque vous voulez passer autour.

    D'autres ressources:

    • lire ceci: pooyakhamooshi.blogspot.co.uk/search?q=chaîne de caractères
    • Désolé, mais vous avez tort quand vous dites: "Un type de référence est passé par référence par défaut." Par défaut, tous les paramètres sont passés par valeur, mais avec des types de référence, cela signifie que la référence est passé par valeur. Vous êtes l'amalgame entre les types de référence avec des paramètres de référence, ce qui est compréhensible parce que c'est un très déroutant distinction. Voir le Passant de Types de Référence par la Valeur de l'article ici. lien de l'article est tout à fait correct, mais il soutient en fait mon point.
    • Afin de ne pas faire une morte fil de commentaires, mais je pense qu'premier plan du commentaire de sens que si l'on pense en C. En C, les données sont seulement un bloc de la mémoire. Une référence est un pointeur vers ce bloc de mémoire. Si vous transmettez l'ensemble du bloc de mémoire à une fonction, que l'on appelle le "passage par valeur". Si vous passez le pointeur, il est appelé "le passage par référence". En C#, il n'y a pas de notion de passage dans l'ensemble du bloc de mémoire, de sorte qu'ils redéfini "passage par valeur" pour dire en passant le pointeur dans. Qui semble mauvais, mais un pointeur est un bloc de mémoire aussi! Pour moi, la terminologie est assez arbitraire
    • Le problème est que nous ne travaillons pas en C et C# est très différent, malgré son nom similaire et de la syntaxe. Pour une chose, références ne sont pas les mêmes que les pointeurs, et de penser de cette façon peut conduire à des pièges. Le plus gros problème, cependant, est que "le passage par référence" a un très précis sens en C#, nécessitant la ref mot-clé. Pour prouver que le passage par référence fait une différence, voir cette démo: rextester.com/WKBG5978
    • Je suis d'accord que le mélange de C et de C# terminologie est mauvaise, mais, bien que j'ai apprécié lippert post, je ne pense pas que la pensée de références (pointeurs en particulier les brumes de quoi que ce soit ici. Le blog explique comment la pensée d'une référence comme un pointeur lui donne trop de pouvoir. Je suis conscient que le ref mot-clé a une utilité, j'essayais juste d'expliquer pourquoi l'une à penser le passage d'un type de référence par valeur en C# me semble que le "traditionnel" (c-C) notion de passage par référence (et le passage d'un type de référence par référence en C# semble de plus en plus comme de passer une référence à une référence de la valeur).
    • Vous avez raison, ils ont des similitudes, et il est difficile d'éviter la comparaison lors de la venue (comme beaucoup d'entre nous n') à partir de C/C++ C#. Je pense que nous sommes d'accord sur la plupart des choses à l'exception de l'importance de la terminologie. Pour moins de confusion, on pourrait parler de Appel-par-le Partage (C#) vs Call-by-Reference (C). En fait, cette question est un parfait exemple de pourquoi il est important: Avec appel par référence à la sémantique, la chaîne d'origine aurait être modifié par les opérations dans le destinataire de l'appel.
    • si vous lisez ce - que j'ai vu votre suggéré de modifier et de correction de la faute de frappe que vous avez trouvé. Grande pêche, je vous remercie.
    • Vous avez raison, mais je pense que @roliu faisait référence à la façon dont une fonction telle que Foo(string bar) pourrait être considéré comme Foo(char* bar) alors que Foo(ref string bar) serait Foo(char** bar) (ou Foo(char*& bar) ou Foo(string& bar) en C++). Bien sûr, ce n'est pas la façon dont vous devriez penser à elle tous les jours, mais en fait elle m'a aidé à enfin comprendre ce qui se passe sous le capot.

    InformationsquelleAutor Justin Morgan
  2. 23

    Chaînes de caractères en C# sont immuables objets de référence. Cela signifie que les références à eux sont passés (en valeur), et une fois qu'une chaîne est créé, vous ne pouvez pas le modifier. Les méthodes qui produisent des versions modifiées de la chaîne (chaînes, garni de versions, etc.) créer modifié copies de la chaîne d'origine.

    InformationsquelleAutor dasblinkenlight
  3. 10

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

    Donc, seule la référence est transmise à votre fonction, mais, quand la chaîne est modifiée, elle devient une nouvelle instance et ne modifie en rien de l'ancienne instance.

    • Donc, c'est pourquoi le StringBuilder est mieux lors de la construction de chaînes de caractères? (Si la chaîne de caractères arn pas "jeté" autour de la mémoire)
    • Les chaînes sont pas un cas particulier à cet aspect. Il est très facile de créer des objets immuables qui pourrait avoir la même sémantique. (C'est une instance d'un type qui n'a pas d'exposer une méthode pour transformer...)
    • Les chaînes de caractères sont des cas particuliers -, ils sont effectivement immuable de référence types qui semblent être mutables en ce qu'ils se comportent comme des types de valeur.
    • StringBuilder est une mutable classe string qui permet la modification rapide de la chaîne construite sans l'attribution de nouvelles chaînes dans la mémoire de chaque modification.
    • Par cette logique, alors Uri (la classe) et Guid (struct) sont également des cas spéciaux. Je ne vois pas comment System.String agit comme un "type de valeur", pas plus que les autres immuable types... de classe ou structure origines.
    • Les cordes ont de la création de la sémantique - contrairement à Uri & Guid - vous pouvez simplement assigner une chaîne littérale valeur à une variable de chaîne. La chaîne semble être mutable, comme un int être réaffectés, mais c'est la création d'un objet implicitement - pas de new mot-clé.
    • La chaîne est un cas spécial, mais qui n'a pas de pertinence à cette question. Type de la valeur, le type de référence, quel que soit le type va agissent tous de la même à cette question.
    • La seule chose qui fait que les chaînes de caractères un cas particulier est que C# prend en charge l'écriture comme des littéraux, et comme @KirkBroadhurst le souligne, ce n'est pas pertinente. Tout le reste, y compris leur "valeur type" comme comportement, je suppose que vous voulez dire des choses comme == comparaison de la valeur) peut être facilement transposé dans les types définis par l'utilisateur. Je ne voudrais pas les décrire comme de se comporter comme des types de valeur.

    InformationsquelleAutor Enigmativity