Penggunaan kata kunci var di C #

406

Setelah berdiskusi dengan kolega mengenai penggunaan kata kunci 'var' di C # 3, saya bertanya-tanya pendapat orang apa tentang penggunaan inferensi tipe yang tepat melalui var?

Misalnya saya agak malas menggunakan var dalam keadaan yang dipertanyakan, misalnya: -

foreach(var item in someList) { // ... } // Type of 'item' not clear.
var something = someObject.SomeProperty; // Type of 'something' not clear.
var something = someMethod(); // Type of 'something' not clear.

Penggunaan var yang lebih sah adalah sebagai berikut: -

var l = new List<string>(); // Obvious what l will be.
var s = new SomeClass(); // Obvious what s will be.

Menariknya LINQ tampaknya agak abu-abu, misalnya: -

var results = from r in dataContext.SomeTable
              select r; // Not *entirely clear* what results will be here.

Jelas hasil apa yang akan di bahwa itu akan menjadi tipe yang mengimplementasikan IEnumerable, namun itu tidak sepenuhnya jelas dengan cara yang sama seperti var mendeklarasikan objek baru.

Ini bahkan lebih buruk ketika datang ke LINQ ke objek, misalnya: -

var results = from item in someList
              where item != 3
              select item;

Ini tidak lebih baik daripada equivilent foreach (item var di someList) {// ...} equivilent.

Ada kekhawatiran nyata tentang keamanan jenis di sini - misalnya jika kita menempatkan hasil kueri ke dalam metode kelebihan beban yang menerima IEnumerable <int> dan IEnumerable <double> pemanggil mungkin secara tidak sengaja mengirimkan tipe yang salah.

var memang mempertahankan pengetikan yang kuat tetapi pertanyaannya adalah apakah berbahaya bagi jenis untuk tidak segera terlihat pada definisi, sesuatu yang diperbesar ketika kelebihan berarti kesalahan kompiler mungkin tidak dikeluarkan ketika Anda tidak sengaja melewati jenis yang salah ke suatu metode.

ljs
sumber
68
Menggunakan var baik-baik saja, tetapi "Saya tidak perlu mencari tahu jenisnya" sepertinya alasan yang sangat buruk untuk menggunakannya ... Anda seharusnya tahu apa jenisnya, var hanyalah jalan pintas untuk menghindari mengetiknya
Thomas Levesque
53
var i = 0;== gagal! var c = new CrazyFrigginLongClassName();== menang!
dotjoe
6
"Var juga mengingatkan saya pada tipe varian VB / VBA. Ia juga memiliki tempatnya. Saya ingat (dari beberapa tahun yang lalu) penggunaannya menjadi tipe yang kurang diinginkan dan agak haus sumber daya." <- menunjukkan ini adalah pertanyaan yang mengumpan karena tipe 'var' dari C # tidak ada hubungannya dengan tipe varian VB / VBA.
user7116
20
var readabilityBeDamned = true;
spoulson
9
Masalah dengan semua contoh yang dinyatakan di sini adalah bahwa kita sedang melihat SATU baris kode. Ketika saya melihat baris demi baris deklarasi "var", satu demi satu, itu keluar dari tangan. Keterbacaan bersifat subyektif, tetapi saya menemukan bahwa penyalahgunaan jauh lebih banyak daripada digunakan dengan terhormat.
jro

Jawaban:

293

Saya masih berpikir vardapat membuat kode lebih mudah dibaca dalam beberapa kasus. Jika saya memiliki kelas Pelanggan dengan properti Pesanan, dan saya ingin menetapkannya ke variabel, saya hanya akan melakukan ini:

var orders = cust.Orders;

Saya tidak peduli jika Pelanggan. Pesanan adalah IEnumerable<Order>, ObservableCollection<Order>atauBindingList<Order> - yang saya inginkan adalah menyimpan daftar itu dalam memori untuk mengulanginya atau mendapatkan hitungan atau sesuatu nanti.

Bandingkan pernyataan di atas dengan:

ObservableCollection<Order> orders = cust.Orders;

Bagi saya, nama tipenya hanyalah noise. Dan jika aku kembali dan memutuskan untuk mengubah jenis dari Customer.Orders ke trek (mengatakan dari ObservableCollection<Order>ke IList<Order>) maka saya perlu mengubah deklarasi itu juga - sesuatu yang saya tidak perlu dilakukan jika saya akan var digunakan dalam pertama tempat.

Matt Hamilton
sumber
48
Saya suka memiliki tipe eksplisit di depan saya ketika saya membaca kode. Bagaimana saya tahu "cust.Orders" apa yang ada di sini tanpa jenis? Ya, saya bisa mengarahkan mouse saya untuk mencari tahu, tetapi mengapa saya harus melakukannya? :)
Jon Tackabury
77
Tetapi intinya adalah bahwa secara umum itu tidak masalah. Disediakan cust.Orders adalah sesuatu yang dapat Anda sebutkan (misalnya foreach over) maka tidak masalah apa pun jenisnya. Kode tambahan hanya menghalangi cara membaca maksud.
Matt Hamilton
67
Tetapi jika Anda hanya memerlukan cust itu. Pesanan adalah "sesuatu yang dapat Anda hitung" maka tidak menyatakannya sebagai <nomor> IEnumerable yang membuat persyaratan itu jelas dan jelas? Mendeklarasikannya sebagai var berarti Anda secara efektif kehilangan persyaratan itu.
GrahamS
5
@jon dan bagaimana pesanan IEnumerbal = cust.Orders foreach (pesanan dalam pesanan) membuat perbedaan? satu-satunya hal yang IEnumerable katakan adalah bahwa Anda dapat memasukkannya ke muka tetapi Anda sudah tahu bahwa dari baris di bawah ini
Rune FS
18
"Satu-satunya hal yang IEnumerable katakan adalah Anda dapat mempelajarinya" - itu juga menyatakan niat bahwa satu - satunya hal yang dapat Anda lakukan adalah menghitung. Menggunakan var memberikan akses dan intellisense bagi anggota publik dari jenis pengumpulan konkret.
Joe
167

saya menggunakan var banyak. Ada kritik bahwa ini mengurangi keterbacaan kode, tetapi tidak ada argumen untuk mendukung klaim itu.

Memang, itu mungkin berarti bahwa tidak jelas apa jenis yang kita hadapi. Terus? Ini sebenarnya adalah titik dari desain yang dipisahkan. Saat berhadapan dengan antarmuka, Anda sangat tidak tertarik pada tipe yang dimiliki variabel. varmengambil ini lebih jauh, benar, tapi saya pikir argumennya tetap sama dari sudut pandang keterbacaan: Pemrogram seharusnya tidak benar-benar tertarik pada jenis variabel melainkan pada apa yang dilakukan variabel . Inilah sebabnya mengapa Microsoft juga menyebut inferensi jenis “mengetik bebek.”

Jadi, apa yang dilakukan variabel ketika saya mendeklarasikannya menggunakan var? Mudah, ia melakukan apa pun yang dikatakan IntelliSense kepada saya. Alasan apa pun tentang C # yang mengabaikan IDE tidak sesuai dengan kenyataan. Dalam praktiknya, setiap kode C # diprogram dalam IDE yang mendukung IntelliSense.

Jika saya menggunakan varvariabel yang dideklarasikan dan menjadi bingung untuk apa variabel itu ada, ada sesuatu yang secara fundamental salah dengan kode saya. varbukan penyebabnya, itu hanya membuat gejala terlihat. Jangan salahkan kurirnya.

Sekarang, tim C # telah merilis pedoman pengkodean yang menyatakan bahwa varseharusnya hanya digunakan untuk menangkap hasil dari pernyataan LINQ yang menciptakan tipe anonim (karena di sini, kami tidak memiliki alternatif nyata untukvar ). Nah, persetan. Selama tim C # tidak memberi saya argumen yang masuk akal untuk panduan ini, saya akan mengabaikannya karena menurut pendapat profesional dan pribadi saya, itu omong kosong. (Maaf; saya tidak punya tautan ke pedoman yang dimaksud.)

Sebenarnya, ada beberapa penjelasan (dangkal) yang bagus tentang mengapa Anda tidak harus menggunakan vartetapi saya masih percaya mereka sebagian besar salah. Ambil contoh "searchabililty": klaim penulis yang varmembuatnya sulit untuk mencari tempat di mana MyTypedigunakan. Baik. Begitu juga antarmuka. Sebenarnya, mengapa saya ingin tahu di mana kelas itu digunakan? Saya mungkin lebih tertarik pada di mana ia dipakai dan ini masih akan dapat dicari karena di suatu tempat konstruktor harus dipanggil (bahkan jika ini dilakukan secara tidak langsung, nama jenis harus disebutkan di suatu tempat).

Konrad Rudolph
sumber
14
Dalam setiap IDE yang layak, Anda tidak menggunakan pencarian teks untuk mendapatkan penggunaan kelas, Anda mendapatkan IDE untuk melakukannya berdasarkan parse tree-nya atau bagaimana pun itu mengidentifikasi jenis objek. Karena kita berbicara tentang pengetikan statis, ini akan menemukan segalanya kecuali jenis anonim.
Dustman
6
Aku benci mewarisi 100 ribu baris sumber tanpa dokumentasi dan penggunaan var yang liberal. Terutama jika Anda menggabungkan var dengan nama variabel yang kurang bermanfaat. Saya bisa melihatnya membantu ketika menggambarkan suatu titik (atau berurusan dengan jenis anonim) tetapi dalam kode produksi?
Shea
7
Arnshea: well, Anda sudah menunjuk masalah sebenarnya di sana: nama variabel yang tidak berguna , dan dokumentasi yang hilang . Saya benar-benar gagal melihat apa yang varmenyebabkan kebingungan. Tentu saja, mungkin ada kasus di mana penting untuk menekankan jenis / ukuran variabel (misalnya operasi bit level rendah). Tidak apa-apa: tidak ada yang pernah mengklaim bahwa varharus digunakan secara eksklusif. Aturannya sederhana: jika benar-benar menyebabkan kebingungan, jangan gunakan itu.
Konrad Rudolph
17
Setiap contoh yang bertentangan dengan var yang saya lihat mengasumsikan bahwa programmer akan menggunakan nama variabel yang tidak berarti. Tapi mungkin ini sebabnya var lebih baik daripada secara eksplisit menentukan jenis: Ini memaksa programmer untuk datang dengan nama variabel yang baik.
Ryan Lundy
16
Microsoft juga menyebut inferensi jenis "mengetik bebek." - benarkah mereka? Saya akan terkejut ...
Anton Tykhyy
118

Var, menurut saya, di C # adalah hal yang baik tm . Variabel apa pun yang diketik masih diketik dengan kuat, tetapi mendapatkan jenisnya dari sisi kanan penugasan di mana ia didefinisikan. Karena informasi jenis tersedia di sisi kanan, dalam banyak kasus, itu tidak perlu dan terlalu bertele-tele juga harus memasukkannya di sisi kiri. Saya pikir ini secara signifikan meningkatkan keterbacaan tanpa mengurangi keamanan jenis.

Dari sudut pandang saya, menggunakan konvensi penamaan yang baik untuk variabel dan metode lebih penting dari perspektif keterbacaan daripada informasi jenis eksplisit. Jika saya memerlukan informasi jenis, saya selalu dapat mengarahkan variabel (dalam VS) dan mendapatkannya. Namun, pada umumnya, informasi jenis eksplisit tidak perlu bagi pembaca. Untuk pengembang, di VS Anda masih mendapatkan Intellisense, terlepas dari bagaimana variabel dideklarasikan. Setelah mengatakan semua itu, mungkin masih ada kasus di mana masuk akal untuk secara eksplisit menyatakan jenis - mungkin Anda memiliki metode yang mengembalikanList<T> , tetapi Anda ingin memperlakukannya sebagaiIEnumerable<T>dalam metode Anda. Untuk memastikan bahwa Anda menggunakan antarmuka, mendeklarasikan variabel tipe antarmuka dapat membuat ini eksplisit. Atau, mungkin, Anda ingin mendeklarasikan variabel tanpa nilai awal - karena ia segera mendapatkan nilai berdasarkan kondisi tertentu. Dalam hal ini Anda membutuhkan tipenya. Jika informasi jenis bermanfaat atau perlu, silakan dan gunakan. Saya merasa, bahwa biasanya itu tidak perlu dan kode lebih mudah dibaca tanpa dalam kebanyakan kasus.

tvanfosson
sumber
3
Saya setuju secara keseluruhan. Poin kunci di sini menurut saya adalah memastikan bahwa maksudnya jelas. Jika tidak jelas bagi pengembang mayoritas di tim, maka itu merugikan, tidak membantu. Yang mengatakan, saya pribadi adalah penggemar BESAR dari ini, tetapi harus mengendalikan diri sedikit ketika devs lain di tim saya mengalami kesulitan menentukan niat saya. Sosok pergi.
Steve Brouillard
3
Eh, saya merasa lebih mudah dibaca ketika jenisnya ada di sebelah kiri. Menggunakan ReSharper, saya tidak perlu mengetik ulang tipe di sebelah kanan, jadi itu tidak mengganggu saya.
BlueRaja - Danny Pflughoeft
1
@ BlueRaja - Saya menemukan bahwa menggunakan nama variabel yang baik biasanya menghilangkan kebutuhan untuk repot dengan tipe aktual untuk memahami. Intellisense masih tersedia pada variabel yang didefinisikan "var", jadi saya tidak perlu tahu tipe untuk memilih metode / properti di dalamnya ketika coding.
tvanfosson
2
Ini tidak begitu banyak tentang kapan Anda mengkode seperti halnya ketika Anda harus membaca kode.
BlueRaja - Danny Pflughoeft
1
Saya harus berada di sisi tebal kemudian, saya perlu Metode yang baik dan nama variabel dan pemahaman tentang jenis yang dioperasikan untuk dapat memahami dengan benar kode yang saya baca. Saya pikir Anda benar meskipun ini merupakan gejala dari masalah yang lebih besar. Salah satu kepercayaan. Untuk memastikan bahwa kode melakukan apa yang tampaknya Anda lakukan, Anda perlu memastikan jenis yang digunakan.
AnthonyWJones
91

Tak satu pun dari itu benar-benar benar; vardapat memiliki efek positif dan negatif pada keterbacaan. Menurut pendapat saya, varharus digunakan ketika salah satu dari berikut ini benar:

  1. Jenisnya anonim (yah, Anda tidak punya pilihan di sini, karena harus var dalam kasus ini)
  2. Jenisnya jelas berdasarkan pada ekspresi yang ditugaskan (yaitu var foo = new TypeWithAReallyLongNameTheresNoSenseRepeating())

vartidak memiliki dampak kinerja, karena itu gula sintaksis; kompiler menyimpulkan tipe dan mendefinisikannya setelah dikompilasi menjadi IL; sebenarnya tidak ada yang dinamis tentang hal itu.

Adam Robinson
sumber
1
setuju pada keduanya, meskipun saya memiliki batasan panjang pada kasus kedua, jika suatu jenis adalah panjang itu biasanya jenis generik dengan banyak argumen generik bersarang, dalam kasus itu sangat diketik "ShortType setara dengan TypeWithAReallyLongNameTheresNoSenseRepeating" lebih masuk akal
Ion Todirel
12
Saya tidak punya keinginan untuk memulai perang agama, tetapi saya pribadi cenderung tidak setuju dengan Ion. Saya lebih suka nama jenis yang sangat panjang, tetapi sangat tepat (ala Paman Bob Martin) daripada nama jenis yang lebih pendek dan mungkin ambigu. Saya akan menambahkan peringatan bahwa saya TIDAK setuju dengan artifisial menggembungkan panjang nama baik. Jika 5 karakter membuat nama ringkas yang dengan jelas menunjukkan niat, maka gunakan 5 dan bukan 25.
Steve Brouillard
2
@Steve: Saya harus setuju dengan Anda; membuat "tipe pendek" (yang saya anggap Anda maksud sebagai pewarisan dari tipe generik khusus semata-mata dengan tujuan memperpendek nama) bukanlah praktik yang baik; itu akan mengharuskan Anda untuk menduplikasi dan melewati konstruktor dari tipe generik, serta mencegah Anda melewati tipe berbeda yang mewarisi dari tipe generik ke fungsi. Anda menggunakan warisan seperti typedefsaat tidak.
Adam Robinson
7
Gunakan varsaat tipenya jelas? Mungkin, tetapi keuntungan sebenarnya adalah ketika jenisnya tidak penting. Jika Anda melakukan hal-hal seperti var customers = whatever; var query = from c in customers select stuffitu, apa pun jenis 'pelanggan' yang tepat. Sudah jelas bagaimana Anda bisa menggunakannya, dan itu sudah cukup. Dan jika jenis yang sebenarnya rumit, ada baiknya untuk menekannya.
Joren
2
@ Kristoffer: Saya bisa mengerti keinginan untuk menghilangkan kekacauan tag, tetapi membungkusnya ke dalam kelas bukanlah (IMO) alternatif yang dapat diterima, karena Anda kemudian memotong kemungkinan kelas anak lain (yang sah) dari tipe generik yang tidak parameter yang valid. Saya lebih suka menggunakan using ShortType = LongGenericType<A,B,C>arahan di bagian atas file, karena itu memberikan keterbacaan yang sama, tidak mengharuskan Anda membuat ulang konstruktor, dan tidak menghilangkan kelas anak dari menjadi kandidat.
Adam Robinson
68

Dari Eric Lippert, Insinyur Desain Perangkat Lunak Senior di tim C #:

Mengapa varkata kunci diperkenalkan?

Ada dua alasan, satu yang ada saat ini, satu yang akan muncul di 3.0.

Alasan pertama adalah bahwa kode ini sangat jelek karena semua redundansi:

Dictionary<string, List<int>> mylists = new Dictionary<string, List<int>>();

Dan itu contoh sederhana - Saya sudah menulis lebih buruk. Setiap kali Anda dipaksa untuk mengetik hal yang persis sama dua kali, itu merupakan redundansi yang dapat kami hapus. Jauh lebih bagus untuk menulis

var mylists = new Dictionary<string,List<int>>();

dan biarkan kompiler mencari tahu apa tipe berdasarkan pada penugasan.

Kedua, C # 3.0 memperkenalkan tipe anonim. Karena tipe anonim menurut definisi tidak memiliki nama, Anda harus dapat menyimpulkan tipe variabel dari ekspresi inisialisasi jika jenisnya anonim.

Tekankan milikku. Seluruh artikel, C # 3.0 masih diketik secara statis, jujur! , dan seri berikutnya cukup bagus.

Ini untuk apa var. Kegunaan lain mungkin tidak akan bekerja dengan baik. Setiap perbandingan dengan JScript, VBScript, atau pengetikan dinamis adalah total susun. Catatan lagi, varyang diperlukan dalam rangka untuk memiliki fitur tertentu lainnya bekerja di NET.

Dustman
sumber
Saya merasa argumen Lippert aneh. Tidak ada yang mengetik nama kelas kedua, mereka membiarkan Intellisense menuliskannya untuk mereka, tetapi kemudian dia berbalik dan mengklaim bahwa var lebih baik karena kompiler / Intellisense berhasil. Anda tidak bisa mendapatkan keduanya!
Dave
5
Tim C # tidak mengontrol intellisense, mereka mengontrol kompiler. Dalam hal apa pun itu bukan masalah utama. Saya tidak berpikir var akan membuat 100 poin pada penghematan pengetikan sendirian.
Dustman
@Dustman: var tidak menyimpan pengetikan sama sekali. Itu membuat Anda menulis lebih banyak!
Piotr Perak
53

Saya pikir penggunaan var harus digabungkan dengan nama variabel yang dipilih dengan bijak.

Saya tidak punya masalah menggunakan var dalam pernyataan foreach, asalkan tidak seperti ini:

foreach (var c in list) { ... }

Jika lebih seperti ini:

foreach (var customer in list) { ... }

... maka seseorang yang membaca kode akan lebih mungkin memahami apa itu "daftar". Jika Anda memiliki kontrol atas nama variabel daftar itu sendiri, itu lebih baik.

Hal yang sama dapat berlaku untuk situasi lain. Ini sangat tidak berguna:

var x = SaveFoo(foo);

... tapi ini masuk akal:

var saveSucceeded = SaveFoo(foo);

Masing-masing untuk miliknya sendiri, kurasa. Saya mendapati diri saya melakukan ini, yang gila:

var f = (float)3;

Saya butuh semacam program 12 langkah var. Nama saya Matt, dan saya (ab) menggunakan var.

Matt Hamilton
sumber
6
Nah satu-satunya yang salah dengan "var f = (float) 3;" adalah bahwa itu harus "var f = 3f" atau "var f = 3.0 (menyebabkan ketelitian tunggal menyebalkan)".
MichaelGG
3
Heh ya 3f atau 3.0 adalah cara untuk pergi! Kami para maniak harus tetap bersama!
Matt Hamilton
27
Masalah sebenarnya dalam contoh pertama adalah "daftar", bukan "c". "daftar" apa ? "daftar" harus diubah namanya menjadi "pelanggan", atau "pelanggan yang membayar uang", atau "pelanggan saat ini", atau sesuatu yang jauh lebih deskriptif. Dan begitu Anda memilikinya, "c" dapat tetap apa adanya, karena Anda sudah tahu apa isinya.
Ryan Lundy
4
Hai Matt! Nama saya Kenny dan saya varaddict.
kenny
var MattHamil = "Luke Skywalker"; // dilucuti satu ton dari itu
Binoj Antony
40

Kami telah mengadopsi etos "Kode untuk orang, bukan mesin", berdasarkan asumsi bahwa Anda menghabiskan waktu beberapa kali lebih lama dalam mode pemeliharaan daripada pada pengembangan baru.

Bagi saya, itu mengesampingkan argumen bahwa kompiler "tahu" apa jenis variabelnya - tentu saja, Anda tidak dapat menulis kode yang tidak valid pertama kali karena kompiler menghentikan kode Anda dari kompilasi, tetapi ketika pengembang berikutnya membaca kode tersebut dalam waktu 6 bulan mereka harus dapat menyimpulkan apa yang variabel lakukan dengan benar atau salah dan dengan cepat mengidentifikasi penyebab masalah.

Jadi,

var something = SomeMethod();

dilarang oleh standar pengkodean kami, tetapi yang berikut dianjurkan di tim kami karena itu meningkatkan keterbacaan:

var list = new List<KeyValuePair<string, double>>();
FillList( list );
foreach( var item in list ) {
   DoWork( item ); 
}
Dexter
sumber
4
Saya telah menemukan bahwa ("Kode untuk orang, bukan mesin") menjadi pedoman yang sangat baik - mengikutinya dapat menghasilkan kode yang lebih baik dan membantu menghindari pengoptimalan prematur.
Thanatos
3
Saya tidak mendapatkan var list = new KeyValuePair <string, double>? Bagi saya daftar dapat memiliki lebih dari satu hal.
TTT
"Kode untuk orang, bukan mesin" - amin.
user1068352
39

Ini tidak buruk, ini lebih merupakan hal gaya, yang cenderung subjektif. Itu dapat menambahkan ketidakkonsistenan, ketika Anda menggunakan var dan ketika Anda tidak.

Kasus lain yang menjadi perhatian, dalam panggilan berikut ini Anda tidak dapat memberi tahu hanya dengan melihat kode jenis yang dikembalikan oleh CallMe:

var variable = CallMe();

Itu keluhan utama saya terhadap var.

Saya menggunakan var ketika saya mendeklarasikan delegasi anonim dalam metode, entah bagaimana var terlihat lebih bersih daripada jika saya akan menggunakan Func. Pertimbangkan kode ini:

var callback = new Func<IntPtr, bool>(delegate(IntPtr hWnd) {
   ...
});

EDIT : Diperbarui sampel kode terakhir berdasarkan masukan Julian

Ion Todirel
sumber
3
Tetapi apakah Anda benar-benar perlu tahu jenisnya di sana pada baris itu? Anda tahu bahwa CallMe mengembalikan sesuatu; tidakkah cukup untuk mengetahui bahwa variabel lokal bernama variabledibuat? Kecuali Anda memperluas contoh Anda, ini bukan keluhan yang sangat kuat, IMO.
Randolpho
2
Ini bukan tentang tidak menjadi kata kerja, ini tentang tidak membiarkan kompiler melakukan sintaksis gula untuk Anda. Pertimbangkan ini: var getter ..., sekarang pengambil Func <object> ini ..., dengan yang kedua Anda tahu Anda tidak perlu memberikan parameter apa pun dan apa yang dikembalikan. Anda tahu dari awal "apa yang harus dilakukan" dan dapat membuat keputusan lebih cepat, ketika merancang sesuatu atau refactoring. Memiliki semua informasi yang ada lebih penting daripada beberapa karakter lainnya. Ini hanya dapat dihargai ketika Anda bekerja dengan banyak kode.
Ion Todirel
2
Karena bagaimanapun juga kita semua berbicara tentang visual studio, apa masalah besar tentang mengarahkan mouse Anda ke variabel sebentar dan hanya melihat apa jenisnya? Jauh lebih baik daripada lari ke deklarasi.
Rubi
3
Variabel umum dan nama fungsi ( variable, CallMe) membuat contoh yang buruk. Namun, jika CallMe()suatu fungsi dalam semacam "aplikasi telepon", maka var call = CallMe(); .... call.HangUp();akan jauh lebih masuk akal.
Danko Durbić
3
@Randolpho: "apa masalah tentang mengarahkan mouse Anda ke variabel sebentar dan hanya melihat jenis apa itu?" Ini menambah waktu ke overhead pemeliharaan ... ditambah satu detik hanya waktu melayang daripada menghitung switch konteks keyboard ke mouse. Saya tidak tahu tentang Anda, tetapi saya bekerja dengan tenggat waktu. Setiap kali saya harus mengarahkan variabel untuk mencari tahu apa jenisnya, adalah waktu yang bisa saya habiskan untuk memperbaiki masalah.
Powerlord
36

Var tidak seperti varian sama sekali. Variabel masih sangat diketik, hanya saja Anda tidak menekan tombol untuk mendapatkannya seperti itu. Anda bisa mengarahkannya di Visual Studio untuk melihat tipenya. Jika Anda membaca kode tercetak, Anda mungkin harus berpikir sedikit untuk mengetahui jenisnya. Tetapi hanya ada satu baris yang mendeklarasikannya dan banyak baris yang menggunakannya, sehingga memberikan nama yang layak masih merupakan cara terbaik untuk membuat kode Anda lebih mudah diikuti.

Apakah menggunakan Intellisense malas? Ini kurang mengetik dari seluruh nama. Atau adakah hal-hal yang kurang berhasil tetapi tidak pantas dikritik? Saya pikir ada, dan var adalah salah satunya.

Kate Gregory
sumber
6
+1, hanya orang yang perlu dicatat yang vartidak ada hubungannya Variant.
user7116
27

Waktu yang paling mungkin Anda perlukan untuk ini adalah untuk jenis anonim (di mana diperlukan 100%); tetapi juga menghindari pengulangan untuk kasus-kasus sepele, dan IMO membuat garis lebih jelas. Saya tidak perlu melihat tipe dua kali untuk inisialisasi sederhana.

Sebagai contoh:

Dictionary<string, List<SomeComplexType<int>>> data = new Dictionary<string, List<SomeComplexType<int>>>();

(tolong jangan edit hscroll di atas - ini agak membuktikan maksudnya !!!)

vs:

var data = new Dictionary<string, List<SomeComplexType<int>>>();

Namun, ada saat-saat ketika ini menyesatkan, dan berpotensi menyebabkan bug. Hati-hati menggunakan varjika variabel asli dan tipe yang diinisialisasi tidak identik. Sebagai contoh:

static void DoSomething(IFoo foo) {Console.WriteLine("working happily") }
static void DoSomething(Foo foo) {Console.WriteLine("formatting hard disk...");}

// this working code...
IFoo oldCode = new Foo();
DoSomething(oldCode);
// ...is **very** different to this code
var newCode = new Foo();
DoSomething(newCode);
Marc Gravell
sumber
1
(untuk info, Anda bisa mendapatkan masalah serupa pada apa pun di mana ini adalah konversi tipe implisit)
Marc Gravell
1
Tidak setuju dengan bagian yang Anda tidak ingin melihatnya dua kali di baris yang sama. Ada kemungkinan bahwa di masa depan Anda tidak secara langsung membuat variabel setelah mendeklarasikan (misalnya dalam jika di bawah definisi) daripada mungkin tidak secara langsung menjadi jelas apa jenisnya. Sebagian besar pengembang terbiasa melihat jenisnya secara langsung di awal baris terutama dalam kode kompleks yang Anda tidak ingin membuat pembacaan kode lebih sulit.
Gertjan
@TheVillageIdiot - Saya memutar kembali hasil edit Anda, karena pada kesempatan ini hscroll terkait dengan titik ;-p
Marc Gravell
2
@ Gertjan - otak saya terbatas; jika kompleks, saya tidak ingin melihatnya dua kali dan harus mulai membandingkan (antarmuka / beton / dll). Saya senang melihatnya sekali dan berpikir "diketik sebagai salah satu dari mereka".
Marc Gravell
17

Satu kasus khusus di mana var sulit: ulasan kode offline, terutama yang dilakukan di atas kertas.

Anda tidak dapat mengandalkan mouse-overs untuk itu.

Jon Limjap
sumber
17
Kenapa Anda kode meninjau di atas kertas? Pikirkan pepohonan! ;)
Dustman
8
Anda dapat memiliki masalah yang sama tanpa menggunakan var. Masalahnya bukan var; masalahnya adalah nama variabel yang buruk. Jika nama variabel dipilih dengan baik, penggunaan var tidak masalah.
Ryan Lundy
Saya memiliki seorang pria di tim saya yang meninjau kode sendiri, dan mencari bug, dengan mencetak kodenya. Dindingnya ditutupi dengan kode. Saya pernah masuk dan dia memiliki seluruh papan tulis besar ditutupi dengan salah satu latihan debuggingnya. Itu mungkin ~ 10.000 LOC
Bip bip
Nama variabel saja tidak menyelesaikan masalah kecuali Anda kembali ke notasi hungaria di mana jenisnya adalah bagian dari namanya.
Kevin Gale
17

