c# - tutorial - linq lambda where

El mejor truco de C#LINQ/Lambdas que alguna vez has sacado?

Question

Vi una publicación sobre las funciones ocultas en C #, pero no mucha gente ha escrito ejemplos de linq / lambdas así que ... Me pregunto ...

¿Cuál es el uso más genial (como el más elegante) de C # LINQ y / o Lambdas / delegados anónimos que haya visto / escrito alguna vez?

¡Bonificación si también entró en producción!

Answer 1

Algunos funcionales básicos:

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);
    }
}

No sirva de mucho si no sabe cómo usarlos. Para saber eso, necesitas saber para qué sirven:

• ¿Qué es currying?
• ¿Qué es un combinador de y?

Answer 2

Con mucho, la implementación de Linq más impresionante que he encontrado es el marco de trabajo de Brahma.

Se puede usar para descargar cálculos paralelos a la GPU usando ''Linq a GPU''. Usted escribe una ''consulta'' en linq, y luego Brahma la traduce a HLSL (High Level Shader Language) para que DirectX pueda procesarla en la GPU.

Este sitio solo me permitirá pegar un enlace, así que prueba este webcast desde dotnetrocks:

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

Si no es por Google para el Proyecto Brahma, obtendrá las páginas correctas.

Cosas extremadamente geniales

GJ

Answer 3

Consultas LINQ reactivas de OLINQ sobre INotifyingCollection: estas permiten realizar (entre otras cosas) agregación en tiempo real frente a grandes conjuntos de datos.

https://github.com/wasabii/OLinq

Answer 4

Creo que LINQ es un cambio importante en .NET y es una herramienta muy poderosa.

Uso LINQ to XML en producción para analizar y filtrar registros de un archivo XML de 6MB (con más de 20 niveles de nodo) en un conjunto de datos en dos líneas de código.

Antes de LINQ esto habría tomado cientos de líneas de código y días para depurar.

¡Eso es lo que llamo elegante!

Answer 5

De hecho, estoy bastante orgulloso de esto por generar documentos en Excel: http://www.aaron-powell.com/linq-to-xml-to-excel

Answer 6

El LINQ Raytracer ciertamente encabeza mi lista =)

No estoy seguro de si califica como elegante, pero sin duda es la mejor expresión de linq que he visto en mi vida.

Ah, y solo para ser extremadamente claro; No lo escribí ( Luke Hoban lo hizo)

Answer 7

Estaba tratando de encontrar una forma genial de construir un control de navegación para un sitio web que estaba construyendo. Quería usar elementos de lista HTML sin ordenar (empleando el aspecto CSS estándar "Sucker Fish" ) con un efecto de mouse de navegación superior que revela los elementos desplegables. Tenía un DataSet en caché dependiente de sql con dos tablas (NavigationTopLevels & NavigationBottomLevels). Entonces todo lo que tuve que hacer fue crear dos objetos de clase (TopNav y SubNav) con las pocas propiedades requeridas (la clase TopNav tenía que tener una lista genérica de elementos bottomnav -> List <SubNav> SubItems).

var TopNavs = from n in ds.NavigationTopLevels select new TopNav { NavigateUrl = String.Format("{0}/{1}", tmpURL, n.id), Text = n.Text, id = n.id, SubItems = new List<SubNav>( from si in ds.NavigationBottomLevels where si.parentID == n.id select new SubNav { id = si.id, level = si.NavLevel, NavigateUrl = String.Format("{0}/{1}/{2}", tmpURL, n.id, si.id), parentID = si.parentID, Text = si.Text } ) }; List<TopNav> TopNavigation = TopNavs.ToList();

Puede que no sea el "más genial", pero para mucha gente que quiere tener navegación dinámica, es bueno no tener que meterse en la lógica de bucle habitual que viene con eso. LINQ es, en todo caso, un ahorro de tiempo en este caso.

Answer 8

Hice una cosa (un poco loca, pero interesante) recientemente:

• http://tomasp.net/blog/reactive-iv-reactivegame.aspx

Answer 9

No es mi diseño pero lo he usado varias veces, una declaración de cambio de tipo: http://community.bartdesmet.net/blogs/bart/archive/2008/03/30/a-functional-c-type-switch.aspx

Me salvó tantos si ... si ... si ... si ... más SI! declaraciones

Answer 10

Para mí, la dualidad entre delegados ( Func<T,R> , Action<T> ) y expresiones ( Expression<Func<T,R>> Expression<Action<T>> ) es lo que da lugar a los usos más inteligentes de lambdas.

Por ejemplo:

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);
        }
    }
}

Luego puede implementar "de manera segura" INotifyPropertyChanged llamando

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

Nota: Vi esto en la web al principio hace unas semanas, luego perdí el enlace y una veintena de variaciones han surgido aquí y allá desde entonces, así que me temo que no puedo dar la atribución adecuada.

Answer 11

Tal vez no sea el más genial, pero recientemente los he estado usando cada vez que tengo un bloque de código que obtiene C + Pd una y otra vez solo para cambiar algunas líneas. Por ejemplo, ejecutar comandos SQL simples para recuperar datos se puede hacer así:

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;
    }
);

Que podría devolver una lista de publicaciones que se crearon hoy. De esta forma, no tengo que copiar y pegar el bloque try-catch-finally quince millones de veces para cada comando, objeto, etc.

Answer 12

Trabajando con atributos:

private void WriteMemberDescriptions(Type type)
{
    var descriptions =
        from member in type.GetMembers()
        let attributes = member.GetAttributes<DescriptionAttribute>(true)
        let attribute = attributes.FirstOrDefault()
        where attribute != null
        select new
        {
            Member = member.Name,
            Text = attribute.Description
        };

        foreach(var description in descriptions)
        {
            Console.WriteLine("{0}: {1}", description.Member, description.Text);
        }
}

El método de extensión GetAttributes :

public static class AttributeSelection
{
    public static IEnumerable<T> GetAttributes<T>(this ICustomAttributeProvider provider, bool inherit) where T : Attribute
    {
        if(provider == null)
        {
            throw new ArgumentNullException("provider");
        }

        return provider.GetCustomAttributes(typeof(T), inherit).Cast<T>();
    }
}

AttributeSelection es un código de producción y también define GetAttribute y HasAttribute . Elegí usar las cláusulas let y where en este ejemplo.

Answer 13

Informes de progreso para consultas LINQ de larga ejecución. En la publicación del blog, puede encontrar un método de extensión WithProgressReporting () que le permite descubrir e informar el progreso de una consulta de linq mientras se ejecuta.

Answer 14

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

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