Raise ein Ereignis einer Klasse aus einer anderen Klasse in C #

Habe ich eine Klasse, EventContainer.cs, die ein Ereignis enthält, sagen:

public event EventHandler AfterSearch;

Habe ich eine andere Klasse, EventRaiser.cs. Wie erhöhe ich (und nicht mit) den oben erwähnten Ereignis aus dieser Klasse?

Des ausgelösten Ereignisses wird wiederum rufen die handler des Ereignisses in der Klasse EventContainer. So etwas (das ist natürlich nicht richtig):

EventContainer obj = new EventContainer(); 
RaiseEvent(obj.AfterSearch);

InformationsquelleAutor der Frage samar | 2010-12-07

c#events

30

Ist dies nicht möglich, werden die Events können nur gesteigert werden, von innerhalb der Klasse. Wenn Sie das tun könnten, es würde Niederlage der Zweck der Veranstaltungen (in der Lage, aufzustehen status ändert sich von innerhalb der Klasse). Ich denke, Sie verkennen die Funktion der Ereignisse - ein Ereignis in einer Klasse definiert und andere können ihn abonnieren, indem Sie tun,

obj.AfterSearch += handler; (wo-handler ist eine Methode, nach der Unterschrift des AfterSearch). Man ist in der Lage, das Ereignis abonnieren von außen Prima aus, aber es kann nur gesteigert werden, von innerhalb der Klasse definieren.

InformationsquelleAutor der Antwort Femaref

Ist es MÖGLICHaber mit cleveren hack.

Inspiriert von http://netpl.blogspot.com/2010/10/is-net-type-safe.html

Wenn Sie nicht glauben, versuchen Sie diesen code.

using System;
using System.Runtime.InteropServices;

namespace Overlapping
{
    [StructLayout(LayoutKind.Explicit)]
    public class OverlapEvents
    {
        [FieldOffset(0)]
        public Foo Source;

        [FieldOffset(0)]
        public OtherFoo Target;
    }

    public class Foo
    {
        public event EventHandler Clicked;

        public override string ToString()
        {
            return "Hello Foo";
        }

        public void Click()
        {
            InvokeClicked(EventArgs.Empty);
        }

        private void InvokeClicked(EventArgs e)
        {
            var handler = Clicked;
            if (handler != null)
                handler(this, e);
        }
    }

    public class OtherFoo
    {
        public event EventHandler Clicked;

        public override string ToString()
        {
            return "Hello OtherFoo";
        }

        public void Click2()
        {
            InvokeClicked(EventArgs.Empty);
        }

        private void InvokeClicked(EventArgs e)
        {
            var handler = Clicked;
            if (handler != null)
                handler(this, e);
        }

        public void Clean()
        {
            Clicked = null;
        }
    }

    class Test
    {
        public static void Test3()
        {
            var a = new Foo();
            a.Clicked += AClicked;
            a.Click();
            var o = new OverlapEvents { Source = a };
            o.Target.Click2();
            o.Target.Clean();

            o.Target.Click2();
            a.Click();
        }

        static void AClicked(object sender, EventArgs e)
        {
            Console.WriteLine(sender.ToString());
        }
    }
}

InformationsquelleAutor der Antwort halorty

Wie es aussieht bist du mit dem Delegate-Muster. In diesem Fall, die AfterSearch Ereignis sollte definiert werden, auf die EventRaiser Klasse, und die EventContainer - Klasse verbrauchen die Veranstaltung:

In 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();
}

In EventContainer.cs

public EventContainer(...)
{
    EventRaiser er = new EventRaiser();

    er.AfterSearch += this.OnAfterSearch;
}

public void OnAfterSearch()
{
   //Handle AfterSearch event
}

InformationsquelleAutor der Antwort Mark Pim

6

Schreiben Sie eine public Methode der Klasse, die Sie wollen, das Ereignis Feuer aus und Feuer das Ereignis, wenn es genannt wird. Sie können dann diese Methode aufrufen, von welchem Benutzer der Klasse.

Natürlich, diese Ruinen Kapselung und ist schlechtes design.

InformationsquelleAutor der Antwort Oded
4

