Créer un Événement Personnalisé

Peut un événement personnalisé être créés pour n'importe quel méthode de l'objet?

Pour ce faire, dois-je simplement utiliser la syntaxe suivante?:

myObject.myMethod +=new EventHandler(myNameEvent);

Le code suivant a invité à cette question:

   private void btRunProcessAndRefresh_Click(object sender,EventArgs e)
    {
        myProcess =new Process();
        myProcess.StartInfo.FileName = @"c:\ConsoleApplication4.exe";
        myProcess.Exited += new EventHandler(MyProcessExited);
        myProcess.EnableRaisingEvents =true;
        myProcess.SynchronizingObject =this;
        btRunProcessAndRefresh.Enabled =false;
        myProcess.Start();
    }

découvrez MSDN exemple des événements bien
notez que myProcess.Exited += MyProcessExited; est assez.
ahhhh ....donc je pourrait avoir soit myProcess.Exited +=new EventHandler(MyProcessExited); OU je pourrais déclarer l'événement et ensuite utiliser myProcess.Exited += MyProcessExited; ?
oui, le new EventHandler() est redondante.
n'oubliez pas de marquer réponse asa accepté si cela fonctionne pour vous ...
joli, j'avais oublié!

InformationsquelleAutor whytheq | 2012-03-27

c#events

Oui, vous pouvez faire comme ceci :

La création de avancée C# des événements personnalisés

Le Plus Simple C# D'Événements Exemple Imaginable

public class Metronome
{
    public event TickHandler Tick;
    public EventArgs e = null;
    public delegate void TickHandler(Metronome m, EventArgs e);
    public void Start()
    {
        while (true)
        {
            System.Threading.Thread.Sleep(3000);
            if (Tick != null)
            {
                Tick(this, e);
            }
        }
    }
}
public class Listener
{
    public void Subscribe(Metronome m)
    {
        m.Tick += new Metronome.TickHandler(HeardIt);
    }

    private void HeardIt(Metronome m, EventArgs e)
    {
        System.Console.WriteLine("HEARD IT");
    }
}
class Test
{
    static void Main()
    {
        Metronome m = new Metronome();
        Listener l = new Listener();
        l.Subscribe(m);
        m.Start();
    }
}

qui n'a pas l'air comme l'exemple le plus simple pour moi.
vérifier d'abord le lien ayant plus simple exemple
c'est mieux 🙂
Voici un autre "plus simple" exemple: msdn.microsoft.com/en-us/library/aa645739%28VS.71%29.aspx
Qu'est-ce que HeardIt?
C'est une méthode qui est censé être dans la classe Écouteur, signature private void HeardIt(Métronome m, EventArgs e). Si vous suivez le second lien, il est là. Je ne sais pas pourquoi il a laissé de côté ici.

InformationsquelleAutor Pranay Rana

Déclarer la classe contenant l'événement:

class MyClass {
    public event EventHandler MyEvent;

    public void Method() {
        OnEvent();
    }

    private void OnEvent() {
        if (MyEvent != null) {
            MyEvent(this, EventArgs.Empty);
        }
    }
}

L'utiliser comme ceci:

MyClass myObject = new MyClass();
myObject.MyEvent += new EventHandler(myObject_MyEvent);
myObject.Method();

+1 belle exemple très simple, merci

InformationsquelleAutor ionden

Oui, vous pouvez créer des événements sur des objets, ici est un exemple;

public class Foo
{
    public delegate void MyEvent(object sender, object param);
    event MyEvent OnMyEvent;

    public Foo()
    {
        this.OnMyEvent += new MyEvent(Foo_OnMyEvent);
    }

    void Foo_OnMyEvent(object sender, object param)
    {
        if (this.OnMyEvent != null)
        {
            //do something
        }
    }



    void RaiseEvent()
    {
        object param = new object();
        this.OnMyEvent(this,param);
    }
}

Je regarde quelques autres exemples fournis et qu'ils ne comprennent pas "délégué" - je n'en ai pas rencontré avant
quand vous regardez dans le Gestionnaire d'événements, c'est juste un délégué spécifique.
pour exposer, vous devez utiliser un gestionnaire d'événements personnalisés délégué, si vous avez besoin de différents paramètres que ceux utilisés pour la EventHandler ou EventHandler<>. Voir ici pour plus de détails.

InformationsquelleAutor daryal

6

Oui, à condition d'avoir accès à la définition de l'objet et peut le modifier pour déclarer l'événement personnalisé
```
public event EventHandler<EventArgs> ModelChanged;
```
Et, normalement, vous seriez de retour à une méthode privée utilisé en interne pour invoquer l'événement:
```
private void OnModelChanged(EventArgs e)
{
    if (ModelChanged != null)
        ModelChanged(this, e);
}
```
Votre code déclare simplement qu'un gestionnaire pour l'déclaré myMethod événement (vous pouvez également supprimer le constructeur), qui serait appelée chaque fois que l'objet qui déclenche l'événement.
```
myObject.myMethod += myNameEvent;
```
De même, vous pouvez détacher un gestionnaire à l'aide de
```
myObject.myMethod -= myNameEvent;
```
Aussi, vous pouvez écrire votre propre sous-classe des EventArgs de fournir des données lors de votre événement se déclenche.
- Simple et élégant.
- J'ai essayé mais l'événement ne se déclenche pas
InformationsquelleAutor Strillo

Basé sur @ionden de réponse, l'appel à la délégué pourrait être simplifiée en utilisant null propagation depuis C# 6.0.

Votre code serait tout simplement:

class MyClass {
    public event EventHandler MyEvent;

    public void Method() {
        MyEvent?.Invoke(this, EventArgs.Empty);
    }
}

L'utiliser comme ceci:

MyClass myObject = new MyClass();
myObject.MyEvent += new EventHandler(myObject_MyEvent);
myObject.Method();

InformationsquelleAutor Antoine C.

3

Vous devez déclarer votre événement dans la classe de monobjet :
```
public event EventHandler<EventArgs> myMethod; //you should name it as an event, like ObjectChanged.
```
puis myNameEvent est le callback pour gérer l'événement, et il peut être dans n'importe quelle autre classe
- ok, mais la question a été inspiré par un code je suis de l'analyse. Je vais ajouter le code de la question. Je ne vois aucune déclaration.
- Eh bien, si vous cliquez sur aller à la définition d'Quitté, il doit être un événement, puis le code de gestion est en MyProcessExited.
InformationsquelleAutor MBen

Vous devez vous connecter pour publier un commentaire.