Saya tidak melihat apa masalahnya ..

var something = someMethod(); // Type of 'something' not clear <-- not to the compiler!

Anda masih memiliki kecerdasan penuh pada 'sesuatu', dan untuk kasus yang ambigu Anda memiliki tes unit Anda, kan? ( Apakah kamu? )

Ini bukan varchar, itu tidak redup, dan tentu saja mengetik tidak dinamis atau lemah. Ini menghentikan maddnes seperti ini:

List<somethinglongtypename> v = new List<somethinglongtypename>();

dan mengurangi total mindclutter menjadi:

var v = new List<somethinglongtypename>();

Bagus, tidak sebagus:

v = List<somethinglongtypename>();

Tapi untuk itulah Boo diperuntukkan.

Frep D-Oronge
sumber
jenis 'sesuatu' sangat jelas untuk kompiler, secara internal, "var" akan diatur ke jenis kembalinya 'someMethod', jelas untuk kompiler, tetapi mungkin tidak jelas bagi pengembang yang mengerjakan proyek. dan Boo tumbuh dengan cepat.
stephenbayer
Tidak, v = List<somethinglongtypename>();bahkan tidak lebih baik. Penting untuk membedakan antara memperkenalkan variabel baru dan menetapkan ke variabel yang ada.
HighCommander4
Nah jika Anda telah ditugaskan ke 'v' sebelumnya dalam lingkup saat ini, maka tugas itu sudah ada. Kalau tidak, itu penugasan ke variabel baru 'v'. Mudah.
Frep D-Oronge
17

