Antecedentes: No próximo mês, darei três palestras sobre ou pelo menos incluir LINQno contexto de C#. Gostaria de saber em quais tópicos vale a pena prestar bastante atenção, com base no que as pessoas podem achar difícil de entender ou no que elas podem ter uma impressão errada. Eu não vou ser especificamente falando sobre LINQa SQLou 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 LINQ? O que você viu em termos de mal-entendidos? Os exemplos podem ser os seguintes, mas não se limite!

• Como o C#compilador trata expressões de consulta
• Expressões lambda
• Árvores de expressão
• Métodos de extensão
• Tipos anônimos
• IQueryable
• Adiado versus execução imediata
• Streaming vs execução em buffer (por exemplo, OrderBy é adiado, mas em buffer)
• Variáveis ​​locais implicitamente digitadas
• Lendo assinaturas genéricas complexas (por exemplo, Enumerable.Join )

Execução atrasada

Sei que o conceito de execução adiada deve estar sendo adotado até agora, mas este exemplo realmente me ajudou a entender o conceito:

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

O código acima retorna o seguinte:

Before add:
Bob
Alice
Trent

After add:
Bob
Alice
Trent
Mallory

Que há mais do que apenas LINQpara SQLe os recursos são mais do que apenas um SQLanalisador incorporado na língua.

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

Eu acho que o fato de uma Lambdaexpressão poder resolver tanto para uma árvore de expressão quanto para um delegado anônimo, para que você possa passar a mesma lambdaexpressão declarativa para os IEnumerable<T>métodos de IQueryable<T>extensão e de extensão.

Me levou maneira muito tempo para perceber que muitos métodos de extensão LINQ, tais 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 algum tutorial ruim me deu o hábito de fazer

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

No LINQ to SQL, vejo constantemente pessoas que não entendem o DataContext, como ele pode ser usado e como deve ser usado. Muitas pessoas não veem o DataContext como um objeto de Unidade de Trabalho, não um objeto persistente.

Eu já vi muitas vezes em que as pessoas estão tentando escolher um DataContext / sessão / etc, em vez de criar um novo horário para cada operação.

E há o descarte do DataContext antes que o IQueryable seja avaliado, mas isso é mais propício para as pessoas que não entendem o IQueryable do que o DataContext.

O outro conceito com o qual vejo muita confusão é a sintaxe de consulta versus a sintaxe de expressão. Usarei o que for mais fácil nesse ponto, geralmente mantendo a Expressão Sintaxe. Muitas pessoas ainda não percebem que produzirão a mesma coisa no final, afinal, o Query é compilado no Expression.

Eu acho que a parte incompreendida do LINQ é que é uma extensão de linguagem , não uma extensão ou construção de banco de dados.

LINQé muito mais que isso LINQ to SQL.

Agora que a maioria de nós já usou LINQcoleções, NUNCA voltaremos!

LINQ é o recurso mais significativo para o .NET desde Generics no 2.0 e Anonymous Types no 3.0.

E agora que temos o Lambda, mal posso esperar pela programação paralela!

Eu, com certeza, gostaria de saber se preciso saber o que são árvores de expressão e por quê.

Eu sou bastante novo no LINQ. Aqui estão as coisas que eu tropecei na minha primeira tentativa

• Combinando várias consultas em um
• Depurando efetivamente as consultas LINQ no Visual Studio.

Algo que eu não percebi originalmente era que a sintaxe do LINQ não requer IEnumerable<T>ou IQueryable<T>funciona, o LINQ é apenas sobre correspondência de padrões.

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

Aqui está a resposta (não, eu não escrevi esse blog, Bart De Smet, e ele é um dos melhores blogueiros do LINQ que eu encontrei).

Eu ainda tenho problemas com o comando "let" (que eu nunca encontrei um uso) e SelectMany (que eu usei, mas não tenho certeza se fiz direito)

Entendendo quando a abstração entre os provedores do Linq vaza. Algumas coisas funcionam em objetos, mas não em SQL (por exemplo, .TakeWhile). Alguns métodos podem ser traduzidos para SQL (ToUpper), enquanto outros não. Algumas técnicas são mais eficientes em objetos, enquanto outras são mais eficazes em SQL (diferentes métodos de junção).

Algumas coisas.

1. Pessoas pensando em Linq como Linq to SQL.
2. Algumas pessoas pensam que podem começar a substituir todos os foreach / logic por consultas Linq sem considerar essas implicações de desempenho.

