The runtime supports constructs called delegates, which enable late-bound operations
such as method invocation and callback procedures. With delegates, a program can
dynamically call different methods at runtime. They are type safe, secure, managed
objects that always point to a valid object and cannot corrupt the memory of another
object. The closest equivalent of a delegate in other languages is a function pointer, but
whereas a function pointer can only reference Shared functions, a delegate can reference
both Shared and instance methods. Delegates are Marshal by Value Objects.
The members of a delegate are the members inherited from class System.Delegate.
A delegate defines the signature and return type of a method. The resulting delegate can
reference any method with a matching signature. Each instance of a delegate can forward
a call to one or more methods that take those parameters and return the same type. Once a
method has been assigned to a delegate, it is called when the delegate is invoked.

Example:
Module delegate_example
Delegate Function calculation(ByVal a As Integer, ByVal b As Integer) As
Integer
Public Function add(ByVal num1 As Integer, ByVal num2 As Integer) As Integer
add = num1 + num2
End Function
Sub Main()
Dim calc_delegate As New calculation(AddressOf add)
Dim result As Integer
result = calc_delegate(50, 70)
End Sub
End Module


Explanation:
Four steps are required to implement delegates viz.

• Defining Delegates
The foremost step is to define the delegate. The definition of the delegate specifies
the method signature, return type of the method, access modifier and the delegate
name. The method signature specifies the order and type of each argument.
The definition of a delegate is indicated by the usage of the Delegate keyword. As
shown in the above code segment, the delegate name is calculation, it's access
modifier is public, it receives two integer arguments and returns an integer value.

• Creating Delegate Method Handler(s)
The next step is to define the method(s) that will be associated with the delegate.
In the above code segment, a method named add is defined. This method must have
same method signature as that of the delegate, as shown in the above code segment.

• Hooking up Delegates and Method Handlers
For a delegate method handler to be invoked, it must be assigned to a delegate object.
In the above code, the delegate object is calc_delegate and is hooked up to the
method handler add.

• Invoking the method through the Delegate
The last step is to invoke the methods that are associated with the delegate. A
delegate method handler is invoked by making a method call on the delegate itself.
This causes the method handler to invoke with the assigned input parameters as if
they were invoked directly by the program, as shown in the above code.