คำถามติดแท็ก design

บริบท เนื่องจากความไร้สัญชาติของรูปแบบสถาปัตยกรรม REST ที่เกี่ยวข้องกับการร้องขอแต่ละรายการนั้นล้วน แต่อยู่คนเดียวเซิร์ฟเวอร์ชั้นนำที่จะไม่เก็บข้อมูลใด ๆ เกี่ยวกับลูกค้า ดังนั้นการควบคุมภาวะพร้อมกันในแง่ร้ายไม่เหมาะสมเพราะจะต้องมีการจัดเก็บเซิร์ฟเวอร์ที่ลูกค้าจะได้รับการล็อคทรัพยากร การควบคุมภาวะพร้อมกันในแง่ดีนั้นจะถูกนำมาใช้ด้วยความช่วยเหลือของEtagส่วนหัว (btw ตามที่ฉันถาม/programming/30080634/concurrency-in-a-rest-api ) ปัญหา ปัญหาหลักที่เกิดขึ้นกับกลไกการควบคุมภาวะพร้อมกันในแง่ดีคือคุณอนุญาตให้ลูกค้าทุกคนทำการดำเนินการใด ๆ ได้ตลอดเวลา และฉันต้องการหลีกเลี่ยงสิ่งนั้นโดยไม่ทำลายหลักการไร้สัญชาติของ REST ฉันหมายความว่าลูกค้าทั้งหมดไม่สามารถดำเนินการใด ๆ ได้ตลอดเวลา คำถาม ในใจของฉันมันเป็นไปได้ด้วยกลไกการควบคุมภาวะพร้อมกันแบบกึ่งมองโลกในแง่ดีเช่นนั้น: ลูกค้าสามารถขอโทเค็น สามารถสร้างโทเค็นเดียวเท่านั้นและมีระยะเวลาที่ จำกัด หากต้องการดำเนินการกับทรัพยากร (เช่นPOSTหรือPUT ) ไคลเอ็นต์จะต้องให้โทเค็นนี้เป็นส่วนหนึ่งของเนื้อความ (หรือส่วนหัว?) ของคำขอ ลูกค้าที่ไม่มีโทเค็นไม่สามารถทำการดำเนินการเหล่านี้ได้ มันคล้ายกันมากกับการควบคุมภาวะพร้อมกันในแง่ดียกเว้นว่ามีลูกค้าเพียงรายเดียวเท่านั้นที่สามารถทำการดำเนินการบางอย่าง (ลูกค้าที่ได้รับโทเค็น) ... ตรงข้ามกับ "ลูกค้าทุกคนสามารถดำเนินการทั้งหมดได้" กลไกนี้เข้ากันได้กับสไตล์สถาปัตยกรรม REST หรือไม่? มันทำลายข้อ จำกัด ใด ๆ หรือไม่? ฉันคิดว่าจะถาม SO แต่ดูเหมือนว่าจะเป็นคำถามระดับสูงที่เกี่ยวข้องกับการออกแบบซอฟต์แวร์

9 design  architecture  rest  concurrency 

