ก่อนอื่นคำถามที่ดี ฉันชื่นชมที่คุณให้ความสำคัญกับยูทิลิตี้แทนที่จะยอมรับ "แนวทางปฏิบัติที่ดีที่สุด" อย่างสุ่ม ๆ +1 สำหรับสิ่งนั้น
ฉันอ่านคำแนะนำนั้นมาก่อน คุณต้องจำบางสิ่งเกี่ยวกับมัน - มันเป็นเพียงแนวทางสำหรับผู้มาใหม่ C # ที่รู้วิธีการเขียนโปรแกรม แต่ไม่คุ้นเคยกับวิธีการทำสิ่ง C # มันไม่ได้เป็นหน้าของกฎเท่าที่เป็นหน้าที่อธิบายถึงสิ่งที่มักจะทำไปแล้ว และเนื่องจากพวกเขาทำเช่นนี้ทุกที่แล้วจึงเป็นความคิดที่ดีที่จะอยู่อย่างสม่ำเสมอ
ฉันจะไปที่จุดตอบคำถามของคุณ
ก่อนอื่นผมถือว่าคุณรู้แล้วว่าอินเตอร์เฟสคืออะไร สำหรับผู้ร่วมประชุมก็พอที่จะบอกได้ว่ามันเป็นโครงสร้างที่มีตัวชี้ที่พิมพ์ไปยังวิธีการพร้อมกับตัวชี้ที่เป็นตัวเลือกไปยังวัตถุที่เป็นตัวแทนของthisอาร์กิวเมนต์สำหรับวิธีการนั้น ในกรณีของวิธีการคงที่ตัวชี้หลังเป็นโมฆะ
นอกจากนี้ยังมีผู้รับหลายผู้รับซึ่งเป็นเหมือนผู้รับมอบสิทธิ์ แต่อาจมีโครงสร้างเหล่านี้หลายอย่างที่มอบหมายให้พวกเขา (หมายถึงการเรียกครั้งเดียวเพื่อเรียกใช้บนผู้รับมอบสิทธิ์หลายผู้รับจะเรียกใช้วิธีการทั้งหมดในรายการเรียกใช้ที่มอบหมาย)
พวกเขาหมายถึงรูปแบบการออกแบบ eventing หรือไม่
พวกเขาหมายถึงการใช้เหตุการณ์ใน C # (ซึ่งมีคำหลักพิเศษสำหรับการใช้รูปแบบที่มีประโยชน์อย่างยิ่งนี้) กิจกรรมใน C # ได้รับการเติมพลังโดยผู้รับมอบหลายผู้รับ
เมื่อคุณกำหนดกิจกรรมเช่นในตัวอย่างนี้:
class MyClass {
// Note: EventHandler is just a multicast delegate,
// that returns void and accepts (object sender, EventArgs e)!
public event EventHandler MyEvent;
public void DoSomethingThatTriggersMyEvent() {
// ... some code
var handler = MyEvent;
if (handler != null)
handler(this, EventArgs.Empty);
// ... some other code
}
}
คอมไพเลอร์แปลงสิ่งนี้เป็นโค้ดต่อไปนี้:
class MyClass {
private EventHandler MyEvent = null;
public void add_MyEvent(EventHandler value) {
MyEvent += value;
}
public void remove_MyEvent(EventHandler value) {
MyEvent -= value;
}
public void DoSomethingThatTriggersMyEvent() {
// ... some code
var handler = MyEvent;
if (handler != null)
handler(this, EventArgs.Empty);
// ... some other code
}
}
จากนั้นคุณสมัครสมาชิกกิจกรรมโดยทำ
MyClass instance = new MyClass();
instance.MyEvent += SomeMethodInMyClass;
ซึ่งคอมไพล์ลงไป
MyClass instance = new MyClass();
instance.add_MyEvent(new EventHandler(SomeMethodInMyClass));
นั่นคืออีเวนติ้งใน C # (หรือ. NET โดยทั่วไป)
วิธีการจัดองค์ประกอบจะง่ายถ้าใช้ผู้รับมอบสิทธิ์
สิ่งนี้อาจแสดงให้เห็นได้อย่างง่ายดาย:
สมมติว่าคุณมีคลาสที่ขึ้นอยู่กับชุดของการกระทำที่จะส่งผ่านไป คุณสามารถแค็ปซูลการกระทำเหล่านั้นในอินเทอร์เฟซ:
interface RequiredMethods {
void DoX();
int DoY();
};
และทุกคนที่ต้องการส่งการกระทำไปยังชั้นเรียนของคุณจะต้องใช้อินเทอร์เฟซนั้นก่อน หรือคุณสามารถทำให้ชีวิตของพวกเขาง่ายขึ้นโดยขึ้นอยู่กับชั้นเรียนต่อไปนี้:
sealed class RequiredMethods {
public Action DoX;
public Func<int> DoY();
}
วิธีนี้ผู้โทรต้องสร้างอินสแตนซ์ของ RequiredMethods และเมธอดการเชื่อมโยงไปยังผู้รับมอบสิทธิ์ที่รันไทม์ นี้คือมักจะง่ายขึ้น
วิธีการทำสิ่งนี้เป็นประโยชน์อย่างยิ่งภายใต้สถานการณ์ที่เหมาะสม ลองคิดดูสิ - ทำไมต้องพึ่งพาอินเทอร์เฟซเมื่อทุกสิ่งที่คุณสนใจจริงๆคือการใช้งานการส่งผ่านให้กับคุณ?
ประโยชน์ของการใช้อินเทอร์เฟซเมื่อมีกลุ่มของวิธีการที่เกี่ยวข้อง
เป็นประโยชน์ในการใช้อินเตอร์เฟสเนื่องจากโดยปกติอินเตอร์เฟสต้องการการใช้งานคอมไพล์เวลาที่ชัดเจน หมายความว่าคุณสร้างคลาสใหม่
และถ้าคุณมีกลุ่มของวิธีการที่เกี่ยวข้องในแพคเกจเดียวมันเป็นประโยชน์ที่จะมีแพคเกจที่สามารถนำมาใช้ใหม่โดยส่วนอื่น ๆ ของรหัส ดังนั้นหากพวกเขาสามารถยกตัวอย่างชั้นเรียนได้อย่างง่ายดายแทนที่จะสร้างกลุ่มผู้ได้รับมอบหมายมันง่ายกว่า
ประโยชน์ของการใช้อินเทอร์เฟซถ้าคลาสต้องการเพียงหนึ่งการใช้งาน
ดังที่ระบุไว้ก่อนหน้านี้อินเทอร์เฟซถูกนำมาใช้ในเวลารวบรวม - ซึ่งหมายความว่าพวกเขามีประสิทธิภาพมากกว่าการเรียกผู้แทน (ซึ่งเป็นระดับของอ้อมต่อ se)
"การติดตั้งใช้งานหนึ่งระบบ" อาจหมายถึงการติดตั้งที่มีอยู่ในที่เดียว
มิฉะนั้นการใช้งานอาจมาจากที่ใดก็ได้ในโปรแกรมซึ่งเพิ่งเกิดขึ้นเพื่อให้สอดคล้องกับลายเซ็นวิธี ที่ช่วยให้มีความยืดหยุ่นมากขึ้นเพราะวิธีการเพียงต้องการให้สอดคล้องกับลายเซ็นที่คาดหวังมากกว่าอยู่ในชั้นเรียนที่ใช้อินเตอร์เฟซที่เฉพาะเจาะจงอย่างชัดเจน แต่ความยืดหยุ่นนั้นอาจมาพร้อมกับค่าใช้จ่ายและทำลายหลักการการทดแทน Liskovเพราะส่วนใหญ่คุณต้องการความชัดเจนเพราะมันช่วยลดโอกาสในการเกิดอุบัติเหตุให้น้อยที่สุด เหมือนกับการพิมพ์แบบคงที่
คำนี้อาจหมายถึงผู้รับมอบหมายหลายผู้รับที่นี่ เมธอดที่ประกาศโดยอินเตอร์เฟสสามารถใช้ได้เพียงครั้งเดียวในคลาสที่นำไปใช้งาน แต่ผู้ได้รับมอบหมายสามารถสะสมหลายวิธีซึ่งจะถูกเรียกตามลำดับ
ดังนั้นโดยรวมแล้วดูเหมือนว่าคำแนะนำนั้นไม่ได้ให้ข้อมูลเพียงพอและเพียงทำหน้าที่เหมือนเป็นคู่มือ - ไม่ใช่กฎ คำแนะนำบางอย่างอาจฟังดูขัดแย้งเล็กน้อย มันขึ้นอยู่กับคุณที่จะตัดสินใจว่าจะใช้อะไร คู่มือดูเหมือนจะให้เส้นทางทั่วไปแก่เราเท่านั้น
ฉันหวังว่าคำถามของคุณจะได้รับคำตอบเพื่อความพึงพอใจของคุณ และอีกครั้งขอชื่นชมสำหรับคำถาม