Chiamare eventi C # dall'esterno della classe proprietaria?

Question

È possibile in qualunque circostanza essere in grado di raggiungere questo obiettivo?

Le mie attuali circostanze sono queste:

public class CustomForm : Form
{
    public class CustomGUIElement
    {
    ...
        public event MouseEventHandler Click;
        // etc, and so forth.
    ...
    }

    private List<CustomGUIElement> _elements;

    ...

    public void CustomForm_Click(object sender, MouseEventArgs e)
    {
        // we might want to call one of the _elements[n].Click in here
        // but we can't because we aren't in the same class.
    }
}

Il mio primo pensiero è stato di avere una funzione simile a:

internal enum GUIElementHandlers { Click, ... }
internal void CustomGUIElement::CallHandler(GUIElementHandler h, object[] args) {
    switch (h) {
        case Click:
            this.Click(this, (EventArgs)args[0]);
            break;
        ... // etc and so forth
    }
}

È un kludge orribilmente brutto, ma dovrebbe funzionare ... Ci deve essere una soluzione più elegante, però? La libreria .NET lo fa sempre con gestori di messaggi ed eventi di chiamata in Control. Qualcun altro ha altre idee / migliori?

Answer 1

Devi solo aggiungere un metodo pubblico per invocare l'evento. Microsoft lo fa già per alcuni eventi come PerformClick per i controlli che espongono un evento Click .

public class CustomGUIElement    
{
    public void PerformClick()
    {
        OnClick(EventArgs.Empty);
    }

    protected virtual void OnClick(EventArgs e)
    {
        if (Click != null)
            Click(this, e);
    }
}

Dovresti quindi eseguire le seguenti operazioni nel gestore di eventi di esempio ...

public void CustomForm_Click(object sender, MouseEventArgs e)        
{
    _elements[0].PerformClick();
}

Answer 2

La parola chiave dell'evento in c # modifica la dichiarazione del delegato. Impedisce l'assegnazione diretta al delegato (è possibile utilizzare solo + = e - = su un evento) e impedisce l'invocazione del delegato al di fuori della classe.

Quindi potresti modificare il tuo codice in questo modo:

public class CustomGUIElement
{
...
    public MouseEventHandler Click;
    // etc, and so forth.
...
}

Quindi puoi invocare l'evento dall'esterno della classe in questo modo.

myCustomGUIElement.Click(sender,args);

Lo svantaggio è che il codice che utilizza la classe può sovrascrivere molto facilmente qualsiasi gestore registrato con un codice come questo:

myCustomGUIElement.Click = null;

che non è consentito se il delegato Click viene dichiarato come evento.

Answer 3

Dovresti davvero racchiudere il codice che vuoi essere in grado di eseguire dall'esterno in un metodo. Quel metodo può quindi fare qualunque cosa il tuo evento farebbe - e quell'evento chiamerebbe anche quel metodo.