Öğretici: Dil tümleşik sorgusunu (LINQ) kullanarak C# dilinde sorgu yazma

Bu öğreticide bir veri kaynağı oluşturacak ve birkaç LINQ sorgusu yazacaksınız. Sorgu ifadeleriyle denemeler yapabilir ve sonuçlardaki farkları görebilirsiniz. Bu kılavuzda LINQ sorgu ifadelerini yazmak için kullanılan C# dil özellikleri gösterilmektedir. Uygulamayı takip edebilir, oluşturabilir ve sorgularla kendiniz denemeler yapabilirsiniz. Bu makalede en son .NET SDK'sını yüklediğiniz varsayılır. Aksi takdirde .NET İndirmeleri sayfasına gidin ve makinenize en son sürümü yükleyin.

İlk olarak uygulamayı oluşturun. Konsoldan aşağıdaki komutu yazın:

dotnet new console -o WalkthroughWritingLinqQueries

Veya Visual Studio'yu tercih ediyorsanız WalkthroughWritingLinqQueries adlı yeni bir konsol uygulaması oluşturun.

Bellek içi veri kaynağı oluşturma

İlk adım, sorgularınız için bir veri kaynağı oluşturmaktır. Sorguların veri kaynağı, kayıtların Student basit bir listesidir. Her Student kaydın bir adı, aile adı ve sınıftaki test puanlarını temsil eden bir tamsayı dizisi vardır. students.cs adlı yeni bir dosya ekleyin ve aşağıdaki kodu bu dosyaya kopyalayın:

namespace WalkthroughWritingLinqQueries;

public record Student(string First, string Last, int ID, int[] Scores);

Aşağıdaki özelliklere dikkat edin:

• Kayıt Student , otomatik olarak uygulanan özelliklerden oluşur.
• Listedeki her öğrenci birincil oluşturucuyla başlatılır.
• Her öğrenci için puanların sırası birincil oluşturucuyla başlatılır.

Ardından, bu sorgunun Student kaynağı olarak hizmet veren bir kayıt dizisi oluşturun. Program.cs açın ve aşağıdaki ortak kodu kaldırın:

// See https://aka.ms/new-console-template for more information
Console.WriteLine("Hello, World!");

Bunu, bir kayıt dizisi Student oluşturan aşağıdaki kodla değiştirin:

using WalkthroughWritingLinqQueries;

// Create a data source by using a collection initializer.
IEnumerable<Student> students =
[
    new Student(First: "Svetlana", Last: "Omelchenko", ID: 111, Scores: [97, 92, 81, 60]),
    new Student(First: "Claire",   Last: "O'Donnell",  ID: 112, Scores: [75, 84, 91, 39]),
    new Student(First: "Sven",     Last: "Mortensen",  ID: 113, Scores: [88, 94, 65, 91]),
    new Student(First: "Cesar",    Last: "Garcia",     ID: 114, Scores: [97, 89, 85, 82]),
    new Student(First: "Debra",    Last: "Garcia",     ID: 115, Scores: [35, 72, 91, 70]),
    new Student(First: "Fadi",     Last: "Fakhouri",   ID: 116, Scores: [99, 86, 90, 94]),
    new Student(First: "Hanying",  Last: "Feng",       ID: 117, Scores: [93, 92, 80, 87]),
    new Student(First: "Hugo",     Last: "Garcia",     ID: 118, Scores: [92, 90, 83, 78]),

    new Student("Lance",   "Tucker",      119, [68, 79, 88, 92]),
    new Student("Terry",   "Adams",       120, [99, 82, 81, 79]),
    new Student("Eugene",  "Zabokritski", 121, [96, 85, 91, 60]),
    new Student("Michael", "Tucker",      122, [94, 92, 91, 91])
];

• Öğrenci dizisi bir koleksiyon ifadesiyle başlatılır.
• Kayıt Student türü tüm öğrencilerin statik listesini tutar.
• Oluşturucu çağrılarından bazıları , hangi bağımsız değişkenin hangi oluşturucu parametresiyle eşleşip eşleşmediği netleştirmek için adlandırılmış bağımsız değişkenler kullanır.

