Penggunaan kata kunci var di C #

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.

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.

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).

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.

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.

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.

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.

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 ); 
}

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

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.

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);

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

Anda tidak dapat mengandalkan mouse-overs untuk itu.

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.

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.

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>();

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

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

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:

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.

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.

@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.

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?

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;

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.

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)

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.

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.

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.

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.

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

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.

Tidak ada, kecuali bahwa Anda tidak perlu menulis nama jenis dua kali. http://msdn.microsoft.com/en-us/library/bb383973.aspx