Jika seseorang menggunakan var kata kunci karena mereka tidak ingin "mengetahui tipe", itu jelas alasan yang salah. Kata varkunci tidak membuat variabel dengan tipe dinamis, kompiler masih harus tahu jenisnya. Karena variabel selalu memiliki tipe tertentu, tipe tersebut juga harus jelas dalam kode jika memungkinkan.

Alasan bagus untuk menggunakan var kata kunci adalah sebagai contoh:

  • Di mana diperlukan, yaitu untuk menyatakan referensi untuk jenis anonim.
  • Di mana itu membuat kode lebih mudah dibaca, yaitu menghapus deklarasi berulang.

Menuliskan tipe data sering membuat kode lebih mudah diikuti. Ini menunjukkan tipe data apa yang Anda gunakan, sehingga Anda tidak perlu mencari tahu tipe data dengan terlebih dahulu mencari tahu apa yang dilakukan kode.

Guffa
sumber
11

Mengingat betapa kuat Intellisense sekarang, saya tidak yakin var lebih sulit dibaca daripada memiliki variabel anggota di kelas, atau variabel lokal dalam metode yang ditentukan dari area layar yang terlihat.

Jika Anda memiliki garis kode seperti

IDictionary<BigClassName, SomeOtherBigClassName> nameDictionary = new Dictionary<BigClassName, SomeOtherBigClassName>();

