Mengapa ReSharper ingin menggunakan 'var' untuk semuanya?

Saya baru saja mulai menggunakan ReSharper dengan Visual Studio (setelah banyak rekomendasi tentang SO). Untuk mencobanya saya membuka proyek ASP.NET MVC baru-baru ini. Salah satu hal pertama dan yang paling sering saya perhatikan adalah menyarankan untuk mengubah sebagian / semua deklarasi eksplisit saya varsebagai gantinya. Sebagai contoh:

//From This:
MyObject foo = DB.MyObjects.SingleOrDefault(w => w.Id == 1);
//To This:
var foo = DB.MyObjects.SingleOrDefault(w => w.Id == 1);

dan sebagainya, bahkan dengan jenis sederhana seperti int, bool, dll

Mengapa ini direkomendasikan? Saya tidak berasal dari ilmu komputer atau .NET latar belakang, setelah "jatuh ke dalam" pengembangan. NET baru-baru ini, jadi saya benar-benar ingin memahami apa yang terjadi dan apakah itu bermanfaat atau tidak.

Salah satu alasannya adalah peningkatan keterbacaan. Mana yang lebih baik?

Dictionary<int, MyLongNamedObject> dictionary = new Dictionary<int, MyLongNamedObject>();

atau

var dictionary = new Dictionary<int, MyLongNamedObject>();

Apa yang ReSharper sarankan jelas terlalu sering menggunakan kata kunci var. Anda dapat menggunakannya di mana tipenya jelas:

var obj = new SomeObject();

Jika jenisnya tidak jelas, Anda sebaiknya menuliskannya:

SomeObject obj = DB.SomeClass.GetObject(42);

Saya pribadi lebih suka mematikan saran ini. Menggunakan varsering dapat meningkatkan keterbacaan; tetapi seperti yang Anda sebutkan, kadang-kadang menguranginya (dengan jenis sederhana, atau ketika jenis yang dihasilkan tidak jelas ).

Saya lebih suka memilih kapan saya menggunakan vardan ketika saya tidak. Tapi sekali lagi, itu hanya aku.

vardapat meningkatkan keterbacaan kode sekaligus mengurangi pemahaman kode secara langsung. Sama saja, dapat mengurangi keterbacaan kode untuk situasi lain. Terkadang penggunaannya netral. Ukuran keterbacaan terhadap pemahaman tidak proporsional tetapi tergantung pada situasinya. Terkadang keduanya meningkat atau menurun bersama.

Faktornya adalah apa yang varsedang diterapkan dan seberapa baik target mendukung kebingungan langsung dari tipe datanya kepada pembaca, atau jika info jenisnya diperlukan untuk memahami bagian program yang ada.

Misalnya, penamaan yang buruk dapat varmenyebabkan penurunan pemahaman kode. Ini bukan varsalah:

var value1 = GetNotObviousValue(); //What's the data type? 
//vs. 
var value2 = Math.Abs(-3); // Obviously a numeric data type. 

Terkadang tidak masuk akal untuk menggunakan vartipe data sederhana ketika kode lebih mudah dibaca jika tidak ada:

var num = GetNumber(); // But what type of number?
// vs. 
double num = GetNumber(); // I see, it's a double type. 

Terkadang varberguna untuk menyembunyikan informasi tipe data yang Anda tidak perlu melihat kerumitan:

    IEnumerable<KeyValuePair<string,List<Dictionary<int,bool>>>> q = from t in d where t.Key == null select t; // OMG! 
    //vs. 
    var q = from t in d where t.Key == null select t;

    // I simply want the first string, so the last version seems fine.  
    q.First().Key; 

Anda harus menggunakan varketika ada jenis anonim hadir karena tidak ada nama jenis untuk menyebutnya dengan:

var o = new { Num=3, Name="" };

Ketika Anda memiliki Visual Studio Intellisense yang menyediakan informasi jenis terlepas dari itu var, Anda kemudian harus bergantung pada pemahaman Anda melalui pembacaan kode yang ketat tanpa bantuan. Mungkin bijaksana untuk menganggap tidak semua orang memiliki atau menggunakan Intellisense.

Singkatnya berdasarkan pada contoh-contoh di atas, saya sarankan penerapan carte blanche varbukanlah ide yang baik karena kebanyakan hal paling baik dilakukan dalam jumlah sedang dan berdasarkan keadaan yang ada seperti ditunjukkan di sini.

