คำถามติดแท็ก object-oriented

ตามที่เป็นอยู่ในปัจจุบันคำถามนี้ไม่เหมาะสำหรับรูปแบบคำถาม & คำตอบของเรา เราคาดหวังคำตอบที่จะได้รับการสนับสนุนจากข้อเท็จจริงการอ้างอิงหรือความเชี่ยวชาญ แต่คำถามนี้มีแนวโน้มที่จะเรียกร้องให้มีการอภิปรายโต้แย้งโต้แย้งหรือการอภิปรายเพิ่มเติม หากคุณรู้สึกว่าคำถามนี้สามารถปรับปรุงและเปิดใหม่ได้โปรดไปที่ศูนย์ช่วยเหลือเพื่อขอคำแนะนำ ปิดให้บริการใน7 ปีที่ผ่านมา มีวิธีปฏิบัติที่ดีที่สุดสำหรับการสั่งซื้อเพื่อกำหนด getters และ setters หรือไม่ ดูเหมือนจะมีสองวิธี: คู่ getter / setter getters แรกจากนั้น setters (หรือวิธีอื่น ๆ ) เพื่อเพิ่มความแตกต่างนี่คือตัวอย่าง Java ของคู่ getter / setter: public class Foo { private int var1, var2, var3; public int getVar1() { return var1; } public void setVar1(int var1) …

14 object-oriented  patterns-and-practices 

ปิด คำถามนี้เป็นคำถามความคิดเห็นตาม ไม่ยอมรับคำตอบในขณะนี้ ต้องการปรับปรุงคำถามนี้หรือไม่ อัปเดตคำถามเพื่อให้สามารถตอบข้อเท็จจริงและการอ้างอิงได้โดยแก้ไขโพสต์นี้ ปิดให้บริการใน2 ปีที่ผ่านมา ในหนังสือโคเดอร์ในที่ทำงาน Joe Armstrong ระบุว่า: ฉันคิดว่าการขาดความสามารถในการนำกลับมาใช้ใหม่เป็นภาษาเชิงวัตถุไม่ใช่ภาษาที่ใช้งานได้ เนื่องจากปัญหาเกี่ยวกับภาษาเชิงวัตถุคือพวกเขามีสภาพแวดล้อมโดยนัยทั้งหมดที่พวกเขามีอยู่ คุณต้องการกล้วย แต่สิ่งที่คุณได้รับคือกอริลลาที่ถือกล้วยและป่าทั้งหมด ฉันไม่ได้รับมันมากที่นี่ หากปัญหาคือการได้รับกล้วยเราสามารถสรุปเหตุผลทั้งหมดที่อยู่เบื้องหลังฟังก์ชั่น 'getBanana' ลิงและป่ามีส่วนเกี่ยวข้องอย่างไรในบริบทนี้ ใครบางคนสามารถเขียนโค้ดขนาดสั้นที่อธิบายถึงปัญหาในวิธีที่เข้าใจง่ายขึ้นพูดแสดงให้เห็นถึงความจริงที่ว่าBananaวัตถุนั้นต้องการMonkeyและJungleวัตถุที่จะเริ่มต้นได้โปรด

14 object-oriented  functional-programming 

ฉันพยายามเขียน servlet ซึ่งทำงานตามค่า "การกระทำ" ที่ส่งผ่านไปเป็นอินพุต นี่คือตัวอย่างที่ public class SampleClass extends HttpServlet { public static void action1() throws Exception{ //Do some actions } public static void action2() throws Exception{ //Do some actions } //And goes on till action9 public void doPost(HttpServletRequest req, HttpServletResponse res)throws ServletException, IOException { String action = req.getParameter("action"); …

14 java  design-patterns  object-oriented 

คลาส LinkedList มีอยู่พร้อมกับฟังก์ชั่นเช่น add_first (), add_last (), add_after (), remove_first (), remove_last () และ remove () ขณะนี้มีคลาสสแต็กที่จัดเตรียมฟังก์ชันการใช้งานเช่น push (), pop (), peek () หรือ top () และเพื่อใช้เมธอดเหล่านี้จะขยายเมธอดคลาส LinkedList นี่เป็นการละเมิดหลักการทดแทนของ Liskov หรือไม่? ตัวอย่างเช่นพิจารณา case add_after () เพื่อเพิ่มโหนดที่ตำแหน่งที่ n ของรายการที่เชื่อมโยง สามารถทำได้ในคลาสพื้นฐาน แต่ไม่สามารถอยู่ในคลาสสแต็กได้ postconditions ถูกทำให้อ่อนลงที่นี่หรือคุณปรับเปลี่ยนวิธี add_after () เพื่อเพิ่มไปยังด้านบนสุดของสแต็กหรือไม่ นอกจากนี้หากไม่เป็นการละเมิดการออกแบบที่ไม่ดีนี้เป็นอย่างไร และคุณจะใช้ฟังก์ชั่น Stack โดยใช้คลาส LinkedList …

13 design  object-oriented  object-oriented-design  solid  liskov-substitution 

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

13 object-oriented  inheritance  composition 

ฉันกำลังสร้างเกมกระดาน (เช่นหมากรุก) ใน Java ซึ่งแต่ละชิ้นเป็นชนิดของตัวเอง (เช่นPawn, Rookฯลฯ ) สำหรับส่วน GUI ของแอปพลิเคชันฉันต้องการรูปภาพสำหรับแต่ละส่วนเหล่านี้ ตั้งแต่ทำไปคิดเหมือน rook.image(); ละเมิดการแยก UI และตรรกะทางธุรกิจฉันจะสร้างผู้นำเสนอที่แตกต่างกันสำหรับแต่ละชิ้นแล้วแมปประเภทชิ้นส่วนกับผู้นำเสนอที่สอดคล้องกันเช่น private HashMap<Class<Piece>, PiecePresenter> presenters = ... public Image getImage(Piece piece) { return presenters.get(piece.getClass()).image(); } จนถึงตอนนี้ดีมาก อย่างไรก็ตามฉันรู้สึกว่าปรมาจารย์ OOP ที่ชาญฉลาดจะขมวดคิ้วเมื่อเรียกgetClass()วิธีการและแนะนำให้ใช้ผู้เยี่ยมชมเช่นนี้: class Rook extends Piece { @Override public <T> T accept(PieceVisitor<T> visitor) { return visitor.visitRook(this); } } …

13 java  design  object-oriented 

ฉันมีCharacterคลาสline 2,500 ที่: ติดตามสถานะภายในของตัวละครในเกม โหลดและยืนยันสถานะนั้น จัดการคำสั่งที่เข้ามา ~ 30 (โดยปกติ = ส่งต่อคำสั่งไปยังGameแต่คำสั่งแบบอ่านอย่างเดียวบางคำสั่งจะตอบกลับทันที) รับสายประมาณ 80 สายจากGameการกระทำที่ต้องทำและการกระทำที่เกี่ยวข้องของผู้อื่น ดูเหมือนว่าฉันCharacterมีความรับผิดชอบเดียว: การจัดการสถานะของตัวละคร, การไกล่เกลี่ยระหว่างคำสั่งที่เข้ามาและเกม มีความรับผิดชอบอื่น ๆ อีกสองสามอย่างที่ถูกทำลายไปแล้ว: Characterมีสิ่งOutgoingที่เรียกร้องให้สร้างการอัพเดตขาออกสำหรับแอปพลิเคชันไคลเอนต์ CharacterมีTimerแทร็กใดที่อนุญาตให้ทำอะไรต่อไป คำสั่งที่เข้ามาจะถูกตรวจสอบกับสิ่งนี้ ดังนั้นคำถามของฉันคือเป็นที่ยอมรับหรือไม่ที่จะมีชั้นเรียนขนาดใหญ่ภายใต้ SRP และหลักการที่คล้ายกัน? มีวิธีปฏิบัติที่ดีที่สุดในการทำให้ยุ่งยากน้อยลงหรือไม่ (เช่นอาจแบ่งวิธีเป็นไฟล์แยกกัน) หรือฉันขาดอะไรบางอย่างไปและมีวิธีที่ดีมากที่จะแยกมันออกมา? ฉันรู้ว่านี่เป็นอัตนัยและต้องการความคิดเห็นจากผู้อื่น นี่คือตัวอย่าง: class Character(object): def __init__(self): self.game = None self.health = 1000 self.successful_attacks = 0 self.points = 0 self.timer = Timer() …

13 object-oriented  class-design  single-responsibility 

ฉันกำลังออกแบบโปรแกรม OOP ตัวเล็ก ๆ ของฉันเพื่อจำลอง Vampires, Wolves, Human และ Trucks และกำลังพยายามใช้ความเข้าใจที่ จำกัด ของตัวเองเกี่ยวกับการเชื่อมต่อ ( ฉันยังคงสรุปอยู่ที่นี่และยังไม่มีการติดตั้งโค้ดดังนั้นจึงเป็นคำถามของการออกแบบ OOP ... ฉันคิดว่า!) ฉันกำลังมองหา'พฤติกรรมทั่วไป'ระหว่างชั้นเรียนเหล่านี้และนำไปใช้เป็นส่วนต่อประสานหรือไม่ ตัวอย่างเช่น Vampires and Wolves กัด ... ดังนั้นฉันควรมีส่วนต่อประสานกัดหรือไม่ public class Vampire : Villain, IBite, IMove, IAttack เช่นเดียวกันสำหรับรถบรรทุก ... public class Truck : Vehicle, IMove และสำหรับมนุษย์ ... public class Man : Human, IMove, …

13 object-oriented  interfaces 

ฉันใช้ C และstructs ที่ struct สามารถมีสมาชิก แต่ไม่ใช่ฟังก์ชั่น สมมติว่าสำหรับความเรียบง่ายที่ฉันต้องการที่จะสร้าง struct สำหรับสตริงที่ฉันชื่อstrและฉันต้องการที่จะสามารถที่จะทำstr.replace(int i, char c)ที่iเป็นดัชนีของสตริงและเป็นตัวละครที่จะแทนที่ตัวอักษรที่ตำแหน่งc iสิ่งนี้จะไม่เป็นไปได้หรือไม่เนื่องจาก structs ไม่มีฟังก์ชั่นหรือยังมีวิธีที่เราสามารถใช้พฤติกรรมนี้และเลียนแบบได้ว่าโครงสร้างอาจมีฟังก์ชั่น (ง่าย) ที่จริง ๆ แล้วคือ struct คัดลอกตัวเองไปที่ struct ใหม่ เขตข้อมูลซึ่งจะทำอย่างไร ดังนั้นreplaceอาจเป็นสมาชิกที่สามของโครงสร้างที่ชี้ไปที่โครงสร้างใหม่ที่มีการปรับปรุงเมื่อมีการเข้าถึงหรือคล้ายกัน ทำได้หรือไม่ หรือมีบางอย่างในตัวหรือทฤษฎีหรือกระบวนทัศน์ที่ป้องกันความตั้งใจของฉัน พื้นหลังคือฉันกำลังเขียนรหัส C และฉันพบว่าตัวเองมีฟังก์ชั่นการฟื้นฟูที่ฉันรู้ว่าเป็นตัวสร้างไลบรารีในภาษา OOP และ OOP จะเป็นวิธีที่ดีในการจัดการสตริงและคำสั่ง

13 object-oriented  c  data-structures 

ฉันทำงานผ่านการสอนของ Ray Wenderlich และสังเกตว่าผู้เขียนใช้ส่วนขยายคลาสเพื่อระงับการโทรกลับแทนที่จะมอบหมายให้จัดการในคลาสเองเช่น: มอบหมาย callback ภายในส่วนขยายของชั้นเรียน: extension LogsViewController : UIPopoverPresentationControllerDelegate { func adaptivePresentationStyleForPresentationController(controller: UIPresentationController, traitCollection: UITraitCollection) -> UIModalPresentationStyle { ... } } ตรงข้ามกับการมีอยู่ในชั้นเรียน: มอบหมายการเรียกกลับภายในชั้นเรียน: class LogsViewController : UITableViewController, UIPopoverPresentationControllerDelegate { func adaptivePresentationStyleForPresentationController(controller: UIPresentationController, traitCollection: UITraitCollection) -> UIModalPresentationStyle { ... } } ฉันพบสิ่งนี้แปลกและน่าสนใจในเวลาเดียวกัน เขามีไฟล์เฉพาะสำหรับการขยายในคลาส LogsViewController ชื่อ "LogsViewControllerExtension.swift" และมีส่วนขยายที่แตกต่างกันสำหรับแต่ละโพรโทคอลของผู้แทน: UITableViewDataSource, UISplitViewDelegate …

13 design  object-oriented  swift-language  extension-method 

กรอบการฉีดที่พึ่งพาเช่น Google Guice ให้แรงจูงใจต่อการใช้งาน (ที่มา ): ในการสร้างวัตถุคุณต้องสร้างการขึ้นต่อกันก่อน แต่ในการสร้างการพึ่งพาแต่ละครั้งคุณจำเป็นต้องมีการพึ่งพาและอื่น ๆ ดังนั้นเมื่อคุณสร้างวัตถุคุณจำเป็นต้องสร้างกราฟวัตถุ การสร้างกราฟวัตถุด้วยมือนั้นเป็นเรื่องยากสำหรับแรงงาน (... ) และทำให้การทดสอบเป็นเรื่องยาก แต่ฉันไม่ได้ซื้ออาร์กิวเมนต์นี้: แม้จะไม่มีกรอบการฉีดพึ่งพาฉันสามารถเขียนชั้นเรียนซึ่งทั้งง่ายต่อการ instantiate และสะดวกในการทดสอบ เช่นตัวอย่างจากหน้าแรงจูงใจของ Guiceสามารถเขียนใหม่ด้วยวิธีต่อไปนี้: class BillingService { private final CreditCardProcessor processor; private final TransactionLog transactionLog; // constructor for tests, taking all collaborators as parameters BillingService(CreditCardProcessor processor, TransactionLog transactionLog) { this.processor = processor; this.transactionLog = …

13 design-patterns  object-oriented  dependency-injection  ioc-containers 

ปิด คำถามนี้เป็นคำถามความคิดเห็นตาม ไม่ยอมรับคำตอบในขณะนี้ ปิดให้บริการใน6 ปีที่ผ่านมา ล็อคแล้ว คำถามและคำตอบของคำถามนี้ถูกล็อคเนื่องจากคำถามอยู่นอกหัวข้อ แต่มีความสำคัญทางประวัติศาสตร์ ขณะนี้ไม่ยอมรับคำตอบหรือการโต้ตอบใหม่ ฉันได้รับการตั้งโปรแกรมในภาษาเชิงปฏิบัติอยู่เสมอและขณะนี้ฉันกำลังมุ่งไปสู่การวางแนวของวัตถุ ปัญหาหลักที่ฉันเผชิญคือฉันไม่เห็นวิธีฝึกการวางแนววัตถุอย่างมีประสิทธิภาพ ฉันจะอธิบายประเด็นของฉัน เมื่อฉันเรียนรู้ PHP และ C มันเป็นเรื่องง่ายที่จะฝึกฝน: มันเป็นเรื่องของการเลือกบางสิ่งบางอย่างและคิดเกี่ยวกับอัลกอริทึมสำหรับสิ่งนั้น ตัวอย่างเช่นใน PHP มันเป็นเรื่องสำคัญที่ระบบปฏิบัติการต้องนั่งลงและคิดว่า: "ดีแค่ฝึกให้ฉันสร้างแอปพลิเคชั่นเดียวด้วยเขตการปกครองซึ่งผู้คนสามารถเพิ่มผลิตภัณฑ์ได้" มันค่อนข้างง่ายมันเป็นเรื่องของการคิดถึงอัลกอริทึมในการลงทะเบียนผู้ใช้บางคนเข้าสู่ระบบผู้ใช้และเพื่อเพิ่มผลิตภัณฑ์ การรวมสิ่งเหล่านี้เข้ากับฟีเจอร์ PHP มันเป็นวิธีที่ดีในการฝึกฝน ตอนนี้ในการวางแนววัตถุเรามีสิ่งเพิ่มเติมมากมาย มันไม่ได้เป็นเพียงแค่การคิดเกี่ยวกับอัลกอริทึม แต่การวิเคราะห์ความต้องการที่ลึกกว่าการเขียนกรณีการใช้งานการหาไดอะแกรมระดับคุณสมบัติและวิธีการการตั้งค่าการฉีดพึ่งพาและหลายสิ่งหลายอย่าง ประเด็นหลักคือในวิธีที่ฉันได้เรียนรู้การวางแนววัตถุดูเหมือนว่าการออกแบบที่ดีนั้นสำคัญมากในขณะที่ภาษาที่ใช้ในขั้นตอนหนึ่งความคิดที่คลุมเครือก็เพียงพอแล้ว ฉันไม่ได้บอกว่าในภาษาเชิงปฏิบัติเราสามารถเขียนซอฟต์แวร์ที่ดีโดยไม่มีการออกแบบเพียงเพื่อประโยชน์ในการฝึกปฏิบัติมันเป็นไปได้ในขณะที่ในการวางแนววัตถุดูเหมือนว่าเป็นไปไม่ได้หากไม่มีการออกแบบที่ดี สิ่งนี้ดูเหมือนจะเป็นปัญหาเพราะถ้าทุกครั้งที่ฉันจะฝึกฉันต้องเข้าใจความต้องการจำนวนมากใช้เคสและอื่น ๆ ดูเหมือนว่าจะไม่ใช่วิธีที่ดีในการวางแนววัตถุให้ดีขึ้นเพราะสิ่งนี้ต้องการ ฉันมีความคิดทั้งหมดสำหรับแอปทุกครั้งที่ฉันจะฝึก เพราะเหตุใดจึงเป็นวิธีที่ดีในการฝึกวางแนววัตถุ

13 object-oriented  learning 

หลังจากเรียนรู้การเขียนโปรแกรมที่ใช้งานได้ใน Haskell และ F # กระบวนทัศน์ OOP ดูเหมือนว่าจะย้อนกลับไปพร้อมกับคลาสอินเทอร์เฟซวัตถุ FP ด้านใดที่ฉันสามารถนำไปใช้ในการทำงานที่เพื่อนร่วมงานของฉันสามารถเข้าใจได้ สไตล์ FP ใด ๆ ที่ควรค่าแก่การพูดคุยกับเจ้านายของฉันเกี่ยวกับการฝึกสอนทีมของฉันใหม่ ลักษณะที่เป็นไปได้ของ FP: การเปลี่ยนไม่ได้ การประยุกต์ใช้บางส่วนและการแกง ฟังก์ชั่นชั้นหนึ่ง (ตัวชี้ฟังก์ชั่น / วัตถุการทำงาน / รูปแบบกลยุทธ์) การประเมินผลขี้เกียจ (และ Monads) ฟังก์ชั่นบริสุทธิ์ (ไม่มีผลข้างเคียง) นิพจน์ (เทียบกับข้อความ - แต่ละบรรทัดของโค้ดจะสร้างค่าแทนหรือนอกเหนือจากการทำให้เกิดผลข้างเคียง) recursion การจับคู่รูปแบบ มันเป็นฟรีสำหรับทุกสิ่งที่เราสามารถทำอะไรก็ได้ที่ภาษาโปรแกรมรองรับจนถึงขีด จำกัด ที่ภาษานั้นรองรับหรือไม่ หรือมีแนวทางที่ดีกว่า

13 object-oriented  programming-practices  functional-programming  paradigms 

ฉันกำลังอ่านหนังสือชื่อ Rails AntiPatterns และพวกเขาคุยกันเรื่องการใช้การมอบหมายเพื่อหลีกเลี่ยงการทำผิดกฎของ Demeter นี่คือตัวอย่างสำคัญของพวกเขา: พวกเขาเชื่อว่าการโทรแบบนี้ในคอนโทรลเลอร์ไม่ดี (และฉันเห็นด้วย) @street = @invoice.customer.address.street ทางออกที่เสนอของพวกเขาคือทำสิ่งต่อไปนี้: class Customer has_one :address belongs_to :invoice def street address.street end end class Invoice has_one :customer def customer_street customer.street end end @street = @invoice.customer_street พวกเขากำลังระบุว่าเนื่องจากคุณใช้เพียงจุดเดียวคุณจะไม่ละเมิดกฎของ Demeter ที่นี่ ฉันคิดว่านี่ไม่ถูกต้องเพราะคุณยังคงต้องผ่านลูกค้าเพื่อผ่านที่อยู่เพื่อรับถนนใบแจ้งหนี้ ฉันได้รับแนวคิดนี้จากโพสต์บล็อกที่ฉันอ่านเป็นหลัก: http://www.dan-manges.com/blog/37 ในบล็อกโพสต์ตัวอย่างสำคัญคือ class Wallet attr_accessor :cash end class Customer has_one …

13 design  design-patterns  object-oriented  ruby-on-rails 

ปิด คำถามนี้เป็นคำถามความคิดเห็นตาม ไม่ยอมรับคำตอบในขณะนี้ ต้องการปรับปรุงคำถามนี้หรือไม่ อัปเดตคำถามเพื่อให้สามารถตอบข้อเท็จจริงและการอ้างอิงได้โดยแก้ไขโพสต์นี้ ปิดให้บริการใน6 ปีที่ผ่านมา ความเป็นมา:ฉันเป็นผู้สนับสนุนการเขียนโปรแกรมฟังก์ชั่นที่ทำงานที่ร้าน VB.NET ซึ่งรูปแบบจิตที่แพร่หลายคือการเขียนโปรแกรมที่จำเป็น การเป็นรากฐานของระบบของเราคือ WinForms ฉันสามารถเข้าใจได้ว่าเราจะไม่หนีจากการเขียนโปรแกรมที่จำเป็นทั้งหมด แต่ฉันก็ยังพยายามใช้ FP (หลัก ๆ ผ่าน Linq) ทุกที่ที่ทำได้เพราะฉันเชื่อในข้อดีของมัน อาร์กิวเมนต์ & การโต้แย้งแย้งกับ FP บางคนอาจสังเกตเห็นว่าความคล่องแคล่วของ Linq นั้นมีประสิทธิภาพน้อยกว่าคู่ที่จำเป็นในลักษณะนี้จะประมวลผลลำดับลงไปที่ลำดับอื่นและทำซ้ำนั้น โดยทั่วไปมันจะใช้เวลาอีกสองสามครั้งกว่าวิธีการที่จำเป็นซึ่งสามารถปรับให้เหมาะสมได้ดีกว่าเพื่อหลีกเลี่ยงการทำซ้ำซ้ำในลำดับ ด้วยเหตุนี้ผู้นำจึงไม่เข้าใจว่าทำไมฉันจึงเลือกวิธีการใช้งานที่ชัดเจนว่า "มีประสิทธิภาพน้อยลง" การโต้แย้ง : ฉันแย้งว่าในขณะที่บางครั้งมันมีประสิทธิภาพน้อยกว่าในแง่ของรอบการทำงานของ CPU แต่ฉันรู้สึกว่ามันเป็นสิ่งที่เข้าใจง่ายและเป็นมนุษย์มากกว่าเพราะแต่ละบรรทัดทำสิ่งเดียวที่ผ่านไปตามลำดับ สำหรับฉันนี้รู้สึกเหมือนมีสายการประกอบที่แต่ละคนที่สถานีของเขามีเพียงงานเดียวที่จะทำ ฉันรู้สึกว่าการแลกเปลี่ยนที่มีประสิทธิภาพน้อยมากได้รับการตอบแทนด้วยรหัสที่มีข้อกังวลแยกออกจากกันอย่างเรียบร้อย ข้อโต้แย้งต่อไปกับ FP ที่ฉันได้ยินในร้านค้าของฉันคือการ debug ยากขึ้นซึ่งเป็นเรื่องจริง ไม่ใช่เรื่องง่ายที่จะเหยียบรหัส Linq และบางครั้งฉันก็ต้องคลี่คลายห่วงโซ่วิธีการเพื่อติดตามและแยกแยะปัญหาที่ฉันไม่สามารถมองเห็นได้ทันที _Counter-argument: ส่วนใหญ่แม้ว่าฉันจะไม่ได้มีปัญหากับเรื่องนี้เพราะฉันคิดว่ารูปแบบการทำงานนั้นมีความชัดเจนในการอ่านและเมื่อมีข้อผิดพลาดเกิดขึ้นในห่วงโซ่การทำงานฉันมักจะเห็นปัญหาทันที คำถามของฉัน ฉันพยายามโปรโมตสไตล์การใช้งานในร้านของเราและฉันไม่รู้สึกว่ากำลังทำอะไรอยู่ ฉันทำทั้งสองรูปแบบของการเขียนโปรแกรมและเพิ่งขลุกอยู่ใน …

13 object-oriented  functional-programming  linq  imperative-programming