Antecedentes: durante el próximo mes, daré tres charlas sobre, o al menos incluidas LINQen el contexto de C#. Me gustaría saber a qué temas vale la pena prestarles una buena atención, en función de lo que las personas puedan encontrar difícil de entender o de lo que puedan tener una impresión errónea. No me referiré específicamente LINQa SQLEntity Framework, excepto como ejemplos de cómo las consultas se pueden ejecutar de forma remota utilizando árboles de expresión (y generalmente IQueryable).

Entonces, ¿qué te ha resultado difícil LINQ? ¿Qué has visto en términos de malentendidos? Los ejemplos pueden ser cualquiera de los siguientes, ¡pero no se limite!

• Cómo C#trata el compilador las expresiones de consulta
• Expresiones lambda
• Árboles de expresión
• Métodos de extensión
• Tipos anónimos
• IQueryable
• Ejecución diferida vs inmediata
• Streaming vs ejecución amortiguada (por ejemplo, OrderBy es diferido pero almacenado)
• Variables locales escritas implícitamente
• Lectura de firmas genéricas complejas (por ejemplo, Enumerable.Join )

Ejecución retrasada

Sé que el concepto de ejecución diferida ya debería estar en mi contra, pero este ejemplo realmente me ayudó a comprenderlo de manera práctica:

static void Linq_Deferred_Execution_Demo()
{
    List<String> items = new List<string> { "Bob", "Alice", "Trent" };

    var results = from s in items select s;

    Console.WriteLine("Before add:");
    foreach (var result in results)
    {
        Console.WriteLine(result);
    }

    items.Add("Mallory");

    //
    //  Enumerating the results again will return the new item, even
    //  though we did not re-assign the Linq expression to it!
    //

    Console.WriteLine("\nAfter add:");
    foreach (var result in results)
    {
        Console.WriteLine(result);
    }
}

El código anterior devuelve lo siguiente:

Before add:
Bob
Alice
Trent

After add:
Bob
Alice
Trent
Mallory

Que hay más que solo LINQpara SQLy las características son más que un SQLanalizador incorporado en el lenguaje.

Gran O notación . LINQ hace que sea increíblemente fácil escribir algoritmos O (n ^ 4) sin darse cuenta, si no sabe lo que está haciendo.

Creo que el hecho de que una Lambdaexpresión puede resolverse tanto en un árbol de expresiones como en un delegado anónimo, por lo que puede pasar la misma lambdaexpresión declarativa tanto a los IEnumerable<T>métodos de IQueryable<T>extensión como a los métodos de extensión.

Me tomó forma demasiado tiempo para darse cuenta de que muchos métodos de extensión LINQ tales como Single(), SingleOrDefault()etc tienen sobrecargas que toman lambdas.

Tu puedes hacer :

Single(x => x.id == id)

y no necesito decir esto, que algún mal tutorial me hizo tener la costumbre de hacer

Where(x => x.id == id).Single()

En LINQ to SQL veo constantemente personas que no entienden el DataContext, cómo se puede usar y cómo se debe usar. Demasiadas personas no ven el DataContext por lo que es, un objeto de Unidad de Trabajo, no un objeto persistente.

He visto muchas veces que las personas intentan seleccionar un DataContext / session it / etc en lugar de hacer un nuevo horario para cada operación.

Y luego está deshacerse del DataContext antes de que se haya evaluado el IQueryable, pero eso es más un problema con las personas que no entienden IQueryable que el DataContext.

El otro concepto con el que veo mucha confusión es la sintaxis de consulta frente a la sintaxis de expresión. Usaré la que sea más fácil en ese punto, a menudo con la sintaxis de expresión. Mucha gente todavía no se da cuenta de que al final producirán lo mismo, después de todo, Query se compila en Expression.

Creo que la parte incomprendida de LINQ es que es una extensión de lenguaje , no una extensión o construcción de base de datos.

