ทำไม ReSharper ต้องการใช้ 'var' สำหรับทุกสิ่ง

ฉันเพิ่งเริ่มใช้ ReSharper กับ Visual Studio (หลังจากคำแนะนำมากมายใน SO) หากต้องการลองฉันเปิดโครงการ ASP.NET MVC เมื่อเร็ว ๆ นี้ หนึ่งในสิ่งแรกและบ่อยที่สุดที่ฉันสังเกตเห็นมันคือการแนะนำให้เปลี่ยน / ประกาศทั้งหมดของฉันชัดเจนที่สุดไปvarแทน ตัวอย่างเช่น:

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

และอื่น ๆ แม้จะมีประเภทง่ายๆเช่นint, boolฯลฯ

เหตุใดจึงมีการแนะนำนี้ ฉันไม่ได้มาจากวิทยาการคอมพิวเตอร์หรือพื้นหลัง. NET มี "ตกอยู่ใน" การพัฒนา. NET เมื่อเร็ว ๆ นี้ดังนั้นฉันชอบที่จะเข้าใจสิ่งที่เกิดขึ้นและไม่ว่าจะเป็นประโยชน์หรือไม่

เหตุผลหนึ่งที่ทำให้อ่านง่ายขึ้น ไหนดีกว่ากัน

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

หรือ

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

สิ่งที่ ReSharper แนะนำคือการใช้คำหลัก var มากเกินไปอย่างชัดเจน คุณสามารถใช้มันในกรณีที่ประเภทชัดเจน:

var obj = new SomeObject();

หากประเภทไม่ชัดเจนคุณควรเขียน:

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

ฉันชอบที่จะปิดคำแนะนำนี้เป็นการส่วนตัว การใช้varบ่อยครั้งสามารถปรับปรุงความสามารถในการอ่านได้ แต่ดังที่คุณกล่าวถึงบางครั้งก็ลดขนาดมันลง (ด้วยประเภทที่เรียบง่ายหรือเมื่อประเภทผลลัพธ์ที่ไม่ชัดเจน )

ฉันชอบที่จะเลือกเมื่อฉันใช้varและเมื่อฉันไม่ แต่นั่นเป็นเพียงฉัน

varสามารถเพิ่มความสามารถในการอ่านของรหัสในขณะที่ลดความเข้าใจรหัสทันที เช่นเดียวกันมันสามารถลดความสามารถในการอ่านของรหัสสำหรับสถานการณ์อื่น ๆ บางครั้งการใช้มันเป็นกลาง การวัดความสามารถในการอ่านเพื่อความเข้าใจไม่ได้เป็นสัดส่วน แต่ขึ้นอยู่กับสถานการณ์ บางครั้งทั้งสองจะเพิ่มขึ้นหรือลดลงด้วยกัน

ปัจจัยคืออะไร varถูกนำไปใช้และเป้าหมายสนับสนุนการทำให้ข้อมูลประเภทนั้นสับสนกับผู้อ่านได้ทันทีหรือหากจำเป็นต้องใช้ข้อมูลประเภทนั้นในการทำความเข้าใจส่วนของโปรแกรมในมือ

ตัวอย่างเช่นการตั้งชื่อไม่ดีสามารถนำไปสู่การvarลดความเข้าใจรหัส นี่ไม่ใช่varความผิดของ:

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

บางครั้งมันก็ไม่สมเหตุสมผลที่จะใช้varกับชนิดข้อมูลอย่างง่าย ๆ เมื่อโค้ดอ่านได้ง่ายขึ้นในกรณีที่ไม่มี:

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

บางครั้งvarอาจมีประโยชน์ในการซ่อนข้อมูลประเภทข้อมูลที่คุณไม่ต้องการดูแลเพื่อดูความซับซ้อนของ:

    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; 

คุณต้องใช้varเมื่อมีประเภทที่ไม่ระบุชื่ออยู่เนื่องจากไม่มีชื่อประเภทที่จะเรียกโดย:

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

เมื่อคุณมี Intellisense Visual Studio ที่ให้ข้อมูลประเภททั้งๆที่varคุณต้องพึ่งพาความเข้าใจของคุณน้อยลงผ่านการอ่านรหัสที่เข้มงวดโดยไม่ต้องให้ความช่วยเหลือ อาจเป็นการดีที่จะสมมติว่าไม่ใช่ทุกคนที่มีหรือใช้ Intellisense

