O que é o mais difícil ou mais aspecto mal compreendido de LINQ? [fechadas]

https://stackoverflow.com/questions/215548

03-07-2019
|

Pergunta

Antecedentes: Durante o próximo mês, vou dar três palestras sobre ou, pelo menos, incluindo LINQ no contexto de C#. Eu gostaria de saber quais tópicos valem a pena dar uma boa quantidade de atenção, com base no que as pessoas podem achar difícil de entender, ou o que eles podem ter uma impressão equivocada de. Eu não vou ser especificamente falando LINQ para SQL ou o Entity Framework, exceto como exemplos de como as consultas podem ser executadas remotamente usando árvores de expressão (e geralmente IQueryable).

Então, o que você achou difícil sobre LINQ? O que você viu em termos de mal-entendidos? Exemplos podem ser qualquer um dos seguintes, mas por favor não se limite!

Como o C# compilador trata consulta expressões
As expressões lambda
Árvores de expressão
Os métodos de extensão
Tipos anônimos
IQueryable
diferidos vs execução imediata
Fluindo vs execução tamponada (por exemplo OrdenarPor é adiada, mas tamponada)
variáveis ??locais implicitamente digitadas
Leitura assinaturas genéricas complexas (por exemplo Enumerable.Join )

Solução

execução atrasada

Outras dicas

Eu sei que o conceito de execução diferida deve ser batido em mim até agora, mas este exemplo realmente me ajudou a obter uma compreensão prática do mesmo:

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

Os retornos de código acima o seguinte:

Before add:
Bob
Alice
Trent

After add:
Bob
Alice
Trent
Mallory

Que não é mais do que apenas LINQ para SQL e os recursos são mais do que apenas um analisador SQL incorporado na língua.

Big O notação . LINQ torna incrivelmente fácil de escrever O (n ^ 4) algoritmos sem perceber, se você não sabe o que está fazendo.

Eu acho que o fato de que uma expressão Lambda pode resolver a ambos uma árvore de expressão e um delegado anônimo, para que possa passar a mesma expressão lambda declarativa para ambos os métodos de extensão IEnumerable<T> e métodos de extensão IQueryable<T>.

Levei modo muito tempo para perceber que muitos métodos de extensão LINQ, como Single(), SingleOrDefault() etc têm sobrecargas que levam lambdas.

Você pode fazer:

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

e não preciso dizer isso - que algumas más tutorial me tenho o hábito de fazer

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

Em LINQ to SQL Eu sempre ver as pessoas não compreender o DataContext, como ele pode ser usado e como ele deve ser usado. Muitas pessoas não vêem o DataContext para o que é, uma unidade de trabalho objeto, não um objeto persistente.

Já vi muitas vezes em que as pessoas estão tentando Singleton um DataContext / sessão, / etc, em vez de fazer um novo tempo para cada operação.

E depois há a eliminação do DataContext antes do IQueryable foi avaliado, mas que é mais de um prople com pessoas não entender IQueryable que o DataContext.

O outro conceito que eu vejo um monte de confusão com é a Sintaxe de Consulta vs Expression Syntax. Vou usar o que for o mais fácil nesse ponto, muitas vezes furando com Expression Syntax. Um monte de pessoas ainda não percebem que eles vão produzir a mesma coisa no final, consulta é compilado em Expression depois de tudo.

Eu acho que o incompreendido parte do LINQ é que ele é uma extensão da linguagem , e não uma extensão de banco de dados ou construção.

LINQ é muito mais do que LINQ to SQL.

Agora que a maioria de nós tem LINQ usado em coleções, nós nunca voltar!

LINQ é a característica mais significativa único para .NET desde Generics em 2.0, e Tipos anónimos em 3.0.

E agora que temos Lambda de, eu não posso esperar para a programação paralela!

Eu, pelo menos faria certeza gostaria de saber se eu preciso saber quais são árvores de expressão, e por quê.

Eu sou bastante novo para LINQ. Eis as coisas que eu tropeçou na minha primeira tentativa

A combinação de várias consultas em um
Efetivamente depuração consultas LINQ no Visual Studio.

Algo que eu não fiz originalmente perceberam foi que a sintaxe LINQ não requerem IEnumerable<T> ou IQueryable<T> ao trabalho, LINQ é apenas sobre a correspondência de padrão.

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

Aqui é a resposta (não, eu fez não gravação que blog, Bart de Smet fez, e que ele está dos melhores blogueiros on LINQ eu encontrei você).

Ainda tenho problemas com o comando "let" (que eu nunca encontrei um uso para) e SelectMany (que eu usei, mas eu não tenho certeza que eu tenho feito isso direito)

Entendimento quando a abstração entre Linq prestadores de vazamentos. Algumas coisas funcionam em objetos, mas não SQL (por exemplo, .TakeWhile). Alguns métodos podem se traduzido em SQL (ToUpper), enquanto outros não podem. Algumas técnicas são mais eficientes em objetos onde os outros são mais eficazes em SQL (diferente métodos de junção).

Algumas coisas.

As pessoas pensando em Linq como LINQ to SQL.
Algumas pessoas pensam que eles podem começar a substituir todos foreach / lógica com consultas LINQ sem considerar este implicações de desempenho.

