Déclencher un événement d'une classe à partir d'une autre classe en C#

Ce n'est pas possible, les Événements ne peut être augmenté, passant à l'intérieur de la classe. Si vous pouviez le faire, il irait à l'encontre de l'objectif d'événements (être à la hauteur des changements d'état de l'intérieur de la classe). Je pense que vous êtes l'incompréhension de la fonction des événements un événement est définie à l'intérieur d'une classe et d'autres personnes pouvez vous abonner en faisant

obj.AfterSearch += handler; (où le gestionnaire est une méthode selon la signature de AfterSearch). On est capable de s'abonner à l'événement de l'extérieur, mais il ne peut être passé de l'intérieur de la classe qui la définit.

On dirait que vous êtes à l'aide de la Modèle de délégué. Dans ce cas, le AfterSearch de l'événement doivent être définis sur la EventRaiser de classe, et l' EventContainer classe devraient consommer de l'événement:

Dans EventRaiser.cs

public event EventHandler BeforeSearch;
public event EventHandler AfterSearch;
public void ExecuteSearch(...)
{
if (this.BeforeSearch != null)
this.BeforeSearch();
//Do search
if (this.AfterSearch != null)
this.AfterSearch();
}

Dans EventContainer.cs

public EventContainer(...)
{
EventRaiser er = new EventRaiser();
er.AfterSearch += this.OnAfterSearch;
}
public void OnAfterSearch()
{
//Handle AfterSearch event
}

Il ya bonne façon de le faire. Chaque événement en C# dispose d'un délégué qui spécifie le signe de méthodes pour l'événement. Définir un champ dans votre classe externe avec le type de votre délégué d'événement. obtenir la référence de ce champ dans le constructeur de la classe externe et de l'enregistrer. Dans la classe principale de votre événement, envoyez la référence de l'événement pour le délégué de la classe externe. Maintenant, vous pouvez facilement appeler le délégué dans votre classe externe.

public delegate void MyEventHandler(object Sender, EventArgs Args);
public class MyMain
{
public event MyEventHandler MyEvent;
...
new MyExternal(this.MyEvent);
...
}
public MyExternal
{
private MyEventHandler MyEvent;
public MyExternal(MyEventHandler MyEvent)
{
this.MyEvent = MyEvent;
}
...
this.MyEvent(..., ...);
...
}

D'accord avec Femaref -- et note ceci est une différence importante entre les délégués et les événements (voir, par exemple, cette entrée de blog pour une bonne discussion de ce et d'autres différences).

En fonction de ce que vous voulez atteindre, vous pourriez être mieux avec un délégué.

J'ai eu un genre de confusion et honnêtement, vous trouverez les réponses ici à être source de confusion. Bien qu'un couple fait allusion à des solutions que j'allais trouver serait de travailler.

Ma solution a été de frapper les livres et à devenir plus familier avec les représentants et les gestionnaires d'événements.
Bien que j'ai utilisé à la fois pour de nombreuses années, je n'ai jamais été intimement familier avec eux.
http://www.codeproject.com/Articles/20550/C-Event-Implementation-Fundamentals-Best-Practices
donne la meilleure explication de ces deux représentants et les gestionnaires d'événements que j'ai jamais lu et explique clairement qu'une classe peut être un éditeur d'événements et d'avoir d'autres catégories de les consommer.
Cet article: http://www.codeproject.com/Articles/12285/Implementing-an-event-which-supports-only-a-single explique comment une seule fonte des événements à un seul gestionnaire depuis les délégués sont multicast par définition . Un délégué hérite du système.MulticastDelegate la plupart, y compris le système des délégués sont Multicast.
J'ai trouvé que la multidiffusion signifiait que tout gestionnaire d'événements avec la même signature de recevoir le soulevé de l'événement. Multidiffusion le comportement m'a causé quelques nuits blanches que je passais à travers le code et vu mon cas apparemment à tort d'être envoyé aux gestionnaires que je n'avais pas l'intention d'obtenir cet événement. Les deux articles qui explique ce comportement.
Le deuxième article vous montre un chemin, et le premier article vous montre un autre, en faisant le délégué et la signature étroitement tapé.
Personnellement, je crois que le typage fort empêche stupide bugs qui peut être difficile à trouver. Donc j'aurais voter pour le premier article, même si j'ai reçu le deuxième article du code de travail. J'étais juste curieux. 🙂