Apakah jauh lebih mudah atau lebih sulit dibaca daripada:

var nameDictionary = new Dictionary<BigClassName, SomeOtherBigClassName>();
Colin Desmond
sumber
Saya tidak benar-benar mempertimbangkan ini, sepertinya dari pertanyaan lain yang merupakan poin yang cukup kuat untuk satu kali menggunakannya.
Finglas
Yang pada dasarnya satu-satunya alasan mereka menerapkan itu (selain dapat mendeklarasikan jenis anonim, tetapi mereka bisa membuat "var" kata kunci khusus yang hanya untuk jenis anonim.)
MQP
10

Saya pikir hal utama dengan VAR adalah hanya menggunakannya di mana yang sesuai yaitu ketika melakukan hal-hal di Linq yang memfasilitasi (dan mungkin dalam kasus lain).

Jika Anda memiliki jenis untuk sesuatu di kemudian Anda harus menggunakannya - tidak untuk melakukannya adalah kemalasan sederhana (sebagai lawan dari kemalasan kreatif yang umumnya didorong - programmer yang baik sering bekerja sangat keras untuk menjadi malas dan dapat dianggap sumber hal di tempat pertama).

Larangan selimut sama buruknya dengan menyalahgunakan konstruk pada awalnya, tetapi harus ada standar pengkodean yang masuk akal.