OK, devido à demanda, escrevi algumas das coisas da Expressão. Não estou 100% satisfeito com a forma como o blogueiro e o LiveWriter conspiraram para formatá-lo, mas o resultado será por enquanto ...

Enfim, aqui vai ... Eu adoraria qualquer feedback, especialmente se houver áreas em que as pessoas querem mais informações.

Aqui está , goste ou odeie ...

Algumas das mensagens de erro, especialmente de LINQ para SQL, podem ser bastante confusas. sorrir

Fui mordido pela execução adiada algumas vezes, como todo mundo. Acho que a coisa mais confusa para mim foi o Provedor de Consultas do SQL Server e o que você pode ou não fazer com ele.

Ainda estou impressionado com o fato de que você não pode fazer um Sum () em uma coluna decimal / dinheiro que às vezes está vazia. Usar DefaultIfEmpty () simplesmente não funcionará. :(

Penso que uma grande coisa a ser abordada no LINQ é como você pode ter problemas em termos de desempenho. Por exemplo, usar a contagem de LINQ como uma condição de loop não é muito, muito inteligente.

Que o IQueryable aceite os dois Expression<Func<T1, T2, T3, ...>>e Func<T1, T2, T3, ...>, sem dar uma dica sobre a degradação do desempenho no segundo caso.

Aqui está um 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);
}

Não sei se qualifica como incompreendido - mas para mim, simplesmente desconhecido.

Fiquei satisfeito em saber sobre o DataLoadOptions e como posso controlar quais tabelas são unidas quando faço uma consulta específica.

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

Eu diria que o aspecto mais mal compreendido (ou não deve ser entendido?) Do LINQ é o IQueryable e os provedores LINQ personalizados .

Estou usando o LINQ há algum tempo e estou completamente confortável no mundo IEnumerable, e posso resolver a maioria dos problemas com o LINQ.

Mas, quando comecei a ler e ler sobre o IQueryable, o Expressions e os fornecedores de linq personalizados, isso fez minha cabeça girar. Veja como o LINQ to SQL funciona, se você quiser ver uma lógica bastante complexa.

Estou ansioso para entender esse aspecto do LINQ ...

Como a maioria das pessoas disse, acho que a parte mais incompreendida é assumir que o LINQ é apenas um substituto para o T-SQL. Meu gerente, que se considera um guru do TSQL, não nos deixou usar o LINQ em nosso projeto e até odeia o MS por lançar algo assim !!!

O que var representa quando uma consulta é executada?

É iQueryable, iSingleResult, iMultipleResult, ou fá-lo mudar de acordo com a implementação. Há alguma especulação sobre o uso (o que parece ser) de digitação dinâmica versus digitação estática padrão em C #.

Como é fácil aninhar um loop é algo que eu não acho que todos entendam.

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 execução adiada deve poder ser resolvida percorrendo algum código simples baseado em LINQ e brincando na janela de inspeção.

Consultas compiladas

O fato de você não poder encadear IQueryableporque são chamadas de método (embora ainda nada mais seja traduzível para SQL!) E que é quase impossível contornar isso é incompreensível e cria uma enorme violação do DRY. Eu preciso do meu IQueryablepara ad-hoc, no qual não tenho consultas compiladas (só tenho consultas compiladas para cenários pesados), mas nas consultas compiladas não posso usá-las e, em vez disso, preciso escrever a sintaxe regular novamente. Agora estou fazendo as mesmas subconsultas em 2 lugares, preciso lembrar de atualizar ambos se algo mudar, e assim por diante. Um pesadelo.

Eu acho que o equívoco número 1 sobre o LINQ to SQL é que você AINDA TEM DE CONHECER o SQL para fazer uso efetivo dele.

Outra coisa incompreendida sobre o Linq to Sql é que você ainda precisa reduzir a segurança do banco de dados ao ponto de absurdo para fazê-lo funcionar.

Um terceiro ponto é que o uso de Linq para Sql junto com classes dinâmicas (significando que a definição de classe é criada em tempo de execução) causa uma quantidade enorme de compilação just-in-time. O que pode absolutamente matar o desempenho.

Carregamento lento.

Como mencionado, carregamento lento e execução adiada

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

COMO criar uma camada de acesso a dados, 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, acho que a parte mais incompreendida é assumir que o LINQ é apenas um substituto para o T-SQL. Meu gerente, que se considera um guru do TSQL, não nos deixou usar o LINQ em nosso projeto e até odeia o MS por lançar uma coisa dessas !!!

Transações (sem usar o TransactionScope)