LINQes mucho más que LINQ to SQL.

Ahora que la mayoría de nosotros hemos usado LINQcolecciones, ¡NUNCA volveremos!

LINQ es la característica más importante para .NET desde Generics en 2.0, y Tipos anónimos en 3.0.

Y ahora que tenemos Lambda's, ¡no puedo esperar para la programación paralela!

Por mi parte, me gustaría saber si necesito saber qué son los árboles de expresión y por qué.

Soy bastante nuevo en LINQ. Aquí están las cosas que me tropecé en mi primer intento

• Combinando varias consultas en una
• Depuración efectiva de consultas LINQ en Visual Studio.

Algo de lo que no me di cuenta originalmente era que la sintaxis de LINQ no requiere IEnumerable<T>o noIQueryable<T> funciona, LINQ se trata solo de la coincidencia de patrones.

texto alternativo http://bartdesmet.info/images_wlw/QIsIQueryabletheRightChoiceforMe_13478/image_thumb_3.png

Aquí está la respuesta (no, no escribí ese blog, lo hizo Bart De Smet, y es uno de los mejores bloggers en LINQ que he encontrado).

Todavía tengo problemas con el comando "let" (para el que nunca he encontrado un uso) y SelectMany (que he usado, pero no estoy seguro de haberlo hecho bien)

Comprender cuándo se filtra la abstracción entre los proveedores de Linq. Algunas cosas funcionan en objetos pero no en SQL (por ejemplo, .TakeWhile). Algunos métodos pueden traducirse a SQL (ToUpper) mientras que otros no. Algunas técnicas son más eficientes en objetos donde otras son más efectivas en SQL (diferentes métodos de unión).

Un par de cosas.

1. La gente piensa en Linq como Linq para SQL.
2. Algunas personas piensan que pueden comenzar a reemplazar todo foreach / logic con consultas Linq sin tener en cuenta estas implicaciones de rendimiento.

OK, debido a la demanda, he escrito algunas de las cosas de Expression. No estoy 100% contento con la forma en que blogger y LiveWriter han conspirado para formatearlo, pero lo hará por ahora ...

De todos modos, aquí va ... Me encantaría cualquier comentario, especialmente si hay áreas donde la gente quiere más información.

Aquí está , me gusta o lo odias ...

Algunos de los mensajes de error, especialmente de LINQ a SQL, pueden ser bastante confusos. mueca

La ejecución diferida me ha mordido un par de veces como todos los demás. Creo que lo más confuso para mí ha sido el proveedor de consultas de SQL Server y lo que puede y no puede hacer con él.

