รับคลาส C # ต่อไปนี้:

c1 {
 event EventHandler someEvent;
}

หากมีจำนวนมากของการสมัครเป็นสมาชิกc1ของsomeEventเหตุการณ์และฉันต้องการที่จะล้างพวกเขาทุกสิ่งที่เป็นวิธีที่ดีที่สุดเพื่อให้บรรลุนี้? นอกจากนี้ยังพิจารณาว่าการสมัครสมาชิกกับเหตุการณ์นี้อาจเป็น / เป็น lambdas / ผู้ได้รับมอบอำนาจโดยไม่ระบุชื่อ

ปัจจุบันโซลูชันของฉันคือการเพิ่มResetSubscriptions()วิธีการc1ที่กำหนดsomeEventเป็นโมฆะ ฉันไม่รู้ว่าสิ่งนี้มีผลที่มองไม่เห็นหรือไม่

จากภายในคลาสคุณสามารถตั้งค่าตัวแปร (ซ่อน) เป็นโมฆะ การอ้างอิง Null เป็นวิธีมาตรฐานของการแสดงรายการการร้องขอว่างอย่างมีประสิทธิภาพ

จากนอกห้องเรียนคุณไม่สามารถทำสิ่งนี้ได้ - โดยทั่วไปเหตุการณ์จะเปิดเผย "สมัครสมาชิก" และ "ยกเลิกการสมัคร" และนั่นก็คือ

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

ดูบทความของฉันเกี่ยวกับเหตุการณ์และผู้ได้รับมอบหมายสำหรับข้อมูลเพิ่มเติม

เพิ่มวิธีการใน c1 ที่จะตั้ง 'someEvent' เป็นโมฆะ

public class c1
{
    event EventHandler someEvent;
    public ResetSubscriptions() => someEvent = null;    
}

class c1
{
    event EventHandler someEvent;
    ResetSubscriptions() => someEvent = delegate { };
}

มันจะดีกว่าที่จะใช้delegate { }กว่าnullเพื่อหลีกเลี่ยงข้อยกเว้นการอ้างอิงโมฆะ

การตั้งค่าเหตุการณ์ให้เป็นโมฆะภายในคลาสใช้งานได้ เมื่อคุณทิ้งคลาสคุณควรตั้งค่าเหตุการณ์เป็นโมฆะ GC มีปัญหากับกิจกรรมและอาจไม่ล้างคลาสที่จำหน่ายหากมีเหตุการณ์ที่ห้อยอยู่

แนวทางที่ดีที่สุดในการล้างสมาชิกทั้งหมดคือการตั้งค่า someEvent เป็นโมฆะโดยการเพิ่มวิธีการสาธารณะอื่นหากคุณต้องการให้ฟังก์ชันนี้เป็นภายนอก สิ่งนี้ไม่มีผลกระทบที่มองไม่เห็น เงื่อนไขที่ต้องจำไว้คือการประกาศให้ผู้ที่มีคำหลัก 'เหตุการณ์'

โปรดดูหนังสือ - C # 4.0 โดยย่อหน้า 125

บางคนเสนอที่นี่เพื่อใช้Delegate.RemoveAllวิธีการ หากคุณใช้รหัสตัวอย่างสามารถทำตามแบบฟอร์มด้านล่าง แต่มันช่างโง่จริงๆ ทำไมไม่เพียงSomeEvent=nullภายในClearSubscribers()ฟังก์ชั่น?

public void ClearSubscribers ()
{
   SomeEvent = (EventHandler) Delegate.RemoveAll(SomeEvent, SomeEvent);
   // Then you will find SomeEvent is set to null.
}

คุณสามารถทำได้โดยใช้วิธีการมอบสิทธิ์ลบหรือผู้รับมอบสิทธิ์ลบวิธีการทั้งหมด

ความคิดเห็นที่น่าเบื่อขยายแนวคิด

ฉันควรใช้คำว่า "event handler" แทนที่จะเป็น "event" หรือ "มอบหมาย" และใช้คำว่า "เหตุการณ์" สำหรับสิ่งอื่น ๆ ในบางภาษาโปรแกรม (VB.NET, Object Pascal, Objective-C), "event" เรียกว่า "message" หรือ "signal" และยังมีคีย์เวิร์ด "message" และไวยากรณ์น้ำตาลเฉพาะ

