Pelajaran 4 [ ADVANCE PROGRAMMING]

Koleksi

.NET Framework menyediakan serangkaian tipe standar untuk menyimpan dan mengelola koleksi
objek. Ini termasuk daftar yang dapat diubah ukurannya, daftar tertaut, kamus yang diurutkan dan
tidak disortir serta array. Dari jumlah tersebut, hanya array yang merupakan bagian dari bahasa C#;
koleksi yang tersisa hanyalah kelas yang Anda buat seperti yang lain.

Koleksi dapat dibagi menjadi beberapa kategori berikut:

 Antarmuka yang mengidentifikasi protokol pengumpulan standar
 Kelas koleksi siap pakai (Daftar, Kamus, dll.)
 Kelas dasar untuk menulis koleksi khusus aplikasi

Ruang nama koleksi adalah sebagai berikut:

// Kelas dan antarmuka koleksi Non-Generik

 menggunakan System.Collections;
//Kelas koleksi non-generik yang diketik dengan kuat
 menggunakan System.Collections.Specialized;
//Kelas dan antarmuka koleksi umum
 menggunakan System.Collections.Generic;
//Proxy dan basis untuk koleksi khusus
 menggunakan System.Collections.ObjectModel;

Meskipun implementasi internal dan karakteristik eksternal dari struktur data ini sangat bervariasi,
kemampuan untuk menelusuri isi koleksi merupakan kebutuhan yang hampir universal. Kerangka
mendukung kebutuhan ini melalui sepasang antarmuka ( IEnumerable,IEnumerator dan rekan-
rekan generik ).

Di bawah ini adalah representasi grafis dari Collection Interfaces:

1
 Pelajaran 4 [ ADVANCE PROGRAMMING]

Koleksi adalah kumpulan catatan terkait. Ini termasuk unit yang berarti:

Kita harus memilih wadah yang sesuai untuk menyimpan data sementara untuk proses pengambilan
dan modifikasi.
Wadah yang sesuai tergantung pada :
1. tujuan yang ingin kita lakukan pada data ( hanya membaca, melakukan modifikasi seperti
menyisipkan, menghapus, memperbarui )
2. Jumlah record yang harus ditransfer

Himpunan
1. Panjang Tetap -> Ukurannya tidak fleksibel. Hal ini ditentukan pada waktu instantiasi.
2. Sangat Diketik -> Pengembang menentukan jenisnya pada waktu instantiasi alih-alih waktu proses.
Fitur ini membuat berjalan cepat saat runtime, karena tidak perlu menunggu definisi tipe.
 3. Pengembang menggunakan kata kunci "foreach" untuk mengisi dan mengulangi array.
Fixed Length dan Strongly Typed mengkonsumsi lebih sedikit memori, oleh karena itu memiliki
kinerja yang baik.

2
 Pelajaran 4 [ ADVANCE PROGRAMMING]

Contoh 1:

kelas ArrayContoh
{
publik statis batal Utama()
{
string [] strData = baru string [5];
untuk ( int i = 0; i < strData.Length; i++)
{
strData[i] = (i + 1).ToString();
}

foreach ( string d di strData)

{
Konsol .WriteLine(d);

}
Konsol .ReadKey();
}
}

Kelas Array berisi berbagai metode untuk menemukan elemen dalam array satu dimensi:

1. Metode Pencarian Biner

o Mencari array yang diurutkan dengan cepat untuk item tertentu
2. Metode IndexOf / LastIndex
o Untuk mencari array yang tidak disortir untuk item tertentu
3. Metode Find/ FindLast / FindIndex / FindLastIndex / FindAll /Exists/ TrueForAll
o Untuk mencari array yang tidak disortir untuk item yang memenuhi kondisi tertentu

Contoh 2: Menggunakan ekspresi lambda

