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

ปิด คำถามนี้เป็นคำถามความคิดเห็นตาม ไม่ยอมรับคำตอบในขณะนี้ ต้องการปรับปรุงคำถามนี้หรือไม่ อัปเดตคำถามเพื่อให้สามารถตอบข้อเท็จจริงและการอ้างอิงได้โดยแก้ไขโพสต์นี้ ปิดให้บริการใน6 ปีที่ผ่านมา ตอนนี้ฉันอยู่มหาวิทยาลัยปีที่ 4 และเมื่อฉันพูดคุยกับอาจารย์เกี่ยวกับหัวข้อนี้เขาปฏิเสธความคิดเห็นของฉันและวิจารณ์ฉันอย่างหนักมาก (ในมหาวิทยาลัยของฉันเรากำลังสอน C (ANSI) (ในขั้นตอน ชั้นเรียนการเขียนโปรแกรม - ในปีที่ 1 ที่มหาวิทยาลัย) ก่อน C ++ (ในชั้นเรียน OOP ในปีที่ 2) และอื่น ๆ ... แต่ตอนอายุ 13 พี่ชายของฉันถูกสอนโดยฉัน Java ก่อนและไม่มีอะไรอื่น ตอนนี้เขาสามารถทำเกือบทุกอย่างที่นักเรียนปกติปีที่ 2 สามารถทำกับ Java สำหรับคุณข้อดีฉันต้องการทราบว่าทำไมคุณคิดว่าเราควรจะสอนการเขียนโปรแกรมขั้นตอนก่อน

10 object-oriented  education 

ล็อคแล้ว คำถามและคำตอบของคำถามนี้ถูกล็อคเนื่องจากคำถามอยู่นอกหัวข้อ แต่มีความสำคัญทางประวัติศาสตร์ ขณะนี้ไม่ยอมรับคำตอบหรือการโต้ตอบใหม่ ฉันมักจะพยายามหลีกเลี่ยงการบอกคนอื่นว่าฉันเป็นโปรแกรมเมอร์เพราะส่วนใหญ่แล้วฉันจะอธิบายให้พวกเขาฟังว่ามันหมายถึงอะไรจริง ๆ เมื่อฉันบอกพวกเขาฉันกำลังเขียนโปรแกรมใน Java พวกเขามักถามคำถามทั่วไปเกี่ยวกับภาษาและความแตกต่างจาก x และ y ฉันไม่สามารถอธิบายสิ่งต่าง ๆ ได้ดีเพราะ 1) ฉันไม่มีประสบการณ์มากมายในสนามและ 2) ฉันเกลียดการอธิบายสิ่งต่าง ๆ กับคนที่ไม่ใช่ช่างเทคนิค พวกเขาบอกว่าคุณเข้าใจสิ่งต่าง ๆ อย่างแท้จริงเมื่อคุณอธิบายให้คนอื่นฟังในกรณีนี้คุณจะอธิบายคำศัพท์และแนวคิดของ OOP ให้คนที่ไม่ใช่ช่างเทคนิคได้อย่างไร

10 object-oriented  terminology  concepts 