Todavía estoy sorprendido por el hecho de que no puedes hacer una suma () en una columna decimal / dinero que a veces está vacía. Usar DefaultIfEmpty () simplemente no funcionará. :(

Creo que una gran cosa para cubrir en LINQ es cómo puedes meterte en problemas en cuanto al rendimiento. Por ejemplo, usar el recuento de LINQ como condición de bucle no es realmente inteligente.

Que IQueryable acepta ambos Expression<Func<T1, T2, T3, ...>>y Func<T1, T2, T3, ...>, sin dar una pista sobre la degradación del rendimiento en el segundo caso.

Aquí hay un ejemplo de código, que demuestra lo que quiero decir:

[TestMethod]
public void QueryComplexityTest()
{
    var users = _dataContext.Users;

    Func<User, bool>                funcSelector =       q => q.UserName.StartsWith("Test");
    Expression<Func<User, bool>>    expressionSelector = q => q.UserName.StartsWith("Test");

    // Returns IEnumerable, and do filtering of data on client-side
    IQueryable<User> func = users.Where(funcSelector).AsQueryable();
    // Returns IQuerible and do filtering of data on server side
    // SELECT ... FROM [dbo].[User] AS [t0] WHERE [t0].[user_name] LIKE @p0
    IQueryable<User> exp = users.Where(expressionSelector);
}

No sé si califica como incomprendido, pero para mí, simplemente desconocido.

Me complació aprender sobre DataLoadOptions y cómo puedo controlar qué tablas se unen cuando hago una consulta en particular.

Consulte aquí para obtener más información: MSDN: DataLoadOptions

Yo diría que el aspecto más incomprendido (¿o no debería entenderse?) De LINQ es IQueryable y los proveedores de LINQ personalizados .

He estado usando LINQ por un tiempo y estoy completamente cómodo en el mundo IEnumerable, y puedo resolver la mayoría de los problemas con LINQ.

Pero cuando comencé a mirar y leer sobre IQueryable, y Expressions y proveedores de linq personalizados, me dio vueltas la cabeza. Eche un vistazo a cómo funciona LINQ to SQL si desea ver una lógica bastante compleja.

Espero comprender ese aspecto de LINQ ...

Como dijo la mayoría de la gente, creo que la parte más incomprendida es asumir que LINQ es solo un reemplazo para T-SQL. ¡Mi gerente que se considera a sí mismo como un gurú de TSQL no nos permitió usar LINQ en nuestro proyecto e incluso odia a MS por lanzar tal cosa!

¿Qué representa var cuando se ejecuta una consulta?

¿Es iQueryable, iSingleResult, iMultipleResult, o cambia basa en la aplicación. Hay algunas especulaciones sobre el uso (lo que parece ser) de escritura dinámica frente a la escritura estática estándar en C #.

Lo fácil que es anidar un bucle es algo que no creo que todos entiendan.

Por ejemplo:

from outerloopitem in outerloopitems
from innerloopitem in outerloopitem.childitems
select outerloopitem, innerloopitem

group by Todavía me da vueltas la cabeza.

Cualquier confusión sobre la ejecución diferida debe poder resolverse al pasar por un código simple basado en LINQ y jugar en la ventana de observación.

Consultas compiladas

El hecho de que no se pueden encadenar IQueryable, ya que son las llamadas de método (mientras todavía otra cosa que traducible SQL!) Y que es casi imposible de trabajo alrededor de ella se mindboggling y crea una enorme violación de SECO. Necesito el mío IQueryablepara ad-hoc en el que no tengo consultas compiladas (solo tengo consultas compiladas para los escenarios pesados), pero en las consultas compiladas no puedo usarlas y en su lugar necesito escribir una sintaxis de consulta regular nuevamente. Ahora estoy haciendo las mismas subconsultas en 2 lugares, necesito recordar actualizar ambas si algo cambia, y así sucesivamente. Una pesadilla.

Creo que la idea errónea n. ° 1 sobre LINQ to SQL es que TODAVÍA TIENE QUE CONOCER SQL para poder usarlo de manera efectiva.

Otra cosa mal entendida acerca de Linq to Sql es que aún debe reducir la seguridad de su base de datos hasta el punto absurdo para que funcione.

Un tercer punto es que el uso de Linq to Sql junto con las clases dinámicas (lo que significa que la definición de clase se crea en tiempo de ejecución) provoca una enorme cantidad de compilación justo a tiempo. Lo que puede matar absolutamente el rendimiento.

Carga lenta.

Como se mencionó, carga diferida y ejecución diferida

Cómo LINQ to Objects y LINQ to XML (IEnumerable) son diferentes de LINQ to SQL (IQueryable)

CÓMO construir una capa de acceso a datos, una capa empresarial y una capa de presentación con LINQ en todas las capas ... y un buen ejemplo.

Como dijo la mayoría de la gente, creo que la parte más incomprendida es asumir que LINQ es solo un reemplazo para T-SQL. ¡Mi gerente que se considera a sí mismo como un gurú de TSQL no nos permitió usar LINQ en nuestro proyecto e incluso odia a MS por lanzar tal cosa!

Transacciones (sin usar TransactionScope)