Mengapa Resharper menggunakannya secara default? Saya sarankan untuk kemudahan, karena tidak dapat mengurai nuansa situasi untuk memutuskan kapan sebaiknya tidak menggunakannya.

Di ReSharper (8.02, tetapi kemungkinan versi lain), opsi untuk saran "Gunakan deklarasi variabel lokal yang diketik secara implisit" dapat disesuaikan dengan preferensi Anda , apa pun itu, dengan terlebih dahulu membuka menu opsi untuk ReSharper:

Kemudian, di bawah "Inspeksi Kode" dengan menyesuaikan "Tingkat Permasalahan Inspeksi" dari bahasa pilihan Anda, dalam kasus saya c #:

Seperti yang Anda lihat, ada opsi untuk menyesuaikan semua saran yang dibuat ReSharper. Semoga ini bisa membantu orang seperti saya yang sudah memiliki strategi penggunaan 'var' dan hanya ingin ReSharper menghormatinya :)

Saya terkejut bahwa tidak ada yang menyebutkan bahwa juga lebih mudah untuk mengubah jenis objek yang dipakai, karena

AVeryLongTypeName myVariable = new AVeryLongTypeName( arguments );

adalah bentuk pengulangan . Jika saya ingin mengubah AVeryLongTypeNameke salah satu kelas turunannya, saya hanya perlu mengubah ini sekali ketika menggunakan vardan masih dapat mengakses metode kelas anak.

Selain itu, peningkatan keterbacaan adalah poin penting, tetapi seperti yang orang lain katakan, var tidak boleh digunakan secara berlebihan, jadi saya pikir mematikan petunjuk di Resharper benar-benar baik-baik saja.

'var' adalah tentang menjadi jelas

Perdebatan utama tentang apakah menggunakan varkata kunci atau tidak adalah tentang seberapa mudah dibaca kode untuk Anda dan pengembang lainnya.

Sama seperti jika Anda sedang menulis cerita, tidak ada jawaban benar yang pasti. Tapi mari kita lihat beberapa contohnya dalam bahasa Inggris.

Jake menyapa Bill. Dia tidak menyukainya, jadi dia berbalik dan pergi ke arah lain.

Siapa yang pergi sebaliknya? Jake atau Bill? Dalam hal ini menggunakan nama "Jake" dan "Bill" seperti menggunakan nama tipe. Dan "Dia" dan "dia" seperti menggunakan varkata kunci. Dalam hal ini mungkin membantu untuk lebih spesifik. Contoh berikut ini jauh lebih jelas.

Jake menyapa Bill. Jake tidak menyukai Bill, jadi ia berbalik dan pergi ke arah lain.

Dalam hal ini menjadi lebih spesifik membuat kalimat menjadi lebih jelas. Tapi itu tidak selalu terjadi. Dalam beberapa kasus menjadi spesifik membuatnya lebih sulit untuk dibaca.

Bill suka buku, jadi Bill pergi ke perpustakaan dan Bill mengeluarkan buku yang selalu disukai Bill.

Dalam hal ini akan lebih mudah untuk membaca kalimat jika kita menggunakan "he" dan dalam beberapa kasus ditinggalkan namanya bersama-sama, yang setara dengan menggunakan varkata kunci.

Bill suka buku, jadi dia pergi ke perpustakaan dan mengeluarkan buku yang selalu dia sukai.

Contoh-contoh itu mencakup intinya, tetapi mereka tidak menceritakan keseluruhan cerita. Dalam contoh-contoh itu hanya ada satu cara untuk merujuk orang tersebut. Baik dengan menggunakan nama mereka atau dengan menggunakan istilah yang lebih umum seperti "dia" dan "dia".

Dalam hal kode, kami memiliki 3 cara untuk membantu menambah kejelasan. Jenis, nama variabel, dan penugasan. Ambil baris kode ini misalnya:

Person p = GetPerson();

Pertanyaannya sekarang adalah apakah ada cukup informasi dalam baris kode itu untuk membantu Anda mengetahui apa yang terjadi?

Bagaimana dengan baris kode berikut? Apakah Anda masih tahu apa partinya dalam hal ini:

var p = GetPerson();

Bagaimana kalau sekarang:

var p = Get();

Atau sekarang:

var person = Get();

Atau yang ini:

var t = GetPerson();

Atau ini:

var u = Person.Get();