Es ist eine gute Möglichkeit, dies zu tun. Jedes Ereignis in C# hat eine Stellvertretung, die angibt, wie Zeichen-Methoden für das event. Definieren Sie ein Feld in der externen Klasse mit dem Typ Ihrer Veranstaltung zu delegieren. Holen Sie sich die Referenz von diesem Feld im Konstruktor der äußeren Klasse und speichern Sie es. In der main-Klasse zu Ihrer Veranstaltung, senden Sie die Referenz der event für Delegierte der externen Klasse. Jetzt können Sie leicht rufen Sie die Delegierten in Ihre externe Klasse.
```
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(..., ...);
     ...
}
```
InformationsquelleAutor der Antwort Milad Irannejad
3

Stimmen mit Femaref -- und Hinweis: dies ist ein wichtiger Unterschied zwischen Delegaten und Ereignisse (siehe zum Beispiel dieser blog-Eintrag für eine gute Diskussion dieser und anderer Unterschiede).

Je nachdem, was Sie erreichen wollen, könnten Sie besser dran mit einem Delegaten.

InformationsquelleAutor der Antwort Tim Barrass

Nicht eine gute Programmierung, aber wenn Sie wollen, dass jede Weise, die Sie tun können, so etwas wie dieses

class Program
{
    static void Main(string[] args)
    {

        Extension ext = new Extension();
        ext.MyEvent += ext_MyEvent;
        ext.Dosomething();
    }

    static void ext_MyEvent(int num)
    {
        Console.WriteLine(num);
    }
}


public class Extension
{
    public delegate void MyEventHandler(int num);
    public event MyEventHandler MyEvent;

    public void Dosomething()
    {
        int no = 0;
        while(true){
            if(MyEvent!=null){
                MyEvent(++no);
            }
        }
    }
}

InformationsquelleAutor der Antwort Jagdish

0

Hatte ich eine ähnliche Verwirrung und ehrlich, die Antworten hier zu verwirrend sein. Obwohl ein paar angedeutet Lösungen, die würde ich später arbeiten würde.

Meine Lösung war, Sie zu schlagen, die Bücher und vertraut mit Delegaten und Ereignishandler.
Obwohl ich habe sowohl seit vielen Jahren, ich war nie sehr vertraut mit Ihnen.
http://www.codeproject.com/Articles/20550/C-Event-Implementation-Fundamentals-Best-Practices
gibt die beste Erklärung der beiden Delegaten und Ereignishandler, die ich je gelesen habe und klar erklärt, dass eine Klasse kann ein Herausgeber Ereignisse und andere Klassen, die Sie verzehren.
Dieser Artikel: http://www.codeproject.com/Articles/12285/Implementing-an-event-which-supports-only-a-single beschreibt, wie Sie single-cast-Ereignisse auf nur einen handler, da Delegaten multicast-per definition . Ein Delegierter inherits system.MulticastDelegate die meisten, einschließlich der system-Delegaten Multicast.
Ich fand, dass multicast bedeutete, dass alle event-handler mit der gleichen Signatur, würde die ausgelösten Ereignisses. Multicast Verhalten verursacht hat mir einige schlaflose Nächte, als ich trat durch Codes und sah, wie mein Fall scheinbar irrtümlich an, Handler, ich hatte nicht die Absicht, sich dieses Ereignis. Beide Artikel erläutert dieses Verhalten.
Der zweite Artikel zeigt Ihnen einen Weg, und der erste Artikel zeigt Sie anderen, indem Sie die Stellvertretung und die Signatur fest eingegeben.
Ich persönlich glaube, starke Typisierung verhindert, dass dumme Fehler, die ein Schmerz sein kann, zu finden. Also würde ich vote für den ersten Artikel, obwohl ich selbst bekam den zweiten Artikel-code arbeiten. Ich war nur neugierig. 🙂

Bekam ich auch neugierig, wenn ich könnte #2 Artikel code zu Verhalten, wie ich interpretiert die ursprüngliche Frage oben. Unabhängig von Ihrer gewählten Ansatz oder wenn ich auch Fehlinterpretation der ursprünglichen Frage, meine eigentliche Botschaft ist, dass ich immer noch denken, Sie würden profitieren von der Lektüre der ersten Artikel, so wie ich, vor allem, wenn die Fragen oder Antworten auf dieser Seite verlassen Sie verwirrt. Wenn Sie multicast-Alpträume und eine schnelle Lösung benötigen, dann Artikel 2 kann Ihnen dabei helfen.

