ตัวอย่าง ( หมายเหตุกรณี ):

string s = "Hello world!";
String s = "Hello world!";

แนวทางการใช้งานของแต่ละคนมีอะไรบ้าง และอะไรคือความแตกต่าง?

stringเป็นนามแฝงใน C # System.Stringสำหรับ
ดังนั้นทางเทคนิคจึงไม่มีความแตกต่าง มันเหมือนเทียบกับint System.Int32

ตามแนวทางแล้วเราแนะนำให้ใช้stringทุกครั้งที่คุณอ้างถึงวัตถุ

เช่น

string place = "world";

ในทำนองเดียวกันฉันคิดว่าโดยทั่วไปจะแนะนำให้ใช้Stringหากคุณต้องการอ้างอิงเฉพาะชั้นเรียน

เช่น

string greet = String.Format("Hello {0}!", place);

นี่คือสไตล์ที่ไมโครซอฟท์มีแนวโน้มที่จะใช้งานในตัวอย่างของพวกเขา

ปรากฏว่าคำแนะนำในพื้นที่นี้อาจมีการเปลี่ยนแปลงเนื่องจากขณะนี้StyleCopบังคับใช้การใช้ชื่อแทนเฉพาะ C #

เพียงเพื่อประโยชน์ของความครบถ้วนสมบูรณ์นี่คือสมองของข้อมูลที่เกี่ยวข้อง ...

เป็นคนอื่นได้ระบุไว้เป็นนามแฝงสำหรับstring System.Stringพวกเขารวบรวมรหัสเดียวกันดังนั้นในเวลาดำเนินการไม่มีความแตกต่างใด ๆ นี่เป็นเพียงหนึ่งในนามแฝงใน C # รายการที่สมบูรณ์คือ:

object:  System.Object
string:  System.String
bool:    System.Boolean
byte:    System.Byte
sbyte:   System.SByte
short:   System.Int16
ushort:  System.UInt16
int:     System.Int32
uint:    System.UInt32
long:    System.Int64
ulong:   System.UInt64
float:   System.Single
double:  System.Double
decimal: System.Decimal
char:    System.Char

นอกเหนือจากstringและobjectนามแฝงล้วนแล้วแต่เป็นประเภทค่า decimalเป็นประเภทค่า แต่ไม่ใช่ประเภทดั้งเดิมใน CLR System.IntPtrชนิดเดียวดั้งเดิมซึ่งไม่ได้มีนามแฝงคือ

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

มีสถานการณ์หนึ่งที่คุณต้องใช้นามแฝงคือ: เมื่อระบุประเภทพื้นฐานของ enum อย่างชัดเจน ตัวอย่างเช่น

public enum Foo : UInt32 {} // Invalid
public enum Bar : uint   {} // Valid

นั่นเป็นเพียงเรื่องของวิธีการที่กำหนดสเป็ค enum ประกาศ - ส่วนที่อยู่หลังลำไส้ใหญ่จะต้องมีหนึ่งประเภทการผลิตซึ่งเป็นหนึ่งในสัญลักษณ์ของsbyte, byte, short, ushort, int, uint,long , ulong, char... เมื่อเทียบกับประเภทการผลิต ใช้โดยการประกาศตัวแปรเช่น ไม่ได้ระบุความแตกต่างอื่น ๆ

ในที่สุดเมื่อมันมาถึงที่จะใช้: ส่วนตัวฉันใช้นามแฝงทุกที่สำหรับการดำเนินการ แต่ประเภท CLR สำหรับ API ใด ๆ มันไม่สำคัญว่าคุณจะนำไปใช้ในแง่ของการใช้งานมากเพียงใด - ความสอดคล้องในหมู่ทีมของคุณนั้นดี แต่ก็ไม่มีใครสนใจ ในทางกลับกันสิ่งสำคัญอย่างแท้จริงคือถ้าคุณอ้างถึงประเภทใน API คุณจะต้องใช้ภาษาที่เป็นกลาง วิธีการที่เรียกว่าReadInt32ไม่คลุมเครือในขณะที่วิธีการที่เรียกว่าReadIntต้องมีการตีความ ผู้โทรสามารถใช้ภาษาที่กำหนดintนามแฝงInt16เช่น ออกแบบกรอบ NET ได้ปฏิบัติตามรูปแบบนี้ตัวอย่างที่ดีอยู่ในBitConverter, BinaryReaderและConvertชั้นเรียน

