ใน C # ฉันควรใช้ string.Empty หรือ String.Empty หรือ“” เพื่อทำให้สตริงเป็นตัวเริ่มต้นหรือไม่?

ใน C # ฉันต้องการเริ่มต้นค่าสตริงด้วยสตริงว่าง

ฉันจะทำสิ่งนี้ได้อย่างไร อะไรคือวิธีที่ถูกต้องและทำไม

string willi = string.Empty;

หรือ

string willi = String.Empty;

หรือ

string willi = "";

หรืออะไร?

ใช้สิ่งที่คุณและทีมหาได้มากที่สุด

คำตอบอื่น ๆ ""ได้แนะนำว่าสตริงใหม่จะถูกสร้างขึ้นทุกครั้งที่คุณใช้ สิ่งนี้ไม่เป็นความจริง - เนื่องจากการฝึกงานสตริงมันจะถูกสร้างขึ้นหนึ่งครั้งต่อแอสเซมบลีหรือหนึ่งครั้งต่อ AppDomain (หรืออาจเกิดขึ้นเพียงครั้งเดียวสำหรับกระบวนการทั้งหมด - ไม่แน่ใจในหน้านั้น) ความแตกต่างนี้เล็กน้อย - อย่างหนาแน่นและไม่มีนัยสำคัญอย่างหนาแน่น

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

การโต้เถียงที่ผิดพลาด""และ" "ง่ายต่อกันไม่ได้ล้างด้วยฉันจริงๆ ถ้าคุณกำลังใช้ตัวอักษรสัดส่วน (และฉันไม่ได้ทำงานร่วมกับใด ๆนักพัฒนาที่ทำ) ก็สวยง่ายที่จะบอกความแตกต่าง

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

ในการดูโค้ดเบื้องหลังคุณจะไม่เห็นความแตกต่างเลย ความแตกต่างเพียงอย่างเดียวคือใน IL ซึ่งstring.Emptyใช้ opcode ldsfld และ""ใช้ opcode ldstrแต่นั่นเป็นเพียงเพราะstring.Emptyเป็นแบบคงที่และทั้งสองคำสั่งทำสิ่งเดียวกัน ถ้าคุณดูแอสเซมบลีที่ผลิตมันจะเหมือนกันทุกประการ

รหัส C #

private void Test1()
{
    string test1 = string.Empty;    
    string test11 = test1;
}

private void Test2()
{
    string test2 = "";    
    string test22 = test2;
}

รหัส IL

.method private hidebysig instance void 
          Test1() cil managed
{
  // Code size       10 (0xa)
  .maxstack  1
  .locals init ([0] string test1,
                [1] string test11)
  IL_0000:  nop
  IL_0001:  ldsfld     string [mscorlib]System.String::Empty
  IL_0006:  stloc.0
  IL_0007:  ldloc.0
  IL_0008:  stloc.1
  IL_0009:  ret
} // end of method Form1::Test1

.method private hidebysig instance void 
        Test2() cil managed
{
  // Code size       10 (0xa)
  .maxstack  1
  .locals init ([0] string test2,
                [1] string test22)
  IL_0000:  nop
  IL_0001:  ldstr      ""
  IL_0006:  stloc.0
  IL_0007:  ldloc.0
  IL_0008:  stloc.1
  IL_0009:  ret
} // end of method Form1::Test2

รหัสการประกอบ

        string test1 = string.Empty;
0000003a  mov         eax,dword ptr ds:[022A102Ch] 
0000003f  mov         dword ptr [ebp-40h],eax 

        string test11 = test1;
00000042  mov         eax,dword ptr [ebp-40h] 
00000045  mov         dword ptr [ebp-44h],eax 

        string test2 = "";
0000003a  mov         eax,dword ptr ds:[022A202Ch] 
00000040  mov         dword ptr [ebp-40h],eax 

        string test22 = test2;
00000043  mov         eax,dword ptr [ebp-40h] 
00000046  mov         dword ptr [ebp-44h],eax 