Şu ana kadar kod hakkında daha fazla bilgi edinmek için öğrenci listesine farklı test puanlarına sahip birkaç öğrenci daha eklemeyi deneyin.

Sorguyu oluşturma

Ardından, ilk sorgunuzu oluşturursunuz. Sorgunuzu yürüttüğünüzde, ilk testte puanı 90'dan büyük olan tüm öğrencilerin bir listesini oluşturur. Nesnenin tamamı Student seçili olduğundan, sorgunun türü şeklindedir IEnumerable<Student>. Kod , var anahtar sözcüğünü kullanarak örtük yazma özelliğini de kullanabilse de, sonuçları açıkça göstermek için açık yazma kullanılır. (hakkında vardaha fazla bilgi için bkz. Örtük Olarak Yazılan Yerel Değişkenler.) Öğrencilerin sırasını oluşturan koddan sonra aşağıdaki kodu Program.cs ekleyin:

// Create the query.
// The first line could also be written as "var studentQuery ="
IEnumerable<Student> studentQuery =
    from student in students
    where student.Scores[0] > 90
    select student;

Sorgunun aralık değişkeni olan student, kaynaktaki her Student birine başvuru görevi görür ve her nesne için üye erişimi sağlar.

Sorguyu çalıştır

Şimdi sorgunun çalışmasını sağlayacak döngüyü yazın. Döndürülen dizideki her öğeye döngüdeki yineleme değişkeni foreach aracılığıyla erişilir. Bu değişkenin türü ve Studentsorgu değişkeninin türü uyumludur. IEnumerable<Student> Aşağıdaki kodu ekledikten sonra konsol penceresinde sonuçları görmek için uygulamayı derleyin ve çalıştırın.

// Execute the query.
// var could be used here also.
foreach (Student student in studentQuery)
{
    Console.WriteLine($"{student.Last}, {student.First}");
}

// Output:
// Omelchenko, Svetlana
// Garcia, Cesar
// Fakhouri, Fadi
// Feng, Hanying
// Garcia, Hugo
// Adams, Terry
// Zabokritski, Eugene
// Tucker, Michael

Sorguyu daha da iyileştirmek için, where klozunda birden çok Boole koşulunu birleştirebilirsiniz. Aşağıdaki kod, sorgunun ilk puanı 90'ın üzerinde ve son puanı 80'in altında olan öğrencileri döndürmesi için bir koşul ekler. yan tümcesi where aşağıdaki koda benzemelidir.

where student.Scores[0] > 90 && student.Scores[3] < 80  

Önceki where yan tümceyi deneyin veya farklı filtre koşullarıyla kendiniz deney yapın. Daha fazla bilgi için. madde koşullarına bkz: .

Sorgu sonuçlarını sıralama

Bir düzende olmaları durumunda sonuçları taramak daha kolaydır. Döndürülen sırayı kaynak öğelerdeki herhangi bir erişilebilir alana göre sıralayabilirsiniz. Örneğin, aşağıdaki orderby yan tümcesi sonuçları her öğrencinin aile adına göre alfabetik olarak A'dan Z'ye sıralar. Sorgunuza aşağıdaki orderby yan tümceyi, where deyiminden hemen sonra ve select deyiminden önce ekleyin:

orderby student.Last ascending

Şimdi yan tümcesini orderby değiştirerek sonuçları ilk testteki puana göre ters sırada sıralayın ve en yüksek puandan en düşük puana geçin.

orderby student.Scores[0] descending

WriteLine Puanları görebilmek için biçim dizesini değiştirin:

Console.WriteLine($"{student.Last}, {student.First} {student.Scores[0]}");

Daha fazla bilgi için bkz. "orderby" yan tümcesi.

Sonuçları gruplandırma

