การส่งวัตถุเป็นวิธีที่เปลี่ยนวัตถุมันเป็นรูปแบบทั่วไป (ต่อต้าน -) หรือไม่?

ฉันอ่านเกี่ยวกับรหัสที่พบบ่อยมีกลิ่นในหนังสือ Refactoring Martin Fowler ของ ในบริบทนั้นฉันสงสัยเกี่ยวกับรูปแบบที่ฉันเห็นในฐานรหัสและไม่มีใครสามารถคิดว่ามันเป็นรูปแบบการต่อต้าน

รูปแบบเป็นสิ่งหนึ่งที่วัตถุถูกส่งผ่านเป็นอาร์กิวเมนต์หนึ่งหรือหลายวิธีซึ่งทั้งหมดนี้เปลี่ยนสถานะของวัตถุ แต่ไม่มีใครกลับวัตถุ ดังนั้นจึงขึ้นอยู่กับการส่งผ่านโดยอ้างอิงธรรมชาติของ (ในกรณีนี้) C # /. NET

var something = new Thing();
// ...
Foo(something);
int result = Bar(something, 42);
Baz(something);

ฉันพบว่า (โดยเฉพาะอย่างยิ่งเมื่อวิธีการไม่ได้ตั้งชื่ออย่างเหมาะสม) ฉันต้องมองหาวิธีการดังกล่าวเพื่อทำความเข้าใจว่าสถานะของวัตถุมีการเปลี่ยนแปลง มันทำให้เข้าใจรหัสมากขึ้นเนื่องจากฉันต้องการติดตาม call-stack หลายระดับ

ฉันต้องการเสนอให้ปรับปรุงโค้ดดังกล่าวเพื่อส่งคืนออบเจ็กต์อื่น (โคลน) ด้วยสถานะใหม่หรืออะไรก็ตามที่จำเป็นในการเปลี่ยนออบเจ็กต์ที่ไซต์การโทร

var something1 =  new Thing();
// ...

// Let's return a new instance of Thing
var something2 = Foo(something1);

// Let's use out param to 'return' other info about the operation
int result;
var something3 = Bar(something2, out result);

// If necessary, let's capture and make explicit complex changes
var changes = Baz(something3)
something3.Apply(changes);

สำหรับฉันดูเหมือนว่ารูปแบบแรกจะถูกเลือกบนสมมติฐาน

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

ฉันแสดงให้เห็นทางเลือกอื่น แต่เพื่อที่จะนำเสนอมันต้องมีการโต้แย้งกับวิธีแก้ปัญหาดั้งเดิม หากมีข้อโต้แย้งใด ๆ ที่สามารถสร้างขึ้นมาเพื่อทำให้กรณีที่โซลูชันดั้งเดิมเป็นรูปแบบการต่อต้าน

และหากมีอะไรผิดปกติกับทางเลือกอื่นของฉัน

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

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

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

เมื่อวิธีการไม่ได้ตั้งชื่ออย่างเหมาะสม

จริงๆแล้วนั่นคือกลิ่นรหัสจริง หากคุณมีวัตถุที่ไม่แน่นอนมันให้วิธีการเปลี่ยนสถานะของมัน หากคุณมีการเรียกใช้วิธีการดังกล่าวที่ฝังอยู่ในงานของคำสั่งเพิ่มเติมบางอย่างก็เป็นเรื่องดีที่จะ refactor งานนั้นไปยังวิธีการของตัวเอง - ซึ่งทำให้คุณตรงกับสถานการณ์ที่อธิบายไว้ แต่ถ้าคุณไม่มีชื่อเมธอดเช่นFooและBarแต่วิธีการที่ชัดเจนว่าพวกเขาเปลี่ยนวัตถุฉันไม่เห็นปัญหาที่นี่ คิดถึง

void AddMessageToLog(Logger logger, string msg)
{
    //...
}

หรือ

void StripInvalidCharsFromName(Person p)
{
// ...
}

หรือ

void AddValueToRepo(Repository repo,int val)
{
// ...
}

หรือ

void TransferMoneyBetweenAccounts(Account source, Account destination, decimal amount)
{
// ...
}

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

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

ใช่ดูhttp://codebetter.com/matthewpodwysocki/2008/04/30/side-effecting-functions-are-code-smells/สำหรับตัวอย่างหนึ่งในหลาย ๆ คนที่ชี้ให้เห็นว่าผลข้างเคียงที่ไม่คาดคิดไม่ดี

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

