(referência de C#) 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 subconsultas, que também começam com um from cláusula. O from cláusula Especifica o seguinte:
A fonte de dados em que a consulta ou sub-consulta deverá ser executada.
Local a variável de intervalo que representa cada elemento da seqüência de origem.
Tanto a variável de intervalo e a fonte de dados são fortemente tipadas. A fonte de dados referenciada no from cláusula deve ter um tipo de IEnumerable, IEnumerable<T>, ou um tipo derivado, como 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 fortemente tipadas mesmo por meio de 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 da variável de intervalo quando a fonte de dados implementa IEnumerable<T>. Por exemplo, se a fonte tem o tipo de IEnumerable<Customer>, em seguida, a variável de intervalo é inferida para ser Customer. O único momento em que você deve especificar explicitamente o tipo é quando a fonte é não genérico IEnumerable tipo como ArrayList. Para obter mais informações, consulte Como: Consultar um ArrayList com LINQ.
No exemplo anterior num é inferido para ser do tipo int. Porque a variável de intervalo tem rigidez de tipos, você pode chamar métodos nele ou usá-lo em outras operações. Por exemplo, em vez de escrever select num, você poderia escrever select num.ToString() para fazer com que a expressão de consulta retornar uma seqüê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 seqüência 14, 11, 13, 12, 10. Para obter mais informações, consulte (referência de C#) da cláusula Select.
A variável de intervalo é como uma variável de iteração em uma foreach instrução, exceto para uma diferença muito importante: uma variável de intervalo, na verdade, nunca armazena os dados da fonte. Ele apenas uma conveniência sintática que permite a consulta descrever o que ocorrerá quando a consulta é executada. Para obter mais informações, consulte Introdução às consultas do LINQ (C#).
Composto de cláusulas
Em alguns casos, cada elemento da seqüência de origem pode propriamente dito ser tanto uma seqüência ou conter uma seqüência. Por exemplo, a fonte de dados pode ser um IEnumerable<Student> onde cada objeto do aluno na seqüência contém uma lista de teste pontuações. Para acessar a lista interna de cada Student elemento, você pode usar compostos from cláusulas. A técnica é como usando aninhados foreach instruções. Você pode adicionar onde ou ClassificadoPor cláusulas para uma from cláusula para filtrar os resultados. O exemplo a seguir mostra uma seqüência de Student objetos, cada qual contendo uma interna List de inteiros que representam o teste pontuações. Para acessar a lista interna, 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:");
// Rest the mouse pointer on scoreQuery in the following line to
// see its type. The type is IEnumerable<'a>, where 'a is an
// anonymous type defined as new {string Last, int score}. That is,
// each instance of this anonymous type has two members, a string
// (Last) and an int (score).
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árias cláusulas from para realizar associações
Um composto from cláusula é usada para acessar as coleções internas em uma fonte de dados único. No entanto, uma consulta também pode conter vários from cláusulas que geram consultas complementares de fontes de dados independentes. Essa técnica permite que você execute a certos tipos de operações de associação que não são possíveis usando o cláusula join.
A exemplo a seguir mostra como dois from cláusulas podem ser usado para o formulário para associar-se uma cruz completa de fontes de dados de dois.
class CompoundFrom2
{
static void Main()
{
char[] upperCase = { 'A', 'B', 'C' };
char[] lowerCase = { 'x', 'y', 'z' };
// The type of joinQuery1 is IEnumerable<'a>, where 'a
// indicates an anonymous type. This anonymous type has two
// members, upper and lower, both of type char.
var joinQuery1 =
from upper in upperCase
from lower in lowerCase
select new { upper, lower };
// The type of joinQuery2 is IEnumerable<'a>, where 'a
// indicates an anonymous type. This anonymous type has two
// members, upper and lower, both of type char.
var joinQuery2 =
from lower in lowerCase
where lower != 'x'
from upper in upperCase
select new { lower, upper };
// Execute the queries.
Console.WriteLine("Cross join:");
// Rest the mouse pointer on joinQuery1 to verify its type.
foreach (var pair in joinQuery1)
{
Console.WriteLine("{0} is matched to {1}", pair.upper, pair.lower);
}
Console.WriteLine("Filtered non-equijoin:");
// Rest the mouse pointer over joinQuery2 to verify its type.
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 associação usar várias from cláusulas, consulte How to: Executar operações de associação de Personalizar (guia de programação de C#).
Consulte também
Conceitos
LINQ Expressões de consulta (guia de programação de C#)