kelas ArrayContoh1
{
publik statis batal Utama()
{
string [] nama = { "Jack" , "Simon" , "Frederick" };

//ekspresi lambda
string match = Array .Find(names, n => n.Contains( "a" ));
Konsol .WriteLine(cocok);

3
 Pelajaran 4 [ ADVANCE PROGRAMMING]

lambda
Ekspresi lambda adalah fungsi anonim yang dapat Anda gunakan untuk
membuat delegasi atau pohon ekspresi jenis . Dengan menggunakan ekspresi lambda, Anda dapat
menulis fungsi lokal yang dapat diteruskan sebagai argumen atau dikembalikan sebagai nilai
pemanggilan fungsi. Ekspresi Lambda sangat membantu untuk menulis ekspresi kueri LINQ.

Sintaksis:

Parameter/Argumen => Hasil/Kode Eksekusi

Contoh 3:

Daftar < int > angka = baru Daftar < int > () { 10, 20, 15, 60 };
int indeks = angka.FindIndex(x=>x%2!=0);
Konsol .WriteLine(indeks);

x [adalah nama argumen]

=> [Memisahkan nama argumen dari ekspresi hasil]

x% 2!=0 [Mengembalikan nilai true jika x tidak genap]

Contoh 4:

Daftar < string > buah = baru Daftar < string >(){ "Apel" , "Oranye" ,
"Pisang" };
string startmatch = buah.Temukan(n => n.MulaiDengan( "O" ));
Konsol .WriteLine(startmatch);

Daftar Array

1. Arraylist BUKAN Panjang Tetap -> Ada kemungkinan data bertambah. Di satu sisi itu adalah fitur
yang bagus setiap kali pengembang tidak yakin tentang ukuran daftar array dan di sisi lain mungkin
butuh waktu lama untuk definisi ukuran.
2. Arraylist TIDAK Diketik dengan Kuat -> Setiap kali pengembang tidak yakin tentang apa sebenarnya
definisi tipe untuk data input atau output dan mereka harus menunggu hingga runtime untuk
menampilkan tipenya. Kerugiannya adalah memakan waktu pada saat runtime untuk memori untuk
menentukan definisi tipe.
3. Pengembang menggunakan kata kunci "foreach" untuk mengisi dan mengulangi melalui arraylist .
 

4
 Pelajaran 4 [ ADVANCE PROGRAMMING]

ArrayList dapat menerima string, integer dan desimal secara bersamaan.

kelas ArrayDaftarContoh
{
publik statis batal Utama()
{
ArrayList arrList = baru Daftar Array ();

arrList.Add( "John Smith" );

arrList.Add(1);
arrList.Add(0.50);

StringBuilder sb = baru StringBuilder ();

foreach ( var data dalam arrList)

{
sb.Tambahkan(data + "," );
}

Konsol .WriteLine(sb);

Konsol .ReadKey();

}
}

Tabel Hash
HashTable adalah jenis lain dari struktur data yang mendefinisikan nilai kunci untuk setiap bagian
data. Oleh karena itu mencari data itu mudah hanya dengan menunjukkan kuncinya. Ini TIDAK
diketik dengan kuat dan BUKAN ukuran tetap.

kelas HashTableContoh
{
publik statis batal Utama()
{
Hashtable hsTable = baru Tabel hash ();

hsTable.Add(1, "John Smith" );

hsTable.Add(2, "Jason Tan" );

foreach ( item DictionaryEntry di hsTable)

{
Konsol .WriteLine( "{0}, {1}" , item.Key, item.Value);
}
}
}

5
 Pelajaran 4 [ ADVANCE PROGRAMMING]

Tumpukan
Kami memiliki struktur data yang berbeda dan tumpukan adalah salah satunya. Stack adalah bagian
dari struktur data. Stack adalah struktur data yang diprioritaskan (seperti List adalah basis terindeks).
Stack mendefinisikan prioritas untuk setiap item, artinya perilaku stack memaksa item-itemnya
untuk dimasukkan (push) ke dalam formulir prioritas stack. Jadi susun item kemudian di atas item
dan perilaku ini adalah "menentukan prioritas untuk setiap item". Oleh karena itu setiap kali Anda
ingin memasukkan item, Anda harus menambahkan (PUSH) di bagian atas tumpukan dan setiap kali
Anda ingin menghapus (POP) item dari tumpukan Anda harus menghapusnya dari atas tumpukan.
Seperti yang Anda dapatkan, item yang datang terakhir akan dipilih ke POP untuk yang pertama dan
ekspresinya dalam ilmu komputer sama dengan "Last in First out" == "LIFO".

Ini TIDAK diketik dengan kuat dan BUKAN ukuran tetap.

Contoh Stack Push dan Pop

kelas Contoh Tumpukan

{
publik statis batal Utama()
{
Stack dataStack = baru Tumpukan ();

dataStack.Push( "John Smith" );

dataStack.Push( "Jason Tan" );

foreach ( var item dalam dataStack) //mengulangi koleksi

6
 Pelajaran 4 [ ADVANCE PROGRAMMING]

{
Konsol .WriteLine(item); // keluarkan data dari tumpukan
}
}
}

Q ueue
Antrian adalah jenis lain dari struktur data yang mendefinisikan prioritas untuk setiap item dalam
bentuk lain. Oleh karena itu setiap kali Anda ingin memasukkan item, Anda harus menambahkan
(Enqueue) di kepala antrian dan kapan pun Anda ingin menghapus (Dequeue) item dari antrian Anda
harus menghapusnya dari bawah antrian. Saat Anda mendapatkannya, item yang datang lebih dulu
akan dipilih untuk Dequeue untuk yang pertama dan ekspresinya dalam ilmu komputer sama dengan
"First in First out" == "FIFO".

Ini TIDAK diketik dengan kuat dan BUKAN ukuran tetap.

Contoh Antrian Antrian dan Dequeue:

kelas Contoh Antrian

{
publik statis batal Utama()
{
// membuat instance objek ke kelas Queue
Data antrian Antrian = baru Antrian ();

//Memasukkan data ke dalam antrian

dataQueue.Enqueue( "John Smith" );
dataQueue.Enqueue( "Jason Tan" );
dataQueue.Enqueue( "Martha Chong" );
dataQueue.Enqueue( "Alex Chu" );

//Mengulangi/Menghitung item dalam antrian

foreach ( var item dalam dataQueue)
{
Konsol .WriteLine(item);
}
}

7
 Pelajaran 4 [ ADVANCE PROGRAMMING]

Daftar
Mengapa kita perlu Daftar?

1. Daftar TIDAK Panjang Tetap -> Ada kemungkinan data bertambah. Di satu sisi itu adalah fitur yang
bagus setiap kali pengembang tidak yakin tentang ukuran daftar array dan di sisi lain mungkin butuh
waktu lama untuk definisi ukuran.

2. Daftar Diketik dengan Kuat ketika didefinisikan "Generik" -> Setiap kali pengembang yakin tentang
apa sebenarnya definisi tipe untuk data input atau output dan mereka tidak menunggu sampai
runtime untuk menampilkan tipenya. Fitur ini membuat berjalan cepat saat runtime, karena tidak
perlu menunggu definisi tipe.

3. Pengembang menggunakan kata kunci "foreach" untuk mengisi dan mengulangi array.
Karena Daftar tidak Panjang Tetap membuat pengembang merasa fleksibel untuk menggunakannya,
dan karena itu Sangat Diketik ketika didefinisikan "Generik" sehingga kode kami berjalan cepat saat
runtime karena tidak perlu menunggu definisi tipe.
 

8
 Pelajaran 4 [ ADVANCE PROGRAMMING]

Contoh 1:

kelas DaftarContoh
{
publik statis batal Utama()
{
//Instansiasi dan
Daftar < string > dataList = baru Daftar < string >();

dataList.Add( "John Smith" );

dataList.Add( "Jason Tan" );
dataList.Add( "Amanda Smith" );

foreach ( item string dalam dataList)

{
Konsol .WriteLine(item);
}
}
}

Contoh2:

publik kelas Karyawan

{
publik string Nama { dapatkan ; mengatur ; }
}
kelas DaftarContoh1
{
publik statis batal Utama()
{
Daftar < Karyawan > dataIList = baru Daftar < Karyawan >();

Karyawan e = baru Karyawan ();

e.Nama= "John Smith" ;
dataIList.Add(e);
e = baru Karyawan ();
e.Nama= "Jason Tan" ;
dataIList.Add(e);
foreach ( Item karyawan di dataIList)
{
Konsol .WriteLine(item);
}

}
}

Daftar
Mengapa kita membutuhkan IList ? IList diimplementasikan oleh List, Ilist adalah antarmuka dan
mengimplementasikan metode. Setiap kali Anda memperkirakan kemungkinan bahwa kode Anda
akan diubah di masa depan, Anda harus menggunakan IList karena antarmuka mengurangi
ketergantungan dan dengan sedikit modifikasi kode Anda berjalan. Oleh karena itu Anda harus
mengamati polimorfisme untuk memisahkan aplikasi Anda dan mengontrol penambahan atau
penghapusan metode yang mungkin diubah. Segala sesuatu yang lain serupa. Setiap kali kita ingin
mengubah beberapa operasi, jadi " IList " memungkinkan kita untuk melakukannya dengan mudah
dengan setidaknya mengubah seluruh kode.
Antarmuka tidak dapat di-instantiate, jadi harus di-instantiate dari List
IList < string > dataIList = baru IList < string >(); //kesalahan

9
 Pelajaran 4 [ ADVANCE PROGRAMMING]

Larutan:
IList < string > dataIList = baru Daftar < string >();

Contoh:

kelas IListContoh1
{
publik statis batal Utama()
{
IList < string > dataIList = baru Daftar < string >();

dataIList.Add( "John Smith" );

dataIList.Add( "Jason Tan" );

foreach ( item string dalam dataIList)

{
Konsol .WriteLine(item);
}
}
}

Perbedaan antara Kelas Beton dan Antarmuka

 Kelas Beton mewarisi hanya dari SATU kelas tetapi dapat mengimplementasikan satu atau
LEBIH dari satu antarmuka
 Anda dapat menulis di dalam versi lengkap kelas beton dari fungsi Anda sementara Anda
harus mendefinisikan tanda tangan saja di dalam antarmuka.
 Anda dapat mendefinisikan variabel dan nilai di dalam Kelas Beton saat Anda tidak diizinkan
untuk mendefinisikan variabel di dalam antarmuka.
 Sebuah Konkret class dapat memiliki konstruktor saat Anda tidak diizinkan untuk
mendefinisikan konstruktor di dalam antarmuka.
 Kelas abstrak dapat berisi pengubah akses sementara antarmuka tidak.

Seperti yang saya sebutkan bahwa bagaimana kelas tidak dapat didorong dari dua kelas itu hanya
dapat didorong dari hanya satu kelas, jadi setiap kali Anda ingin mengemudi dari dua kelas, tidak
mungkin untuk mewarisi dari dua kelas abstrak tetapi dimungkinkan untuk mengemudi dari lebih
dari satu kelas dengan antarmuka .
Nanti di masa depan jika pengembang memutuskan untuk menambahkan beberapa fitur di kelas
mereka dan mewarisinya dari kelas lain, pengembang selalu lebih suka menggunakan antarmuka
koleksi sehingga jika Anda ingin mengubah kode Anda dan meningkatkan kemampuannya, pilih
antarmuka.

Di sisi lain, antarmuka menyimpan program Anda dapat diperpanjang dan Decouple : Kelas-kelasnya

independen satu sama lain, jadi kesalahan, pengecualian, dan kegagalan akan jarang terjadi dalam
perubahan kode di masa mendatang oleh antarmuka.

10
 Pelajaran 4 [ ADVANCE PROGRAMMING]

Polimorfisme : Saat Anda menggunakan antarmuka, Anda benar-benar mengamati dan melakukan
polimorfisme dan OOP. Ini berarti merangkum desainer Anda. Antarmuka berarti titik atau simpul
untuk menghubungkan dua bagian satu sama lain, itu berarti membuat ketergantungan rendah dari
dua bagian dan membuat bagian gabungan untuk membuatnya fleksibel dengan perubahan di masa
depan.

Contoh:

kelas IListContoh1
{
publik statis batal Utama()
{
IList < int > dataIList = baru Daftar < int >();

dataIList.Add(100);
dataIList.Add(1000);

StringBuilder str = baru StringBuilder ();

foreach ( item int dalam dataIList)
{
str.Append( "Nilai:" + item + "\n" );
}

Konsol .WriteLine(str);
Konsol .ReadKey();
}
}
 

11
 Pelajaran 4 [ ADVANCE PROGRAMMING]

dapat dihitung
IEnumerable cocok hanya untuk beralih melalui pengumpulan dan Anda tidak dapat mengubah
(Tambah atau Hapus) data IEnumerable membawa SEMUA data dari server ke klien kemudian
memfilternya, anggap Anda memiliki banyak catatan sehingga IEnumerable menempatkan overhead
pada memori Anda.

Contoh 1:
publik kelas Murid
{
publik string ID { dapatkan ; mengatur ; }
publik string Nama { dapatkan ; mengatur ; }
publik int Umur { dapatkan ; mengatur ; }
}

kelas IEnumerableContoh1
{
publik statis batal Utama()
{
IEnumerable < Mahasiswa > dataIEnumerable = baru Daftar < Siswa
>()
{
baru Siswa {ID= "1001" , Nama= "John Smith" , Umur=25},
baru Siswa {ID= "1002" , Nama= "Amanda Tan" , Umur=30},
baru Siswa {ID= "1003" , Nama= "Jason Chen" , Umur=28}
};
Console .WriteLine( "StudID" + "\t" + "StudName" + "\t" +
"StudAge" );
foreach ( Item siswa dalam dataIEnumerable)
{
Console .WriteLine(item.ID + "\t" + item.Name + "\t" +
item.Usia);
}

12
 Pelajaran 4 [ ADVANCE PROGRAMMING]

}
}

Contoh 2:

IEnumerable < Mahasiswa > dataIEnumerable = baru Daftar < Siswa >()
{
baru Siswa {ID= "1001" , Nama= "John Smith" , Umur=25},
baru Siswa {ID= "1002" , Nama= "Amanda Tan" , Umur=30},
baru Siswa {ID= "1003" , Nama= "Jason Chen" , Umur=28}
};
Console .WriteLine( "StudID" + "\t" + "StudName" + "\t" +
"StudAge" );
foreach ( Item siswa dalam dataIEnumerable)
{
Console .WriteLine(item.ID + "\t" + item.Name + "\t" +
item.Usia);
}

IEnumerable StudName = dari n di dataIEnumerable

di mana n.Name.StartsWith( "J" )
pilih n.Nama;

Console .WriteLine( "\n\nNama yang dimulai dengan J" );

foreach ( string sn di StudName)
{
Konsol .WriteLine(sn);
}

IEnumerable dan IEnumerator

Enumerator _ interface mendefinisikan protokol tingkat rendah dasar di mana elemen dalam koleksi
dilintasi—atau dihitung—dengan cara forward-only. Deklarasinya adalah sebagai berikut:

publik IEnumerator
{
bool Pindah Berikutnya ();
objek Saat Ini { dapatkan; }
batal Atur Ulang();
}

Koleksi biasanya tidak menerapkan enumerator ; sebagai gantinya, mereka menyediakan

enumerator, melalui antarmuka IEnumerable :

publik IEnumerable
{
IEnumerator GetEnumerator ( );
}

Contoh:
13
 Pelajaran 4 [ ADVANCE PROGRAMMING]

kelas IEnumerableIEnumeratorEx1
{
publik statis batal Utama()
{
string s = "Halo Dunia" ;
IEnumerator enumRator = s.GetEnumerator();

sementara (enumRator.MoveNext())
{
char c = ( char )enumRator.Current;
Konsol .Tulis(c + "." );
}

}
}

Namun, jarang memanggil metode pada enumerator secara langsung dengan cara ini, karena C#
menyediakan pintasan sintaksis: pernyataan foreach . Berikut contoh yang sama yang ditulis ulang
menggunakan foreach :

string s = "Halo Dunia" ; // kelas string mengimplementasikan IEnumerable

foreach ( char c dalam s)

{
Konsol .Tulis(c + "." );
}

IEnumerable<T> dan IEnumerator<T> (Setara Generik)

Pencacah dan IEnumerable hampir selalu diimplementasikan bersama dengan versi generik yang
diperluas:

publik IEnumerator<T> : IEnumerator, IDisposable

{
T Arus { dapatkan ; }
}
publik IEnumerable<T> : IEnumerable
{
IEnumerator<T> GetEnumerator ( );
}

Contoh:

kelas IEnumerableIEnumeratorGeneric
{
publik statis batal Utama()
{
IEnumerable < int > s = dari nilai dalam Enumerable .Range(0,
2)
pilih nilai;

foreach ( int val dalam s)

{
Konsol .WriteLine(val);

14
 Pelajaran 4 [ ADVANCE PROGRAMMING]

}
// dapat menggunakan metode ekstensi di IEnumerable<int>
jalan ganda = s.Rata-rata();

Konsol .WriteLine(ave);

//Metode ekstensi dapat mengonversi IEnumerable<int>

Daftar < int > lst = s.ToList();
int [] lstArray = lst.ToArray();

foreach ( int l di lstArray)

{
Konsol .WriteLine(l);
}
Konsol .ReadKey();
}
}

Menerapkan Antarmuka Enumerasi

Anda mungkin ingin menerapkan IEnumerable atau IEnumerable<T> untuk satu atau beberapa
alasan berikut:
 Untuk mendukung pernyataan foreach
 Untuk beroperasi dengan apa pun yang mengharapkan koleksi standar
 Untuk memenuhi persyaratan antarmuka koleksi yang lebih canggih
 Untuk mendukung penginisialisasi koleksi

Untuk mengimplementasikan IEnumerable / IEnumerable<T> , Anda harus menyediakan

enumerator. Anda dapat melakukan ini dengan salah satu dari tiga cara:
 Jika kelas "membungkus" koleksi lain, dengan mengembalikan enumerator koleksi yang
dibungkus
 Melalui iterator menggunakan pengembalian hasil
 Dengan membuat instance implementasi IEnumerator / IEnumerator<T> Anda sendiri

Cara lain untuk menggunakan dan mendeklarasikan IEnumerable:

kelas IEnumerableIEnumeratorEx2 : IEnumerable

{
int [] angka = { 324, 2, 34, 1 };
publik IEnumerator GetEnumerator()
{
foreach ( int i dalam angka)
{
menghasilkan kembali saya;
}
}
publik statis batal Utama()
{
IEnumerableIEnumeratorEx2 ex = baru IEnumerableIEnumeratorEx2
();
IEnumerator rator = ex.GetEnumerator(); //Inumerator
sementara (rator.MoveNext())
{
Konsol .WriteLine(rator.Current);
}

15
 Pelajaran 4 [ ADVANCE PROGRAMMING]

// Kelas array mengimplementasikan IEnumerable

foreach ( int i di ex.number)
{
Konsol .WriteLine(i);
}
Konsol .ReadKey();
}
}

Dapat dimintai permintaan

Setiap kali kami menemukan data yang sangat besar dengan begitu banyak catatan sehingga kami
harus mengurangi overhead dari aplikasi. IQueryable menyiapkan kinerja tinggi dalam situasi seperti
itu (data besar) dengan memfilter data terlebih dahulu dan kemudian mengirimkan data yang difilter
ke klien.

Ikuti "Entity Framework DatabaseFirst " dari ini artikel untuk membuat DBContext

Entitas Akses Data ctx = baru DataAccessEntities ( );

var ctx = baru DataAccessEntities ();

16
 Pelajaran 4 [ ADVANCE PROGRAMMING]

//Perbedaan antara IQueryable dan IEnumerable

//Anda dapat membuat instance IEnumerable dari Daftar

IEnumerable<karyawan> queryIEnumerable = Daftar baru <karyawan >( ) ;

// Bawa SEMUA catatan dari server -> ke klien lalu filter koleksi
//Untuk membawa semua data dari server, Anda harus menghilangkan where cluse dari
linq ke sql
queryIEnumerable = dari m di ctx.Karyawan pilih m;

//Jika Anda menggunakan metode ekstensi where sebagai IEnumerable maka Semua
catatan akan dimuat
queryIEnumerable = queryIEnumerable.Where (x => x.ID == 1 ). DaftarTo ();

//Anda tidak dapat membuat instance IQueryable

IQueryable <karyawan> queryIQueryable =null;

//Bawa hanya SATU catatan dari server --> ke klien

queryIQueryable = (dari m di ctx.Karyawan

dimana m.ID == 1
pilih m);

//Setiap kali Anda memanggil IQueryable jadi ==> Itu akan dieksekusi
this .GridViewIQueryable.DataSource = queryIQueryable.ToList ( );
ini .GridViewIQueryable.DataBind ( );

  Koleksi
ICollection mewarisi dari IEnumerable. Ada satu perbedaan:

Itu dapat menemukan IEnumerable [ i ] --> Berbasis Indeks

17
 Pelajaran 4 [ ADVANCE PROGRAMMING]

TIDAK DAPAT menemukan ICollection [ i ] --> Tidak Berbasis Indeks

// IList {pengindeks dan Modifikasi} vs ICollection {secara acak dan Ubah}

//Koleksi tidak dapat dibuat dari ICollection , jadi harus instantiate dari List

18
 Pelajaran 4 [ ADVANCE PROGRAMMING]

System.Collections.Generic.ICollection <string> strICollection = Daftar baru<string

>( );
strKoleksi. Tambah ( " Mahsa " );
strKoleksi. Tambahkan ( " Hassankashi " );

//Dapat dihitung***
ke dalam ICollectionCount = strICollection.Count ;

this.ListBoxICollection.DataSource = strICollection ;
this.ListBoxICollection.DataBind ( );
Sistem. Teks .StringBuilder str = Sistem baru. Teks .StringBuilder ( );
foreach ( var item dalam strIKoleksi )
{
str.Tambahkan ( " , " + item);
}
this.lblKoleksi. Teks = str.ToString ( );

// Daftar ***
System.Collections.Generic.IList <Employee> objIList = Daftar baru<Karyawan >( );
objIList = ( dari m in ctx.Karyawan
pilih m). DaftarTo ();

Obj karyawan = objIList. Dimana ( i => i.Name == "Sara" ). PertamaOrDefault ();

ke dalam indexofSara = objIList.IndexOf ( obj );
ke dalam cIList = objIList.Count ;

// Koleksi ***
System.Collections.Generic.ICollection <Karyawan> objICollection = Daftar
baru<Karyawan >( );
objICollection = ( dari m in ctx.Karyawan
pilih m). DaftarTo ();
ObjIC karyawan = objICollection. Dimana ( i => i.Name == "Sara" ). PertamaOrDefault ();
//Anda tidak bisa mendapatkan indeks dari objek, jika Anda menghapus komentar dari kode di
bawah ini, muncul kesalahan
// ke dalam indexofSaraICollection = objIC.IndexOf ( objIC );
ke dalam cICollection = objICollection.Count ;

Referensi
msdn.microsoft.com: Jenis Koleksi yang Umum Digunakan
http://www.codeproject.com/Articles/732425/IEnumerable-Vs-IQueryable
http://www.dotnet-tricks.com/Tutorial/linq/I8SY160612-IEnumerable-VS-IQueryable.html
http://www.claudiobernasconi.ch/2013/07/22/when-to-use-ienumerable-icollection-ilist-and-list
http://www.dotnetperls.com/

Tutorial MVC: http://technical.cosmicverse.info/Article/Index/3
Tutorial Lapisan Akses Data: http://technical.cosmicverse.info/Article/Index/4

19