Gruplandırma, sorgu ifadelerinde güçlü bir özelliktir. Grup yan tümcesine sahip bir sorgu bir grup dizisi oluşturur ve her grubun kendisi, o grubun tüm üyelerinden oluşan bir Key ve dizisi içerir. Aşağıdaki yeni sorgu, öğrencileri anahtar olarak aile adlarının ilk harfini kullanarak gruplandırma yapar.

IEnumerable<IGrouping<char, Student>> studentQuery =
    from student in students
    group student by student.Last[0];

Sorgunun türü değişti. Artık anahtar türüne ve nesne dizisine sahip char bir grup dizisi Student oluşturur. Yürütme döngüsündeki kodun foreach da değişmesi gerekir:

foreach (IGrouping<char, Student> studentGroup in studentQuery)
{
    Console.WriteLine(studentGroup.Key);
    foreach (Student student in studentGroup)
    {
        Console.WriteLine($"   {student.Last}, {student.First}");
    }
}
// Output:
// O
//   Omelchenko, Svetlana
//   O'Donnell, Claire
// M
//   Mortensen, Sven
// G
//   Garcia, Cesar
//   Garcia, Debra
//   Garcia, Hugo
// F
//   Fakhouri, Fadi
//   Feng, Hanying
// T
//   Tucker, Lance
//   Tucker, Michael
// A
//   Adams, Terry
// Z
//   Zabokritski, Eugene

Uygulamayı çalıştırın ve konsol penceresinde sonuçları görüntüleyin. Daha fazla bilgi için bkz. grup yan tümcesi.

açıkça kodlama IEnumerablesIGroupings hızlı bir şekilde sıkıcı hale gelebilir. Aynı sorguyu yazın ve foreach kullanarak varçok daha rahat döngü yapın. var anahtar sözcüğü nesnelerinizin türlerini değiştirmez; yalnızca derleyiciye türleri çıkarmasını emreder. studentQuery ve yineleme değişkeni group türünü var olarak değiştirin ve sorguyu yeniden çalıştırın. İç foreach döngüde yineleme değişkeni yine olarak Studentyazılır ve sorgu önceki gibi çalışır. Yineleme değişkenini student olarak var değiştirin ve sorguyu yeniden çalıştırın. Tam olarak aynı sonuçları elde ettiğinizi görürsünüz.

IEnumerable<IGrouping<char, Student>> studentQuery =
    from student in students
    group student by student.Last[0];

foreach (IGrouping<char, Student> studentGroup in studentQuery)
{
    Console.WriteLine(studentGroup.Key);
    foreach (Student student in studentGroup)
    {
        Console.WriteLine($"   {student.Last}, {student.First}");
    }
}

hakkında vardaha fazla bilgi için bkz. Örtük Olarak Yazılan Yerel Değişkenler.

Grupları anahtar değerlerine göre sıralama

Önceki sorgudaki gruplar alfabetik sırada değil. Yan tümceden group sonra bir orderby yan tümce sağlayabilirsiniz. Ancak bir orderby yan tümce kullanmak için önce yan tümcesi tarafından oluşturulan gruplara başvuru işlevi görecek bir tanımlayıcıya group ihtiyacınız vardır. Tanımlayıcıyı aşağıdaki gibi anahtar sözcüğünü into kullanarak sağlarsınız:

var studentQuery4 =
    from student in students
    group student by student.Last[0] into studentGroup
    orderby studentGroup.Key
    select studentGroup;

foreach (var groupOfStudents in studentQuery4)
{
    Console.WriteLine(groupOfStudents.Key);
    foreach (var student in groupOfStudents)
    {
        Console.WriteLine($"   {student.Last}, {student.First}");
    }
}

// Output:
//A
//   Adams, Terry
//F
//   Fakhouri, Fadi
//   Feng, Hanying
//G
//   Garcia, Cesar
//   Garcia, Debra
//   Garcia, Hugo
//M
//   Mortensen, Sven
//O
//   Omelchenko, Svetlana
//   O'Donnell, Claire
//T
//   Tucker, Lance
//   Tucker, Michael
//Z
//   Zabokritski, Eugene

