Antefatto: nel prossimo mese, terrò tre discorsi o almeno LINQnel contesto di C#. Mi piacerebbe sapere a quali argomenti vale la pena prestare una buona dose di attenzione, in base a ciò che le persone possono trovare difficili da capire, o di cosa potrebbero avere un'impressione sbagliata. Non parlerò in modo specifico LINQdi SQLEntity Framework o di Entity tranne che come esempi di come le query possono essere eseguite in remoto usando gli alberi delle espressioni (e di solito IQueryable).

Quindi, cosa hai trovato difficile LINQ? Cosa hai visto in termini di incomprensioni? Gli esempi potrebbero essere i seguenti, ma per favore non limitarti!

• Come il C#compilatore tratta le espressioni di query
• Espressioni Lambda
• Alberi di espressione
• Metodi di estensione
• Tipi anonimi
• IQueryable
• Esecuzione differita vs esecuzione immediata
• Streaming vs esecuzione con buffer (ad es. OrderBy è differito ma con buffer)
• Variabili locali tipizzate implicitamente
• Lettura di firme generiche complesse (ad es. Enumerable.Join )

Esecuzione ritardata

So che il concetto di esecuzione differita dovrebbe essere battuto in me ormai, ma questo esempio mi ha davvero aiutato a comprenderlo pratico:

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

Il codice sopra riportato restituisce quanto segue:

Before add:
Bob
Alice
Trent

After add:
Bob
Alice
Trent
Mallory

Che ci sia più di un semplice LINQper SQLe le caratteristiche sono molto più di un SQLparser incorporato nella lingua.

Notazione O grande . LINQ rende incredibilmente facile scrivere algoritmi O (n ^ 4) senza accorgersene, se non sai cosa stai facendo.

Penso che Lambdaun'espressione possa risolversi sia in un albero delle espressioni che in un delegato anonimo, quindi puoi trasmettere la stessa lambdaespressione dichiarativa sia ai IEnumerable<T>metodi di IQueryable<T>estensione che ai metodi di estensione.

Mi ha portato via troppo tempo per rendersi conto che molti metodi di estensione LINQ, come Single(), SingleOrDefault()ecc hanno sovraccarichi che prendono lambda.

Tu puoi fare :

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

e non c'è bisogno di dirlo - che qualche brutto tutorial mi ha preso l'abitudine di fare

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

In LINQ to SQL vedo costantemente persone che non comprendono DataContext, come può essere usato e come dovrebbe essere usato. Troppe persone non vedono DataContext per quello che è, un oggetto Unit of Work, non un oggetto persistente.

Ho visto un sacco di volte in cui le persone stanno cercando di singleton un DataContext / session it / etc piuttosto che fare un nuovo tempo per ogni operazione.

E poi c'è lo smaltimento di DataContext prima che IQueryable sia stato valutato, ma è più di una ragione con persone che non capiscono IQueryable di DataContext.

L'altro concetto con cui vedo molta confusione è Query Syntax vs Expression Syntax. Userò quale mai è il più semplice a quel punto, spesso attenendosi alla sintassi di espressione. Molte persone ancora non si rendono conto che alla fine produrranno la stessa cosa, dopo tutto la query viene compilata in Expression.

Penso che la parte incompresa di LINQ sia che si tratta di un'estensione del linguaggio , non di un'estensione o di un costrutto di database.

LINQè molto più di LINQ to SQL.

Ora che la maggior parte di noi ha utilizzato le LINQcollezioni, non torneremo MAI più indietro!

LINQ è la caratteristica più significativa per .NET da Generics in 2.0 e Tipi anonimi in 3.0.

E ora che abbiamo Lambda, non vedo l'ora di programmare in parallelo!

Personalmente vorrei sapere se ho bisogno di sapere quali sono gli alberi delle espressioni e perché.

Sono abbastanza nuovo in LINQ. Ecco le cose su cui sono inciampato nel mio primo tentativo

• Combinazione di più query in una
• Effettuare il debug efficace delle query LINQ in Visual Studio.

Qualcosa che inizialmente non mi ero reso conto era che la sintassi LINQ non richiede IEnumerable<T>o nonIQueryable<T> funziona, LINQ riguarda solo la corrispondenza dei modelli.

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

Ecco la risposta (no, non ho scritto quel blog, Bart De Smet, ed è uno dei migliori blogger su LINQ che ho trovato).

Ho ancora problemi con il comando "let" (per cui non ho mai trovato un uso) e SelectMany (che ho usato, ma non sono sicuro di averlo fatto bene)

Comprendere quando perde l'astrazione tra i fornitori di Linq. Alcune cose funzionano su oggetti ma non su SQL (ad es. .TakeWhile). Alcuni metodi possono essere tradotti in SQL (ToUpper) mentre altri no. Alcune tecniche sono più efficienti negli oggetti in cui altre sono più efficaci in SQL (diversi metodi di join).

Un paio di cose.

1. La gente pensa a Linq come Linq a SQL.
2. Alcune persone pensano di poter iniziare a sostituire tutte le operazioni foreach / logic con le query Linq senza considerare queste implicazioni sulle prestazioni.

