Devrait LINQ être évitée car elle est lente?

Devrait Linq être évitée en raison de sa lente?

Pas. Il doit être évité si elle est pas assez rapide. Lent et pas assez rapide ne sont pas du tout la même chose!

Lent est pas pertinent pour vos clients, votre gestion et vos parties prenantes. Pas assez rapide est extrêmement pertinent. Ne jamais mesurer comment rapide quelque chose; qui vous dit rien que vous pouvez utiliser à la base d'une décision d'affaires sur. Mesure près d'être acceptable pour le client il est. Si elle est acceptable, alors arrêter de dépenser de l'argent sur le rendant plus rapide; c'est déjà bien assez.

L'optimisation de la Performance est cher. L'écriture de code de sorte qu'il peut être lu et entretenus par d'autres est cher. Ces objectifs sont souvent en opposition les uns aux autres, afin de passer vos parties prenantes de l'argent de façon responsable, vous avez pour vous assurer que vous êtes seulement un temps précieux et d'efforts à faire de l'optimisation des performances sur des choses qui sont pas assez rapide.

Vous avez trouvé une artificielle, irréaliste de référence situation où LINQ code est plus lent que sur une autre façon d'écrire le code. Je vous assure que vos clients de soins n'est pas un peu sur la vitesse de votre irréaliste de référence. Ils ont en charge uniquement si le programme que vous êtes de livraison est trop lent pour eux. Et je vous assure, la gestion de votre soucis n'est pas un peu à ce sujet (si elles sont compétentes); ils se soucient de savoir combien d'argent vous serez en mesure de dépenser inutilement de faire des trucs qui est assez rapide unnoticably plus rapide, et de rendre le code plus cher de lire, de comprendre, et de maintenir dans le processus.

Peut-être que j'ai manqué quelque chose, mais je suis sûr que tes repères sont éteints.

J'ai testé avec les méthodes suivantes:

• La Any méthode d'extension ("LINQ")
• Un simple foreach boucle (votre "optimisé" de la méthode)
• À l'aide de la ICollection.Contains méthode
• La Any méthode d'extension à l'aide d'une optimisation de structure de données (HashSet<T>)

Voici le code de test:

class Program
{
static void Main(string[] args)
{
var names = Enumerable.Range(1, 10000).Select(i => i.ToString()).ToList();
var namesHash = new HashSet<string>(names);
string testName = "9999";
for (int i = 0; i < 10; i++)
{
Profiler.ReportRunningTimes(new Dictionary<string, Action>() 
{
{ "Enumerable.Any", () => ExecuteContains(names, testName, ContainsAny) },
{ "ICollection.Contains", () => ExecuteContains(names, testName, ContainsCollection) },
{ "Foreach Loop", () => ExecuteContains(names, testName, ContainsLoop) },
{ "HashSet", () => ExecuteContains(namesHash, testName, ContainsCollection) }
},
(s, ts) => Console.WriteLine("{0, 20}: {1}", s, ts), 10000);
Console.WriteLine();
}
Console.ReadLine();
}
static bool ContainsAny(ICollection<string> names, string name)
{
return names.Any(s => s == name);
}
static bool ContainsCollection(ICollection<string> names, string name)
{
return names.Contains(name);
}
static bool ContainsLoop(ICollection<string> names, string name)
{
foreach (var currentName in names)
{
if (currentName == name)
return true;
}
return false;
}
static void ExecuteContains(ICollection<string> names, string name,
Func<ICollection<string>, string, bool> containsFunc)
{
if (containsFunc(names, name))
Trace.WriteLine("Found element in list.");
}
}

Ne vous inquiétez pas sur le fonctionnement interne de la Profiler classe. Il fonctionne juste l' Action dans une boucle et utilise un Stopwatch pour le moment. Elle fait également en sorte d'appeler GC.Collect() avant chaque test afin d'éliminer autant de bruit que possible.

Voici les résultats:

      Enumerable.Any: 00:00:03.4228475
ICollection.Contains: 00:00:01.5884240
Foreach Loop: 00:00:03.0360391
HashSet: 00:00:00.0016518
Enumerable.Any: 00:00:03.4037930
ICollection.Contains: 00:00:01.5918984
Foreach Loop: 00:00:03.0306881
HashSet: 00:00:00.0010133
Enumerable.Any: 00:00:03.4148203
ICollection.Contains: 00:00:01.5855388
Foreach Loop: 00:00:03.0279685
HashSet: 00:00:00.0010481
Enumerable.Any: 00:00:03.4101247
ICollection.Contains: 00:00:01.5842384
Foreach Loop: 00:00:03.0234608
HashSet: 00:00:00.0010258
Enumerable.Any: 00:00:03.4018359
ICollection.Contains: 00:00:01.5902487
Foreach Loop: 00:00:03.0312421
HashSet: 00:00:00.0010222

Les données est très cohérent et raconte l'histoire suivante:

• Naïvement à l'aide de la Any méthode d'extension est d'environ 9% plus lent que naïvement à l'aide d'un foreach boucle.

• À l'aide de la méthode la plus appropriée (ICollection<string>.Contains) avec un unoptimized structure de données (List<string>) est d'environ 50% plus rapide que naïvement à l'aide d'un foreach boucle.

• À l'aide d'une optimisation de structure de données (HashSet<string>) souffle complètement l'une des méthodes hors de l'eau en termes de performances.

Je n'ai aucune idée de l'endroit où vous avez obtenu 243% de. Ma conjecture est qu'il a quelque chose à faire avec tout ce casting. Si vous utilisez un ArrayList alors non seulement vous à l'aide d'un unoptimized structure de données, vous êtes en utilisant une grande partie obsolètes structure de données.

Je peux prévoir ce qui vient ensuite. "Ouais, je sais que vous pouvez l'optimiser un peu mieux, mais c'était juste un exemple pour comparer la performance de LINQ vs non-LINQ."

Ouais, mais si vous ne pouvait pas encore être approfondie dans votre exemple, comment peut-on s'attendre à l'être approfondie dans le code de production?

La ligne de fond est: est-ce

Comment vous l'architecte et la conception de votre logiciel est considérablement plus important que ce que les outils spécifiques que vous utilisez et quand.

Si vous exécutez dans les goulets d'étranglement de performance - qui est tout aussi susceptible de se produire avec LINQ vs sans - puis à les résoudre. Eric suggestion de traitement automatisé de tests de performance est excellente; qui va vous aider à identifier les problèmes précoce de sorte que vous pouvez les résoudre correctement - pas en fuyant un outil étonnant qui vous fait 80% plus productif, mais il arrive à subir une < 10% de la performance, mais en fait enquêter sur la question et à venir avec une vraie solution qui peuvent booster vos performances par un facteur de 2, ou 10, ou 100 ou plus.

De créer des applications de haute performance n'est pas à propos de l'utilisation du droit de bibliothèques. C'est à propos de de profilage, à faire de bons choix de conception, et la rédaction d'un bon code.

Tout prématurée pessimization est (à mon humble avis) aussi mauvais que l'optimisation prématurée, vous ne devriez pas écarter toute une technologie basée sur la vitesse absolue, sans prendre d'utilisation en considération. Oui, si vous êtes en train de faire quelques très lourd arithmétique et c'est un goulot d'étranglement, LINQ pourrait être problématique - profil.

Un argument que vous pourriez utiliser en faveur de LINQ, c'est que, tandis que vous pouvez probablement surpasser avec manuscrites code, le LINQ version pourrait être plus clair et plus facile à maintenir - en plus, il y a l'avantage de PLINQ par rapport à manuel complexe de parallélisation.

Peut-être linq est lent, mais avec linq je peut paralléliser mon code très simple.

Comme ceci:

lst1.Cast<MyLinqTestClass1>().AsParallel().Any(item => item.Name == "9999");

Comment vous paralléliser cycle?

Voici une observation intéressante, puisque vous parlez de nHibernate est lent comme une conséquence de LINQ d'être lent. Si vous êtes en train de faire LINQ to SQL (ou nHibernate équivalent), puis votre code LINQ se traduit par une EXISTE requête sur le serveur SQL server où en tant que votre boucle de code doit d'abord récupérer toutes les lignes, puis itérer sur eux. Maintenant, vous pouvez facilement écrire un tel test, de sorte que la boucle de code lit toutes les données à la fois (un seul DB de recherche) pour tous les 10K s'exécute, mais le code LINQ effectue 10K de requêtes SQL. Il va probablement afficher un grand avantage en termes de vitesse de la boucle de version qui n'existe pas dans la réalité. En réalité, un seul EXISTE requête est en passe de dépasser l'analyse de la table et de la boucle à chaque fois, même si vous ne disposez pas d'un index sur la colonne qui est interrogé (qui vous serait probablement si cette requête est fait très souvent).

Je ne dis pas que c'est le cas avec votre test, nous n'avons pas assez de code pour voir, mais il pourrait l'être. Il se pourrait aussi que il y a vraiment une différence de performance avec LINQ to Objects, mais qui ne peut pas se traduire à LINQ to SQL à tous. Vous devez savoir ce que vous êtes en mesure et comment elle est applicable à votre monde réel besoin.

Oui, vous avez raison. Il est facile d'écrire lente code dans LINQ. Les autres sont à droite, trop: il est facile d'écrire lente code en C# sans LINQ.

J'ai écrit la même boucle que vous en C et il a couru pendant un certain nombre de millisecondes plus rapide. La conclusion que je tire de cette est que C# lui-même est lent.

Comme avec votre LINQ->boucle d'expansion, en C il va prendre plus de 5 fois plus de lignes de code pour faire la même chose, le rendant plus lent à écrire, plus difficile à lire, plus susceptibles d'avoir des bugs, et plus difficile à trouver et les corriger, mais si l'enregistrement de quelques millisecondes pour chaque milliard de dollars d'itérations est important, c'est souvent ce qu'il faut.

