9
votes

Plus rapide de déclarer des variables à l'intérieur d'une boucle ou d'une boucle?

est-il plus rapide de déclarer des variables à l'intérieur d'une boucle ou d'une boucle? Par exemple: xxx pré>

lequel est plus rapide? Pourquoi? Je suppose que ce dernier est plus rapide car il suffit de réutiliser le même "pointeur" de faire référence à une nouvelle valeur dans les coulisses au lieu de créer un nouveau pointeur chaque itération, correct? Quelqu'un peut-il élaborer? P>

Merci P>

Mise à jour: strong> p>

Le compilateur est suffisamment intelligent pour optimiser le code lors de la génération du langage intermédiaire. Il déplace les déclarations variables en haut de la méthode. Ci-dessous, les déclassements de l'IL après compilation: p> xxx pré>

voici l'ensemble de l'IL pour les personnes intéressées: p>

.method private instance void  Form1_Load(object sender,
                                          class [mscorlib]System.EventArgs e) cil managed
{
  // Code size       55 (0x37)
  .maxstack  2
  .locals init ([0] string newVariable2,
           [1] int32 i,
           [2] string newVariable,
           [3] int32 V_3,
           [4] int32 VB$CG$t_i4$S0)
  IL_0000:  nop
  IL_0001:  ldc.i4.0
  IL_0002:  stloc.1
  IL_0003:  ldarg.0
  IL_0004:  callvirt   instance string WindowsApplication1.TestVariableDeclaration::getstring()
  IL_0009:  stloc.2
  IL_000a:  nop
  IL_000b:  ldloc.1
  IL_000c:  ldc.i4.1
  IL_000d:  add.ovf
  IL_000e:  stloc.1
  IL_000f:  ldloc.1
  IL_0010:  ldc.i4     0x989680
  IL_0015:  stloc.s    VB$CG$t_i4$S0
  IL_0017:  ldloc.s    VB$CG$t_i4$S0
  IL_0019:  ble.s      IL_0003
  IL_001b:  ldc.i4.0
  IL_001c:  stloc.3
  IL_001d:  ldarg.0
  IL_001e:  callvirt   instance string WindowsApplication1.TestVariableDeclaration::getstring()
  IL_0023:  stloc.0
  IL_0024:  nop
  IL_0025:  ldloc.3
  IL_0026:  ldc.i4.1
  IL_0027:  add.ovf
  IL_0028:  stloc.3
  IL_0029:  ldloc.3
  IL_002a:  ldc.i4     0x989680
  IL_002f:  stloc.s    VB$CG$t_i4$S0
  IL_0031:  ldloc.s    VB$CG$t_i4$S0
  IL_0033:  ble.s      IL_001d
  IL_0035:  nop
  IL_0036:  ret
} // end of method TestVariableDeclaration::Form1_Load

optimization .net loops variables declaration

2 commentaires

Peut-être que le compilateur l'optimiserait? Meilleur conseil: incendiez votre IDE, instancez un chronomètre et courez quelques milliers d'itérations de chaque version et voyez s'il y a une vraie différence.

Bonne idée! Brb avec les résultats ..

3 Réponses :

2
votes

Je pouvais imaginer que l'optimiseur sait que celles-ci sont identiques et qu'ils s'avèrent donc avoir la même performance. Ce n'est peut-être pas cependant. Vous pouvez soit inspecter le code d'objet ou la mesure.

0 commentaires

4
votes

ni. Vous créez toujours une nouvelle chaîne dans chaque itération de la boucle, de sorte qu'ils seront les mêmes. Même s'il y en a un, ce que vous prenez est incroyable négligeable dans la grande portée des choses.

La déclaration d'étendue de la variable est ce qui changera, et si vous n'en avez pas besoin en dehors de la boucle, vous devriez le placer à l'intérieur.

0 commentaires

13
votes

Je suis d'accord avec la réponse de Kevin, définissez les variables où elles ont une signification. S'inquiéter des optimisations si et quand ils se présentent eux-mêmes et que vous savez qu'une déclaration variable est la question. Cependant, considérez les deux morceaux de code suivants xxx

et leur générés il: xxx

voir la différence? Ces gars compilateurs, ils sont intelligents.

1 commentaires

L'utilisation de la chronomètre n'était pas très utile. J'ai eu des résultats variables, mais je regarde l'IL était bonificial. Essentiellement, le compilateur déplace la déclaration au sommet de la méthode dans l'IL. Je vais éditer mon message pour fournir une clarification de l'IL.