เมื่อใดควรใช้การผูกมัด
ฟังก์ชั่นผูกมัดส่วนใหญ่เป็นที่นิยมในภาษาที่ IDE กับการเติมอัตโนมัติเป็นเรื่องธรรมดา ตัวอย่างเช่นนักพัฒนา C # เกือบทั้งหมดใช้ Visual Studio ดังนั้นหากคุณกำลังพัฒนาด้วยการเพิ่มการผูกมัด C # กับวิธีการของคุณอาจเป็นการประหยัดเวลาสำหรับผู้ใช้ของคลาสนั้นเพราะ Visual Studio จะช่วยคุณในการสร้างห่วงโซ่
ในทางกลับกันภาษาเช่น PHP ที่มีความเป็นธรรมชาติสูงและมักจะไม่มีการสนับสนุนที่สมบูรณ์แบบอัตโนมัติใน IDEs จะเห็นคลาสที่น้อยลงที่รองรับการโยง การผูกมัดจะเหมาะสมเมื่อมีการใช้งาน phpDocs ที่ถูกต้องเพื่อแสดงวิธีการเชื่อมต่อ
ผูกมัดคืออะไร?
ให้ชั้นชื่อFooสองวิธีต่อไปนี้เป็นทั้ง chainable
function what() { return this; }
function when() { return new Foo(this); }
ความจริงที่ว่าหนึ่งคือการอ้างอิงถึงอินสแตนซ์ปัจจุบันและเป็นหนึ่งในการสร้างอินสแตนซ์ใหม่จะไม่เปลี่ยนแปลงว่าสิ่งเหล่านี้เป็นวิธีการที่ chainable
ไม่มีกฎทองคำที่วิธีการเชื่อมโยงจะต้องอ้างอิงวัตถุปัจจุบันเท่านั้น Infact วิธีการเชื่อมต่อสามารถข้ามชั้นเรียนได้สองแบบ ตัวอย่างเช่น;
class B { function When() { return true; } };
class A { function What() { return new B(); } };
var a = new A();
var x = a.What().When();
ไม่มีการอ้างอิงถึงthisในตัวอย่างใด ๆ ข้างต้น รหัสa.What().When()เป็นตัวอย่างของการผูกมัด สิ่งที่น่าสนใจคือประเภทของคลาสBไม่เคยถูกกำหนดให้กับตัวแปร
วิธีการถูกผูกมัดเมื่อมันกลายเป็นค่าตอบแทนที่ใช้เป็นองค์ประกอบต่อไปของการแสดงออก
นี่คือตัวอย่างเพิ่มเติม
// return value never assigned.
myFile.Open("something.txt").Write("stuff").Close();
// two chains used in expression
int x = a.X().Y() * b.X().Y();
// a chain that creates new strings
string name = str.Substring(1,10).Trim().ToUpperCase();
ควรใช้เมื่อใดthisและnew(this)
เงื่อนไขในภาษาส่วนใหญ่ไม่เปลี่ยนรูป ดังนั้นวิธีการผูกมัดการโทรมักจะส่งผลให้เกิดสายใหม่ที่ถูกสร้างขึ้น ในกรณีที่วัตถุเช่น StringBuilder สามารถแก้ไขได้
ความสอดคล้องเป็นแนวปฏิบัติที่ดีที่สุด
หากคุณมีวิธีการที่แก้ไขสถานะของวัตถุและส่งคืนthisอย่ารวมวิธีการที่ส่งคืนอินสแตนซ์ใหม่ ให้สร้างวิธีการเฉพาะที่เรียกClone()ว่าจะทำสิ่งนี้แทน
var x = a.Foo().Boo().Clone().Foo();
aนั่นเป็นจำนวนมากที่ชัดเจนเป็นสิ่งที่เกิดขึ้นภายใน
เคล็ดลับขั้นตอนนอกและด้านหลัง
ฉันเรียกสิ่งนี้ว่าขั้นตอนในและนอกเคล็ดลับเพราะมันแก้ปัญหาทั่วไปมากมายที่เกี่ยวข้องกับการผูกมัด โดยพื้นฐานแล้วหมายความว่าคุณจะก้าวออกจากคลาสเดิมไปสู่คลาสชั่วคราวใหม่จากนั้นกลับสู่คลาสเดิม
คลาสชั่วคราวมีไว้เพื่อมอบคุณสมบัติพิเศษให้กับคลาสดั้งเดิม แต่ภายใต้เงื่อนไขพิเศษเท่านั้น
บ่อยครั้งที่ห่วงโซ่ต้องการเปลี่ยนสถานะแต่คลาสAไม่สามารถแสดงสถานะที่เป็นไปได้ทั้งหมด Aดังนั้นในช่วงโซ่คลาสใหม่ที่มีการแนะนำที่มีกลับอ้างอิงถึง สิ่งนี้ทำให้โปรแกรมเมอร์สามารถเข้าสู่สถานะและย้อนกลับไปAได้
Bนี่คือตัวอย่างของฉันให้รัฐพิเศษที่รู้จักในฐานะ
class A {
function Foo() { return this; }
function Boo() { return this; }
function Change() return new B(this); }
}
class B {
var _a;
function (A) { _a = A; }
function What() { return this; }
function When() { return this; }
function End() { return _a; }
}
var a = new A();
a.Foo().Change().What().When().End().Boo();
ตอนนี้เป็นตัวอย่างที่ง่ายมาก หากคุณต้องการมีการควบคุมที่มากขึ้นคุณBสามารถกลับไปใช้ super-type ใหม่Aที่มีวิธีการต่างกัน