Code équivalent au mot clé ‘let’ dans les appels de méthode d’extension LINQ chaînés

En utilisant les fonctionnalités de compréhension des requêtes des compilateurs C #, vous pouvez écrire du code comme:

var names = new ssortingng[] { "Dog", "Cat", "Giraffe", "Monkey", "Tortoise" }; var result = from animalName in names let nameLength = animalName.Length where nameLength > 3 orderby nameLength select animalName;

Dans l’expression de requête ci-dessus, le mot clé let permet de transmettre une valeur aux opérations where et orderby sans appels en double à animalName.Length .

Quel est le jeu équivalent d’appels de méthode d’extension LINQ qui réalise ce que le mot clé “let” fait ici?

Let n’a pas sa propre opération; il tire de Select . Vous pouvez le voir si vous utilisez “réflecteur” pour séparer une DLL existante.

ce sera quelque chose comme:

 var result = names .Select(animalName => new { nameLength = animalName.Length, animalName}) .Where(x=>x.nameLength > 3) .OrderBy(x=>x.nameLength) .Select(x=>x.animalName);

Il y a un bon article ici

Essentiellement, crée un tuple anonyme. C’est équivalent à:

 var result = names.Select( animal => new { animal = animal, nameLength = animal.Length }) .Where(x => x.nameLength > 3) .OrderBy(y => y.nameLength) .Select(z => z.animal);

Il existe également une méthode d’extension .Let dans System.Interactive, mais elle vise à introduire une expression lambda à évaluer «en ligne» dans une expression fluide. Par exemple, considérons (dans LinqPad, par exemple) l’expression suivante qui crée de nouveaux nombres aléatoires à chaque exécution:

 var seq = EnumerableEx.Generate( new Random(), _ => true, _ => _, x => x.Next());

Pour voir que de nouveaux échantillons aléatoires apparaissent à chaque fois, considérez ce qui suit

 seq.Zip(seq, Tuple.Create).Take(3).Dump();

qui produit des paires dans lesquelles la gauche et la droite sont différentes. Pour produire des paires dans lesquelles la gauche et la droite sont toujours les mêmes, procédez comme suit:

 seq.Take(3).ToList().Let(xs => xs.Zip(xs, Tuple.Create)).Dump();

Si nous pouvions appeler directement des expressions lambda, nous pourrions écrire

 (xs => xs.Zip(xs, Tuple.Create))(seq.Take(3).ToList()).Dump();

Mais nous ne pouvons pas invoquer des expressions lambda comme s’il s’agissait de méthodes.