ใน C # เหตุใด String จึงเป็นประเภทการอ้างอิงที่ทำงานเหมือนประเภทค่า

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

เหตุใดสตริงจึงไม่เป็นเพียงประเภทค่า

สตริงไม่ใช่ประเภทค่าเนื่องจากมีขนาดใหญ่และจำเป็นต้องเก็บไว้ในกอง ชนิดของค่าคือ (ในการนำไปใช้งานทั้งหมดของ CLR ณ ขณะนั้น) เก็บไว้ในสแต็ก สแต็กการจัดสรรสตริงจะทำลายทุกสิ่ง: สแต็คมีเพียง 1MB สำหรับ 32- บิตและ 4MB สำหรับ 64- บิต, คุณจะต้องทำกล่องแต่ละสตริง, เกิดการลงโทษการคัดลอก, คุณไม่สามารถฝึกงานและใช้หน่วยความจำ บอลลูนจะ ฯลฯ

(แก้ไข: เพิ่มความกระจ่างเกี่ยวกับการจัดเก็บประเภทค่าเป็นรายละเอียดการใช้งานซึ่งนำไปสู่สถานการณ์นี้ที่เรามีประเภทที่มีความหมายของค่าไม่ได้สืบทอดจาก System.ValueType ขอบคุณ Ben)

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

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

string s = "hello";
string t = "hello";
bool b = (s == t);

ตั้งbให้เป็นfalse? ลองนึกภาพว่าการเขียนโค้ดเกี่ยวกับแอพพลิเคชันใดทำได้ยาก

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

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

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

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

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

นี่เป็นคำตอบที่ล่าช้าสำหรับคำถามเก่า แต่คำตอบอื่น ๆ ทั้งหมดหายไปซึ่งเป็นที่. NET ไม่ได้มีชื่อสามัญจนกระทั่ง. NET 2.0 ในปี 2005

Stringเป็นประเภทการอ้างอิงแทนที่จะเป็นประเภทค่าเนื่องจากมีความสำคัญอย่างยิ่งสำหรับ Microsoft เพื่อให้แน่ใจว่าสามารถเก็บสตริงได้อย่างมีประสิทธิภาพที่สุดในคอลเลกชันที่ไม่ใช่แบบทั่วไปเช่นSystem.Collections.ArrayListเช่น

การเก็บค่าประเภทในคอลเลกชันที่ไม่ใช่แบบทั่วไปต้องมีการแปลงแบบพิเศษเป็นประเภทobjectที่เรียกว่ามวย เมื่อ CLR ทำกล่องชนิดของค่ามันจะตัดค่าภายในSystem.Objectและเก็บไว้ในฮีปที่ได้รับการจัดการ

การอ่านค่าจากคอลเล็กชันต้องการการดำเนินการผกผันซึ่งเรียกว่า unboxing

ทั้งการชกมวยและการไม่จิกมีค่าใช้จ่ายที่ไม่สำคัญ: มวยต้องการการจัดสรรเพิ่มเติม, การยกเลิกการจั่วต้องมีการตรวจสอบประเภท

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

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

สตริงไม่เพียง แต่เป็นประเภทการอ้างอิงที่ไม่เปลี่ยนรูป ผู้ได้รับมอบหมาย Multi-cast เกินไป นี่คือเหตุผลว่าทำไมจึงปลอดภัยที่จะเขียน

protected void OnMyEventHandler()
{
     delegate handler = this.MyEventHandler;
     if (null != handler)
     {
        handler(this, new EventArgs());
     }
}

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

string s1 = "my string";
//some code here
string s2 = "my string";

โอกาสที่ทั้งสองอินสแตนซ์ของค่าคงที่ "สตริงของฉัน" จะถูกจัดสรรในแอสเซมบลีของคุณเพียงครั้งเดียว

หากคุณต้องการจัดการสตริงเหมือนประเภทอ้างอิงปกติให้ใส่สตริงไว้ใน StringBuilder ใหม่ (สตริง s) หรือใช้ MemoryStreams

หากคุณต้องการสร้างห้องสมุดที่คุณคาดหวังว่าจะมีสตริงจำนวนมากที่ถูกส่งผ่านในฟังก์ชั่นของคุณให้กำหนดพารามิเตอร์เป็น StringBuilder หรือเป็นสตรีม

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

บางที Jon Skeet อาจช่วยได้ที่นี่?

มันเป็นเรื่องของประสิทธิภาพเป็นหลัก

การมีสตริงทำงานชนิดของค่า LIKE ช่วยให้เมื่อเขียนโค้ด แต่ถ้าเป็นประเภทของค่าจะทำให้การทำงานมีประสิทธิภาพอย่างมาก

เพื่อการมองในเชิงลึกลองดูบทความดีๆเกี่ยวกับสายอักขระในกรอบงาน. net

กล่าวง่ายๆว่าค่าใด ๆ ที่มีขนาดแน่นอนสามารถถือว่าเป็นประเภทค่าได้

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

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

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

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

ไม่ง่ายอย่างที่ Strings ประกอบไปด้วยตัวละคร ฉันดูสตริงเป็นอาร์เรย์อักขระ [] ดังนั้นจึงอยู่ในฮีปเนื่องจากตำแหน่งหน่วยความจำอ้างอิงเก็บอยู่ในสแต็กและชี้ไปที่ตำแหน่งเริ่มต้นของตำแหน่งหน่วยความจำของอาเรย์บนฮีป ไม่ทราบขนาดสตริงก่อนที่จะจัดสรร ... สมบูรณ์แบบสำหรับฮีป

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

ความเสี่ยงในการได้รับการลงคะแนนเสียงลึกลับอีกครั้ง ... ความจริงที่ว่าหลายคนพูดถึงสแต็คและหน่วยความจำเกี่ยวกับประเภทของค่าและประเภทดั้งเดิมคือเพราะพวกเขาจะต้องลงทะเบียนในไมโครโปรเซสเซอร์ คุณไม่สามารถผลักดันหรือป๊อปอัพบางสิ่งไปยัง / จากสแต็กหากใช้บิตมากกว่าการลงทะเบียนมี .... คำแนะนำคือตัวอย่างเช่น "pop eax" - เนื่องจาก eax นั้นกว้าง 32 บิตบนระบบ 32 บิต

ประเภทดั้งเดิมจุดลอยตัวได้รับการจัดการโดย FPU ซึ่งมีความกว้าง 80 บิต

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