Hal lain yang perlu diingat adalah bahwa itu bukan tipe VB var karena tidak dapat mengubah jenis - itu adalah variabel yang diketik dengan kuat hanya bahwa jenisnya disimpulkan (itulah sebabnya ada orang yang akan berpendapat bahwa itu tidak masuk akal untuk gunakan dalam, katakanlah, sebuah pendahuluan tapi saya tidak setuju karena alasan keterbacaan dan pemeliharaan.

Saya menduga ini akan berjalan dan berjalan (-:

Murph

Murph
sumber
10

Tentu, intitu mudah, tetapi ketika tipe variabelnya adalah IEnumerable<MyStupidLongNamedGenericClass<int, string>>, var membuat segalanya lebih mudah.

Blorgbeard keluar
sumber
2
+1 untuk ini. intversus varadalah sesuatu untuk diperdebatkan, tetapi beberapa tipe generik bersarang membuat varanugerah. Di sinilah menggunakan nama jenis berulang kali benar-benar menghancurkan keterbacaan kode.
Chris Farmer
Ini benar-benar alasan yang salah untuk menggunakannya. Jika kode Anda menggunakan tipe generik bersarang Anda harus mendapatkan kelas bernama khusus untuk itu. Misalnya: class IntStringEnumerator : IEnumerable<MyStupidLongNamedGenericClass<int, string>>lalu gunakan nama baru. Itu membersihkan kode dan menjelaskan jenisnya dengan lebih baik.
xxbbcc
Baiklah, tapi teladan saya hanya hiperbola. IntStringEnumerator i = new IntStringEnumerator()masih terlalu banyak mengetik.
Blorgbeard keluar
9

Dicuri dari pos pada masalah ini di CodingHorror :


Sayangnya, Anda dan orang lain salah besar. Meskipun saya setuju dengan Anda bahwa redundansi bukanlah hal yang baik, cara yang lebih baik untuk menyelesaikan masalah ini adalah dengan melakukan sesuatu seperti berikut:

MyObject m = baru ();

Atau jika Anda melewatkan parameter:

Orang p = baru ("FirstName", "LastName);

Di mana dalam penciptaan objek baru, kompiler menyimpulkan jenis dari sisi kiri, dan bukan kanan. Ini memiliki kelebihan lain daripada "var", karena dapat digunakan dalam deklarasi lapangan juga (ada juga beberapa area lain yang bisa berguna juga, tetapi saya tidak akan membahasnya di sini).

Pada akhirnya, itu tidak dimaksudkan untuk mengurangi redundansi. Jangan salah paham, "var" SANGAT penting di C # untuk tipe / proyeksi anonim, tetapi penggunaannya di sini hanya WAY off (dan saya sudah mengatakan ini untuk waktu yang sangat lama) ketika Anda mengaburkan jenis yang sedang dipakai. Harus mengetik dua kali terlalu sering, tetapi menyatakan nol kali terlalu sedikit.

Nicholas Paldino .NET / C # MVP pada 20 Juni 2008 08:00


Saya kira jika masalah utama Anda adalah mengetik lebih sedikit - maka tidak ada argumen yang akan mempengaruhi Anda untuk menggunakannya.

Jika Anda hanya akan pernah menjadi orang yang terlihat di kode Anda, lalu siapa peduli? Kalau tidak, dalam kasus seperti ini:

var people = Managers.People

tidak apa-apa, tetapi dalam kasus seperti ini:

var fc = Factory.Run();

itu sirkuit pendek setiap pengurangan tipe langsung otak saya bisa mulai terbentuk dari 'bahasa Inggris' kode.

Jika tidak, gunakan saja penilaian terbaik Anda dan program 'kesopanan' terhadap orang lain yang mungkin harus mengerjakan proyek Anda.

Rostov
sumber
4
Contoh Anda di atas bukan argumen untuk tidak menggunakan var; mereka adalah argumen untuk menggunakan nama variabel deskriptif yang baik. Jika, alih-alih [var fc = Factory.Run ();] Anda memiliki [bool fc = Factory.Run ();], kode tidak akan menjadi lebih jelas.
Ryan Lundy
9

Menggunakan varbukan tipe eksplisit membuat refactoring jauh lebih mudah (karena itu saya harus bertentangan dengan poster sebelumnya yang berarti tidak ada bedanya atau itu murni "gula sintaksis").

Anda dapat mengubah jenis pengembalian metode Anda tanpa mengubah setiap file tempat metode ini dipanggil. Membayangkan

...
List<MyClass> SomeMethod() { ... }
...

yang digunakan suka

...
IList<MyClass> list = obj.SomeMethod();
foreach (MyClass c in list)
  System.Console.WriteLine(c.ToString());
...

Jika Anda ingin refactor SomeMethod()untuk mengembalikanIEnumerable<MySecondClass> , Anda harus mengubah deklarasi variabel (juga di dalamforeach ) di setiap tempat Anda menggunakan metode.

Jika kamu menulis

...
var list = obj.SomeMethod();
foreach (var element in list)
  System.Console.WriteLine(element.ToString());
...

alih-alih, Anda tidak perlu mengubahnya.

MartinStettner
sumber
setuju - bertanya-tanya mengapa efek samping yang bagus ini tidak disebut-sebut sebanyak yang lain, pro lebih subjektif dalam tanggapan yang lebih populer.
fieldingmellish
Ini terjadi pada saya hari ini. Saya memiliki kelas pabrik yang mengembalikan kelas MainMenu. Hari ini saya membuat MainMenu2 dengan antarmuka MainMenu yang sama. Semua kode aplikasi saya belum tersentuh setelah perubahan!
Marco Staffoli
8

@aku: Salah satu contohnya adalah ulasan kode. Contoh lain adalah skenario refactoring.

Pada dasarnya saya tidak ingin pergi berburu tipe dengan mouse saya. Itu mungkin tidak tersedia.

erlando
sumber
2
Sangat menarik Anda mengatakan itu karena var dapat membuat refactoring lebih sederhana. Jika Anda telah menggunakan var, Anda tidak harus melakukannya. Sekarang Anda dapat selalu mengandalkan alat refactoring IDE, tapi kau tahu, Anda selalu dapat mengandalkan IDE untuk jenis juga :)
Fred
8

Ini masalah selera. Semua ini meributkan tentang jenis variabel menghilang ketika Anda terbiasa dengan bahasa yang diketik secara dinamis. Yaitu, jika Anda mulai menyukai mereka (saya tidak yakin apakah semua orang bisa, tetapi saya menyukainya).

C # varcukup keren karena terlihat seperti pengetikan dinamis, tetapi sebenarnya pengetikan statis - kompiler memberlakukan penggunaan yang benar.

Jenis variabel Anda tidak terlalu penting (ini telah dikatakan sebelumnya). Seharusnya relatif jelas dari konteks (interaksinya dengan variabel dan metode lain) dan namanya - jangan berharap customerList mengandung int...

Saya masih menunggu untuk melihat apa pendapat bos saya tentang masalah ini - saya mendapat selimut "teruskan" untuk menggunakan konstruksi baru dalam 3,5, tetapi apa yang akan kita lakukan tentang pemeliharaan?

Daren Thomas
sumber
7

Dalam perbandingan Anda antara IEnumerable<int>dan IEnumerable<double>Anda tidak perlu khawatir - jika Anda memasukkan jenis yang salah kode Anda tidak akan dikompilasi.

Tidak ada kekhawatiran tentang jenis-keselamatan, seperti varyang tidak dinamis. Itu hanya kompiler ajaib dan semua jenis panggilan tidak aman yang Anda buat akan tertangkap.

Var mutlak diperlukan untuk Linq:

var anonEnumeration =
    from post in AllPosts()
    where post.Date > oldDate
    let author = GetAuthor( post.AuthorId )
    select new { 
        PostName = post.Name, 
        post.Date, 
        AuthorName = author.Name
    };

Sekarang lihat anonEnumeration di intellisense dan akan muncul sesuatu sepertiIEnumerable<'a>

foreach( var item in anonEnumeration ) 
{
    //VS knows the type
    item.PostName; //you'll get intellisense here

    //you still have type safety
    item.ItemId;   //will throw a compiler exception
}

Compiler C # cukup pintar - tipe anon yang dihasilkan secara terpisah akan memiliki tipe yang sama jika propertinya cocok.

Di luar itu, selama Anda memiliki kecerdasan, masuk akal untuk menggunakan di varmana saja konteksnya jelas.

//less typing, this is good
var myList = new List<UnreasonablyLongClassName>();

//also good - I can't be mistaken on type
var anotherList = GetAllOfSomeItem();

//but not here - probably best to leave single value types declared
var decimalNum = 123.456m;
Keith
sumber
Harap singkirkan IQueriable<T>sebelum mengulangi: anonEnumeration.ToList();
David Diez
@ Davidvidie bisakah Anda ulangi? Pernyataan Anda tidak masuk akal. Tidak ada referensi cuplikan kode saya IQueryableatau.ToList()
Keith
var anonEnumeration = from post in AllPosts() where post.Date > oldDate let author = GetAuthor( post.AuthorId ) select new { PostName = post.Name, post.Date, AuthorName = author.Name };tidak mengembalikan IQueriable<T>?
David Diez
1
@ Davidvidie itu tergantung pada apa yang AllPosts()kembali - penanya merujuk List<T>jadi saya berasumsi itu. Dalam hal ini hasilnya adalah anonEnumerationtipe IEnumerable<'a>. Sekarang jika AllPosts()kembali IQueryable<T>sebagai gantinya anonEnumerationakan menjadi IQueryable<'a>(perhatikan tidak idalam Queryable) - namun dalam kasus itu kode saya masih berfungsi karena IQueryable<T>mengimplementasikan IEnumerable<T>. Ada banyak T&J yang lebih baik di sini tentang perbedaan di antara mereka - di sini kasus saya 'aadalah anonim dan varmemungkinkan Anda untuk menetapkannya ke variabel yang diketik secara statis.
Keith
Ohh begitu, terima kasih sudah menjelaskannya :) Komentar saya adalah karena iterasi IQueryable<T>bukan praktik yang baik karena dalam setiap iterasi Anda membuat pernyataan baca dalam DB. Pastikan untuk *.ToList() IQueryable<T>sebelum iterasi mereka
David Diez
7

Saya kira itu tergantung pada sudut pandang Anda. Saya pribadi tidak pernah mengalami kesulitan memahami sepotong kode karena var"penyalahgunaan", dan rekan kerja saya dan saya menggunakannya cukup banyak di seluruh. (Saya setuju bahwa Intellisense adalah bantuan besar dalam hal ini.) Saya menyambutnya sebagai cara untuk menghilangkan kesalahan berulang.

Lagi pula, jika pernyataan suka

var index = 5; // this is supposed to be bad

var firstEligibleObject = FetchSomething(); // oh no what type is it
                                            // i am going to die if i don't know

benar-benar mustahil untuk ditangani, tidak ada yang akan menggunakan bahasa yang diketik secara dinamis.

mqp
sumber
Agaknya dalam .Net 4 di mana jenis dinamis adalah tempat umum, ini akan menjadi lebih penting?
Colin Desmond
2
Sebaliknya, jika Anda bingung dengan "var" sekarang, saya berharap Anda juga akan bingung dengan "dinamis." Allah melarang siapa pun yang pernah menyatakan dinamis dan kemudian membuat referensi untuk itu menggunakan "var" :)
MQP
Maksud saya sesuatu seperti dinamis d = 52; var x = d; yang seharusnya baik-baik saja.
mqp
7