Apakah kata kunci varberfungsi dalam skenario yang diberikan tergantung banyak pada konteks kode, seperti bagaimana variabel, kelas, dan metode diberi nama. Ini juga tergantung pada kompleksitas kode dan sisa kode di sekitarnya.

Secara pribadi saya suka menggunakan varkata kunci itu lebih komprehensif bagi saya sebagian besar waktu. Tapi saya juga cenderung memberi nama variabel saya setelah tipe jadi saya tidak benar-benar kehilangan informasi.

Yang mengatakan kadang-kadang tergantung pada konteks saya membuat pengecualian, seperti sifat dari sesuatu yang kompleks, dan perangkat lunak tidak ada artinya jika tidak kompleks.

Saya tidak menyukai ini juga.

Saya tidak ingin ini berubah menjadi perdebatan tentang penggunaan var, ini memiliki kegunaannya tetapi tidak boleh digunakan di mana-mana.

Hal utama yang perlu diingat adalah ReSharper dikonfigurasi untuk standar pengkodean apa pun yang Anda inginkan.

Sunting: ReSharper dan var

Saya melihat banyak jawaban yang benar, tetapi melewatkan jawaban yang lengkap.

Memang benar bahwa ReSharper berlebihan varsecara default. Saya pikir kebanyakan orang akan setuju dengan itu. Ini juga lebih mudah dibaca ketika vardigunakan dan jenisnya jelas seperti ketika Anda menggunakan newpernyataan. Saya melihat satu pos yang menunjukkan cara memperbarui keparahan inspeksi untuk hanya menunjukkan petunjuk untuk penggunaan var.

Saya telah mencoba mengomentari posting lain terlebih dahulu untuk menambahkan tempat untuk mengatur ini tetapi tidak memiliki reputasi untuk itu. Rupanya, saya juga tidak memiliki reputasi untuk mengirim tangkapan layar pengaturan saya.

Saya akan menjelaskan cara menuju ke sana.

Di Visual Studio> Menu Utama> Resharper> Pilihan> Pengeditan Kode> C #> Gaya Kode> Penggunaan Var dalam deklarasi

• Untuk tipe bawaan Gunakan tipe eksplisit
• Untuk tipe sederhana Gunakan 'var' saat terbukti
• Di Tempat Lain, Gunakan'var '

Dokumentasi bantuan ReSharper: Gaya Sintaksis Kode: Pengetikan Implisit / Eksplisit (Kata Kunci 'var') - Konfigurasikan preferensi penggunaan kata kunci 'var'

Aturan saya adalah ini:

• Apakah Anda mendeklarasikan tipe primitif (yaitu byte, char, string, int[], double?, decimal, dll)? -> Gunakan tipe:

  string myStr = "foo";
  int[] myIntArray = [123, 456, 789];
  double? myDouble = 123.3;

• Apakah Anda mendeklarasikan tipe kompleks (yaitu List<T>, Dictionary<T, T>, MyObj)? -> Gunakan var:

  var myList = List<string>();
  var myDictionary = Dictionary<string, string>();
  var myObjInstance = new MyObj();

Saya hanya ingin menunjukkan bahwa penggunaan "var" direkomendasikan dalam Konvensi C # Coding

ketika jenis variabel jelas dari sisi kanan penugasan, atau ketika jenis tepatnya tidak penting

jadi mungkin itulah sebabnya tip diaktifkan secara default di ReSharper. Mereka juga menyediakan beberapa kasus di mana itu tidak akan meningkatkan keterbacaan tepat di bawah dalam dokumen yang sama.

ReSharper merekomendasikan varkarena cenderung mengacaukan pembuatan objek.

Bandingkan dua contoh ini:

StringBuilder bld = new StringBuilder();

var bld = new StringBuilder();

Itu hanya singkatan yang seharusnya lebih mudah dibaca.

Saya pikir tidak apa-apa ketika Anda membuat objek baru secara eksplisit dengan "baru". Namun dalam contoh Anda, mungkin tidak jelas jika kelas tidak diberi nama dengan benar.

BTW, ReSharper menggambarkan perbedaan antara 'Anda mungkin ingin menerapkan saran ini ke kode Anda' dan 'kode Anda rusak, ingin saya memperbaikinya?'. Kata varkunci dalam kategori saran, bersama dengan hal-hal seperti "membalikkan jika mengurangi bersarang"; Anda tidak harus mengikutinya.

