ทำไมค่าเริ่มต้นของประเภทสตริงเป็นโมฆะแทนที่จะเป็นสตริงว่าง

มันน่ารำคาญมากทีเดียวที่จะทดสอบสตริงของฉันทั้งหมดnullก่อนที่ผมจะสามารถใช้วิธีการเช่นToUpper(), StartWith()ฯลฯ ...

หากค่าเริ่มต้นของstringสตริงว่างเปล่าฉันจะไม่ต้องทดสอบและฉันรู้สึกว่ามันจะสอดคล้องกับประเภทค่าอื่น ๆ เช่นintหรือdoubleตัวอย่าง นอกจากนี้Nullable<String>จะทำให้รู้สึก

เหตุใดนักออกแบบของ C # จึงเลือกใช้nullเป็นค่าเริ่มต้นของสตริง

หมายเหตุ: สิ่งนี้เกี่ยวข้องกับคำถามนี้แต่ให้ความสำคัญกับสาเหตุมากกว่าจะทำอย่างไรกับมัน

ทำไมค่าเริ่มต้นของประเภทสตริงเป็นโมฆะแทนที่จะเป็นสตริงว่าง

เพราะstringเป็นชนิดการอ้างอิงnullและค่าเริ่มต้นสำหรับทุกประเภทอ้างอิง

มันค่อนข้างน่ารำคาญที่จะทดสอบสตริงทั้งหมดของฉันเป็นโมฆะก่อนที่ฉันจะสามารถใช้วิธีการอย่าง ToUpper (), StartWith () และอื่น ๆ ...

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

หากค่าเริ่มต้นของสตริงเป็นสตริงว่างเปล่าฉันจะไม่ต้องทดสอบและฉันจะรู้สึกว่ามันสอดคล้องกับประเภทค่าอื่น ๆ เช่น int หรือ double เป็นต้น

การกำหนดค่าเริ่มต้นการเฉพาะชนิดการอ้างอิงอื่น ๆ กว่าnullจะทำให้มันไม่สอดคล้องกัน

นอกจากนี้Nullable<String>จะทำให้รู้สึก

Nullable<T>ทำงานกับประเภทค่า สิ่งที่ควรทราบคือความจริงที่Nullableไม่ได้ถูกนำมาใช้ในแพลตฟอร์ม NETเดิมดังนั้นจะมีรหัสที่ใช้งานไม่ได้หากพวกเขาเปลี่ยนกฎนั้น ( Courtesy @jcolebrand )

ฮาบิบพูดถูก - เพราะstringเป็นประเภทอ้างอิง

แต่ที่สำคัญคุณไม่ต้องตรวจสอบnullทุกครั้งที่ใช้งาน คุณอาจจะโยนArgumentNullExceptionถ้ามีใครบางคนผ่านฟังก์ชั่นnullอ้างอิงของคุณ

นี่คือสิ่งที่ - กรอบจะโยนNullReferenceExceptionให้คุณต่อไปถ้าคุณพยายามโทรหา.ToUpper()สาย โปรดจำไว้ว่ากรณีนี้ยังสามารถเกิดขึ้นได้ถ้าคุณทดสอบข้อโต้แย้งของคุณสำหรับnullตั้งแต่ทรัพย์สินใด ๆ nullหรือวิธีการที่วัตถุที่ผ่านมาการทำงานของคุณเป็นพารามิเตอร์อาจประเมิน

การตรวจสอบสตริงหรือโมฆะที่ว่างเปล่าเป็นเรื่องปกติที่ต้องทำดังนั้นพวกเขาจึงจัดหาString.IsNullOrEmpty()และString.IsNullOrWhiteSpace()เพื่อจุดประสงค์นี้เท่านั้น

คุณสามารถเขียนวิธีการขยาย (สำหรับสิ่งที่คุ้มค่า):

public static string EmptyNull(this string str)
{
    return str ?? "";
}

ตอนนี้ทำงานได้อย่างปลอดภัย:

string str = null;
string upper = str.EmptyNull().ToUpper();

คุณสามารถใช้สิ่งต่อไปนี้ตั้งแต่ C # 6.0

string myString = null;
string result = myString?.ToUpper();

ผลลัพธ์ของสตริงจะเป็นโมฆะ

สตริงและโมฆะที่ว่างเปล่านั้นแตกต่างกันโดยพื้นฐาน ค่า Null คือการไม่มีค่าและสตริงว่างคือค่าที่ว่าง

ภาษาการเขียนโปรแกรมการตั้งสมมติฐานเกี่ยวกับ "ค่า" ของตัวแปรในกรณีนี้สตริงว่างจะดีเท่ากับเริ่มต้นสตริงด้วยค่าอื่น ๆ ที่จะไม่ทำให้เกิดปัญหาการอ้างอิงโมฆะ

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

