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.
sumber
var i = 0;
== gagal!var c = new CrazyFrigginLongClassName();
== menang!var readabilityBeDamned = true;
Jawaban:
Saya masih berpikir
var
dapat 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: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:
Bagi saya, nama tipenya hanyalah noise. Dan jika aku kembali dan memutuskan untuk mengubah jenis dari Customer.Orders ke trek (mengatakan dari
ObservableCollection<Order>
keIList<Order>
) maka saya perlu mengubah deklarasi itu juga - sesuatu yang saya tidak perlu dilakukan jika saya akan var digunakan dalam pertama tempat.sumber
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.
var
mengambil 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
var
variabel yang dideklarasikan dan menjadi bingung untuk apa variabel itu ada, ada sesuatu yang secara fundamental salah dengan kode saya.var
bukan penyebabnya, itu hanya membuat gejala terlihat. Jangan salahkan kurirnya.Sekarang, tim C # telah merilis pedoman pengkodean yang menyatakan bahwa
var
seharusnya 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
var
tetapi saya masih percaya mereka sebagian besar salah. Ambil contoh "searchabililty": klaim penulis yangvar
membuatnya sulit untuk mencari tempat di manaMyType
digunakan. 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).sumber
var
menyebabkan 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 bahwavar
harus digunakan secara eksklusif. Aturannya sederhana: jika benar-benar menyebabkan kebingungan, jangan gunakan itu.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 mengembalikan
List<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.sumber
Tak satu pun dari itu benar-benar benar;
var
dapat memiliki efek positif dan negatif pada keterbacaan. Menurut pendapat saya,var
harus digunakan ketika salah satu dari berikut ini benar:var foo = new TypeWithAReallyLongNameTheresNoSenseRepeating()
)var
tidak memiliki dampak kinerja, karena itu gula sintaksis; kompiler menyimpulkan tipe dan mendefinisikannya setelah dikompilasi menjadi IL; sebenarnya tidak ada yang dinamis tentang hal itu.sumber
typedef
saat tidak.var
saat tipenya jelas? Mungkin, tetapi keuntungan sebenarnya adalah ketika jenisnya tidak penting. Jika Anda melakukan hal-hal sepertivar customers = whatever; var query = from c in customers select stuff
itu, 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.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.Dari Eric Lippert, Insinyur Desain Perangkat Lunak Senior di tim C #:
Mengapa
var
kata kunci diperkenalkan?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,var
yang diperlukan dalam rangka untuk memiliki fitur tertentu lainnya bekerja di NET.sumber
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:
Jika lebih seperti ini:
... 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:
... tapi ini masuk akal:
Masing-masing untuk miliknya sendiri, kurasa. Saya mendapati diri saya melakukan ini, yang gila:
Saya butuh semacam program 12 langkah var. Nama saya Matt, dan saya (ab) menggunakan var.
sumber
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,
dilarang oleh standar pengkodean kami, tetapi yang berikut dianjurkan di tim kami karena itu meningkatkan keterbacaan:
sumber
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
: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:EDIT : Diperbarui sampel kode terakhir berdasarkan masukan Julian
sumber
variable
dibuat? Kecuali Anda memperluas contoh Anda, ini bukan keluhan yang sangat kuat, IMO.variable
,CallMe
) membuat contoh yang buruk. Namun, jikaCallMe()
suatu fungsi dalam semacam "aplikasi telepon", makavar call = CallMe(); .... call.HangUp();
akan jauh lebih masuk akal.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.
sumber
var
tidak ada hubungannyaVariant
.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:
(tolong jangan edit hscroll di atas - ini agak membuktikan maksudnya !!!)
vs:
Namun, ada saat-saat ketika ini menyesatkan, dan berpotensi menyebabkan bug. Hati-hati menggunakan
var
jika variabel asli dan tipe yang diinisialisasi tidak identik. Sebagai contoh:sumber
Satu kasus khusus di mana var sulit: ulasan kode offline, terutama yang dilakukan di atas kertas.
Anda tidak dapat mengandalkan mouse-overs untuk itu.
sumber
Saya tidak melihat apa masalahnya ..
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:
dan mengurangi total mindclutter menjadi:
Bagus, tidak sebagus:
Tapi untuk itulah Boo diperuntukkan.
sumber
v = List<somethinglongtypename>();
bahkan tidak lebih baik. Penting untuk membedakan antara memperkenalkan variabel baru dan menetapkan ke variabel yang ada.Jika seseorang menggunakan
var
kata kunci karena mereka tidak ingin "mengetahui tipe", itu jelas alasan yang salah. Katavar
kunci 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: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.
sumber
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
Apakah jauh lebih mudah atau lebih sulit dibaca daripada:
sumber
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
sumber
Tentu,
int
itu mudah, tetapi ketika tipe variabelnya adalahIEnumerable<MyStupidLongNamedGenericClass<int, string>>
, var membuat segalanya lebih mudah.sumber
int
versusvar
adalah sesuatu untuk diperdebatkan, tetapi beberapa tipe generik bersarang membuatvar
anugerah. Di sinilah menggunakan nama jenis berulang kali benar-benar menghancurkan keterbacaan kode.class IntStringEnumerator : IEnumerable<MyStupidLongNamedGenericClass<int, string>>
lalu gunakan nama baru. Itu membersihkan kode dan menjelaskan jenisnya dengan lebih baik.IntStringEnumerator i = new IntStringEnumerator()
masih terlalu banyak mengetik.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:
tidak apa-apa, tetapi dalam kasus seperti ini:
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.
sumber
Menggunakan
var
bukan 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
yang digunakan suka
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
alih-alih, Anda tidak perlu mengubahnya.
sumber
@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.
sumber
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 #
var
cukup 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?
sumber
Dalam perbandingan Anda antara
IEnumerable<int>
danIEnumerable<double>
Anda tidak perlu khawatir - jika Anda memasukkan jenis yang salah kode Anda tidak akan dikompilasi.Tidak ada kekhawatiran tentang jenis-keselamatan, seperti
var
yang tidak dinamis. Itu hanya kompiler ajaib dan semua jenis panggilan tidak aman yang Anda buat akan tertangkap.Var
mutlak diperlukan untuk Linq:Sekarang lihat anonEnumeration di intellisense dan akan muncul sesuatu seperti
IEnumerable<'a>
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
var
mana saja konteksnya jelas.sumber
IQueriable<T>
sebelum mengulangi:anonEnumeration.ToList();
IQueryable
atau.ToList()
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 mengembalikanIQueriable<T>
?AllPosts()
kembali - penanya merujukList<T>
jadi saya berasumsi itu. Dalam hal ini hasilnya adalahanonEnumeration
tipeIEnumerable<'a>
. Sekarang jikaAllPosts()
kembaliIQueryable<T>
sebagai gantinyaanonEnumeration
akan menjadiIQueryable<'a>
(perhatikan tidaki
dalam Queryable) - namun dalam kasus itu kode saya masih berfungsi karenaIQueryable<T>
mengimplementasikanIEnumerable<T>
. Ada banyak T&J yang lebih baik di sini tentang perbedaan di antara mereka - di sini kasus saya'a
adalah anonim danvar
memungkinkan Anda untuk menetapkannya ke variabel yang diketik secara statis.IQueryable<T>
bukan praktik yang baik karena dalam setiap iterasi Anda membuat pernyataan baca dalam DB. Pastikan untuk*.ToList()
IQueryable<T>
sebelum iterasi merekaSaya 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
benar-benar mustahil untuk ditangani, tidak ada yang akan menggunakan bahasa yang diketik secara dinamis.
sumber
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":
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:
Terutama, saya tidak pernah menggunakan var dalam kasus-kasus di mana sisi kanan bahkan bukan metode, tetapi hanya sebuah nilai:
(karena kompiler tidak dapat mengetahui apakah saya ingin byte, pendek, int atau apa pun)
sumber
var
, makavar
bukan masalahnya: sisi kanan adalah masalahnya. Itu tidak cukup deskriptif .Customer c = GetContext()
adalah masih belum jelas dan tidak ada yang lebih baik daripada menggunakanvar
.Bagi saya, antipati terhadap
var
ilustrasi mengapa bilingualisme dalam .NET penting. Bagi para programmer C # yang juga telah melakukan VB. NET, keuntungan darivar
intuisi jelas. Deklarasi C # standar untuk:adalah setara, dalam VB .NET, mengetik ini:
Tidak ada yang melakukan itu di VB. NET. Akan konyol untuk, karena sejak versi pertama. NET Anda sudah bisa melakukan ini ...
... yang membuat variabel dan menginisialisasi semuanya dalam satu baris yang cukup ringkas. Ah, tapi bagaimana jika Anda menginginkan
IList<string>
, bukanList<string>
? Nah, di VB .NET itu berarti Anda harus melakukan ini:Sama seperti yang harus Anda lakukan dalam C #, dan jelas tidak dapat digunakan
var
untuk: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.
sumber
var
di C # tidak memiliki koneksi apa pun denganvar
JavaScript. Sebuahvar
variabel -declared di C # adalah kuat-mengetik.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
var
untuk 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 '
var
atau tidak' hal ke dalam campuran. Kasus terburuk adalah di mana satu programmer tidak menggunakanvar
dan 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.
sumber
Banyak waktu selama pengujian, saya mendapati diri saya memiliki kode seperti ini:
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:
untuk ini:
Tanpa var, saya harus terus mengubah tipe yang dideklarasikan di sisi kiri juga. Saya tahu ini kecil, tetapi sangat nyaman.
sumber
Untuk penggemar yang berpikir
var
menghemat waktu, perlu sedikit penekanan tombol untuk mengetik:dari
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.
sumber
Saya perpecahan var seluruh tempat, tempat hanya dipertanyakan bagi saya adalah jenis pendek internal misalnya saya lebih memilih
int i = 3;
lebihvar i = 3;
sumber
Ini tentu bisa membuat segalanya lebih sederhana, dari kode yang saya tulis kemarin:
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
var
sebanyak yang saya bisa, dan menggunakan tipe eksplisit sekarang menunjukkan bahwa variabel tersebut bukan tipe ekspresi inisialisasi.sumber
Tidak ada, kecuali bahwa Anda tidak perlu menulis nama jenis dua kali. http://msdn.microsoft.com/en-us/library/bb383973.aspx
sumber