รหัสที่ดีที่สุดคือไม่มีรหัสเลย :

ลักษณะพื้นฐานของการเขียนโปรแกรมคืองานของเราในฐานะโปรแกรมเมอร์คือการตระหนักว่าการตัดสินใจทุกครั้งที่เราทำคือการแลกเปลี่ยน […] เริ่มด้วยความกะทัดรัด เพิ่มมิติอื่นตามที่ต้องการโดยการทดสอบ

ดังนั้นโค้ดน้อยเป็นรหัสที่ดีกว่า: ชอบ""ไปหรือstring.Empty String.Emptyทั้งสองนั้นมีความยาวเพิ่มขึ้นหกเท่าโดยไม่มีผลประโยชน์เพิ่มเติม - แน่นอนว่าไม่มีความชัดเจนที่เพิ่มขึ้นเนื่องจากพวกเขาแสดงข้อมูลเดียวกันที่แน่นอน

สิ่งหนึ่งที่แตกต่างคือถ้าคุณใช้switch-caseไวยากรณ์คุณไม่สามารถเขียนได้case string.Empty:เพราะมันไม่คงที่ คุณจะได้รับCompilation error : A constant value is expected

ดูที่ลิงค์นี้สำหรับข้อมูลเพิ่มเติม: คำพูดสตริงว่างเปล่าและว่างเปล่าคำพูด

ฉันไม่ต้องการที่จะstring Stringเลือกstring.Emptyมากกว่า""เป็นเรื่องของการเลือกหนึ่งและเกาะติดกับมัน ประโยชน์ของการใช้string.Emptyมันเป็นที่ชัดเจนมากสิ่งที่คุณหมายและคุณไม่ได้ตั้งใจคัดลอกตัวอักษรมากกว่าที่ไม่พิมพ์เหมือนในของคุณ"\x003"""

ฉันจะไม่พูดสอด แต่ฉันเห็นข้อมูลผิดพลาดที่จะถูกโยนออกจากที่นี่

string.Emptyผมเองชอบ นั่นเป็นความชอบส่วนตัวและฉันก็มุ่งมั่นที่จะทำตามความต้องการของทีมที่ฉันทำงานด้วยเป็นกรณีไป

ขณะที่บางคนอื่น ๆ ได้กล่าวถึงมีความแตกต่างในระหว่างไม่มีและstring.EmptyString.Empty

นอกจากนี้และนี่เป็นความจริงที่รู้จักกันน้อยการใช้ "" เป็นที่ยอมรับอย่างสมบูรณ์ ทุกตัวอย่างของ "" จะสร้างวัตถุในสภาพแวดล้อมอื่น อย่างไรก็ตาม. NET ฝึกงานสตริงของมันดังนั้นอินสแตนซ์ในอนาคตจะดึงสตริงที่ไม่เปลี่ยนรูปแบบเดียวกันจากกลุ่มฝึกงานและผลการปฏิบัติงานใด ๆ ที่จะเล็กน้อย ที่มา: แบรดอับราฮัม

ฉันชอบมากกว่า "" ถ้าไม่มีเหตุผลที่ดีสำหรับบางสิ่งที่ซับซ้อนกว่า

String.Emptyและstring.Emptyเทียบเท่า Stringคือชื่อคลาส BCL stringคือ C # นามแฝง (หรือทางลัดหากคุณต้องการ) เช่นเดียวกับกับและInt32 intดูเอกสารสำหรับตัวอย่างเพิ่มเติม

เท่าที่""เกี่ยวข้องฉันไม่แน่ใจจริงๆ

string.Emptyส่วนตัวผมมักจะใช้

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

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

ฉันพบความแตกต่างในพฤติกรรมของคอมไพเลอร์ถ้าคุณใช้string.Emptyหรือเครื่องหมายคำพูดคู่ ความแตกต่างแสดงตัวเองถ้าคุณไม่ใช้ตัวแปรสตริงที่เริ่มต้นด้วย string.Empty หรือด้วยเครื่องหมายคำพูดคู่

