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

ในตัวอย่างโค้ดต่อไปนี้เรามีคลาสสำหรับวัตถุที่ไม่เปลี่ยนรูปซึ่งแสดงถึงห้อง ทิศเหนือทิศใต้ทิศตะวันออกและทิศตะวันตกเป็นตัวแทนออกไปสู่ห้องอื่น public sealed class Room { public Room(string name, Room northExit, Room southExit, Room eastExit, Room westExit) { this.Name = name; this.North = northExit; this.South = southExit; this.East = eastExit; this.West = westExit; } public string Name { get; } public Room North { get; } public Room South …

24 c#  functional-programming  immutability  circular-dependency 

ปิด. คำถามนี้เป็นคำถามปิดหัวข้อ ไม่ยอมรับคำตอบในขณะนี้ ต้องการปรับปรุงคำถามนี้หรือไม่ อัพเดตคำถามเพื่อให้เป็นหัวข้อสำหรับ Software Engineering Stack Exchange ปิดให้บริการใน3 ปีที่ผ่านมา กรอบ Redux สนับสนุนกระบวนทัศน์ของฟังก์ชันบริสุทธิ์ / ไม่เปลี่ยนรูปแบบซึ่งส่งเสริมการสร้างสถานะใหม่จากสถานะก่อนหน้าในแง่ของการกระทำในปัจจุบัน การบังคับใช้กระบวนทัศน์นี้ไม่อาจปฏิเสธได้ ข้อกังวลหลักของฉันคือเนื่องจาก Redux reducers ส่งคืนสถานะใหม่ที่สดใหม่จากสถานะก่อนหน้าสำหรับการกระทำทุกครั้งที่เรียกใช้หน่วยความจำขนาดใหญ่ที่ระบายออก (เพื่อไม่ให้สับสนกับการรั่วไหลของหน่วยความจำ) จะกลายเป็นเรื่องธรรมดา . เมื่อพิจารณาว่าแอปพลิเคชัน Javascript ทำงานตามปกติในเบราว์เซอร์ในอุปกรณ์ของผู้ใช้โดยเฉลี่ยซึ่งอาจใช้งานแอพพลิเคชั่นเฉพาะอุปกรณ์อื่น ๆ รวมถึงแท็บและหน้าต่างเบราว์เซอร์อื่น ๆ อีกมากมายความจำเป็นในการอนุรักษ์หน่วยความจำ มีใครเปรียบเทียบการใช้หน่วยความจำของแอพพลิเคชัน Redux กับสถาปัตยกรรม Flux แบบดั้งเดิมบ้างไหม ถ้าเป็นเช่นนั้นพวกเขาสามารถแบ่งปันสิ่งที่ค้นพบของพวกเขา?

23 memory  immutability  memory-usage  reactjs 

ฉันชอบ "รูปแบบ" ที่ไม่เปลี่ยนแปลงเนื่องจากจุดแข็งของมันและในอดีตฉันพบว่ามันมีประโยชน์ต่อระบบการออกแบบที่มีชนิดข้อมูลที่ไม่เปลี่ยนรูปแบบ (บางส่วนหรือเกือบทั้งหมด) บ่อยครั้งที่ฉันทำเช่นนั้นฉันพบว่าตัวเองเขียนบั๊กน้อยลงและการดีบักง่ายขึ้นมาก อย่างไรก็ตามเพื่อนของฉันโดยทั่วไปอายห่างจากไม่เปลี่ยนรูป พวกเขาไม่ได้ไม่มีประสบการณ์เลย (ห่างไกลจากมัน) แต่พวกเขาก็เขียนวัตถุข้อมูลแบบคลาสสิก - สมาชิกส่วนตัวที่มีทะเยอทะยานและเป็นตัวตั้งค่าสำหรับสมาชิกทุกคน จากนั้นโดยปกติ Constructor ของพวกเขาจะไม่มีการโต้แย้งหรืออาจจะเป็นเพียงการโต้แย้งเพื่อความสะดวก บ่อยครั้งที่การสร้างวัตถุมีลักษณะดังนี้: Foo a = new Foo(); a.setProperty1("asdf"); a.setProperty2("bcde"); บางทีพวกเขาทำอย่างนั้นทุกที่ บางทีพวกเขาอาจไม่ได้กำหนดนวกรรมิกที่ใช้ทั้งสองสายไม่ว่าพวกเขาจะสำคัญแค่ไหน และบางทีพวกเขาอาจไม่เปลี่ยนค่าของสตริงเหล่านั้นในภายหลังและไม่จำเป็นต้องทำ เห็นได้ชัดว่าถ้าสิ่งเหล่านั้นเป็นจริงวัตถุจะได้รับการออกแบบที่ดีขึ้นไม่เปลี่ยนรูปใช่มั้ย (ตัวสร้างใช้คุณสมบัติทั้งสองไม่มีตัวตั้งค่าเลย) คุณจะตัดสินใจได้อย่างไรว่าประเภทวัตถุควรได้รับการออกแบบให้ไม่เปลี่ยนรูป? มีเกณฑ์ที่ดีในการตัดสินด้วยหรือไม่ ขณะนี้ฉันกำลังถกเถียงกันว่าจะเปลี่ยนประเภทข้อมูลบางอย่างในโครงการของฉันเป็นแบบไม่เปลี่ยนรูปแบบหรือไม่ แต่ฉันจะต้องพิสูจน์ให้เพื่อนของฉันดูและข้อมูลในประเภทนั้นอาจเปลี่ยนแปลงได้ มันเป็นวิธีที่ไม่เปลี่ยนรูปแบบ (สร้างขึ้นใหม่คัดลอกคุณสมบัติจากวัตถุเก่ายกเว้นวิธีที่คุณต้องการเปลี่ยน) แต่ฉันไม่แน่ใจว่านี่เป็นเพียงความรักของฉันที่ไม่สามารถแสดงผ่านได้หรือถ้ามีความต้องการที่แท้จริงสำหรับ / ประโยชน์จากพวกเขา

23 design  immutability 

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

18 immutability  domain-driven-design 

มาจากพื้นหลัง OOP (Java) ฉันกำลังเรียน Scala ด้วยตัวเอง ในขณะที่ฉันสามารถเห็นข้อดีของการใช้วัตถุที่ไม่เปลี่ยนรูปแบบรายบุคคล แต่ฉันมีเวลายากที่จะเห็นว่าใครสามารถออกแบบแอปพลิเคชันทั้งหมดเช่นนั้นได้ ฉันจะให้ตัวอย่าง: ว่าฉันมีวัตถุที่แสดงถึง "วัสดุ" และคุณสมบัติของพวกเขา (ฉันกำลังออกแบบเกมดังนั้นจริง ๆ แล้วฉันมีปัญหานั้น) เช่นน้ำและน้ำแข็ง ฉันจะมี "ผู้จัดการ" ที่เป็นเจ้าของอินสแตนซ์ของวัสดุดังกล่าวทั้งหมด หนึ่งคุณสมบัติจะเป็นจุดเยือกแข็งและจุดหลอมเหลวและสิ่งที่วัสดุค้างหรือละลาย [แก้ไข] ทุกกรณีวัสดุคือ "ซิงเกิลตัน" เช่นเดียวกับ Java Enum ฉันต้องการให้ "น้ำ" บอกว่าค้างเป็น "น้ำแข็ง" ที่ 0C และ "น้ำแข็ง" เพื่อบอกว่ามันละลายเป็น "น้ำ" ที่ 1C แต่ถ้าน้ำและน้ำแข็งไม่เปลี่ยนรูปพวกเขาไม่สามารถรับค่าอ้างอิงซึ่งกันและกันเป็นพารามิเตอร์ตัวสร้างได้เนื่องจากจะต้องสร้างอย่างใดอย่างหนึ่งก่อนและไม่สามารถรับการอ้างอิงถึงพารามิเตอร์อื่น ๆ ที่ยังไม่ได้มีอยู่เป็นพารามิเตอร์ตัวสร้างได้ ฉันสามารถแก้ปัญหานี้ได้โดยให้ทั้งคู่อ้างอิงถึงผู้จัดการเพื่อให้พวกเขาสามารถสอบถามเพื่อค้นหาอินสแตนซ์วัสดุอื่น ๆ ที่พวกเขาต้องการทุกครั้งที่พวกเขาถูกถามถึงคุณสมบัติการแช่แข็ง / การหลอมเหลวของพวกเขา แต่แล้วฉันก็พบปัญหาเดียวกันระหว่างผู้จัดการ และวัสดุที่พวกเขาต้องการการอ้างอิงถึงแต่ละอื่น ๆ แต่มันสามารถให้ไว้ในตัวสร้างสำหรับหนึ่งในพวกเขาดังนั้นผู้จัดการหรือวัสดุที่ไม่สามารถเปลี่ยนไม่ได้ …

17 design-patterns  immutability 

เมื่อออกแบบคลาสเพื่อเก็บโมเดลข้อมูลของคุณฉันได้อ่านแล้วมันมีประโยชน์ในการสร้างออบเจ็กต์ที่ไม่เปลี่ยนรูป แต่ภาระหน้าที่ของรายการพารามิเตอร์คอนสตรัคเตอร์และสำเนาลึกกลายเป็นมากเกินไปและคุณต้องละทิ้งข้อ จำกัด ที่ไม่เปลี่ยน ตัวอย่างเช่นนี่คือคลาสที่ไม่เปลี่ยนรูปเพื่อแสดงสิ่งที่มีชื่อ (ฉันใช้ไวยากรณ์ C # แต่หลักการใช้กับภาษา OO ทั้งหมด) class NamedThing { private string _name; public NamedThing(string name) { _name = name; } public NamedThing(NamedThing other) { this._name = other._name; } public string Name { get { return _name; } } } สิ่งที่สร้างชื่อสามารถสร้างสอบถามและคัดลอกไปยังสิ่งที่ตั้งชื่อใหม่ แต่ไม่สามารถเปลี่ยนชื่อได้ ทั้งหมดนี้เป็นสิ่งที่ดี แต่จะเกิดอะไรขึ้นเมื่อฉันต้องการเพิ่มคุณสมบัติอื่น ฉันต้องเพิ่มพารามิเตอร์ให้กับตัวสร้างและอัปเดตตัวสร้างสำเนา ซึ่งไม่ทำงานมากเกินไป …

16 class-design  immutability 

เมื่อเร็ว ๆ นี้ฉันได้พบว่าวัตถุที่เปลี่ยนไม่ได้มีประโยชน์อย่างไรและเช่นถ้าคุณส่งองค์ประกอบไปยังตัวสร้างและคลาสของคุณควรจะไม่เปลี่ยนรูปคุณต้องคัดลอกองค์ประกอบเหล่านี้หากพวกเขาไม่เปลี่ยนรูปตัวเอง สิ่งนี้ต้องการการตรวจสอบหรือความรู้มากมายเกี่ยวกับโครงการของฉันเพราะถ้าฉันมี public A(B foo) และBไม่ได้เปลี่ยนรูปฉันต้องคัดลอกA Bตอนนี้จินตนาการBดูเหมือนไม่เปลี่ยนรูป แต่ตัวเองมีคลาสที่ไม่แน่นอนในตัวสร้างและอื่น ๆ มีมาตรฐานหรือแนวปฏิบัติที่ดีที่สุดสำหรับการจัดทำเอกสารหรือไม่หากคลาสไม่เปลี่ยนรูปแบบใน Java? ดูเหมือนว่าไม่มี@immutableคำหลักใน Javadoc คำอธิบายประกอบ @Immutableดูเหมือนว่าจะมีบางสิ่งบางอย่างที่แตกต่างกันโดยสิ้นเชิงในการผลิตระดับอัตโนมัติและไม่ได้เป็นส่วนหนึ่งของมาตรฐาน Java

14 java  documentation  immutability 

แรงบันดาลใจจากคำถามจาก SO: /programming/6623391/how-to-gain-control-of-a-5gb-heap-in-haskell มันอาจเป็นการถกเถียงกันมานานเกี่ยวกับข้อดีและข้อเสียของ FP มากมาย แต่สำหรับตอนนี้ฉันต้องการ จำกัด ขอบเขตของ FP ที่มีประสิทธิภาพหลักสำหรับฮาร์ดแวร์ที่ทันสมัย วิทยานิพนธ์: กระบวนทัศน์การใช้งานหมายถึงความไม่สามารถเปลี่ยนแปลงได้และไร้สัญชาติ (?) แต่ฮาร์ดแวร์ที่เราเรียกใช้โปรแกรมการทำงานนั้นเป็นสถานะออโตมาต้าอัน จำกัด การแปลโปรแกรม 'ฟังก์ชั่นที่ใช้งานได้จริง' เป็น 'การแสดงสถานะฮาร์ดแวร์' ทำให้การควบคุมเพียงเล็กน้อยสำหรับโปรแกรมเมอร์ทำให้โอเวอร์เฮด (?) และ จำกัด การใช้ความสามารถของฮาร์ดแวร์ ฉันถูกหรือผิดในข้อความที่ถาม? มันสามารถพิสูจน์ได้ว่า FP ทำ / ไม่ได้บอกถึงการลงโทษด้านประสิทธิภาพที่สำคัญของสถาปัตยกรรมคอมพิวเตอร์ที่มีวัตถุประสงค์ทั่วไปที่ทันสมัยหรือไม่? แก้ไข: ตามที่ฉันได้กล่าวแล้วในการตอบสนองต่อความคิดเห็นบางคำถามไม่ได้เกี่ยวกับประสิทธิภาพการใช้งานและรายละเอียด มันเกี่ยวกับการมีอยู่หรือไม่มีค่าโสหุ้ยหลักที่ใช้ FP กับออโตมาตะแบบ stateful อาจนำมาซึ่ง

14 performance  functional-programming  hardware  immutability  state 

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

13 language-design  scala  list  immutability 

ฉันยังใหม่ต่อการเขียนโปรแกรมเชิงวัตถุและแนวคิดหนึ่งที่ทำให้ฉันเข้าใจไม่ได้ ฉันคิดว่าหลอดไฟดับไปเมื่อคืน แต่ฉันต้องการยืนยัน: เมื่อฉันเจอข้อความที่ไม่สามารถเปลี่ยนวัตถุที่ไม่เปลี่ยนรูปได้ฉันก็สับสนเพราะฉันสามารถทำสิ่งต่อไปนี้: NSString *myName = @"Bob"; myName = @"Mike"; ที่นั่นฉันเพิ่งเปลี่ยน myName ประเภท NSString ที่ไม่เปลี่ยนรูป ปัญหาของฉันคือคำว่า "วัตถุ" สามารถอ้างถึงวัตถุทางกายภาพในหน่วยความจำหรือนามธรรม "myName" คำจำกัดความเดิมใช้กับแนวคิดของการเปลี่ยนแปลงไม่ได้ สำหรับตัวแปรนั้นนิยามของ immutability ที่ชัดเจน (สำหรับฉัน) คือค่าของวัตถุที่ไม่เปลี่ยนรูปสามารถเปลี่ยนได้โดยเปลี่ยนตำแหน่งในหน่วยความจำเช่นการอ้างอิง ถูกต้องหรือไม่ฉันยังหลงทางอยู่ในป่า?

13 object-oriented  objective-c  immutability 

ฉันจะสร้างระบบที่มีสิ่งต่อไปนี้ทั้งหมดได้อย่างไร : การใช้ฟังก์ชั่นบริสุทธิ์กับวัตถุที่ไม่เปลี่ยนรูป ส่งผ่านไปยังข้อมูลฟังก์ชันที่ฟังก์ชันต้องการเท่านั้นไม่เกิน (เช่นไม่มีวัตถุสถานะแอปพลิเคชันขนาดใหญ่) หลีกเลี่ยงการขัดแย้งกับฟังก์ชันมากเกินไป หลีกเลี่ยงการสร้างวัตถุใหม่เพียงเพื่อจุดประสงค์ในการบรรจุและเอาพารามิเตอร์ออกจากฟังก์ชั่นเพื่อหลีกเลี่ยงการส่งพารามิเตอร์ไปยังฟังก์ชันมากเกินไป ถ้าฉันจะแพ็คหลายรายการไปยังฟังก์ชันเป็นวัตถุเดียวฉันต้องการให้วัตถุนั้นเป็นเจ้าของข้อมูลนั้นไม่ใช่สิ่งที่สร้างขึ้นชั่วคราว สำหรับฉันแล้วดูเหมือนว่ารัฐ monad ทำผิดกฎข้อที่ 2 ถึงแม้ว่ามันจะไม่ชัดเจนเพราะมันถูกสานต่อผ่าน monad ฉันรู้สึกว่าฉันจำเป็นต้องใช้เลนส์อย่างใด แต่มีน้อยมากที่เขียนเกี่ยวกับมันสำหรับภาษาที่ไม่สามารถใช้งานได้ พื้นหลัง ในการออกกำลังกายฉันกำลังแปลงแอปพลิเคชันที่มีอยู่ของฉันจากสไตล์เชิงวัตถุเป็นสไตล์การทำงาน สิ่งแรกที่ฉันพยายามทำคือการสร้างแกนในของแอปพลิเคชันให้ได้มากที่สุด สิ่งหนึ่งที่ฉันได้ยินคือวิธีการจัดการ "รัฐ" ในภาษาที่ใช้งานได้อย่างหมดจดและนี่คือสิ่งที่ฉันเชื่อว่าทำโดย Monads ของรัฐนั่นคือเหตุผลที่คุณเรียกฟังก์ชันบริสุทธิ์ว่า "ผ่านสถานะของ โลกตามที่มันเป็น "จากนั้นเมื่อฟังก์ชั่นกลับมาก็จะกลับสู่สถานะของโลกตามที่มีการเปลี่ยนแปลง เพื่อแสดงให้เห็นว่าวิธีการที่คุณสามารถทำ "สวัสดีโลก" ในลักษณะการทำงานล้วนเป็นเหมือนคุณผ่านโปรแกรมของคุณที่สถานะของหน้าจอและรับกลับสถานะของหน้าจอด้วยการพิมพ์ "สวัสดีโลก" ดังนั้นในทางเทคนิคคุณกำลังโทรไปยังฟังก์ชั่นที่บริสุทธิ์และไม่มีผลข้างเคียง จากนั้นฉันก็ผ่านแอปพลิเคชันของฉันและ: 1. ขั้นแรกให้สถานะแอปพลิเคชันทั้งหมดของฉันเป็นวัตถุระดับโลกเดียว (GameState) 2. ประการที่สองฉันทำให้ GameState ไม่เปลี่ยนรูป คุณไม่สามารถเปลี่ยนได้ หากคุณต้องการการเปลี่ยนแปลงคุณต้องสร้างสิ่งใหม่ ฉันทำสิ่งนี้โดยการเพิ่มตัวคัดลอกตัวเลือกที่จะเลือกหนึ่งหรือมากกว่าหนึ่งช่องที่มีการเปลี่ยนแปลง 3. สำหรับแต่ละแอปพลิเคชันฉันส่งผ่าน GameState เป็นพารามิเตอร์ ภายในฟังก์ชั่นหลังจากที่ทำสิ่งที่มันจะทำมันจะสร้าง GameState ใหม่และส่งคืน …

12 c#  functional-programming  immutability  state  monad 

ฉันกำลังฝึกใช้วัตถุที่ไม่เปลี่ยนรูปใน C ++ เป้าหมายส่วนตัวของฉันแสดงกราฟวัตถุทั่วไป (เป็นกอง) กับลำดับของกราฟที่ไม่เปลี่ยนรูป การสร้างกราฟหลายรุ่นนั้นไม่ได้ยากขนาดนั้น ปัญหาคือประสิทธิภาพ การกำหนดเวอร์ชันแบบเดรัจฉานต้องการสำเนากราฟเต็มรูปแบบและไม่สามารถยอมรับได้ ฉันพยายามแชร์โหนดที่ไม่เปลี่ยนแปลง แต่ในกรณีนี้ฉันมีปัญหาใหม่ การอ้างอิง การอ้างอิงถึงวัตถุอื่นต้องได้รับการอัปเดตทั้งกราฟ สิ่งนี้ต้องการการเยี่ยมชมโหนดทั้งหมดทุกครั้งที่ได้รับกราฟรุ่นใหม่ และสิ่งนี้กลายพันธุ์โหนดที่มีการอ้างอิงดังนั้นจึงควรได้รับมา (โดยการคัดลอก) ประสิทธิภาพจะไม่ดีไปกว่าการทำสำเนาที่ดุร้าย เท่าที่ฉันสามารถจินตนาการได้ไม่มีวิธีที่มีประสิทธิภาพจริง ๆ เพื่อเป็นตัวแทนของการกลายพันธุ์ของกราฟวัตถุกับรัฐที่ไม่เปลี่ยนรูป ดังนั้นฉันขอความคิดเกี่ยวกับเรื่องนี้ เป็นไปได้หรือไม่ที่จะแสดงการกลายพันธุ์ของกราฟวัตถุอย่างมีประสิทธิภาพด้วยสถานะไม่เปลี่ยนรูป?

12 graph  immutability 

เมื่อเร็ว ๆ นี้มีการปฏิวัติต่อต้านซิงเกิลบ้าง แต่มีอะไรผิดปกติกับพวกเขาไหมถ้าพวกเขาไร้สัญชาติ? ฉันรู้ว่าการพูดคุยที่มากเกินไปและทั้งหมด ... สิ่งนี้ใช้ได้กับทุกสิ่งที่ไม่ใช่แค่ซิงเกิลตัน

12 design-patterns  object-oriented  singleton  immutability 

ฉันพยายามที่จะเข้าใจการจัดการกับข้อมูลที่ไม่เปลี่ยนรูปแบบใน FP (โดยเฉพาะใน F # แต่ FP อื่น ๆ ก็โอเคเช่นกัน) และทำลายนิสัยเดิมของการคิดแบบเต็มรัฐ (OOP) ส่วนหนึ่งของคำตอบที่เลือกสำหรับคำถามที่นี่ย้ำการค้นหาของฉันสำหรับการแก้ไขปัญหาที่แก้ไขโดยการเป็นตัวแทนใน OOP กับสิ่งที่ไม่เปลี่ยนรูปใน FP (ตัวอย่างเช่น: คิวกับ Producers & Consumer) ความคิดหรือลิงค์ยินดีต้อนรับ? ขอบคุณล่วงหน้า. แก้ไข : หากต้องการเพิ่มความกระจ่างของคำถามอีกเล็กน้อยโครงสร้างที่ไม่เปลี่ยนรูปแบบ (เช่นคิว) จะถูกแชร์กันในหลาย ๆ เธรดพร้อมกัน (เช่นผู้ผลิตและผู้บริโภค) ใน FP ได้อย่างไร

12 f#  functional-programming  immutability 

ฉันเห็นตัวเองโดยใช้ประเภทมากขึ้นและเปลี่ยนรูปมากขึ้นเมื่อกรณีของชั้นไม่ได้คาดว่าจะมีการเปลี่ยนแปลง ต้องใช้งานมากขึ้น (ดูตัวอย่างด้านล่าง) แต่ทำให้การใช้ประเภทในสภาพแวดล้อมแบบมัลติเธรดง่ายขึ้น ในเวลาเดียวกันฉันไม่ค่อยเห็นประเภทที่ไม่เปลี่ยนรูปในแอปพลิเคชั่นอื่น ๆ แม้ว่าความไม่แน่นอนจะไม่เกิดประโยชน์ก็ตาม คำถาม:ทำไมประเภทที่ไม่เปลี่ยนรูปแบบจึงไม่ค่อยถูกใช้ในแอปพลิเคชันอื่น เป็นเพราะมันนานกว่าที่จะเขียนโค้ดสำหรับประเภทที่ไม่เปลี่ยนรูป หรือฉันกำลังพลาดบางสิ่งบางอย่างและมีข้อบกพร่องที่สำคัญเมื่อใช้ประเภทที่ไม่เปลี่ยนรูปแบบ? ตัวอย่างจากชีวิตจริง สมมติว่าคุณได้รับWeatherRESTful API เช่นนั้น: public Weather FindWeather(string city) { // TODO: Load the JSON response from the RESTful API and translate it into an instance // of the Weather class. } สิ่งที่เราจะเห็นโดยทั่วไปคือ (บรรทัดใหม่และความคิดเห็นถูกลบออกเพื่อย่อรหัส): public sealed class Weather { public City …

12 c#  immutability