Saya hanya menggunakan var ketika jelas untuk melihat tipe apa yang digunakan.

Sebagai contoh, saya akan menggunakan var dalam kasus ini, karena Anda dapat segera melihat bahwa x akan menjadi tipe "MyClass":

var x = new MyClass();

Saya TIDAK akan menggunakan var dalam kasus-kasus seperti ini, karena Anda harus menyeret mouse ke atas kode dan melihat tooltip untuk melihat tipe MyFunction kembali:

var x = MyClass.MyFunction();

Terutama, saya tidak pernah menggunakan var dalam kasus-kasus di mana sisi kanan bahkan bukan metode, tetapi hanya sebuah nilai:

var x = 5;

(karena kompiler tidak dapat mengetahui apakah saya ingin byte, pendek, int atau apa pun)

Christian Specht
sumber
Jika sisi kanan tidak cukup jelas untuk membenarkan penggunaan var, maka varbukan masalahnya: sisi kanan adalah masalahnya. Itu tidak cukup deskriptif . Customer c = GetContext()adalah masih belum jelas dan tidak ada yang lebih baik daripada menggunakan var.
JulianR
6

Bagi saya, antipati terhadap varilustrasi mengapa bilingualisme dalam .NET penting. Bagi para programmer C # yang juga telah melakukan VB. NET, keuntungan dari varintuisi jelas. Deklarasi C # standar untuk:

List<string> whatever = new List<string>();

adalah setara, dalam VB .NET, mengetik ini:

Dim whatever As List(Of String) = New List(Of String)

Tidak ada yang melakukan itu di VB. NET. Akan konyol untuk, karena sejak versi pertama. NET Anda sudah bisa melakukan ini ...

Dim whatever As New List(Of String)

... yang membuat variabel dan menginisialisasi semuanya dalam satu baris yang cukup ringkas. Ah, tapi bagaimana jika Anda menginginkan IList<string>, bukan List<string>? Nah, di VB .NET itu berarti Anda harus melakukan ini:

Dim whatever As IList(Of String) = New List(Of String)

Sama seperti yang harus Anda lakukan dalam C #, dan jelas tidak dapat digunakan varuntuk:

IList<string> whatever = new List<string>();

Jika Anda perlu jenisnya menjadi sesuatu yang berbeda, itu bisa saja. Tetapi salah satu prinsip dasar pemrograman yang baik adalah mengurangi redundansi, dan itulah yang dilakukan var.

Ryan Lundy
sumber
1
Lucu Anda menyebut bilingualisme sebagai sesuatu yang mempromosikan penggunaan var. Antagonisme saya terhadap kata kunci var berasal langsung dari kefasihan saya dalam javascript! :)
urig
vardi C # tidak memiliki koneksi apa pun dengan varJavaScript. Sebuah varvariabel -declared di C # adalah kuat-mengetik.
Ryan Lundy
6

