Klauzula From (odwołanie w C#)
Wyrażenie kwerendy musi zaczynać się from klauzuli.Dodatkowo, wyrażeniu kwerendy mogą zawierać sub-queries, które również rozpoczynać od from klauzuli.from Klauzuli określa następujące elementy:
Źródło danych, na którym uruchomiona jest kwerenda lub podkwerendy.
Lokalnym Zakres zmiennej reprezentującym każdy element w sekwencji źródła.
Wpisywane są silnie zarówno zmienna zakres i źródła danych.Źródło danych, do których odwołuje się from klauzuli musi mieć typ IEnumerable, IEnumerable, albo typu pochodnego, takich jak IQueryable.
W poniższym przykładzie numbers jest źródłem danych i num jest zmienna zakresu.Należy zauważyć, że zarówno zmienne mają jednoznacznie określone typy nawet poprzez var. użyć słowa kluczowego.
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
Zakres zmiennej
Kompilator ustala typ zmiennej zakres, gdy źródło danych implementuje IEnumerable.Na przykład, jeżeli źródło ma określony typ IEnumerable<Customer>, a następnie zmiennej zakres jest niezamierzone za Customer.Tylko wtedy, że należy określić, kiedy jest wyraźnie typ źródła jest nie uniwersalne IEnumerable typu, takich jak ArrayList.Aby uzyskać więcej informacji, zobacz Porady: zapytanie w ArrayList za pomocą LINQ.
W poprzednim przykładzie num się ich doszukiwać się typ int.Ponieważ zmienna zakres ma jednoznacznie określony, można wywoływać metod lub używać go w innych operacji.Na przykład, zamiast pisania select num, można napisać select num.ToString() spowodować wyrażenie kwerendy przywrócić Sekwencja ciągów zamiast liczb całkowitych.Lub można napisać select n + 10 spowodować wyrażenie, które ma zwrócić sekwencji 14, 11, 13, 12, 10.Aby uzyskać więcej informacji, zobacz select — Klauzula (odwołanie w C#).
Zmienna zakres jest jak zmienna iteracji w foreach instrukcji, z wyjątkiem jednego bardzo istotna różnica: zmienna zakres nigdy faktycznie przechowuje dane ze źródła.To, które po prostu syntaktyczne wygody umożliwiający kwerendy do opisywania, co ma miejsce, gdy kwerenda jest wykonywana.Aby uzyskać więcej informacji, zobacz Wprowadzenie do kwerend LINQ (C#).
Mieszanki z klauzul
W niektórych przypadkach każdy element w sekwencji źródła może sam być albo sekwencję lub zawierać sekwencji.Na przykład źródło danych może być IEnumerable<Student> gdzie każdy obiekt student w sekwencji zawiera listę wyników testów.Do dostępu do wewnętrznej listy w ramach każdego Student element, można użyć mieszanek from klauzul.Technika ta jest tak, jak przy użyciu zagnieżdżone foreach instrukcji.Można dodać gdzie lub orderby klauzul albo from klauzuli filtrowania wyników.W poniższym przykładzie pokazano sekwencji Student obiektów, z których każdy zawiera wewnętrznym List liczb reprezentujących wyniki testu.Aby uzyskać dostęp do wewnętrznej listy, należy użyć związek from klauzuli.Można wstawić klauzul między tymi dwoma from klauzule, jeśli to konieczne.
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
*/
Przy użyciu wielu z klauzul Aby wykonać sprzężenia
Związek from klauzuli jest umożliwiające dostęp do wewnętrznej kolekcji w jedno źródło danych.Jednakże, kwerenda może również zawierać wiele from klauzul generujących dodatkowe kwerendy ze źródeł danych niezależnych.Ta technika umożliwia wykonywanie pewnych operacji sprzężenia, które nie są możliwe przy użyciu klauzuli join.
W poniższym przykładzie jak dwie from klauzul umożliwia pełne sprzężenie dwa źródła danych formularza.
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
*/
Aby uzyskać więcej informacji na temat operacji sprzężenia, które używają wielu from klauzule, zobacz Porady: wykonywanie niestandardowych operacji łączenia (Przewodnik programowania w języku C#).
Zobacz też
Koncepcje
Wyrażenia kwerend LINQ (Przewodnik programowania w języku C#)