C # optimise-t-il la concaténation des littéraux de chaîne?

Question

Par exemple, le compilateur sait-il traduire

 string s = "test " + "this " + "function";
 

à

 string s = "test this function";
 

et ainsi éviter les performances touchées par la concaténation de chaînes?

Answer 1

Oui. Cela est garanti par la spécification C#. C'est dans la section 7.18 (C# 3.0):

Chaque fois qu'une expression remplit les les exigences énumérées ci-dessus, le l'expression est évaluée à au moment de la compilation. Cela est vrai même si l' l'expression est une sous-expression d'un plus grande expression qui contient non-constante des constructions.

(Les "exigences énumérées ci-dessus", y compris l'opérateur + appliqué à deux expressions constantes.)

Voir également cette question.

Answer 2

Juste une remarque sur un sujet connexe - le compilateur C# aura aussi "optimiser" plusieurs enchaînements de non-littéraux à l'aide de la '+' opérateur à un seul appel à un multi-paramètre de surcharge de la Chaîne.Méthode Concat ().

Donc

string result = x + y + z;

compile de quelque chose d'équivalent à

string result = String.Concat( x, y, z);

plutôt que le plus naïf possibilité:

string result = String.Concat( String.Concat( x, y), z);

Rien de fracassant, mais je voulais juste ajouter ce bit à la discussion sur la chaîne de caractères littérale concaténation d'optimisation. Je ne sais pas si ce comportement est mandaté par la langue standard ou pas.

Answer 3

Oui.

C # optimise non seulement la concaténation des littéraux de chaîne, mais réduit également les littéraux de chaîne équivalents en constantes et utilise des pointeurs pour référencer toutes les références à la même constante.

Answer 4

Oui - Vous pouvez voir cela de manière explicite à l'aide de ILDASM.

Exemple:

Voici un programme qui est similaire à votre exemple suivi par la compilation de code CIL:

Note: je suis l'aide de la Chaîne.Concat() la fonction juste pour voir comment le compilateur traite les deux différentes méthodes de concaténation.

Programme

class Program
{
    static void Main(string[] args)
    {
        string s = "test " + "this " + "function";
        string ss = String.Concat("test", "this", "function");
    }
}

ILDASM

.method private hidebysig static void  Main(string[] args) cil managed
{
  .entrypoint
  // Code size       29 (0x1d)
  .maxstack  3
  .locals init (string V_0,
           string V_1)
  IL_0000:  nop
  IL_0001:  ldstr      "test this function"
  IL_0006:  stloc.0
  IL_0007:  ldstr      "test"
  IL_000c:  ldstr      "this"
  IL_0011:  ldstr      "function"
  IL_0016:  call       string [mscorlib]System.String::Concat(string,
                                                              string,
                                                              string)
  IL_001b:  stloc.1
  IL_001c:  ret
} // end of method Program::Main

Notez comment au IL_0001 le compilateur créé la constante "tester cette fonction", par opposition à la façon dont le compilateur traite la Chaîne.Concat() la fonction qui crée une constante pour chaque de la .Concat() params, puis appelle la .Concat() fonction.

Answer 5

Des chevaux à la bouche:

"Concaténation est le processus d'ajout d'une chaîne de caractères à la fin d'une autre chaîne. Lorsque vous concaténer des chaînes de caractères littérales ou des constantes de chaîne en utilisant l'opérateur+, le compilateur crée une chaîne unique. Aucun moment de l'exécution de concaténation se produit. Cependant, les variables de chaîne peuvent être concaténés seulement au moment de l'exécution. Dans ce cas, vous devez comprendre les implications sur les performances des différentes approches. "

http://msdn.microsoft.com/en-us/library/ms228504.aspx