Champion "Static Delegates"

[tannergooding]

Superseded by https://github.com/dotnet/csharplang/blob/master/proposals/csharp-9.0/function-pointers.md

• Proposal added: proposals/static-delegates.md
• Discussed in LDM (https://github.com/dotnet/csharplang/blob/master/meetings/2017/LDM-2017-05-16.md#static-delegates)
• Decision in LDM
• Finalized (done, rejected, inactive)
• Spec'ed

[tannergooding]

FYI. @gafter. I think this one was skipped over after the proposal was merged. It is being championed by @jaredpar

[AlgorithmsAreCool]

@jaredpar I took a look at the proposal and maybe this is beyond my understanding, but if this is geared at interop i'm not really clear what the difference or synergy between this and an extern function is. Maybe that isn't even a sensible question...

[DavidArno]

Could you please add some examples of how this might be used, and it's limitations? For example, in the proposal, it's stated that "Static Delegates would not work with existing APIs that use regular delegates". I'm reading that as I couldn't use this to improve the performance of:

int Foo(int p, Func<int, int> f) => f(p);

But could static delegates be used to provide a better performing version of Foo? If so, what would the signature look like?

[tannergooding]

@AlgorithmsAreCool, think of this as a type of value delegate (in the same vein as ValueTuple compared to Tuple).

It can be used for interop, but it can also be used as a type of lightweight delegate.

[tannergooding]

@DavidArno. It wouldn't be useable as a drop in replacement in the same way that you can't just use ValueTuple anywhere that you can use Tuple. One always exists on the heap, and the other could potentially exist on the stack.

You could convert from one to the other, so it could be 'used', but it would incur the cost of the allocation/etc.

[AlgorithmsAreCool]

Could you provide a little code snippet showing the creation, passing (to a function) and invocation of a static delegate?

Also why is it "static". Wouldn't struct delegate be a better moniker?

[tannergooding]

static delegate was just the name @jaredpar gave them in the original issue: #80. But, as everyone knows, computer programming only has two hard problems ;)

NOTE: The LDM could decide to do this entirely differently, this is just how I imagine it 😄

As for declaration, I imagine exactly like a regular delegate, but prefixed with static:

static delegate T ValueFunc<T>();

static delegate IntPtr WNDPROC(
    [In] IntPtr hWnd,
    [In] uint uMsg,
    [In] IntPtr wParam,
    [In] IntPtr lParam
);

For creation, assignment, and passing, it would work just like a regular delegate:

• ValueFunc<int> valueFunc = Test;
• var result = valueFunc();

class TestClass
{
    ValueFunc<int> _valueFunc;

    public TestClass(ValueFunc<int> valueFunc)
    {
        _valueFunc = valueFunc;
    }
}

You could not do multiple assignment, so valueFunc += Method; and valueFunc -= Method; would result in a compilation error.

[AlgorithmsAreCool]

Ah, all is made clear. The static was throwing me off.

I like this and would use it.

[Joe4evr]

So reading Jared's main post on the subject in the other thread:

1. It can only bind to static methods.
2. Under the hood it is represented as a struct that has a single member of type IntPtr.

I guess this also precludes use as closures?

[tannergooding]

@Joe4evr. Possible, however just because it only binds to static methods, doesn't mean it can't access instance fields, it just means you would need to be explicit about passing in this.

Such as:

static delegate void ValueAction<T>(T obj);

public class MyClass
{
    private int _someField;

    public static void SomeMethod(MyClass @this)
    {
        Console.WriteLine(@this._someField);
    }

    public void Method1()
    {
        ValueAction<MyClass> x = SomeMethod;
        x(this);
    }
}

So lets take some code you might have today:

public class MyClass
{
    public void Method1()
    {
        int someLocal = 1;
        ValueAction x = static () => Console.WriteLine(someLocal);
        x();
    }
}

This gets translated (roughly) into:

public class MyClass
{
    [CompilerGenerated]
    private sealed class <>c__DisplayClass0_0
    {
        public int someLocal;

        internal void <Method1>b__0()
        {
            Console.WriteLine(someLocal);
        }
    }

    public void Method1()
    {
        var CS$<>8__locals0 = new <>c__DisplayClass0_0();
        CS$<>8__locals0.someLocal = 1;

        Action x = CS$<>8__locals0.<Method1>b__0;
        x();
    }
}

You then might imagine the same being supported with static delegates:

public class MyClass
{
    public void Method1()
    {
        int someLocal = 1;
        ValueAction x = static () => Console.WriteLine(someLocal);
        x();
    }
}

The hard part here, is that the user declares ValueAction, but in order to pass in the captured state we need ValueAction<T>. So, provided an answer is given for the required transformation here, it should be possible.

At least without delving too much into the finer details, I could imagine something like the following working:

static delegate void ValueAction();

public class MyClass
{
    [CompilerGenerated]
    private sealed class <>c__DisplayClass0_0
    {
        public static ThreadLocal<<>c__DisplayClass0_0> threadData;
        public int someLocal;

        internal static void <Method1>b__0()
        {
            var data = threadData.Value;
            Console.WriteLine(data.someLocal);
        }
    }

    public void Method1()
    {
        var CS$<>8__locals0 = new <>c__DisplayClass0_0();
        CS$<>8__locals0.someLocal = 1;

        ValueAction x = <>c__DisplayClass0_0.<Method1>b__0;
        <>c__DisplayClass0_0.threadData.Value = CS$<>8__locals0.someLocal;
        x();
    }
}

I think the primary issue with the above approach would be memory overhead for stray threads, but I honestly haven't put too much thought into it right now 😄