โดยสรุปจากตัวอย่างข้างต้นฉันขอแนะนำให้ใช้แอปพลิเคชันตามสั่งของ blanchevarไม่ใช่ความคิดที่ดีเพราะสิ่งต่าง ๆ ส่วนใหญ่ทำได้ดีที่สุดในการกลั่นกรองและตามสถานการณ์ในมือดังที่แสดงไว้ที่นี่

เหตุใด Resharper จึงใช้ค่านี้โดยปริยาย ฉันขอแนะนำให้ใช้งานง่ายเพราะมันไม่สามารถแยกความแตกต่างของสถานการณ์ที่จะตัดสินใจได้ดีที่สุดว่าจะไม่ใช้เมื่อใด

ใน ReSharper (8.02 แต่รุ่นอื่น ๆ มีแนวโน้ม) ตัวเลือกสำหรับข้อเสนอแนะ "ใช้พิมพ์โดยปริยายประกาศตัวแปรท้องถิ่น" สามารถปรับให้คุณตั้งค่าสิ่งที่อาจจะโดยการเปิดตัวครั้งแรกเมนูตัวเลือกสำหรับ ReSharper:

จากนั้นภายใต้ "การตรวจสอบรหัส" โดยปรับ "ความรุนแรงในการตรวจสอบ" ของภาษาที่คุณเลือกในกรณีของฉัน c #:

อย่างที่คุณเห็นมีตัวเลือกในการปรับคำแนะนำทั้งหมดที่ ReSharper ทำ ความหวังนี้จะช่วยให้คนอย่างฉันที่มีกลยุทธ์การใช้งาน 'var' อยู่แล้วและต้องการให้ ReSharper ให้ความเคารพ :)

ฉันประหลาดใจที่ไม่มีใครพูดถึงว่ามันง่ายกว่าที่จะเปลี่ยนประเภทของวัตถุที่สร้างอินสแตนซ์

AVeryLongTypeName myVariable = new AVeryLongTypeName( arguments );

เป็นรูปแบบของการทำซ้ำ ถ้าฉันต้องการที่จะเปลี่ยนAVeryLongTypeNameเป็นหนึ่งในชั้นเรียนที่ได้รับของมันฉันต้องเปลี่ยนเพียงครั้งเดียวเมื่อใช้varและยังคงสามารถเข้าถึงวิธีการของชั้นเรียนเด็ก

นอกเหนือจากนั้นความสามารถในการอ่านที่ดีขึ้นเป็นประเด็นสำคัญ แต่อย่างที่คนอื่นพูดว่าไม่ควรใช้ความแปรปรวนมากเกินไปดังนั้นฉันคิดว่าการปิดคำใบ้ใน Resharper นั้นทำได้อย่างสมบูรณ์

'var' กำลังจะชัดเจน

การถกเถียงหลักเกี่ยวกับว่าจะใช้varคำหลักหรือไม่นั้นเป็นเรื่องเกี่ยวกับวิธีการอ่านรหัสที่มีต่อคุณและนักพัฒนาอื่น ๆ

ราวกับว่าคุณกำลังเขียนเรื่องราวไม่มีคำตอบที่ถูกต้องชัดเจน แต่ลองมาดูตัวอย่างของสิ่งนี้เป็นภาษาอังกฤษธรรมดา

เจคกล่าวทักทายกับบิล เขาไม่ชอบเขาดังนั้นเขาจึงหันไปทางอื่น

ใครไปทางอื่น เจคหรือบิล? ในกรณีนี้การใช้ชื่อ "Jake" และ "Bill" ก็เหมือนกับการใช้ชื่อประเภท และ "เขา" และ "เขา" ก็เหมือนกับการใช้varคำหลัก ในกรณีนี้อาจช่วยให้เฉพาะเจาะจงมากขึ้น ตัวอย่างต่อไปนี้ชัดเจนยิ่งขึ้น

เจคกล่าวทักทายกับบิล เจคไม่ชอบบิลดังนั้นเขาจึงหันไปทางอื่น

ในกรณีนี้การเจาะจงมากขึ้นทำให้ประโยคชัดเจนยิ่งขึ้น แต่นั่นไม่ได้เป็นกรณีเสมอไป ในบางกรณีความเฉพาะเจาะจงทำให้อ่านยากขึ้น