OK, a causa della domanda, ho scritto alcune delle cose di Expression. Non sono soddisfatto al 100% di come blogger e LiveWriter abbiano cospirato per formattarlo, ma per ora lo farà ...

Ad ogni modo, qui va ... Mi piacerebbe qualsiasi feedback, soprattutto se ci sono aree in cui le persone vogliono maggiori informazioni.

Eccolo , piace o odio ...

Alcuni dei messaggi di errore, in particolare da LINQ a SQL, possono essere piuttosto confusi. sorriso

Sono stato morso dall'esecuzione differita un paio di volte come tutti gli altri. Penso che la cosa più confusa per me sia stata il provider di query di SQL Server e ciò che puoi e non puoi farci.

Sono ancora sorpreso dal fatto che non puoi fare una somma () su una colonna decimale / denaro che a volte è vuota. L'uso di DefaultIfEmpty () non funzionerà. :(

Penso che una cosa grandiosa da affrontare in LINQ sia come mettersi nei guai in termini di prestazioni. Ad esempio, l'utilizzo del conteggio di LINQ come condizione di loop non è davvero intelligente.

Che IQueryable accetta entrambi Expression<Func<T1, T2, T3, ...>>eFunc<T1, T2, T3, ...> , senza dare un accenno al degrado delle prestazioni nel secondo caso.

Ecco un esempio di codice che dimostra cosa intendo:

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

Non so se si qualifichi come frainteso - ma per me, semplicemente sconosciuto.

Mi ha fatto piacere conoscere DataLoadOptions e come posso controllare quali tabelle vengono unite quando eseguo una query specifica.

Vedi qui per maggiori informazioni: MSDN: DataLoadOptions

Direi che l'aspetto più incompreso (o che non dovrebbe essere compreso?) Di LINQ è rappresentato dai provider LINQ IQueryable e personalizzati .

Sto usando LINQ da un po 'di tempo e sono completamente a mio agio nel mondo IEnumerable e posso risolvere la maggior parte dei problemi con LINQ.

Ma quando ho iniziato a guardare e leggere IQueryable, Expressions e fornitori di linq personalizzati mi ha fatto girare la testa. Dai un'occhiata a come funziona LINQ to SQL se vuoi vedere una logica piuttosto complessa.

Non vedo l'ora di capire quell'aspetto di LINQ ...

Come molte persone hanno detto, penso che la parte più fraintesa sia supporre che LINQ sia solo un sostituto di T-SQL. Il mio manager che si considera un guru di TSQL non ci permetterebbe di usare LINQ nel nostro progetto e odia persino la SM per aver rilasciato una cosa del genere !!!

Cosa rappresenta var quando viene eseguita una query?

E ' iQueryable, iSingleResult, iMultipleResult, o lo fa cambia in base alla realizzazione. C'è qualche speculazione sull'uso (di ciò che sembra essere) di tipo dinamico rispetto a quello statico standard in C #.

Quanto sia facile nidificare un ciclo è qualcosa che non credo capiscano tutti.

Per esempio:

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

group by mi fa ancora girare la testa.

Qualsiasi confusione sull'esecuzione differita dovrebbe poter essere risolta esaminando un semplice codice basato su LINQ e giocando nella finestra di controllo.

Query compilate

Il fatto che non si possa incatenare IQueryableperché sono chiamate di metodo (mentre ancora nient'altro che SQL traducibile!) E che è quasi impossibile aggirarlo è strabiliante e crea un'enorme violazione di DRY. Ho bisogno del mio IQueryablead-hoc in cui non ho compilato query (ho solo compilato query per gli scenari pesanti), ma nelle query compilate non posso usarle e invece devo scrivere di nuovo la sintassi delle query regolari. Ora sto eseguendo le stesse subquery in 2 posti, devo ricordare di aggiornare sia se qualcosa cambia, e così via. Un incubo.

Penso che l'idea sbagliata n. 1 su LINQ to SQL sia che DEVI ANCORA CONOSCERE SQL per poterne fare un uso efficace.

Un'altra cosa fraintesa su Linq to Sql è che devi ancora abbassare la sicurezza del tuo database al punto di assurdità per farlo funzionare.

Un terzo punto è che l'uso di Linq a SQL insieme alle classi dinamiche (il che significa che la definizione della classe viene creata in fase di esecuzione) provoca un'enorme quantità di compilazione just-in-time. Che può assolutamente uccidere le prestazioni.

Caricamento pigro.

Come accennato, caricamento lento ed esecuzione differita

In che modo LINQ to Objects e LINQ to XML (IEnumerable) sono diversi da LINQ a SQL (IQueryable)

COME costruire un livello di accesso ai dati, un livello aziendale e un livello di presentazione con LINQ in tutti i livelli .... e un buon esempio.

Come molte persone hanno detto, penso che la parte più fraintesa sia supporre che LINQ sia solo un sostituto di T-SQL. Il mio manager che si considera un guru di TSQL non ci permetterebbe di usare LINQ nel nostro progetto e odia persino la SM per aver rilasciato una cosa del genere !!!

Transazioni (senza utilizzare TransactionScope)