Je suis aussi curieux de savoir si je pourrais obtenir de l' #2 articles du code de se comporter comme comment j'ai interprété la question initiale. Quelle que soit votre approche choisie ou si je suis aussi une mauvaise interprétation de la question d'origine, mon vrai message, c'est que je pense toujours que vous auriez avantage à lire le premier article que j'ai fait, surtout si les questions ou des réponses sur cette page vous laisser confondre. Si vous avez de la multidiffusion des cauchemars et ont besoin d'une solution rapide, puis l'article 2 peut vous aider.

J'ai commencé à jouer avec le deuxième article de la eventRaiser classe. J'ai fait un simple formulaire windows projet.
J'ai ajouté la deuxième articles de la classe EventRaiser.cs à mon projet.
Dans le formulaire Principal du code, j'ai défini une référence à cette EventRaiser classe au sommet comme

private EventRaiser eventRaiser = new EventRaiser();

J'ai ajouté une méthode dans la principale forme de code que je voulais être appelée lorsque l'événement a été déclenché

protected void MainResponse( object sender, EventArgs eArgs )
{            
MessageBox.Show("got to MainResponse");
}

puis dans le formulaire principal du constructeur, j'ai ajouté l'événement affectation:

eventRaiser.OnRaiseEvent += new EventHandler(MainResponse);`

Ensuite, j'ai créé une classe qui serait instancié par mon formulaire principal appelé "SimpleClass" par manque d'ingéniosité créatrice à l'heure actuelle.

Puis j'ai ajouté un bouton et dans l'événement click du bouton
J'ai instancié le SimpleClass code que j'ai voulu faire un événement à partir de:

    private void button1_Click( object sender, EventArgs e )
{            
SimpleClass sc = new SimpleClass(eventRaiser);
}

Note l'instance de "eventRaiser" que j'ai passé à SimpleClass.cs. Qui a été définie et instancié plus tôt dans la Principale forme de code.

Dans le SimpleClass:

using System.Windows.Forms;
using SinglecastEvent; //see SingleCastEvent Project for info or http://www.codeproject.com/Articles/12285/Implementing-an-event-which-supports-only-a-single
namespace GenericTest
{
public class SimpleClass
{
private EventRaiser eventRaiser = new EventRaiser();
public SimpleClass( EventRaiser ev )
{
eventRaiser = ev;
simpleMethod();
}
private void simpleMethod()
{
MessageBox.Show("in FileWatcher.simple() about to raise the event");
eventRaiser.RaiseEvent();
}
}
}

Le seul point à la méthode privée, j'ai appelé SimpleMethod était de vérifier qu'une entreprise privée dont l'étendue méthode pourrait encore augmenter l'événement, non pas que je doutais, mais je tiens à être positif.

J'ai couru le projet, ce qui a abouti dans la sensibilisation de l'événement de la "simpleMethod" de la "SimpleClass" jusqu'à la forme principale et allez la bonne méthode, appelée MainResponse prouvant qu'une classe peut en effet déclencher un événement qui est consommé par une autre classe.
Oui, l'événement doit être soulevé au sein de la classe qui a besoin de changer de diffusion à d'autres classes que les soins. La réception de classes peut être une classe ou de nombreuses de nombreuses classes en fonction de comment fortement typés vous les avez définies ou en les rendant unique jeté comme dans le 2ème article.

Espérons que cela aide et de ne pas brouiller l'eau. Personnellement, j'ai beaucoup de délégués et événements à nettoyer! Multidiffusion démons begone!

Exemple très simple. je tiens à le faire de cette façon en utilisant Gestionnaire.

    class Program
{
static void Main(string[] args)
{
MyExtension ext = new MyExtension();
ext.MyEvent += ext_MyEvent;
ext.Dosomething();
Console.ReadLine();
}
static void ext_MyEvent(object sender, int num)
{
Console.WriteLine("Event fired.... "+num);
}
}
public class MyExtension
{
public event EventHandler<int> MyEvent;
public void Dosomething()
{
int no = 1;
if (MyEvent != null)
MyEvent(this, ++no);
}
}
}