Bill ชอบหนังสือดังนั้น Bill จึงไปที่ห้องสมุดและ Bill เอาหนังสือที่ Bill ชอบมาตลอด

ในกรณีนี้มันจะง่ายต่อการอ่านประโยคถ้าเราใช้ "เขา" และในบางกรณีทำให้ชื่อของเขาหายไปด้วยกันซึ่งเทียบเท่ากับการใช้varคำหลัก

บิลชอบหนังสือดังนั้นเขาจึงไปที่ห้องสมุดและหยิบหนังสือที่เขาชอบมาตลอด

ตัวอย่างเหล่านั้นครอบคลุมส่วนสำคัญ แต่พวกเขาไม่ได้บอกเรื่องราวทั้งหมด ในตัวอย่างเหล่านั้นมีเพียงวิธีเดียวในการอ้างถึงบุคคลนั้น ทั้งโดยใช้ชื่อของพวกเขาหรือโดยใช้คำทั่วไปเช่น "เขา" และ "เขา"

ในกรณีของรหัสเรามี 3 วิธีที่เราช่วยเพิ่มความชัดเจน ชนิดชื่อตัวแปรและการกำหนด ใช้บรรทัดของรหัสนี้เช่น:

Person p = GetPerson();

ตอนนี้กลายเป็นคำถามมีข้อมูลเพียงพอในบรรทัดของรหัสนั้นเพื่อช่วยให้คุณทราบว่าเกิดอะไรขึ้น

แล้วโค้ดต่อไปนี้ล่ะ? คุณยังคงรู้pว่าในกรณีนี้มีความหมายอย่างไร:

var p = GetPerson();

ตอนนี้:

var p = Get();

หรือตอนนี้:

var person = Get();

หรืออันนี้:

var t = GetPerson();

หรือสิ่งนี้:

var u = Person.Get();

ไม่ว่าจะเป็นคำสำคัญ varทำงานในสถานการณ์ที่กำหนดหรือไม่นั้นขึ้นอยู่กับบริบทของรหัสเช่นวิธีการตั้งชื่อตัวแปรคลาสและวิธีการต่างๆ นอกจากนี้ยังขึ้นอยู่กับความซับซ้อนของรหัสและรหัสที่เหลือโดยรอบ

โดยส่วนตัวแล้วฉันชอบที่จะใช้varคำหลักมันครอบคลุมมากขึ้นสำหรับฉันตลอดเวลา แต่ฉันก็มักจะตั้งชื่อตัวแปรของฉันตามประเภทดังนั้นฉันจะไม่สูญเสียข้อมูลใด ๆ

ที่กล่าวว่าบางครั้งขึ้นอยู่กับบริบทที่ฉันทำข้อยกเว้นเช่นลักษณะของสิ่งที่ซับซ้อนและซอฟต์แวร์คืออะไรถ้าไม่ซับซ้อน

ฉันไม่ชอบสิ่งนี้เช่นกัน

ฉันไม่ต้องการให้สิ่งนี้กลายเป็นการอภิปรายเกี่ยวกับการใช้varมันมีประโยชน์ แต่ไม่ควรใช้ทุกที่

สิ่งสำคัญที่ต้องจำคือ ReSharper ถูกกำหนดค่าให้เป็นมาตรฐานการเข้ารหัสที่คุณต้องการ

แก้ไข: ReSharper และ var

ฉันเห็นคำตอบที่ถูกต้องมากมาย แต่ไม่มีคำตอบเต็ม

มันเป็นความจริงที่ ReSharper overuses varโดยปริยาย ฉันคิดว่าคนส่วนใหญ่จะเห็นด้วยกับที่ นอกจากนี้ยังง่ายต่อการอ่านเมื่อvarมีการใช้งานและประเภทจะชัดเจนเช่นเมื่อคุณใช้newคำสั่ง ฉันเห็นหนึ่งโพสต์ที่แสดงวิธีการอัปเดตความรุนแรงของการตรวจสอบเพื่อแสดงเฉพาะคำแนะนำสำหรับการใช้งานvarผมเห็นโพสต์หนึ่งที่แสดงให้เห็นถึงวิธีการปรับปรุงการตรวจสอบความรุนแรงที่จะแสดงเฉพาะคำแนะนำสำหรับการใช้งานของ

