(referência translation from VPE for Csharp) da cláusula FROM

Uma expressão de consulta deve começar com um from cláusula. Além disso, uma expressão de consulta pode conter sub-queries, que também começam com um from cláusula. The from cláusula Especifica o seguinte:

• A fonte de dados em que a consulta ou subconsulta será ser executada.

• Um local variável de intervalo que representa cada elemento da sequência de fonte.

A variável de intervalo e a fonte de dados fortemente tipados.A fonte de dados referenciada no from cláusula deve ter um tipo de IEnumerable, IEnumerable<T>, ou um tipo derivado, sistema autônomo IQueryable<T>.

No exemplo a seguir, numbers é a fonte de dados e num é a variável de intervalo. Observe que ambas as variáveis são altamente digitadas mesmo durante o var palavra-chave é usada.

class LowNums
{
    static void Main()
    {   
        // A simple data source.
        int[] numbers = { 5, 4, 1, 3, 9, 8, 6, 7, 2, 0 };

        // Create the query.
        // lowNums is an IEnumerable<int>
        var lowNums = from num in numbers
            where num < 5
            select num;

        // Execute the query.
        foreach (int i in lowNums)
        {
            Console.Write(i + " ");
        }
    }        
}
// Output: 4 1 3 2 0

A variável de intervalo

O compilador infere o tipo de variável de intervalo quando a fonte de dados implementa IEnumerable<T>. Por exemplo, se a fonte tem o tipo de IEnumerable<Customer>, e, em seguida, a variável de intervalo é inferida para ser Customer. A única time que você deve especificar explicitamente o tipo é quando fonte é um não-genéricas IEnumerable Digite sistema autônomo ArrayList. Para obter mais informações, consulte Como: Consultar um ArrayList com o LINQ.

No exemplo anterior num é inferido para ser do tipo int. Como a variável de intervalo tem rigidez de tipos, você pode telefonar métodos nele ou usá-la em outras operações.Por exemplo, em vez de escrever select num, você poderia gravar select num.ToString() Para fazer com que a expressão de consulta retornar uma sequência de cadeias de caracteres em vez de números inteiros. Ou você poderia escrever select n + 10 Para fazer com que a expressão retornar a sequência 14, 11, 13, 12, 10. Para obter mais informações, consulte selecionar cláusula (translation from VPE for Csharp Reference).

A variável de intervalo é como uma variável de iteração em um foreach demonstrativo, exceto para uma diferença muito importante: uma variável de intervalo, na verdade, nunca armazena dados da fonte.Ele apenas uma conveniência sintática permite que a consulta descrever o que ocorrerá quando a consulta é executada.Para obter mais informações, consulte Introdução às consultas do LINQ.

Composto de cláusulas

Em alguns casos, cada elemento da sequência de fonte pode propriamente dito ser em uma sequência ou conter uma sequência.Por exemplo, sua fonte de dados pode ser um IEnumerable<Student> em que cada objeto do aluno na sequência contém uma lista de resultados de teste. Para acesso lista interna de dentro de cada Student elemento, você pode usar composto from cláusulas. A técnica é como usar aninhados foreach instruções.Você pode adicionar onde or OrderBy cláusulas para qualquer um dos from cláusula para filtrar os resultados. O exemplo a seguir mostra uma sequência de Student objetos, cada uma delas conterá um interno List de inteiros que representam os resultados de teste. Para acesso interno lista, use um composto from cláusula. Você pode inserir cláusulas entre os dois from cláusulas se necessário.

class CompoundFrom
{
    // The element type of the data source.
    public class Student
    {
        public string LastName { get; set; }
        public List<int> Scores {get; set;}
    }

    static void Main()
    {

        // Use a collection initializer to create the data source. Note that 
        // each element in the list contains an inner sequence of scores.
        List<Student> students = new List<Student>
        {
           new Student {LastName="Omelchenko", Scores= new List<int> {97, 72, 81, 60}},
           new Student {LastName="O'Donnell", Scores= new List<int> {75, 84, 91, 39}},
           new Student {LastName="Mortensen", Scores= new List<int> {88, 94, 65, 85}},
           new Student {LastName="Garcia", Scores= new List<int> {97, 89, 85, 82}},
           new Student {LastName="Beebe", Scores= new List<int> {35, 72, 91, 70}} 
        };        

        // Use a compound from to access the inner sequence within each element.
        // Note the similarity to a nested foreach statement.
        var scoreQuery = from student in students
                         from score in student.Scores
                            where score > 90
                            select new { Last = student.LastName, score };

        // Execute the queries.
        Console.WriteLine("scoreQuery:");
        foreach (var student in scoreQuery)
        {
            Console.WriteLine("{0} Score: {1}", student.Last, student.score);
        }

        // Keep the console window open in debug mode.
        Console.WriteLine("Press any key to exit.");
        Console.ReadKey();
    }       
}
/*
scoreQuery:
Omelchenko Score: 97
O'Donnell Score: 91
Mortensen Score: 94
Garcia Score: 97
Beebe Score: 91
*/

Usando vários de cláusulas para executar associações

Um composto from cláusula é usada para acessar coleções internas em uma única fonte de dados. No entanto, uma consulta também pode conter vários from cláusulas gerar consultas complementares de fontes de dados independentes. Essa técnica permite a execução de determinados tipos de operações de unir que não são possíveis utilizando o cláusula de unir.

O exemplo a seguir mostra como dois from cláusulas podem ser usado unir em uma cruz completa da forma de duas fontes de dados.

class CompoundFrom2
{
    static void Main()
    {              
        char[] upperCase = { 'A', 'B', 'C'};
        char[] lowerCase = { 'x', 'y', 'z'};

        var joinQuery1 =
            from upper in upperCase
            from lower in lowerCase
                select new { upper, lower};

        var joinQuery2 =
            from lower in lowerCase
            where lower != 'x'
            from upper in upperCase
            select new { lower, upper };


        // Execute the queries.
        Console.WriteLine("Cross join:");
        foreach (var pair in joinQuery1)
        {
            Console.WriteLine("{0} is matched to {1}", pair.upper, pair.lower);
        }

        Console.WriteLine("Filtered non-equijoin:");
        foreach (var pair in joinQuery2)
        {
            Console.WriteLine("{0} is matched to {1}", pair.lower, pair.upper);
        }

        // Keep the console window open in debug mode.
        Console.WriteLine("Press any key to exit.");
        Console.ReadKey();
    }
}
/* Output:
        Cross join:
        A is matched to x
        A is matched to y
        A is matched to z
        B is matched to x
        B is matched to y
        B is matched to z
        C is matched to x
        C is matched to y
        C is matched to z
        Filtered non-equijoin:
        y is matched to A
        y is matched to B
        y is matched to C
        z is matched to A
        z is matched to B
        z is matched to C
        */

Para obter mais informações sobre as operações de unir que usam vários from cláusulas, consulte Como: Executar operações de unir personalizada (guia de programação translation from VPE for Csharp).

Consulte também

Conceitos

Expressões de consulta do LINQ (guia de programação translation from VPE for Csharp)

Outros recursos

Palavras-chave de consulta (translation from VPE for Csharp Reference)