.NET LINQ dari Dasar

Indonesian (Bahasa Indonesia) translation by Hakima Madani (you can also view the original English article)

Sebagai pengembang perangkat lunak, kami menghabiskan banyak waktu penggalian dan menampilkan data dari berbagai sumber data yang berbeda. Apakah itu suatu webservice XML dari beberapa macam, atau fitur penuh database relasional, kita telah dipaksa untuk belajar metode akses data yang berbeda. Bukankah indah jika metode akses yang sama untuk semua sumber data? Yah, kami beruntung karena, pada rilis dan C# 3,0, .NET Framework 3,5, LINQ telah datang untuk mengubah permainan selamanya.

Rincian tutorial

Pengantar LINQ sintaks
Proyeksi menggunakan LINQ
Penyaringan data
Standar operator

Saat ini Data akses Ikhtisar

Di atas .NET platform kami telah dan masih memanfaatkan ADO.NET
untuk mengakses sumber data yang berbeda. Komunitas open source juga telah memberikan
Para pengembang dengan beberapa alternatif.

Language Integrated Query adalah tambahan baru .NET
Keluarga dan seperti namanya adalah gaya jenis data query akses
didukung sepenuhnya oleh bahasa untuk secara efektif menyatukan cara kita mengakses data
dan untuk membuat hidup kita lebih mudah. LINQ ini mampu menargetkan sejumlah sumber yang berbeda yaitu Oracle,
MSSQL, XML dan beberapa orang lain, tetapi untuk sekarang kita akan fokus pada paling dasar
Semua, LINQ untuk objek.

LINQ untuk objek

Biasanya, untuk proses dan memperbaiki data di dalam daftar kami
dan berbagai struktur data lain, kami telah menggunakan loop 'foreach' atau lain
jenis perulangan metode iterate melalui benda-benda dan proses mereka satu oleh
satu menurut beberapa kondisi. Ini baik, tetapi terus terang membutuhkan banyak
kode dasar yang kita semua ingin kita tidak harus menulis. Pada dasarnya kami telah memberitahu
kompiler setiap detail tunggal dari proses untuk memanipulasi data.

Ini adalah persis mana LINQ bersinar terbaik. Apa LINQ memungkinkan kita
lakukan adalah untuk hanya mengatakan kompilator apa yang kami ingin untuk melakukan dan membiarkan kompiler yang bekerja
tahu cara terbaik untuk benar-benar mencapai itu. Jika Anda menggunakan SQL sintaks sebelumnya, kemiripan besar
antara LINQ dan setiap dialek SQL akan menjadi hal pertama yang Anda perhatikan.
Seperti SQL, LINQ terlalu mendukung "select", "from", "where", "join", "group by"
dan "order by" kata kunci. Berikut adalah contoh sederhana query daftar benda:

Inisialisasi daftar:


List<Car> ListOfCars = new List<Car>()
{
    new Car {name = "Toyota"    , owner = "Alex" , model = 1992},
    new Car {name = "Mitsubishi", owner = "Jeff" , model = 2005},
    new Car {name = "Land Rover", owner = "Danny", model = 2001},
    new Car {name = "BMW"       , owner = "Danny", model = 2006},
    new Car {name = "Subaru"    , owner = "Smith", model = 2003}
};

Query:

1
2	IEnumerable<Car> QueryResult = from car in ListOfCars
3	select car;

Bagian pertama dari kode sebelumnya hanya populates daftar
dengan empat contoh kelas 'Mobil'. Bagian selanjutnya dari kode, namun, menggunakan
"from" dan "select" kunci untuk memilih sekelompok objek. Perbedaan utama
antara SQL dan LINQ adalah bahwa kata kunci "from" datang sebelum "select"
kata kunci karena kita pertama kali harus mendefinisikan objek yang kita inginkan untuk beroperasi pada. Akhirnya
klausa "select" memberitahu kompilator apa yang kita ingin ekstrak dalam query ini. Atas
Kode hanya ekstrak segala sesuatu yang ada di daftar ke dan "QueryResult"
variabel.

Ketika kami permintaan hal-hal dari benda-benda (LINQ untuk objek) kami
pertanyaan selalu kembali "IEnumrable<T>" daftar objek. Pada dasarnya
Jenis "IEnumerable" adalah jenis daftar yang memperlihatkan Pencacah, yang
mendukung iterasi sederhana melalui koleksi bebas-umum, dan<T>
adalah jenis setiap entri dalam daftar.

Jangan khawatir jika Anda tidak akrab dengan "enumerators" dan "generics". Hanya
Ingat bahwa hasil dari query LINQ selalu koleksi seperti data
struktur yang memungkinkan untuk iterasi melalui menggunakan loop seperti ditunjukkan
di bawah:

1
2	foreach(Car car in QueryResult)
3	Console.WriteLine(car.name);

Kami belajar bahwa LINQ selalu kembali struktur koleksi yang serupa
untuk daftar lain. Namun, LINQ query tidak melaksanakan sampai hasilnya
Diakses oleh beberapa bagian lain dari kode, seperti loop "foreach" di atas. Ini adalah untuk
memungkinkan kita untuk terus-menerus mendefinisikan query tanpa overhead dengan mengevaluasi kembali
setiap langkah yang baru dalam permintaan.

Proyeksi

So far so good; tetapi sebagian besar waktu, pertanyaan kami akan perlu
menjadi lebih kompleks; Jadi mari kita coba memproyeksikan data. Dalam SQL, proyeksi berarti memilih
nama kolom(s) table(s) yang satu keinginan untuk melihat muncul dalam hasil
query. Dalam kasus LINQ untuk objek, melakukan proyeksi akan menghasilkan
dalam jenis hasil query berbeda daripada jenis objek yang kita lakukan
query.

Ada dua jenis proyeksi yang dapat kita lakukan. Kita dapat
baik melakukan proyeksi berdasarkan jenis objek yang sudah ada, atau pergi sama sekali
cara lain dengan menggunakan jenis anonim. Contoh berikut adalah yang pertama
jenis:

1
2	IEnumerable<CarOwner> QueryResult = from car in ListOfCars
3	select new CarOwner { owner_name = car.owner };

Dalam kode sebelumnya, jenis hasil query dinyatakan sebagai
<CarOwner>, yang berbeda untuk <Car>, jenis yang 'ListOfCar' variabel yang diinisialisasi dengan. Kita memiliki
juga digunakan kata kunci "new" dan telah melakukan beberapa tugas di dalam keriting
kurung. Dalam kode di atas, menggunakan "select" dengan kata kunci "new" memberitahu
compiler untuk instantiate baru objek 'CarOwner' untuk setiap entri dalam hasil query.
Juga dengan menetapkan nilai ke jenis baru kita telah diinisialisasi setiap contoh
'CarOwner' kelas.

Namun, jika Anda tidak sudah memiliki tipe didefinisikan
penggunaan, Anda masih dapat melakukan proyeksi menggunakan jenis anonim.

Proyeksi menggunakan jenis anonim

Akan sangat rumit jika, untuk setiap proyeksi, anda
dipaksa untuk membuat jenis baru. Itu sebabnya, C# 3.0, memberi dukungan untuk anonim
jenis telah ditambahkan ke bahasa. Anonim tipe dinyatakan menggunakan "var"
kata kunci. Ia memberitahu kompilator jenis variabel tidak diketahui sampai
Hal ini ditugaskan untuk pertama kalinya.


var QueryResult = from car in ListOfCars
                  select new { 
                      car_name = car.name, 
                      owner_name = car.owner 
                  };

foreach(var entry in QueryResult)
    Console.WriteLine(entry.car_name);

Di atas adalah contoh melakukan query dengan anonim
jenis. Satu-satunya menangkap harus diwaspadai adalah bahwa kompilator tidak akan
memungkinkan kembali anonim jenis dari metode.

Mengakses properti anonim tipe mudah. Dalam Visual Studio 2008, kode
Penyelesaian Intellisense juga mencantumkan properti yang terpapar oleh anonim tipe.

Penyaringan Data

Biasanya sebagai bagian dari LINQ query, kita juga perlu untuk memperbaiki
hasil query dengan menetapkan kondisi. Sama seperti SQL, LINQ terlalu menggunakan "where"
klausul untuk memberitahu kompilator kondisi apa diterima.

1
2	IEnumerable<Car> QueryResult = from car in ListOfCars
3	where car.name == "Subaru"
4	select car;

Kode sebelumnya mendemonstrasikan penggunaan klausa "where" dan
kondisi untuk mengikuti. Untuk lebih lanjut untuk menentukan beberapa kondisi, mendukung LINQ
'and' (&& amp) dan 'or' konstruksi (||). "where" bagian dari query harus selalu
Boolean expression, jika tidak kompilator akan mengeluh.

Order by

Ketika query objek, dimungkinkan untuk bergantung pada query
sasaran yang sudah diurutkan. Jika itu tidak terjadi, LINQ dapat mengurus yang
dengan menggunakan kalimat "order by" yang akan menjamin hasil kueri
diurutkan dengan benar.

1
2	IEnumerable<Car> QueryResult = from car in ListOfCars
3	orderby car.model
4	select car;

Jika Anda menjalankan kode di atas, Anda akan melihat bahwa hasil
query diurutkan dalam urutan menaik. Anda dapat mengubah urutan dengan menggunakan "ascending" dan "descending"
kata kunci, dan lebih lanjut perubahan urutan dengan menetapkan lebih dari satu bidang untuk menyortir
oleh. Kode berikut menunjukkan bagaimana:

1
2	IEnumerable<Car> QueryResult = from car in ListOfCars
3	orderby car.model descending
4	select car;

Grouping

LINQ juga memungkinkan pengelompokan hasil query dengan nilai
properti tertentu seperti yang ditunjukkan dalam contoh ini:

1
2	var QueryResult = from car in ListOfCars
3	group car by car.owner into carOwnersGroup
4	select carOwnersGroup.Key;

Seperti yang Anda lihat, LINQ mendukung klausul "group by" untuk
menentukan objek apa dan apa properti untuk kelompok oleh. "into" kata kunci akan
kemudian memungkinkan kita untuk proyek pada hasil pengelompokan yang dapat diakses oleh "key"
properti.

joins

Mendukung LINQ bergabung data dari koleksi yang berbeda menjadi satu
hasil query. Anda dapat melakukannya menggunakan kata kunci "join" untuk menentukan apa benda
untuk bergabung dan menggunakan kata "on" kunci untuk menentukan hubungan pencocokan
dua objek.

Inisialisasi daftar terkait:


List<Car> ListOfCars = new List<Car>()
{
    new Car {name = "Mitsubishi", owner = "Jeff" , model = 2005},
    new Car {name = "Land Rover", owner = "Danny", model = 2001},
    new Car {name = "Subaru"    , owner = "Smith", model = 2003},
    new Car {name = "Toyota"    , owner = "Alex" , model = 1992},
    new Car {name = "BMW"       , owner = "Danny", model = 2006},
};

List<CarOwner> ListOfCarOwners = new List<CarOwner>()
{
    new CarOwner {owner_name = "Danny", age = 22},
    new CarOwner {owner_name = "Jeff" , age = 35},
    new CarOwner {owner_name = "Smith", age = 19},
    new CarOwner {owner_name = "Alex" , age = 40}
};

Query:

1
2	var QueryResult = from car in ListOfCars
3	join carowner in ListOfCarOwners on car.owner equals carowner.owner_name
4	select new {name = car.name, owner = car.owner, owner_age = carowner.age};

Pada kode diatas, menggunakan jenis anonim, kami telah bergabung
dua objek dalam hasil permintaan tunggal.

Objek hirarki menggunakan Joins dan grup

Sejauh ini, kami telah belajar bagaimana kita dapat menggunakan LINQ untuk membangun flat
Daftar hasil query. Dengan LINQ, juga dimungkinkan untuk mencapai query hirarkis
hasil menggunakan "GroupJoin". Dalam kata-kata sederhana, kita bisa menetapkan objek untuk
sifat setiap entri dengan LINQ query.


List<Car> ListOfCars = new List<Car>()
{
    new Car {name = "Mitsubishi", owner = "Jeff" , model = 2005},
    new Car {name = "Land Rover", owner = "Danny", model = 2001},
    new Car {name = "Subaru"    , owner = "Smith", model = 2003},
    new Car {name = "Toyota"    , owner = "Alex" , model = 1992},
    new Car {name = "BMW"       , owner = "Danny", model = 2006},
};

List<CarOwner> ListOfCarOwners = new List<CarOwner>()
{
    new CarOwner {owner_name = "Danny", age = 22},
    new CarOwner {owner_name = "Jeff" , age = 35},
    new CarOwner {owner_name = "Smith", age = 19},
    new CarOwner {owner_name = "Alex" , age = 40}
};

var QueryResult = from carowner in ListOfCarOwners
                  join car in ListOfCars on carowner.owner_name equals car.owner into carsGroup
                  select new {name = carowner.owner_name, cars = carsGroup};

foreach(var carOwner in QueryResult) 
    foreach(var car in carOwner.cars)
        Console.WriteLine("Owner name: {0}, car name: {1}, car model: {2}", carOwner.name, car.name, car.model);

Dalam contoh di atas, klausa "Join" diikuti dengan sebuah "into"
Bagian. Ini berbeda untuk operasi bergabung sebelumnya bahwa kita melihat. Di sini, "into"
ayat yang digunakan untuk kelompok mobil oleh pemilik (into carsGroup) dan menetapkan grouping
"cars" properti jenis anonim.

Standar Query operator

Sejauh ini, segala sesuatu yang kita lihat telah didukung oleh C# 3.0
sintax. Namun, masih ada sejumlah besar operasi yang tidak C# 3.0
dukungan. Operator standar permintaan menyediakan kemampuan permintaan, termasuk
penyaringan, proyeksi, agregasi, menyortir dan banyak lagi. Operasi ini karena didukung
sebagai metode Perpustakaan LINQ dan dapat dijalankan pada hasil query seperti ditunjukkan dalam
screenshot berikut:

Operator ini tercantum di bawah ini untuk referensi Anda.

Agregat operator

Sum: kembali jumlah dari semua entri
Max: kembali entri dengan nilai maksimum
Min: kembali entri dengan nilai minimum
Average: mengembalikan nilai rata-rata untuk koleksi
Aggregate: digunakan untuk membuat agregasi disesuaikan
LongCount: ketika berhadapan dengan koleksi besar, metode ini akan mengembalikan nilai sampai nilai terbesar yang didukung oleh kelas "lama"
Count: kembali "integer" untuk menghitung item dalam koleksi

Elemen operator

First: kembali pertama masuk dari kumpulan hasil
FirstOrDefault: jika kosong koleksi, akan kembali nilai default, sebaliknya akan kembali pertama masuk dari koleksi
Single: akan kembali hanya elemen dari koleksi
SingleOrDefault: jika kosong koleksi, akan kembali nilai default, sebaliknya akan kembali hanya elemen dari koleksi
Last: kembali entri terakhir dari koleksi
LastOrDefault: jika kosong koleksi, akan kembali nilai default, sebaliknya kembali entri terakhir dari koleksi
ElementAt: kembali elemen di posisi tertentu
ElementAtOrDefault: jika kosong koleksi, akan kembali nilai default, sebaliknya kembali elemen di posisi tertentu

Mengatur operator terkait

Except: serupa untuk bergabung kiri dalam SQL, akan kembali entri dari satu set yang tidak ada dalam satu set
Union: kembali semua masukan dari kedua benda
Intersect: kembali elemen yang sama dari set kedua
Distinct: Menampilkan entri yang unik dari koleksi

Generasi operator

DefaultIfEmpty: jika hasilnya kosong, mengembalikan nilai default
Repeat: mengulangi kembali objek untuk jumlah waktu yang ditentukan
Empty: akan kembali koleksi IEnumerable yang kosong
Range: kembali kisaran angka untuk jumlah tertentu, dan menghitung

Penyulingan operator

Where: akan kembali benda-benda yang memenuhi kondisi tertentu
OfType: akan kembali objek dari jenis yang ditetapkan

Konversi operator

ToLookup: kembali hasil sebagai sebuah lookup
ToList: kembali hasil sebagai daftar koleksi
ToDictionary: kembali hasil sebagai sebuah kamus
ToArray: kembali hasil sebagai koleksi Array
AsQueryable: kembali hasil sebagai IQueryable<T></T>
AsEnumerable: kembali hasil sebagai IEnumerable<T></T>
OfType: filter koleksi berdasarkan tipe tertentu
Cast: digunakan untuk mengkonversi koleksi lemah diketik ke dalam koleksi mengetik kuat

Partisi operator

Take: kembali jumlah tertentu dari catatan
Takewhile: kembali jumlah tertentu dari catatan sementara kondisi mengevaluasi True
Skip: melompat ditentukan jumlah entri dan kembali sisa
SkipWhile: melompat ditentukan jumlah entri sementara kondisi mengevaluasi True

Operator quantifier

Any: returns true atau false untuk kondisi tertentu
Contains: mengembalikan true atau false untuk keberadaan objek tertentu
All: pengembalian true atau false untuk semua benda-benda yang memenuhi kondisi tertentu

Bergabung dengan operator

Join: kembali entri di mana kunci set yang sama
GroupJoin: digunakan untuk membangun objek hierarki berdasarkan hubungan master dan detail

Kesetaraan operator

SequenceEqual: mengembalikan nilai true ketika koleksi sama

Penyortiran operator

Reverse: kembali koleksi terbalik
ThenBy: digunakan untuk melakukan tambahan untuk menyortir
ThenByDescending: digunakan untuk melakukan lebih lanjut penyortiran dalam urutan
OrderBy: digunakan untuk menentukan urutan
OrderByDescending: digunakan untuk menentukan urutan

Proyeksi operator

SelectMany: digunakan untuk meratakan koleksi hirarkis
Select: digunakan untuk mengidentifikasi sifat kembali

Rangkaian operator

Concat: digunakan untuk menggabungkan dua koleksi

Jadi apa sekarang?

LINQ telah terbukti sangat berguna untuk query objek, dan sintax SQL-seperti yang memudahkan untuk
belajar dan menggunakan. Juga, sejumlah besar standar operator memungkinkan untuk rantai sejumlah operator
untuk melakukan query yang kompleks. Dalam tindak lanjut untuk tutorial ini, kita akan meninjau bagaimana LINQ dapat digunakan untuk
query database dan isi XML...

Jual .NET skrip dan komponen pada CodeCanyon

Ikuti kami di Twitter, atau berlangganan Nettuts + RSS Feed untuk tutorial pengembangan web terbaik di web.