ฉันพยายามแสดงความคิดเห็นในโพสต์อื่นก่อนเพื่อเพิ่มตำแหน่งที่จะตั้งค่าเหล่านี้ แต่ไม่มีชื่อเสียงสำหรับมัน เห็นได้ชัดว่าฉันยังไม่มีชื่อเสียงในการโพสต์ภาพหน้าจอของการตั้งค่า

ฉันจะอธิบายวิธีการเดินทาง

ใน Visual Studio> เมนูหลัก> Resharper> ตัวเลือก> การแก้ไขรหัส> C #> ลักษณะรหัส> การใช้ Var ในการประกาศ

• สำหรับประเภทในตัวใช้ประเภทที่ชัดเจน
• สำหรับประเภทง่าย ๆ ให้ใช้ 'var' เมื่อเห็นได้ชัด
• ที่อื่น Use'var '

เอกสารวิธีใช้ ReSharper ใหม่: รูปแบบไวยากรณ์ของโค้ด: การพิมพ์โดยนัย / โดยชัดแจ้ง (คำหลัก 'var') - กำหนดค่าการกำหนดลักษณะการใช้คำหลัก 'var'

กฎของฉันคือ:

• คุณกำลังประกาศชนิดดั้งเดิม (เช่นbyte, char, string, int[], double?, decimalฯลฯ )? -> ใช้ประเภท:

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

• คุณกำลังประกาศประเภทที่ซับซ้อน (เช่นList<T>, Dictionary<T, T>, MyObj)? -> การใช้งานvar:

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

ฉันต้องการจะชี้ให้เห็นว่าแนะนำให้ใช้ "var" ในข้อตกลงการเข้ารหัส C #

เมื่อชนิดของตัวแปรชัดเจนจากด้านขวาของการกำหนดหรือเมื่อชนิดที่แม่นยำไม่สำคัญ

ดังนั้นนั่นอาจเป็นสาเหตุที่ทิปเปิดอยู่ตามค่าเริ่มต้นใน ReSharper พวกเขายังให้บางกรณีที่จะไม่ปรับปรุงการอ่านด้านล่างขวาในเอกสารเดียวกัน

ReSharper แนะนำvarเพราะมันมีแนวโน้มที่จะกระจายการสร้างวัตถุ

เปรียบเทียบตัวอย่างทั้งสองนี้:

StringBuilder bld = new StringBuilder();

var bld = new StringBuilder();

มันเป็นแค่ชวเลขที่ควรอ่านง่ายขึ้น

ฉันคิดว่าไม่เป็นไรเมื่อคุณสร้างวัตถุใหม่อย่างชัดเจนด้วย "ใหม่" ในตัวอย่างของคุณอาจไม่ชัดเจนว่าคลาสนั้นมีชื่อไม่ถูกต้องหรือไม่

BTW, ReSharper ดึงความแตกต่างระหว่าง 'คุณอาจต้องการใช้คำแนะนำนี้กับรหัสของคุณ' และ 'รหัสของคุณเสียต้องการให้ฉันแก้ไขหรือไม่' varคำหลักในหมวดหมู่คำแนะนำพร้อมกับสิ่งที่ชอบ "กลับถ้าจะลดการทำรัง"; คุณไม่ต้องทำตาม

คุณสามารถกำหนดค่าว่าการแจ้งเตือนแต่ละรายการนั้นน่ารำคาญแค่ไหนในกล่องโต้ตอบตัวเลือกหรือผ่านเมนูป๊อปอัพสำหรับการแจ้งเตือนนั้นโดยตรง คุณสามารถลดระดับสิ่งต่าง ๆ เช่นvarข้อเสนอแนะเพื่อให้พวกเขาโดดเด่นน้อยลงหรือคุณสามารถอัพเกรดสิ่งต่าง ๆ เช่นการแจ้งเตือน 'ใช้วิธีการขยาย' เพื่อให้มันปรากฏเป็นข้อผิดพลาดจริง

varคุณสมบัติของสุทธิ 3.0 เป็นเพียงการอนุมานชนิดซึ่งเป็นชนิดที่ปลอดภัยและมักจะทำให้รหัสของคุณให้อ่านง่ายขึ้น แต่คุณไม่จำเป็นต้องทำและสามารถปิดคำแนะนำนั้นเป็น resharper ได้หากต้องการ