Stringย่อมาจากSystem.Stringและเป็น. NET Framework ประเภท stringเป็นนามแฝงในภาษา C # System.Stringสำหรับ ทั้งคู่รวบรวมSystem.Stringใน IL (ภาษาระดับกลาง) ดังนั้นจึงไม่มีความแตกต่าง เลือกสิ่งที่คุณชอบและใช้สิ่งนั้น หากคุณเขียนโค้ดใน C # ฉันต้องการได้stringเนื่องจากเป็นชื่อแทนประเภท C # และเป็นที่รู้จักกันดีโดยโปรแกรมเมอร์ C #

ฉันสามารถพูดแบบเดียวกันเกี่ยวกับ( int, System.Int32)ฯลฯ

คำตอบที่ดีที่สุดที่ฉันเคยได้ยินเกี่ยวกับการใช้นามแฝงประเภทที่ระบุไว้ใน C # มาจากเจฟฟรีย์ริกเตอร์ในหนังสือของเขาCLR ผ่าน C # นี่คือเหตุผล 3 ข้อของเขา:

• ฉันเห็นนักพัฒนาจำนวนหนึ่งสับสนโดยไม่รู้ว่าจะใช้สตริงหรือสตริงในรหัสของพวกเขาหรือไม่ เนื่องจากใน C # สตริง (คำหลัก) จะจับคู่กับ System.String (ประเภท FCL) ทุกประการจึงไม่มีความแตกต่างและสามารถใช้ได้
• ใน C #, ยาวแมปไปSystem.Int64แต่ในการเขียนโปรแกรมภาษาที่แตกต่างกันยาวอาจแผนที่ไปยังInt16หรือInt32 ในความเป็นจริง, C ++ / CLI ในความเป็นจริงการรักษานานเป็นInt32 บางคนที่อ่านซอร์สโค้ดในภาษาเดียวสามารถตีความเจตนาของรหัสได้อย่างง่ายดายหากเขาหรือเธอคุ้นเคยกับการเขียนโปรแกรมในภาษาโปรแกรมอื่น ในความเป็นจริงภาษาส่วนใหญ่จะไม่ได้รักษานานเป็นคำหลักและรหัสจะไม่รวบรวมที่ใช้มัน
• FCL มีวิธีการมากมายที่มีชื่อประเภทเป็นส่วนหนึ่งของชื่อวิธีการ ตัวอย่างเช่นชนิดBinaryReaderนำเสนอวิธีการเช่นReadBoolean , ReadInt32 , ReadSingleและอื่น ๆ และประเภทSystem.Convertเสนอวิธีการเช่นToBoolean , ToInt32 , ToSingleและอื่น ๆ แม้ว่าจะถูกกฎหมายในการเขียนรหัสต่อไปนี้บรรทัดที่มี float รู้สึกผิดธรรมชาติมากสำหรับฉันและไม่ชัดเจนว่าบรรทัดนั้นถูกต้อง:

BinaryReader br = new BinaryReader(...);
float val  = br.ReadSingle(); // OK, but feels unnatural
Single val = br.ReadSingle(); // OK and feels good

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

stringเป็นคำที่สงวนไว้ แต่Stringเป็นเพียงชื่อคลาส หมายความว่าstringไม่สามารถใช้เป็นชื่อตัวแปรได้

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