OK, devido à demanda, Eu escrevi algumas das coisas Expression. Eu não estou 100% feliz com o blogueiro e LiveWriter conspiraram para formatá-lo, mas ele vai fazer por agora ...

De qualquer forma, aqui vai ... Eu adoraria algum feedback, especialmente se existem áreas onde as pessoas querem mais informações.

Aqui é , goste ou odiá-lo .. .

Algumas das mensagens de erro, especialmente a partir de LINQ to SQL pode ser bastante confuso. sorriso

Eu fui mordido pelo execução adiada algumas vezes, como todos os outros. Eu acho que a coisa mais confuso para mim tem sido o provedor SQL Server Query eo que você pode e não pode fazer com ele.

Ainda estou espantado com o fato de você não pode fazer uma Sum () em uma coluna decimal / dinheiro que às vezes é esvaziar. Usando DefaultIfEmpty () só não vai funcionar. : (

Eu acho que uma grande coisa para cobertura em LINQ é como você pode obter-se em termos de performance problemas. Por exemplo, usando contagem de LINQ como uma condição de loop é realmente, realmente não é inteligente.

Isso IQueryable aceitar tanto, Expression<Func<T1, T2, T3, ...>> e Func<T1, T2, T3, ...>, sem dar uma dica sobre a degradação do desempenho no segundo caso.

Aqui é exemplo de código, que demonstra o que quero dizer:

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

Eu não sei se ela se qualifica como mal compreendido - mas para mim, simplesmente desconhecido

Tive o prazer de aprender sobre DataLoadOptions e como posso controlar quais tabelas são unidas quando eu faço uma consulta particular.

Veja aqui para mais informações: MSDN: DataLoadOptions

Eu diria que o mais mal entendido (ou que deveria ser não-entendido?) Aspecto da LINQ é IQueryable e prestadores de costume LINQ .

Eu tenho usado o LINQ por um tempo agora e estou completamente à vontade no mundo IEnumerable, e pode resolver a maioria dos problemas com o LINQ.

Mas quando eu comecei a olhar e ler sobre IQueryable e Expressões e provedores LINQ personalizada que fez minha cabeça girar. Dê uma olhada em como LINQ to SQL funciona se você quiser ver alguma lógica bastante complexa.

Estou ansioso para compreender esse aspecto de LINQ ...

Como a maioria das pessoas disse, eu acho que a parte mais incompreendida está assumindo LINQ é um apenas um substituto para T-SQL. Meu gerente que considera -se como um guru TSQL não vamos usar LINQ em nosso projeto e até mesmo odeia MS para liberar uma coisa dessas !!!

O que var representam quando uma consulta é executada?

É iQueryable, iSingleResult, iMultipleResult, ou ele mudar de acordo com a implementação. Há alguma especulação sobre o uso (o que parece ser) dynamic-digitação vs a estática-digitação padrão em C #.

Como é fácil de se aninhar um loop é algo que eu não acho que todo mundo entende.

Por exemplo:

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

group by ainda faz minha cabeça girar.

Qualquer confusão sobre adiada execução deve ser capaz de ser resolvido, percorrendo alguns código baseado em LINQ simples e brincar na janela do relógio.

Compilado consultas

O fato de que você não pode cadeia IQueryable porque são chamadas de método (enquanto ainda mais nada, mas translateable SQL!) E que é quase impossível trabalhar em torno dele é incompreensível e cria uma enorme violação do DRY. Eu preciso da minha IQueryable é para (consultas só tenho compilados para os cenários pesados) ad-hoc em que eu não tenha compilado consultas, mas em consultas compiladas eu não posso usá-los e, em vez precisa escrever sintaxe de consulta normal novamente. Agora eu estou fazendo as mesmas subconsultas em 2 lugares, precisa se lembrar de atualizar ambos, se algo muda, e assim por diante. Um pesadelo.

Eu acho que o # 1 equívoco sobre LINQ to SQL é que você ainda tem que saber SQL, a fim de fazer uso efetivo do mesmo.

Outra coisa mal entendido sobre Linq para Sql é que você ainda tem que reduzir a sua segurança banco de dados para o ponto do absurdo, a fim de fazê-lo funcionar.

Um terceiro ponto é que usando LINQ to SQL, juntamente com aulas dinâmicas (ou seja, a definição de classe é criada em tempo de execução) faz com que uma quantidade enorme de compilação just-in-time. Que pode absolutamente matar desempenho.

Lazy Loading.

Como mencionado, o carregamento lento e execução diferida

Como LINQ to Objects e LINQ para XML (IEnumerable) são diferentes de LINQ to SQL (IQueryable)

Como para construir um Data Access Layer, camada de negócios e camada de apresentação com LINQ em todas as camadas .... e um bom exemplo.

Como a maioria das pessoas disse, eu acho que a parte mais incompreendida está assumindo LINQ é um apenas um substituto para T-SQL. Meu gerente que se considera como um guru TSQL não vamos usar LINQ em nosso projeto e até mesmo odeia MS para liberar uma coisa dessas !!!

Transações (sem usar TransactionScope)

Licenciado em: CC-BY-SA com atribuição

Não afiliado a StackOverflow