from tümcesi (C# Başvurusu)from clause (C# Reference)

Sorgu ifadesi ile başlamalıdır bir from yan tümcesi.A query expression must begin with a from clause. Ayrıca, bir sorgu ifadesi de şununla alt sorgularda içerebilir bir from yan tümcesi.Additionally, a query expression can contain sub-queries, which also begin with a from clause. from Yan tümcesi şunları belirtir:The from clause specifies the following:

  • Veri kaynağı üzerinde sorgu veya alt sorgu çalıştırılır.The data source on which the query or sub-query will be run.

  • Yerel bir aralık değişkeni , kaynak dizideki her öğe temsil eder.A local range variable that represents each element in the source sequence.

Veri kaynağı ve aralık değişkeni kesin türlü yapılır.Both the range variable and the data source are strongly typed. Başvurulan veri kaynağı from yan tümcesi, bir tür olmalıdır IEnumerable, IEnumerable<T>, veya türetilmiş bir tür gibi IQueryable<T>.The data source referenced in the from clause must have a type of IEnumerable, IEnumerable<T>, or a derived type such as IQueryable<T>.

Aşağıdaki örnekte, numbers veri kaynağıdır ve num aralık değişkeni.In the following example, numbers is the data source and num is the range variable. Her iki değişken olsa bile kesin olarak belirlenmiştir, Not var anahtar sözcüğü kullanılır.Note that both variables are strongly typed even though the var keyword is used.

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

Aralık değişkeniThe range variable

Veri kaynağı uygular, derleyici Aralık değişkeninin türünü çıkarsar IEnumerable<T>.The compiler infers the type of the range variable when the data source implements IEnumerable<T>. Örneğin, kaynak türü varsa IEnumerable<Customer>, aralık değişkeni olması sorguluyorsanız Customer.For example, if the source has a type of IEnumerable<Customer>, then the range variable is inferred to be Customer. Açıkça türüdür ne zaman belirtmelisiniz. yalnızca bir kez kaynağı olan genel olmayan IEnumerable gibi yazın ArrayList.The only time that you must specify the type explicitly is when the source is a non-generic IEnumerable type such as ArrayList. Daha fazla bilgi için nasıl yapılır: LINQ ile ArrayList sorgulama.For more information, see How to: Query an ArrayList with LINQ.

Önceki örnekte num türünde olmasını çıkarılan int.In the previous example num is inferred to be of type int. Aralık değişkeninin türü kesin olarak belirtilmiş olduğundan üzerinde yöntemleri çağırmak ya da diğer işlemleri kullanın.Because the range variable is strongly typed, you can call methods on it or use it in other operations. Örneğin, yazmak yerine select num, şunu yazabilirsiniz select num.ToString() dize yerine tamsayı bir dizisini döndürmek sorgu ifadesi neden olacak.For example, instead of writing select num, you could write select num.ToString() to cause the query expression to return a sequence of strings instead of integers. Veya şunu yazabilirsiniz select num + 10 14 dizisini döndürmek için ifadeyi neden 11, 13, 12, 10.Or you could write select num + 10 to cause the expression to return the sequence 14, 11, 13, 12, 10. Daha fazla bilgi için select yan tümcesi.For more information, see select clause.

Bir yineleme değişkeni aralık değişkeni benzer bir foreach çok önemli bir fark dışında deyimi: bir aralık değişkenine asla gerçekten kaynaktan gelen verileri depolar.The range variable is like an iteration variable in a foreach statement except for one very important difference: a range variable never actually stores data from the source. Yalnızca bir sorgu çalıştırıldığında ne olacağını açıklamak sorgu sağlar söz dizimsel kolaylık bir özelliktir.It's just a syntactic convenience that enables the query to describe what will occur when the query is executed. Daha fazla bilgi için (C#) LINQ sorgularına giriş.For more information, see Introduction to LINQ Queries (C#).

Bileşik yan tümcelerindenCompound from clauses

Bazı durumlarda, kaynak dizideki her öğe kendisi ya da bir dizi veya bir dizisini içerir.In some cases, each element in the source sequence may itself be either a sequence or contain a sequence. Örneğin, veri kaynağınızın olabilir bir IEnumerable<Student> burada dizideki her Öğrenci nesne içeren test puanlarını listesi.For example, your data source may be an IEnumerable<Student> where each student object in the sequence contains a list of test scores. Her iç listesine erişmek için Student öğesi bileşik kullanabilirsiniz from yan tümceleri.To access the inner list within each Student element, you can use compound from clauses. Kullanarak içe gibi tekniktir foreach deyimleri.The technique is like using nested foreach statements. Ekleyebileceğiniz burada veya orderby ya da yan tümceleri from sonuçları filtrelemek için yan tümcesi.You can add where or orderby clauses to either from clause to filter the results. Aşağıdaki örnek, bir dizi gösterir Student her biri içeren bir iç nesneler List tamsayılar temsil eden test puanlarını.The following example shows a sequence of Student objects, each of which contains an inner List of integers representing test scores. İç listesine erişmek için bileşik kullanın from yan tümcesi.To access the inner list, use a compound from clause. İkisi arasındaki yan tümce ekleyebilirsiniz from yan tümceleri gerekirse.You can insert clauses between the two from clauses if necessary.

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
*/

Birleştirmeler gerçekleştirme için birden çok yan tümceleri'den kullanmaUsing Multiple from Clauses to Perform Joins

Bileşik from yan tümcesi, tek bir veri kaynağındaki iç koleksiyonlara erişmek için kullanılır.A compound from clause is used to access inner collections in a single data source. Ancak, bir sorgu birden çok de içerebilir from yan tümceleri bağımsız veri kaynaklarından ek sorgular oluşturun.However, a query can also contain multiple from clauses that generate supplemental queries from independent data sources. Belirli türlerini kullanarak mümkün olmayan birleştirme işlemleri gerçekleştirmek Bu teknik sayesinde JOIN yan tümcesi.This technique enables you to perform certain types of join operations that are not possible by using the join clause.

Aşağıdaki örnekte gösterildiği nasıl iki from yan tümceleri, iki veri kaynaklarının tam çapraz birleştirme oluşturmak için kullanılabilir.The following example shows how two from clauses can be used to form a complete cross join of two data sources.

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
        */

Birden çok kullanan birleştirme işlemleri hakkında daha fazla bilgi için from yan tümcesi bkz sol dış birleştirmeler gerçekleştirme.For more information about join operations that use multiple from clauses, see Perform left outer joins.

Ayrıca bkz.See also