Dalam C #, haruskah saya menggunakan string.Empty atau String.Empty atau "" untuk menginisialisasi string?

Dalam C #, saya ingin menginisialisasi nilai string dengan string kosong.

Bagaimana saya harus melakukan ini? Apa jalan yang benar, dan mengapa?

string willi = string.Empty;

atau

string willi = String.Empty;

atau

string willi = "";

atau apa?

Gunakan apa pun yang Anda dan tim Anda temukan yang paling mudah dibaca.

Jawaban lain menyarankan bahwa string baru dibuat setiap kali Anda menggunakan "". Ini tidak benar - karena pemagangan string, itu akan dibuat sekali per perakitan atau sekali per AppDomain (atau mungkin sekali untuk seluruh proses - tidak yakin di depan itu). Perbedaan ini dapat diabaikan - secara besar-besaran, tidak signifikan secara besar- besaran .

Yang menurut Anda lebih mudah dibaca adalah masalah yang berbeda. Ini subjektif dan akan bervariasi dari orang ke orang - jadi saya sarankan Anda mencari tahu apa yang disukai kebanyakan orang di tim Anda, dan semuanya sesuai dengan konsistensi. Secara pribadi saya merasa ""lebih mudah dibaca.

Argumen itu ""dan " "mudah keliru satu sama lain tidak benar-benar cocok dengan saya. Kecuali Anda menggunakan font proporsional (dan saya belum pernah bekerja dengan pengembang mana pun ), cukup mudah untuk membedakannya.

Tidak ada perbedaan dari sudut pandang kinerja dan kode yang dihasilkan. Dalam pengujian kinerja, mereka bolak-balik di antara yang satu lebih cepat vs yang lain, dan hanya dalam milidetik.

Dalam melihat kode di balik layar, Anda juga tidak melihat perbedaan. Satu-satunya perbedaan adalah pada IL, yang string.Emptymenggunakan opcode ldsfld dan"" menggunakan opcode ldstr, tetapi itu hanya karena string.Emptystatis, dan kedua instruksi melakukan hal yang sama. Jika Anda melihat perakitan yang diproduksi, itu persis sama.

Kode C #

private void Test1()
{
    string test1 = string.Empty;    
    string test11 = test1;
}

private void Test2()
{
    string test2 = "";    
    string test22 = test2;
}

Kode IL

.method private hidebysig instance void 
          Test1() cil managed
{
  // Code size       10 (0xa)
  .maxstack  1
  .locals init ([0] string test1,
                [1] string test11)
  IL_0000:  nop
  IL_0001:  ldsfld     string [mscorlib]System.String::Empty
  IL_0006:  stloc.0
  IL_0007:  ldloc.0
  IL_0008:  stloc.1
  IL_0009:  ret
} // end of method Form1::Test1

.method private hidebysig instance void 
        Test2() cil managed
{
  // Code size       10 (0xa)
  .maxstack  1
  .locals init ([0] string test2,
                [1] string test22)
  IL_0000:  nop
  IL_0001:  ldstr      ""
  IL_0006:  stloc.0
  IL_0007:  ldloc.0
  IL_0008:  stloc.1
  IL_0009:  ret
} // end of method Form1::Test2

Kode perakitan

        string test1 = string.Empty;
0000003a  mov         eax,dword ptr ds:[022A102Ch] 
0000003f  mov         dword ptr [ebp-40h],eax 

        string test11 = test1;
00000042  mov         eax,dword ptr [ebp-40h] 
00000045  mov         dword ptr [ebp-44h],eax 

        string test2 = "";
0000003a  mov         eax,dword ptr ds:[022A202Ch] 
00000040  mov         dword ptr [ebp-40h],eax 

        string test22 = test2;
00000043  mov         eax,dword ptr [ebp-40h] 
00000046  mov         dword ptr [ebp-44h],eax 

Kode terbaik adalah tidak ada kode sama sekali :

Sifat dasar dari pengkodean adalah bahwa tugas kita, sebagai pemrogram, adalah untuk mengakui bahwa setiap keputusan yang kita buat adalah pertukaran. […] Mulai dengan singkat. Tambah dimensi lain seperti yang dipersyaratkan oleh pengujian.

Akibatnya, kode kurang adalah kode yang lebih baik: Memilih untuk ""ke string.Emptyatau String.Empty. Keduanya enam kali lebih lama tanpa manfaat tambahan - tentu saja tidak ada kejelasan tambahan, karena mereka mengungkapkan informasi yang sama persis.

Satu perbedaan adalah bahwa jika Anda menggunakan switch-casesintaks, Anda tidak dapat menulis case string.Empty:karena itu bukan konstanta. Anda mendapatkanCompilation error : A constant value is expected