StringBuilder String = new StringBuilder();  // compiles
StringBuilder string = new StringBuilder();  // doesn't compile 

หากคุณต้องการชื่อตัวแปรที่ชื่อว่าstringคุณสามารถใช้@เป็นคำนำหน้า:

StringBuilder @string = new StringBuilder();

ความแตกต่างที่สำคัญอื่น: Stack Overflow จะเน้นให้เห็นถึงความแตกต่าง

มีข้อแตกต่างประการหนึ่งคือคุณไม่สามารถใช้งานได้Stringโดยไม่using System;ได้ตั้งใจ

มันถูกคลุมไว้ข้างบน; อย่างไรก็ตามคุณไม่สามารถใช้การstringสะท้อนกลับได้ Stringคุณต้องใช้

System.Stringเป็น. คลาสสตริง. NET - ใน C # stringเป็นนามแฝงสำหรับSystem.String- ดังนั้นในการใช้พวกเขาจะเหมือนกัน

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

หากคุณพบว่าตัวเองระบบที่มีความจำเป็นสร้างเพื่อระบุขนาดของจำนวนเต็มที่คุณกำลังใช้และอื่น ๆ มีแนวโน้มที่จะใช้งานInt16, Int32, UInt16, UInt32ฯลฯ แล้วมันอาจดูเป็นธรรมชาติมากขึ้นเพื่อใช้String- และเมื่อย้ายไปรอบ ๆ ระหว่าง NET ภาษาที่แตกต่างกันมันอาจ ทำให้สิ่งต่าง ๆ เข้าใจได้มากขึ้นมิฉะนั้นฉันจะใช้สตริงและ int

ฉันชอบ.NETประเภทตัวพิมพ์ใหญ่(แทนนามแฝง) สำหรับการจัดรูปแบบเหตุผล .NETชนิดมีสีเดียวกับวัตถุประเภทอื่น ๆ (ประเภทค่าเป็นวัตถุที่เหมาะสมหลังจากทั้งหมด)

คำหลักแบบมีเงื่อนไขและการควบคุม (เช่นif, switchและreturn) เป็นตัวพิมพ์เล็กและสีน้ำเงินเข้มสี (โดยค่าเริ่มต้น) และฉันค่อนข้างจะไม่เห็นด้วยกับการใช้งานและรูปแบบ

พิจารณา:

String someString; 
string anotherString; 

stringและStringเหมือนกันทุกวิธี (ยกเว้นตัวพิมพ์ใหญ่ "S") ไม่มีนัยยะทางประสิทธิภาพ

ตัวพิมพ์เล็กstringเป็นที่ต้องการในโครงการส่วนใหญ่เนื่องจากการเน้นไวยากรณ์

C # เป็นภาษาที่ใช้ร่วมกับ CLR

string เป็นประเภทใน C #

System.String เป็นประเภทใน CLR

เมื่อคุณใช้ C # ร่วมกับการ CLR จะถูกแมปไปstringSystem.String

ในทางทฤษฎีคุณสามารถใช้ C # -compiler ที่สร้าง Java bytecode การดำเนินการที่เหมาะสมของคอมไพเลอร์นี้อาจจะ map stringไปjava.lang.Stringเพื่อที่จะทำงานร่วมกับห้องสมุดรันไทม์ Java

วิดีโอYouTube นี้แสดงให้เห็นว่าแตกต่างกันอย่างไร

แต่ตอนนี้สำหรับคำตอบที่เป็นข้อความยาว ๆ