ในกรณีของการเริ่มต้นด้วยstring.Emptyคำเตือนคอมไพเลอร์

CS0219 - The variable 'x' is assigned but its value is never used

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

พฤติกรรมนี้มีการอธิบายไว้ในบทความเชื่อมต่อที่ลิงก์นี้: https://connect.microsoft.com/VisualStudio/feedback/details/799810/c-warning-cs0219-not-reported-when-assign-non-constant-value

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

ฉันทำการทดสอบง่าย ๆ โดยใช้วิธีการต่อไปนี้ในแอปพลิเคชันคอนโซล:

private static void CompareStringConstants()
{
    string str1 = "";
    string str2 = string.Empty;
    string str3 = String.Empty;
    Console.WriteLine(object.ReferenceEquals(str1, str2)); //prints True
    Console.WriteLine(object.ReferenceEquals(str2, str3)); //prints True
}

นี้อย่างชัดเจนแสดงให้เห็นว่าทั้งสามตัวแปรคือstr1, str2และstr3แม้ว่าจะถูกเริ่มต้นโดยใช้ไวยากรณ์ที่แตกต่างกันจะชี้ไปที่สายเดียวกันว่า (จากความยาวเป็นศูนย์) วัตถุในหน่วยความจำ ฉันทำการทดสอบนี้ในแอปพลิเคชันคอนโซล NET 4.5 ดังนั้นภายในพวกเขาจึงไม่มีความแตกต่างและทุกอย่างก็ลงเอยด้วยความสะดวกที่คุณต้องการใช้เป็นโปรแกรมเมอร์ พฤติกรรมของคลาสสตริงนี้เป็นที่รู้จักกันในนามสตริงฝึกงานใน. NET Eric Lippert มีบล็อกที่ดีมากที่นี่อธิบายแนวคิดนี้

ข้อใดข้อหนึ่งข้างต้น

มีหลายสิ่งที่ดีกว่าที่จะเป็นสังฆราช เช่นสิ่งที่เปลือกไม้สีเหมาะสมกับต้นไม้ฉันคิดว่าสีน้ำตาลคลุมเครือกับสีน้ำตาลมอส

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

ไม่มีใครพูดถึงว่าใน VisualStudio String จะมีรหัสสีแตกต่างกันไปตามสตริง ซึ่งเป็นสิ่งสำคัญสำหรับการอ่าน นอกจากนี้ตัวพิมพ์เล็กมักจะใช้สำหรับ vars และ type ไม่ใช่เรื่องใหญ่ แต่ String.Empty เป็นค่าคงที่ไม่ใช่ var หรือ type

stringเป็นคำพ้องความหมายสำหรับSystem.Stringประเภทพวกเขาเหมือนกัน

ค่าเหมือนกัน: string.Empty == String.Empty == ""

ฉันจะไม่ใช้ตัวอักษรคงที่ในรหัสแทนstring.EmptyหรือString.Empty- ง่ายกว่าที่จะเห็นความหมายของโปรแกรมเมอร์

ระหว่างstringและStringฉันเหมือนกรณีที่ต่ำกว่าstringมากขึ้นเพียงเพราะผมใช้ในการทำงานร่วมกับ Delphi สำหรับจำนวนมากของปีที่ผ่านมาและรูปแบบ Delphi stringเป็นตัวพิมพ์เล็ก

ดังนั้นถ้าฉันเป็นเจ้านายของคุณคุณจะต้องเขียน string.Empty

ฉันจะชอบstring.Emptyมากกว่าString.Emptyเพราะคุณสามารถใช้งานได้โดยไม่จำเป็นต้องรวมusing System;ไว้ในไฟล์ของคุณ

สำหรับการเลือก""มากกว่าstring.Emptyนั้นมันเป็นความชอบส่วนตัวและควรตัดสินใจโดยทีมของคุณ

ฉันไม่ได้สร้างความแตกต่าง อันสุดท้ายคือพิมพ์เร็วที่สุด :)