Ich begann das Spiel mit dem zweiten Artikel ist eventRaiser Klasse. Ich machte eine einfache windows form-Projekt.
Ich habe den zweiten Artikel, Klasse EventRaiser.cs zu meinem Projekt.
Im Haupt-Formular code, den ich definiert einen Verweis auf das EventRaiser-Klasse an der Spitze als
```
private EventRaiser eventRaiser = new EventRaiser();
```
Ich habe eine Methode in der main-form-code, das wollte ich werden aufgerufen, wenn das Ereignis ausgelöst wurde
```
protected void MainResponse( object sender, EventArgs eArgs )
{            
    MessageBox.Show("got to MainResponse");
}
```
dann in das Hauptformular Konstruktor habe ich noch die event-Zuordnung:
```
eventRaiser.OnRaiseEvent += new EventHandler(MainResponse);`
```
Dann habe ich eine Klasse, würde instanziiert werden von meinem Hauptformular namens "SimpleClass" für den Mangel an schöpferischer Einfallsreichtum im moment.

Dann habe ich einen button und im click-Ereignis der Schaltfläche
Ich instanziiert die SimpleClass code wollte ich ein Ereignis auslösen von:
```
    private void button1_Click( object sender, EventArgs e )
   {            
       SimpleClass sc = new SimpleClass(eventRaiser);
   }
```
Beachten Sie die Instanz von "eventRaiser" , ich ging zu SimpleClass.cs. Das war definiert und instanziiert früher in der Haupt-form-code.

In der 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();
            }
        }
    }
```
Die nur auf die private Methode, die ich genannt SimpleMethod wurde, um zu überprüfen, dass ein privat Gültigkeitsbereich der Methode könnte noch das Ereignis auslösen, nicht, dass ich bezweifelte es, aber ich mag, positiv zu sein.

Ich leitete das Projekt und führte diese, da das Ereignis von der "simpleMethod" der "SimpleClass" bis an die main-form und geht um die zu erwartende richtige Methode aufgerufen MainResponse beweisen, dass eine Klasse zwar kann ein Ereignis auslösen, die verbraucht wird, durch eine andere Klasse.
Ja die Veranstaltung, die von innerhalb der Klasse, die es braucht, change-broadcast, um andere Klassen kümmern. Empfangen von Klassen kann eine Klasse oder viele, viele Klassen, je nachdem, wie stark typisiert man Sie definiert oder indem Sie einzelne Darsteller wie im 2. Artikel.

Hoffe, das hilft und nicht schlammig das Wasser. Ich persönlich habe eine Menge von Delegaten und Ereignisse zu bereinigen! Multicast-Dämonen hinfort!

InformationsquelleAutor der Antwort user3866622

Die Anhebung Klasse hat, um eine frische Kopie von der EventHandler.
Eine mögliche Lösung unten.

using System;

namespace ConsoleApplication1
{
    class Program
    {
        class HasEvent
        {
            public event EventHandler OnEnvent;
            EventInvoker myInvoker;

            public HasEvent()
            {
                myInvoker = new EventInvoker(this, () => OnEnvent);
            }

            public void MyInvokerRaising() {
                myInvoker.Raise();
            }

        }

        class EventInvoker
        {
            private Func<EventHandler> GetEventHandler;
            private object sender;

            public EventInvoker(object sender, Func<EventHandler> GetEventHandler)
            {
                this.sender = sender;
                this.GetEventHandler = GetEventHandler;
            }

            public void Raise()
            {
                if(null != GetEventHandler())
                {
                    GetEventHandler()(sender, new EventArgs());
                }
            }
        }

        static void Main(string[] args)
        {
            HasEvent h = new HasEvent();
            h.OnEnvent += H_OnEnvent;
            h.MyInvokerRaising();
        }

        private static void H_OnEnvent(object sender, EventArgs e)
        {
            Console.WriteLine("FIRED");
        }
    }
}

InformationsquelleAutor der Antwort Johannes

Sehr einfaches Beispiel. ich mag, es zu tun auf diese Weise mit EventHandler.

    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);
        }
    }
}

InformationsquelleAutor der Antwort Mist

Schreibe einen Kommentar

Du musst angemeldet sein, um einen Kommentar abzugeben.