it-swarm.com.de

Warum kann ich keinen Delegaten in eine Benutzeroberfläche einfügen?

Warum kann ich meiner Benutzeroberfläche keinen Delegaten hinzufügen?

26
user73936

Sie können eine der folgenden verwenden:

public delegate double CustomerDelegate(int test);
public interface ITest
{
    EventHandler<EventArgs> MyHandler{get;set;}
    CustomerDelegate HandlerWithCustomDelegate { get; set; }
    event EventHandler<EventArgs> MyEvent;
}
32
eglasius

Ein Delegat ist nur ein anderer Typ, so dass Sie nichts gewinnen, wenn Sie ihn in die Benutzeroberfläche einfügen.

Sie sollten keine eigenen Delegierten erstellen müssen. Die meiste Zeit sollten Sie nur EventHandler, Func, Predicate oder Action verwenden.

Darf ich fragen, wie Ihr Delegierter aussieht?

23
Jonathan Allen

Ein Delegat ist ein Typ der nicht in einer Schnittstelle deklariert werden kann. Möglicherweise möchten Sie entweder ein Ereignis (falls zutreffend) verwenden oder einen Delegaten außerhalb der Schnittstelle, aber im gleichen Namespace deklarieren.

Dieser Link kann helfen- Wann werden Delegierte anstelle von Schnittstellen verwendet

7
cgreeno

dies ist eine Delegierte TYPE Dekalaration ...

public delegate returntype MyDelegateType (params)

dies kann nicht in einer Schnittstelle deklariert werden, da es sich um eine Typdeklaration handelt 

mit der obigen Typdeklaration KÖNNEN Sie jedoch eine Delegateninstanz verwenden 

MyDelegateType MyDelegateInstance ( get; set;)

delegateninstanzen sind also in Ordnung, Delegatentypdeklarationen jedoch nicht (in einer Schnittstelle)

6
Matt

In der Dokumentation heißt es eindeutig, dass Sie einen Delegierten in einer Schnittstelle definieren können:

Eine Schnittstelle enthält nur die Signaturen von Methoden, Delegaten oder Ereignissen.

MSDN: Schnittstelle (C # -Referenz)

In den Anmerkungen auf derselben Seite heißt es jedoch, dass eine Schnittstelle Signaturen von Methoden, Eigenschaften, Indexern und Ereignissen enthalten kann.

Wenn Sie versuchen, einen Delegaten in eine Schnittstelle einzufügen, sagt der Compiler, dass "Schnittstellen keine Typen deklarieren können".

Der Ecma-334-Standard (8.9 Interfaces) stimmt mit den Anmerkungen auf dieser Seite und dem Compiler überein.

4
Guffa

Wie bereits erwähnt, können Sie nur Delegates outside der Schnittstelle definieren.

Bei der Verwendung von Delegaten ist nichts falsch. Ich persönlich denke, dass Func<int, double> weniger wünschenswert ist als die Verwendung von Delegaten:

  1. Sie können die Argumente nicht benennen, daher kann die Argumentbedeutung mehrdeutig sein 
  2. Es ist eine alte Nachricht, dass Events nicht threadsicher sind, daher ist der folgende Code nicht ideal:

    if (MyFuncEvent != null)
    {
        MyFuncEvent(42, 42.42);
    }
    

    Siehe: http://kristofverbiest.blogspot.com/2006/08/better-way-to-raise-events.html

    Der sicherere Code lautet:

    MyFuncEventHandler handler = MyFuncEvent;
    if (handler != null)
    {
        handler(42, 42.42);
    }
    
  3. Sie müssen die Signatur des Ereignisses duplizieren, wenn Sie es in einer Variablen speichern möchten (oder Sie könnten var verwenden, was mir nicht gefällt). Wenn Sie viele Argumente haben, kann dies sehr langweilig werden (wiederum können Sie immer faul sein und var verwenden).

    Func<int, double, string, object, short, string, object> handler = MyFuncEvent;
    if (handler != null)
    {
        handler(42, 42.42, ...);
    }
    

Delegaten ersparen Ihnen, dass Sie die Signatur der Methode/des Ereignisses jedes Mal, wenn Sie sie einem Variablentyp zuordnen möchten, duplizieren müssen.

1
swooby

Eine Schnittstellenmethode kann einen Delegaten als Parameter akzeptieren, keine Probleme. (Vielleicht sehe ich das Problem nicht?) Wenn Sie jedoch beabsichtigen, einen abgehenden Anruf in der Benutzeroberfläche anzugeben, verwenden Sie ein Ereignis.

Es gibt so viele kleine Details, dass es viel einfacher ist, nur etwas Code zu zeigen, anstatt alles in Prosa zu beschreiben. (Sorry, auch das Codebeispiel ist etwas aufgebläht ...)

namespace DelegatesAndEvents
{
    public class MyEventArgs : EventArgs
    {
        public string Message { get; set; }
        public MyEventArgs(string message) { Message = message; }
    }

    delegate void TwoWayCallback(string message);
    delegate void TwoWayEventHandler(object sender, MyEventArgs eventArgs);

    interface ITwoWay
    {
        void CallThis(TwoWayCallback callback);

        void Trigger(string message);
        event TwoWayEventHandler TwoWayEvent;
    }

    class Talkative : ITwoWay
    {
        public void CallThis(TwoWayCallback callback)
        {
            callback("Delegate invoked.");
        }

        public void Trigger(string message)
        {
            TwoWayEvent.Invoke(this, new MyEventArgs(message));
        }

        public event TwoWayEventHandler TwoWayEvent;
    }

    class Program
    {
        public static void MyCallback(string message)
        {
            Console.WriteLine(message);
        }

        public static void OnMyEvent(object sender, MyEventArgs eventArgs)
        {
            Console.WriteLine(eventArgs.Message);
        }

        static void Main(string[] args)
        {
            Talkative talkative = new Talkative();

            talkative.CallThis(MyCallback);

            talkative.TwoWayEvent += new TwoWayEventHandler(OnMyEvent);
            talkative.Trigger("Event fired with this message.");

            Console.ReadKey();
        }
    }
}
0
Paul Williams