มันไม่สำคัญ - พวกมันเหมือนกันทุกประการ อย่างไรก็ตามสิ่งสำคัญคือคุณจะต้องสอดคล้อง

ป.ล. ฉันต่อสู้กับ "สิ่งที่ถูกต้อง" แบบนี้ตลอดเวลา

มันเป็นการกำหนดลักษณะของโค้ดโดยสิ้นเชิง อย่างไรก็ตามนี่คือความคิดเห็นของฉัน :)

ฉันมักจะใช้ชื่อ BCL ประเภทเมื่อมีการเข้าถึงวิธีการคงคุณสมบัติและสาขา: String.EmptyหรือInt32.TryParse(...)หรือDouble.Epsilon

ฉันมักจะใช้คำหลัก C # เมื่อประกาศอินสแตนซ์ใหม่: int i = 0;หรือstring foo = "bar";

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

ฉันใช้อันที่สาม แต่อีกสองอันแรกดูจะแปลกน้อยกว่า string เป็นนามแฝงสำหรับ String แต่การได้เห็นพวกเขาข้ามการมอบหมายจะรู้สึกไม่ดี

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

[แก้ไข]

นอกจากนี้คุณอาจต้องการใช้อย่างใดอย่างหนึ่งstringหรือStringเพื่อความมั่นคงเสมอ แต่นั่นเป็นเพียงฉัน

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

ใช่นี่เป็นการเรียกวิจารณญาณเป็นอย่างมาก แต่เมื่อภาษาให้คุณทำสิ่งต่าง ๆ ได้หลายวิธีฉันมักจะเอนไปหาภาษาที่มีการกำกับดูแลคอมไพเลอร์มากที่สุด นั่นไม่ใช่ "" มันคือทั้งหมดที่เกี่ยวกับการแสดงเจตนาที่เฉพาะเจาะจง

ถ้าคุณพิมพ์ string.EMpty หรือ Strng.Empty คอมไพเลอร์จะช่วยให้คุณรู้ว่าคุณทำผิด ทันที มันจะไม่รวบรวม ในฐานะนักพัฒนาคุณกำลังอ้างถึงความตั้งใจเฉพาะที่คอมไพเลอร์ (หรือผู้พัฒนารายอื่น) ไม่สามารถตีความผิดพลาดได้และเมื่อคุณทำผิดคุณไม่สามารถสร้างบั๊ก

ถ้าคุณพิมพ์ "" เมื่อคุณหมายถึง "" หรือในทางกลับกันคอมไพเลอร์จะทำสิ่งที่คุณบอกให้ทำอย่างมีความสุข ผู้พัฒนารายอื่นอาจจะหรืออาจไม่สามารถรวบรวมความตั้งใจที่เฉพาะเจาะจงของคุณ สร้างข้อผิดพลาด

นานมาแล้วที่สตริงสตริงเป็นสิ่งที่ฉันใช้ไลบรารีมาตรฐานที่กำหนดค่าคงที่ EMPTY_STRING เรายังคงใช้ค่าคงที่ในงบกรณีที่สตริงไม่อนุญาตให้ใช้

เมื่อใดก็ตามที่เป็นไปได้ให้คอมไพเลอร์ทำงานให้คุณและกำจัดโอกาสที่จะเกิดข้อผิดพลาดของมนุษย์ไม่ว่าจะเล็กเพียงใดก็ตาม IMO, สำคัญกว่านี้ "อ่านง่าย" เป็นคนอื่นได้อ้างถึง

ความจำเพาะและการบังคับใช้เวลารวบรวม มันคืออะไรสำหรับอาหารเย็น

ฉันใช้ "" เพราะจะมีสีเหลืองชัดเจนในรหัสของฉัน ... ด้วยเหตุผลบางประการ String.Empty เป็นสีขาวทั้งหมดในชุดรูปแบบ Visual Studio Code ของฉัน และฉันเชื่อว่ามีความสำคัญต่อฉันมากที่สุด

คอมไพเลอร์ควรทำให้เหมือนกันทั้งหมดในระยะยาว เลือกมาตรฐานเพื่อให้โค้ดของคุณอ่านได้ง่ายและติดกับมัน