อีกโอกาสที่ปัญหานี้จะเกิดขึ้นเมื่อสตริงเป็นค่าส่งคืนจากบางฟังก์ชัน เนื่องจากสตริงเป็นประเภทอ้างอิงและในทางเทคนิคสามารถมีค่าเป็น null และว่างทั้งคู่ดังนั้นฟังก์ชันจึงสามารถส่งคืนค่าว่างหรือเทคนิคว่างได้ในทางเทคนิค (ไม่มีอะไรจะหยุดมันได้ ตอนนี้เนื่องจากมี 2 แนวคิดเกี่ยวกับ "การขาดค่า" นั่นคือสตริงว่างและ null รหัสทั้งหมดที่ใช้ฟังก์ชันนี้จะต้องทำการตรวจสอบ 2 ครั้ง หนึ่งรายการว่างเปล่าและอีกรายการหนึ่งเป็นโมฆะ

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

/software/32578/sql-empty-string-vs-null-value

NULL vs Empty เมื่อจัดการกับอินพุตของผู้ใช้

เหตุผล / ปัญหาพื้นฐานคือผู้ออกแบบข้อกำหนด CLS (ซึ่งกำหนดวิธีการที่ภาษาโต้ตอบกับ. net) ไม่ได้กำหนดวิธีการที่สมาชิกชั้นเรียนสามารถระบุได้ว่าพวกเขาจะต้องถูกเรียกโดยตรงแทนที่จะผ่านcallvirtโดยไม่มีผู้โทรทำการ การตรวจสอบการอ้างอิงเป็นศูนย์ และมันก็ไม่ได้ให้ความสำคัญกับการกำหนดโครงสร้างซึ่งจะไม่เป็นเรื่องปกติ "มวย"

มีข้อกำหนด CLS ที่กำหนดวิธีการดังกล่าวจากนั้นมันจะเป็นไปได้สำหรับ. net ที่จะปฏิบัติตามผู้นำที่สร้างขึ้นโดย Common Object Model (COM) อย่างสม่ำเสมอซึ่งการอ้างอิงสตริง null นั้นถูกพิจารณาว่ามีความหมายเทียบเท่ากับสตริงว่างและอื่น ๆ ประเภทที่ไม่เปลี่ยนรูปแบบที่ผู้ใช้กำหนดซึ่งควรจะมีความหมายของค่าเพื่อกำหนดค่าเริ่มต้นเช่นเดียวกัน โดยพื้นฐานแล้วอะไรจะเกิดขึ้นจะเป็นสำหรับสมาชิกแต่ละคนของStringเช่นการเขียนเป็นสิ่งที่ชอบLength [InvokableOnNull()] int String Length { get { if (this==null) return 0; else return _Length;} }วิธีการนี้จะให้ความหมายที่ดีมากสำหรับสิ่งที่ควรทำตัวเหมือนค่านิยม แต่เนื่องจากปัญหาการใช้งานจะต้องเก็บไว้ในกอง ปัญหาที่ใหญ่ที่สุดด้วยวิธีนี้คือความหมายของการแปลงระหว่างประเภทดังกล่าวและObjectอาจมืดมัวเล็กน้อย

อีกวิธีหนึ่งที่จะช่วยให้คำจำกัดความของประเภทโครงสร้างพิเศษที่ไม่ได้รับมรดกObjectแต่แทนที่จะมีการชกมวยแบบกำหนดเองและการดำเนินการ unboxing (ซึ่งจะแปลงเป็น / จากประเภทคลาสอื่น ๆ ) ภายใต้วิธีการดังกล่าวจะมีประเภทคลาสNullableStringที่ทำงานเป็นสตริงทำในขณะนี้และโครงสร้าง struct แบบกล่องที่กำหนดเองStringซึ่งจะเก็บฟิลด์ส่วนตัวValueประเภทStringเดียว ความพยายามที่จะแปลงStringไปNullableStringหรือObjectจะกลับมาValueถ้าไม่ใช่ null หรือString.Emptyถ้า null ความพยายามที่จะส่งต่อStringการอ้างอิงที่ไม่ใช่ค่า null ไปยังNullableStringอินสแตนซ์จะเก็บการอ้างอิงไว้ในValue(อาจเก็บค่าว่างหากความยาวเป็นศูนย์); การส่งการอ้างอิงอื่นใดจะทำให้เกิดข้อยกเว้น

แม้ว่าสตริงจะต้องถูกเก็บไว้ในฮีป แต่ก็ไม่มีเหตุผลว่าทำไมพวกเขาไม่ควรทำตัวเหมือนประเภทของค่าที่มีค่าเริ่มต้นที่ไม่เป็นโมฆะ การเก็บไว้เป็นโครงสร้าง "ปกติ" ซึ่งมีการอ้างอิงจะมีประสิทธิภาพสำหรับรหัสที่ใช้เป็นสตริง "type" แต่จะเพิ่มเลเยอร์ทางอ้อมและความไร้ประสิทธิภาพพิเศษเมื่อส่งไปยัง "object" ในขณะที่ฉันไม่คาดการณ์. net เพิ่มคุณสมบัติข้างต้นอย่างใดอย่างหนึ่งในวันที่ล่าช้านี้บางทีนักออกแบบของกรอบงานในอนาคตอาจพิจารณารวมถึงพวกเขา

เพราะตัวแปรสตริงคือการอ้างอิงที่ไม่อินสแตนซ์

การกำหนดค่าเริ่มต้นเป็น Empty โดยค่าเริ่มต้นนั้นเป็นไปได้ แต่จะมีการแนะนำที่ไม่สอดคล้องกันมากมายทั่วกระดาน

ทำไมนักออกแบบของ C # เลือกใช้ null เป็นค่าเริ่มต้นของสตริง

เนื่องจากสตริงเป็นประเภทการอ้างอิงประเภทการอ้างอิงจึงเป็นค่าเริ่มต้นคือnullประเภทอ้างอิงค่าเริ่มต้นคือตัวแปรประเภทการอ้างอิงจะเก็บการอ้างอิงไปยังข้อมูลจริง

มาใช้defaultคำสำคัญสำหรับกรณีนี้

string str = default(string); 

strเป็นstringดังนั้นจึงเป็นชนิดการอ้างอิงnullเพื่อเป็นค่าเริ่มต้น

int str = (default)(int);

strเป็นintจึงเป็นประเภทค่าzeroดังนั้นค่าเริ่มต้นคือ

หากค่าเริ่มต้นของstringสตริงว่างเปล่าฉันจะไม่ต้องทดสอบ

ไม่ถูกต้อง! การเปลี่ยนค่าเริ่มต้นจะไม่เปลี่ยนแปลงความจริงที่ว่ามันเป็นชนิดการอ้างอิงและคนที่ยังคงสามารถอย่างชัดเจนตั้งค่าnullอ้างอิงที่จะเป็น

นอกจากนี้Nullable<String>จะทำให้รู้สึก

จุดที่แท้จริง มันจะสมเหตุสมผลมากกว่าที่จะไม่อนุญาตให้nullใช้ประเภทการอ้างอิงใด ๆ แทนที่จะต้องการNullable<TheRefType>คุณสมบัตินั้น

เหตุใดนักออกแบบของ C # จึงเลือกใช้nullเป็นค่าเริ่มต้นของสตริง

ความสอดคล้องกับประเภทอ้างอิงอื่น ๆ ตอนนี้ทำไมอนุญาตให้ใช้nullในประเภทอ้างอิงเลย อาจจะเพื่อให้มันรู้สึกเหมือน C Nullableแม้ว่านี่คือการตัดสินใจการออกแบบที่น่าสงสัยในภาษาที่ยังมี

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

string str = SomeMethodThatReturnsaString() ?? "";
// if SomeMethodThatReturnsaString() returns a null value, "" is assigned to str.

String เป็นวัตถุที่ไม่เปลี่ยนรูปซึ่งหมายความว่าเมื่อกำหนดค่าแล้วค่าเก่าจะไม่ถูกลบออกจากหน่วยความจำ แต่ยังคงอยู่ในตำแหน่งเดิมและค่าใหม่จะถูกใส่ในตำแหน่งใหม่ ดังนั้นถ้าค่าเริ่มต้นของString aเป็นString.EmptyมันจะเสียString.Emptyบล็อกในหน่วยความจำว่างเมื่อได้รับค่าแรก

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

เนื่องจากสตริงเป็นประเภทอ้างอิงและค่าเริ่มต้นสำหรับประเภทอ้างอิงเป็นโมฆะ

บางทีstringคำหลักอาจทำให้คุณสับสนเนื่องจากดูเหมือนว่าการประกาศประเภทค่าอื่น ๆแต่จริงๆแล้วมันเป็นชื่อแทนSystem.Stringตามที่อธิบายไว้ในคำถามนี้
นอกจากนี้ยังมีสีเข้มสีฟ้าใน Visual Studio structและตัวอักษรตัวแรกพิมพ์เล็กอาจทำให้เข้าใจผิดคิดว่ามันเป็น

ประเภท Nullable ไม่ได้เข้ามาจนถึง 2.0

หากมีประเภท nullable ได้ทำในการเริ่มต้นของภาษาแล้วสตริงจะไม่เป็นโมฆะและสตริง? คงจะเป็นโมฆะ แต่พวกเขาไม่สามารถทำสิ่งนี้เพื่อรองรับความเข้ากันได้แบบย้อนหลัง

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