Partilhar via

Recursos do C# que suportam LINQ

Expressões de consulta

As expressões de consulta usam uma sintaxe declarativa semelhante a SQL ou XQuery para consultar coleções System.Collections.Generic.IEnumerable<T> . No momento da compilação, o compilador converte a sintaxe da consulta em chamadas de método para a implementação dos métodos padrão de consulta por um fornecedor LINQ. As aplicações controlam os operadores de consulta padrão que estão no escopo especificando o namespace apropriado por meio de uma diretiva using. A expressão de consulta a seguir usa uma matriz de cadeias de caracteres, agrupa-as de acordo com o primeiro caractere da cadeia de caracteres e ordena os grupos.

var query = from str in stringArray
            group str by str[0] into stringGroup
            orderby stringGroup.Key
            select stringGroup;

Variáveis tipadas implicitamente (var)

Você pode usar o modificador var para instruir o compilador a inferir e atribuir o tipo, conforme mostrado aqui:

var number = 5;
var name = "Virginia";
var query = from str in stringArray
            where str[0] == 'm'
            select str;

Variáveis declaradas como var são fortemente tipadas, assim como variáveis cujo tipo é especificado explicitamente. O uso var permite criar tipos anónimos, mas apenas para variáveis locais. Para obter mais informações, consulte Variáveis locais digitadas implicitamente.

Inicializadores de objetos e coleções

Os inicializadores de objeto e coleção tornam possível inicializar objetos sem chamar explicitamente um construtor para o objeto. Normalmente usas inicializadores nas expressões de consulta quando projetam os dados de origem para um novo tipo de dado. Assumindo uma classe nomeada Customer com public Name e Phone properties, pode usar o inicializador de objetos conforme o seguinte código:

var cust = new Customer { Name = "Mike", Phone = "555-1212" };

Continuando com a sua Customer classe, assuma que existe uma fonte de dados chamada IncomingOrders, e que para cada pedido com um grande OrderSize, quer criar um novo Customer com base nesse pedido. Pode executar uma consulta LINQ nesta fonte de dados e usar a inicialização de objetos para preencher uma coleção:

var newLargeOrderCustomers = from o in IncomingOrders
                            where o.OrderSize > 5
                            select new Customer { Name = o.Name, Phone = o.Phone };

A fonte de dados pode ter mais propriedades definidas do que a Customer classe, como OrderSize, mas com a inicialização do objeto, os dados devolvidos da consulta são moldados no tipo de dado desejado; escolhes os dados relevantes para a tua classe. Como resultado, agora você tem um System.Collections.Generic.IEnumerable<T> preenchido com os novos Customers que você queria. Também pode escrever o exemplo anterior na sintaxe do método do LINQ:

var newLargeOrderCustomers = IncomingOrders.Where(x => x.OrderSize > 5).Select(y => new Customer { Name = y.Name, Phone = y.Phone });

A partir do C# 12, você pode usar uma expressão de coleção para inicializar uma coleção.

Para obter mais informações, consulte:

Tipos anónimos

O compilador constrói um tipo anônimo. Só o compilador pode aceder ao nome do tipo. Os tipos anônimos fornecem uma maneira conveniente de agrupar um conjunto de propriedades temporariamente em um resultado de consulta sem precisar definir um tipo nomeado separado. Inicializa tipos anónimos com uma nova expressão e um inicializador de objetos, como mostrado aqui:

select new {name = cust.Name, phone = cust.Phone};

A partir do C# 7, você pode usar tuplas para criar tipos sem nome.

Membros da Extensão

Um membro de extensão é um membro estático de uma classe estática associada a um tipo chamado tipo receptor. Pode invocar um membro da extensão como se fosse um membro do tipo receptor. Esta funcionalidade permite-lhe "adicionar" novos membros a tipos existentes sem realmente os modificar. Os operadores de consulta padrão são um conjunto de métodos de extensão que fornecem funcionalidade de consulta LINQ para qualquer tipo que implemente IEnumerable<T>.

Expressões lambda

Uma expressão lambda é uma função inline que utiliza o => operador para separar parâmetros de entrada do corpo da função e pode ser convertida em tempo de compilação para um delegado ou uma árvore de expressões. Na programação LINQ, você encontra expressões lambda quando faz chamadas diretas de método para os operadores de consulta padrão.

Expressões como dados

Os objetos de consulta são compostáveis, o que significa que você pode retornar uma consulta de um método. Os objetos que representam consultas não armazenam a coleção resultante, mas sim as etapas para produzir os resultados quando necessário. A vantagem de devolver objetos de consulta a partir de métodos é que pode compô-los ou modificá-los ainda mais. Portanto, qualquer valor de retorno ou out parâmetro de um método que devolve uma consulta deve também ter esse tipo. Se um método materializa uma consulta em um concreto List<T> ou Array tipo, ele retorna os resultados da consulta em vez da própria consulta. Ainda podes compor ou modificar uma variável de consulta que é devolvida por um método.

No exemplo a seguir, o primeiro método QueryMethod1 retorna uma consulta como um valor de retorno e o segundo método QueryMethod2 retorna uma consulta como um out parâmetro (returnQ no exemplo). Em ambos os casos, é uma consulta que é devolvida, não resultados de consulta.

IEnumerable<string> QueryMethod1(int[] ints) =>
    from i in ints
    where i > 4
    select i.ToString();

void QueryMethod2(int[] ints, out IEnumerable<string> returnQ) =>
    returnQ = from i in ints
              where i < 4
              select i.ToString();

int[] nums = [ 0, 1, 2, 3, 4, 5, 6, 7, 8, 9 ];

var myQuery1 = QueryMethod1(nums);

O ciclo seguinte foreach executa a consulta myQuery1.

foreach (var s in myQuery1)
{
    Console.WriteLine(s);
}

Coloque o ponteiro do rato sobre myQuery1 para ver o seu tipo.

Também pode executar a consulta devolvida do QueryMethod1 diretamente, sem usar myQuery1.

foreach (var s in QueryMethod1(nums))
{
    Console.WriteLine(s);
}

Coloque o ponteiro do rato sobre a chamada para QueryMethod1 ver o seu tipo de retorno.

QueryMethod2 Retorna uma consulta como o valor de seu out parâmetro:

QueryMethod2(nums, out IEnumerable<string> myQuery2);

// Execute the returned query.
foreach (var s in myQuery2)
{
    Console.WriteLine(s);
}

Você pode modificar uma consulta usando a composição da consulta. Nesse caso, o objeto de consulta anterior é usado para criar um novo objeto de consulta. Esse novo objeto retorna resultados diferentes do objeto de consulta original.

myQuery1 = from item in myQuery1
           orderby item descending
           select item;

// Execute the modified query.
Console.WriteLine("\nResults of executing modified myQuery1:");
foreach (var s in myQuery1)
{
    Console.WriteLine(s);
}
  • Last updated on