Delegate mit beliebigen Parametern

Gibt es in C# die Möglichkeit, Delegates zu deklarieren, die Funktionen unabhängig von ihrer Signatur entgegennehmen können?

Normalerweise macht man es ja so:

static class Program
{
    public delegate void FunktionOhneParameter();
    public delegate void FunktionMitParameter(int a, int b);

    public static void DelegatebenutzungOhneParameter(FunktionOhneParameter funktion)
    {
        funktion();
    }

    public static void DelegatebenutzungMitParameter(FunktionMitParameter funktion, int a, int b)
    {
        funktion(a, b);
    }

    public static void TestfunktionOhneParameter() { /* ... */ }
    public static void TestfunktionMitParameter(int a, int b) { /* ... */ }

    static void Main(string[] args)
    {
        DelegatebenutzungOhneParameter(TestfunktionOhneParameter);
        DelegatebenutzungMitParameter(TestfunktionMitParameter, 1, 2);
    }
}

Das, was ich suche, ist sowas hier in der Art:

static class Program
{
    public delegate void Funktion(...);

    public static void Delegatebenutzung(Funktion funktion)
    {
        funktion;
    }

    public static void TestfunktionOhneParameter() { /* ... */ }
    public static void TestfunktionMitParameter(int a, int b) { /* ... */ }

    static void Main(string[] args)
    {
        Delegatebenutzung(TestfunktionOhneParameter());
        Delegatebenutzung(TestfunktionMitParameter(1, 2));
    }
}

Ist sowas möglich, und wenn ja, wie?

Dravere

Gibt mehrere Möglichkeiten. Aber bei allen gibt es Nachteile, vor allem in der Performance.

1. Alle Delegates erben von System.Delegate . Diese bietet die Methode DynamicInvoke an.
2. Du kannst über Reflection an die Methode herankommen. Schau dir unteranderen dazu mal die Klasse MethodInfo an. Diese hat eine Invoke Methode, welche allerdings ein Objekt benötig, worauf sie aufgerufen wird.
3. Man kann sich auch selber etwas zum Problem passendes nachbauen, z.B. über Vererbung. Da kommt es aber auf die Problemstellung an und du müsstest uns mehr Informationen geben.

Grüssli

Das Problem besteht doch schon früher.

Hier hast Du die Parameter einfach weggelassen.

Bürp schrieb:

public static void Delegatebenutzung(Funktion funktion)
    {
        funktion;
    }

Stattdessen findet der Aufruf der Testfunktionen hier statt:

Bürp schrieb:

Delegatebenutzung(TestfunktionOhneParameter());
        Delegatebenutzung(TestfunktionMitParameter(1, 2));

Ich weiß, das war nur ein Beispiel. Aber Du müsstest bereits Delegatebenutzung für eine variable Parameterliste vorbereiten. Ich glaube Du suchst nach einer Lösung an der falschen Stelle. Wie würdest Du Dir denn den Aufruf eines Delegaten mit unbekannter Parameteranzahl und mit verschiedenen Parametertypen vorstellen?

Wenn Dir typsicherheit egal ist, kannst Du es so machen:

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;

namespace VarPar
{
    delegate void del1();
    delegate void del2(string s);

    class Program
    {
        static void test1()
        {
            Console.WriteLine("in test1");
        }

        static void test2(string s)
        {
            Console.WriteLine("in test2: " + s);
        }

        static void Main(string[] args)
        {
            del1 f1 = test1;
            Caller(f1);

            del2 f2 = test2;
            Caller(f2, "hallo");

            Console.ReadKey(true);
        }

        static void Caller(Delegate del, params object[] values)
        {
            del.DynamicInvoke(values);
        }
    }
}

Das ist natürlich Mist.

Andere Möglichkeit: .NET bietet eine Reihe an generischen Func- und Action-Delegaten. Trotzdem bist Du das Problem nicht los, den Aufruf der Delegaten variabel aber typsicher zu gestallten.

Ich schließe mich Dravere an: Bitte mehr Information was Du genau willst.