หลายครั้งที่วัตถุธุรกิจของฉันมักจะมีสถานการณ์ที่ข้อมูลจำเป็นต้องข้ามขอบเขตวัตถุบ่อยเกินไป เมื่อทำ OO เราต้องการให้ข้อมูลอยู่ในวัตถุเดียวและมากที่สุดเท่าที่เป็นไปได้รหัสทั้งหมดที่เกี่ยวข้องกับข้อมูลนั้นควรอยู่ในวัตถุนั้น อย่างไรก็ตามกฎเกณฑ์ทางธุรกิจไม่ได้ปฏิบัติตามหลักการนี้ทำให้ฉันมีปัญหา ตัวอย่างเช่นสมมติว่าเรามีคำสั่งซื้อที่มีหมายเลขของ OrderItems ซึ่งอ้างถึง InventoryItem ซึ่งมีราคา ฉันเรียกใช้ Order.GetTotal () ซึ่งสรุปผลของ OrderItem.GetPrice () ที่ทวีคูณปริมาณโดย InventoryItem.GetPrice () จนถึงตอนนี้ดีมาก แต่จากนั้นเราพบว่าบางรายการมีการขายสองรายการต่อการจัดการหนึ่งรายการ เราสามารถจัดการสิ่งนี้ได้โดยให้ OrderItem.GetPrice () ทำบางอย่างเช่น InventoryItem.GetPrice (ปริมาณ) และปล่อยให้ InventoryItem จัดการกับสิ่งนี้ อย่างไรก็ตามเราพบว่าดีลแบบสองต่อหนึ่งนั้นมีระยะเวลาที่ จำกัด เท่านั้น ช่วงเวลานี้จะต้องเป็นไปตามวันที่สั่งซื้อ ตอนนี้เราเปลี่ยน OrderItem.GetPrice () เป็น InventoryItem.GetPrice (quatity, order.GetDate ()) แต่เราต้องสนับสนุนราคาที่แตกต่างกันขึ้นอยู่กับระยะเวลาที่ลูกค้าอยู่ในระบบ: InventoryItem.GetPrice (ปริมาณ, คำสั่งซื้อ GetDate (), คำสั่งซื้อ GetCustomer …

10 design  object-oriented  business-rules 

ปิด คำถามนี้ต้องการรายละเอียดหรือความคมชัด ไม่ยอมรับคำตอบในขณะนี้ ต้องการปรับปรุงคำถามนี้หรือไม่ เพิ่มรายละเอียดและชี้แจงปัญหาโดยแก้ไขโพสต์นี้ ปิดให้บริการใน6 ปีที่ผ่านมา ฉันเพิ่งเริ่มทำงานในโครงการและเรากำลังใช้การออกแบบที่ขับเคลื่อนด้วยโดเมน (ตามที่กำหนดโดย Eric Evans ในการออกแบบที่ขับเคลื่อนด้วยโดเมน: การแก้ปัญหาความซับซ้อนในหัวใจของซอฟต์แวร์ฉันเชื่อว่าโครงการของเราเป็นผู้สมัครสำหรับการออกแบบนี้ แบบที่อีแวนส์อธิบายไว้ในหนังสือของเขา ฉันกำลังดิ้นรนกับความคิดในการปรับโครงสร้างใหม่อย่างต่อเนื่อง ฉันรู้ว่าการปรับโครงสร้างเป็นสิ่งจำเป็นในโครงการใด ๆ และจะเกิดขึ้นอย่างหลีกเลี่ยงไม่ได้เมื่อมีการเปลี่ยนแปลงซอฟต์แวร์ อย่างไรก็ตามจากประสบการณ์ของฉันการเปลี่ยนโครงสร้างเกิดขึ้นเมื่อความต้องการของทีมพัฒนาเปลี่ยนไปไม่ใช่ความเข้าใจในการเปลี่ยนแปลงโดเมน ("การปรับโครงสร้างใหม่เป็นความเข้าใจที่ลึกซึ้งยิ่งขึ้น" ตามที่ Evans เรียกว่า) ฉันกังวลมากที่สุดกับความก้าวหน้าในการทำความเข้าใจโมเดลโดเมน ฉันเข้าใจว่าทำการเปลี่ยนแปลงเล็กน้อย แต่จะเกิดอะไรขึ้นถ้าจำเป็นต้องเปลี่ยนแปลงโมเดลเป็นอย่างมาก เป็นวิธีที่มีประสิทธิภาพในการโน้มน้าวตัวเอง (และอื่น ๆ ) คุณควร refactor หลังจากที่คุณได้รับรูปแบบโดเมนที่ชัดเจนคืออะไร? ท้ายที่สุดการปรับโครงสร้างองค์กรเพื่อปรับปรุงโค้ดหรือประสิทธิภาพอาจแตกต่างอย่างสิ้นเชิงจากวิธีการแสดงออกในแง่ของรหัสภาษาที่แพร่หลาย บางครั้งดูเหมือนว่าไม่มีเวลาพอที่จะสร้างใหม่ โชคดีที่ SCRUM ปล่อยให้ตนเองฟื้นฟู ลักษณะซ้ำของ SCRUM ทำให้ง่ายต่อการสร้างชิ้นเล็ก ๆ และเปลี่ยนแปลงและมัน แต่เมื่อเวลาผ่านไปชิ้นส่วนนั้นจะใหญ่ขึ้นและจะเกิดอะไรขึ้นถ้าคุณมีความก้าวหน้าหลังจากชิ้นส่วนนั้นใหญ่มากจนยากที่จะเปลี่ยน มีใครทำงานในโครงการที่ใช้การออกแบบโดยใช้โดเมนหรือไม่ ถ้าเป็นเช่นนั้นจะเป็นการดีหากได้รับข้อมูลเชิงลึกเกี่ยวกับสิ่งนี้ ฉันต้องการได้ยินเรื่องราวความสำเร็จเป็นพิเศษเนื่องจาก DDD ดูเหมือนจะยากมาก ขอบคุณ!

10 design-patterns  architecture  object-oriented  scrum  domain-driven-design 

แม้ว่ามันอาจเป็นวิธีปฏิบัติที่ไม่ดีฉันจะบอกว่ามีเวลาที่มันจะบรรลุวัตถุประสงค์

10 .net  c#  object-oriented 

โดยทั่วไปเมื่อประกาศคลาส C ++ เป็นแนวปฏิบัติที่ดีที่สุดที่จะใส่เฉพาะการประกาศในไฟล์ส่วนหัวและวางการประยุกต์ใช้ในไฟล์ต้นฉบับ อย่างไรก็ตามดูเหมือนว่ารูปแบบการออกแบบนี้จะไม่ทำงานกับคลาสเทมเพลต เมื่อดูทางออนไลน์มีความคิดเห็น 2 ข้อเกี่ยวกับวิธีที่ดีที่สุดในการจัดการคลาสเทมเพลต: 1. การประกาศทั้งหมดและการใช้งานในส่วนหัว สิ่งนี้ค่อนข้างตรงไปตรงมา แต่นำไปสู่สิ่งที่ฉันคิดว่าเป็นเรื่องยากที่จะรักษาและแก้ไขไฟล์โค้ดเมื่อเทมเพลตมีขนาดใหญ่ 2. เขียนการใช้งานในเทมเพลตรวมไฟล์ (.tpp) ที่รวมอยู่ท้าย ดูเหมือนว่าจะเป็นทางออกที่ดีกว่าสำหรับฉัน แต่ดูเหมือนจะไม่ได้ใช้อย่างกว้างขวาง มีเหตุผลที่วิธีนี้ด้อยกว่าหรือไม่? ฉันรู้ว่าหลายครั้งที่รูปแบบของรหัสถูกกำหนดโดยการตั้งค่าส่วนตัวหรือรูปแบบดั้งเดิม ฉันกำลังเริ่มโครงการใหม่ (การย้ายโครงการ C เก่าไปยัง C ++) และฉันค่อนข้างใหม่ในการออกแบบ OO และต้องการปฏิบัติตามแนวทางปฏิบัติที่ดีที่สุดตั้งแต่เริ่มต้น

10 object-oriented  c++  coding-style  templates 

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

10 object-oriented  object-oriented-design  solid 

เมื่อเร็ว ๆ นี้ฉันมีปัญหาเกี่ยวกับการใช้คลาสที่เป็นนามธรรม บางครั้งคลาสนามธรรมจะถูกสร้างขึ้นล่วงหน้าและทำงานเป็นแม่แบบของวิธีการเรียนที่ได้รับจะทำงาน ซึ่งหมายความว่ามากหรือน้อยที่พวกเขามีฟังก์ชั่นระดับสูงบางอย่าง แต่ออกรายละเอียดบางอย่างที่จะดำเนินการโดยชั้นเรียนที่ได้รับ ชั้นนามธรรมกำหนดความต้องการรายละเอียดเหล่านี้โดยการวางวิธีการบางอย่างที่เป็นนามธรรม ในกรณีเช่นนี้คลาสนามธรรมจะทำงานเหมือนกับพิมพ์เขียวคำอธิบายระดับสูงของฟังก์ชันหรือสิ่งที่คุณต้องการเรียกใช้ ไม่สามารถใช้ด้วยตนเองได้ แต่ต้องมีความเชี่ยวชาญในการกำหนดรายละเอียดที่ถูกทิ้งไว้จากการใช้งานระดับสูง บางครั้งมันเกิดขึ้นที่คลาสนามธรรมถูกสร้างขึ้นหลังจากการสร้างคลาส "ที่ได้รับ" บางส่วน (เนื่องจากคลาสแม่ / นามธรรมไม่ได้อยู่ที่นั่นพวกเขายังไม่ได้รับมา แต่คุณรู้ว่าฉันหมายถึงอะไร) ในกรณีเหล่านี้คลาสนามธรรมมักจะใช้เป็นสถานที่ที่คุณสามารถใส่รหัสทั่วไปใด ๆ ที่คลาสที่ได้รับปัจจุบันมี หลังจากทำการสังเกตข้างต้นฉันสงสัยว่าในสองกรณีนี้ควรเป็นกฎ รายละเอียดใด ๆ ที่ควรจะถูกทำให้กระฉับกระเฉงขึ้นไปสู่ชั้นนามธรรมเพียงเพราะพวกเขากำลังเกิดขึ้นเป็นเรื่องธรรมดาในทุกชั้นเรียนที่ได้รับ? ควรใช้รหัสทั่วไปที่ไม่ได้เป็นส่วนหนึ่งของฟังก์ชั่นระดับสูงหรือไม่? รหัสที่อาจไม่มีความหมายสำหรับคลาสนามธรรมควรมีเพียงเพราะมันเกิดขึ้นเป็นเรื่องธรรมดาสำหรับคลาสที่ได้รับ? ขอยกตัวอย่าง: คลาสนามธรรม A มีเมธอด a () และเมธอด abstract aq () เมธอด aq () ทั้งคลาสที่ได้รับ AB และ AC ใช้เมธอด b () ควรย้าย b () ไปที่ …

10 object-oriented  clean-code  abstract-class 

(ฉันเคยเห็นคำถามนี้แต่คำตอบแรกเป็นเรื่องเกี่ยวกับคุณสมบัติอัตโนมัติมากกว่าเกี่ยวกับการออกแบบและคำตอบที่สองบอกว่าซ่อนรหัสการจัดเก็บข้อมูลจากผู้บริโภคซึ่งฉันไม่แน่ใจว่าเป็นสิ่งที่ฉันต้องการ / รหัสของฉันทำ ดังนั้นฉันต้องการฟังความเห็นอื่น ๆ ) ฉันมีเอนทิตีที่คล้ายกันมากสองรายการHolidayDiscountและRentalDiscountนั่นคือส่วนลดที่มีความยาวเนื่องจาก 'ถ้าอย่างน้อยที่สุดจะnumberOfDaysใช้percentส่วนลดได้' ตารางมี fks ไปยังเอนทิตีพาเรนต์ที่แตกต่างกันและใช้ในสถานที่ต่าง ๆ แต่ที่ที่ใช้จะมีตรรกะทั่วไปเพื่อรับส่วนลดสูงสุดที่เกี่ยวข้อง ตัวอย่างเช่น a HolidayOfferมีจำนวนHolidayDiscountsและเมื่อคำนวณต้นทุนเราต้องหาส่วนลดที่เกี่ยวข้อง RentalDiscountsเหมือนกันสำหรับเช่าและ เนื่องจากตรรกะเหมือนกันฉันต้องการเก็บไว้ในที่เดียว นั่นคือสิ่งที่วิธีต่อไปนี้เพรดิเคตและตัวเปรียบเทียบทำ: Optional<LengthDiscount> getMaxApplicableLengthDiscount(List<LengthDiscount> discounts, int daysToStay) { if (discounts.isEmpty()) { return Optional.empty(); } return discounts.stream() .filter(new DiscountIsApplicablePredicate(daysToStay)) .max(new DiscountMinDaysComparator()); } public class DiscountIsApplicablePredicate implements Predicate<LengthDiscount> { private final long daysToStay; public DiscountIsApplicablePredicate(long …

10 java  object-oriented  object-oriented-design  code-quality 

ใน 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 = …

10 c#  object-oriented  builder-pattern 

วิธีที่แนะนำสำหรับฟังก์ชั่นผู้ช่วยคืออะไร? ฉันต้องการเลือกหนึ่งเทคนิคและดำเนินการเพื่อสร้าง "คลาส" ใหม่ของฉัน นี่คือตัวเลือกการออกแบบที่ฉันได้ครุ่นคิด: ตัวเลือกที่ 1: ฟังก์ชันผู้ช่วยในขอบเขตด้านนอกเรียกใช้ด้วยบริบทของอินสแตนซ์ function createPane (pane) { // logic to create pane var proto = Object.create(this.paneList); $.extend(paneProto, pane); return paneProto; } Panes.prototype.initialize = function (panes) { var _this = this; _.each(panes, function () { _this.panes.push(createPane.call(_this, this)); }); } จุดเด่น:ไวยากรณ์ง่าย ๆ createPaneไม่ได้เผยแพร่ในอินสแตนซ์ ข้อด้อย: createPaneสามารถเข้าถึงได้ในขอบเขตอื่น ตัวเลือก 2: …

10 object-oriented  javascript 

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

10 java  design  object-oriented  architectural-patterns 

ทำไมจะมีความได้เปรียบในการใช้วิธีการแบบสแตติกและส่งผ่านการอ้างอิงไปยังวัตถุเป็นพารามิเตอร์แทนที่จะเรียกวิธีการบนวัตถุ เพื่อชี้แจงสิ่งที่ฉันหมายถึงพิจารณาชั้นเรียนต่อไปนี้: public class SomeClass { private double someValue; public SomeClass() { // Some constructor in which someValue is set } public void incrementValue() { someValue++; } } เปรียบเทียบกับการใช้ทางเลือกนี้ด้วยวิธีการคงที่: public class SomeClass { private double someValue; public SomeClass() { // Some constructor in which someValue is set } public static …

9 java  object-oriented  static-methods 

ฉันกำลังอ่านหน้านี้เกี่ยวกับเมื่อ getters / setters เป็นธรรมและ OP ให้ตัวอย่างรหัสต่อไปนี้: class Fridge { int cheese; void set_cheese(int _cheese) { cheese = _cheese; } int get_cheese() { return cheese; } } void go_shopping(Fridge fridge) { fridge.set_cheese(fridge.get_cheese() + 5); } ยอมรับคำตอบรัฐ: โดยวิธีการในตัวอย่างของคุณ, ฉันจะให้ชั้นและวิธีการแทนและ จากนั้นคุณจะยังคงมีการห่อหุ้มFridgeputCheese()takeCheese()get_cheese()set_cheese() การห่อหุ้มนั้นถูกเก็บรักษาไว้อย่างไรโดยการเปลี่ยนชื่อจากรับ / ตั้งค่าเป็นputCheese()/ takeCheese()คุณเห็นได้ชัดว่าได้รับ / ตั้งค่าดังนั้นทำไมไม่ปล่อยไว้เป็นรับ / ตั้งค่า? ในคำตอบเดียวกันมันยังระบุ: มี getters …

9 object-oriented  class-design  encapsulation  setters  getters 

ฉันสามารถเห็นประโยชน์ของวัตถุที่เปลี่ยนแปลงไม่ได้กับวัตถุที่เปลี่ยนแปลงไม่ได้เช่นวัตถุที่ไม่เปลี่ยนรูปทำให้ยากต่อการแก้ไขปัญหาในการเขียนโปรแกรมแบบมัลติเธรดเนื่องจากสถานะที่ใช้ร่วมกันและเขียนได้ ในทางตรงกันข้ามวัตถุที่ไม่แน่นอนช่วยในการจัดการกับตัวตนของวัตถุมากกว่าการสร้างสำเนาใหม่ทุกครั้งและยังปรับปรุงประสิทธิภาพและการใช้หน่วยความจำโดยเฉพาะอย่างยิ่งสำหรับวัตถุขนาดใหญ่ สิ่งหนึ่งที่ฉันพยายามเข้าใจคือสิ่งที่ผิดพลาดในการมีวัตถุที่ไม่แน่นอนในบริบทของการเขียนโปรแกรมการทำงาน อย่างหนึ่งในจุดที่บอกกับฉันคือผลลัพธ์ของการเรียกฟังก์ชั่นในลำดับที่แตกต่างกันนั้นไม่ได้กำหนดขึ้น ฉันกำลังมองหาตัวอย่างที่เป็นรูปธรรมที่ชัดเจนว่าอะไรผิดพลาดได้โดยใช้วัตถุที่ไม่แน่นอนในการเขียนโปรแกรมฟังก์ชั่น โดยทั่วไปถ้ามันไม่ดีก็ไม่ดีโดยไม่คำนึงถึง OO หรือกระบวนทัศน์การเขียนโปรแกรมการทำงานใช่ไหม ฉันเชื่อว่าข้อความของฉันตอบคำถามนี้เอง แต่ฉันก็ยังต้องการตัวอย่างเพื่อที่ฉันจะได้รู้สึกเป็นธรรมชาติมากขึ้น OO ช่วยในการจัดการการพึ่งพาและเขียนโปรแกรมที่ง่ายขึ้นและบำรุงรักษาด้วยความช่วยเหลือของเครื่องมือเช่น encapsulation, polymorphism เป็นต้น ฟังก์ชั่นการเขียนโปรแกรมยังมีแรงจูงใจเดียวกันในการส่งเสริมรหัสที่สามารถบำรุงรักษาได้ แต่โดยการใช้สไตล์ซึ่งไม่จำเป็นต้องใช้เครื่องมือและเทคนิค OO - หนึ่งในสิ่งที่ฉันเชื่อคือการลดผลข้างเคียงฟังก์ชั่นบริสุทธิ์ ฯลฯ

9 c#  object-oriented  programming-practices  functional-programming  immutability