เป้าหมายของงานของฉันคือการออกแบบระบบขนาดเล็กที่สามารถเรียกใช้งานที่เกิดขึ้นซ้ำตามกำหนดเวลา งานที่เกิดซ้ำเป็นเหมือน "ส่งอีเมลไปยังผู้ดูแลระบบทุกชั่วโมงตั้งแต่ 8:00 น. ถึง 17:00 น. วันจันทร์ถึงวันศุกร์" ฉันได้เรียนฐานที่เรียกว่าRecurringTask public abstract class RecurringTask{ // I've already figured out this part public bool isOccuring(DateTime dateTime){ // implementation } // run the task public abstract void Run(){ } } และฉันมีหลายชั้นเรียนซึ่งได้รับมาจากRecurringTask หนึ่งในนั้นคือเรียกว่าSendEmailTask public class SendEmailTask : RecurringTask{ private Email email; public SendEmailTask(Email …

9 design  design-patterns  object-oriented  visitor-pattern 

ฉันได้รับมอบหมายให้ออกแบบเฟรมเวิร์กแอปพลิเคชันที่จะอนุญาตให้แต่ละการปรับใช้ส่วนต่าง ๆ ของส่วนติดต่อผู้ใช้เอง ตัวอย่างหนึ่งดังกล่าวอาจเป็นไปได้ว่าการใช้งาน (ลองเรียกว่าไคลเอนต์นับจากนี้เป็นต้นไป) สามารถกำหนดเซลล์มุมมองคอลเลกชันที่จะกลับมาสำหรับหน้าจอเฉพาะ เฟรมเวิร์กมีหน้าที่รับผิดชอบในการจำหน่ายวัตถุที่เหมาะสมเพื่อให้การสร้างแอปง่ายขึ้นมากเนื่องจากเราจะสร้างอินสแตนซ์ที่ดูคล้ายกันหลายครั้ง แนวทางปัจจุบันของฉันในกรอบการทำงานคือการออกแบบตัวควบคุมประสานงานที่รับผิดชอบการนำเสนอและเลิกจ้างกิจกรรมทั้งหมดในแอพ ตัวควบคุมการประสานงานเริ่มต้นจะแสดงตัวควบคุมมุมมองเริ่มต้นทั้งหมดภายในกรอบงานที่ทำงานทั้งหมดที่เกี่ยวข้องโดยไม่จำเป็นต้องมี UI ที่กำหนดค่าไว้ ตัวอย่างเช่น: หนึ่งคอนโทรลเลอร์จะแสดงมุมมองคอลเลกชันที่มีเซลล์แม่แบบและไม่มีอะไรพิเศษ ประโยชน์ของการออกแบบนี้คือการลบการเชื่อมต่อระหว่างตัวควบคุมและยังช่วยให้ลูกค้าสามารถแทนที่ผู้ประสานงานเริ่มต้นและส่งกลับตัวควบคุมมุมมองใหม่ทั้งหมดสำหรับงานเฉพาะ ปัญหาที่ฉันมีคือฉันควรออกแบบกรอบงานนี้อย่างไรเพื่อให้ลูกค้าสามารถเพิ่ม UI ที่กำหนดเองของตัวเองลงในแอพได้ แนวทางที่หนึ่ง ทำให้เฟรมเวิร์กจำเป็นต้องใช้มุมมองจากโรงงานและให้มุมมองนี้จากโรงงานรับผิดชอบในการจำหน่ายมุมมองที่เกี่ยวข้องทั้งหมด ดังนั้นใน App Delegate เราอาจบังคับให้ไคลเอนต์สร้าง CollectionViewCellFactory เป็นต้นและอินเทอร์เฟซจะกำหนดเซลล์ทั้งหมดที่คลาสที่สอดคล้องกันใด ๆ จะต้องจัดหา ฉันสืบทอดฐานรหัสด้วยการออกแบบนี้และย้ายออกไปจากที่นี่เพราะมันเป็นนามธรรมและปรับแต่งได้ มันมาพร้อมกับโรงงานมากมายสำหรับทุกแง่มุมของแอพและจะเพิ่มวันเข้าสู่เวลาตั้งค่าของแอพทุกตัว แนวทางที่สอง แต่ละตัวควบคุมมุมมองระบุ hooks subclassing หรือ setup API ที่จะอนุญาตให้กำหนด UI คลาสแบบกำหนดเองเหล่านี้ในเวลาทำงาน (คล้ายกับวิธีที่ UISplitViewController อนุญาตให้ผู้เรียกตั้งค่าตัวควบคุมโดยใช้คุณสมบัติ viewControllers) ในการทำสิ่งนี้ลูกค้าแต่ละคนจะทำการ subclass Base ประสานงานควบคุมและในแต่ละงานนำเสนอของคอนโทรลเลอร์ ตั้งค่าที่เหมาะสมลงบนคอนโทรลเลอร์เพื่อให้ได้ UI ที่ต้องการ …

9 design  architecture  ios  user-interface 

นี่คือข้อกำหนดที่ง่ายขึ้น: ผู้ใช้สร้างQuestionที่มีหลายAnswers Questionต้องมีอย่างน้อยหนึ่งAnswerรายการ การชี้แจง: คิดQuestionและAnswerในการทดสอบ : มีคำถามหนึ่งข้อ แต่มีหลายคำตอบซึ่งมีเพียงไม่กี่ข้อที่ถูกต้อง ผู้ใช้คือนักแสดงที่กำลังเตรียมการทดสอบนี้ดังนั้นเขาจึงสร้างคำถามและคำตอบ ฉันพยายามจำลองตัวอย่างง่ายๆนี้เพื่อ 1) จับคู่โมเดลชีวิตจริง 2) แสดงรหัสด้วยดังนั้นเพื่อลดการใช้ผิดและข้อผิดพลาดที่อาจเป็นไปได้และให้คำแนะนำแก่นักพัฒนาเกี่ยวกับวิธีใช้โมเดล คำถามที่เป็นนิติบุคคลในขณะที่คำตอบคือวัตถุที่คุ้มค่า คำถามถือคำตอบ จนถึงตอนนี้ฉันมีวิธีแก้ปัญหาที่เป็นไปได้เหล่านี้ [A]ภายในโรงงานQuestion แทนที่จะสร้างAnswerด้วยตนเองเราสามารถโทร: Answer answer = question.createAnswer() answer.setText(""); ... ที่จะสร้างคำตอบและเพิ่มลงในคำถาม จากนั้นเราสามารถจัดการคำตอบได้โดยตั้งค่าคุณสมบัติ ด้วยวิธีนี้เฉพาะคำถามเท่านั้นที่สามารถสร้างคำตอบได้ นอกจากนี้เราป้องกันไม่ให้มีคำตอบโดยไม่มีคำถาม แต่เราไม่ได้มีการควบคุมมากกว่าการสร้างคำตอบเป็นที่ hardcoded Questionใน นอกจากนี้ยังมีปัญหาหนึ่งกับ 'ภาษา' ของรหัสด้านบน ผู้ใช้คือคนที่สร้างคำตอบไม่ใช่คำถาม โดยส่วนตัวแล้วฉันไม่ชอบที่เราจะสร้างวัตถุที่มีคุณค่าและขึ้นอยู่กับนักพัฒนาเพื่อเติมให้เต็มด้วยค่า - เขาจะแน่ใจได้อย่างไรว่าจะต้องเพิ่มอะไรบ้าง [B]คำถามจากโรงงานใช้ # 2 บางคนบอกว่าเราควรมีวิธีนี้ในQuestion: question.addAnswer(String answer, boolean correct, int level....); เช่นเดียวกับวิธีแก้ไขปัญหาข้างต้นวิธีนี้ใช้ข้อมูลที่จำเป็นสำหรับคำตอบและสร้างรายการที่จะถูกเพิ่มลงในคำถามด้วย …

