Apa itu reifikasi?

Saya tahu bahwa Java mengimplementasikan parametric polymorphism (Generics) dengan penghapusan. Saya mengerti apa itu penghapusan.

Saya tahu bahwa C # mengimplementasikan polimorfisme parametrik dengan reifikasi. Saya tahu itu bisa membuat Anda menulis

public void dosomething(List<String> input) {}
public void dosomething(List<Int> input) {}

atau bahwa Anda bisa tahu pada saat runtime apa jenis parameter dari beberapa jenis parameterised adalah, tapi saya tidak mengerti apa yang .

• Apa yang dimaksud dengan tipe reified?
• Apa yang dimaksud dengan nilai reified?
• Apa yang terjadi ketika suatu jenis / nilai diverifikasi?

Reifikasi adalah proses mengambil sesuatu yang abstrak dan menciptakan sesuatu yang konkret.

Istilah reifikasi dalam C # generics mengacu pada proses dimana definisi tipe generik dan satu atau lebih argumen tipe generik (hal abstrak) digabungkan untuk membuat tipe generik baru (hal konkret).

Untuk mengatakannya secara berbeda, itu adalah proses mengambil definisi List<T>dan intdan menghasilkan List<int>jenis yang konkret .

Untuk memahaminya lebih lanjut, bandingkan pendekatan berikut:

• Dalam Java generics, definisi tipe generik diubah menjadi dasarnya satu tipe generik konkret yang dibagikan di semua kombinasi argumen tipe yang diizinkan. Dengan demikian, beberapa tipe (level kode sumber) dipetakan ke satu tipe (level biner) - tetapi sebagai hasilnya, informasi tentang argumen tipe instance dihilangkan dalam instance tersebut (tipe erasure) .

  1. Sebagai efek samping dari teknik implementasi ini, satu-satunya argumen tipe generik yang diizinkan secara asli adalah tipe-tipe yang dapat membagikan kode biner dari tipe konkretnya; yang berarti tipe-tipe yang lokasi penyimpanannya memiliki representasi yang dapat dipertukarkan; yang berarti tipe referensi. Menggunakan tipe nilai sebagai argumen tipe umum memerlukan tinju mereka (menempatkan mereka dalam pembungkus tipe referensi sederhana).
  2. Tidak ada kode yang diduplikasi untuk mengimplementasikan obat generik dengan cara ini.
  3. Ketik informasi yang mungkin tersedia saat runtime (menggunakan refleksi) hilang. Ini, pada gilirannya, berarti spesialisasi jenis generik (kemampuan untuk menggunakan kode sumber khusus untuk setiap kombinasi argumen generik tertentu) sangat terbatas.
  4. Mekanisme ini tidak memerlukan dukungan dari lingkungan runtime.
  5. Ada beberapa solusi untuk mempertahankan informasi jenis yang dapat digunakan oleh program Java atau bahasa berbasis JVM.