Gunakan untuk jenis anonim - itulah gunanya. Ada lagi yang menggunakan terlalu jauh. Seperti banyak orang yang tumbuh di C, saya terbiasa melihat di sebelah kiri deklarasi untuk tipe. Saya tidak melihat sisi kanan kecuali saya harus. Menggunakan varuntuk deklarasi lama membuat saya melakukan itu sepanjang waktu, yang saya pribadi merasa tidak nyaman.

Mereka yang mengatakan 'tidak masalah, gunakan apa yang Anda sukai' tidak melihat keseluruhan gambar. Semua orang akan mengambil kode orang lain pada satu titik atau yang lain dan harus berurusan dengan keputusan apa pun yang mereka buat pada saat mereka menulisnya. Sudah cukup buruk harus berurusan dengan konvensi penamaan yang sangat berbeda, atau - gaya klasik pengikat - gaya, tanpa menambahkan keseluruhan ' varatau tidak' hal ke dalam campuran. Kasus terburuk adalah di mana satu programmer tidak menggunakan vardan kemudian datanglah seorang pengelola yang menyukainya, dan memperluas kode menggunakannya. Jadi sekarang Anda memiliki kekacauan yang tidak suci.

Standar adalah hal yang baik justru karena itu berarti Anda jauh lebih mungkin untuk dapat mengambil kode acak dan dapat melakukannya dengan cepat. Semakin banyak hal yang berbeda, semakin sulit. Dan pindah ke gaya 'var everywhere' membuat perbedaan besar .

Saya tidak keberatan mengetik dinamis, dan saya tidak keberatan mengetik implisit - dalam bahasa yang dirancang untuk mereka. Saya sangat suka Python. Tapi C # dirancang sebagai bahasa yang diketik secara eksplisit secara statis dan begitulah seharusnya. Melanggar aturan untuk jenis anonim sudah cukup buruk; membiarkan orang mengambil yang lebih jauh dan mematahkan idiom bahasa bahkan lebih adalah sesuatu yang saya tidak senang. Sekarang jin sudah keluar dari botol, itu tidak akan pernah masuk lagi. C # akan menjadi balkan ke dalam kamp. Tidak baik.

Neil Hewitt
sumber
7
Wow. Mengabaikan semua argumen yang muncul di utas ini sejauh ini dan mengatur ulang seluruh diskusi adalah sebuah pencapaian.
Konrad Rudolph
100% ini menggambarkan perasaan saya tentang 'var', terutama dari sudut pandang mengambil kode orang lain. Penggunaan var secara radikal mengubah tugas yang ada jika itu berserakan. +1
Simon
6

Banyak waktu selama pengujian, saya mendapati diri saya memiliki kode seperti ini:

var something = myObject.SomeProperty.SomeOtherThing.CallMethod();
Console.WriteLine(something);

Sekarang, kadang-kadang, saya ingin melihat isi SomeOtherThing itu sendiri, SomeOtherThing bukan tipe yang sama dengan yang dikembalikan oleh CallMethod (). Karena saya menggunakan var, saya hanya mengubah ini:

var something = myObject.SomeProperty.SomeOtherThing.CallMethod();

untuk ini:

var something = myObject.SomeProperty.SomeOtherThing;

Tanpa var, saya harus terus mengubah tipe yang dideklarasikan di sisi kiri juga. Saya tahu ini kecil, tetapi sangat nyaman.

BFree
sumber
6

Untuk penggemar yang berpikir varmenghemat waktu, perlu sedikit penekanan tombol untuk mengetik:

StringBuilder sb = new StringBuilder();

dari

var sb = new StringBuilder();

Hitung mereka jika Anda tidak percaya padaku ...

19 lawan 21

Saya akan menjelaskan jika saya harus melakukannya, tetapi coba saja ... (tergantung pada kondisi saat ini dari kecerdasan Anda, Anda mungkin harus mengetikkan lebih banyak untuk masing-masing)

Dan itu benar untuk setiap tipe yang dapat Anda pikirkan !!

Perasaan pribadi saya adalah bahwa var tidak boleh digunakan kecuali jika jenisnya tidak diketahui karena mengurangi pengakuan readabiltiy dalam kode. Butuh otak lebih lama untuk mengenali tipe daripada garis penuh. Penghitung waktu lama yang mengerti kode mesin dan bit tahu persis apa yang saya bicarakan. Otak memproses secara paralel dan ketika Anda menggunakan var Anda memaksanya untuk membuat serialisasi inputnya. Mengapa ada orang yang ingin membuat otak mereka bekerja lebih keras? Untuk itulah komputer digunakan.

Wray Smallwood
sumber
Saya menemukan pengulangan stringBuilder sb = new StringBuilder () berantakan dan lebih lama untuk mengenali dengan jelas. Ini kebisingan ekstra. Masalahnya adalah, menentukan apa yang merupakan dan tidak merupakan upaya intelektual ekstra untuk memahami beberapa kode sangat subjektif!
ljs
"var tidak boleh digunakan kecuali jika jenisnya tidak diketahui ..." - Anda SELALU dapat mengetahui jenisnya, seperti halnya kompiler. Ini bukan pengetikan dinamis, itu hanya memungkinkan kompiler menentukan jenis untuk Anda. Namun tipenya tidak pernah tidak dikenal.
Gabriel Magana
5

Saya perpecahan var seluruh tempat, tempat hanya dipertanyakan bagi saya adalah jenis pendek internal misalnya saya lebih memilih int i = 3;lebihvar i = 3;

robi-y
sumber
5

Ini tentu bisa membuat segalanya lebih sederhana, dari kode yang saya tulis kemarin:

var content  = new Queue<Pair<Regex, Func<string, bool>>>();
...
foreach (var entry in content) { ... }

Ini akan menjadi sangat verbose tanpa var.

Tambahan: Sedikit waktu yang dihabiskan dengan bahasa dengan inferensi tipe nyata (mis. F #) akan menunjukkan betapa bagusnya kompiler dalam mendapatkan jenis ekspresi yang benar. Ini tentu saja berarti saya cenderung menggunakan varsebanyak yang saya bisa, dan menggunakan tipe eksplisit sekarang menunjukkan bahwa variabel tersebut bukan tipe ekspresi inisialisasi.

Richard
sumber
Yup, kompiler lebih pintar dari kita, lupakan saja!
Benjol