Lihatlah tautan ini untuk info lebih lanjut: string-blank-versus-empty-quotes

Saya lebih suka stringuntuk String. memilih string.Emptylebih ""adalah masalah memilih satu dan tetap menggunakannya. Keuntungan menggunakan string.Emptyadalah sangat jelas apa yang Anda maksud, dan Anda tidak sengaja menyalin lebih dari karakter yang tidak dapat dicetak seperti "\x003"di Anda "".

Saya tidak akan berpadu, tapi saya melihat beberapa info yang salah dibuang di sini.

Saya pribadi lebih suka string.Empty . Itu adalah pilihan pribadi, dan saya tunduk pada kehendak tim apa pun yang bekerja sama dengan saya berdasarkan kasus per kasus.

Seperti yang disebutkan beberapa orang lainnya, tidak ada perbedaan sama sekali antara string.EmptydanString.Empty .

Selain itu, dan ini adalah fakta yang sedikit diketahui, menggunakan "" sangat bisa diterima. Setiap instance "" akan, di lingkungan lain, membuat objek. Namun, .NET magang string-nya, sehingga contoh di masa depan akan menarik string abadi yang sama dari kolam intern, dan setiap hit kinerja akan diabaikan. Sumber: Brad Abrams .

Saya pribadi lebih suka "" kecuali ada alasan bagus untuk sesuatu yang lebih kompleks.

String.Emptydan string.Emptysetara. Stringadalah nama kelas BCL; stringadalah alias C # (atau pintasan, jika Anda mau). Sama seperti dengan Int32dan int. Lihat dokumen untuk contoh lebih lanjut.

Sejauh ""menyangkut, saya tidak begitu yakin.

Secara pribadi, saya selalu menggunakan string.Empty.

Hampir setiap pengembang di luar sana akan tahu apa artinya "". Saya pribadi menjumpai String.Empty pertama kali dan harus meluangkan waktu mencari google untuk mengetahui apakah mereka benar - benar hal yang sama persis.

Topik ini cukup lama dan panjang, jadi permisi jika perilaku ini disebutkan di tempat lain. (Dan arahkan saya ke jawaban yang mencakup ini)

Saya telah menemukan perbedaan dalam perilaku kompiler jika Anda menggunakan string.Emptyatau mengutip ganda. Perbedaannya muncul dengan sendirinya jika Anda tidak menggunakan variabel string yang diinisialisasi dengan string.Empty atau dengan tanda kutip ganda.

Dalam kasus inisialisasi dengan string.Emptymaka Peringatan Kompiler

CS0219 - The variable 'x' is assigned but its value is never used

tidak pernah dipancarkan saat inisialisasi dengan tanda kutip ganda Anda mendapatkan pesan yang diharapkan.

Perilaku ini dijelaskan dalam artikel Hubungkan di tautan ini: https://connect.microsoft.com/VisualStudio/feedback/details/799810/c-warning-cs0219-not-reported-when-assign-non-constant-value

Pada dasarnya, jika saya melakukannya dengan benar, mereka ingin memungkinkan seorang programmer untuk mengatur variabel dengan nilai kembali fungsi untuk keperluan debugging tanpa mengganggunya dengan pesan peringatan dan dengan demikian mereka membatasi peringatan hanya dalam hal penugasan dan string yang mahal. Kosong bukan konstanta tetapi bidang.

Saya melakukan tes yang sangat sederhana ini menggunakan metode berikut dalam aplikasi konsol:

private static void CompareStringConstants()
{
    string str1 = "";
    string str2 = string.Empty;
    string str3 = String.Empty;
    Console.WriteLine(object.ReferenceEquals(str1, str2)); //prints True
    Console.WriteLine(object.ReferenceEquals(str2, str3)); //prints True
}

Ini jelas menunjukkan bahwa ketiga variabel yaitu str1, str2dan str3meskipun diinisialisasi menggunakan sintaks yang berbeda menunjuk ke objek string yang sama (panjang nol) di memori. Saya melakukan tes ini di aplikasi .NET 4.5 konsol. Jadi secara internal mereka tidak memiliki perbedaan dan semuanya bermuara pada kenyamanan yang mana yang ingin Anda gunakan sebagai programmer. Perilaku kelas string ini dikenal sebagai string magang di .NET. Eric Lippert memiliki blog yang sangat bagus di sini yang menggambarkan konsep ini.

Salah satu di atas.

Ada banyak, banyak hal yang lebih baik untuk dikuasai. Seperti warna kulit pohon yang paling cocok untuk pohon, saya pikir cokelat samar dengan warna lumut belati.