Var เป็นสิ่งที่น่าทึ่ง! ฉันได้เจอนักพัฒนาหลายคนที่อยู่ภายใต้การแสดงผลที่varถูกผูกไว้กับประเภทไดนามิกมันไม่ได้เป็น มันยังคงพิมพ์แบบคงที่มันเป็นเพียงการตัดสินใจโดยคอมไพเลอร์

ต่อไปนี้เป็นข้อดีบางประการของการใช้ var

var ที่พิมพ์น้อยกว่านั้นสั้นกว่าและอ่านง่ายกว่าเช่น

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

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

ชื่อตัวแปรอธิบายเพิ่มเติม - ผอมบาง แต่ฉันคิดว่ามันสำคัญที่จะปล่อยให้ธรรมชาติของvarแสงเปล่งปลั่งที่นี่ ในฐานะที่varเป็นบิตคลุมเครือจริงๆมันไม่ขอแนะนำให้ชื่อตัวแปร desciptive มากขึ้นมากกว่าการปล่อยให้ชนิดที่พูดสำหรับตัวเอง

การเปลี่ยนแปลงรหัสน้อยลง - หากประเภทการส่งคืนของการเรียกใช้เมธอดเปลี่ยนแปลง คุณต้องเปลี่ยนวิธีการโทรไม่ใช่ทุกที่ที่ใช้

ชนิดที่ไม่ระบุชื่อ - ประเภทที่ไม่ระบุชื่อเป็นแนวคิดที่มีประสิทธิภาพจริงๆโดยเฉพาะอย่างยิ่งในพื้นที่เช่น WebAPI ทรัพยากรบางส่วน หากไม่มี var จะไม่สามารถใช้งานได้

บางครั้งมันก็มีประโยชน์ในการประกาศประเภทอย่างชัดเจนและฉันพบว่ามีประโยชน์มากที่สุดในแบบดั้งเดิมหรือโครงสร้าง ตัวอย่างเช่นฉันไม่พบว่าไวยากรณ์นี้มีประโยชน์มาก:

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

}

VS

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

}

ทุกอย่างขึ้นอยู่กับความชอบส่วนบุคคล แต่การใช้งานvarจริง ๆ จะช่วยเร่งการพัฒนาของคุณและปลดล็อกโลกทั้งโลกของความดีงามประเภทนิรนาม

ไม่มีความแตกต่างทางเทคนิคถ้าคุณใช้ var ประเภทจะถูกแปลโดยคอมไพเลอร์ หากคุณมีรหัสเช่นนี้:

var x = 1;

x มีความหมายว่าเป็น int และไม่มีค่าอื่นใดที่สามารถกำหนดได้

คำหลัก var มีประโยชน์หากคุณเปลี่ยนชนิดของตัวแปร จากนั้นคุณจะต้องทำการเปลี่ยนแปลงเพียงครั้งเดียวแทนที่จะเป็นสอง:

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

varคำหลักที่ถูกนำมาใช้ใน C # 3.0 - มันช่วยให้เราสามารถลืมเกี่ยวกับการระบุชนิดของเราอย่างชัดเจน

ไม่มีความแตกต่างที่แท้จริงว่าคุณใช้

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

หรือ

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

ยกเว้นการอ่านอย่างแท้จริงและโอกาสน้อยกว่าสำหรับข้อผิดพลาด

ดูเหมือนว่าเป็นตัวอย่างโบราณ แต่การพูดต่อไปนี้อาจช่วยให้คุณเข้าใจ:

var myInt = 23;

ส่งคืนintชนิดในขณะที่

var myInt = "23";

ส่งคืนstringชนิด

การอ้างอิง MSDN

การระบุประเภทวัตถุที่ชัดเจนเป็นอย่างใดซ้ำซ้อน แม้จะแปลเป็นภาษาอังกฤษมันฟังดูซ้ำซ้อน: "ใส่อ็อบเจกต์ประเภท X ลงในตัวแปรประเภท X" vs "วางออบเจ็กต์ประเภท X ลงในตัวแปร"

อย่างไรก็ตามการใช้ 'var' มีของข้อ จำกัด มันป้องกันการใช้polymorphismด้านล่างซึ่งเป็นความงามที่บริสุทธิ์ :

สมมติว่าสุนัขขยายสัตว์; Cat ขยายลำดับชั้นของสัตว์:

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

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

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

รหัสเดียวกันกับ x ประกาศด้วย 'var' จะไม่ได้รวบรวม

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