ก่อนอื่นสิ่งนี้ไม่ได้ขึ้นอยู่กับ "การส่งต่อโดยอ้างอิงธรรมชาติของ" มันขึ้นอยู่กับวัตถุที่เป็นประเภทอ้างอิงที่ไม่แน่นอน ในภาษาที่ไม่สามารถใช้งานได้นั้นมักจะเป็นอย่างนั้น

ประการที่สองไม่ว่าจะเป็นปัญหาหรือไม่นั้นขึ้นอยู่กับทั้งวัตถุและความสัมพันธ์ของการเปลี่ยนแปลงในโพรซีเดอร์ที่ต่างกันอย่างแน่นหนา - ถ้าคุณล้มเหลวในการเปลี่ยนแปลงใน Foo และนั่นทำให้ Bar ล้มเหลวนั่นเป็นปัญหา ไม่จำเป็นต้องมีกลิ่นรหัส แต่เป็นปัญหากับ Foo หรือ Bar หรือ Something (อาจเป็น Bar เพราะควรตรวจสอบอินพุตของมัน แต่อาจเป็นบางสิ่งที่ทำให้สถานะไม่ถูกต้องซึ่งควรป้องกัน)

ฉันจะไม่พูดว่ามันเพิ่มขึ้นถึงระดับของรูปแบบการต่อต้าน แต่เป็นสิ่งที่ควรระวัง

ฉันเถียงมีความแตกต่างเล็ก ๆ น้อย ๆ ระหว่างA.Do(Something)การปรับเปลี่ยนsomethingและการปรับเปลี่ยนsomething.Do() ไม่ว่าsomethingในกรณีใดมันก็ควรจะชัดเจนจากชื่อของวิธีการเรียกใช้ที่somethingจะถูกแก้ไข หากไม่ชัดเจนจากชื่อวิธีการไม่ว่าsomethingจะเป็นพารามิเตอร์thisหรือส่วนหนึ่งของสภาพแวดล้อมก็ไม่ควรแก้ไข

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

var users = Dependency.Resolve<IGetUsersQuery>().GetAll();

var excludeAdminUsersFilter = new ExcludeAdminUsersFilter();
var filterByAnotherCriteria = new AnotherCriteriaFilter();

excludeAdminUsersFilter.Apply(users);
filterByAnotherCriteria.Apply(users); 

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

var users = Dependency.Resolve<IGetUsersQuery>().GetAll();
Filter(users);

ที่Filter(users)จะดำเนินการตัวกรองดังกล่าวข้างต้น

ฉันจำไม่ได้ว่าเคยเจอสิ่งนี้มาก่อน แต่ฉันคิดว่ามันเรียกว่าการกรองไปป์ไลน์

ฉันไม่แน่ใจว่าโซลูชันใหม่ที่เสนอ (ของการคัดลอกวัตถุ) เป็นรูปแบบหรือไม่ ปัญหาดังที่คุณได้ชี้ให้เห็นคือการตั้งชื่อฟังก์ชั่นไม่ดี

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

เกี่ยวกับวิธีการแก้ปัญหาของคุณข้อสังเกตบางประการ:

• แอปพลิเคชันได้รับการออกแบบมาจากแง่มุมต่าง ๆ : เมื่อวัตถุถูกใช้เพียงเพื่อเก็บค่าหรือส่งผ่านข้ามขอบเขตขององค์ประกอบก็ควรเปลี่ยนอุปกรณ์ภายในของวัตถุภายนอกแทนที่จะเติมด้วยรายละเอียดของวิธีการเปลี่ยนแปลง
• วัตถุโคลนนำไปสู่การท้องอืดต้องการหน่วยความจำและในหลายกรณีที่นำไปสู่การดำรงอยู่ของวัตถุเทียบเท่าในรัฐเข้ากันไม่ได้ (ที่Xกลายเป็นYหลังf()แต่Xเป็นจริงY) และความไม่สอดคล้องกันอาจจะเป็นชั่วคราว

ปัญหาที่คุณพยายามแก้ไขคือปัญหาที่ถูกต้อง อย่างไรก็ตามถึงแม้จะมีการทำ overengineering อย่างมากปัญหาก็คือการหลีกเลี่ยงไม่สามารถแก้ไขได้