9 design  domain-driven-design  domain-model 

ฉันได้เรียนที่มีสามวิธีA(), และB() C()วิธีการเหล่านั้นแก้ไขอินสแตนซ์ของตัวเอง ในขณะที่วิธีการจะต้องส่งคืนอินสแตนซ์เมื่ออินสแตนซ์เป็นสำเนาแยกต่างหาก (เช่นเดียวกับClone()) ฉันมีตัวเลือกฟรีที่จะส่งคืนvoidหรืออินสแตนซ์เดียวกัน ( return this;) เมื่อทำการแก้ไขอินสแตนซ์เดียวกันในวิธีการและไม่คืนค่าอื่น ๆ obj.A().B().C();เมื่อตัดสินใจกลับมาเช่นการแก้ไขเดียวกันผมสามารถทำโซ่วิธีการเรียบร้อยเช่น นี่จะเป็นเหตุผลเดียวที่ทำเช่นนั้น? มันยังโอเคที่จะปรับเปลี่ยนอินสแตนซ์ของตัวเองและส่งคืนด้วยหรือไม่ หรือควรส่งคืนสำเนาและปล่อยให้วัตถุต้นฉบับเหมือนเดิมหรือไม่ เพราะเมื่อส่งคืนอินสแตนซ์ที่ถูกแก้ไขเดียวกันผู้ใช้อาจจะคิดว่าค่าที่ส่งคืนเป็นสำเนามิฉะนั้นจะไม่ถูกส่งคืน? หากไม่เป็นไรวิธีที่ดีที่สุดในการชี้แจงเรื่องดังกล่าวกับวิธีการคืออะไร