const
  WM_Paint = 998;  // <-- "question" can be done by several talkers
  WM_Clear = 546;

type
  MyWindowClass = class(Window)
    procedure NotEventHandlerMethod_1;
    procedure NotEventHandlerMethod_17;

    procedure DoPaintEventHandler; message WM_Paint; // <-- "answer" by this listener
    procedure DoClearEventHandler; message WM_Clear;
  end;

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

สรุป: "เหตุการณ์" คือ "คำถาม", "ตัวจัดการเหตุการณ์" คือคำตอบ

นี่คือทางออกของฉัน:

public class Foo : IDisposable
{
    private event EventHandler _statusChanged;
    public event EventHandler StatusChanged
    {
        add
        {
            _statusChanged += value;
        }
        remove
        {
            _statusChanged -= value;
        }
    }

    public void Dispose()
    {
        _statusChanged = null;
    }
}

คุณต้องโทรDispose()หรือใช้using(new Foo()){/*...*/}รูปแบบเพื่อยกเลิกการเป็นสมาชิกทั้งหมดของรายการการเรียก

ลบกิจกรรมทั้งหมดถือว่าเหตุการณ์เป็นประเภท "การกระทำ":

Delegate[] dary = TermCheckScore.GetInvocationList();

if ( dary != null )
{
    foreach ( Delegate del in dary )
    {
        TermCheckScore -= ( Action ) del;
    }
}

แทนที่จะเพิ่มและลบการเรียกกลับด้วยตนเองและการประกาศประเภทผู้ร่วมประชุมทุกที่:

// The hard way
public delegate void ObjectCallback(ObjectType broadcaster);

public class Object
{
    public event ObjectCallback m_ObjectCallback;
    
    void SetupListener()
    {
        ObjectCallback callback = null;
        callback = (ObjectType broadcaster) =>
        {
            // one time logic here
            broadcaster.m_ObjectCallback -= callback;
        };
        m_ObjectCallback += callback;

    }
    
    void BroadcastEvent()
    {
        m_ObjectCallback?.Invoke(this);
    }
}

คุณสามารถลองวิธีการทั่วไปนี้:

public class Object
{
    public Broadcast<Object> m_EventToBroadcast = new Broadcast<Object>();

    void SetupListener()
    {
        m_EventToBroadcast.SubscribeOnce((ObjectType broadcaster) => {
            // one time logic here
        });
    }

    ~Object()
    {
        m_EventToBroadcast.Dispose();
        m_EventToBroadcast = null;
    }

    void BroadcastEvent()
    {
        m_EventToBroadcast.Broadcast(this);
    }
}


public delegate void ObjectDelegate<T>(T broadcaster);
public class Broadcast<T> : IDisposable
{
    private event ObjectDelegate<T> m_Event;
    private List<ObjectDelegate<T>> m_SingleSubscribers = new List<ObjectDelegate<T>>();

    ~Broadcast()
    {
        Dispose();
    }

    public void Dispose()
    {
        Clear();
        System.GC.SuppressFinalize(this);
    }

    public void Clear()
    {
        m_SingleSubscribers.Clear();
        m_Event = delegate { };
    }

    // add a one shot to this delegate that is removed after first broadcast
    public void SubscribeOnce(ObjectDelegate<T> del)
    {
        m_Event += del;
        m_SingleSubscribers.Add(del);
    }

    // add a recurring delegate that gets called each time
    public void Subscribe(ObjectDelegate<T> del)
    {
        m_Event += del;
    }

    public void Unsubscribe(ObjectDelegate<T> del)
    {
        m_Event -= del;
    }

    public void Broadcast(T broadcaster)
    {
        m_Event?.Invoke(broadcaster);
        for (int i = 0; i < m_SingleSubscribers.Count; ++i)
        {
            Unsubscribe(m_SingleSubscribers[i]);
        }
        m_SingleSubscribers.Clear();
    }
}