Bu sorguyu çalıştırdığınızda gruplar alfabetik düzende sıralanır.

Anahtar sözcüğünü let kullanarak sorgu ifadesindeki herhangi bir ifade sonucunun tanımlayıcısını tanıtabilirsiniz. Bu tanımlayıcı, aşağıdaki örnekte olduğu gibi kolaylık sağlayabilir. Ayrıca, bir ifadenin sonuçlarını birden çok kez hesaplanması gerekmeyecek şekilde depolayarak performansı artırabilir.

// This query returns those students whose
// first test score was higher than their
// average score.
var studentQuery5 =
    from student in students
    let totalScore = student.Scores[0] + student.Scores[1] +
        student.Scores[2] + student.Scores[3]
    where totalScore / 4 < student.Scores[0]
    select $"{student.Last}, {student.First}";

foreach (string s in studentQuery5)
{
    Console.WriteLine(s);
}

// Output:
// Omelchenko, Svetlana
// O'Donnell, Claire
// Mortensen, Sven
// Garcia, Cesar
// Fakhouri, Fadi
// Feng, Hanying
// Garcia, Hugo
// Adams, Terry
// Zabokritski, Eugene
// Tucker, Michael

Daha fazla bilgi için yan tümcesindeki makaleyelet bakın.

Sorgu ifadesinde yöntem söz dizimi kullanma

LINQ içindeki Sorgu Sözdizimi ve Yöntem Sözdizimi'nde açıklandığı gibi, bazı sorgu işlemleri yalnızca yöntem söz dizimi kullanılarak ifade edilebilir. Aşağıdaki kod, kaynak dizideki her Student biri için toplam puanı hesaplar ve ardından sınıfın ortalama puanını hesaplamak için bu sorgunun sonuçlarında yöntemini çağırır Average() .

var studentQuery =
    from student in students
    let totalScore = student.Scores[0] + student.Scores[1] +
        student.Scores[2] + student.Scores[3]
    select totalScore;

double averageScore = studentQuery.Average();
Console.WriteLine($"Class average score = {averageScore}");

// Output:
// Class average score = 334.166666666667

Select yan tümcesinde dönüştürmek veya proje yapmak için

Bir sorgunun, öğeleri kaynak dizilerdeki öğelerden farklı olan bir dizi oluşturması yaygındır. Önceki sorgunuzu ve yürütme döngünüzü silin veya açıklama satırı yapın ve aşağıdaki kodla değiştirin. Sorgu bir dizi dize (değil Students) döndürür ve bu olgu döngüye foreach yansıtılır.

IEnumerable<string> studentQuery =
    from student in students
    where student.Last == "Garcia"
    select student.First;

Console.WriteLine("The Garcias in the class are:");
foreach (string s in studentQuery)
{
    Console.WriteLine(s);
}

// Output:
// The Garcias in the class are:
// Cesar
// Debra
// Hugo

Bu kılavuzun önceki bölümlerinde yer alan kod, ortalama sınıf puanının yaklaşık 334 olduğunu gösteriyor. Sınıf ortalamasından büyük toplam puana sahip bir Students dizisi oluşturmak için, select deyiminde Student ID ile birlikte anonim bir tür kullanabilirsiniz.

var aboveAverageQuery =
    from student in students
    let x = student.Scores[0] + student.Scores[1] +
        student.Scores[2] + student.Scores[3]
    where x > averageScore
    select new { id = student.ID, score = x };

foreach (var item in aboveAverageQuery)
{
    Console.WriteLine("Student ID: {0}, Score: {1}", item.id, item.score);
}

// Output:
// Student ID: 113, Score: 338
// Student ID: 114, Score: 353
// Student ID: 116, Score: 369
// Student ID: 117, Score: 352
// Student ID: 118, Score: 343
// Student ID: 120, Score: 341
// Student ID: 122, Score: 368