Contoh ( perhatikan kasusnya ):

string s = "Hello world!";
String s = "Hello world!";

Apa pedoman untuk penggunaan masing-masing? Dan apa perbedaannya?

stringadalah alias dalam C # untuk System.String.
Jadi secara teknis, tidak ada perbedaan. Ini seperti int vs System.Int32 .

Sejauh pedoman, umumnya disarankan untuk menggunakan stringsetiap kali Anda merujuk ke suatu objek.

misalnya

string place = "world";

Demikian juga, saya pikir ini umumnya direkomendasikan untuk digunakan Stringjika Anda perlu merujuk secara khusus ke kelas.

misalnya

string greet = String.Format("Hello {0}!", place);

Ini adalah gaya yang cenderung digunakan Microsoft dalam contoh mereka .

Tampaknya panduan di area ini mungkin telah berubah, karena StyleCop sekarang memberlakukan penggunaan alias khusus C #.

Demi kelengkapan, berikut adalah kumpulan informasi terkait ...

Seperti yang telah dicatat orang lain, stringadalah alias untuk System.String. Mereka mengkompilasi ke kode yang sama, sehingga pada waktu eksekusi tidak ada perbedaan apa pun. Ini hanyalah salah satu dari alias di C #. Daftar lengkapnya adalah:

object:  System.Object
string:  System.String
bool:    System.Boolean
byte:    System.Byte
sbyte:   System.SByte
short:   System.Int16
ushort:  System.UInt16
int:     System.Int32
uint:    System.UInt32
long:    System.Int64
ulong:   System.UInt64
float:   System.Single
double:  System.Double
decimal: System.Decimal
char:    System.Char

Terlepas dari stringdan object, alias semua untuk tipe nilai. decimaladalah tipe nilai, tetapi bukan tipe primitif di CLR. Satu-satunya tipe primitif yang tidak memiliki alias adalah System.IntPtr.

Dalam spec, alias tipe nilai dikenal sebagai "tipe sederhana". Literal dapat digunakan untuk nilai konstan dari setiap tipe sederhana; tidak ada tipe nilai lain yang memiliki bentuk literal tersedia. (Bandingkan ini dengan VB, yang memungkinkan DateTimeliteral, dan juga memiliki alias untuk itu.)

Ada satu keadaan di mana Anda harus menggunakan alias: ketika secara eksplisit menentukan jenis enum yang mendasarinya. Contohnya:

public enum Foo : UInt32 {} // Invalid
public enum Bar : uint   {} // Valid

Itu hanya soal cara spec mendefinisikan enum deklarasi - bagian setelah usus besar harus menjadi terpisahkan-jenis produksi, yang merupakan salah satu tanda sbyte, byte, short, ushort, int, uint, long, ulong, char... sebagai lawan jenis produksi digunakan oleh deklarasi variabel misalnya. Itu tidak menunjukkan perbedaan lainnya.

Akhirnya, ketika tiba saatnya untuk menggunakan: secara pribadi saya menggunakan alias di mana-mana untuk implementasi, tetapi tipe CLR untuk API apa pun. Ini benar-benar tidak terlalu penting yang Anda gunakan dalam hal implementasi - konsistensi di antara tim Anda bagus, tetapi tidak ada orang lain yang peduli. Di sisi lain, itu benar-benar penting bahwa jika Anda merujuk pada jenis dalam API, Anda melakukannya dengan cara yang netral bahasa. Metode yang disebut ReadInt32tidak ambigu, sedangkan metode yang disebut ReadIntmembutuhkan interpretasi. Penelepon dapat menggunakan bahasa yang mendefinisikan intalias untuk Int16, misalnya. Desainer .NET framework telah mengikuti pola ini, contoh yang bagus ada di BitConverter, BinaryReaderdan Convertkelas.

Stringsingkatan System.Stringdan itu adalah tipe .NET Framework. stringadalah alias dalam bahasa C # untuk System.String. Keduanya dikompilasi System.Stringdalam IL (Intermediate Language), sehingga tidak ada perbedaan. Pilih apa yang Anda suka dan gunakan itu. Jika Anda kode dalam C #, saya lebih suka stringkarena ini adalah alias tipe C # dan terkenal oleh programmer C #.

Saya dapat mengatakan hal yang sama tentang ( int, System.Int32) dll.

