มีจุดใดบ้างในการใช้ตัวสร้างและส่วนต่อประสานกับวัตถุเริ่มต้น?

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

Vehicle v = new Vehicle.Builder()
                    .manufacturer("Toyota")
                    .model("Camry")
                    .year(1997)
                    .colour(CarColours.Red)
                    .addSpecialFeature(new Feature.CDPlayer())
                    .addSpecialFeature(new Feature.SeatWarmer(4))
                    .build();

ในทางกลับกันใน C # one สามารถเขียน:

var vehicle = new Vehicle {
                Manufacturer = "Toyota",
                Model = "Camry",
                Year = 1997,
                Colour = CarColours.Red,
                SpecialFeatures = new List<SpecialFeature> {
                    new Feature.CDPlayer(),
                    new Feature.SeatWarmer { Seats = 4 }
                }
              }

... ไม่จำเป็นต้องมีผู้สร้างตามที่เห็นในตัวอย่างก่อนหน้านี้

จากตัวอย่างเหล่านี้ผู้สร้างยังคงมีประโยชน์ใน C # หรือถูกแทนที่โดยผู้เริ่มต้นทั้งหมดหรือไม่

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

รุ่นต่อไปของ C #, 8.0 มีแนวโน้มที่จะแนะนำwithคำหลักซึ่งจะช่วยให้วัตถุที่ไม่เปลี่ยนรูปแบบจะเริ่มต้นได้อย่างชัดเจนและรัดกุมโดยไม่จำเป็นต้องเขียนผู้สร้าง

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

ตัวอย่างเช่น

value.Match()
    .Case((DateTime d) => Console.WriteLine($"{d: yyyy-mm-dd}"))
    .Case((double d) => Console.WriteLine(Math.Round(d, 4));
    // void

var str = value.Match()
    .Case((DateTime d) => $"{d: yyyy-mm-dd}")
    .Case((double d) => Math.Round(d, 4).ToString())
    .ResultOrDefault(string.Empty);
    // string

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

วัตถุเริ่มต้นต้องการให้คุณสมบัติต้องสามารถเข้าถึงได้โดยการเรียกรหัส ผู้สร้างที่ซ้อนกันอาจเข้าถึงสมาชิกส่วนตัวของชั้นเรียน

หากคุณต้องการทำให้Vehicleไม่เปลี่ยนรูปแบบ (ผ่านการตั้งค่าส่วนตัวทั้งหมด) จากนั้นตัวสร้างที่ซ้อนกันสามารถใช้เพื่อตั้งค่าตัวแปรส่วนตัว

พวกเขาทั้งหมดมีจุดประสงค์ที่แตกต่าง !!!

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

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

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