กำหนดค่าระดับ / โครงสร้าง: รูปแบบหรือรูปแบบต่อต้าน? ทางเลือก?

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

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

2. ทำให้การตั้งค่าการกำหนดค่าที่ใช้บ่อยที่สุดคือ global / static นี่เป็นวิธีที่ง่ายที่สุด แต่แนะนำให้ดำเนินการในระยะไกลเป็นอุปสรรคต่อการทดสอบและถือว่าการกำหนดค่านั้นเป็นระดับโลกอย่างแท้จริง (ซึ่งคุณต้องการเพียงหนึ่งการกำหนดค่าในเวลาที่กำหนด)

3. สร้างคลาสการกำหนดค่า / โครงสร้างที่มีตัวเลือกการกำหนดค่าทั้งหมดสำหรับโปรแกรมทั้งหมดหรือสำหรับข้อกังวลหลัก ๆ ภายในโปรแกรมจากนั้นส่งผ่านสิ่งนี้อย่างชัดเจน สิ่งนี้ชัดเจนน้อยกว่า (1) แต่ชัดเจนกว่า (2) หากคุณต้องการเปลี่ยนการตั้งค่าสำหรับการเรียกใช้ฟังก์ชั่นเดียวคุณสามารถโคลนวัตถุกำหนดค่าและเปลี่ยนค่านี้ได้ สิ่งนี้มีประโยชน์ทั้งในการทดสอบและในทางปฏิบัติ อย่างไรก็ตามคุณยังคงสามารถส่งข้อมูลจำนวนมากไปยังฟังก์ชั่นที่ไม่ต้องการและเปลี่ยนค่าในคลาส / โครงสร้าง config ยังสามารถทำให้เกิดการกระทำที่ระยะไกล

คุณจะพิจารณา (3) รูปแบบหรือรูปแบบการต่อต้านหรือไม่? หากเป็นรูปแบบการต่อต้านคุณจะทำอย่างไรแทน

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

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

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

หากคุณใช้. NET คุณสามารถสร้างคลาสด้วย DataContracts ที่คุณสามารถใช้ XmlSerialiser เพื่อสร้างลำดับชั้นวัตถุจากการกำหนดค่า Xml ของคุณและส่งต่อวัตถุเหล่านี้เป็นรูปแบบการกำหนดค่า

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

การรู้ว่าส่วนใดเป็นส่วนใดและการแยกการตั้งค่าข้อมูลเหล่านี้จะทำให้การติดตั้งอัปเดตง่ายขึ้นมาก (โดยไม่สูญเสียการตั้งค่าลูกค้า)

ฉันจะทำให้ชั้นเรียนในตัวเลือก # 3 คงที่ ดังนั้นแทนที่จะ

//create SomeCl
Foo f = new Foo();
f.setConfigInst(cfg);
...
...
//Inside Foo
public void setConfig(MyAppConfig c) { localCfg = c; }
...
//somewhere else:
x = localCfg.getConfigForX();

คุณสามารถมี:

//Inside Foo
x = MyAppConfig.getConfigForX();

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

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

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

เราทำงานกับการกำหนดค่าที่แตกต่างกัน 3 แบบโดยเฉพาะสำหรับพีซีซึ่งผู้ใช้กำลังทำงานอยู่ ที่สองที่เฉพาะเจาะจงสำหรับผู้ใช้ปัจจุบันและการกำหนดค่าระดับโลกที่สามสำหรับผู้ใช้และลูกค้าแอปทั้งหมด

แต่ละการกำหนดค่าจะถูกแสดงในแต่ละอินสแตนซ์ของแอปพลิเคชันโดยวัตถุ

วิธีนี้อาจช่วยโครงการของคุณ