Saya sangat suka String.Empty, selain dari alasan lain untuk memastikan Anda tahu apa itu dan bahwa Anda tidak sengaja menghapus konten, tetapi terutama untuk internasionalisasi. Jika saya melihat string dalam tanda kutip maka saya selalu bertanya-tanya apakah itu kode baru dan harus dimasukkan ke dalam tabel string. Jadi, setiap kali kode diubah / ditinjau, Anda perlu mencari "sesuatu dalam tanda kutip" dan ya Anda dapat menyaring string kosong tapi saya katakan pada orang-orang itu adalah praktik yang baik untuk tidak pernah meletakkan string dalam tanda kutip kecuali Anda tahu itu tidak akan terlokalisasi .

Tidak ada yang menyebutkan bahwa dalam VisualStudio String kode warna berbeda dari string. Yang penting untuk keterbacaan. Juga, huruf kecil biasanya digunakan untuk vars dan tipe, bukan masalah besar tapi String.Empty adalah konstanta dan bukan var atau tipe.

string adalah sinonim untuk System.String tipe, Mereka identik.

Nilai-nilai juga identik: string.Empty == String.Empty == ""

Saya tidak akan menggunakan konstanta karakter "" dalam kode, lebih tepatnya string.EmptyatauString.Empty - lebih mudah untuk melihat apa yang dimaksud pemrogram.

Antara stringdan Stringsaya suka huruf kecil stringlebih hanya karena saya dulu bekerja dengan Delphi selama bertahun-tahun dan gaya Delphi adalah huruf kecilstring .

Jadi, jika saya adalah bos Anda, Anda akan menulis string.Empty

Saya akan mendukung string.Emptylebih String.Emptykarena Anda dapat menggunakannya tanpa perlu menyertakanusing System; dalam file Anda.

Adapun memilih ""lebih string.Empty, itu adalah pilihan pribadi dan harus diputuskan oleh tim Anda.

Saya tidak membuat perbedaan. Yang terakhir adalah yang tercepat untuk mengetik :)

Tidak masalah - mereka persis hal yang sama. Namun, yang utama adalah Anda harus konsisten

id Saya berjuang dengan "whats the right thing" semacam ini sepanjang waktu.

Ini benar-benar preferensi gaya-kode, lakukan untuk bagaimana .NET menangani string. Namun, inilah pendapat saya :)

Saya selalu menggunakan nama Tipe BCL ketika mengakses metode statis, properti dan bidang: String.Emptyatau Int32.TryParse(...)atauDouble.Epsilon

Saya selalu menggunakan kata kunci C # ketika mendeklarasikan instance baru: int i = 0;ataustring foo = "bar";

Saya jarang menggunakan string string yang tidak dideklarasikan karena saya ingin dapat memindai kode untuk menggabungkannya menjadi konstanta bernama yang dapat digunakan kembali. Kompiler menggantikan konstanta dengan literal, jadi ini lebih merupakan cara untuk menghindari string / angka ajaib dan untuk memberi sedikit lebih banyak makna kepada mereka dengan nama. Ditambah mengubah nilai lebih mudah.

Saya menggunakan yang ketiga, tetapi dari dua lainnya yang pertama tampaknya kurang aneh. string adalah alias untuk String, tetapi melihatnya di suatu tugas terasa tidak menyenangkan.

Salah satu dari dua yang pertama akan diterima oleh saya. Saya akan menghindari yang terakhir karena relatif mudah untuk memperkenalkan bug dengan memberi jarak di antara tanda kutip. Bug khusus ini akan sulit ditemukan dengan observasi. Dengan asumsi tidak ada kesalahan ketik, semua secara semantik setara.

[EDIT]

Juga, Anda mungkin ingin selalu menggunakan salah satu stringatau Stringuntuk konsistensi, tapi itu hanya saya.

Saya pribadi menyaksikan "" mengakibatkan masalah (minor) dua kali. Pernah karena kesalahan pengembang junior yang baru pemrograman berbasis tim, dan yang lainnya adalah kesalahan ketik yang sederhana, tetapi kenyataannya menggunakan string. Kekuasaan akan menghindari kedua masalah.

Ya, ini adalah panggilan penilaian, tetapi ketika sebuah bahasa memberi Anda banyak cara untuk melakukan sesuatu, saya cenderung condong ke arah yang memiliki pengawasan paling kompiler dan penegakan waktu kompilasi terkuat. Itu bukan "". Ini semua tentang mengekspresikan maksud tertentu.

