InfoQ Homepage News C# Futures: Static Delegates and Function Pointers

# C# Futures: Static Delegates and Function Pointers

This item in japanese

With each release of C#, it gains more low-level capabilities. While not useful to most business application developers, these features allow for high performance code suitable for graphics processing, machine learning, and mathematical packages.

In these next two proposals, we see new ways to reference and invoke functions.

Static Delegates

A normal delegate in C# is a somewhat complex data structure. It contains a function pointer, an optional object reference for the this parameter, and a link to a chained delegate. The whole structure is heap-allocated like any other reference type, with the corresponding memory pressure. Furthermore, whenever it is used with unmanaged code it needs to be marshalled.

Compared to a normal delegate, a “static delegate” is greatly simplified. It is implemented as a struct with one field, a function pointer of type IntPtr. This makes it blittable, which means it has exactly the same memory layout when used in managed and unmanaged code. Or in other words, marshalling isn’t required when calling a native system function.

It is declared using this syntax:

static delegate int Func()

Additional settings such as character set and calling convention can be specified using an attribute similar to the UnmanagedFunctionPointer attribute.

Static delegates are not without limitations. They can only refer to static functions; member methods on objects are not permitted because there is no place to store the pointer to the object. Furthermore, static delegates cannot be chained to other delegates.

At the CLR level, a static delegate is invoked using the calli (call indirect) instruction. By contrast, a normal delegate is invoked using the call or callvirt (call virtual) instruction.

In order to make it more compatible with existing code, an implicit conversion from a static delegate to a normal delegate would be allowed. Going the other direction would require an explicit cast, as not all normal delegates meet the requirements of a static delegate.

Function Pointers

A competing proposal is simply titled Function Pointers. This too exposes the ability to use the calli instruction and its partner, the ldftn (load method pointer) instruction. Like the previous proposal, it begins with a delegate declaration. Though in this case, the keyword delegate is replaced with funcptr.

funcptr int F1(int value);

When invoking a native function, the caller needs to know what the calling convention is. This affects things such as the order of items on the stack and whether the caller or callee is responsible for clearing the stack after use. The calling conventions covered by this proposal are cdecl, fastcall, stdcall, thiscall or winapi. The developer can specify which to use by modifying the delegate’s declaration:

funcptr cdecl int F1(int value);

In this proposal, function pointers would only be allowed in an unsafe context.

As part of this proposal you would be able to use the address-of operator (&) on a function’s name in order to create a function pointer. This too is only allowed to be used in an unsafe context.

The other restrictions on a function pointer are the same as a static delegate. Specifically, they can only refer to static functions and cannot be chained to other delegates.

Both proposals are under consideration and are not currently on the C# road map. A third proposal titled Compiler Intrinsics also competes with these two, but has additional limitations that make it less compelling.

Style

## Hello stranger!

You need to Register an InfoQ account or or login to post comments. But there's so much more behind being registered.

Get the most out of the InfoQ experience.

Allowed html: a,b,br,blockquote,i,li,pre,u,ul,p

• ##### Not quite as ugly as the other one

by Cameron Purdy /

• ##### Re: Not quite as ugly as the other one

by Jonathan Allen /

• ##### Not quite as ugly as the other one

Your message is awaiting moderation. Thank you for participating in the discussion.

This proposal makes a bit more sense. Introducing "funcptr" as a keyword is ugly as sin, but C# doesn't have "function" as a reserved word, so why not just use it? For example:

function Ordered (ElementType, ElementType) compare;

• ##### Re: Not quite as ugly as the other one

Your message is awaiting moderation. Thank you for participating in the discussion.

Maybe it's called that to scare away people who shouldn't be messing with it. I can't see a lot of people needing this and the ones who do are used to weird C naming conventions.

Allowed html: a,b,br,blockquote,i,li,pre,u,ul,p

Allowed html: a,b,br,blockquote,i,li,pre,u,ul,p

Is your profile up-to-date? Please take a moment to review and update.

Note: If updating/changing your email, a validation request will be sent

Company name:
Company role:
Company size:
Country/Zone:
State/Province/Region:
You will be sent an email to validate the new email address. This pop-up will close itself in a few moments.