Anda dapat mengonfigurasikan betapa menjengkelkan setiap lansirannya melalui dialog Opsi, atau langsung melalui menu sembulan untuk lansiran itu. Anda dapat menurunkan versi hal-hal seperti varsaran sehingga kurang menonjol, atau Anda dapat memutakhirkan hal-hal seperti peringatan 'gunakan metode perluasan' sehingga muncul sebagai kesalahan aktual.

The varFitur Bersih 3.0 hanya inferensi tipe , yaitu tipe aman dan sering membuat kode Anda lebih mudah dibaca. Tetapi Anda tidak harus, dan dapat menonaktifkan rekomendasi itu di resharper jika Anda mau.

Var luar biasa! Saya telah menemukan banyak pengembang yang berada di bawah kesan yang varterikat pada tipe dinamis, bukan. Itu masih diketik secara statis, hanya diputuskan oleh kompiler.

Berikut adalah beberapa hal positif dari penggunaan var

Kurang mengetik var lebih pendek dan lebih mudah dibaca, misalnya

Dictionary<int,IList<string>> postcodes = new Dictionary<int,IList<string>>()Yuk.

var postcodes = new Dictionary<int,IList<string>>()\ o / \ o /

Lebih banyak nama variabel deskriptif - yang lemah tapi saya pikir penting untuk membiarkan sifat cairan varbersinar di sini. Seperti varsedikit kabur, itu benar-benar mendorong nama variabel yang lebih deskriptif daripada membiarkan tipe berbicara sendiri.

Kurangi perubahan kode - jika jenis pengembalian panggilan metode berubah. Anda hanya perlu mengubah pemanggilan metode, tidak setiap tempat digunakan.

Jenis anonim - jenis anonim adalah konsep yang sangat kuat, terutama di bidang-bidang seperti sumber daya parsial WebApi . Tanpa var, mereka tidak dapat digunakan.

Namun kadang-kadang berguna untuk secara eksplisit menyatakan jenis dan saya menemukan ini paling berguna dalam primitif atau struct. Sebagai contoh, saya pribadi tidak menemukan sintaks ini sangat berguna:

for(var i = 0; i < 10; i++) 
{

}

vs.

for(int i = 0; i < 10; i++) 
{

}

Semuanya tergantung pada preferensi pribadi tetapi menggunakan varbenar - benar akan mempercepat pengembangan Anda dan membuka seluruh dunia jenis kebaikan anonim.

Tidak ada perbedaan teknis, jika Anda menggunakan var, tipe tersirat oleh kompiler. Jika Anda memiliki kode seperti ini:

var x = 1;

x disiratkan sebagai int dan tidak ada nilai lain yang dapat ditetapkan untuknya.

Kata kunci var berguna jika Anda mengubah jenis variabel; Anda hanya perlu melakukan satu perubahan alih-alih dua:

var x = 1; --> var x = "hello";
int x = 1; --> string x = "hello";

Kata varkunci diperkenalkan di C # 3.0 - ini memungkinkan kita untuk melupakan menentukan jenis kita secara eksplisit.

Tidak ada perbedaan nyata untuk apakah Anda menggunakan atau tidak

MyObject foo = DB.MyObjects.SingleOrDefault(w => w.Id == 1);

atau

var foo = DB.MyObjects.SingleOrDefault(w => w.Id == 1);

kecuali keterbacaan murni dan sedikit kemungkinan kesalahan.

Sepertinya ini contoh klise, tetapi katakan hal berikut ini dapat membantu pemahaman Anda:

var myInt = 23;

mengembalikan inttipe, sedangkan

var myInt = "23";

mengembalikan stringtipe.

Referensi MSDN

Menentukan jenis objek eksplisit entah bagaimana berlebihan. Bahkan diterjemahkan dalam bahasa Inggris, itu terdengar berlebihan: "meletakkan objek tipe X dalam variabel tipe X" vs "Masukkan objek tipe X dalam variabel".

Namun, menggunakan 'var' memiliki keterbatasan . Ini mencegah penggunaan polimorfisme di bawah ini yang merupakan keindahan murni :

Anggaplah Anjing adalah Hewan; Cat memperluas hierarki kelas Hewan:

Animal x = new Dog();
DoStuffWithDog(x as Dog);

x = new Cat();
DoStuffWithCat(x as Cat);

void DoStuffWithDog(Dog d){}
void DoStuffWithCat(Cat c){}

Kode yang sama, dengan x yang dideklarasikan dengan 'var' tidak akan dikompilasi .

