Question Le plus cool truc C # LINQ / Lambdas que vous ayez jamais tiré?


J'ai vu un article sur les fonctionnalités cachées de C # mais peu de gens ont écrit l'exemple de linq / lambdas alors ... je me demande ...

Quelle est l'utilisation la plus cool (comme dans la plus élégante) des délégués C # LINQ et / ou Lambdas / anonymes que vous avez déjà vus / écrits?

Bonus s'il est entré en production aussi!


42
2017-08-26 19:04


origine


Réponses:


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

Je ne suis pas sûr si qualifie d'élégant mais c'est très certainement l'expression linq la plus cool que j'ai jamais vue!

Oh, et juste pour être extrêmement clair; J'ai fait ne pas écris le (Luke Hoban fait)


28
2017-08-26 19:54



Quelques fonctions de base:

public static class Functionals
{
    // One-argument Y-Combinator.
    public static Func<T, TResult> Y<T, TResult>(Func<Func<T, TResult>, Func<T, TResult>> F)
    {
        return t => F(Y(F))(t);
    }

    // Two-argument Y-Combinator.
    public static Func<T1, T2, TResult> Y<T1, T2, TResult>(Func<Func<T1, T2, TResult>, Func<T1, T2, TResult>> F)
    {
        return (t1, t2) => F(Y(F))(t1, t2);
    }

    // Three-arugument Y-Combinator.
    public static Func<T1, T2, T3, TResult> Y<T1, T2, T3, TResult>(Func<Func<T1, T2, T3, TResult>, Func<T1, T2, T3, TResult>> F)
    {
        return (t1, t2, t3) => F(Y(F))(t1, t2, t3);
    }

    // Four-arugument Y-Combinator.
    public static Func<T1, T2, T3, T4, TResult> Y<T1, T2, T3, T4, TResult>(Func<Func<T1, T2, T3, T4, TResult>, Func<T1, T2, T3, T4, TResult>> F)
    {
        return (t1, t2, t3, t4) => F(Y(F))(t1, t2, t3, t4);
    }

    // Curry first argument
    public static Func<T1, Func<T2, TResult>> Curry<T1, T2, TResult>(Func<T1, T2, TResult> F)
    {
        return t1 => t2 => F(t1, t2);
    }

    // Curry second argument.
    public static Func<T2, Func<T1, TResult>> Curry2nd<T1, T2, TResult>(Func<T1, T2, TResult> F)
    {
        return t2 => t1 => F(t1, t2);
    }

    // Uncurry first argument.
    public static Func<T1, T2, TResult> Uncurry<T1, T2, TResult>(Func<T1, Func<T2, TResult>> F)
    {
        return (t1, t2) => F(t1)(t2);
    }

    // Uncurry second argument.
    public static Func<T1, T2, TResult> Uncurry2nd<T1, T2, TResult>(Func<T2, Func<T1, TResult>> F)
    {
        return (t1, t2) => F(t2)(t1);
    }
}

Ne faites pas beaucoup de bien si vous ne savez pas comment les utiliser. Pour le savoir, vous devez savoir à quoi ils servent:


20
2017-08-18 15:32



L'implémentation Linq la plus impressionnante que je connaisse est le framework 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" dans linq, puis Brahma la traduit en HLSL (High Level Shader Language) pour que DirectX puisse le traiter sur le GPU.

Ce site me permettra de ne coller qu'un seul lien, alors essayez ce webcast de dotnetrocks:

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

Sinon, google pour Brahma Project, vous obtiendrez les bonnes pages.

Des trucs extrêmement cool.

GJ


17
2017-09-17 09:02



Rapport de progrès pour les requêtes LINQ de longue durée. Dans l'article du 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 lors de son exécution.


11
2017-08-26 19:30



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

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


4
2017-09-17 09:08



Pour moi, la dualité entre les délégués (Func<T,R>, Action<T>) et les expressions (Expression<Func<T,R>>  Expression<Action<T>>) est ce qui donne lieu aux utilisations les plus intelligentes des lambda.

Par exemple:

public static class PropertyChangedExtensions
{
    public static void Raise(this PropertyChangedEventHandler handler, Expression<Func<object>> propertyExpression)
    {
        if (handler != null)
        {
            // Retrieve lambda body
            var body = propertyExpression.Body as MemberExpression;
            if (body == null)
                throw new ArgumentException("'propertyExpression' should be a member expression");

            // Extract the right part (after "=>")
            var vmExpression = body.Expression as ConstantExpression;
            if (vmExpression == null)
                throw new ArgumentException("'propertyExpression' body should be a constant expression");

            // Create a reference to the calling object to pass it as the sender
            LambdaExpression vmlambda = Expression.Lambda(vmExpression);
            Delegate vmFunc = vmlambda.Compile();
            object vm = vmFunc.DynamicInvoke();

            // Extract the name of the property to raise a change on
            string propertyName = body.Member.Name;
            var e = new PropertyChangedEventArgs(propertyName);
            handler(vm, e);
        }
    }
}

Ensuite, vous pouvez "implémenter" en toute sécurité INotifyPropertyChanged en appelant

if (PropertyChanged != null)
    PropertyChanged.Raise( () => MyProperty );

Note: j'ai vu ceci sur le web il y a quelques semaines, puis j'ai perdu le lien et une vingtaine de variations sont apparues ici et là, alors j'ai peur de ne pas pouvoir vous donner d'attribution.


4
2017-09-17 09:36



Ce n'est pas ma conception mais je l'ai utilisée à quelques reprises, une déclaration de type tapé: http://community.bartdesmet.net/blogs/bart/archive/2008/03/30/a-functional-c-type-switch.aspx

M'a sauvé tellement si ... sinon si ... sinon si ... sinon SI! déclarations


3
2017-11-28 00:47



En fait, j'en suis assez fier pour générer des documents Excel: http://www.aaron-powell.com/linq-to-xml-to-excel


3
2017-08-26 19:16



J'ai fait une chose (un peu folle mais intéressante) comme ça récemment:


2
2017-09-17 09:14



J'essayais de trouver un moyen génial de créer un contrôle de navigation pour un site Web que je construisais. Je voulais utiliser des éléments de liste HTML non ordonnés (en utilisant la norme CSS "Sucker Fish") avec un effet de navigation de haut en bas qui révèle les éléments déroulants. J'avais un DataSet en cache dépendant de SQL avec deux tables (NavigationTopLevels & NavigationBottomLevels). Il ne me restait plus qu'à créer deux objets de classe (TopNav & SubNav) avec les quelques propriétés requises (la classe TopNav devait avoir une liste générique d'éléments bottomnav -> List <SubNav> SubItems).


var TopNavs = depuis n dans ds.NavigationTopLevels                           sélectionnez nouveau TopNav                           {                               NavigateUrl = String.Format ("{0} / {1}", tmpURL, n.id),                               Text = n.Text,                               id = n.id,                               SubItems = new List <SubNav> (                                   de si dans ds.NavigationBottomLevels                                   où si.parentID == n.id                                   sélectionnez nouveau SubNav                                   {                                       id = si.id,                                       level = si.NavLevel,                                       NavigateUrl = String.Format ("{0} / {1} / {2}", tmpURL, n.id, si.id),                                       parentID = si.parentID,                                       Texte = si.Text                                   }                                 )                           };  List <TopNav> TopNavigation = TopNavs.ToList ();

Ce n'est peut-être pas le plus "cool", mais pour beaucoup de gens qui veulent une navigation dynamique, il est agréable de ne pas avoir à se débrouiller dans la logique de boucle habituelle qui accompagne cela. LINQ est un gain de temps dans ce cas.


1
2017-11-22 20:41



Je pense que LINQ est un changement majeur pour .NET et c'est un outil très puissant.

J'utilise LINQ to XML en production pour analyser et filtrer les enregistrements d'un fichier XML de 6 Mo (avec plus de 20 niveaux de nœuds) dans un jeu de données en deux lignes de code.

Avant LINQ, cela aurait pris des centaines de lignes de code et des jours pour déboguer.

C'est ce que j'appelle élégant!


1