ยังไงก็ตามกลับไปที่คำถามเดิมฉันไม่ได้ใช้ Resharper แต่ฉันคิดว่ามันฉลาดพอที่จะตรวจจับเวลาที่ไม่ใช้ 'var' :-)

ในมุมมองของฉันvarควรใช้เมื่อชัดเจนทันทีประเภทคือเมื่อกำหนดค่าของตัวแปร

ตัวอย่าง:

var s = "string value";

เป็นที่ชัดเจนว่าเป็นsstring

ฉันเชื่อว่ามันก็เหมาะสมเมื่อชื่อประเภทตัวแปรนั้นซับซ้อนมาก

ตัวอย่าง:

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

นอกเหนือจากสถานการณ์เหล่านี้ฉันไม่เห็นกำไรใด ๆ ที่จะทำโดยใช้varแต่ฉันสามารถนึกถึงบางสถานการณ์ที่เป็นอันตราย:

ตัวอย่างเช่นชนิดที่ใช้แล้วทิ้งซึ่งมีค่าตัวแปรทางด้านขวาไม่แสดงประเภทอย่างชัดเจน การทิ้ง IDisposable นั้นสามารถลืมได้ง่ายๆ

ตัวอย่าง:

// 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' เพิ่มองค์ประกอบ "ไดนามิก" ลงในรหัสของคุณ (แม้ว่ารหัสจะยังคงพิมพ์อยู่อย่างแน่นอน) ฉันแนะนำให้ใช้กับมันในกรณีที่ประเภทไม่ชัดเจน ลองพิจารณาตัวอย่างนี้:

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

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

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

หากการคืนค่าชนิดของ GetTheObjectFromDatabase () เปลี่ยนจาก Type A เป็น B เราจะไม่สังเกตเห็นเนื่องจากทั้งสองคลาสใช้ DoSomething () อย่างไรก็ตามรหัสอาจทำอะไรที่แตกต่างไปจากเดิมอย่างสิ้นเชิง

สิ่งนี้อาจจะบอบบางทั้งสองเขียนสิ่งต่าง ๆ ลงในบันทึกดังนั้นคุณอาจไม่สังเกตเห็นว่ายูนิตนั้นสายเกินไป

การใช้ var ต่อไปนี้ควรจะใช้ได้:

var abc = new Something();

สำหรับผู้ที่ไม่ชอบการใช้ "var" อย่างต่อเนื่องคุณสามารถหยุด ReSharper จากการตั้งค่าเริ่มต้นเป็น var เมื่อทำ "แนะนำตัวแปร" นี่เป็นสิ่งที่ทำให้ฉันหงุดหงิดเป็นเวลานานมันมักจะผิดนัด var และฉันก็เปลี่ยนมันทุกครั้ง

การตั้งค่าเหล่านี้อยู่ภายใต้การแก้ไขรหัส> C #> ลักษณะของรหัส

ไม่มีความแตกต่างทางเทคนิค (ตามที่ eWolf ชี้ให้เห็น) คุณสามารถใช้อย่างใดอย่างหนึ่งรหัส CLR ที่สร้างขึ้นจะมีลักษณะเดียวกัน

ในความคิดของฉันประโยชน์หลักคือมันบังคับให้คุณใช้การตั้งชื่อตัวแปรที่ดีกว่า ในตัวอย่าง 'foo' ของคุณเป็นตัวเลือกที่ไม่ดีนักสำหรับชื่อตัวแปร

ตาม JetBrains (ผู้เขียน ReSharper) พวกเขาสนับสนุนให้ใช้ var โดยค่าเริ่มต้น

จากเว็บไซต์ของพวกเขา :

การใช้ตัวแปรท้องถิ่นที่พิมพ์ไว้โดยนัย (หรือที่รู้จักกันว่าvarคำหลัก) ที่นำมาใช้ใน C # 3.0 ได้รับความนิยมอย่างมากเนื่องจากช่วยเพิ่มความสามารถในการอ่านในสถานการณ์ต่างๆ ตามค่าเริ่มต้น ReSharper ยังสนับสนุนให้ใช้varคำหลัก แต่การกำหนดลักษณะการใช้งานนั้นสามารถกำหนดค่าได้อย่างยืดหยุ่นตัวอย่างเช่นคุณสามารถเลือกใช้ประเภทที่ชัดเจนในบางกรณีหรือทุกที่และ ReSharper จะช่วยให้คุณบังคับใช้ค่ากำหนดของคุณ