9 design  object-oriented  methods  return-type  method-chaining 

ฉันใช้อินเตอร์เฟสขนาดใหญ่ที่มีประมาณ 50 วิธีในการเข้าถึงฐานข้อมูล ส่วนต่อประสานถูกเขียนขึ้นโดยเพื่อนร่วมงานของฉัน เราพูดถึงเรื่องนี้: ฉัน: 50 วิธีมากเกินไป มันเป็นกลิ่นรหัส เพื่อนร่วมงาน: ฉันต้องทำอย่างไรกับเรื่องนี้? คุณต้องการเข้าถึงฐานข้อมูล - คุณมีมัน ฉัน: ใช่ แต่มันไม่ชัดเจนและไม่สามารถบำรุงรักษาได้ในอนาคต เพื่อนร่วมงาน: โอเคคุณพูดถูกมันไม่ดีเลย อินเตอร์เฟสควรมีหน้าตาเป็นอย่างไร? ฉัน: วิธีการประมาณ 5 วิธีที่ส่งคืนวัตถุที่มีเช่น 10 วิธีในแต่ละวิธี? อืม แต่นี่จะไม่เหมือนกันหรือ สิ่งนี้นำไปสู่ความชัดเจนมากขึ้นหรือไม่? มันคุ้มค่ากับความพยายามหรือไม่? ทุก ๆ ครั้งที่ฉันอยู่ในสถานการณ์ที่ฉันต้องการอินเทอร์เฟซและสิ่งแรกที่นึกได้ก็คืออินเทอร์เฟซใหญ่ มีรูปแบบการออกแบบทั่วไปสำหรับสิ่งนี้หรือไม่? อัปเดต (ตอบกลับความคิดเห็นของ SJuan): "ชนิดวิธีการ": เป็นอินเทอร์เฟซสำหรับดึงข้อมูลจากฐานข้อมูล วิธีการทั้งหมดมีรูปแบบ (pseudocode) List<Typename> createTablenameList() วิธีการและตารางไม่ได้อยู่ในความสัมพันธ์ 1-1 อย่างชัดเจนสิ่งสำคัญคือความจริงที่ว่าคุณได้รับรายการบางประเภทที่มาจากฐานข้อมูลเสมอ

9 design  c++  interfaces 

