C # delegate v. s. eventHandler

Chcę powiadomić wszystkich subskrybentów, gdy pojawi się pułapka.

Stworzony przeze mnie kod działa dobrze za pomocą metody delegata(myDelegate del).

1. Chcę wiedzieć, czy warto używać Eventhandler better off delegate? nie wiesz, czym dokładnie różni się delegat od Wydarzenia w moim przypadku?

2. Powiadom(trapinfo t), to jest to, co zrobiłem tutaj, aby uzyskać informacje pułapki. Ale to nie jest dobry pomysł. Przeczytaj trochę online tutorial lekcja przedstawiająca delegatów zdających obiekt, czy jest to odpowiednie dla mojego przypadku? I jak mam to zrobić? Jakieś sugestie?

Wielkie dzięki:)

Mój kod:

public class trapinfo
    {
        public string info;
        public string ip;
        public string cause;
    }

    public class trap
    {
        public delegate void myDelegate(trapinfo t);
        public myDelegate del;

        trapinfo info = new trapinfo();

        public void run()
        {
            //While(true) 
            // If a trap occurred, notify the subscriber
            for (; ; )
            {
                Thread.Sleep(500);
                foreach (myDelegate d in del.GetInvocationList())
                {
                    info.cause = "Shut Down";
                    info.ip = "192.168.0.1";
                    info.info = "Test";
                    d.Invoke(info);
                }
            }
        }
    }
    public class machine
    {
        private int _occuredtime=0;

        public trapinfo info = new trapinfo();
        public void notify(trapinfo t)
        {
            ++_occuredtime;
            info.cause = t.cause;
            info.info = t.info;
            info.ip = t.ip;
            getInfo();
        }
        public void subscribe(trap t)
        {
            t.del += new trap.myDelegate(notify);
        }
        public void getInfo()
        {
            Console.WriteLine("<Alert>: cauese/{0}, info/ {1}, ip/{2}, time/{3}",
                info.cause, info.info, info.ip,_occuredtime);
        }
    }
    class Program
    {
        static void Main(string[] args)
        {
            trap t = new trap();
            machine machineA = new machine();
            machineA.subscribe(t);
            t.run();
        }
    }

Aktualizacja 2013-08-12

Może obserwator / obserwowalny wzorzec projektowy, który wygląda świetnie w moim przypadku. (EventHandler) Super-prosty przykład C # observer/observable z delegatami

Korzyść:

• Nie obchodzi mnie już GetInvocationList (), wystarczy użyć ( + = ) i ( - = ), aby zdecydować, do kogo wysyłana jest pułapka.

• Łatwo zrozumieć logikę mojego programu.

Czytałem artykuł MSDN EventArgs, który sugeruje Matthew Watson system.eventargs

Oto moja wersja Wydarzenia:

public class TrapInfoEventArgs : EventArgs
{
    public int info { get; set; }
    public string  ip { get; set; }
    public string cause { get; set; }
}
public class trap
{
    public event EventHandler<TrapInfoEventArgs> TrapOccurred;

    protected virtual void OnTrapOccurred(TrapInfoEventArgs e)
    {
        EventHandler<TrapInfoEventArgs> handler = TrapOccurred;
        if (handler != null)
        {
            handler(this, e);
        }
    }


    public void run()
    {
        //While(true) 
        // If a trap occurred, notify the subscriber
        for (; ; )
        {
            Thread.Sleep(500);
            TrapInfoEventArgs args = new TrapInfoEventArgs();
            args.cause = "Shut Down";
            OnTrapOccurred(args);
        }
    }
}
public class machine
{
    public void c_TrapOccurred(object sender, TrapInfoEventArgs e)
    {
        Console.WriteLine("<Alert>: cauese/{0}, info/ {1}, ip/{2}, time/{3}",
            e.cause, e.info, e.ip, DateTime.Now.ToString());
    }
}
class Program
{
    static void Main(string[] args)
    {
        trap t = new trap();
        machine machineA = new machine();
        t.TrapOccurred += machineA.c_TrapOccurred; //notify machine A
        t.run();
    }
}