• Dalam C # generics, definisi tipe generik dipertahankan dalam memori saat runtime. Setiap kali tipe beton baru diperlukan, lingkungan runtime menggabungkan definisi tipe generik dan argumen tipe dan membuat tipe baru (reifikasi). Jadi kita mendapatkan tipe baru untuk setiap kombinasi argumen tipe, saat runtime .

  1. Teknik implementasi ini memungkinkan segala jenis kombinasi argumen jenis akan dipakai. Menggunakan tipe nilai sebagai argumen tipe umum tidak menyebabkan tinju, karena tipe ini mendapatkan implementasinya sendiri. ( Tinju masih ada di C # , tentu saja - tetapi itu terjadi dalam skenario lain, bukan yang ini.)
  2. Duplikasi kode bisa menjadi masalah - tetapi dalam praktiknya tidak, karena implementasi yang cukup pintar ( ini termasuk Microsoft .NET dan Mono ) dapat berbagi kode untuk beberapa contoh.
  3. Informasi tipe dipertahankan, yang memungkinkan spesialisasi sampai batas tertentu, dengan memeriksa argumen tipe menggunakan refleksi. Namun, tingkat spesialisasi terbatas, sebagai akibat dari kenyataan bahwa definisi tipe generik dikompilasi sebelum reifikasi terjadi (ini dilakukan dengan menyusun definisi terhadap kendala pada parameter tipe - dengan demikian, kompiler harus dapat "mengerti" definisi bahkan tanpa adanya tipe argumen tertentu ).
  4. Teknik implementasi ini sangat bergantung pada dukungan runtime dan kompilasi JIT (itulah sebabnya Anda sering mendengar bahwa generik C # memiliki beberapa batasan pada platform seperti iOS , di mana pembuatan kode dinamis dibatasi).
  5. Dalam konteks generik C #, reifikasi dilakukan untuk Anda oleh lingkungan runtime. Namun, jika Anda ingin lebih memahami perbedaan antara definisi tipe generik dan tipe generik konkret, Anda selalu dapat melakukan reifikasi sendiri, menggunakan System.Typekelas (bahkan jika kombinasi argumen tipe generik tertentu yang Anda instantiating tidak t muncul dalam kode sumber Anda secara langsung).

• Dalam template C ++, definisi template dipertahankan dalam memori pada waktu kompilasi. Setiap kali instantiasi baru dari tipe templat diperlukan dalam kode sumber, kompiler menggabungkan definisi templat dan argumen templat dan membuat tipe baru. Jadi kami mendapatkan tipe unik untuk setiap kombinasi argumen template, pada waktu kompilasi .

  1. Teknik implementasi ini memungkinkan segala jenis kombinasi argumen jenis akan dipakai.
  2. Ini dikenal untuk menggandakan kode biner tetapi rantai-alat yang cukup pintar masih bisa mendeteksi ini dan membagikan kode untuk beberapa contoh.
  3. Definisi templat itu sendiri tidak "dikompilasi" - hanya instantiasinya yang konkret yang benar-benar dikompilasi . Ini menempatkan lebih sedikit kendala pada kompiler dan memungkinkan tingkat spesialisasi templat yang lebih besar .
  4. Karena contoh template dilakukan pada waktu kompilasi, tidak ada dukungan runtime yang diperlukan di sini juga.
  5. Proses ini belakangan disebut sebagai monomorphization , terutama di komunitas Rust. Kata ini digunakan berbeda dengan polimorfisme parametrik , yang merupakan nama konsep dari mana obat generik berasal.

Reifikasi berarti secara umum (di luar ilmu komputer) "untuk membuat sesuatu yang nyata".

Dalam pemrograman, sesuatu dibenarkan jika kita dapat mengakses informasi dalam bahasa itu sendiri.

Untuk dua contoh yang sepenuhnya tidak berhubungan dengan generik tentang sesuatu yang C # lakukan dan tidak miliki terverifikasi, mari kita ambil metode dan akses memori.

Bahasa OO umumnya memiliki metode , (dan banyak yang tidak memiliki fungsi yang serupa meskipun tidak terikat ke kelas). Karena itu, Anda dapat menentukan metode dalam bahasa tersebut, menyebutnya, mungkin menimpanya, dan sebagainya. Tidak semua bahasa tersebut memungkinkan Anda menangani metode itu sendiri sebagai data untuk suatu program. C # (dan benar-benar, .NET, bukan C #) memungkinkan Anda menggunakan MethodInfoobjek yang mewakili metode, jadi dalam metode C # diverifikasi. Metode dalam C # adalah "objek kelas satu".

Semua bahasa praktis memiliki beberapa cara untuk mengakses memori komputer. Dalam bahasa tingkat rendah seperti C, kita bisa berurusan langsung dengan pemetaan antara alamat numerik yang digunakan oleh komputer, jadi suka int* ptr = (int*) 0xA000000; *ptr = 42;itu masuk akal (selama kita punya alasan yang bagus untuk mencurigai bahwa mengakses alamat memori 0xA000000dengan cara ini tidak akan menang ' t meledakkan sesuatu). Dalam C # ini tidak masuk akal (kita bisa memaksakannya dalam. NET, tetapi dengan manajemen memori .NET memindahkan hal-hal di sekitar itu tidak mungkin berguna). C # tidak memiliki alamat memori terverifikasi.

Jadi, sebagaimana ditolak berarti "menjadi nyata", "jenis yang ditegaskan" adalah jenis yang dapat kita "bicarakan" dalam bahasa yang dimaksud.

Dalam generik ini berarti dua hal.

Salah satunya adalah bahwa List<string>adalah jenis seperti stringatau intyang. Kita dapat membandingkan jenis itu, mendapatkan namanya, dan menanyakannya:

Console.WriteLine(typeof(List<string>).FullName); // System.Collections.Generic.List`1[[System.String, mscorlib, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089]]
Console.WriteLine(typeof(List<string>) == (42).GetType()); // False
Console.WriteLine(typeof(List<string>) == Enumerable.Range(0, 1).Select(i => i.ToString()).ToList().GetType()); // True
Console.WriteLine(typeof(List<string>).GenericTypeArguments[0] == typeof(string)); // True

Konsekuensi dari hal ini adalah bahwa kita dapat "berbicara tentang" tipe parameter metode generik (atau metode kelas generik) dalam metode itu sendiri:

public static void DescribeType<T>(T element)
{
  Console.WriteLine(typeof(T).FullName);
}
public static void Main()
{
  DescribeType(42);               // System.Int32
  DescribeType(42L);              // System.Int64
  DescribeType(DateTime.UtcNow);  // System.DateTime
}

Sebagai aturan, melakukan ini terlalu "bau", tetapi memiliki banyak kasus yang bermanfaat. Sebagai contoh, lihat:

public static TSource Min<TSource>(this IEnumerable<TSource> source)
{
  if (source == null) throw Error.ArgumentNull("source");
  Comparer<TSource> comparer = Comparer<TSource>.Default;
  TSource value = default(TSource);
  if (value == null)
  {
    using (IEnumerator<TSource> e = source.GetEnumerator())
    {
      do
      {
        if (!e.MoveNext()) return value;
        value = e.Current;
      } while (value == null);
      while (e.MoveNext())
      {
        TSource x = e.Current;
        if (x != null && comparer.Compare(x, value) < 0) value = x;
      }
    }
  }
  else
  {
    using (IEnumerator<TSource> e = source.GetEnumerator())
    {
      if (!e.MoveNext()) throw Error.NoElements();
      value = e.Current;
      while (e.MoveNext())
      {
        TSource x = e.Current;
        if (comparer.Compare(x, value) < 0) value = x;
      }
    }
  }
  return value;
}

Ini tidak melakukan banyak perbandingan antara jenis TSourcedan berbagai jenis untuk perilaku yang berbeda (umumnya merupakan tanda bahwa Anda seharusnya tidak menggunakan obat generik sama sekali), tetapi memang memecah antara jalur kode untuk jenis yang dapat null(harus kembali nulljika tidak ada elemen yang ditemukan, dan tidak boleh membuat perbandingan untuk menemukan minimum jika salah satu elemen dibandingkan adalah null) dan jalur kode untuk tipe yang tidak dapat null(harus dibuang jika tidak ada elemen yang ditemukan, dan tidak perlu khawatir tentang kemungkinan nullelemen ).

Karena TSource"nyata" dalam metode ini, perbandingan ini dapat dibuat baik pada saat runtime atau waktu jitting (umumnya waktu jitting, tentu saja kasus di atas akan melakukannya pada waktu jitting dan tidak menghasilkan kode mesin untuk jalur yang tidak diambil) dan kami memiliki pisahkan versi "nyata" dari metode untuk setiap kasus. (Meskipun sebagai optimasi, kode mesin dibagikan untuk metode yang berbeda untuk parameter tipe tipe referensi yang berbeda, karena dapat tanpa mempengaruhi ini, dan karenanya kita dapat mengurangi jumlah kode mesin yang dipasangkan).

(Tidak umum untuk berbicara tentang reifikasi tipe generik dalam C # kecuali jika Anda juga berurusan dengan Java, karena dalam C # kami hanya menerima reifikasi ini; semua tipe diverifikasi. Di Jawa, tipe non-generik disebut sebagai reified karena itu adalah perbedaan antara mereka dan tipe generik).

Seperti yang sudah dicatat oleh duffymo, "reifikasi" bukanlah perbedaan utama.

Di Jawa, obat generik pada dasarnya ada untuk meningkatkan dukungan waktu kompilasi - ini memungkinkan Anda untuk menggunakan koleksi mis. Yang diketik dalam kode Anda, dan mengatur keselamatan jenis untuk Anda. Namun, ini hanya ada pada waktu kompilasi - kode kode yang dikompilasi tidak lagi memiliki pengertian generik; semua tipe generik ditransformasikan menjadi tipe "konkret" (menggunakan objectjika tipe generik tidak terikat), menambahkan konversi tipe dan memeriksa jenis sesuai kebutuhan.

Dalam .NET, obat generik adalah fitur integral dari CLR. Saat Anda mengompilasi tipe generik, itu tetap generik di IL yang dihasilkan. Bukan hanya ditransformasikan menjadi kode non-generik seperti di Jawa.

Ini memiliki beberapa dampak pada bagaimana obat generik bekerja dalam praktiknya. Sebagai contoh:

• Java harus SomeType<?>mengizinkan Anda untuk melewati implementasi konkret dari tipe generik yang diberikan. C # tidak dapat melakukan ini - setiap tipe generik spesifik ( reified ) adalah tipenya sendiri.
• Tipe generik tidak terbatas di Jawa berarti nilainya disimpan sebagai object. Ini dapat memiliki dampak kinerja ketika menggunakan tipe nilai dalam obat generik tersebut. Di C #, ketika Anda menggunakan tipe nilai dalam tipe generik, itu tetap tipe nilai.

Untuk memberikan sampel, anggap Anda memiliki Listtipe generik dengan satu argumen generik. Di Jawa, List<String>dan List<Int>pada akhirnya akan menjadi tipe yang sama persis saat runtime - tipe generik hanya benar-benar ada untuk kode waktu kompilasi. Semua panggilan ke mis GetValueakan ditransformasikan ke (String)GetValuedan (Int)GetValuemasing - masing.

Dalam C #, List<string>dan List<int>ada dua jenis yang berbeda. Mereka tidak dapat dipertukarkan, dan keamanan jenisnya juga diberlakukan pada saat runtime. Tidak peduli apa yang Anda lakukan, new List<int>().Add("SomeString")akan tidak pernah bekerja - penyimpanan yang mendasari dalam List<int>adalah benar-benar beberapa array integer, sedangkan di Jawa, maka perlu sebuah objectarray yang. Di C #, tidak ada pemain yang terlibat, tidak ada tinju dll.

Ini juga harus menjelaskan mengapa C # tidak dapat melakukan hal yang sama dengan Java SomeType<?>. Di Jawa, semua tipe generik "berasal dari" SomeType<?>akhirnya menjadi tipe yang sama persis. Dalam C #, semua berbagai spesifik SomeType<T>adalah tipe mereka sendiri. Menghapus pemeriksaan waktu kompilasi, dimungkinkan untuk lulus SomeType<Int>alih-alih SomeType<String>(dan sebenarnya, semua itu SomeType<?>artinya "abaikan pemeriksaan waktu kompilasi untuk jenis generik yang diberikan"). Dalam C #, itu tidak mungkin, bahkan untuk tipe turunan (yaitu, Anda tidak dapat melakukannya List<object> list = (List<object>)new List<string>();meskipun stringberasal dari object).

Kedua implementasi memiliki pro dan kontra. Sudah ada beberapa kali ketika saya ingin bisa membiarkan hanya SomeType<?>sebagai argumen dalam C # - tetapi itu tidak masuk akal cara kerja C # generics.

Reifikasi adalah konsep pemodelan berorientasi objek.

Reify adalah kata kerja yang berarti "membuat sesuatu abstrak nyata" .

Ketika Anda melakukan pemrograman berorientasi objek, biasanya memodelkan objek dunia nyata sebagai komponen perangkat lunak (misalnya Window, Button, Person, Bank, Vehicle, dll.)

Juga umum untuk merevisi konsep abstrak menjadi komponen juga (misalnya WindowListener, Broker, dll.)