Jika Anda mengetik string.EMpty atau Strng.Empty, kompiler memberi tahu Anda bahwa Anda melakukan kesalahan. Segera. Itu tidak akan dikompilasi. Sebagai pengembang, Anda mengutip maksud tertentu yang tidak dapat disalahartikan oleh kompiler (atau pengembang lain), dan ketika Anda melakukannya dengan salah, Anda tidak dapat membuat bug.

Jika Anda mengetikkan "" ketika maksud Anda "" atau sebaliknya, kompiler dengan senang hati melakukan apa yang Anda perintahkan. Pengembang lain mungkin atau mungkin tidak dapat mengumpulkan maksud spesifik Anda. Bug dibuat.

Jauh sebelum string.Empty adalah hal yang saya gunakan perpustakaan standar yang mendefinisikan konstanta EMPTY_STRING. Kami masih menggunakan konstanta itu dalam pernyataan kasus di mana string.Empty tidak diizinkan.

Kapan pun memungkinkan, letakkan kompiler berfungsi untuk Anda, dan hilangkan kemungkinan kesalahan manusia, sekecil apa pun. IMO, ini mengalahkan "keterbacaan" seperti yang dikutip orang lain.

Kekhususan dan kompilasi penegakan waktu. Ini untuk makan malam.

Saya menggunakan "" karena akan diberi warna kuning khas dalam kode saya ... untuk beberapa alasan String.Empty semuanya putih dalam tema Visual Studio Code saya. Dan saya percaya itu yang terpenting bagi saya.

Kompiler harus membuat semuanya tetap sama dalam jangka panjang. Pilih standar sehingga kode Anda akan mudah dibaca, dan tetap menggunakannya.

Saya hanya melihat beberapa kode dan pertanyaan ini muncul di pikiran saya yang telah saya baca beberapa waktu sebelumnya. Ini tentu saja masalah keterbacaan.

Pertimbangkan kode C # berikut ...

(customer == null) ? "" : customer.Name

vs.

(customer == null) ? string.empty : customer.Name

Saya pribadi menemukan yang terakhir kurang ambigu dan lebih mudah dibaca.

Seperti yang ditunjukkan oleh orang lain, perbedaan yang sebenarnya dapat diabaikan.

Saya pikir yang kedua adalah "tepat," tetapi jujur ​​saja, saya pikir itu tidak masalah. Kompiler harus cukup pintar untuk mengkompilasi semua dari mereka ke bytecode yang sama persis. Saya menggunakan "" diri saya sendiri.

Walaupun perbedaannya sangat, SANGAT kecil, perbedaannya masih ada.

1) "" membuat objek sedangkan String.Empty tidak. Tetapi objek ini akan dibuat sekali dan akan direferensikan dari kumpulan string nanti jika Anda memiliki "" yang lain dalam kode.

2) String dan string adalah sama, tetapi saya akan merekomendasikan untuk menggunakan String.Empty (serta String.Format, String.Copy dll) karena notasi titik menunjukkan kelas, bukan operator, dan memiliki kelas yang dimulai dengan huruf kapital sesuai dengan Standar pengkodean C #.

Pada http://blogs.msdn.com/b/brada/archive/2003/04/22/49997.aspx :

Seperti yang disiratkan David, ada perbedaan antara String.Emptydan ""cukup kecil, tetapi ada perbedaan. ""sebenarnya menciptakan objek, kemungkinan akan ditarik keluar dari kolam string magang, tapi masih ... sementara String.Emptytidak menciptakan objek ... jadi jika Anda benar-benar mencari akhirnya dalam efisiensi memori, saya sarankan String.Empty. Namun, Anda harus ingat bahwa perbedaannya sangat sepele sehingga Anda tidak akan pernah melihatnya dalam kode Anda ...
Untuk System.String.Emptyatau string.Emptyatau String.Empty... tingkat perawatan saya rendah ;-)

String kosong seperti set kosong hanya nama yang digunakan semua orang untuk memanggil "". Juga dalam bahasa formal string yang dibuat dari alfabet yang memiliki panjang nol disebut string kosong. Baik set maupun string memiliki simbol khusus untuk itu. String kosong: ε dan set kosong: ∅. Jika Anda ingin berbicara tentang string panjang nol ini, Anda akan menyebutnya string kosong sehingga semua orang tahu persis apa yang Anda maksud. Sekarang dalam kasus Anda beri nama string kosong mengapa tidak digunakan string.Emptydalam kode, ini menunjukkan maksudnya eksplisit. Kelemahannya adalah itu tidak konstan dan karenanya tidak tersedia di mana-mana, seperti pada atribut. (Ini bukan konstanta untuk beberapa alasan teknis, lihat sumber referensi.)

Saya lebih suka ""karena lebih pendek dan String.Emptymenyelesaikan masalah yang tidak ada.