Déclarer une variable à l'intérieur ou à l'extérieur d'une boucle foreach: qui est plus rapide / meilleur?

Question

Lequel de ceux-ci est le plus rapide / meilleur?

Celui-là:

 List<User> list = new List<User>();
User u;

foreach (string s in l)
{
    u = new User();
    u.Name = s;
    list.Add(u);
}
 

Ou celui-ci:

 List<User> list = new List<User>();

foreach (string s in l)
{
    User u = new User();
    u.Name = s;
    list.Add(u);
}
 

Mes compétences en développement de débutants me disent que le premier est meilleur, mais un de mes amis me dit que je me trompe, mais ne pourrait pas me donner une bonne raison pour laquelle le second est meilleur.

Y a-t-il une différence de performance?

Answer 1

En termes de performances, les deux exemples sont compilés sur le même IL, il n'y a donc aucune différence.

La seconde est meilleure, car elle exprime plus clairement votre intention si u n'est utilisé que dans la boucle.

Answer 2

Dans tous les cas, le meilleur moyen serait d'utiliser un constructeur qui prend un Nom... ou, au contraire, d'exploiter bouclés accolade de notation:

foreach (string s in l)
{
    list.Add(new User(s));
}

ou

foreach (string s in l)
{
    list.Add(new User() { Name = s });
}

ou encore mieux, LINQ:

var list = l.Select( s => new User { Name = s});

Maintenant, lors de votre premier exemple pourrait, dans certains cas, être unperceptibly plus rapide, le second est mieux parce que c'est plus lisible, et le compilateur peut ignorer la variable (et d'omettre tout à fait), car il n'est pas utilisé outsid l' foreachs'portée.

Answer 3

Une déclaration ne provoque l'exécution d'aucun code et ne constitue donc pas un problème de performances.

Le second est ce que vous voulez dire, et vous êtes moins susceptible de faire une erreur stupide si vous le faites de la deuxième façon, alors utilisez-le. Essayez toujours de déclarer des variables dans la plus petite portée nécessaire.

Et en plus, le meilleur moyen est d'utiliser Linq:

 List<User> users = l.Select(name => new User{ Name = name }).ToList();
 

Answer 4

Chaque fois que vous avez une question à propos de la performance, la seule chose à faire est de mesurer - exécuter une boucle autour de votre test et le temps.

Pour répondre à votre question - sans le mesurer :-) ou en regardant le générés ilasm - aucune différence ne serait pas perceptible dans un nombre significatif d'itérations et la plus coûteuse dans votre code, il est probable que l'affectation d'utilisateur par quelques ordres de grandeur, donc se concentrer sur le code de la clarté (comme vous devriez en général) et d'aller avec les 2.

Oh, sa fin et je suppose que je suis juste en train de dire ne vous inquiétez pas à propos de ce genre de chose ou de se laisser prendre dans des détails de ce genre.

K

Answer 5

Le 2ème est meilleur. Vous voulez avoir un nouvel utilisateur à chaque itération.