How to define parameter names for higher order functions in C #

Question

In C #, you can create higher-order functions, i.e. functions gtake functions as arguments. Let's say I want to create a function that defines a function fand returns another function that extends its functionality. How to determine argument names for returned extended method? The motivation is that I work with higher-order methods in general, some of which create new methods .. and this can be difficult to use because parameter names are not attached to them, etc.

An example illustrating how gand faccordingly can be defined in C #:

I define an Extend method that can extend methods that take an argument Tas an argument and return S.

static class M
{
    public static Func< T, S> Extend(Func< T, S> functionToWrap)
    {
      return (someT) =>
      {
        ...
        var result = functionToWrap(someT);
        ...
        return result;
      };
    }
}

Then we can extend the method on our class without changing the method.

class Calc2
{
    public Func< int, int> Calc;
    public Calc2()
    {
      Calc = M.Extend< int, int>(CalcPriv);
    }
    private int CalcPriv(int positiveNumber)
    {
      if(positiveNumber < 0) throw new Exception(...);
      Console.WriteLine("calc " + i);
      return i++;
    }
}

Alas, the argument name is positiveNumberno longer available, as available information is available only Func<int, int> Calc. That is, when I use the advanced method by typing new Calc2().Calc(-1), I get no help from the IDE, which is actually my argument is incorrect.

It would be nice if we could define delegateand apply it to this, however this is not possible.

Any suggestions?

Answer 1

, :

Func :

public delegate TResult Func<in T, out TResult>(T arg)

, .

, . :

public static T Extend(T functionToWrap)
{
}

, , ( ). , , .

:

new MyFunc(Extend(f))

MyFunc .

:

public static T ConvertDelegate<T>(Delegate d)
{
    if (!(typeof(T).IsSubclassOf(typeof(Delegate))))
        throw new ArgumentException("T is no Delegate");
    if (d == null)
        throw new ArgumentNullException();
    MulticastDelegate md = d as MulticastDelegate;
    Delegate[] invList = null;
    int invCount = 1;
    if (md != null)
        invList = md.GetInvocationList();
    if (invList != null)
        invCount = invList.Length;
    if (invCount == 1)
    {
        return (T)(object)Delegate.CreateDelegate(typeof(T), d.Target, d.Method);
    }
    else
    {
        for (int i = 0; i < invList.Length; i++)
        {
            invList[i] = (Delegate)(object)ConvertDelegate<T>(invList[i]);
            }
            return (T)(object)MulticastDelegate.Combine(invList);
        }
    }

public static TDelegate Extend<TDelegate,TArg,TResult>(Func<TArg,TResult> functionToWrap)
where TDelegate:class
    {       
        Func<TArg,TResult> wrappedFunc= DoTheWrapping(functionToWrap);
        return ConvertDelegate<TDelegate>(wrappedFunc);
    }

BTW ConvertDelegate Co/Contravariance .net 4.

Answer 2

Func:

public delegate double CalcFunc(double value);

static class M
{
    public static Func<T, S> Extend<T,S>(Func<T, S> functionToWrap)
    {
      return (someT) => functionToWrap(someT);
    }
}

class Program
{
    private static double Calc(double input)
    {
        return 2*input;
    }

    [STAThread]
    static void Main()
    {
        Func<double, double> extended = M.Extend<double, double>(Calc);

        CalcFunc casted = (CalcFunc)Delegate.CreateDelegate(typeof(CalcFunc), extended.Target, extended.Method);
        Console.WriteLine(casted(2) + " == 4");
        Console.WriteLine("I didn't crash!");
        Console.ReadKey();
    }
}

---

: . , ( .NET 4).

Answer 3

; . Func , int int. , , , , , .

, , - Calc, , , CalcPriv. , , , Calc.

xml-doc Calc ///<summary></summary>, Calc, .

, Func<T,TResult> TakesPositiveInteger<T,TResult>. , ...