ฉันมีข้อสงสัยอย่างมากเกี่ยวกับการออกแบบสำหรับเว็บแอปพลิเคชันของฉัน ฉันต้องการแยกตรรกะทางธุรกิจออกจากส่วนติดต่อดังนั้นฉันจึงสร้าง Web API ที่จัดการคำขอทั้งหมดไปยังฐานข้อมูล มันเป็น ASP.NET Web API พร้อม Entity framework และหน่วยการทำงานและรูปแบบพื้นที่เก็บข้อมูลทั่วไป จนถึงตอนนี้ทุกอย่างดี ปัญหา ที่ฉันต้องการความช่วยเหลือฉันไม่สามารถหาวิธีที่มีประสิทธิภาพในการแชร์ออบเจ็กต์ระหว่าง API และแอปพลิเคชัน ฉันไม่ต้องการที่จะทำให้เป็นลำดับวัตถุวัตถุโดยตรงฉันคิดว่ามันจะเป็นวิธีปฏิบัติที่ไม่ดีเพราะถ้ารูปแบบนิติบุคคลมีการเปลี่ยนแปลงฉันสามารถจบลงด้วยวัตถุขนาดใหญ่ที่ทำให้เป็นอันดับโดยไม่มีเหตุผล วิธีการใช้งานตอนนี้ เนื่องจากอินเทอร์เฟซของฉันคือ ASP.NET เว็บแอปพลิเคชันใน C # และ API ของฉันอยู่ใน C # ฉันจึงสร้างไลบรารีทั่วไปพร้อมคำจำกัดความของคลาสทั้งหมดของฉันที่ฉันต้องการแชร์ระหว่างพวกเขา ฉันรู้ว่าวิธีแก้ปัญหาจะไม่ทำงานเมื่อฉันจะพัฒนาแอพ Android ฉันจะต้องสร้างคลาสของฉันอีกครั้งใน Java แต่นั่นไม่ใช่ปัญหาที่ใหญ่ที่สุดของฉัน ปัญหาคือฉันรู้สึกว่าฉันมักจะแปลงวัตถุของฉัน ตัวอย่าง นี่คือตัวอย่างของกระบวนการทำงานของฉัน: ฉันเริ่มต้นด้วยโมเดลที่มีวัตถุทั้งหมดและบันทึกย่อข้อมูลสำหรับฟอร์มของฉันจากนั้นผู้ใช้จะโพสต์โมเดลนั้นไปยังคอนโทรลเลอร์ ในคอนโทรลเลอร์ฉันต้องแปลงโมเดลนี้เป็นคลาสในไลบรารีทั่วไปของฉันจากนั้นส่งวัตถุนั้นไปยัง API ของฉัน จากนั้นคอนโทรลเลอร์ใน API ของฉันจะรับสายและแปลงวัตถุนั้นเป็นวัตถุเอนทิตีเพื่ออัพเดทฐานข้อมูล ดังนั้นฉันมี 3 ชั้น โมเดลสำหรับมุมมองพร้อมหมายเหตุประกอบข้อมูลทั้งหมดสำหรับการตรวจสอบความถูกต้อง …

9 design  design-patterns  web-development  web-api 

ปิด คำถามนี้จะต้องมีมากขึ้นมุ่งเน้น ไม่ยอมรับคำตอบในขณะนี้ ต้องการปรับปรุงคำถามนี้หรือไม่ อัปเดตคำถามเพื่อให้มุ่งเน้นที่ปัญหาเดียวโดยแก้ไขโพสต์นี้ ปิดให้บริการใน5 ปีที่ผ่านมา ฉันเข้าใจแนวคิดของวัตถุและในฐานะที่เป็นโปรแกรมเมอร์ Java ฉันรู้สึกว่ากระบวนทัศน์ OO นั้นค่อนข้างเป็นธรรมชาติสำหรับฉันในทางปฏิบัติ อย่างไรก็ตามเมื่อเร็ว ๆ นี้ฉันพบว่าตัวเองกำลังคิด: รอสักครู่สิ่งที่เป็นประโยชน์จริงของการใช้วัตถุมากกว่าการใช้คลาสคงที่ (มีการห่อหุ้มที่เหมาะสมและการปฏิบัติ OO)? ฉันนึกถึงประโยชน์สองประการของการใช้วัตถุ (ทั้งสองอย่างมีความสำคัญและมีประสิทธิภาพ): ความแตกต่าง: ช่วยให้คุณสามารถสลับการทำงานแบบไดนามิกและยืดหยุ่นในช่วงรันไทม์ ยังอนุญาตให้เพิ่ม 'ส่วน' การทำงานใหม่และทางเลือกให้กับระบบได้อย่างง่ายดาย ตัวอย่างเช่นหากมีCarคลาสที่ออกแบบมาเพื่อทำงานกับEngineวัตถุและคุณต้องการเพิ่ม Engine ใหม่ให้กับระบบที่รถยนต์สามารถใช้ได้คุณสามารถสร้างEngineคลาสย่อยใหม่ และเพียงส่งวัตถุของคลาสนี้ไปยัง Carวัตถุโดยไม่ต้อง Carเปลี่ยนอะไรเกี่ยวกับ และคุณสามารถตัดสินใจได้ในระหว่างรันไทม์ ความสามารถในการ 'ผ่านฟังก์ชันการทำงานรอบ ๆ ': คุณสามารถส่งผ่านวัตถุรอบ ๆ ระบบแบบไดนามิก แต่มีข้อได้เปรียบเพิ่มเติมใด ๆ กับวัตถุที่อยู่เหนือคลาสแบบคงที่ บ่อยครั้งที่ฉันเพิ่ม 'ส่วน' ใหม่ลงในระบบฉันทำได้โดยการสร้างคลาสใหม่และสร้างอินสแตนซ์ของวัตถุจากมัน แต่เมื่อเร็ว ๆ นี้เมื่อฉันหยุดและคิดเกี่ยวกับมันฉันรู้ว่าชั้นคงที่จะทำเช่นเดียวกับวัตถุในสถานที่จำนวนมากที่ฉันมักจะใช้วัตถุ ตัวอย่างเช่นฉันกำลังทำงานเพื่อเพิ่มกลไกการบันทึก / …