Jawaban terbaik yang pernah saya dengar tentang menggunakan alias tipe yang disediakan di C # berasal dari Jeffrey Richter dalam bukunya CLR Via C # . Berikut 3 alasannya:

• Saya telah melihat sejumlah pengembang bingung, tidak tahu apakah akan menggunakan string atau String dalam kode mereka. Karena dalam C # string (kata kunci) memetakan dengan tepat ke System.String (tipe FCL), tidak ada perbedaan dan keduanya dapat digunakan.
• Dalam C #, peta panjang ke System.Int64 , tetapi dalam bahasa pemrograman yang berbeda, panjang bisa memetakan ke Int16 atau Int32 . Bahkan, C ++ / CLI sebenarnya memperlakukan selama sebagai Int32 . Seseorang yang membaca kode sumber dalam satu bahasa dapat dengan mudah salah mengartikan maksud kode jika ia terbiasa pemrograman dalam bahasa pemrograman yang berbeda. Bahkan, sebagian besar bahasa bahkan tidak akan memperlakukan lama sebagai kata kunci dan tidak akan mengkompilasi kode yang menggunakannya.
• FCL memiliki banyak metode yang memiliki nama ketik sebagai bagian dari nama metode mereka. Misalnya, tipe BinaryReader menawarkan metode seperti ReadBoolean , ReadInt32 , ReadSingle , dan seterusnya, dan tipe System.Convert menawarkan metode seperti ToBoolean , ToInt32 , ToSingle , dan sebagainya. Meskipun legal untuk menulis kode berikut, baris dengan float terasa sangat tidak wajar bagi saya, dan tidak jelas bahwa baris tersebut benar:

BinaryReader br = new BinaryReader(...);
float val  = br.ReadSingle(); // OK, but feels unnatural
Single val = br.ReadSingle(); // OK and feels good

Jadi begitulah. Saya pikir ini semua adalah poin yang sangat bagus. Namun, saya tidak menemukan diri saya menggunakan saran Jeffrey dalam kode saya sendiri. Mungkin saya terlalu terjebak dalam dunia C # saya tetapi akhirnya saya mencoba membuat kode saya terlihat seperti kode kerangka kerja.

stringadalah kata yang dilindungi undang-undang, tetapi Stringhanya nama kelas. Ini berarti bahwa stringtidak dapat digunakan sebagai nama variabel dengan sendirinya.

Jika karena alasan tertentu Anda menginginkan variabel yang disebut string , Anda hanya akan melihat yang pertama dari kompilasi ini:

StringBuilder String = new StringBuilder();  // compiles
StringBuilder string = new StringBuilder();  // doesn't compile 

Jika Anda benar-benar menginginkan nama variabel yang disebut string, Anda dapat menggunakan @awalan:

StringBuilder @string = new StringBuilder();

Perbedaan kritis lainnya: Stack Overflow menyoroti mereka secara berbeda.

Ada satu perbedaan - Anda tidak dapat menggunakannya Stringtanpa using System;sebelumnya.

Sudah dibahas di atas; Namun, Anda tidak dapat menggunakan stringrefleksi; kamu harus menggunakan String.

System.Stringadalah kelas .NET string - di C # stringadalah alias untuk System.String- jadi saat digunakan keduanya sama.

Adapun pedoman saya tidak akan terlalu macet dan hanya menggunakan mana pun yang Anda suka - ada hal-hal yang lebih penting dalam hidup dan kode akan tetap sama.

Jika Anda menemukan diri sistem di mana perlu membangun untuk menentukan ukuran bilangan bulat yang Anda gunakan dan begitu cenderung digunakan Int16, Int32, UInt16, UInt32dll maka mungkin terlihat lebih alami untuk menggunakan String- dan ketika bergerak di sekitar antara bahasa .net yang berbeda itu mungkin membuat hal-hal lebih dimengerti - kalau tidak saya akan menggunakan string dan int.

Saya lebih suka .NETjenis huruf besar (daripada alias) untuk alasan pemformatan. The .NETjenis berwarna sama dengan jenis objek lain (jenis nilai adalah objek yang tepat, setelah semua).

Kata kunci bersyarat dan kontrol (seperti if,, switchdan return) adalah huruf kecil dan berwarna biru tua (secara default). Dan saya lebih suka tidak memiliki perbedaan pendapat dalam penggunaan dan format.

Mempertimbangkan:

String someString; 
string anotherString; 

stringdan Stringidentik dalam semua hal (kecuali huruf besar "S"). Tidak ada implikasi kinerja.

Huruf kecil stringlebih disukai di sebagian besar proyek karena penyorotan sintaksis

C # adalah bahasa yang digunakan bersama dengan CLR.

string adalah tipe dalam C #.

System.String adalah tipe dalam CLR.

Ketika Anda menggunakan C # bersama dengan CLR stringakan dipetakan ke System.String.

Secara teoritis, Anda bisa mengimplementasikan kompiler C # yang menghasilkan bytecode Java. Implementasi masuk akal dari kompiler ini mungkin akan memetakan stringke java.lang.Stringdalam rangka untuk beroperasi dengan runtime library Java.

Video YouTube ini menunjukkan secara praktis perbedaannya.

Tapi sekarang untuk jawaban tekstual yang panjang.

Ketika kita berbicara tentang .NETada dua hal yang berbeda satu ada .NETkerangka kerja dan yang lainnya ada bahasa ( C#, VB.NETdll) yang menggunakan kerangka itu.

" System.String" alias "String" (huruf kapital "S") adalah .NETtipe data kerangka kerja sedangkan "string" adalah C#tipe data.

Singkatnya "String" adalah alias (hal yang sama disebut dengan nama yang berbeda) dari "string". Jadi secara teknis kedua pernyataan kode di bawah ini akan memberikan hasil yang sama.

String s = "I am String";

atau

string s = "I am String";

Dengan cara yang sama ada alias untuk tipe data c # lainnya seperti yang ditunjukkan di bawah ini: -

objek: System.Object, String: System.String, bool: System.Boolean, byte: System.Byte, sbyte: System.SByte, pendek: System.Int16dan sebagainya

Sekarang pertanyaan jutaan dolar dari sudut pandang programmer Jadi kapan harus menggunakan "String" dan "string"?

Hal pertama untuk menghindari kebingungan gunakan salah satunya secara konsisten. Tetapi dari perspektif praktik terbaik ketika Anda melakukan deklarasi variabel, ada baiknya menggunakan "string" (kecil "s") dan ketika Anda menggunakannya sebagai nama kelas maka "String" (huruf kapital "S") lebih disukai.

Dalam kode di bawah ini, sisi kiri adalah deklarasi variabel dan dinyatakan menggunakan "string". Di sisi kanan kita memanggil metode sehingga "String" lebih masuk akal.

string s = String.ToUpper() ;

Huruf kecil stringadalah alias untuk System.String. Mereka sama di C#.

Ada perdebatan apakah Anda harus menggunakan jenis Sistem ( System.Int32, System.String, dll) jenis atau C# aliases( int, string, dll). Saya pribadi percaya Anda harus menggunakan C# aliases, tapi itu hanya preferensi pribadi saya.

stringhanyalah alias untuk System.String. Kompiler akan memperlakukan mereka secara identik.

Satu-satunya perbedaan praktis adalah penyorotan sintaksis seperti yang Anda sebutkan, dan bahwa Anda harus menulis using Systemjika Anda menggunakannya String.

Keduanya sama. Tapi dari perspektif pedoman pengkodean lebih baik digunakan stringdaripada String. Inilah yang umumnya digunakan pengembang. mis. alih-alih menggunakan, Int32kami menggunakan intapa intadanya alias untukInt32

FYI "String kata kunci hanyalah alias untuk kelas yang telah ditentukan System.String." - C # Bahasa Spesifikasi 4.2.3 http://msdn2.microsoft.com/En-US/library/aa691153.aspx

Seperti yang dikatakan orang lain, mereka sama. Aturan StyleCop, secara default, akan menegakkan Anda untuk menggunakan stringsebagai gaya kode C # praktek terbaik, kecuali ketika referensi System.Stringfungsi statis, seperti String.Format, String.Join, String.Concat, dll ...

Jawaban baru setelah 6 tahun dan 5 bulan (penundaan).

Meskipun stringkata kunci C # yang dilindungi undang-undang yang selalu memiliki makna tetap, Stringhanyalah pengidentifikasi biasa yang dapat merujuk pada apa pun. Bergantung pada anggota tipe saat ini, namespace saat ini dan usingarahan yang diterapkan serta penempatannya, Stringdapat berupa nilai atau tipe yang berbeda global::System.String.

Saya akan memberikan dua contoh di mana usingarahan tidak akan membantu .

Pertama, ketika Stringadalah nilai dari jenis saat ini (atau variabel lokal):

class MySequence<TElement>
{
  public IEnumerable<TElement> String { get; set; }

  void Example()
  {
    var test = String.Format("Hello {0}.", DateTime.Today.DayOfWeek);
  }
}

Di atas tidak akan dikompilasi karena IEnumerable<>tidak memiliki anggota non-statis yang dipanggil Format, dan tidak ada metode ekstensi yang berlaku. Dalam kasus di atas, masih mungkin untuk digunakan Stringdalam konteks lain di mana jenis adalah satu-satunya kemungkinan secara sintaksis. Misalnya String local = "Hi mum!";bisa OK (tergantung namespace dan usingarahan).

Lebih buruk: Mengatakan String.Concat(someSequence)kemungkinan akan (tergantung pada usings) pergi ke metode ekstensi Linq Enumerable.Concat. Itu tidak akan pergi ke metode statis string.Concat.

Kedua, kapan tipeString lain , bersarang di dalam tipe saat ini:

class MyPiano
{
  protected class String
  {
  }

  void Example()
  {
    var test1 = String.Format("Hello {0}.", DateTime.Today.DayOfWeek);
    String test2 = "Goodbye";
  }
}

Tidak ada pernyataan dalam Examplemetode yang dikompilasi. Berikut Stringselalu piano tali , MyPiano.String. Tidak ada anggota ( staticatau tidak) Formatada di sana (atau diwarisi dari kelas dasarnya). Dan nilainya "Goodbye"tidak dapat dikonversi ke dalamnya.

Menggunakan tipe Sistem memudahkan untuk melakukan porting antara C # dan VB.Net, jika Anda menyukai hal-hal seperti itu.

Terhadap apa yang tampaknya menjadi praktik umum di kalangan programmer lain, saya lebih suka Stringlebih string, hanya untuk menyoroti fakta bahwa Stringadalah tipe referensi, seperti Jon Skeet disebutkan.

stringadalah alias (atau singkatan) dari System.String. Itu berarti, dengan mengetik yang stringkami maksud System.String. Anda dapat membaca lebih lanjut di tautan think: 'string' adalah alias / singkatan dari System.String.

Saya hanya ingin menambahkan ini ke jawaban lfousts, dari buku Ritchers:

Spesifikasi bahasa C # menyatakan, "Sebagai masalah gaya, penggunaan kata kunci lebih disukai daripada penggunaan nama tipe sistem yang lengkap." Saya tidak setuju dengan spesifikasi bahasa; Saya lebih suka menggunakan nama tipe FCL dan sepenuhnya menghindari nama tipe primitif. Bahkan, saya berharap bahwa kompiler bahkan tidak menawarkan nama tipe primitif dan memaksa pengembang untuk menggunakan nama tipe FCL sebagai gantinya. Inilah alasan saya:

• Saya telah melihat sejumlah pengembang bingung, tidak tahu apakah akan menggunakan string atau String dalam kode mereka. Karena dalam string C # (kata kunci) memetakan dengan tepat ke System.String (tipe FCL), tidak ada perbedaan dan keduanya dapat digunakan. Demikian pula, saya pernah mendengar beberapa pengembang mengatakan bahwa int mewakili integer 32-bit ketika aplikasi berjalan pada OS 32-bit dan bahwa itu mewakili integer 64-bit ketika aplikasi berjalan pada OS 64-bit. Pernyataan ini benar-benar salah: di C #, int selalu memetakan ke System.Int32 , dan karena itu mewakili integer 32-bit terlepas dari OS yang dijalankan oleh kode. Jika programmer akan menggunakanInt32 dalam kode mereka, maka potensi kebingungan ini juga dihilangkan.

• Dalam C #, peta panjang ke System.Int64 , tetapi dalam bahasa pemrograman yang berbeda, panjang bisa memetakan ke Int16 atau Int32 . Bahkan, C ++ / CLI memperlakukan selama sebagai Int32 . Seseorang yang membaca kode sumber dalam satu bahasa dapat dengan mudah salah mengartikan maksud kode jika ia terbiasa pemrograman dalam bahasa pemrograman yang berbeda. Bahkan, sebagian besar bahasa bahkan tidak akan memperlakukan lama sebagai kata kunci dan tidak akan mengkompilasi kode yang menggunakannya.

• FCL memiliki banyak metode yang memiliki nama ketik sebagai bagian dari nama metode mereka. Misalnya, tipe BinaryReader menawarkan metode seperti ReadBoolean , ReadInt32 , ReadSingle , dan seterusnya, dan tipe System.Convert menawarkan metode seperti ToBoolean , ToInt32 , ToSingle , dan sebagainya. Meskipun legal untuk menulis kode berikut, baris dengan float terasa sangat tidak wajar bagi saya, dan tidak jelas bahwa baris tersebut benar:

  BinaryReader br = new BinaryReader(...);
  float val = br.ReadSingle(); // OK, but feels unnatural
  Single val = br.ReadSingle(); // OK and feels good

• Banyak programmer yang menggunakan C # secara eksklusif cenderung lupa bahwa bahasa pemrograman lain dapat digunakan terhadap CLR, dan karena itu, C # -isms merayap ke dalam kode perpustakaan kelas. Misalnya, Microsoft FCL hampir secara eksklusif ditulis dalam C # dan pengembang di tim FCL sekarang telah memperkenalkan metode ke perpustakaan seperti Array 's GetLongLength , yang mengembalikan nilai Int64 yang panjang dalam C # tetapi tidak dalam bahasa lain (seperti C ++ / CLI). Contoh lain adalah System.Linq.Enumerable ‘s LongCount metode.

Saya tidak mendapatkan pendapatnya sebelum saya membaca paragraf lengkap.

String ( System.String) adalah kelas di pustaka kelas dasar. string (huruf kecil) adalah karya yang disediakan di C # yang merupakan alias untuk System.String. Int32 vs int adalah situasi yang sama Boolean vs. bool. Kata kunci spesifik bahasa C # ini memungkinkan Anda untuk mendeklarasikan primitif dalam gaya yang mirip dengan C.

Stringbukan kata kunci dan dapat digunakan sebagai Identifier sedangkan stringkata kunci dan tidak dapat digunakan sebagai Identifier. Dan dalam sudut pandang fungsi keduanya sama.

Ini masalah konvensi, sungguh. stringhanya lebih mirip gaya C / C ++. Konvensi umum adalah untuk menggunakan cara pintas apa pun yang telah disediakan bahasa pilihan Anda (int / Int untuk Int32). Ini berlaku untuk "objek" dan decimaljuga.

Secara teoritis ini dapat membantu untuk port kode ke beberapa standar 64-bit di masa depan di mana "int" mungkin berarti Int64, tapi bukan itu intinya, dan saya akan mengharapkan panduan upgrade untuk mengubah intreferensi apa pun untuk Int32tetap aman.

Datang terlambat ke pesta: Saya menggunakan tipe CLR 100% dari waktu (well, kecuali jika dipaksa untuk menggunakan tipe C #, tapi saya tidak ingat kapan terakhir kali itu).

Saya awalnya mulai melakukan ini tahun lalu, sesuai buku CLR oleh Ritchie. Masuk akal bagi saya bahwa semua bahasa CLR pada akhirnya harus dapat mendukung set tipe CLR, jadi menggunakan tipe CLR sendiri memberikan kode yang lebih jelas, dan mungkin lebih "dapat digunakan kembali".

Sekarang saya sudah melakukannya selama bertahun-tahun, itu kebiasaan dan saya suka warna yang ditunjukkan VS untuk tipe CLR.

Satu-satunya downer nyata adalah bahwa lengkapi-otomatis menggunakan tipe C #, jadi saya akhirnya mengetik ulang tipe yang dihasilkan secara otomatis untuk menentukan tipe CLR.

Juga, sekarang, ketika saya melihat "int" atau "string", itu hanya terlihat sangat salah bagi saya, seperti saya sedang melihat kode C tahun 1970-an.

Tidak ada perbedaan.

Kata kunci C # stringmemetakan untuk tipe .NET System.String- ini adalah alias yang mempertahankan konvensi penamaan bahasa.

Demikian pula intpeta untuk System.Int32.

Ada kutipan tentang masalah ini dari buku Daniel Solis .

Semua tipe standar telah dipetakan langsung ke tipe .NET yang mendasarinya. Nama tipe C # (string) hanyalah alias untuk tipe .NET (String atau System.String), jadi menggunakan nama .NET berfungsi dengan baik secara sintaksis, meskipun ini tidak disarankan. Di dalam program C #, Anda harus menggunakan nama C # daripada nama .NET.

string adalah kata kunci, dan Anda tidak dapat menggunakan string sebagai pengidentifikasi.

String bukan kata kunci, dan Anda dapat menggunakannya sebagai pengidentifikasi:

Contoh

string String = "I am a string";

Kata kunci string adalah alias untuk System.Stringselain dari masalah kata kunci, keduanya persis sama.

 typeof(string) == typeof(String) == typeof(System.String)

Ya, tidak ada perbedaan di antara mereka, sama seperti booldan Boolean.

@JaredPar (pengembang pada kompiler C # dan pengguna SO yang produktif!) Menulis posting blog yang bagus tentang masalah ini. Saya pikir layak untuk dibagikan di sini. Ini adalah perspektif yang bagus tentang masalah kita.

stringvs Stringbukan debat gaya

[...]

Kata kunci stringmemiliki makna konkret dalam C #. Ini adalah tipe System.Stringyang ada dalam perakitan runtime inti. Runtime secara intrinsik memahami tipe ini dan menyediakan kapabilitas yang diharapkan pengembang untuk string dalam .NET. Keberadaannya sangat penting bagi C # sehingga jika tipe itu tidak ada, kompiler akan keluar sebelum mencoba untuk menguraikan baris kode. Karenanya stringmemiliki makna yang tepat dan tidak ambigu dalam kode C #.

Identifier Stringtidak memiliki arti konkret dalam C #. Ini adalah pengidentifikasi yang melewati semua aturan pencarian nama seperti Widget,, Studentdll ... Itu bisa mengikat string atau bisa mengikat ke jenis di majelis lain seluruhnya yang tujuannya mungkin sama sekali berbeda dari string. Lebih buruk lagi dapat didefinisikan sedemikian rupa sehingga kode seperti String s = "hello"; terus mengkompilasi.

class TricksterString { 
  void Example() {
    String s = "Hello World"; // Okay but probably not what you expect.
  }
}

class String {
  public static implicit operator String(string s) => null;
}

Arti sebenarnya Stringakan selalu tergantung pada resolusi nama. Itu artinya tergantung pada semua file sumber dalam proyek dan semua jenis yang ditentukan dalam semua rujukan yang direferensikan. Singkatnya itu membutuhkan sedikit konteks untuk mengetahui apa artinya.

Benar bahwa dalam sebagian besar kasus Stringdan stringakan mengikat ke jenis yang sama. Tetapi menggunakan Stringpengembang diam berarti membiarkan program mereka untuk interpretasi di tempat-tempat di mana hanya ada satu jawaban yang benar. Ketika Stringmengikat ke jenis yang salah itu dapat meninggalkan pengembang debug selama berjam-jam, pengarsipan bug pada tim kompiler dan umumnya membuang-buang waktu yang bisa diselamatkan dengan menggunakan string.

Cara lain untuk memvisualisasikan perbedaan adalah dengan sampel ini:

string s1 = 42; // Errors 100% of the time  
String s2 = 42; // Might error, might not, depends on the code

Banyak yang akan berpendapat bahwa sementara ini informasi yang akurat secara teknis, penggunaannya Stringmasih baik karena sangat jarang bahwa basis kode akan menentukan jenis nama ini. Atau bahwa ketika Stringdidefinisikan itu adalah pertanda basis kode yang buruk.

[...]

Anda akan melihat bahwa Stringdidefinisikan untuk sejumlah tujuan yang sepenuhnya valid: pembantu refleksi, pustaka serialisasi, pustaka, protokol, dll. Untuk pustaka ini Stringvs. stringmemiliki konsekuensi nyata tergantung pada tempat kode digunakan.

Jadi ingat ketika Anda melihat perdebatan Stringvs. stringini tentang semantik, bukan gaya. Memilih string memberikan makna yang tajam untuk basis kode Anda. Memilih Stringtidak salah tetapi membiarkan pintu terbuka untuk kejutan di masa depan.

Catatan: Saya menyalin / menempel sebagian besar posting blog karena alasan arsip. Saya mengabaikan beberapa bagian, jadi saya sarankan untuk melewati dan membaca posting blog jika Anda bisa.