Je dirais plutôt que vous devriez éviter d'essayer trop dur d'écrire le plus efficace du code, à l'exception, c'est obligatoire.

Votre cas de test est un peu biaisé. Le TOUT opérateur va commencer l'énumération par le biais de vos résultats et de les retourner true en cas de première instance si trouve et cesser de fumer. Essayez cela avec de simples listes de chaînes pour voir le résultat. Pour répondre à votre question sur la façon d'éviter LINQ, vous devriez vraiment la transition vers l'utilisation de LINQ. Il rend le code plus facile à lire quand vous faites des requêtes complexes en plus de compiler le temps de vérifier. Aussi, vous n'avez pas besoin d'utiliser l'opérateur de Cast dans votre exemple.

string compareMe = "Success";
string notEqual = "Not Success";
List<string> headOfList = new List<string>();
List<string> midOfList = new List<string>();
List<string> endOfList = new List<string>();
//Create a list of 999,999 items
List<string> masterList = new List<string>();
masterList.AddRange(Enumerable.Repeat(notEqual, 999999));
//put the true case at the head of the list
headOfList.Add(compareMe);
headOfList.AddRange(masterList);
//insert the true case in the middle of the list
midOfList.AddRange(masterList);
midOfList.Insert(masterList.Count/2, compareMe);
//insert the true case at the tail of the list
endOfList.AddRange(masterList);
endOfList.Add(compareMe);
Stopwatch stopWatch = new Stopwatch();
stopWatch.Start();
headOfList.Any(p=>p == compareMe);
stopWatch.ElapsedMilliseconds.Dump();
stopWatch.Reset();
stopWatch.Start();
midOfList.Any(p=>p == compareMe);
stopWatch.ElapsedMilliseconds.Dump();
stopWatch.Reset();
stopWatch.Start();
endOfList.Any(p=>p == compareMe);
stopWatch.ElapsedMilliseconds.Dump();
stopWatch.Stop();

Il y a mille fois plus de raisons pour éviter de Linq.

Citation suivante à partir d'une discussion sur Linq noms de quelques-uns d'entre eux:

QUOTE1

"Par exemple cela fonctionne:

var a = new { x = 1, y = 2 };
a = new { x = 1, y = 3 };

Mais cela ne fonctionne pas:

var a = new { x = 1, y = 2 };
a = new { x = 1, y = 2147483649 };

Il retourne : Error 1 Cannot implicitly convert type 'AnonymousType#1' to 'AnonymousType#2'

Mais cela fonctionne:

var a = new { x = 1, y = 2147483648 };
a = new { x = 1, y = 2147483649 };

Lors de la compilation:

var a = new { x = 1, y = 2 };

Le type de composants x et y est arbitrairement déclaré comme un entier signé de 32 bits, et il est l'un des nombreux types integer de la plate-forme, sans rien de spécial.

Mais il n'y est plus. Par exemple cela fonctionne:

double x = 1.0;
x = 1;

Mais cela ne fonctionne pas:

var a = new { x = 1.0, y = 0 }; 
a = new { x = 1, y = 0 };

La conversion numérique règles ne sont pas applicables à ce genre de types. Comme vous pouvez le voir, l'élégance est dans chaque détail."

QUOTE2

"Il semble, alors, que" AnonymousType#1 " et "AnonymousType#2" ne sont pas synonymes-ils le nom de types distincts. Et comme { x = 1, y = 2 } et { y = 2, x = 1 } sont les expressions de ces deux types, respectivement, non seulement ils dénotent des valeurs distinctes, mais aussi des valeurs de types distincts.

Ce qui m'a le droit d'être paranoïaque. Maintenant, ma paranoïa s'étend encore plus loin et j'ai demander à ce que LinQ fait la comparaison suivante:

new { x = 1, y = 2 } == new { x = 1, y = 2 }

Le résultat est faux parce que c'est un pointeur de comparaison.

Mais le résultat de:

(new { x = 1, y = 2 }).Equals(new { x = 1, y = 2 })

Est vrai.

Et le résultat de:

(new { x = 1, y = 2 }).Equals(new { y = 2, x = 1 })

et

(new { x = 1, y = 2 }).Equals(new { a = 1, b = 2 })

Est faux."

QUOTE3

"mises à jour d'enregistrement sont orientées vers :-O

Cela, je suis d'accord, est problématique, et la dérive de LINQ séquence tournée vers la nature.

C'est un frein pour moi. Si je dois utiliser SQL pour mes mises à jour de toute façon, pourquoi se préoccuper de LinQ?

l'optimisation de LinQ to objects est unexistent.

Il n'est pas algébrique d'optimisation, ni automatique expression de réécriture. Beaucoup de gens ne veulent pas utiliser LinQ to Objects, car ils perdent beaucoup de performance. Les requêtes sont exécutées de la même manière que vous les écrivez."