เมื่อเราพูดถึง.NETมีสองสิ่งที่แตกต่างกันหนึ่งมี.NETกรอบและอื่น ๆ ที่มีภาษา ( C#และVB.NETอื่น ๆ ) ซึ่งใช้กรอบงานนั้น

" System.String" aka "String" (ตัวพิมพ์ใหญ่ "S") เป็น.NETชนิดข้อมูลเฟรมเวิร์กในขณะที่ "string" เป็นC#ชนิดข้อมูล

โดยย่อ "String" เป็นนามแฝง (ชื่อเดียวกันกับชื่ออื่น) ของ "string" ดังนั้นในทางเทคนิคทั้งสองข้อความรหัสด้านล่างจะให้ผลลัพธ์เดียวกัน

String s = "I am String";

หรือ

string s = "I am String";

ในทำนองเดียวกันมีชื่อแทนสำหรับประเภทข้อมูล c # อื่นดังที่แสดงด้านล่าง: -

วัตถุ: System.Object, สตริง: System.String, บูล: System.Boolean, ไบต์: System.Byte, sbyte:, System.SByteสั้น: System.Int16และอื่น ๆ

ตอนนี้คำถามล้านดอลลาร์จากมุมมองของโปรแกรมเมอร์ดังนั้นเมื่อใดควรใช้ "String" และ "string"

สิ่งแรกที่ควรหลีกเลี่ยงความสับสนใช้หนึ่งในนั้นอย่างสม่ำเสมอ แต่จากมุมมองแนวปฏิบัติที่ดีที่สุดเมื่อคุณประกาศตัวแปรเป็นเรื่องดีที่จะใช้ "string" (small "s") และเมื่อคุณใช้มันเป็นชื่อคลาสแล้วต้องการสตริง "String" (ตัวพิมพ์ใหญ่ "S")

ในรหัสด้านล่างด้านซ้ายมือเป็นการประกาศตัวแปรและมันประกาศโดยใช้ "สตริง" ที่ด้านขวามือเรากำลังเรียกใช้เมธอดดังนั้น "String" จึงมีเหตุผลมากขึ้น

string s = String.ToUpper() ;

กรณีที่ต่ำกว่าเป็นนามแฝงสำหรับstring พวกเขาเป็นในแบบเดียวกันSystem.StringC#

มีการถกเถียงกันว่าคุณควรใช้ประเภทของระบบ (เป็นSystem.Int32, System.Stringฯลฯ ) ประเภทหรือC# aliases( int, stringฯลฯ ) ฉันเองเชื่อว่าคุณควรใช้C# aliasesแต่เป็นเพียงความชอบส่วนตัวของฉัน

stringSystem.Stringเป็นเพียงนามแฝงสำหรับ คอมไพเลอร์จะปฏิบัติต่อพวกเขาเหมือนกัน

เฉพาะที่แตกต่างในทางปฏิบัติจะเน้นไวยากรณ์ที่คุณกล่าวถึงและที่คุณต้องเขียนถ้าคุณใช้using SystemString

ทั้งคู่เหมือนกัน แต่จากมุมมองของการเข้ารหัสแนวทางมันจะดีกว่าที่จะใช้แทนstring Stringนี่คือสิ่งที่นักพัฒนาใช้โดยทั่วไป เช่นแทนที่จะใช้Int32เราใช้intตามที่intเป็นนามแฝงInt32

FYI“ สตริงคำหลักเป็นเพียงนามแฝงสำหรับคลาสที่กำหนดไว้ล่วงหน้าSystem.String” - ข้อมูลจำเพาะภาษา C # 4.2.3 http://msdn2.microsoft.com/En-US/library/aa691153.aspx

อย่างที่คนอื่น ๆ พูดกันพวกเขาเหมือนกัน กฎ StyleCop โดยค่าเริ่มต้นจะบังคับให้คุณใช้stringเป็น C # สไตล์รหัสปฏิบัติที่ดีที่สุดยกเว้นเมื่ออ้างอิงถึงSystem.Stringฟังก์ชั่นแบบคงที่เช่นString.Format, String.Join, String.Concatฯลฯ ...

คำตอบใหม่หลังจาก 6 ปี 5 เดือน (การผัดวันประกันพรุ่ง)

แม้ว่าstringคำหลัก C # ที่สงวนไว้จะมีความหมายคงที่อยู่เสมอ แต่Stringเป็นเพียงตัวระบุทั่วไปที่สามารถอ้างถึงอะไรก็ได้ ทั้งนี้ขึ้นอยู่กับสมาชิกของชนิดปัจจุบัน namespace ปัจจุบันและการประยุกต์ใช้usingคำสั่งและตำแหน่งของพวกเขาอาจจะเป็นค่าหรือชนิดที่แตกต่างจากStringglobal::System.String

ฉันจะให้สองตัวอย่างที่สั่งจะไม่ช่วยusing

ครั้งแรกเมื่อStringเป็นค่าประเภทปัจจุบัน (หรือตัวแปรท้องถิ่น):

class MySequence<TElement>
{
  public IEnumerable<TElement> String { get; set; }

  void Example()
  {
    var test = String.Format("Hello {0}.", DateTime.Today.DayOfWeek);
  }
}

ข้างต้นจะไม่รวบรวมเพราะIEnumerable<>ไม่มีสมาชิกที่ไม่คงที่เรียกFormatและไม่มีการใช้วิธีการขยาย ในกรณีข้างต้นอาจเป็นไปได้ที่จะใช้Stringในบริบทอื่น ๆ ที่ประเภทเป็นไปได้เพียงอย่างเดียว syntactically ตัวอย่างเช่นString local = "Hi mum!";อาจตกลง (ขึ้นอยู่กับเนมสเปซและusingคำสั่ง)

ที่เลวร้ายยิ่ง: บอกว่าString.Concat(someSequence)จะมีแนวโน้มที่ (ขึ้นอยู่กับusings) Enumerable.Concatไปที่วิธีขยาย string.Concatมันจะไม่ไปที่วิธีการคง

ประการที่สองเมื่อStringเป็นประเภทอื่นซ้อนอยู่ภายในประเภทปัจจุบัน:

class MyPiano
{
  protected class String
  {
  }

  void Example()
  {
    var test1 = String.Format("Hello {0}.", DateTime.Today.DayOfWeek);
    String test2 = "Goodbye";
  }
}

ไม่มีคำสั่งในExampleวิธีการรวบรวม ที่นี่Stringอยู่เสมอเปียโนสตริงMyPiano.String , ไม่มีสมาชิก ( staticหรือไม่) Formatอยู่ในนั้น (หรือสืบทอดมาจากคลาสฐาน) และค่า"Goodbye"ไม่สามารถแปลงเป็นมันได้

การใช้ประเภทระบบทำให้การพอร์ตระหว่าง C # และ VB.Net ง่ายขึ้นถ้าคุณอยู่ในประเภทนั้น

กับสิ่งที่ดูเหมือนจะเป็นเรื่องธรรมดาในหมู่โปรแกรมเมอร์คนอื่น ๆ ฉันชอบStringมากกว่าstringเพียงเพื่อเน้นความจริงที่Stringเป็นประเภทอ้างอิงตามที่ Jon Skeet กล่าวถึง

stringเป็นนามแฝง (หรือจดชวเลข) System.Stringของ ซึ่งหมายความว่าโดยการพิมพ์ที่เราหมายถึงstring System.Stringคุณสามารถอ่านเพิ่มเติมได้ในลิงค์คิด: 'string' เป็นนามแฝง / ชวเลขของ System.String

ฉันแค่ต้องการเพิ่มสิ่งนี้ลงในคำตอบ lfousts จากหนังสือ Ritchers:

สถานะข้อมูลจำเพาะภาษา C #“ ในเรื่องของสไตล์การใช้คำหลักได้รับความนิยมมากกว่าการใช้ชื่อประเภทระบบที่สมบูรณ์” ฉันไม่เห็นด้วยกับข้อกำหนดภาษา ฉันชอบใช้ชื่อประเภท FCL และหลีกเลี่ยงชื่อประเภทดั้งเดิม ในความเป็นจริงฉันต้องการให้คอมไพเลอร์ไม่ได้เสนอชื่อดั้งเดิมและบังคับให้ผู้พัฒนาใช้ชื่อประเภท FCL แทน นี่คือเหตุผลของฉัน:

• ฉันเห็นนักพัฒนาจำนวนหนึ่งสับสนโดยไม่รู้ว่าจะใช้สตริง หรือสตริงในรหัสของพวกเขาหรือไม่ เนื่องจากใน C # string (คำหลัก) จะจับคู่กับ System.String (ประเภท FCL) ทุกประการจึงไม่มีความแตกต่างและสามารถใช้ได้ ในทำนองเดียวกันฉันได้ยินว่านักพัฒนาบางคนบอกว่าintแสดงถึงจำนวนเต็ม 32 บิตเมื่อแอปพลิเคชันทำงานบนระบบปฏิบัติการ 32 บิตและเป็นตัวแทนของจำนวนเต็ม 64 บิตเมื่อแอปพลิเคชันทำงานบนระบบปฏิบัติการ 64 บิต คำสั่งนี้เป็นเท็จอย่างแน่นอน: ใน C #, intมักจะจับคู่กับSystem.Int32และดังนั้นจึงแสดงถึงจำนวนเต็ม 32- บิตโดยไม่คำนึงถึงระบบปฏิบัติการที่รหัสทำงานอยู่ หากโปรแกรมเมอร์จะใช้ Int32ในรหัสของพวกเขาแล้วความสับสนที่อาจเกิดขึ้นนี้ก็จะถูกกำจัดออกไป

• ใน C #, ยาวแมปไปSystem.Int64แต่ในการเขียนโปรแกรมภาษาที่แตกต่างกันยาว อาจแผนที่ไปยังInt16หรือInt32 ในความเป็นจริง, C ++ / CLI ไม่รักษานานเป็นInt32 บางคนที่อ่านซอร์สโค้ดในภาษาเดียวสามารถตีความเจตนาของรหัสได้อย่างง่ายดายหากเขาหรือเธอคุ้นเคยกับการเขียนโปรแกรมในภาษาโปรแกรมอื่น ในความเป็นจริงภาษาส่วนใหญ่จะไม่ได้รักษานานเป็นคำหลักและรหัสจะไม่รวบรวมที่ใช้มัน

• FCL มีวิธีการมากมายที่มีชื่อประเภทเป็นส่วนหนึ่งของชื่อวิธีการ ตัวอย่างเช่นชนิดBinaryReaderนำเสนอวิธีการเช่นReadBoolean , ReadInt32 , ReadSingleและอื่น ๆ และประเภทSystem.Convertเสนอวิธีการเช่น ToBoolean , ToInt32 , ToSingleและอื่น ๆ แม้ว่าจะถูกกฎหมายในการเขียนรหัสต่อไปนี้บรรทัดที่มีfloatรู้สึกผิดธรรมชาติมากสำหรับฉันและไม่ชัดเจนว่าบรรทัดนั้นถูกต้อง:

  BinaryReader br = new BinaryReader(...);
  float val = br.ReadSingle(); // OK, but feels unnatural
  Single val = br.ReadSingle(); // OK and feels good

• โปรแกรมเมอร์จำนวนมากที่ใช้ C # มีแนวโน้มที่จะลืมว่าภาษาการเขียนโปรแกรมอื่นสามารถใช้กับ CLR และด้วยเหตุนี้ C # -isms จะคืบคลานเข้าไปในรหัสไลบรารีคลาส ยกตัวอย่างเช่นไมโครซอฟท์ FCL ถูกเขียนเกือบเฉพาะใน C # และนักพัฒนาในทีม FCL ได้แนะนำตอนนี้วิธีการเข้าไปในห้องสมุดเช่น อาร์เรย์ ‘s GetLongLengthซึ่งส่งกลับInt64ค่าที่เป็นเวลานานใน C # แต่ไม่ได้อยู่ในภาษาอื่น ๆ (เช่น C ++ / CLI) อีกตัวอย่างหนึ่งคือวิธีLongCountของ System.Linq.Enumerable

ฉันไม่ได้รับความเห็นของเขาก่อนที่จะอ่านย่อหน้าที่สมบูรณ์

String ( System.String) เป็นคลาสในไลบรารีคลาสฐาน string (ตัวพิมพ์เล็ก) เป็นงานที่สงวนไว้ใน C # ซึ่งเป็นนามแฝงของ System.String Int32 VS int Boolean vs. boolเป็นสถานการณ์ที่คล้ายกันคือ คำหลักเฉพาะภาษา C # เหล่านี้ช่วยให้คุณสามารถประกาศแบบดั้งเดิมในสไตล์ที่คล้ายกับ C

Stringไม่ใช่คำหลักและสามารถใช้เป็นตัวระบุได้ในขณะที่stringเป็นคำหลักและไม่สามารถใช้เป็นตัวระบุได้ และในมุมมองของฟังก์ชั่นทั้งคู่ก็เหมือนกัน

มันเป็นเรื่องของการประชุมจริงๆ stringดูคล้ายกับสไตล์ C / C ++ มากขึ้น การประชุมทั่วไปคือการใช้ทางลัดใด ๆ ก็ตามที่ภาษาที่คุณเลือกได้จัดเตรียมไว้ (int / Int for Int32) สิ่งนี้มีไว้สำหรับ "วัตถุ" และdecimalเช่นกัน

ในทางทฤษฎีสิ่งนี้อาจช่วยให้รหัสพอร์ตเป็นมาตรฐาน 64- บิตในอนาคตซึ่ง "int" อาจหมายถึงInt64แต่นั่นไม่ใช่ประเด็นและฉันคาดหวังว่าตัวช่วยสร้างการอัปเกรดจะเปลี่ยนintการอ้างอิงใด ๆInt32เพื่อความปลอดภัย

มาปาร์ตี้ช้า: ฉันใช้ CLR ประเภท 100% ของเวลา (ดียกเว้นถ้าถูกบังคับให้ใช้ประเภท C # แต่ฉันจำไม่ได้เมื่อครั้งสุดท้ายที่เป็น)

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

ตอนนี้ฉันทำมาหลายปีแล้วมันก็เป็นนิสัยและฉันชอบสีที่ VS แสดงให้เห็นถึงประเภท CLR

Downer จริงเพียงอย่างเดียวคือการเติมข้อมูลอัตโนมัติใช้ประเภท C # ดังนั้นฉันเลยพิมพ์ใหม่ที่สร้างขึ้นโดยอัตโนมัติเพื่อระบุประเภท CLR แทน

นอกจากนี้ตอนนี้เมื่อฉันเห็น "int" หรือ "string" ดูเหมือนว่าฉันผิดจริงๆเช่นฉันกำลังดูรหัส C ของปี 1970

ไม่มีความแตกต่าง

คีย์เวิร์ด C # stringจะจับคู่กับประเภท. NET System.String- เป็นนามแฝงที่ใช้ในการตั้งชื่อภาษา

ในทำนองเดียวกันแมปไปintSystem.Int32

มีคำพูดเกี่ยวกับเรื่องนี้จากหนังสือแดเนียล Solis'

ประเภทที่กำหนดไว้ล่วงหน้าทั้งหมดจะถูกแมปโดยตรงกับประเภท. NET พื้นฐาน ชื่อประเภท C (สตริง) เป็นเพียงนามแฝงสำหรับ. ประเภท NET (สตริงหรือ System.String) ดังนั้นการใช้ชื่อ. NET จะทำงานได้ดีในทาง syntactically แม้ว่าจะไม่ได้รับการสนับสนุนก็ตาม ภายในโปรแกรม C # คุณควรใช้ชื่อ C # แทนชื่อ. NET

เชือกเป็นคำหลักและคุณไม่สามารถใช้สตริงเป็นตัวระบุได้

สตริงไม่ใช่คำหลักและคุณสามารถใช้มันเป็นตัวระบุ:

ตัวอย่าง

string String = "I am a string";

คำหลักstring เป็นชื่อแทน System.Stringนอกเหนือจากปัญหาคำหลักคำหลักสองคำนี้เทียบเท่ากันทั้งหมด

 typeof(string) == typeof(String) == typeof(System.String)

ใช่ว่าเป็นความแตกต่างระหว่างพวกเขาไม่เหมือนและboolBoolean

@ JaredPar (ผู้พัฒนาในคอมไพเลอร์ C # และผู้ใช้ SO ที่อุดมสมบูรณ์!) เขียนโพสต์บล็อกยอดเยี่ยมเกี่ยวกับปัญหานี้ ฉันคิดว่ามันคุ้มค่าที่จะแบ่งปันที่นี่ มันเป็นมุมมองที่ดีในเรื่องของเรา

string เมื่อเทียบกับ Stringไม่ใช่การอภิปรายสไตล์

[ ... ]

คำหลักstringมีความหมายที่ชัดเจนใน C # เป็นชนิดSystem.Stringที่มีอยู่ในชุดประกอบหลักของรันไทม์ รันไทม์เข้าใจอย่างแท้จริงชนิดนี้และให้ความสามารถในการพัฒนาคาดหวังสำหรับสตริงใน. NET การมีอยู่ของมันสำคัญมากสำหรับ C # ซึ่งหากประเภทนั้นไม่มีอยู่คอมไพเลอร์จะออกก่อนที่จะพยายามแยกวิเคราะห์บรรทัดของโค้ด ด้วยเหตุนี้stringมีความหมายที่แม่นยำและชัดเจนในรหัส C #

Stringแม้ว่าตัวระบุจะไม่มีความหมายที่เป็นรูปธรรมใน C # มันเป็นตัวบ่งชี้ที่จะไปผ่านทุกกฎการค้นหาชื่อเป็นWidget, Studentฯลฯ ... stringมันอาจจะผูกกับสตริงหรือมันอาจจะผูกกับชนิดอื่นในการชุมนุมทั้งหมดที่มีวัตถุประสงค์เพื่อการอาจแตกต่างอย่างสิ้นเชิง ยิ่งไปกว่านั้นมันอาจจะถูกกำหนดในลักษณะที่รหัสเช่นString s = "hello"; รวบรวมอย่างต่อเนื่อง

class TricksterString { 
  void Example() {
    String s = "Hello World"; // Okay but probably not what you expect.
  }
}

class String {
  public static implicit operator String(string s) => null;
}

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

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

อีกวิธีในการมองเห็นความแตกต่างคือกับตัวอย่างนี้:

string s1 = 42; // Errors 100% of the time  
String s2 = 42; // Might error, might not, depends on the code

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

[ ... ]

คุณจะเห็นว่าStringมีการกำหนดไว้สำหรับวัตถุประสงค์ที่ถูกต้องจำนวนหนึ่ง: ผู้ช่วยเหลือการสะท้อน, ไลบรารีการทำให้เป็นอนุกรม, lexers, โปรโตคอล ฯลฯ ... สำหรับไลบรารีใด ๆ เหล่านี้Stringเทียบกับstringผลที่เกิดขึ้นจริงขึ้นอยู่กับตำแหน่งที่ใช้รหัส

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

หมายเหตุ: ฉันคัดลอก / วางโพสต์บล็อกส่วนใหญ่เพื่อเหตุผลการเก็บถาวร ฉันไม่สนใจบางส่วนดังนั้นฉันแนะนำให้ข้ามและอ่านโพสต์บล็อกหากคุณทำได้