User Tools

Site Tools



Why Delegates

Delegates are a new concept in the X# language - in VO they don't exist.

In every language there is sometimes the need to pass code as parameter to a function. VO has codeblocks, therefore normally you don't need function pointers, but pass codeblocks instead.

The only real use of function pointers in the VO language is the interface to Windows API functions or other DLL calls.

Since every pointer use can lead to serious problems when wrongly used, the .NET languages define another concept: the delegates. And therefore you should also use delegates when you need to dynamically call functions. Please see below in the PCall note for a link to a sample.

What is a Delegate

A delegate is a declaration of a datatype that defines how a method must be defined, or better, a delegate defines the number and types of parameters and the type of return value. Sometimes this is referred as signature, but the definitions of this term are not clear: sometimes the return value is part of the signature, sometimes not.

Every datatype in .NET is really a class, and therefore also the delegate declaration is a (special) class (inherited from System.Delegate or System.MulticastDelegate), that normally is defined outside of a class, but since .NET permits nested classes (a class that is visible only in another class), a delegate can also be declared inside a class declaration.

And it looks like this:

delegate IntDelegate( nParm as int ) as string

The second piece that you normally need to use a delegate (like using a class), is one or more variables of the type of the delegate:

local oDelegate as IntDelegate

and then you can assign a method to the delegate:

oDelegate := Execute1
oDelegate := Execute2
oDelegate := Execute3 // Compile error here, the signature does not matches
method Execute1( nParm as int ) as string
  return nParm:ToString()
method Execute2( nParm as int ) as string
  return nParm:ToString()
method Execute3( cParm as string ) as string
  return cParm

In most cases your work with the delegate will be finished here, as you pass the delegate variable to some other method.

But of course you can call the delegate also in your code:

oDelegate:Invoke( 1234 )
oDelegate:Invoke( "Hi" ) // Compile error here as your parameter does not matches the delegate declaration

Of course you can omit also the Invoke() call - the compiler will add it for you:

oDelegate( 789 )

Delegates can be also used in other cases: when you need to call a function in a dynamically loaded DLL. In VO we used the PCall() pseudo-function, in Vulcan also PCallNative(). For a sample please look here: PCall vs PCallNative

Please look also at this message in the X# forum by Chris Pyrgas:

Further informations

delegates.txt · Last modified: 2018/07/11 11:36 by wolfgangriedmann