Quel est le tour le plus cool de C# LINQ/Lambdas que vous ayez jamais fait?

Question

J'ai vu un post sur les fonctionnalités cachées de C# mais peu de gens ont écrit un exemple de linq/lambdas donc... Je me demande...

Quelle est l'utilisation la plus cool (la plus élégante) de LINQ et/ou Lambdas/délégués anonymes en C# que vous ayez jamais vue/écrite?

Bonus si cela a été mis en production aussi!

Answer 1

Le Raytracer LINQ est certainement en tête de ma liste =)

Je ne suis pas tout à fait sûr s'il se qualifie d'élégant, mais c'est certainement l'expression LINQ la plus cool que j'aie jamais vue!

Oh, et juste pour être extrêmement clair ; je ne l'ai pas écrit (c'est Luke Hoban qui l'a fait)

Answer 2

Quelques fonctions de base:

public static class Functionals
{
    // Y-Combinateur à un argument.
    public static Func Y(Func, Func> F)
    {
        return t => F(Y(F))(t);
    }

    // Y-Combinateur à deux arguments.
    public static Func Y(Func, Func> F)
    {
        return (t1, t2) => F(Y(F))(t1, t2);
    }

    // Y-Combinateur à trois arguments.
    public static Func Y(Func, Func> F)
    {
        return (t1, t2, t3) => F(Y(F))(t1, t2, t3);
    }

    // Y-Combinateur à quatre arguments.
    public static Func Y(Func, Func> F)
    {
        return (t1, t2, t3, t4) => F(Y(F))(t1, t2, t3, t4);
    }

    // Currying du premier argument
    public static Func> Curry(Func F)
    {
        return t1 => t2 => F(t1, t2);
    }

    // Currying du deuxième argument
    public static Func> Curry2nd(Func F)
    {
        return t2 => t1 => F(t1, t2);
    }

    // Uncurrying du premier argument
    public static Func Uncurry(Func> F)
    {
        return (t1, t2) => F(t1)(t2);
    }

    // Uncurrying du deuxième argument
    public static Func Uncurry2nd(Func> F)
    {
        return (t1, t2) => F(t2)(t1);
    }
}

Ça ne sert pas à grand-chose si vous ne savez pas comment les utiliser. Pour le savoir, vous devez savoir à quoi ils servent:

• Qu'est-ce que le currying?
• Qu'est-ce qu'un y-combinateur?

Answer 3

De loin, la mise en œuvre Linq la plus impressionnante que j'aie jamais rencontrée est le cadre Brahma.

Il peut être utilisé pour décharger des calculs parallèles sur le GPU en utilisant 'Linq to GPU'. Vous écrivez une 'requête' en linq, puis Brahma la traduit en HLSL (High Level Shader Language) pour que DirectX puisse la traiter sur le GPU.

Ce site ne me permettra que de coller un seul lien, donc essayez ce webcast de dotnetrocks:

http://www.dotnetrocks.com/default.aspx?showNum=466

Sinon, recherchez le Projet Brahma, vous trouverez les bonnes pages.

Très cool.

GJ

Answer 4

Reporting de progression pour les requêtes LINQ longues. Dans l'article de blog, vous pouvez trouver une méthode d'extension WithProgressReporting() qui vous permet de découvrir et de signaler la progression d'une requête linq pendant son exécution.

Answer 5

http://igoro.com/archive/extended-linq-additional-operators-for-linq-to-objects/

http://igoro.com/archive/7-tricks-to-simplify-your-programs-with-linq/