Cool C#, LINQ/Lambdas vous tromper n'ai jamais tiré?

De base fonctionnelles:

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 pas faire beaucoup de bien si vous ne savez pas comment les utiliser. Dans le but de savoir que vous besoin de savoir ce qu'ils sont pour:

• Qu'est-ce que nourrissage?
• Ce qui est un y-combinator?

Rapports Sur Les Progrès Réalisés pour de longues requêtes LINQ. Dans le billet de blog, vous pouvez trouver une méthode d'extension WithProgressReporting() qui vous permet de découvrir et de faire rapport sur les progrès d'une requête linq comme il l'exécute.

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

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 "en toute sécurité" mettre en œuvre INotifyPropertyChanged en appelant

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

Remarque : j'ai vu cela sur le web à première il y a quelques semaines, puis a perdu le lien et un score de variations ont surgi ici et là depuis je crains que je ne peut pas donner la bonne attribution.

Pas ma conception, mais je l'ai utilisé quelques fois, typé-instruction switch: http://community.bartdesmet.net/blogs/bart/archive/2008/03/30/a-functional-c-type-switch.aspx

M'a sauvé tellement de nombreux if... else if... else if... else if! états

J'ai essayé de trouver une façon cool de construire un contrôle de navigation pour un site, j'ai été la construction. J'ai voulu l'utiliser régulièrement HTML liste non ordonnée d'éléments (employant la norme CSS "Sucker Poisson" regardez) avec un haut-de navigation de la souris sur l'effet que révèle la liste des éléments. J'ai eu un sql dépendante de la mise en cache DataSet avec deux tables (NavigationTopLevels & NavigationBottomLevels). Ensuite, tout ce que je devais était de créer deux objets de la classe (TopNav & SubNav) avec les quelques propriétés requises (le TopNav classe a dû avoir une liste générique de bottomnav éléments -> Liste<SubNav> Points).

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

 

Il pourrait ne pas être le "plus cool", mais pour beaucoup de gens qui veulent avoir une navigation dynamique, son doux de ne pas avoir de confusion autour de l'habitude de boucle logique qui vient avec ça. LINQ est, si quoi que ce soit d'un gain de temps dans ce cas.

Peut-être pas le plus cool, mais récemment, j'ai été de les utiliser à tout moment, j'ai un bloc de code C+Pd maintes et maintes fois pour les avoir seulement quelques lignes de changement. Par exemple, l'exécution de simples commandes SQL pour extraire des données peut être fait comme suit:

SqlDevice device = GetDevice();
return device.GetMultiple<Post>(
"GetPosts",
(s) => {
s.Parameters.AddWithValue("@CreatedOn", DateTime.Today);
return true;
},
(r, p) => {
p.Title = r.Get<string>("Title");
//Fill out post object
return true;
}
);

Qui pourrait revenir à une liste de Postes qui ont été créés aujourd'hui. De cette façon, je n'ai pas de copier et de coller le try-catch-finally bloc de quinze millions de fois pour chaque commande, de l'objet, et cetera.

OLINQ réactif requêtes LINQ sur INotifyingCollection - ci vous permettent de le faire (entre autres choses) agrégation en temps réel contre les grands ensembles de données.

https://github.com/wasabii/OLinq