[.Net] return type van een delegate

[Verwijderd]

Ik probeer een event te maken.

Ik heb op een main-form een print button die ik wil enablen als het rapport gegenereert is op een sub-form.
Het genereren van het rapport gebeurt op het sub-form. Als dit klaar is wil ik een event afvuren.
Dit moet opgevangen worden door het hoofdform, de print button kan enablen.

Bij het begin beginnen

public delegate bool IsReportReadyHandler();
public event IsReortReadyHandler IsReportReady ;

Welke informatie plaats je in het returntype van de delegate
en welke informatie plaats je in de parameter ?

[Verwijderd]

Er van uitgaande dat je C# gebruikt, dit is meestal hoe ik het oplos.
Het is welliswaar een console voorbeeld, maar het werkt ook in forms en je kan evt. de class afschieten naar een andere thread zodat je UI ook bereikbaar blijft.
Houd alleen in het achterhoofd dat je een cross thread exception kan krijgen als je niet controleert op 'InvokeRequired' en dit afhandelt natuurlijk.

Events.cs

C#:

namespace EventHandlerExample
{
    using System;

    public delegate void IsReportReadyHandler(object sender, ReportReadyEventArgs e);
    public delegate void StatusReportHandler(object sender, ReportStatusEventArgs e);

    public class Reporting
    {
        private IsReportReadyHandler OnReportIsReady;
        private StatusReportHandler OnStatusReport;

        public event IsReportReadyHandler IsReportReady
        {
            add
            {
                this.OnReportIsReady += value;
            }
            remove
            {
                this.OnReportIsReady -= value;
            }
        }
        public event StatusReportHandler CurrentStatus
        {
            add
            {
                this.OnStatusReport += value;
            }
            remove
            {
                this.OnStatusReport -= value;
            }
        }

        private void readyReport(object sender, ReportReadyEventArgs e)
        {
            if (this.OnReportIsReady != null) this.OnReportIsReady(sender, e);
        }

        private void ReadyReport(bool IsReady)
        {
            if (this.OnReportIsReady != null) this.OnReportIsReady(this, new ReportReadyEventArgs(IsReady));
        }

        private void statusReport(object sender, ReportStatusEventArgs e)
        {
            if (this.OnStatusReport != null) this.OnStatusReport(sender, e);
        }

        private void StatusReport(string Status)
        {
            if (this.OnStatusReport != null) this.OnStatusReport(this, new ReportStatusEventArgs(Status));
        }

        public void TimeConsumingMethod(int Count)
        {
            for (int i = 0; i < Count; i++)
            {
                StatusReport(string.Format("C = {0}", i));
                ReadyReport(false);
            }
            ReadyReport(true);
        }
    }

    public class ReportReadyEventArgs : EventArgs
    {
        public ReportReadyEventArgs(bool IsReportReady)
        {
            this.IsReportReady = IsReportReady;
        }
        public bool IsReportReady { get; private set; }
    }

    public class ReportStatusEventArgs : EventArgs
    {
        public ReportStatusEventArgs(string Status)
        {
            this.Status = Status;
        }
        public string Status { get; private set; }
    }
}

Program.cs

C#:

using System;

namespace EventHandlerExample
{
    class Program
    {
        static Reporting r;
        static void Main(string[] args)
        {
            r = new Reporting();
            r.IsReportReady += ReportingHandler;
            r.CurrentStatus += StatusReportHandler;
            r.TimeConsumingMethod(10);

            Console.ReadKey();
        }

        private static void ReportingHandler(object sender, ReportReadyEventArgs e)
        {
            Console.WriteLine(string.Format("Done? {0}", e.IsReportReady));
        }

        private static void StatusReportHandler(object sender, ReportStatusEventArgs e)
        {
            Console.WriteLine(e.Status);
        }
    }
}

Mocht er iets niet duidelijk zijn dan laat het mij weten!

[sig69]

Ik doe altijd gewoon:

C#:

public event EventHandler<SoortEventArgs> SomethingChanged = delegate{};

(code is misschien niet 100% correct)
En klaar, events gooien maar.

[Verwijderd]

Zou ook gewoon moeten werken in principe, is misschien zelfs ook beter in sommige gevallen.

[sig69]

Het is onderhuids hetzelfde, scheelt alleen wat type werk

[Verwijderd]

Ja, ik zag dat de generic type de eventargs exposed.
Scheelt een hoop type werk zo.

Zou er nog een goede reden zijn om de langere versie te gebruiken dan?

[sig69]

Nee

[Verwijderd]

Haha, duly noted, scheelt weer een hoop getik.

[Verwijderd]

Dank je voor het uitschrijven.
Ik programmeer in C#.

Ziet er duidelijk uit.

Nadat ze je delegates geleerd hebben en overgaan naar events willen ze inderdaad graag dat je dan het object en de eventargs meegeeft. Dus misschien moet ik daar maar meteen aan wennen.

De langere versie is voor mij op dit moment duidelijker.

Is de delegate van een event altijd void ?

[Verwijderd]

Nee dat hoeft niet, wat wel moet is dat de delegate en gebruikte method met elkaar overeenkomen.

Zie: MSDN: Calling Synchronous Methods Asynchronously

[farlane]

Verwijderd schreef op zaterdag 06 juni 2015 @ 23:54:
Is de delegate van een event altijd void ?

Probleem met een delegate als event die iets returned is : welke subscriber heeft dat gereturned en wat heb je er dan aan?

[Woy]

farlane schreef op maandag 08 juni 2015 @ 09:04:
[...]


Probleem met een delegate als event die iets returned is : welke subscriber heeft dat gereturned en wat heb je er dan aan?

Inderdaad, het is gebruikelijk om bij events ( en eigenlijk multicast delegates in het algemeen ) altijd void als return value te hebben.

Als er toch state terug gegeven moet worden aan de caller wordt er meestal gebruik gemaakt van de EventArgs ( zoals bijvoorbeeld CancelEventArgs waar een veld Cancel in zit die door de caller weer gebruikt wordt )

[Verwijderd]

Dank jullie wel.

Met het code voorbeeld is het gelukt en de uitleg erbij maakt het een stuk duidelijker.