ฉันเพิ่งดูรหัสและคำถามนี้โผล่เข้ามาในใจของฉันซึ่งฉันได้อ่านบางครั้งก่อน นี่เป็นคำถามของการอ่านอย่างแน่นอน

พิจารณารหัส C # ต่อไปนี้ ...

(customer == null) ? "" : customer.Name

VS

(customer == null) ? string.empty : customer.Name

ฉันเองพบว่าหลังน้อยกว่าคลุมเครือและอ่านง่ายขึ้น

ความแตกต่างที่เกิดขึ้นจริงนั้นเล็กน้อยมาก

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

ในขณะที่ความแตกต่างนั้นมีน้อยมากความแตกต่างก็ยังคงมีอยู่

1) "" สร้างวัตถุในขณะที่ String.Empty ไม่ได้ แต่วัตถุนี้จะถูกสร้างขึ้นหนึ่งครั้งและจะถูกอ้างอิงจากกลุ่มของสตริงในภายหลังหากคุณมีรหัสอื่น ""

2) สตริงและสตริงเหมือนกัน แต่ฉันอยากจะแนะนำให้ใช้ String.Empty (เช่นเดียวกับ String.Format, String.Copy เป็นต้น) เนื่องจากเครื่องหมายจุดแสดงถึงคลาสไม่ใช่ตัวดำเนินการและมีคลาสที่ขึ้นต้นด้วยอักษรตัวใหญ่สอดคล้องกับ มาตรฐานการเข้ารหัส C #

ในhttp://blogs.msdn.com/b/brada/archive/2003/04/22/49997.aspx :

อย่างที่เดวิดบอกไว้มีความแตกต่างระหว่างString.Emptyและ""มีขนาดค่อนข้างเล็ก แต่มีความแตกต่าง ""จริงสร้างวัตถุก็จะมีแนวโน้มที่จะดึงออกมาจากสระว่ายน้ำฝึกงานสตริง แต่ยังคง ... ในขณะที่String.Emptyสร้างวัตถุไม่ ... String.Emptyดังนั้นหากคุณกำลังมองหาจริงๆในท้ายที่สุดในประสิทธิภาพการใช้หน่วยความจำผมขอแนะนำให้ อย่างไรก็ตามคุณควรระลึกไว้เสมอว่าความแตกต่างนั้นสำคัญมากดังนั้นคุณจะไม่เคยเห็นมันในรหัสของคุณ ...
สำหรับSystem.String.Emptyหรือstring.EmptyหรือString.Empty... ระดับการดูแลของฉันต่ำ ;-)

""สตริงที่ว่างเปล่าเป็นเหมือนเซตว่างเพียงแค่ชื่อที่ใช้ทุกคนที่จะเรียก นอกจากนี้ในสตริงภาษาทางการที่สร้างจากตัวอักษรที่มีความยาวเป็นศูนย์จะเรียกว่าสตริงว่าง ทั้งชุดและสายอักขระมีสัญลักษณ์พิเศษสำหรับมัน สตริงว่าง: εและชุดว่าง: ∅ หากคุณต้องการพูดถึงสตริงความยาวเป็นศูนย์คุณจะเรียกมันว่าสตริงว่างดังนั้นทุกคนรู้ว่าคุณหมายถึงอะไร ตอนนี้ในกรณีที่คุณตั้งชื่อมันว่าสตริงว่างทำไมไม่ใช้string.Emptyในรหัสมันแสดงให้เห็นถึงความตั้งใจที่ชัดเจน ข้อเสียคือมันไม่คงที่และดังนั้นจึงไม่สามารถใช้ได้ทุกที่เช่นในคุณสมบัติ (มันไม่คงที่ด้วยเหตุผลทางเทคนิคบางอย่างดูแหล่งอ้างอิง)

ฉันชอบ""เพราะมันสั้นกว่าและString.Emptyแก้ปัญหาที่ไม่มีอยู่จริง