9 design  object-oriented  class  static 

มาตรฐาน C99 ระบุไว้ใน 6.5.16: 2: ผู้ประกอบการที่ได้รับมอบหมายจะต้องมีค่า lvalue ที่สามารถแก้ไขได้เป็นตัวถูกดำเนินการด้านซ้าย และใน 6.3.2.1:1: lvalue ที่แก้ไขได้คือ lvalue ที่ไม่มีประเภทอาร์เรย์, ไม่มีประเภทที่ไม่สมบูรณ์, ไม่มีประเภทที่ผ่านการรับรองและถ้าเป็นโครงสร้างหรือสหภาพไม่มีสมาชิกใด ๆ (รวมถึงสมาชิกแบบเรียกซ้ำสมาชิกใด ๆ ) หรือองค์ประกอบของมวลรวมหรือสหภาพที่มีอยู่ทั้งหมด) ที่มีประเภทที่ผ่านการรับรอง ตอนนี้ขอพิจารณาไม่ใช่const structมีconstข้อมูล typedef struct S_s { const int _a; } S_t; ตามมาตรฐานรหัสต่อไปนี้คือพฤติกรรมที่ไม่ได้กำหนด (UB): S_t s1; S_t s2 = { ._a = 2 }; s1 = s2; ปัญหาทางความหมายของเรื่องนี้คือสิ่งที่แนบมาเอนทิตี้ของ ( …

9 design  c 

ฉันกำลังดูที่การออกแบบส่วนต่อประสานของฉันและฉันพยายามที่จะตัดสินใจว่าวิธีใดที่ "ถูกต้อง" ที่สุดในการใช้การควบคุมการเข้าถึงตามบทบาทซึ่งกำหนดไว้userและสิ่งsubjectที่userต้องการเข้าถึง เท่าที่ฉันเห็นฉันมีสามตัวเลือกหลัก (ที่สี่เป็นลูกครึ่งของสามสามและห้าเป็นบิดของสี่): ค้นหาsubjectด้วยรายการสิทธิ์ที่userมี -subject.allowAccess(user.getPermissionSet) ค้นหาuserด้วยรายการสิทธิ์ที่subjectต้องการ -user.hasPermissionTo(subject.getRequiredPermissions()) สอบถามบุคคลที่สามเพื่อค้นหาจุดตัดสิทธิ์ - accessController.doPermissionSetsIntersect(subject.permissionSet, user.getPermissionSet()) ค้นหาทั้งsubject/ userในขณะที่มอบหมาย "การตัดสินใจ" ให้กับบุคคลที่สามชั้น มีuserความพยายามในการเข้าถึงsubjectและโยนข้อผิดพลาดหากไม่ได้รับอนุญาต ฉันกำลังเอนเอียงไปทางตัวเลือกที่สี่ - มีsubjectประกอบด้วยaccessControllerข้อมูลที่โทรไปยังsubject.userMayAccess(User user)มอบหมายการดำเนินการแบบ a la: class Subject { public function display(user) { if(!accessController.doPermissionSetsIntersect(this.permissionSet, user.getPermissionSet())) { display403(); //Or other.. eg, throw an error.. } } } .. แต่เมื่อถามคำถามเพิ่มเติม: accessControllerฟิลด์ควรเป็นคลาสคงที่ .. ควรsubject รู้ว่าต้องใช้การอนุญาตใดเพื่อให้สามารถดูได้ …

9 design  single-responsibility  access-control 

ฉันคิดว่าคำถามนี้ควรใช้กับโปรแกรมส่วนใหญ่ที่โหลดการตั้งค่าจากไฟล์ คำถามของฉันมาจากมุมมองการเขียนโปรแกรมและเป็นวิธีจัดการกับการโหลดการตั้งค่าจากไฟล์ในแง่ของคลาสและการเข้าถึงที่แตกต่างกัน ตัวอย่างเช่น หากโปรแกรมมีsettings.iniไฟล์อย่างง่ายเนื้อหาของมันควรจะโหลดในload()วิธีการเรียนหรือบางทีนวกรรมิก? ควรเก็บค่าไว้ในpublic staticตัวแปรหรือควรมีstaticวิธีรับและตั้งค่าคุณสมบัติหรือไม่ จะเกิดอะไรขึ้นหากไฟล์ไม่มีอยู่หรืออ่านไม่ได้? คุณจะให้โปรแกรมที่เหลือรู้ว่าไม่สามารถรับคุณสมบัติเหล่านั้นได้อย่างไร เป็นต้น ฉันหวังว่าฉันจะขอสิ่งนี้ในสถานที่ที่เหมาะสมที่นี่ ฉันต้องการตั้งคำถามให้เป็นผู้ไม่เชื่อเรื่องภาษามากที่สุด แต่ฉันมุ่งเน้นที่ภาษาที่มีสิ่งต่าง ๆ เช่นมรดกโดยเฉพาะ Java และ C # .NET

9 design  language-agnostic  file-handling 

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

9 design  functional-programming  haskell  architectural-patterns 

ขณะนี้เรากำลังออกแบบ REST API เพื่อเข้าถึงข้อมูลลูกค้าแบบดั้งเดิม หนึ่งในองค์ประกอบใน API เป็นสินทรัพย์ของผู้ใช้ สินทรัพย์จะถูกเพิ่มภายใต้บริการที่กำหนด API ส่วนหลังจะเพิ่มเนื้อหาให้กับผู้ใช้ภายใต้บริการที่กำหนดเท่านั้น ดังนั้นจึงไม่มีผู้ใช้ - ความสัมพันธ์ของเนื้อหา แต่เป็นผู้ใช้ - [บริการ] - ความสัมพันธ์ของเนื้อหา URI ของเราจะเป็นดังนี้: /users/{id}/assets/{id}/services/{id} การใช้ API จะทราบรหัสเนื้อหาและรหัสบริการเพื่อสร้างรายการใหม่ สิ่งที่เราดิ้นรนคือการสร้างความสัมพันธ์นี้ วิธีหนึ่งที่ตรงไปตรงมาคือการโพสต์ความสัมพันธ์ทั้งหมด /users/{id}/assets/ POST /users/{id}/assets {asset:${id}, service:{id}, attribute1:"{var}", attribute2:"{var}"} แต่จากนั้นเราไม่ได้สร้างเนื้อหาตามที่ URI อาจระบุ แต่เป็นเรื่องเกี่ยวกับบริการสินทรัพย์ อีกทางเลือกหนึ่งเรากำลังพิจารณา POST'ing กับ URI ที่เกี่ยวข้องกับความสัมพันธ์ดังนี้: POST /users/{id}/assets/{id}/service/{id} {attribute1:"{var}", attribute2:"{var}"} แต่ในกรณีนี้เส้นทางของทรัพยากร/users/{id}/assets/{id}จะไม่มีอยู่ก่อน POST และจะถูกสร้างเป็นผลข้างเคียง กำลังโพสต์ไปยังเส้นทางของทรัพยากรที่ยังไม่ได้รับอนุญาตเลย? …

9 design  design-patterns  rest 

ฉันเลิกเขียนโปรแกรมเมื่อประมาณหนึ่งปีที่แล้วตอนที่ฉันกดปุ่มกำแพงนี้ต่อไป ฉันกำลังทบทวนหัวข้อนี้เพราะฉันต้องการสร้างแอปพลิเคชัน Android ขั้นพื้นฐาน แต่ฉันรู้สึกว่าความรู้ที่ จำกัด ของฉันจะไม่เพียงพอ นี่คือปัญหาของฉัน ฉันได้อ่านหนังสือสองสามเล่มและดูวิดีโอการสอนบน C # / Java แล้วทำตามตัวอย่างจากนั้นก็อ่านหนังสือจนจบ ในท้ายที่สุดพวกเขาดูเหมือนจะทิ้งฉันไปตะลึงกับสิ่งที่ต้องทำต่อไป หมายความว่าอย่างไรพวกเขาสอนคุณจากแอปพลิเคชัน "สวัสดีโลก" พื้นฐานของคุณไปจนถึงถ้าและอาร์เรย์นั้นดูเหมือนว่าคุณคาดหวังว่าคุณจะรู้วิธีที่จะออกไปสู่โลกแห่งการเข้ารหัสและสร้างอะไร ฉันทำอะไรบางอย่างหายไปหรือเปล่า ฉันรู้ว่าสิ่งเหล่านี้เป็นองค์ประกอบสำคัญของโปรแกรมทั้งหมด แต่หนังสือที่ฉันอ่านไม่เคยแสดงให้ฉันเห็นว่าต้องทำอะไรต่อไป คำตอบง่ายๆที่ฉันคิดว่าน่าจะเป็น 'เริ่มการเข้ารหัส' แต่ที่ไหน ฉันอ่าน "Head First Java" เป็นตัวอย่าง พวกเขาบอกว่าคุณทำทุกอย่างที่เรียนรู้และสร้างเกมแข่งสุนัข "พยายามที่จะไม่โกงและดูซอร์สโค้ดที่ให้ไว้คุณควรจะทำสิ่งนี้ได้ในตอนนี้" _ นั่นไม่ใช่คำพูดที่แน่นอน แต่โดยทั่วไปนั่นคือสิ่งที่ฉันบอก ....... ครึ่งชั่วโมงที่ผ่านมาพวกเขาแค่อธิบายถึงวิธีการทำอาร์เรย์แล้วถ้าไม่มีทฤษฎีใดที่ฉันตั้งใจจะสร้างเกมที่ใช้งานได้ เหตุผลที่ฉันถามสิ่งนี้เพราะฉันกลัวว่านี่คือทั้งหมดที่ฉันควรรู้อย่างน้อยก็เริ่มเขียนโค้ด แต่มันรู้สึกเหมือนฉันได้รับกล่องเครื่องมือขนาดเล็กและถูกสั่งให้สร้างตึกระฟ้า ขอบคุณสำหรับคำแนะนำใด ๆ

9 java  c#  programming-languages  design 

ฉันไม่ได้พยายามที่จะบอกว่าฉันรู้ว่าสิ่งที่คนอื่นไม่ได้ทำ แต่ฉันได้แก้ไขการออกแบบมากขึ้นด้วยการใช้คลาสที่ซ้อนกันดังนั้นฉันอยากรู้อยากเห็นความรู้สึกของการยอมรับการใช้สิ่งนี้ดูเหมือนไม่ค่อยได้ใช้ กลไกการออกแบบ สิ่งนี้ทำให้ฉันมีคำถาม: ฉันจะลงเส้นทางที่ไม่ดีโดยเนื้อแท้ด้วยเหตุผลที่ฉันจะค้นพบเมื่อพวกเขากลับมากัดฉันหรือเรียนซ้อนกันอาจเป็นสิ่งที่ underrated? นี่คือตัวอย่างสองตัวอย่างที่ฉันเพิ่งใช้เพื่อ: https://gist.github.com/3975581 - สิ่งแรกที่ช่วยให้ฉันเก็บรักษาสิ่งที่สืบทอดมาได้อย่างแน่นหนาด้วยกันครั้งที่สองให้ฉันเข้าถึงสมาชิกที่ได้รับความคุ้มครองจากพนักงาน ...

9 c#  design