Compartilhar via

Recursos do C# que dão suporte a 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> . Durante o tempo de compilação, o compilador converte a sintaxe de consulta em chamadas de método para a implementação dos métodos padrão de consulta de um provedor LINQ. Os aplicativos controlam os operadores de consulta padrão que estão no escopo, especificando o namespace apropriado com 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 na 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 você especifica explicitamente. O uso var possibilita a criação de tipos anônimos, mas apenas para variáveis locais. Para obter mais informações, consulte Variáveis locais de tipo implícito.

Inicializadores de objeto e coleção

Inicializadores de objeto e coleção possibilitam inicializar objetos sem chamar explicitamente um construtor para o objeto. Normalmente, você usa inicializadores em expressões de consulta quando eles projetam os dados de origem em um novo tipo de dados. Supondo que uma classe chamada Customer com Name e Phone propriedades públicas, você pode usar o inicializador de objeto no seguinte código:

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

Continuando com sua Customer classe, suponha que haja uma fonte de dados chamada IncomingOrders, e que para cada pedido com um grande OrderSize, você deseja criar um novo Customer com base nessa ordem. Você pode executar uma consulta LINQ nesta fonte de dados e usar a inicialização de objeto 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 classe Customer, mas com a inicialização do objeto, os dados retornados da consulta são convertidos no tipo de dados desejado, permitindo que você selecione os dados relevantes para sua classe. Como resultado, agora você tem um System.Collections.Generic.IEnumerable<T> preenchido com os novos Customers que você queria. Você também pode escrever o exemplo anterior na sintaxe do método 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. Somente o compilador pode acessar o 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. Você inicializa tipos anônimos com uma nova expressão e um inicializador de objeto, conforme 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 de extensão

Um membro de extensão é um membro estático de uma classe estática associada a um tipo chamado de tipo receptor. Você pode chamar um membro de extensão como se fosse um membro do tipo receptor. Esse recurso permite que você "adicione" novos membros aos tipos existentes sem realmente modificá-los. 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 usa o operador => para separar os parâmetros de entrada do corpo da função, e pode ser convertida em tempo de compilação em um delegado ou em uma árvore de expressão. Na programação LINQ, você encontra expressões lambda ao fazer chamadas de método direto para os operadores de consulta padrão.

Expressões como dados

Os objetos de consulta são componíveis, o que significa que podem ser retornados a partir 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 retornar objetos de consulta de métodos é que você pode redigir ou modificá-los ainda mais. Portanto, qualquer valor ou out parâmetro retornado de um método que retorna uma consulta também deve ter esse tipo. Se um método materializa uma consulta em um tipo concreto List<T> ou Array, ele retornará os resultados da consulta em vez da consulta em si. Você ainda pode redigir ou modificar uma variável de consulta retornada de um método.

No exemplo a seguir, o primeiro método QueryMethod1 retorna uma consulta como um valor retornado e o segundo método QueryMethod2 retorna uma consulta como um out parâmetro (returnQ no exemplo). Em ambos os casos, é uma consulta retornada, não os resultados da 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 loop a seguir foreach executa a consulta myQuery1.

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

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

Você também pode executar a consulta retornada QueryMethod1 diretamente, sem usar myQuery1.

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

Coloque o ponteiro do mouse sobre a chamada a QueryMethod1 para ver o 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 de 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