ค# เป็นภาษาโปรแกรมที่ใช้กันอย่างแพร่หลายซึ่งออกแบบมาเพื่อสร้างแอปพลิเคชันที่มีประสิทธิภาพและแข็งแกร่งสำหรับแพลตฟอร์มต่างๆ ภาษามีคุณสมบัติขั้นสูงมากมาย รวมถึง โอเปอเรเตอร์การรวมศูนย์ที่เป็นโมฆะ ซึ่งช่วยให้โค้ดที่ซับซ้อนง่ายขึ้นโดยจัดเตรียมไวยากรณ์แบบกระชับเพื่อจัดการกับค่า Null โอเปอเรเตอร์นี้ได้รับความนิยมในหมู่นักพัฒนาที่มองหาวิธีจัดการที่ไม่ซับซ้อน โมฆะ คุณค่าในโครงการของพวกเขา
บทความนี้จะกล่าวถึงรายละเอียดเกี่ยวกับ โอเปอเรเตอร์การรวมศูนย์ที่เป็นโมฆะ .
Null Coalescing Operator ใน C# คืออะไร
ใน C# สัญลักษณ์สำหรับ โอเปอเรเตอร์การรวมศูนย์ที่เป็นโมฆะ เป็น ?? . หากตัวแปรเป็น null จะใช้เพื่อให้เป็นค่าเริ่มต้น
เช่น ถ้าเรามีตัวแปร x ที่สามารถเป็น null ได้ และเราต้องการกำหนดให้มันเป็นค่าเริ่มต้นที่ 10 หากเป็น null เราสามารถใช้ โอเปอเรเตอร์การรวมศูนย์ที่เป็นโมฆะ ดังนี้
int y = x ?? 10
คำสั่งนี้จะกำหนดค่าของ 10 ถึง y ถ้า x เป็นโมฆะ มิฉะนั้น มันจะรับค่าของ x
มันจะคืนค่าของตัวถูกดำเนินการด้านซ้ายหากไม่เป็นค่าว่าง ตรวจสอบตัวถูกดำเนินการทางขวามือและผลลัพธ์จะถูกส่งกลับหากเป็นโมฆะ อีกทางหนึ่ง ถ้าตัวถูกดำเนินการทางซ้ายมือประเมินเป็นค่าไม่เป็นโมฆะ ก็จะไม่ประเมินค่าตัวถูกดำเนินการทางขวามือ
วิธีดั้งเดิมในการเขียนโค้ดโดยไม่ต้องใช้ โอเปอเรเตอร์การรวมศูนย์ที่เป็นโมฆะ เป็น:
ถ้า ( ผลลัพธ์เป็นโมฆะ )กลับ รายการใหม่ < บุคคล > ( ) ;
กลับ ผลลัพธ์;
เราสามารถย่อสิ่งนี้ให้เป็นบรรทัดเดียวที่มีทั้งค่าเริ่มต้นที่ไม่ใช่ค่า Null และการตรวจสอบค่า Null โดยใช้ โอเปอเรเตอร์การรวมศูนย์ที่เป็นโมฆะ :
กลับ ผลลัพธ์ ?? รายการใหม่ < บุคคล > ( ) ;
ประเด็นสำคัญที่ต้องจำ โอเปอเรเตอร์การรวมศูนย์ที่เป็นโมฆะ เป็น:
- ตัวแปรต้องเป็นตัวถูกดำเนินการทางซ้ายมือของเครื่องหมาย ?? ผู้ประกอบการ
- ตัวถูกดำเนินการทางซ้ายมือของตัวดำเนินการ ??= ไม่สามารถเป็นประเภทที่ไม่เป็นโมฆะได้
- ไม่สามารถโอเวอร์โหลดโอเปอเรเตอร์ null-coalescing ได้
- ตัวดำเนินการการรวมศูนย์เป็นค่าที่เชื่อมโยงทางขวา ซึ่งหมายความว่าการแสดงออก เช่น a ??= b ??= c จะถูกประเมินเป็น ??= (b ??= c)
การใช้ตัวดำเนินการ Null Coalescing
การใช้งานของ โอเปอเรเตอร์การรวมศูนย์ที่เป็นโมฆะ เป็น:
1: การให้ค่าเริ่มต้น
เมื่อทำงานกับประเภท nullable ถ้าค่าเป็น null คุณสามารถใช้ โอเปอเรเตอร์การรวมศูนย์ที่เป็นโมฆะ เพื่อให้เป็นค่าเริ่มต้นแทนการโยนข้อยกเว้น
ใช้ระบบ;โปรแกรมชั้นเรียนสาธารณะ
{
โมฆะสาธารณะคงหลัก ( )
{
int? nullableValue = null;
ค่า int = nullableValue ?? 10 ;
Console.WriteLine ( 'ค่าคือ: ' + ค่า ) ;
}
}
ในตัวอย่างข้างต้น เรากำหนดจำนวนเต็ม ค่า nullable ตัวแปรและให้ค่าเป็นศูนย์ เดอะ โอเปอเรเตอร์การรวมศูนย์ที่เป็นโมฆะ จากนั้นจะใช้เพื่อให้ตัวแปรค่าเป็นค่าเริ่มต้นที่ 10 ถ้าค่า nullableValue เป็นค่าว่าง ถัดไป ค่าจะแสดงบนคอนโซล
2: หลีกเลี่ยงข้อยกเว้นการอ้างอิงที่เป็นค่าว่าง
ค่า Null อาจส่งผลให้เกิดข้อยกเว้นการอ้างอิงเป็น Null เมื่อทำงานกับโครงสร้างข้อมูลที่ซับซ้อน เช่น อ็อบเจ็กต์และอาร์เรย์ ข้อยกเว้นเหล่านี้สามารถหลีกเลี่ยงได้โดยใช้ โอเปอเรเตอร์การรวมศูนย์ที่เป็นโมฆะ ซึ่งให้ค่าดีฟอลต์
ใช้ระบบ;myClass คลาสสาธารณะ
{
ชื่อสตริงสาธารณะ { รับ; ชุด ; }
รหัส int สาธารณะ { รับ; ชุด ; }
}
โปรแกรมชั้นเรียนสาธารณะ
{
โมฆะสาธารณะคงหลัก ( )
{
บุคคล myClass = null;
ชื่อสตริง = คน?.ชื่อ ?? 'ไม่ทราบ' ;
นานาชาติ รหัส = คน?.ID ?? 0 ;
Console.WriteLine ( 'ชื่อ: ' + ชื่อ ) ;
Console.WriteLine ( 'รหัส: ' + รหัส ) ;
}
}
ชื่อ และ รหัส เป็นคุณลักษณะของ ห้องเรียนของฉัน คลาสในรหัสด้านบน เพื่อให้เข้าถึงได้อย่างปลอดภัย ชื่อ และ รหัส คุณสมบัติของอ็อบเจกต์บุคคลและจัดหาค่าเริ่มต้นหากเป็นค่าว่าง จะตั้งค่าตัวแปรบุคคลเป็นค่าว่าง จากนั้นจึงใช้ตัวดำเนินการเงื่อนไขค่าว่าง (?.) และ โอเปอเรเตอร์การรวมศูนย์ที่เป็นโมฆะ (??). จากนั้นคอนโซลจะถูกพิมพ์ด้วยชื่อและค่ารหัส
3: การลบเงื่อนไข if-else ที่ซ้ำซ้อน
คุณยังสามารถใช้โอเปอเรเตอร์การรวมศูนย์เพื่อทำให้โค้ดของคุณกระชับและอ่านง่ายขึ้นโดยไม่จำเป็นต้องซ้ำซ้อน เงื่อนไข if-else .
ตัวอย่างเช่น:
ใช้ระบบ;ตัวอย่างเนมสเปซ
{
คลาส myClass
{
โมฆะคงที่หลัก ( สตริง [ ] หาเรื่อง )
{
int? nullableValue = null;
ค่า int;
ถ้า ( ค่า nullable ! = โมฆะ )
{
ค่า = nullableValue.Value;
}
อื่น
{
ค่า = 10 ;
}
Console.WriteLine ( 'ค่าคือ: ' + ค่า ) ;
}
}
}
ในโค้ดด้านบน ตัวดำเนินการการรวมศูนย์ที่เป็นโมฆะ ?? ใช้เพื่อกำหนดค่าของ ค่า nullable มูลค่า. ถ้า ค่า nullable ไม่เป็นโมฆะ ค่าที่ได้จะมีค่าเท่ากับ ค่า nullable . ถ้า ค่า nullable เป็น null ค่าที่ได้จะมีค่าเท่ากับ 10 ถ้าอย่างอื่น ไม่จำเป็นต้องมีเงื่อนไขอีกต่อไป และตอนนี้รหัสก็สั้นลงและเข้าใจง่ายขึ้น
บทสรุป
เดอะ โอเปอเรเตอร์การรวมศูนย์ที่เป็นโมฆะ ใน C# เป็นคุณสมบัติอันทรงพลังที่ช่วยให้วิธีที่นักพัฒนาจัดการค่า Null ในโครงการของพวกเขาง่ายขึ้น ตัวดำเนินการนี้มีไวยากรณ์ที่กะทัดรัด มีประสิทธิภาพ และยืดหยุ่นในการกำหนดค่าเริ่มต้นให้กับตัวแปรที่อาจเป็นค่าว่าง โดยใช้ โอเปอเรเตอร์การรวมศูนย์ที่เป็นโมฆะ นักพัฒนาสามารถเขียนโค้ดที่อ่านง่าย บำรุงรักษาได้ และมีประสิทธิภาพมากขึ้น ช่วยประหยัดเวลาและความพยายามในกระบวนการพัฒนา