var x = new Dog(); // from this point, x is a Dog
DoStuffWithDog(x as Dog);

x = new Cat(); // cannot assign a Cat instance to a Dog
DoStuffWithCat(x as Cat);

void DoStuffWithDog(Dog d){}
void DoStuffWithCat(Cat c){}

Ngomong-ngomong, kembali ke pertanyaan awal, saya tidak menggunakan Resharper, tetapi saya menganggap itu cukup cerdas untuk mendeteksi kapan tidak menggunakan 'var'. :-)

Menurut saya, var seharusnya hanya digunakan ketika itu segera jelas apa jenisnya ketika mendefinisikan nilai variabel.

Contoh:

var s = "string value";

Jelas itu sadalah a string.

Saya percaya itu juga tepat ketika nama tipe variabel sangat kompleks.

Contoh:

Dictionary<SomeCustomKeyType, Dictionary<AnotherCustomKeyType, List<int>>> dict = new Dictionary<SomeCustomKeyType, Dictionary<AnotherCustomKeyType, List<int>>>();

// This is a little easier to read than the above statement
var dict = new Dictionary<SomeCustomKeyType, Dictionary<AnotherCustomKeyType, List<int>>>();

Selain skenario ini, saya tidak melihat GAIN dibuat dengan menggunakan var, tapi saya bisa memikirkan beberapa skenario yang bisa merugikan:

Misalnya, jenis sekali pakai yang nilai variabel sisi kanannya tidak jelas menunjukkan jenis itu. Membuang IDisposable dapat dengan mudah dilupakan

Contoh:

// returns some file writer
var wr = GetWriter();

wr.add("stuff");
wr.add("more stuff");

//...
//...

// Now `wr` needs to be disposed, 
// but there is no clear indication of the type of `wr`,
// so it will be easily overlooked by code writer and code reviewer.

'var' menambahkan semacam elemen "dinamis" ke kode Anda (meskipun kode tetap diketik dengan ketat). Saya menyarankan agar tidak menggunakannya dalam kasus di mana tipenya tidak jelas. Pertimbangkan contoh ini:

var bar = GetTheObjectFromDatabase();
bar.DoSomething();

ClassA {
  void DoSomething() {
  //does something
  }
}

ClassB {
  void DoSomething() {
  //does something entirely different
  }
}

Jika Tipe pengembalian GetTheObjectFromDatabase () diubah dari Tipe A ke B kami tidak akan melihat, karena kedua Kelas menerapkan DoSomething (). Namun, kode tersebut sekarang dapat benar-benar melakukan sesuatu yang sama sekali berbeda.

Ini mungkin sama halusnya seperti menulis hal-hal yang berbeda ke log, jadi Anda mungkin tidak menyadari bahwa unitl sudah terlambat.

Penggunaan var berikut harus selalu baik-baik saja:

var abc = new Something();

Bagi mereka yang tidak menyukai penggunaan "var" secara konstan, Anda juga dapat menghentikan ReSharper dari default ke var ketika melakukan "memperkenalkan variabel". Ini adalah sesuatu yang membuat saya frustrasi untuk waktu yang lama, selalu default untuk var, dan saya mengubahnya setiap waktu.

Pengaturan ini berada di bawah Pengeditan Kode> C #> Gaya Kode

Tidak ada perbedaan teknis (seperti yang ditunjukkan eWolf). Anda dapat menggunakan satu atau yang lain, kode CLR yang dihasilkan akan terlihat sama.

Menurut pendapat saya manfaat utama adalah bahwa ini cenderung memaksa Anda untuk menggunakan penamaan variabel yang lebih baik. Dalam contoh Anda, 'foo' adalah pilihan yang sangat buruk untuk nama variabel.

Menurut JetBrains (penulis ReSharper), mereka mendorong penggunaan var secara default.

Dari situs web mereka :

Menggunakan variabel lokal yang diketik secara implisit (juga dikenal sebagai varkata kunci) yang diperkenalkan dalam C # 3.0 telah menjadi cukup populer karena meningkatkan keterbacaan dalam banyak skenario. Secara default, ReSharper juga menganjurkan penggunaan varkata kunci, tetapi preferensi penggunaannya dapat dikonfigurasi secara fleksibel - misalnya, Anda dapat memilih untuk menggunakan jenis eksplisit dalam kasus tertentu atau di mana saja dan ReSharper akan membantu Anda menegakkan preferensi Anda.