Qual è l'aspetto più difficile o incompreso di LINQ? [chiuso]

https://stackoverflow.com/questions/215548

03-07-2019
|

Domanda

Contesto: nel prossimo mese, terrò tre discorsi o almeno includerò LINQ nel 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 di SQL a IQueryable o Entity Framework, tranne come esempi di come le query possono essere eseguite in remoto usando gli alberi delle espressioni (e di solito <=>).

Quindi, cosa hai trovato di difficile in <=>? Cosa hai visto in termini di incomprensioni? Gli esempi potrebbero essere uno dei seguenti, ma per favore non limitarti!

Come il <=> compilatore tratta le espressioni di query
Espressioni lambda
Alberi delle espressioni
Metodi di estensione
Tipi anonimi
<=>
Esecuzione differita vs esecuzione immediata
Streaming vs esecuzione con buffer (ad es. OrderBy è differito ma con buffer)
Variabili locali tipizzate in modo implicito
Lettura di firme generiche complesse (ad es. Enumerable.Join )

Soluzione

Esecuzione ritardata

Altri suggerimenti

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

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 c'è molto di più che da LINQ a SQL e che le caratteristiche sono più di un <=> parser 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 un'espressione Lambda possa risolvere sia un albero delle espressioni che un delegato anonimo, quindi puoi passare la stessa espressione dichiarativa lambda sia ai metodi di estensione IEnumerable<T> che ai metodi di estensione IQueryable<T>.

Mi ha preso strada troppo a lungo per rendermi conto che molti metodi di estensione LINQ come Single(), SingleOrDefault() ecc hanno sovraccarichi che prendono lambdas.

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 provando a 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 una estensione di lingua , 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 <=> nelle raccolte, non torneremo MAI indietro!

<=> è 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!

Io per uno vorrei sicuramente 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

Combinando più query in una
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 IQueryable<T> per funzionare, LINQ riguarda solo la corrispondenza dei modelli.

alt text http://bartdesmet.info/images_wlw/QIsIQueryabletheRightChoiceforMe_13478>

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

Ho ancora problemi con il " let " command (che non ho mai trovato utile) e SelectMany (che ho usato, ma non sono sicuro di averlo fatto bene)

Comprensione della perdita di 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.

Le persone che pensano a Linq come Linq a SQL.
Alcune persone pensano di poter iniziare a sostituire tutte le foreach / la logica 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 hanno cospirato per formattarlo, ma per ora lo farà ...

Comunque, qui va ... Mi piacerebbe qualsiasi feedback, specialmente se ci sono aree in cui le persone vogliono maggiori informazioni.

Eccolo , piace o odio .. .

Alcuni dei messaggi di errore, specialmente 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 è davvero, davvero non intelligente.

Che IQueryable accetta entrambi, Expression<Func<T1, T2, T3, ...>> e Func<T1, T2, T3, ...>, senza dare un suggerimento sul 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 incompreso - ma per me, semplicemente sconosciuto.

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

Vedi qui per maggiori informazioni: MSDN: DataLoadOptions

Direi che l'aspetto più incompreso (o dovrebbe essere non compreso?) di LINQ è IQueryable e provider LINQ 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 e 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 considera se stesso come un guru TSQL non ci permetterebbe di usare LINQ nel nostro progetto e odia persino MS per aver rilasciato una cosa del genere !!!

Cosa rappresenta var quando viene eseguita una query?

È iQueryable, iSingleResult, iMultipleResult o cambia in base all'implementazione. Ci sono alcune speculazioni sull'uso (di quello che sembra essere) la tipizzazione dinamica rispetto alla tipizzazione statica standard in C #.

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

Ad esempio:

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

group by mi fa ancora girare la testa.

Qualsiasi confusione su esecuzione differita dovrebbe essere in grado di essere risolto passando attraverso un semplice codice basato su LINQ e giocando nella finestra di controllo.

Query compilate

Il fatto che non si possa incatenare IQueryable perché 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 dei miei <=> per ad-hoc in cui non ho query compilate (ho solo query compilate per gli scenari pesanti), ma nelle query compilate non posso usarle e invece devo scrivere query regolari sintassi di nuovo. Ora sto eseguendo le stesse subquery in 2 posti, devo ricordarmi 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 utilizzarlo efficacemente.

Un'altra cosa fraintesa su Linq a 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 in SQL con le classi Dynamic (ovvero 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 lento.

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 per creare 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)

Autorizzato sotto: CC-BY-SA insieme a attribuzione

Non affiliato a StackOverflow