Private delegate void dldislay string s có nghĩa là gì năm 2024

Question

Upgrade to Microsoft Edge to take advantage of the latest features, security updates, and technical support.

Nội dung chính Show

System.Delegate.CreateDelegate methods
In this article
and methods
Compatible parameter types and return type
Determine the methods a delegate can represent

System.Delegate.CreateDelegate methods

Article
01/30/2024

method

This method overload is equivalent to calling the method overload and specifying true for

open System open System.Reflection // A sample class with an instance method and a static method. type C(id) =

member _.M1(s) =
    printfn $"Instance method M1 on C:  id = %i{id}, s = %s{s}"
static member M2(s) =
    printfn $"Static method M2 on C:  s = %s{s}"

// Declare three delegate types for demonstrating the combinations
// of static versus instance methods and open versus closed
// delegates.
type D1 = delegate of C * string -> unit
type D2 = delegate of string -> unit
type D3 = delegate of unit -> unit
let c1 = C 42
// Get a MethodInfo for each method.
//
let mi1 = typeof.GetMethod("M1", BindingFlags.Public ||| BindingFlags.Instance)
let mi2 = typeof.GetMethod("M2", BindingFlags.Public ||| BindingFlags.Static)
printfn "\nAn instance method closed over C."
// In this case, the delegate and the
// method must have the same list of argument types use
// delegate type D2 with instance method M1.
let test = Delegate.CreateDelegate(typeof, c1, mi1, false)
// Because false was specified for throwOnBindFailure
// in the call to CreateDelegate, the variable 'test'
// contains null if the method fails to bind (for
// example, if mi1 happened to represent a method of
// some class other than C).
if test <> null thenlet d2 = test :?> D2
// The same instance of C is used every time the
// delegate is invoked.
d2.Invoke "Hello, World!"
d2.Invoke "Hi, Mom!"
printfn "\nAn open instance method."
// In this case, the delegate has one more
// argument than the instance method this argument comes
// at the beginning, and represents the hidden instance
// argument of the instance method. Use delegate type D1
// with instance method M1.
let d1 = Delegate.CreateDelegate(typeof, null, mi1) :?> D1
// An instance of C must be passed in each time the
// delegate is invoked.
d1.Invoke(c1, "Hello, World!")
d1.Invoke(C 5280, "Hi, Mom!")
printfn "\nAn open static method."
// In this case, the delegate and the method must
// have the same list of argument types use delegate type
// D2 with static method M2.
let d2 = Delegate.CreateDelegate(typeof, null, mi2) :?> D2
// No instances of C are involved, because this is a static
// method.
d2.Invoke "Hello, World!"
d2.Invoke "Hi, Mom!"
printfn "\nA static method closed over the first argument (String)."
// The delegate must omit the first argument of the method.
// A string is passed as the firstArgument parameter, and
// the delegate is bound to this string. Use delegate type
// D3 with static method M2.
let d3 = Delegate.CreateDelegate(typeof, "Hello, World!", mi2) :?> D3
// Each time the delegate is invoked, the same string is used.
d3.Invoke()
// This code example produces the following output:
// An instance method closed over C.
// Instance method M1 on C: id = 42, s = Hello, World!
// Instance method M1 on C: id = 42, s = Hi, Mom!
//
// An open instance method.
// Instance method M1 on C: id = 42, s = Hello, World!
// Instance method M1 on C: id = 5280, s = Hi, Mom!
//
// An open static method.
// Static method M2 on C: s = Hello, World!
// Static method M2 on C: s = Hi, Mom!
//
// A static method closed over the first argument (String).
// Static method M2 on C: s = Hello, World!

0.

Examples

This section contains two code examples. The first example demonstrates the two kinds of delegates that can be created with this method overload: open over an instance method and open over a static method.

The second code example demonstrates compatible parameter types and return types.

Example 1

The following code example demonstrates the two ways a delegate can be created using this overload of the CreateDelegate method.

Note

There are two overloads of the CreateDelegate method that specify a MethodInfo but not a first argument; their functionality is the same except that one allows you to specify whether to throw on failure to bind, and the other always throws. This code example uses both overloads.

The example declares a class

open System open System.Reflection // A sample class with an instance method and a static method. type C(id) =

member _.M1(s) =
    printfn $"Instance method M1 on C:  id = %i{id}, s = %s{s}"
static member M2(s) =
    printfn $"Static method M2 on C:  s = %s{s}"

// Declare three delegate types for demonstrating the combinations
// of static versus instance methods and open versus closed
// delegates.
type D1 = delegate of C * string -> unit
type D2 = delegate of string -> unit
type D3 = delegate of unit -> unit
let c1 = C 42
// Get a MethodInfo for each method.
//
let mi1 = typeof.GetMethod("M1", BindingFlags.Public ||| BindingFlags.Instance)
let mi2 = typeof.GetMethod("M2", BindingFlags.Public ||| BindingFlags.Static)
printfn "\nAn instance method closed over C."
// In this case, the delegate and the
// method must have the same list of argument types use
// delegate type D2 with instance method M1.
let test = Delegate.CreateDelegate(typeof, c1, mi1, false)
// Because false was specified for throwOnBindFailure
// in the call to CreateDelegate, the variable 'test'
// contains null if the method fails to bind (for
// example, if mi1 happened to represent a method of
// some class other than C).
if test <> null thenlet d2 = test :?> D2
// The same instance of C is used every time the
// delegate is invoked.
d2.Invoke "Hello, World!"
d2.Invoke "Hi, Mom!"
printfn "\nAn open instance method."
// In this case, the delegate has one more
// argument than the instance method this argument comes
// at the beginning, and represents the hidden instance
// argument of the instance method. Use delegate type D1
// with instance method M1.
let d1 = Delegate.CreateDelegate(typeof, null, mi1) :?> D1
// An instance of C must be passed in each time the
// delegate is invoked.
d1.Invoke(c1, "Hello, World!")
d1.Invoke(C 5280, "Hi, Mom!")
printfn "\nAn open static method."
// In this case, the delegate and the method must
// have the same list of argument types use delegate type
// D2 with static method M2.
let d2 = Delegate.CreateDelegate(typeof, null, mi2) :?> D2
// No instances of C are involved, because this is a static
// method.
d2.Invoke "Hello, World!"
d2.Invoke "Hi, Mom!"
printfn "\nA static method closed over the first argument (String)."
// The delegate must omit the first argument of the method.
// A string is passed as the firstArgument parameter, and
// the delegate is bound to this string. Use delegate type
// D3 with static method M2.
let d3 = Delegate.CreateDelegate(typeof, "Hello, World!", mi2) :?> D3
// Each time the delegate is invoked, the same string is used.
d3.Invoke()
// This code example produces the following output:
// An instance method closed over C.
// Instance method M1 on C: id = 42, s = Hello, World!
// Instance method M1 on C: id = 42, s = Hi, Mom!
//
// An open instance method.
// Instance method M1 on C: id = 42, s = Hello, World!
// Instance method M1 on C: id = 5280, s = Hi, Mom!
//
// An open static method.
// Static method M2 on C: s = Hello, World!
// Static method M2 on C: s = Hi, Mom!
//
// A static method closed over the first argument (String).
// Static method M2 on C: s = Hello, World!

1 with a static method

open System open System.Reflection // A sample class with an instance method and a static method. type C(id) =

member _.M1(s) =
    printfn $"Instance method M1 on C:  id = %i{id}, s = %s{s}"
static member M2(s) =
    printfn $"Static method M2 on C:  s = %s{s}"

// Declare three delegate types for demonstrating the combinations
// of static versus instance methods and open versus closed
// delegates.
type D1 = delegate of C * string -> unit
type D2 = delegate of string -> unit
type D3 = delegate of unit -> unit
let c1 = C 42
// Get a MethodInfo for each method.
//
let mi1 = typeof.GetMethod("M1", BindingFlags.Public ||| BindingFlags.Instance)
let mi2 = typeof.GetMethod("M2", BindingFlags.Public ||| BindingFlags.Static)
printfn "\nAn instance method closed over C."
// In this case, the delegate and the
// method must have the same list of argument types use
// delegate type D2 with instance method M1.
let test = Delegate.CreateDelegate(typeof, c1, mi1, false)
// Because false was specified for throwOnBindFailure
// in the call to CreateDelegate, the variable 'test'
// contains null if the method fails to bind (for
// example, if mi1 happened to represent a method of
// some class other than C).
if test <> null thenlet d2 = test :?> D2
// The same instance of C is used every time the
// delegate is invoked.
d2.Invoke "Hello, World!"
d2.Invoke "Hi, Mom!"
printfn "\nAn open instance method."
// In this case, the delegate has one more
// argument than the instance method this argument comes
// at the beginning, and represents the hidden instance
// argument of the instance method. Use delegate type D1
// with instance method M1.
let d1 = Delegate.CreateDelegate(typeof, null, mi1) :?> D1
// An instance of C must be passed in each time the
// delegate is invoked.
d1.Invoke(c1, "Hello, World!")
d1.Invoke(C 5280, "Hi, Mom!")
printfn "\nAn open static method."
// In this case, the delegate and the method must
// have the same list of argument types use delegate type
// D2 with static method M2.
let d2 = Delegate.CreateDelegate(typeof, null, mi2) :?> D2
// No instances of C are involved, because this is a static
// method.
d2.Invoke "Hello, World!"
d2.Invoke "Hi, Mom!"
printfn "\nA static method closed over the first argument (String)."
// The delegate must omit the first argument of the method.
// A string is passed as the firstArgument parameter, and
// the delegate is bound to this string. Use delegate type
// D3 with static method M2.
let d3 = Delegate.CreateDelegate(typeof, "Hello, World!", mi2) :?> D3
// Each time the delegate is invoked, the same string is used.
d3.Invoke()
// This code example produces the following output:
// An instance method closed over C.
// Instance method M1 on C: id = 42, s = Hello, World!
// Instance method M1 on C: id = 42, s = Hi, Mom!
//
// An open instance method.
// Instance method M1 on C: id = 42, s = Hello, World!
// Instance method M1 on C: id = 5280, s = Hi, Mom!
//
// An open static method.
// Static method M2 on C: s = Hello, World!
// Static method M2 on C: s = Hi, Mom!
//
// A static method closed over the first argument (String).
// Static method M2 on C: s = Hello, World!

2 and an instance method

open System open System.Reflection // A sample class with an instance method and a static method. type C(id) =

member _.M1(s) =
    printfn $"Instance method M1 on C:  id = %i{id}, s = %s{s}"
static member M2(s) =
    printfn $"Static method M2 on C:  s = %s{s}"

// Declare three delegate types for demonstrating the combinations
// of static versus instance methods and open versus closed
// delegates.
type D1 = delegate of C * string -> unit
type D2 = delegate of string -> unit
type D3 = delegate of unit -> unit
let c1 = C 42
// Get a MethodInfo for each method.
//
let mi1 = typeof.GetMethod("M1", BindingFlags.Public ||| BindingFlags.Instance)
let mi2 = typeof.GetMethod("M2", BindingFlags.Public ||| BindingFlags.Static)
printfn "\nAn instance method closed over C."
// In this case, the delegate and the
// method must have the same list of argument types use
// delegate type D2 with instance method M1.
let test = Delegate.CreateDelegate(typeof, c1, mi1, false)
// Because false was specified for throwOnBindFailure
// in the call to CreateDelegate, the variable 'test'
// contains null if the method fails to bind (for
// example, if mi1 happened to represent a method of
// some class other than C).
if test <> null thenlet d2 = test :?> D2
// The same instance of C is used every time the
// delegate is invoked.
d2.Invoke "Hello, World!"
d2.Invoke "Hi, Mom!"
printfn "\nAn open instance method."
// In this case, the delegate has one more
// argument than the instance method this argument comes
// at the beginning, and represents the hidden instance
// argument of the instance method. Use delegate type D1
// with instance method M1.
let d1 = Delegate.CreateDelegate(typeof, null, mi1) :?> D1
// An instance of C must be passed in each time the
// delegate is invoked.
d1.Invoke(c1, "Hello, World!")
d1.Invoke(C 5280, "Hi, Mom!")
printfn "\nAn open static method."
// In this case, the delegate and the method must
// have the same list of argument types use delegate type
// D2 with static method M2.
let d2 = Delegate.CreateDelegate(typeof, null, mi2) :?> D2
// No instances of C are involved, because this is a static
// method.
d2.Invoke "Hello, World!"
d2.Invoke "Hi, Mom!"
printfn "\nA static method closed over the first argument (String)."
// The delegate must omit the first argument of the method.
// A string is passed as the firstArgument parameter, and
// the delegate is bound to this string. Use delegate type
// D3 with static method M2.
let d3 = Delegate.CreateDelegate(typeof, "Hello, World!", mi2) :?> D3
// Each time the delegate is invoked, the same string is used.
d3.Invoke()
// This code example produces the following output:
// An instance method closed over C.
// Instance method M1 on C: id = 42, s = Hello, World!
// Instance method M1 on C: id = 42, s = Hi, Mom!
//
// An open instance method.
// Instance method M1 on C: id = 42, s = Hello, World!
// Instance method M1 on C: id = 5280, s = Hi, Mom!
//
// An open static method.
// Static method M2 on C: s = Hello, World!
// Static method M2 on C: s = Hi, Mom!
//
// A static method closed over the first argument (String).
// Static method M2 on C: s = Hello, World!

3, and two delegate types:

open System open System.Reflection // A sample class with an instance method and a static method. type C(id) =

member _.M1(s) =
    printfn $"Instance method M1 on C:  id = %i{id}, s = %s{s}"
static member M2(s) =
    printfn $"Static method M2 on C:  s = %s{s}"

// Declare three delegate types for demonstrating the combinations
// of static versus instance methods and open versus closed
// delegates.
type D1 = delegate of C * string -> unit
type D2 = delegate of string -> unit
type D3 = delegate of unit -> unit
let c1 = C 42
// Get a MethodInfo for each method.
//
let mi1 = typeof.GetMethod("M1", BindingFlags.Public ||| BindingFlags.Instance)
let mi2 = typeof.GetMethod("M2", BindingFlags.Public ||| BindingFlags.Static)
printfn "\nAn instance method closed over C."
// In this case, the delegate and the
// method must have the same list of argument types use
// delegate type D2 with instance method M1.
let test = Delegate.CreateDelegate(typeof, c1, mi1, false)
// Because false was specified for throwOnBindFailure
// in the call to CreateDelegate, the variable 'test'
// contains null if the method fails to bind (for
// example, if mi1 happened to represent a method of
// some class other than C).
if test <> null thenlet d2 = test :?> D2
// The same instance of C is used every time the
// delegate is invoked.
d2.Invoke "Hello, World!"
d2.Invoke "Hi, Mom!"
printfn "\nAn open instance method."
// In this case, the delegate has one more
// argument than the instance method this argument comes
// at the beginning, and represents the hidden instance
// argument of the instance method. Use delegate type D1
// with instance method M1.
let d1 = Delegate.CreateDelegate(typeof, null, mi1) :?> D1
// An instance of C must be passed in each time the
// delegate is invoked.
d1.Invoke(c1, "Hello, World!")
d1.Invoke(C 5280, "Hi, Mom!")
printfn "\nAn open static method."
// In this case, the delegate and the method must
// have the same list of argument types use delegate type
// D2 with static method M2.
let d2 = Delegate.CreateDelegate(typeof, null, mi2) :?> D2
// No instances of C are involved, because this is a static
// method.
d2.Invoke "Hello, World!"
d2.Invoke "Hi, Mom!"
printfn "\nA static method closed over the first argument (String)."
// The delegate must omit the first argument of the method.
// A string is passed as the firstArgument parameter, and
// the delegate is bound to this string. Use delegate type
// D3 with static method M2.
let d3 = Delegate.CreateDelegate(typeof, "Hello, World!", mi2) :?> D3
// Each time the delegate is invoked, the same string is used.
d3.Invoke()
// This code example produces the following output:
// An instance method closed over C.
// Instance method M1 on C: id = 42, s = Hello, World!
// Instance method M1 on C: id = 42, s = Hi, Mom!
//
// An open instance method.
// Instance method M1 on C: id = 42, s = Hello, World!
// Instance method M1 on C: id = 5280, s = Hi, Mom!
//
// An open static method.
// Static method M2 on C: s = Hello, World!
// Static method M2 on C: s = Hi, Mom!
//
// A static method closed over the first argument (String).
// Static method M2 on C: s = Hello, World!

4 takes an instance of

open System open System.Reflection // A sample class with an instance method and a static method. type C(id) =

member _.M1(s) =
    printfn $"Instance method M1 on C:  id = %i{id}, s = %s{s}"
static member M2(s) =
    printfn $"Static method M2 on C:  s = %s{s}"

// Declare three delegate types for demonstrating the combinations
// of static versus instance methods and open versus closed
// delegates.
type D1 = delegate of C * string -> unit
type D2 = delegate of string -> unit
type D3 = delegate of unit -> unit
let c1 = C 42
// Get a MethodInfo for each method.
//
let mi1 = typeof.GetMethod("M1", BindingFlags.Public ||| BindingFlags.Instance)
let mi2 = typeof.GetMethod("M2", BindingFlags.Public ||| BindingFlags.Static)
printfn "\nAn instance method closed over C."
// In this case, the delegate and the
// method must have the same list of argument types use
// delegate type D2 with instance method M1.
let test = Delegate.CreateDelegate(typeof, c1, mi1, false)
// Because false was specified for throwOnBindFailure
// in the call to CreateDelegate, the variable 'test'
// contains null if the method fails to bind (for
// example, if mi1 happened to represent a method of
// some class other than C).
if test <> null thenlet d2 = test :?> D2
// The same instance of C is used every time the
// delegate is invoked.
d2.Invoke "Hello, World!"
d2.Invoke "Hi, Mom!"
printfn "\nAn open instance method."
// In this case, the delegate has one more
// argument than the instance method this argument comes
// at the beginning, and represents the hidden instance
// argument of the instance method. Use delegate type D1
// with instance method M1.
let d1 = Delegate.CreateDelegate(typeof, null, mi1) :?> D1
// An instance of C must be passed in each time the
// delegate is invoked.
d1.Invoke(c1, "Hello, World!")
d1.Invoke(C 5280, "Hi, Mom!")
printfn "\nAn open static method."
// In this case, the delegate and the method must
// have the same list of argument types use delegate type
// D2 with static method M2.
let d2 = Delegate.CreateDelegate(typeof, null, mi2) :?> D2
// No instances of C are involved, because this is a static
// method.
d2.Invoke "Hello, World!"
d2.Invoke "Hi, Mom!"
printfn "\nA static method closed over the first argument (String)."
// The delegate must omit the first argument of the method.
// A string is passed as the firstArgument parameter, and
// the delegate is bound to this string. Use delegate type
// D3 with static method M2.
let d3 = Delegate.CreateDelegate(typeof, "Hello, World!", mi2) :?> D3
// Each time the delegate is invoked, the same string is used.
d3.Invoke()
// This code example produces the following output:
// An instance method closed over C.
// Instance method M1 on C: id = 42, s = Hello, World!
// Instance method M1 on C: id = 42, s = Hi, Mom!
//
// An open instance method.
// Instance method M1 on C: id = 42, s = Hello, World!
// Instance method M1 on C: id = 5280, s = Hi, Mom!
//
// An open static method.
// Static method M2 on C: s = Hello, World!
// Static method M2 on C: s = Hi, Mom!
//
// A static method closed over the first argument (String).
// Static method M2 on C: s = Hello, World!

1 and a string, and

open System open System.Reflection // A sample class with an instance method and a static method. type C(id) =

member _.M1(s) =
    printfn $"Instance method M1 on C:  id = %i{id}, s = %s{s}"
static member M2(s) =
    printfn $"Static method M2 on C:  s = %s{s}"

// Declare three delegate types for demonstrating the combinations
// of static versus instance methods and open versus closed
// delegates.
type D1 = delegate of C * string -> unit
type D2 = delegate of string -> unit
type D3 = delegate of unit -> unit
let c1 = C 42
// Get a MethodInfo for each method.
//
let mi1 = typeof.GetMethod("M1", BindingFlags.Public ||| BindingFlags.Instance)
let mi2 = typeof.GetMethod("M2", BindingFlags.Public ||| BindingFlags.Static)
printfn "\nAn instance method closed over C."
// In this case, the delegate and the
// method must have the same list of argument types use
// delegate type D2 with instance method M1.
let test = Delegate.CreateDelegate(typeof, c1, mi1, false)
// Because false was specified for throwOnBindFailure
// in the call to CreateDelegate, the variable 'test'
// contains null if the method fails to bind (for
// example, if mi1 happened to represent a method of
// some class other than C).
if test <> null thenlet d2 = test :?> D2
// The same instance of C is used every time the
// delegate is invoked.
d2.Invoke "Hello, World!"
d2.Invoke "Hi, Mom!"
printfn "\nAn open instance method."
// In this case, the delegate has one more
// argument than the instance method this argument comes
// at the beginning, and represents the hidden instance
// argument of the instance method. Use delegate type D1
// with instance method M1.
let d1 = Delegate.CreateDelegate(typeof, null, mi1) :?> D1
// An instance of C must be passed in each time the
// delegate is invoked.
d1.Invoke(c1, "Hello, World!")
d1.Invoke(C 5280, "Hi, Mom!")
printfn "\nAn open static method."
// In this case, the delegate and the method must
// have the same list of argument types use delegate type
// D2 with static method M2.
let d2 = Delegate.CreateDelegate(typeof, null, mi2) :?> D2
// No instances of C are involved, because this is a static
// method.
d2.Invoke "Hello, World!"
d2.Invoke "Hi, Mom!"
printfn "\nA static method closed over the first argument (String)."
// The delegate must omit the first argument of the method.
// A string is passed as the firstArgument parameter, and
// the delegate is bound to this string. Use delegate type
// D3 with static method M2.
let d3 = Delegate.CreateDelegate(typeof, "Hello, World!", mi2) :?> D3
// Each time the delegate is invoked, the same string is used.
d3.Invoke()
// This code example produces the following output:
// An instance method closed over C.
// Instance method M1 on C: id = 42, s = Hello, World!
// Instance method M1 on C: id = 42, s = Hi, Mom!
//
// An open instance method.
// Instance method M1 on C: id = 42, s = Hello, World!
// Instance method M1 on C: id = 5280, s = Hi, Mom!
//
// An open static method.
// Static method M2 on C: s = Hello, World!
// Static method M2 on C: s = Hi, Mom!
//
// A static method closed over the first argument (String).
// Static method M2 on C: s = Hello, World!

6 takes a string.

A second class named

open System open System.Reflection // A sample class with an instance method and a static method. type C(id) =

member _.M1(s) =
    printfn $"Instance method M1 on C:  id = %i{id}, s = %s{s}"
static member M2(s) =
    printfn $"Static method M2 on C:  s = %s{s}"

// Declare three delegate types for demonstrating the combinations
// of static versus instance methods and open versus closed
// delegates.
type D1 = delegate of C * string -> unit
type D2 = delegate of string -> unit
type D3 = delegate of unit -> unit
let c1 = C 42
// Get a MethodInfo for each method.
//
let mi1 = typeof.GetMethod("M1", BindingFlags.Public ||| BindingFlags.Instance)
let mi2 = typeof.GetMethod("M2", BindingFlags.Public ||| BindingFlags.Static)
printfn "\nAn instance method closed over C."
// In this case, the delegate and the
// method must have the same list of argument types use
// delegate type D2 with instance method M1.
let test = Delegate.CreateDelegate(typeof, c1, mi1, false)
// Because false was specified for throwOnBindFailure
// in the call to CreateDelegate, the variable 'test'
// contains null if the method fails to bind (for
// example, if mi1 happened to represent a method of
// some class other than C).
if test <> null thenlet d2 = test :?> D2
// The same instance of C is used every time the
// delegate is invoked.
d2.Invoke "Hello, World!"
d2.Invoke "Hi, Mom!"
printfn "\nAn open instance method."
// In this case, the delegate has one more
// argument than the instance method this argument comes
// at the beginning, and represents the hidden instance
// argument of the instance method. Use delegate type D1
// with instance method M1.
let d1 = Delegate.CreateDelegate(typeof, null, mi1) :?> D1
// An instance of C must be passed in each time the
// delegate is invoked.
d1.Invoke(c1, "Hello, World!")
d1.Invoke(C 5280, "Hi, Mom!")
printfn "\nAn open static method."
// In this case, the delegate and the method must
// have the same list of argument types use delegate type
// D2 with static method M2.
let d2 = Delegate.CreateDelegate(typeof, null, mi2) :?> D2
// No instances of C are involved, because this is a static
// method.
d2.Invoke "Hello, World!"
d2.Invoke "Hi, Mom!"
printfn "\nA static method closed over the first argument (String)."
// The delegate must omit the first argument of the method.
// A string is passed as the firstArgument parameter, and
// the delegate is bound to this string. Use delegate type
// D3 with static method M2.
let d3 = Delegate.CreateDelegate(typeof, "Hello, World!", mi2) :?> D3
// Each time the delegate is invoked, the same string is used.
d3.Invoke()
// This code example produces the following output:
// An instance method closed over C.
// Instance method M1 on C: id = 42, s = Hello, World!
// Instance method M1 on C: id = 42, s = Hi, Mom!
//
// An open instance method.
// Instance method M1 on C: id = 42, s = Hello, World!
// Instance method M1 on C: id = 5280, s = Hi, Mom!
//
// An open static method.
// Static method M2 on C: s = Hello, World!
// Static method M2 on C: s = Hi, Mom!
//
// A static method closed over the first argument (String).
// Static method M2 on C: s = Hello, World!

7 contains the code that creates the delegates.

A delegate of type open System open System.Reflection // A sample class with an instance method and a static method. type C(id) = member _.M1(s) = printfn $"Instance method M1 on C: id = %i{id}, s = %s{s}" static member M2(s) = printfn $"Static method M2 on C: s = %s{s}" // Declare three delegate types for demonstrating the combinations // of static versus instance methods and open versus closed // delegates. type D1 = delegate of C * string -> unit type D2 = delegate of string -> unit type D3 = delegate of unit -> unit let c1 = C 42 // Get a MethodInfo for each method. // let mi1 = typeof.GetMethod("M1", BindingFlags.Public ||| BindingFlags.Instance) let mi2 = typeof.GetMethod("M2", BindingFlags.Public ||| BindingFlags.Static) printfn "\nAn instance method closed over C." // In this case, the delegate and the // method must have the same list of argument types use // delegate type D2 with instance method M1. let test = Delegate.CreateDelegate(typeof, c1, mi1, false) // Because false was specified for throwOnBindFailure // in the call to CreateDelegate, the variable 'test' // contains null if the method fails to bind (for // example, if mi1 happened to represent a method of // some class other than C). if test <> null then let d2 = test :?> D2 // The same instance of C is used every time the // delegate is invoked. d2.Invoke "Hello, World!" d2.Invoke "Hi, Mom!" printfn "\nAn open instance method." // In this case, the delegate has one more // argument than the instance method this argument comes // at the beginning, and represents the hidden instance // argument of the instance method. Use delegate type D1 // with instance method M1. let d1 = Delegate.CreateDelegate(typeof, null, mi1) :?> D1 // An instance of C must be passed in each time the // delegate is invoked. d1.Invoke(c1, "Hello, World!") d1.Invoke(C 5280, "Hi, Mom!") printfn "\nAn open static method." // In this case, the delegate and the method must // have the same list of argument types use delegate type // D2 with static method M2. let d2 = Delegate.CreateDelegate(typeof, null, mi2) :?> D2 // No instances of C are involved, because this is a static // method. d2.Invoke "Hello, World!" d2.Invoke "Hi, Mom!" printfn "\nA static method closed over the first argument (String)." // The delegate must omit the first argument of the method. // A string is passed as the firstArgument parameter, and // the delegate is bound to this string. Use delegate type // D3 with static method M2. let d3 = Delegate.CreateDelegate(typeof, "Hello, World!", mi2) :?> D3 // Each time the delegate is invoked, the same string is used. d3.Invoke() // This code example produces the following output: // An instance method closed over C. // Instance method M1 on C: id = 42, s = Hello, World! // Instance method M1 on C: id = 42, s = Hi, Mom! // // An open instance method. // Instance method M1 on C: id = 42, s = Hello, World! // Instance method M1 on C: id = 5280, s = Hi, Mom! // // An open static method. // Static method M2 on C: s = Hello, World! // Static method M2 on C: s = Hi, Mom! // // A static method closed over the first argument (String). // Static method M2 on C: s = Hello, World!
4, representing an open instance method, is created for the instance method
open System open System.Reflection // A sample class with an instance method and a static method. type C(id) = member _.M1(s) = printfn $"Instance method M1 on C: id = %i{id}, s = %s{s}" static member M2(s) = printfn $"Static method M2 on C: s = %s{s}" // Declare three delegate types for demonstrating the combinations // of static versus instance methods and open versus closed // delegates. type D1 = delegate of C * string -> unit type D2 = delegate of string -> unit type D3 = delegate of unit -> unit let c1 = C 42 // Get a MethodInfo for each method. // let mi1 = typeof.GetMethod("M1", BindingFlags.Public ||| BindingFlags.Instance) let mi2 = typeof.GetMethod("M2", BindingFlags.Public ||| BindingFlags.Static) printfn "\nAn instance method closed over C." // In this case, the delegate and the // method must have the same list of argument types use // delegate type D2 with instance method M1. let test = Delegate.CreateDelegate(typeof, c1, mi1, false) // Because false was specified for throwOnBindFailure // in the call to CreateDelegate, the variable 'test' // contains null if the method fails to bind (for // example, if mi1 happened to represent a method of // some class other than C). if test <> null then let d2 = test :?> D2 // The same instance of C is used every time the // delegate is invoked. d2.Invoke "Hello, World!" d2.Invoke "Hi, Mom!" printfn "\nAn open instance method." // In this case, the delegate has one more // argument than the instance method this argument comes // at the beginning, and represents the hidden instance // argument of the instance method. Use delegate type D1 // with instance method M1. let d1 = Delegate.CreateDelegate(typeof, null, mi1) :?> D1 // An instance of C must be passed in each time the // delegate is invoked. d1.Invoke(c1, "Hello, World!") d1.Invoke(C 5280, "Hi, Mom!") printfn "\nAn open static method." // In this case, the delegate and the method must // have the same list of argument types use delegate type // D2 with static method M2. let d2 = Delegate.CreateDelegate(typeof, null, mi2) :?> D2 // No instances of C are involved, because this is a static // method. d2.Invoke "Hello, World!" d2.Invoke "Hi, Mom!" printfn "\nA static method closed over the first argument (String)." // The delegate must omit the first argument of the method. // A string is passed as the firstArgument parameter, and // the delegate is bound to this string. Use delegate type // D3 with static method M2. let d3 = Delegate.CreateDelegate(typeof, "Hello, World!", mi2) :?> D3 // Each time the delegate is invoked, the same string is used. d3.Invoke() // This code example produces the following output: // An instance method closed over C. // Instance method M1 on C: id = 42, s = Hello, World! // Instance method M1 on C: id = 42, s = Hi, Mom! // // An open instance method. // Instance method M1 on C: id = 42, s = Hello, World! // Instance method M1 on C: id = 5280, s = Hi, Mom! // // An open static method. // Static method M2 on C: s = Hello, World! // Static method M2 on C: s = Hi, Mom! // // A static method closed over the first argument (String). // Static method M2 on C: s = Hello, World! 3. An instance must be passed when the delegate is invoked.
A delegate of type open System open System.Reflection // A sample class with an instance method and a static method. type C(id) = member _.M1(s) = printfn $"Instance method M1 on C: id = %i{id}, s = %s{s}" static member M2(s) = printfn $"Static method M2 on C: s = %s{s}" // Declare three delegate types for demonstrating the combinations // of static versus instance methods and open versus closed // delegates. type D1 = delegate of C * string -> unit type D2 = delegate of string -> unit type D3 = delegate of unit -> unit let c1 = C 42 // Get a MethodInfo for each method. // let mi1 = typeof.GetMethod("M1", BindingFlags.Public ||| BindingFlags.Instance) let mi2 = typeof.GetMethod("M2", BindingFlags.Public ||| BindingFlags.Static) printfn "\nAn instance method closed over C." // In this case, the delegate and the // method must have the same list of argument types use // delegate type D2 with instance method M1. let test = Delegate.CreateDelegate(typeof, c1, mi1, false) // Because false was specified for throwOnBindFailure // in the call to CreateDelegate, the variable 'test' // contains null if the method fails to bind (for // example, if mi1 happened to represent a method of // some class other than C). if test <> null then let d2 = test :?> D2 // The same instance of C is used every time the // delegate is invoked. d2.Invoke "Hello, World!" d2.Invoke "Hi, Mom!" printfn "\nAn open instance method." // In this case, the delegate has one more // argument than the instance method this argument comes // at the beginning, and represents the hidden instance // argument of the instance method. Use delegate type D1 // with instance method M1. let d1 = Delegate.CreateDelegate(typeof, null, mi1) :?> D1 // An instance of C must be passed in each time the // delegate is invoked. d1.Invoke(c1, "Hello, World!") d1.Invoke(C 5280, "Hi, Mom!") printfn "\nAn open static method." // In this case, the delegate and the method must // have the same list of argument types use delegate type // D2 with static method M2. let d2 = Delegate.CreateDelegate(typeof, null, mi2) :?> D2 // No instances of C are involved, because this is a static // method. d2.Invoke "Hello, World!" d2.Invoke "Hi, Mom!" printfn "\nA static method closed over the first argument (String)." // The delegate must omit the first argument of the method. // A string is passed as the firstArgument parameter, and // the delegate is bound to this string. Use delegate type // D3 with static method M2. let d3 = Delegate.CreateDelegate(typeof, "Hello, World!", mi2) :?> D3 // Each time the delegate is invoked, the same string is used. d3.Invoke() // This code example produces the following output: // An instance method closed over C. // Instance method M1 on C: id = 42, s = Hello, World! // Instance method M1 on C: id = 42, s = Hi, Mom! // // An open instance method. // Instance method M1 on C: id = 42, s = Hello, World! // Instance method M1 on C: id = 5280, s = Hi, Mom! // // An open static method. // Static method M2 on C: s = Hello, World! // Static method M2 on C: s = Hi, Mom! // // A static method closed over the first argument (String). // Static method M2 on C: s = Hello, World!
6, representing an open static method, is created for the static method
open System open System.Reflection // A sample class with an instance method and a static method. type C(id) = member _.M1(s) = printfn $"Instance method M1 on C: id = %i{id}, s = %s{s}" static member M2(s) = printfn $"Static method M2 on C: s = %s{s}" // Declare three delegate types for demonstrating the combinations // of static versus instance methods and open versus closed // delegates. type D1 = delegate of C * string -> unit type D2 = delegate of string -> unit type D3 = delegate of unit -> unit let c1 = C 42 // Get a MethodInfo for each method. // let mi1 = typeof.GetMethod("M1", BindingFlags.Public ||| BindingFlags.Instance) let mi2 = typeof.GetMethod("M2", BindingFlags.Public ||| BindingFlags.Static) printfn "\nAn instance method closed over C." // In this case, the delegate and the // method must have the same list of argument types use // delegate type D2 with instance method M1. let test = Delegate.CreateDelegate(typeof, c1, mi1, false) // Because false was specified for throwOnBindFailure // in the call to CreateDelegate, the variable 'test' // contains null if the method fails to bind (for // example, if mi1 happened to represent a method of // some class other than C). if test <> null then let d2 = test :?> D2 // The same instance of C is used every time the // delegate is invoked. d2.Invoke "Hello, World!" d2.Invoke "Hi, Mom!" printfn "\nAn open instance method." // In this case, the delegate has one more // argument than the instance method this argument comes // at the beginning, and represents the hidden instance // argument of the instance method. Use delegate type D1 // with instance method M1. let d1 = Delegate.CreateDelegate(typeof, null, mi1) :?> D1 // An instance of C must be passed in each time the // delegate is invoked. d1.Invoke(c1, "Hello, World!") d1.Invoke(C 5280, "Hi, Mom!") printfn "\nAn open static method." // In this case, the delegate and the method must // have the same list of argument types use delegate type // D2 with static method M2. let d2 = Delegate.CreateDelegate(typeof, null, mi2) :?> D2 // No instances of C are involved, because this is a static // method. d2.Invoke "Hello, World!" d2.Invoke "Hi, Mom!" printfn "\nA static method closed over the first argument (String)." // The delegate must omit the first argument of the method. // A string is passed as the firstArgument parameter, and // the delegate is bound to this string. Use delegate type // D3 with static method M2. let d3 = Delegate.CreateDelegate(typeof, "Hello, World!", mi2) :?> D3 // Each time the delegate is invoked, the same string is used. d3.Invoke() // This code example produces the following output: // An instance method closed over C. // Instance method M1 on C: id = 42, s = Hello, World! // Instance method M1 on C: id = 42, s = Hi, Mom! // // An open instance method. // Instance method M1 on C: id = 42, s = Hello, World! // Instance method M1 on C: id = 5280, s = Hi, Mom! // // An open static method. // Static method M2 on C: s = Hello, World! // Static method M2 on C: s = Hi, Mom! // // A static method closed over the first argument (String). // Static method M2 on C: s = Hello, World! 2.

using System; using System.Reflection; // Declare three delegate types for demonstrating the combinations // of static versus instance methods and open versus closed // delegates. // public delegate void D1(C c, string s); public delegate void D2(string s); public delegate void D3(); // A sample class with an instance method and a static method. // public class C {

private int id;
public C(int id) { this.id = id; }
public void M1(string s)
{
    Console.WriteLine("Instance method M1 on C:  id = {0}, s = {1}",
        this.id, s);
}
public static void M2(string s)
{
    Console.WriteLine("Static method M2 on C:  s = {0}", s);
}

}
public class Example2
{public static void Main()
{
    C c1 = new C(42);
    // Get a MethodInfo for each method.
    //
    MethodInfo mi1 = typeof(C).GetMethod("M1",
        BindingFlags.Public | BindingFlags.Instance);
    MethodInfo mi2 = typeof(C).GetMethod("M2",
        BindingFlags.Public | BindingFlags.Static);
    D1 d1;
    D2 d2;
    D3 d3;
    Console.WriteLine("\nAn instance method closed over C.");
    // In this case, the delegate and the
    // method must have the same list of argument types; use
    // delegate type D2 with instance method M1.
    //
    Delegate test =
        Delegate.CreateDelegate(typeof(D2), c1, mi1, false);
    // Because false was specified for throwOnBindFailure
    // in the call to CreateDelegate, the variable 'test'
    // contains null if the method fails to bind (for
    // example, if mi1 happened to represent a method of
    // some class other than C).
    //
    if (test != null)
    {
        d2 = (D2)test;
        // The same instance of C is used every time the
        // delegate is invoked.
        d2("Hello, World!");
        d2("Hi, Mom!");
    }
    Console.WriteLine("\nAn open instance method.");
    // In this case, the delegate has one more
    // argument than the instance method; this argument comes
    // at the beginning, and represents the hidden instance
    // argument of the instance method. Use delegate type D1
    // with instance method M1.
    //
    d1 = (D1)Delegate.CreateDelegate(typeof(D1), null, mi1);
    // An instance of C must be passed in each time the
    // delegate is invoked.
    //
    d1(c1, "Hello, World!");
    d1(new C(5280), "Hi, Mom!");
    Console.WriteLine("\nAn open static method.");
    // In this case, the delegate and the method must
    // have the same list of argument types; use delegate type
    // D2 with static method M2.
    //
    d2 = (D2)Delegate.CreateDelegate(typeof(D2), null, mi2);
    // No instances of C are involved, because this is a static
    // method.
    //
    d2("Hello, World!");
    d2("Hi, Mom!");
    Console.WriteLine("\nA static method closed over the first argument (String).");
    // The delegate must omit the first argument of the method.
    // A string is passed as the firstArgument parameter, and
    // the delegate is bound to this string. Use delegate type
    // D3 with static method M2.
    //
    d3 = (D3)Delegate.CreateDelegate(typeof(D3),
        "Hello, World!", mi2);
    // Each time the delegate is invoked, the same string is
    // used.
    d3();
}
}
/ This code example produces the following output:
An instance method closed over C.
Instance method M1 on C: id = 42, s = Hello, World!
Instance method M1 on C: id = 42, s = Hi, Mom!
An open instance method.
Instance method M1 on C: id = 42, s = Hello, World!
Instance method M1 on C: id = 5280, s = Hi, Mom!
An open static method.
Static method M2 on C: s = Hello, World!
Static method M2 on C: s = Hi, Mom!
A static method closed over the first argument (String).
Static method M2 on C: s = Hello, World!
/

open System open System.Reflection // A sample class with an instance method and a static method. type C(id) =

member _.M1(s) =
    printfn $"Instance method M1 on C:  id = %i{id}, s = %s{s}"
static member M2(s) =
    printfn $"Static method M2 on C:  s = %s{s}"

// Declare three delegate types for demonstrating the combinations
// of static versus instance methods and open versus closed
// delegates.
type D1 = delegate of C * string -> unit
type D2 = delegate of string -> unit
type D3 = delegate of unit -> unit
let c1 = C 42
// Get a MethodInfo for each method.
//
let mi1 = typeof.GetMethod("M1", BindingFlags.Public ||| BindingFlags.Instance)
let mi2 = typeof.GetMethod("M2", BindingFlags.Public ||| BindingFlags.Static)
printfn "\nAn instance method closed over C."
// In this case, the delegate and the
// method must have the same list of argument types use
// delegate type D2 with instance method M1.
let test = Delegate.CreateDelegate(typeof, c1, mi1, false)
// Because false was specified for throwOnBindFailure
// in the call to CreateDelegate, the variable 'test'
// contains null if the method fails to bind (for
// example, if mi1 happened to represent a method of
// some class other than C).
if test <> null thenlet d2 = test :?> D2
// The same instance of C is used every time the
// delegate is invoked.
d2.Invoke "Hello, World!"
d2.Invoke "Hi, Mom!"
printfn "\nAn open instance method."
// In this case, the delegate has one more
// argument than the instance method this argument comes
// at the beginning, and represents the hidden instance
// argument of the instance method. Use delegate type D1
// with instance method M1.
let d1 = Delegate.CreateDelegate(typeof, null, mi1) :?> D1
// An instance of C must be passed in each time the
// delegate is invoked.
d1.Invoke(c1, "Hello, World!")
d1.Invoke(C 5280, "Hi, Mom!")
printfn "\nAn open static method."
// In this case, the delegate and the method must
// have the same list of argument types use delegate type
// D2 with static method M2.
let d2 = Delegate.CreateDelegate(typeof, null, mi2) :?> D2
// No instances of C are involved, because this is a static
// method.
d2.Invoke "Hello, World!"
d2.Invoke "Hi, Mom!"
printfn "\nA static method closed over the first argument (String)."
// The delegate must omit the first argument of the method.
// A string is passed as the firstArgument parameter, and
// the delegate is bound to this string. Use delegate type
// D3 with static method M2.
let d3 = Delegate.CreateDelegate(typeof, "Hello, World!", mi2) :?> D3
// Each time the delegate is invoked, the same string is used.
d3.Invoke()
// This code example produces the following output:
// An instance method closed over C.
// Instance method M1 on C: id = 42, s = Hello, World!
// Instance method M1 on C: id = 42, s = Hi, Mom!
//
// An open instance method.
// Instance method M1 on C: id = 42, s = Hello, World!
// Instance method M1 on C: id = 5280, s = Hi, Mom!
//
// An open static method.
// Static method M2 on C: s = Hello, World!
// Static method M2 on C: s = Hi, Mom!
//
// A static method closed over the first argument (String).
// Static method M2 on C: s = Hello, World!

Imports System.Reflection Imports System.Security.Permissions ' Declare three delegate types for demonstrating the combinations ' of Shared versus instance methods and open versus closed ' delegates. ' Public Delegate Sub D1(ByVal c As C2, ByVal s As String) Public Delegate Sub D2(ByVal s As String) Public Delegate Sub D3() ' A sample class with an instance method and a Shared method. ' Public Class C2

Private id As Integer
Public Sub New(ByVal id As Integer)
    Me.id = id
End Sub
Public Sub M1(ByVal s As String)
    Console.WriteLine("Instance method M1 on C2:  id = {0}, s = {1}",
        Me.id, s)
End Sub
Public Shared Sub M2(ByVal s As String)
    Console.WriteLine("Shared method M2 on C2:  s = {0}", s)
End Sub

End Class
Public Class Example2Public Shared Sub Main()
    Dim c1 As New C2(42)
    ' Get a MethodInfo for each method.
    '
    Dim mi1 As MethodInfo = GetType(C2).GetMethod("M1",
        BindingFlags.Public Or BindingFlags.Instance)
    Dim mi2 As MethodInfo = GetType(C2).GetMethod("M2",
        BindingFlags.Public Or BindingFlags.Static)
    Dim d1 As D1
    Dim d2 As D2
    Dim d3 As D3
    Console.WriteLine(vbLf & "An instance method closed over C2.")
    ' In this case, the delegate and the
    ' method must have the same list of argument types; use
    ' delegate type D2 with instance method M1.
    '
    Dim test As [Delegate] =
        [Delegate].CreateDelegate(GetType(D2), c1, mi1, False)
    ' Because False was specified for throwOnBindFailure 
    ' in the call to CreateDelegate, the variable 'test'
    ' contains Nothing if the method fails to bind (for 
    ' example, if mi1 happened to represent a method of 
    ' some class other than C2).
    '
    If test IsNot Nothing Then
        d2 = CType(test, D2)
        ' The same instance of C2 is used every time the
        ' delegate is invoked.
        d2("Hello, World!")
        d2("Hi, Mom!")
    End If
    Console.WriteLine(vbLf & "An open instance method.")
    ' In this case, the delegate has one more 
    ' argument than the instance method; this argument comes
    ' at the beginning, and represents the hidden instance
    ' argument of the instance method. Use delegate type D1
    ' with instance method M1.
    '
    d1 = CType([Delegate].CreateDelegate(GetType(D1), Nothing, mi1), D1)
    ' An instance of C2 must be passed in each time the 
    ' delegate is invoked.
    '
    d1(c1, "Hello, World!")
    d1(New C2(5280), "Hi, Mom!")
    Console.WriteLine(vbLf & "An open Shared method.")
    ' In this case, the delegate and the method must 
    ' have the same list of argument types; use delegate type
    ' D2 with Shared method M2.
    '
    d2 = CType([Delegate].CreateDelegate(GetType(D2), Nothing, mi2), D2)
    ' No instances of C2 are involved, because this is a Shared
    ' method. 
    '
    d2("Hello, World!")
    d2("Hi, Mom!")
    Console.WriteLine(vbLf & "A Shared method closed over the first argument (String).")
    ' The delegate must omit the first argument of the method.
    ' A string is passed as the firstArgument parameter, and 
    ' the delegate is bound to this string. Use delegate type 
    ' D3 with Shared method M2. 
    '
    d3 = CType([Delegate].CreateDelegate(GetType(D3), "Hello, World!", mi2), D3)
    ' Each time the delegate is invoked, the same string is
    ' used.
    d3()
End Sub
End Class
' This code example produces the following output:
'
'An instance method closed over C2.
'Instance method M1 on C2: id = 42, s = Hello, World!
'Instance method M1 on C2: id = 42, s = Hi, Mom!
'
'An open instance method.
'Instance method M1 on C2: id = 42, s = Hello, World!
'Instance method M1 on C2: id = 5280, s = Hi, Mom!
'
'An open Shared method.
'Shared method M2 on C2: s = Hello, World!
'Shared method M2 on C2: s = Hi, Mom!
'
'A Shared method closed over the first argument (String).
'Shared method M2 on C2: s = Hello, World!
'

Example 2

The following code example demonstrates compatibility of parameter types and return types.

The code example defines a base class named

Imports System.Reflection Imports System.Security.Permissions ' Declare three delegate types for demonstrating the combinations ' of Shared versus instance methods and open versus closed ' delegates. ' Public Delegate Sub D1(ByVal c As C2, ByVal s As String) Public Delegate Sub D2(ByVal s As String) Public Delegate Sub D3() ' A sample class with an instance method and a Shared method. ' Public Class C2

Private id As Integer
Public Sub New(ByVal id As Integer)
    Me.id = id
End Sub
Public Sub M1(ByVal s As String)
    Console.WriteLine("Instance method M1 on C2:  id = {0}, s = {1}",
        Me.id, s)
End Sub
Public Shared Sub M2(ByVal s As String)
    Console.WriteLine("Shared method M2 on C2:  s = {0}", s)
End Sub

End Class
Public Class Example2Public Shared Sub Main()
    Dim c1 As New C2(42)
    ' Get a MethodInfo for each method.
    '
    Dim mi1 As MethodInfo = GetType(C2).GetMethod("M1",
        BindingFlags.Public Or BindingFlags.Instance)
    Dim mi2 As MethodInfo = GetType(C2).GetMethod("M2",
        BindingFlags.Public Or BindingFlags.Static)
    Dim d1 As D1
    Dim d2 As D2
    Dim d3 As D3
    Console.WriteLine(vbLf & "An instance method closed over C2.")
    ' In this case, the delegate and the
    ' method must have the same list of argument types; use
    ' delegate type D2 with instance method M1.
    '
    Dim test As [Delegate] =
        [Delegate].CreateDelegate(GetType(D2), c1, mi1, False)
    ' Because False was specified for throwOnBindFailure 
    ' in the call to CreateDelegate, the variable 'test'
    ' contains Nothing if the method fails to bind (for 
    ' example, if mi1 happened to represent a method of 
    ' some class other than C2).
    '
    If test IsNot Nothing Then
        d2 = CType(test, D2)
        ' The same instance of C2 is used every time the
        ' delegate is invoked.
        d2("Hello, World!")
        d2("Hi, Mom!")
    End If
    Console.WriteLine(vbLf & "An open instance method.")
    ' In this case, the delegate has one more 
    ' argument than the instance method; this argument comes
    ' at the beginning, and represents the hidden instance
    ' argument of the instance method. Use delegate type D1
    ' with instance method M1.
    '
    d1 = CType([Delegate].CreateDelegate(GetType(D1), Nothing, mi1), D1)
    ' An instance of C2 must be passed in each time the 
    ' delegate is invoked.
    '
    d1(c1, "Hello, World!")
    d1(New C2(5280), "Hi, Mom!")
    Console.WriteLine(vbLf & "An open Shared method.")
    ' In this case, the delegate and the method must 
    ' have the same list of argument types; use delegate type
    ' D2 with Shared method M2.
    '
    d2 = CType([Delegate].CreateDelegate(GetType(D2), Nothing, mi2), D2)
    ' No instances of C2 are involved, because this is a Shared
    ' method. 
    '
    d2("Hello, World!")
    d2("Hi, Mom!")
    Console.WriteLine(vbLf & "A Shared method closed over the first argument (String).")
    ' The delegate must omit the first argument of the method.
    ' A string is passed as the firstArgument parameter, and 
    ' the delegate is bound to this string. Use delegate type 
    ' D3 with Shared method M2. 
    '
    d3 = CType([Delegate].CreateDelegate(GetType(D3), "Hello, World!", mi2), D3)
    ' Each time the delegate is invoked, the same string is
    ' used.
    d3()
End Sub
End Class
' This code example produces the following output:
'
'An instance method closed over C2.
'Instance method M1 on C2: id = 42, s = Hello, World!
'Instance method M1 on C2: id = 42, s = Hi, Mom!
'
'An open instance method.
'Instance method M1 on C2: id = 42, s = Hello, World!
'Instance method M1 on C2: id = 5280, s = Hi, Mom!
'
'An open Shared method.
'Shared method M2 on C2: s = Hello, World!
'Shared method M2 on C2: s = Hi, Mom!
'
'A Shared method closed over the first argument (String).
'Shared method M2 on C2: s = Hello, World!
'

2 and a class named

Imports System.Reflection Imports System.Security.Permissions ' Declare three delegate types for demonstrating the combinations ' of Shared versus instance methods and open versus closed ' delegates. ' Public Delegate Sub D1(ByVal c As C2, ByVal s As String) Public Delegate Sub D2(ByVal s As String) Public Delegate Sub D3() ' A sample class with an instance method and a Shared method. ' Public Class C2

Private id As Integer
Public Sub New(ByVal id As Integer)
    Me.id = id
End Sub
Public Sub M1(ByVal s As String)
    Console.WriteLine("Instance method M1 on C2:  id = {0}, s = {1}",
        Me.id, s)
End Sub
Public Shared Sub M2(ByVal s As String)
    Console.WriteLine("Shared method M2 on C2:  s = {0}", s)
End Sub

End Class
Public Class Example2Public Shared Sub Main()
    Dim c1 As New C2(42)
    ' Get a MethodInfo for each method.
    '
    Dim mi1 As MethodInfo = GetType(C2).GetMethod("M1",
        BindingFlags.Public Or BindingFlags.Instance)
    Dim mi2 As MethodInfo = GetType(C2).GetMethod("M2",
        BindingFlags.Public Or BindingFlags.Static)
    Dim d1 As D1
    Dim d2 As D2
    Dim d3 As D3
    Console.WriteLine(vbLf & "An instance method closed over C2.")
    ' In this case, the delegate and the
    ' method must have the same list of argument types; use
    ' delegate type D2 with instance method M1.
    '
    Dim test As [Delegate] =
        [Delegate].CreateDelegate(GetType(D2), c1, mi1, False)
    ' Because False was specified for throwOnBindFailure 
    ' in the call to CreateDelegate, the variable 'test'
    ' contains Nothing if the method fails to bind (for 
    ' example, if mi1 happened to represent a method of 
    ' some class other than C2).
    '
    If test IsNot Nothing Then
        d2 = CType(test, D2)
        ' The same instance of C2 is used every time the
        ' delegate is invoked.
        d2("Hello, World!")
        d2("Hi, Mom!")
    End If
    Console.WriteLine(vbLf & "An open instance method.")
    ' In this case, the delegate has one more 
    ' argument than the instance method; this argument comes
    ' at the beginning, and represents the hidden instance
    ' argument of the instance method. Use delegate type D1
    ' with instance method M1.
    '
    d1 = CType([Delegate].CreateDelegate(GetType(D1), Nothing, mi1), D1)
    ' An instance of C2 must be passed in each time the 
    ' delegate is invoked.
    '
    d1(c1, "Hello, World!")
    d1(New C2(5280), "Hi, Mom!")
    Console.WriteLine(vbLf & "An open Shared method.")
    ' In this case, the delegate and the method must 
    ' have the same list of argument types; use delegate type
    ' D2 with Shared method M2.
    '
    d2 = CType([Delegate].CreateDelegate(GetType(D2), Nothing, mi2), D2)
    ' No instances of C2 are involved, because this is a Shared
    ' method. 
    '
    d2("Hello, World!")
    d2("Hi, Mom!")
    Console.WriteLine(vbLf & "A Shared method closed over the first argument (String).")
    ' The delegate must omit the first argument of the method.
    ' A string is passed as the firstArgument parameter, and 
    ' the delegate is bound to this string. Use delegate type 
    ' D3 with Shared method M2. 
    '
    d3 = CType([Delegate].CreateDelegate(GetType(D3), "Hello, World!", mi2), D3)
    ' Each time the delegate is invoked, the same string is
    ' used.
    d3()
End Sub
End Class
' This code example produces the following output:
'
'An instance method closed over C2.
'Instance method M1 on C2: id = 42, s = Hello, World!
'Instance method M1 on C2: id = 42, s = Hi, Mom!
'
'An open instance method.
'Instance method M1 on C2: id = 42, s = Hello, World!
'Instance method M1 on C2: id = 5280, s = Hi, Mom!
'
'An open Shared method.
'Shared method M2 on C2: s = Hello, World!
'Shared method M2 on C2: s = Hi, Mom!
'
'A Shared method closed over the first argument (String).
'Shared method M2 on C2: s = Hello, World!
'

3 that derives from

Imports System.Reflection Imports System.Security.Permissions ' Declare three delegate types for demonstrating the combinations ' of Shared versus instance methods and open versus closed ' delegates. ' Public Delegate Sub D1(ByVal c As C2, ByVal s As String) Public Delegate Sub D2(ByVal s As String) Public Delegate Sub D3() ' A sample class with an instance method and a Shared method. ' Public Class C2

Private id As Integer
Public Sub New(ByVal id As Integer)
    Me.id = id
End Sub
Public Sub M1(ByVal s As String)
    Console.WriteLine("Instance method M1 on C2:  id = {0}, s = {1}",
        Me.id, s)
End Sub
Public Shared Sub M2(ByVal s As String)
    Console.WriteLine("Shared method M2 on C2:  s = {0}", s)
End Sub

End Class
Public Class Example2Public Shared Sub Main()
    Dim c1 As New C2(42)
    ' Get a MethodInfo for each method.
    '
    Dim mi1 As MethodInfo = GetType(C2).GetMethod("M1",
        BindingFlags.Public Or BindingFlags.Instance)
    Dim mi2 As MethodInfo = GetType(C2).GetMethod("M2",
        BindingFlags.Public Or BindingFlags.Static)
    Dim d1 As D1
    Dim d2 As D2
    Dim d3 As D3
    Console.WriteLine(vbLf & "An instance method closed over C2.")
    ' In this case, the delegate and the
    ' method must have the same list of argument types; use
    ' delegate type D2 with instance method M1.
    '
    Dim test As [Delegate] =
        [Delegate].CreateDelegate(GetType(D2), c1, mi1, False)
    ' Because False was specified for throwOnBindFailure 
    ' in the call to CreateDelegate, the variable 'test'
    ' contains Nothing if the method fails to bind (for 
    ' example, if mi1 happened to represent a method of 
    ' some class other than C2).
    '
    If test IsNot Nothing Then
        d2 = CType(test, D2)
        ' The same instance of C2 is used every time the
        ' delegate is invoked.
        d2("Hello, World!")
        d2("Hi, Mom!")
    End If
    Console.WriteLine(vbLf & "An open instance method.")
    ' In this case, the delegate has one more 
    ' argument than the instance method; this argument comes
    ' at the beginning, and represents the hidden instance
    ' argument of the instance method. Use delegate type D1
    ' with instance method M1.
    '
    d1 = CType([Delegate].CreateDelegate(GetType(D1), Nothing, mi1), D1)
    ' An instance of C2 must be passed in each time the 
    ' delegate is invoked.
    '
    d1(c1, "Hello, World!")
    d1(New C2(5280), "Hi, Mom!")
    Console.WriteLine(vbLf & "An open Shared method.")
    ' In this case, the delegate and the method must 
    ' have the same list of argument types; use delegate type
    ' D2 with Shared method M2.
    '
    d2 = CType([Delegate].CreateDelegate(GetType(D2), Nothing, mi2), D2)
    ' No instances of C2 are involved, because this is a Shared
    ' method. 
    '
    d2("Hello, World!")
    d2("Hi, Mom!")
    Console.WriteLine(vbLf & "A Shared method closed over the first argument (String).")
    ' The delegate must omit the first argument of the method.
    ' A string is passed as the firstArgument parameter, and 
    ' the delegate is bound to this string. Use delegate type 
    ' D3 with Shared method M2. 
    '
    d3 = CType([Delegate].CreateDelegate(GetType(D3), "Hello, World!", mi2), D3)
    ' Each time the delegate is invoked, the same string is
    ' used.
    d3()
End Sub
End Class
' This code example produces the following output:
'
'An instance method closed over C2.
'Instance method M1 on C2: id = 42, s = Hello, World!
'Instance method M1 on C2: id = 42, s = Hi, Mom!
'
'An open instance method.
'Instance method M1 on C2: id = 42, s = Hello, World!
'Instance method M1 on C2: id = 5280, s = Hi, Mom!
'
'An open Shared method.
'Shared method M2 on C2: s = Hello, World!
'Shared method M2 on C2: s = Hi, Mom!
'
'A Shared method closed over the first argument (String).
'Shared method M2 on C2: s = Hello, World!
'

2. The derived class has a

Imports System.Reflection Imports System.Security.Permissions ' Declare three delegate types for demonstrating the combinations ' of Shared versus instance methods and open versus closed ' delegates. ' Public Delegate Sub D1(ByVal c As C2, ByVal s As String) Public Delegate Sub D2(ByVal s As String) Public Delegate Sub D3() ' A sample class with an instance method and a Shared method. ' Public Class C2

Private id As Integer
Public Sub New(ByVal id As Integer)
    Me.id = id
End Sub
Public Sub M1(ByVal s As String)
    Console.WriteLine("Instance method M1 on C2:  id = {0}, s = {1}",
        Me.id, s)
End Sub
Public Shared Sub M2(ByVal s As String)
    Console.WriteLine("Shared method M2 on C2:  s = {0}", s)
End Sub

End Class
Public Class Example2Public Shared Sub Main()
    Dim c1 As New C2(42)
    ' Get a MethodInfo for each method.
    '
    Dim mi1 As MethodInfo = GetType(C2).GetMethod("M1",
        BindingFlags.Public Or BindingFlags.Instance)
    Dim mi2 As MethodInfo = GetType(C2).GetMethod("M2",
        BindingFlags.Public Or BindingFlags.Static)
    Dim d1 As D1
    Dim d2 As D2
    Dim d3 As D3
    Console.WriteLine(vbLf & "An instance method closed over C2.")
    ' In this case, the delegate and the
    ' method must have the same list of argument types; use
    ' delegate type D2 with instance method M1.
    '
    Dim test As [Delegate] =
        [Delegate].CreateDelegate(GetType(D2), c1, mi1, False)
    ' Because False was specified for throwOnBindFailure 
    ' in the call to CreateDelegate, the variable 'test'
    ' contains Nothing if the method fails to bind (for 
    ' example, if mi1 happened to represent a method of 
    ' some class other than C2).
    '
    If test IsNot Nothing Then
        d2 = CType(test, D2)
        ' The same instance of C2 is used every time the
        ' delegate is invoked.
        d2("Hello, World!")
        d2("Hi, Mom!")
    End If
    Console.WriteLine(vbLf & "An open instance method.")
    ' In this case, the delegate has one more 
    ' argument than the instance method; this argument comes
    ' at the beginning, and represents the hidden instance
    ' argument of the instance method. Use delegate type D1
    ' with instance method M1.
    '
    d1 = CType([Delegate].CreateDelegate(GetType(D1), Nothing, mi1), D1)
    ' An instance of C2 must be passed in each time the 
    ' delegate is invoked.
    '
    d1(c1, "Hello, World!")
    d1(New C2(5280), "Hi, Mom!")
    Console.WriteLine(vbLf & "An open Shared method.")
    ' In this case, the delegate and the method must 
    ' have the same list of argument types; use delegate type
    ' D2 with Shared method M2.
    '
    d2 = CType([Delegate].CreateDelegate(GetType(D2), Nothing, mi2), D2)
    ' No instances of C2 are involved, because this is a Shared
    ' method. 
    '
    d2("Hello, World!")
    d2("Hi, Mom!")
    Console.WriteLine(vbLf & "A Shared method closed over the first argument (String).")
    ' The delegate must omit the first argument of the method.
    ' A string is passed as the firstArgument parameter, and 
    ' the delegate is bound to this string. Use delegate type 
    ' D3 with Shared method M2. 
    '
    d3 = CType([Delegate].CreateDelegate(GetType(D3), "Hello, World!", mi2), D3)
    ' Each time the delegate is invoked, the same string is
    ' used.
    d3()
End Sub
End Class
' This code example produces the following output:
'
'An instance method closed over C2.
'Instance method M1 on C2: id = 42, s = Hello, World!
'Instance method M1 on C2: id = 42, s = Hi, Mom!
'
'An open instance method.
'Instance method M1 on C2: id = 42, s = Hello, World!
'Instance method M1 on C2: id = 5280, s = Hi, Mom!
'
'An open Shared method.
'Shared method M2 on C2: s = Hello, World!
'Shared method M2 on C2: s = Hi, Mom!
'
'A Shared method closed over the first argument (String).
'Shared method M2 on C2: s = Hello, World!
'

5 (

Imports System.Reflection Imports System.Security.Permissions ' Declare three delegate types for demonstrating the combinations ' of Shared versus instance methods and open versus closed ' delegates. ' Public Delegate Sub D1(ByVal c As C2, ByVal s As String) Public Delegate Sub D2(ByVal s As String) Public Delegate Sub D3() ' A sample class with an instance method and a Shared method. ' Public Class C2

Private id As Integer
Public Sub New(ByVal id As Integer)
    Me.id = id
End Sub
Public Sub M1(ByVal s As String)
    Console.WriteLine("Instance method M1 on C2:  id = {0}, s = {1}",
        Me.id, s)
End Sub
Public Shared Sub M2(ByVal s As String)
    Console.WriteLine("Shared method M2 on C2:  s = {0}", s)
End Sub

End Class
Public Class Example2Public Shared Sub Main()
    Dim c1 As New C2(42)
    ' Get a MethodInfo for each method.
    '
    Dim mi1 As MethodInfo = GetType(C2).GetMethod("M1",
        BindingFlags.Public Or BindingFlags.Instance)
    Dim mi2 As MethodInfo = GetType(C2).GetMethod("M2",
        BindingFlags.Public Or BindingFlags.Static)
    Dim d1 As D1
    Dim d2 As D2
    Dim d3 As D3
    Console.WriteLine(vbLf & "An instance method closed over C2.")
    ' In this case, the delegate and the
    ' method must have the same list of argument types; use
    ' delegate type D2 with instance method M1.
    '
    Dim test As [Delegate] =
        [Delegate].CreateDelegate(GetType(D2), c1, mi1, False)
    ' Because False was specified for throwOnBindFailure 
    ' in the call to CreateDelegate, the variable 'test'
    ' contains Nothing if the method fails to bind (for 
    ' example, if mi1 happened to represent a method of 
    ' some class other than C2).
    '
    If test IsNot Nothing Then
        d2 = CType(test, D2)
        ' The same instance of C2 is used every time the
        ' delegate is invoked.
        d2("Hello, World!")
        d2("Hi, Mom!")
    End If
    Console.WriteLine(vbLf & "An open instance method.")
    ' In this case, the delegate has one more 
    ' argument than the instance method; this argument comes
    ' at the beginning, and represents the hidden instance
    ' argument of the instance method. Use delegate type D1
    ' with instance method M1.
    '
    d1 = CType([Delegate].CreateDelegate(GetType(D1), Nothing, mi1), D1)
    ' An instance of C2 must be passed in each time the 
    ' delegate is invoked.
    '
    d1(c1, "Hello, World!")
    d1(New C2(5280), "Hi, Mom!")
    Console.WriteLine(vbLf & "An open Shared method.")
    ' In this case, the delegate and the method must 
    ' have the same list of argument types; use delegate type
    ' D2 with Shared method M2.
    '
    d2 = CType([Delegate].CreateDelegate(GetType(D2), Nothing, mi2), D2)
    ' No instances of C2 are involved, because this is a Shared
    ' method. 
    '
    d2("Hello, World!")
    d2("Hi, Mom!")
    Console.WriteLine(vbLf & "A Shared method closed over the first argument (String).")
    ' The delegate must omit the first argument of the method.
    ' A string is passed as the firstArgument parameter, and 
    ' the delegate is bound to this string. Use delegate type 
    ' D3 with Shared method M2. 
    '
    d3 = CType([Delegate].CreateDelegate(GetType(D3), "Hello, World!", mi2), D3)
    ' Each time the delegate is invoked, the same string is
    ' used.
    d3()
End Sub
End Class
' This code example produces the following output:
'
'An instance method closed over C2.
'Instance method M1 on C2: id = 42, s = Hello, World!
'Instance method M1 on C2: id = 42, s = Hi, Mom!
'
'An open instance method.
'Instance method M1 on C2: id = 42, s = Hello, World!
'Instance method M1 on C2: id = 5280, s = Hi, Mom!
'
'An open Shared method.
'Shared method M2 on C2: s = Hello, World!
'Shared method M2 on C2: s = Hi, Mom!
'
'A Shared method closed over the first argument (String).
'Shared method M2 on C2: s = Hello, World!
'

6 in Visual Basic) method named

Imports System.Reflection Imports System.Security.Permissions ' Declare three delegate types for demonstrating the combinations ' of Shared versus instance methods and open versus closed ' delegates. ' Public Delegate Sub D1(ByVal c As C2, ByVal s As String) Public Delegate Sub D2(ByVal s As String) Public Delegate Sub D3() ' A sample class with an instance method and a Shared method. ' Public Class C2

Private id As Integer
Public Sub New(ByVal id As Integer)
    Me.id = id
End Sub
Public Sub M1(ByVal s As String)
    Console.WriteLine("Instance method M1 on C2:  id = {0}, s = {1}",
        Me.id, s)
End Sub
Public Shared Sub M2(ByVal s As String)
    Console.WriteLine("Shared method M2 on C2:  s = {0}", s)
End Sub

End Class
Public Class Example2Public Shared Sub Main()
    Dim c1 As New C2(42)
    ' Get a MethodInfo for each method.
    '
    Dim mi1 As MethodInfo = GetType(C2).GetMethod("M1",
        BindingFlags.Public Or BindingFlags.Instance)
    Dim mi2 As MethodInfo = GetType(C2).GetMethod("M2",
        BindingFlags.Public Or BindingFlags.Static)
    Dim d1 As D1
    Dim d2 As D2
    Dim d3 As D3
    Console.WriteLine(vbLf & "An instance method closed over C2.")
    ' In this case, the delegate and the
    ' method must have the same list of argument types; use
    ' delegate type D2 with instance method M1.
    '
    Dim test As [Delegate] =
        [Delegate].CreateDelegate(GetType(D2), c1, mi1, False)
    ' Because False was specified for throwOnBindFailure 
    ' in the call to CreateDelegate, the variable 'test'
    ' contains Nothing if the method fails to bind (for 
    ' example, if mi1 happened to represent a method of 
    ' some class other than C2).
    '
    If test IsNot Nothing Then
        d2 = CType(test, D2)
        ' The same instance of C2 is used every time the
        ' delegate is invoked.
        d2("Hello, World!")
        d2("Hi, Mom!")
    End If
    Console.WriteLine(vbLf & "An open instance method.")
    ' In this case, the delegate has one more 
    ' argument than the instance method; this argument comes
    ' at the beginning, and represents the hidden instance
    ' argument of the instance method. Use delegate type D1
    ' with instance method M1.
    '
    d1 = CType([Delegate].CreateDelegate(GetType(D1), Nothing, mi1), D1)
    ' An instance of C2 must be passed in each time the 
    ' delegate is invoked.
    '
    d1(c1, "Hello, World!")
    d1(New C2(5280), "Hi, Mom!")
    Console.WriteLine(vbLf & "An open Shared method.")
    ' In this case, the delegate and the method must 
    ' have the same list of argument types; use delegate type
    ' D2 with Shared method M2.
    '
    d2 = CType([Delegate].CreateDelegate(GetType(D2), Nothing, mi2), D2)
    ' No instances of C2 are involved, because this is a Shared
    ' method. 
    '
    d2("Hello, World!")
    d2("Hi, Mom!")
    Console.WriteLine(vbLf & "A Shared method closed over the first argument (String).")
    ' The delegate must omit the first argument of the method.
    ' A string is passed as the firstArgument parameter, and 
    ' the delegate is bound to this string. Use delegate type 
    ' D3 with Shared method M2. 
    '
    d3 = CType([Delegate].CreateDelegate(GetType(D3), "Hello, World!", mi2), D3)
    ' Each time the delegate is invoked, the same string is
    ' used.
    d3()
End Sub
End Class
' This code example produces the following output:
'
'An instance method closed over C2.
'Instance method M1 on C2: id = 42, s = Hello, World!
'Instance method M1 on C2: id = 42, s = Hi, Mom!
'
'An open instance method.
'Instance method M1 on C2: id = 42, s = Hello, World!
'Instance method M1 on C2: id = 5280, s = Hi, Mom!
'
'An open Shared method.
'Shared method M2 on C2: s = Hello, World!
'Shared method M2 on C2: s = Hi, Mom!
'
'A Shared method closed over the first argument (String).
'Shared method M2 on C2: s = Hello, World!
'

7 with one parameter of type

Imports System.Reflection Imports System.Security.Permissions ' Declare three delegate types for demonstrating the combinations ' of Shared versus instance methods and open versus closed ' delegates. ' Public Delegate Sub D1(ByVal c As C2, ByVal s As String) Public Delegate Sub D2(ByVal s As String) Public Delegate Sub D3() ' A sample class with an instance method and a Shared method. ' Public Class C2

Private id As Integer
Public Sub New(ByVal id As Integer)
    Me.id = id
End Sub
Public Sub M1(ByVal s As String)
    Console.WriteLine("Instance method M1 on C2:  id = {0}, s = {1}",
        Me.id, s)
End Sub
Public Shared Sub M2(ByVal s As String)
    Console.WriteLine("Shared method M2 on C2:  s = {0}", s)
End Sub

End Class
Public Class Example2Public Shared Sub Main()
    Dim c1 As New C2(42)
    ' Get a MethodInfo for each method.
    '
    Dim mi1 As MethodInfo = GetType(C2).GetMethod("M1",
        BindingFlags.Public Or BindingFlags.Instance)
    Dim mi2 As MethodInfo = GetType(C2).GetMethod("M2",
        BindingFlags.Public Or BindingFlags.Static)
    Dim d1 As D1
    Dim d2 As D2
    Dim d3 As D3
    Console.WriteLine(vbLf & "An instance method closed over C2.")
    ' In this case, the delegate and the
    ' method must have the same list of argument types; use
    ' delegate type D2 with instance method M1.
    '
    Dim test As [Delegate] =
        [Delegate].CreateDelegate(GetType(D2), c1, mi1, False)
    ' Because False was specified for throwOnBindFailure 
    ' in the call to CreateDelegate, the variable 'test'
    ' contains Nothing if the method fails to bind (for 
    ' example, if mi1 happened to represent a method of 
    ' some class other than C2).
    '
    If test IsNot Nothing Then
        d2 = CType(test, D2)
        ' The same instance of C2 is used every time the
        ' delegate is invoked.
        d2("Hello, World!")
        d2("Hi, Mom!")
    End If
    Console.WriteLine(vbLf & "An open instance method.")
    ' In this case, the delegate has one more 
    ' argument than the instance method; this argument comes
    ' at the beginning, and represents the hidden instance
    ' argument of the instance method. Use delegate type D1
    ' with instance method M1.
    '
    d1 = CType([Delegate].CreateDelegate(GetType(D1), Nothing, mi1), D1)
    ' An instance of C2 must be passed in each time the 
    ' delegate is invoked.
    '
    d1(c1, "Hello, World!")
    d1(New C2(5280), "Hi, Mom!")
    Console.WriteLine(vbLf & "An open Shared method.")
    ' In this case, the delegate and the method must 
    ' have the same list of argument types; use delegate type
    ' D2 with Shared method M2.
    '
    d2 = CType([Delegate].CreateDelegate(GetType(D2), Nothing, mi2), D2)
    ' No instances of C2 are involved, because this is a Shared
    ' method. 
    '
    d2("Hello, World!")
    d2("Hi, Mom!")
    Console.WriteLine(vbLf & "A Shared method closed over the first argument (String).")
    ' The delegate must omit the first argument of the method.
    ' A string is passed as the firstArgument parameter, and 
    ' the delegate is bound to this string. Use delegate type 
    ' D3 with Shared method M2. 
    '
    d3 = CType([Delegate].CreateDelegate(GetType(D3), "Hello, World!", mi2), D3)
    ' Each time the delegate is invoked, the same string is
    ' used.
    d3()
End Sub
End Class
' This code example produces the following output:
'
'An instance method closed over C2.
'Instance method M1 on C2: id = 42, s = Hello, World!
'Instance method M1 on C2: id = 42, s = Hi, Mom!
'
'An open instance method.
'Instance method M1 on C2: id = 42, s = Hello, World!
'Instance method M1 on C2: id = 5280, s = Hi, Mom!
'
'An open Shared method.
'Shared method M2 on C2: s = Hello, World!
'Shared method M2 on C2: s = Hi, Mom!
'
'A Shared method closed over the first argument (String).
'Shared method M2 on C2: s = Hello, World!
'

2 and a return type of

Imports System.Reflection Imports System.Security.Permissions ' Declare three delegate types for demonstrating the combinations ' of Shared versus instance methods and open versus closed ' delegates. ' Public Delegate Sub D1(ByVal c As C2, ByVal s As String) Public Delegate Sub D2(ByVal s As String) Public Delegate Sub D3() ' A sample class with an instance method and a Shared method. ' Public Class C2

Private id As Integer
Public Sub New(ByVal id As Integer)
    Me.id = id
End Sub
Public Sub M1(ByVal s As String)
    Console.WriteLine("Instance method M1 on C2:  id = {0}, s = {1}",
        Me.id, s)
End Sub
Public Shared Sub M2(ByVal s As String)
    Console.WriteLine("Shared method M2 on C2:  s = {0}", s)
End Sub

End Class
Public Class Example2Public Shared Sub Main()
    Dim c1 As New C2(42)
    ' Get a MethodInfo for each method.
    '
    Dim mi1 As MethodInfo = GetType(C2).GetMethod("M1",
        BindingFlags.Public Or BindingFlags.Instance)
    Dim mi2 As MethodInfo = GetType(C2).GetMethod("M2",
        BindingFlags.Public Or BindingFlags.Static)
    Dim d1 As D1
    Dim d2 As D2
    Dim d3 As D3
    Console.WriteLine(vbLf & "An instance method closed over C2.")
    ' In this case, the delegate and the
    ' method must have the same list of argument types; use
    ' delegate type D2 with instance method M1.
    '
    Dim test As [Delegate] =
        [Delegate].CreateDelegate(GetType(D2), c1, mi1, False)
    ' Because False was specified for throwOnBindFailure 
    ' in the call to CreateDelegate, the variable 'test'
    ' contains Nothing if the method fails to bind (for 
    ' example, if mi1 happened to represent a method of 
    ' some class other than C2).
    '
    If test IsNot Nothing Then
        d2 = CType(test, D2)
        ' The same instance of C2 is used every time the
        ' delegate is invoked.
        d2("Hello, World!")
        d2("Hi, Mom!")
    End If
    Console.WriteLine(vbLf & "An open instance method.")
    ' In this case, the delegate has one more 
    ' argument than the instance method; this argument comes
    ' at the beginning, and represents the hidden instance
    ' argument of the instance method. Use delegate type D1
    ' with instance method M1.
    '
    d1 = CType([Delegate].CreateDelegate(GetType(D1), Nothing, mi1), D1)
    ' An instance of C2 must be passed in each time the 
    ' delegate is invoked.
    '
    d1(c1, "Hello, World!")
    d1(New C2(5280), "Hi, Mom!")
    Console.WriteLine(vbLf & "An open Shared method.")
    ' In this case, the delegate and the method must 
    ' have the same list of argument types; use delegate type
    ' D2 with Shared method M2.
    '
    d2 = CType([Delegate].CreateDelegate(GetType(D2), Nothing, mi2), D2)
    ' No instances of C2 are involved, because this is a Shared
    ' method. 
    '
    d2("Hello, World!")
    d2("Hi, Mom!")
    Console.WriteLine(vbLf & "A Shared method closed over the first argument (String).")
    ' The delegate must omit the first argument of the method.
    ' A string is passed as the firstArgument parameter, and 
    ' the delegate is bound to this string. Use delegate type 
    ' D3 with Shared method M2. 
    '
    d3 = CType([Delegate].CreateDelegate(GetType(D3), "Hello, World!", mi2), D3)
    ' Each time the delegate is invoked, the same string is
    ' used.
    d3()
End Sub
End Class
' This code example produces the following output:
'
'An instance method closed over C2.
'Instance method M1 on C2: id = 42, s = Hello, World!
'Instance method M1 on C2: id = 42, s = Hi, Mom!
'
'An open instance method.
'Instance method M1 on C2: id = 42, s = Hello, World!
'Instance method M1 on C2: id = 5280, s = Hi, Mom!
'
'An open Shared method.
'Shared method M2 on C2: s = Hello, World!
'Shared method M2 on C2: s = Hi, Mom!
'
'A Shared method closed over the first argument (String).
'Shared method M2 on C2: s = Hello, World!
'

3. The code example also defines a delegate named

open System open System.Reflection // A sample class with an instance method and a static method. type C(id) =

member _.M1(s) =
    printfn $"Instance method M1 on C:  id = %i{id}, s = %s{s}"
static member M2(s) =
    printfn $"Static method M2 on C:  s = %s{s}"

// Declare three delegate types for demonstrating the combinations
// of static versus instance methods and open versus closed
// delegates.
type D1 = delegate of C * string -> unit
type D2 = delegate of string -> unit
type D3 = delegate of unit -> unit
let c1 = C 42
// Get a MethodInfo for each method.
//
let mi1 = typeof.GetMethod("M1", BindingFlags.Public ||| BindingFlags.Instance)
let mi2 = typeof.GetMethod("M2", BindingFlags.Public ||| BindingFlags.Static)
printfn "\nAn instance method closed over C."
// In this case, the delegate and the
// method must have the same list of argument types use
// delegate type D2 with instance method M1.
let test = Delegate.CreateDelegate(typeof, c1, mi1, false)
// Because false was specified for throwOnBindFailure
// in the call to CreateDelegate, the variable 'test'
// contains null if the method fails to bind (for
// example, if mi1 happened to represent a method of
// some class other than C).
if test <> null thenlet d2 = test :?> D2
// The same instance of C is used every time the
// delegate is invoked.
d2.Invoke "Hello, World!"
d2.Invoke "Hi, Mom!"
printfn "\nAn open instance method."
// In this case, the delegate has one more
// argument than the instance method this argument comes
// at the beginning, and represents the hidden instance
// argument of the instance method. Use delegate type D1
// with instance method M1.
let d1 = Delegate.CreateDelegate(typeof, null, mi1) :?> D1
// An instance of C must be passed in each time the
// delegate is invoked.
d1.Invoke(c1, "Hello, World!")
d1.Invoke(C 5280, "Hi, Mom!")
printfn "\nAn open static method."
// In this case, the delegate and the method must
// have the same list of argument types use delegate type
// D2 with static method M2.
let d2 = Delegate.CreateDelegate(typeof, null, mi2) :?> D2
// No instances of C are involved, because this is a static
// method.
d2.Invoke "Hello, World!"
d2.Invoke "Hi, Mom!"
printfn "\nA static method closed over the first argument (String)."
// The delegate must omit the first argument of the method.
// A string is passed as the firstArgument parameter, and
// the delegate is bound to this string. Use delegate type
// D3 with static method M2.
let d3 = Delegate.CreateDelegate(typeof, "Hello, World!", mi2) :?> D3
// Each time the delegate is invoked, the same string is used.
d3.Invoke()
// This code example produces the following output:
// An instance method closed over C.
// Instance method M1 on C: id = 42, s = Hello, World!
// Instance method M1 on C: id = 42, s = Hi, Mom!
//
// An open instance method.
// Instance method M1 on C: id = 42, s = Hello, World!
// Instance method M1 on C: id = 5280, s = Hi, Mom!
//
// An open static method.
// Static method M2 on C: s = Hello, World!
// Static method M2 on C: s = Hi, Mom!
//
// A static method closed over the first argument (String).
// Static method M2 on C: s = Hello, World!

7 that has one parameter of type

Imports System.Reflection Imports System.Security.Permissions ' Declare three delegate types for demonstrating the combinations ' of Shared versus instance methods and open versus closed ' delegates. ' Public Delegate Sub D1(ByVal c As C2, ByVal s As String) Public Delegate Sub D2(ByVal s As String) Public Delegate Sub D3() ' A sample class with an instance method and a Shared method. ' Public Class C2

Private id As Integer
Public Sub New(ByVal id As Integer)
    Me.id = id
End Sub
Public Sub M1(ByVal s As String)
    Console.WriteLine("Instance method M1 on C2:  id = {0}, s = {1}",
        Me.id, s)
End Sub
Public Shared Sub M2(ByVal s As String)
    Console.WriteLine("Shared method M2 on C2:  s = {0}", s)
End Sub

End Class
Public Class Example2Public Shared Sub Main()
    Dim c1 As New C2(42)
    ' Get a MethodInfo for each method.
    '
    Dim mi1 As MethodInfo = GetType(C2).GetMethod("M1",
        BindingFlags.Public Or BindingFlags.Instance)
    Dim mi2 As MethodInfo = GetType(C2).GetMethod("M2",
        BindingFlags.Public Or BindingFlags.Static)
    Dim d1 As D1
    Dim d2 As D2
    Dim d3 As D3
    Console.WriteLine(vbLf & "An instance method closed over C2.")
    ' In this case, the delegate and the
    ' method must have the same list of argument types; use
    ' delegate type D2 with instance method M1.
    '
    Dim test As [Delegate] =
        [Delegate].CreateDelegate(GetType(D2), c1, mi1, False)
    ' Because False was specified for throwOnBindFailure 
    ' in the call to CreateDelegate, the variable 'test'
    ' contains Nothing if the method fails to bind (for 
    ' example, if mi1 happened to represent a method of 
    ' some class other than C2).
    '
    If test IsNot Nothing Then
        d2 = CType(test, D2)
        ' The same instance of C2 is used every time the
        ' delegate is invoked.
        d2("Hello, World!")
        d2("Hi, Mom!")
    End If
    Console.WriteLine(vbLf & "An open instance method.")
    ' In this case, the delegate has one more 
    ' argument than the instance method; this argument comes
    ' at the beginning, and represents the hidden instance
    ' argument of the instance method. Use delegate type D1
    ' with instance method M1.
    '
    d1 = CType([Delegate].CreateDelegate(GetType(D1), Nothing, mi1), D1)
    ' An instance of C2 must be passed in each time the 
    ' delegate is invoked.
    '
    d1(c1, "Hello, World!")
    d1(New C2(5280), "Hi, Mom!")
    Console.WriteLine(vbLf & "An open Shared method.")
    ' In this case, the delegate and the method must 
    ' have the same list of argument types; use delegate type
    ' D2 with Shared method M2.
    '
    d2 = CType([Delegate].CreateDelegate(GetType(D2), Nothing, mi2), D2)
    ' No instances of C2 are involved, because this is a Shared
    ' method. 
    '
    d2("Hello, World!")
    d2("Hi, Mom!")
    Console.WriteLine(vbLf & "A Shared method closed over the first argument (String).")
    ' The delegate must omit the first argument of the method.
    ' A string is passed as the firstArgument parameter, and 
    ' the delegate is bound to this string. Use delegate type 
    ' D3 with Shared method M2. 
    '
    d3 = CType([Delegate].CreateDelegate(GetType(D3), "Hello, World!", mi2), D3)
    ' Each time the delegate is invoked, the same string is
    ' used.
    d3()
End Sub
End Class
' This code example produces the following output:
'
'An instance method closed over C2.
'Instance method M1 on C2: id = 42, s = Hello, World!
'Instance method M1 on C2: id = 42, s = Hi, Mom!
'
'An open instance method.
'Instance method M1 on C2: id = 42, s = Hello, World!
'Instance method M1 on C2: id = 5280, s = Hi, Mom!
'
'An open Shared method.
'Shared method M2 on C2: s = Hello, World!
'Shared method M2 on C2: s = Hi, Mom!
'
'A Shared method closed over the first argument (String).
'Shared method M2 on C2: s = Hello, World!
'

3 and a return type of

Imports System.Reflection Imports System.Security.Permissions ' Declare three delegate types for demonstrating the combinations ' of Shared versus instance methods and open versus closed ' delegates. ' Public Delegate Sub D1(ByVal c As C2, ByVal s As String) Public Delegate Sub D2(ByVal s As String) Public Delegate Sub D3() ' A sample class with an instance method and a Shared method. ' Public Class C2

Private id As Integer
Public Sub New(ByVal id As Integer)
    Me.id = id
End Sub
Public Sub M1(ByVal s As String)
    Console.WriteLine("Instance method M1 on C2:  id = {0}, s = {1}",
        Me.id, s)
End Sub
Public Shared Sub M2(ByVal s As String)
    Console.WriteLine("Shared method M2 on C2:  s = {0}", s)
End Sub

End Class
Public Class Example2Public Shared Sub Main()
    Dim c1 As New C2(42)
    ' Get a MethodInfo for each method.
    '
    Dim mi1 As MethodInfo = GetType(C2).GetMethod("M1",
        BindingFlags.Public Or BindingFlags.Instance)
    Dim mi2 As MethodInfo = GetType(C2).GetMethod("M2",
        BindingFlags.Public Or BindingFlags.Static)
    Dim d1 As D1
    Dim d2 As D2
    Dim d3 As D3
    Console.WriteLine(vbLf & "An instance method closed over C2.")
    ' In this case, the delegate and the
    ' method must have the same list of argument types; use
    ' delegate type D2 with instance method M1.
    '
    Dim test As [Delegate] =
        [Delegate].CreateDelegate(GetType(D2), c1, mi1, False)
    ' Because False was specified for throwOnBindFailure 
    ' in the call to CreateDelegate, the variable 'test'
    ' contains Nothing if the method fails to bind (for 
    ' example, if mi1 happened to represent a method of 
    ' some class other than C2).
    '
    If test IsNot Nothing Then
        d2 = CType(test, D2)
        ' The same instance of C2 is used every time the
        ' delegate is invoked.
        d2("Hello, World!")
        d2("Hi, Mom!")
    End If
    Console.WriteLine(vbLf & "An open instance method.")
    ' In this case, the delegate has one more 
    ' argument than the instance method; this argument comes
    ' at the beginning, and represents the hidden instance
    ' argument of the instance method. Use delegate type D1
    ' with instance method M1.
    '
    d1 = CType([Delegate].CreateDelegate(GetType(D1), Nothing, mi1), D1)
    ' An instance of C2 must be passed in each time the 
    ' delegate is invoked.
    '
    d1(c1, "Hello, World!")
    d1(New C2(5280), "Hi, Mom!")
    Console.WriteLine(vbLf & "An open Shared method.")
    ' In this case, the delegate and the method must 
    ' have the same list of argument types; use delegate type
    ' D2 with Shared method M2.
    '
    d2 = CType([Delegate].CreateDelegate(GetType(D2), Nothing, mi2), D2)
    ' No instances of C2 are involved, because this is a Shared
    ' method. 
    '
    d2("Hello, World!")
    d2("Hi, Mom!")
    Console.WriteLine(vbLf & "A Shared method closed over the first argument (String).")
    ' The delegate must omit the first argument of the method.
    ' A string is passed as the firstArgument parameter, and 
    ' the delegate is bound to this string. Use delegate type 
    ' D3 with Shared method M2. 
    '
    d3 = CType([Delegate].CreateDelegate(GetType(D3), "Hello, World!", mi2), D3)
    ' Each time the delegate is invoked, the same string is
    ' used.
    d3()
End Sub
End Class
' This code example produces the following output:
'
'An instance method closed over C2.
'Instance method M1 on C2: id = 42, s = Hello, World!
'Instance method M1 on C2: id = 42, s = Hi, Mom!
'
'An open instance method.
'Instance method M1 on C2: id = 42, s = Hello, World!
'Instance method M1 on C2: id = 5280, s = Hi, Mom!
'
'An open Shared method.
'Shared method M2 on C2: s = Hello, World!
'Shared method M2 on C2: s = Hi, Mom!
'
'A Shared method closed over the first argument (String).
'Shared method M2 on C2: s = Hello, World!
'

2.

The code example demonstrates that the delegate named

open System open System.Reflection // A sample class with an instance method and a static method. type C(id) =

member _.M1(s) =
    printfn $"Instance method M1 on C:  id = %i{id}, s = %s{s}"
static member M2(s) =
    printfn $"Static method M2 on C:  s = %s{s}"

// Declare three delegate types for demonstrating the combinations
// of static versus instance methods and open versus closed
// delegates.
type D1 = delegate of C * string -> unit
type D2 = delegate of string -> unit
type D3 = delegate of unit -> unit
let c1 = C 42
// Get a MethodInfo for each method.
//
let mi1 = typeof.GetMethod("M1", BindingFlags.Public ||| BindingFlags.Instance)
let mi2 = typeof.GetMethod("M2", BindingFlags.Public ||| BindingFlags.Static)
printfn "\nAn instance method closed over C."
// In this case, the delegate and the
// method must have the same list of argument types use
// delegate type D2 with instance method M1.
let test = Delegate.CreateDelegate(typeof, c1, mi1, false)
// Because false was specified for throwOnBindFailure
// in the call to CreateDelegate, the variable 'test'
// contains null if the method fails to bind (for
// example, if mi1 happened to represent a method of
// some class other than C).
if test <> null thenlet d2 = test :?> D2
// The same instance of C is used every time the
// delegate is invoked.
d2.Invoke "Hello, World!"
d2.Invoke "Hi, Mom!"
printfn "\nAn open instance method."
// In this case, the delegate has one more
// argument than the instance method this argument comes
// at the beginning, and represents the hidden instance
// argument of the instance method. Use delegate type D1
// with instance method M1.
let d1 = Delegate.CreateDelegate(typeof, null, mi1) :?> D1
// An instance of C must be passed in each time the
// delegate is invoked.
d1.Invoke(c1, "Hello, World!")
d1.Invoke(C 5280, "Hi, Mom!")
printfn "\nAn open static method."
// In this case, the delegate and the method must
// have the same list of argument types use delegate type
// D2 with static method M2.
let d2 = Delegate.CreateDelegate(typeof, null, mi2) :?> D2
// No instances of C are involved, because this is a static
// method.
d2.Invoke "Hello, World!"
d2.Invoke "Hi, Mom!"
printfn "\nA static method closed over the first argument (String)."
// The delegate must omit the first argument of the method.
// A string is passed as the firstArgument parameter, and
// the delegate is bound to this string. Use delegate type
// D3 with static method M2.
let d3 = Delegate.CreateDelegate(typeof, "Hello, World!", mi2) :?> D3
// Each time the delegate is invoked, the same string is used.
d3.Invoke()
// This code example produces the following output:
// An instance method closed over C.
// Instance method M1 on C: id = 42, s = Hello, World!
// Instance method M1 on C: id = 42, s = Hi, Mom!
//
// An open instance method.
// Instance method M1 on C: id = 42, s = Hello, World!
// Instance method M1 on C: id = 5280, s = Hi, Mom!
//
// An open static method.
// Static method M2 on C: s = Hello, World!
// Static method M2 on C: s = Hi, Mom!
//
// A static method closed over the first argument (String).
// Static method M2 on C: s = Hello, World!

7 can be used to represent the method

Imports System.Reflection Imports System.Security.Permissions ' Declare three delegate types for demonstrating the combinations ' of Shared versus instance methods and open versus closed ' delegates. ' Public Delegate Sub D1(ByVal c As C2, ByVal s As String) Public Delegate Sub D2(ByVal s As String) Public Delegate Sub D3() ' A sample class with an instance method and a Shared method. ' Public Class C2

Private id As Integer
Public Sub New(ByVal id As Integer)
    Me.id = id
End Sub
Public Sub M1(ByVal s As String)
    Console.WriteLine("Instance method M1 on C2:  id = {0}, s = {1}",
        Me.id, s)
End Sub
Public Shared Sub M2(ByVal s As String)
    Console.WriteLine("Shared method M2 on C2:  s = {0}", s)
End Sub

End Class
Public Class Example2Public Shared Sub Main()
    Dim c1 As New C2(42)
    ' Get a MethodInfo for each method.
    '
    Dim mi1 As MethodInfo = GetType(C2).GetMethod("M1",
        BindingFlags.Public Or BindingFlags.Instance)
    Dim mi2 As MethodInfo = GetType(C2).GetMethod("M2",
        BindingFlags.Public Or BindingFlags.Static)
    Dim d1 As D1
    Dim d2 As D2
    Dim d3 As D3
    Console.WriteLine(vbLf & "An instance method closed over C2.")
    ' In this case, the delegate and the
    ' method must have the same list of argument types; use
    ' delegate type D2 with instance method M1.
    '
    Dim test As [Delegate] =
        [Delegate].CreateDelegate(GetType(D2), c1, mi1, False)
    ' Because False was specified for throwOnBindFailure 
    ' in the call to CreateDelegate, the variable 'test'
    ' contains Nothing if the method fails to bind (for 
    ' example, if mi1 happened to represent a method of 
    ' some class other than C2).
    '
    If test IsNot Nothing Then
        d2 = CType(test, D2)
        ' The same instance of C2 is used every time the
        ' delegate is invoked.
        d2("Hello, World!")
        d2("Hi, Mom!")
    End If
    Console.WriteLine(vbLf & "An open instance method.")
    ' In this case, the delegate has one more 
    ' argument than the instance method; this argument comes
    ' at the beginning, and represents the hidden instance
    ' argument of the instance method. Use delegate type D1
    ' with instance method M1.
    '
    d1 = CType([Delegate].CreateDelegate(GetType(D1), Nothing, mi1), D1)
    ' An instance of C2 must be passed in each time the 
    ' delegate is invoked.
    '
    d1(c1, "Hello, World!")
    d1(New C2(5280), "Hi, Mom!")
    Console.WriteLine(vbLf & "An open Shared method.")
    ' In this case, the delegate and the method must 
    ' have the same list of argument types; use delegate type
    ' D2 with Shared method M2.
    '
    d2 = CType([Delegate].CreateDelegate(GetType(D2), Nothing, mi2), D2)
    ' No instances of C2 are involved, because this is a Shared
    ' method. 
    '
    d2("Hello, World!")
    d2("Hi, Mom!")
    Console.WriteLine(vbLf & "A Shared method closed over the first argument (String).")
    ' The delegate must omit the first argument of the method.
    ' A string is passed as the firstArgument parameter, and 
    ' the delegate is bound to this string. Use delegate type 
    ' D3 with Shared method M2. 
    '
    d3 = CType([Delegate].CreateDelegate(GetType(D3), "Hello, World!", mi2), D3)
    ' Each time the delegate is invoked, the same string is
    ' used.
    d3()
End Sub
End Class
' This code example produces the following output:
'
'An instance method closed over C2.
'Instance method M1 on C2: id = 42, s = Hello, World!
'Instance method M1 on C2: id = 42, s = Hi, Mom!
'
'An open instance method.
'Instance method M1 on C2: id = 42, s = Hello, World!
'Instance method M1 on C2: id = 5280, s = Hi, Mom!
'
'An open Shared method.
'Shared method M2 on C2: s = Hello, World!
'Shared method M2 on C2: s = Hi, Mom!
'
'A Shared method closed over the first argument (String).
'Shared method M2 on C2: s = Hello, World!
'

7. The method can be bound to the delegate because:

The parameter type of the delegate (

Imports System.Reflection Imports System.Security.Permissions
' Declare three delegate types for demonstrating the combinations
' of Shared versus instance methods and open versus closed
' delegates.
'
Public Delegate Sub D1(ByVal c As C2, ByVal s As String)
Public Delegate Sub D2(ByVal s As String)
Public Delegate Sub D3()
' A sample class with an instance method and a Shared method.
'
Public Class C2 
Private id As Integer  
Public Sub New(ByVal id As Integer)  
    Me.id = id  
End Sub  
Public Sub M1(ByVal s As String)  
    Console.WriteLine("Instance method M1 on C2:  id = {0}, s = {1}",  
        Me.id, s)  
End Sub  
Public Shared Sub M2(ByVal s As String)  
    Console.WriteLine("Shared method M2 on C2:  s = {0}", s)  
End Sub  
End Class
Public Class Example2 Public Shared Sub Main()  
    Dim c1 As New C2(42)  
    ' Get a MethodInfo for each method.  
    '  
    Dim mi1 As MethodInfo = GetType(C2).GetMethod("M1",  
        BindingFlags.Public Or BindingFlags.Instance)  
    Dim mi2 As MethodInfo = GetType(C2).GetMethod("M2",  
        BindingFlags.Public Or BindingFlags.Static)  
    Dim d1 As D1  
    Dim d2 As D2  
    Dim d3 As D3  
    Console.WriteLine(vbLf & "An instance method closed over C2.")  
    ' In this case, the delegate and the  
    ' method must have the same list of argument types; use  
    ' delegate type D2 with instance method M1.  
    '  
    Dim test As [Delegate] =  
        [Delegate].CreateDelegate(GetType(D2), c1, mi1, False)  
    ' Because False was specified for throwOnBindFailure  
    ' in the call to CreateDelegate, the variable 'test'  
    ' contains Nothing if the method fails to bind (for  
    ' example, if mi1 happened to represent a method of  
    ' some class other than C2).  
    '  
    If test IsNot Nothing Then  
        d2 = CType(test, D2)  
        ' The same instance of C2 is used every time the  
        ' delegate is invoked.  
        d2("Hello, World!")  
        d2("Hi, Mom!")  
    End If  
    Console.WriteLine(vbLf & "An open instance method.")  
    ' In this case, the delegate has one more  
    ' argument than the instance method; this argument comes  
    ' at the beginning, and represents the hidden instance  
    ' argument of the instance method. Use delegate type D1  
    ' with instance method M1.  
    '  
    d1 = CType([Delegate].CreateDelegate(GetType(D1), Nothing, mi1), D1)  
    ' An instance of C2 must be passed in each time the  
    ' delegate is invoked.  
    '  
    d1(c1, "Hello, World!")  
    d1(New C2(5280), "Hi, Mom!")  
    Console.WriteLine(vbLf & "An open Shared method.")  
    ' In this case, the delegate and the method must  
    ' have the same list of argument types; use delegate type  
    ' D2 with Shared method M2.  
    '  
    d2 = CType([Delegate].CreateDelegate(GetType(D2), Nothing, mi2), D2)  
    ' No instances of C2 are involved, because this is a Shared  
    ' method.  
    '  
    d2("Hello, World!")  
    d2("Hi, Mom!")  
    Console.WriteLine(vbLf & "A Shared method closed over the first argument (String).")  
    ' The delegate must omit the first argument of the method.  
    ' A string is passed as the firstArgument parameter, and  
    ' the delegate is bound to this string. Use delegate type  
    ' D3 with Shared method M2.  
    '  
    d3 = CType([Delegate].CreateDelegate(GetType(D3), "Hello, World!", mi2), D3)  
    ' Each time the delegate is invoked, the same string is  
    ' used.  
    d3()  
End Sub  
End Class
' This code example produces the following output:
'
'An instance method closed over C2.
'Instance method M1 on C2: id = 42, s = Hello, World!
'Instance method M1 on C2: id = 42, s = Hi, Mom!
'
'An open instance method.
'Instance method M1 on C2: id = 42, s = Hello, World!
'Instance method M1 on C2: id = 5280, s = Hi, Mom!
'
'An open Shared method.
'Shared method M2 on C2: s = Hello, World!
'Shared method M2 on C2: s = Hi, Mom!
'
'A Shared method closed over the first argument (String).
'Shared method M2 on C2: s = Hello, World!
'

is more restrictive than the parameter type of

Imports System.Reflection Imports System.Security.Permissions
' Declare three delegate types for demonstrating the combinations
' of Shared versus instance methods and open versus closed
' delegates.
'
Public Delegate Sub D1(ByVal c As C2, ByVal s As String)
Public Delegate Sub D2(ByVal s As String)
Public Delegate Sub D3()
' A sample class with an instance method and a Shared method.
'
Public Class C2 
Private id As Integer  
Public Sub New(ByVal id As Integer)  
    Me.id = id  
End Sub  
Public Sub M1(ByVal s As String)  
    Console.WriteLine("Instance method M1 on C2:  id = {0}, s = {1}",  
        Me.id, s)  
End Sub  
Public Shared Sub M2(ByVal s As String)  
    Console.WriteLine("Shared method M2 on C2:  s = {0}", s)  
End Sub  
End Class
Public Class Example2 Public Shared Sub Main()  
    Dim c1 As New C2(42)  
    ' Get a MethodInfo for each method.  
    '  
    Dim mi1 As MethodInfo = GetType(C2).GetMethod("M1",  
        BindingFlags.Public Or BindingFlags.Instance)  
    Dim mi2 As MethodInfo = GetType(C2).GetMethod("M2",  
        BindingFlags.Public Or BindingFlags.Static)  
    Dim d1 As D1  
    Dim d2 As D2  
    Dim d3 As D3  
    Console.WriteLine(vbLf & "An instance method closed over C2.")  
    ' In this case, the delegate and the  
    ' method must have the same list of argument types; use  
    ' delegate type D2 with instance method M1.  
    '  
    Dim test As [Delegate] =  
        [Delegate].CreateDelegate(GetType(D2), c1, mi1, False)  
    ' Because False was specified for throwOnBindFailure  
    ' in the call to CreateDelegate, the variable 'test'  
    ' contains Nothing if the method fails to bind (for  
    ' example, if mi1 happened to represent a method of  
    ' some class other than C2).  
    '  
    If test IsNot Nothing Then  
        d2 = CType(test, D2)  
        ' The same instance of C2 is used every time the  
        ' delegate is invoked.  
        d2("Hello, World!")  
        d2("Hi, Mom!")  
    End If  
    Console.WriteLine(vbLf & "An open instance method.")  
    ' In this case, the delegate has one more  
    ' argument than the instance method; this argument comes  
    ' at the beginning, and represents the hidden instance  
    ' argument of the instance method. Use delegate type D1  
    ' with instance method M1.  
    '  
    d1 = CType([Delegate].CreateDelegate(GetType(D1), Nothing, mi1), D1)  
    ' An instance of C2 must be passed in each time the  
    ' delegate is invoked.  
    '  
    d1(c1, "Hello, World!")  
    d1(New C2(5280), "Hi, Mom!")  
    Console.WriteLine(vbLf & "An open Shared method.")  
    ' In this case, the delegate and the method must  
    ' have the same list of argument types; use delegate type  
    ' D2 with Shared method M2.  
    '  
    d2 = CType([Delegate].CreateDelegate(GetType(D2), Nothing, mi2), D2)  
    ' No instances of C2 are involved, because this is a Shared  
    ' method.  
    '  
    d2("Hello, World!")  
    d2("Hi, Mom!")  
    Console.WriteLine(vbLf & "A Shared method closed over the first argument (String).")  
    ' The delegate must omit the first argument of the method.  
    ' A string is passed as the firstArgument parameter, and  
    ' the delegate is bound to this string. Use delegate type  
    ' D3 with Shared method M2.  
    '  
    d3 = CType([Delegate].CreateDelegate(GetType(D3), "Hello, World!", mi2), D3)  
    ' Each time the delegate is invoked, the same string is  
    ' used.  
    d3()  
End Sub  
End Class
' This code example produces the following output:
'
'An instance method closed over C2.
'Instance method M1 on C2: id = 42, s = Hello, World!
'Instance method M1 on C2: id = 42, s = Hi, Mom!
'
'An open instance method.
'Instance method M1 on C2: id = 42, s = Hello, World!
'Instance method M1 on C2: id = 5280, s = Hi, Mom!
'
'An open Shared method.
'Shared method M2 on C2: s = Hello, World!
'Shared method M2 on C2: s = Hi, Mom!
'
'A Shared method closed over the first argument (String).
'Shared method M2 on C2: s = Hello, World!
'

7 (

Imports System.Reflection Imports System.Security.Permissions
' Declare three delegate types for demonstrating the combinations
' of Shared versus instance methods and open versus closed
' delegates.
'
Public Delegate Sub D1(ByVal c As C2, ByVal s As String)
Public Delegate Sub D2(ByVal s As String)
Public Delegate Sub D3()
' A sample class with an instance method and a Shared method.
'
Public Class C2 
Private id As Integer  
Public Sub New(ByVal id As Integer)  
    Me.id = id  
End Sub  
Public Sub M1(ByVal s As String)  
    Console.WriteLine("Instance method M1 on C2:  id = {0}, s = {1}",  
        Me.id, s)  
End Sub  
Public Shared Sub M2(ByVal s As String)  
    Console.WriteLine("Shared method M2 on C2:  s = {0}", s)  
End Sub  
End Class
Public Class Example2 Public Shared Sub Main()  
    Dim c1 As New C2(42)  
    ' Get a MethodInfo for each method.  
    '  
    Dim mi1 As MethodInfo = GetType(C2).GetMethod("M1",  
        BindingFlags.Public Or BindingFlags.Instance)  
    Dim mi2 As MethodInfo = GetType(C2).GetMethod("M2",  
        BindingFlags.Public Or BindingFlags.Static)  
    Dim d1 As D1  
    Dim d2 As D2  
    Dim d3 As D3  
    Console.WriteLine(vbLf & "An instance method closed over C2.")  
    ' In this case, the delegate and the  
    ' method must have the same list of argument types; use  
    ' delegate type D2 with instance method M1.  
    '  
    Dim test As [Delegate] =  
        [Delegate].CreateDelegate(GetType(D2), c1, mi1, False)  
    ' Because False was specified for throwOnBindFailure  
    ' in the call to CreateDelegate, the variable 'test'  
    ' contains Nothing if the method fails to bind (for  
    ' example, if mi1 happened to represent a method of  
    ' some class other than C2).  
    '  
    If test IsNot Nothing Then  
        d2 = CType(test, D2)  
        ' The same instance of C2 is used every time the  
        ' delegate is invoked.  
        d2("Hello, World!")  
        d2("Hi, Mom!")  
    End If  
    Console.WriteLine(vbLf & "An open instance method.")  
    ' In this case, the delegate has one more  
    ' argument than the instance method; this argument comes  
    ' at the beginning, and represents the hidden instance  
    ' argument of the instance method. Use delegate type D1  
    ' with instance method M1.  
    '  
    d1 = CType([Delegate].CreateDelegate(GetType(D1), Nothing, mi1), D1)  
    ' An instance of C2 must be passed in each time the  
    ' delegate is invoked.  
    '  
    d1(c1, "Hello, World!")  
    d1(New C2(5280), "Hi, Mom!")  
    Console.WriteLine(vbLf & "An open Shared method.")  
    ' In this case, the delegate and the method must  
    ' have the same list of argument types; use delegate type  
    ' D2 with Shared method M2.  
    '  
    d2 = CType([Delegate].CreateDelegate(GetType(D2), Nothing, mi2), D2)  
    ' No instances of C2 are involved, because this is a Shared  
    ' method.  
    '  
    d2("Hello, World!")  
    d2("Hi, Mom!")  
    Console.WriteLine(vbLf & "A Shared method closed over the first argument (String).")  
    ' The delegate must omit the first argument of the method.  
    ' A string is passed as the firstArgument parameter, and  
    ' the delegate is bound to this string. Use delegate type  
    ' D3 with Shared method M2.  
    '  
    d3 = CType([Delegate].CreateDelegate(GetType(D3), "Hello, World!", mi2), D3)  
    ' Each time the delegate is invoked, the same string is  
    ' used.  
    d3()  
End Sub  
End Class
' This code example produces the following output:
'
'An instance method closed over C2.
'Instance method M1 on C2: id = 42, s = Hello, World!
'Instance method M1 on C2: id = 42, s = Hi, Mom!
'
'An open instance method.
'Instance method M1 on C2: id = 42, s = Hello, World!
'Instance method M1 on C2: id = 5280, s = Hi, Mom!
'
'An open Shared method.
'Shared method M2 on C2: s = Hello, World!
'Shared method M2 on C2: s = Hi, Mom!
'
'A Shared method closed over the first argument (String).
'Shared method M2 on C2: s = Hello, World!
'

2), so that it is always safe to pass the argument of the delegate to

Imports System.Reflection Imports System.Security.Permissions
' Declare three delegate types for demonstrating the combinations
' of Shared versus instance methods and open versus closed
' delegates.
'
Public Delegate Sub D1(ByVal c As C2, ByVal s As String)
Public Delegate Sub D2(ByVal s As String)
Public Delegate Sub D3()
' A sample class with an instance method and a Shared method.
'
Public Class C2 
Private id As Integer  
Public Sub New(ByVal id As Integer)  
    Me.id = id  
End Sub  
Public Sub M1(ByVal s As String)  
    Console.WriteLine("Instance method M1 on C2:  id = {0}, s = {1}",  
        Me.id, s)  
End Sub  
Public Shared Sub M2(ByVal s As String)  
    Console.WriteLine("Shared method M2 on C2:  s = {0}", s)  
End Sub  
End Class
Public Class Example2 Public Shared Sub Main()  
    Dim c1 As New C2(42)  
    ' Get a MethodInfo for each method.  
    '  
    Dim mi1 As MethodInfo = GetType(C2).GetMethod("M1",  
        BindingFlags.Public Or BindingFlags.Instance)  
    Dim mi2 As MethodInfo = GetType(C2).GetMethod("M2",  
        BindingFlags.Public Or BindingFlags.Static)  
    Dim d1 As D1  
    Dim d2 As D2  
    Dim d3 As D3  
    Console.WriteLine(vbLf & "An instance method closed over C2.")  
    ' In this case, the delegate and the  
    ' method must have the same list of argument types; use  
    ' delegate type D2 with instance method M1.  
    '  
    Dim test As [Delegate] =  
        [Delegate].CreateDelegate(GetType(D2), c1, mi1, False)  
    ' Because False was specified for throwOnBindFailure  
    ' in the call to CreateDelegate, the variable 'test'  
    ' contains Nothing if the method fails to bind (for  
    ' example, if mi1 happened to represent a method of  
    ' some class other than C2).  
    '  
    If test IsNot Nothing Then  
        d2 = CType(test, D2)  
        ' The same instance of C2 is used every time the  
        ' delegate is invoked.  
        d2("Hello, World!")  
        d2("Hi, Mom!")  
    End If  
    Console.WriteLine(vbLf & "An open instance method.")  
    ' In this case, the delegate has one more  
    ' argument than the instance method; this argument comes  
    ' at the beginning, and represents the hidden instance  
    ' argument of the instance method. Use delegate type D1  
    ' with instance method M1.  
    '  
    d1 = CType([Delegate].CreateDelegate(GetType(D1), Nothing, mi1), D1)  
    ' An instance of C2 must be passed in each time the  
    ' delegate is invoked.  
    '  
    d1(c1, "Hello, World!")  
    d1(New C2(5280), "Hi, Mom!")  
    Console.WriteLine(vbLf & "An open Shared method.")  
    ' In this case, the delegate and the method must  
    ' have the same list of argument types; use delegate type  
    ' D2 with Shared method M2.  
    '  
    d2 = CType([Delegate].CreateDelegate(GetType(D2), Nothing, mi2), D2)  
    ' No instances of C2 are involved, because this is a Shared  
    ' method.  
    '  
    d2("Hello, World!")  
    d2("Hi, Mom!")  
    Console.WriteLine(vbLf & "A Shared method closed over the first argument (String).")  
    ' The delegate must omit the first argument of the method.  
    ' A string is passed as the firstArgument parameter, and  
    ' the delegate is bound to this string. Use delegate type  
    ' D3 with Shared method M2.  
    '  
    d3 = CType([Delegate].CreateDelegate(GetType(D3), "Hello, World!", mi2), D3)  
    ' Each time the delegate is invoked, the same string is  
    ' used.  
    d3()  
End Sub  
End Class
' This code example produces the following output:
'
'An instance method closed over C2.
'Instance method M1 on C2: id = 42, s = Hello, World!
'Instance method M1 on C2: id = 42, s = Hi, Mom!
'
'An open instance method.
'Instance method M1 on C2: id = 42, s = Hello, World!
'Instance method M1 on C2: id = 5280, s = Hi, Mom!
'
'An open Shared method.
'Shared method M2 on C2: s = Hello, World!
'Shared method M2 on C2: s = Hi, Mom!
'
'A Shared method closed over the first argument (String).
'Shared method M2 on C2: s = Hello, World!
'

7.

The return type of

Imports System.Reflection Imports System.Security.Permissions
' Declare three delegate types for demonstrating the combinations
' of Shared versus instance methods and open versus closed
' delegates.
'
Public Delegate Sub D1(ByVal c As C2, ByVal s As String)
Public Delegate Sub D2(ByVal s As String)
Public Delegate Sub D3()
' A sample class with an instance method and a Shared method.
'
Public Class C2 
Private id As Integer  
Public Sub New(ByVal id As Integer)  
    Me.id = id  
End Sub  
Public Sub M1(ByVal s As String)  
    Console.WriteLine("Instance method M1 on C2:  id = {0}, s = {1}",  
        Me.id, s)  
End Sub  
Public Shared Sub M2(ByVal s As String)  
    Console.WriteLine("Shared method M2 on C2:  s = {0}", s)  
End Sub  
End Class
Public Class Example2 Public Shared Sub Main()  
    Dim c1 As New C2(42)  
    ' Get a MethodInfo for each method.  
    '  
    Dim mi1 As MethodInfo = GetType(C2).GetMethod("M1",  
        BindingFlags.Public Or BindingFlags.Instance)  
    Dim mi2 As MethodInfo = GetType(C2).GetMethod("M2",  
        BindingFlags.Public Or BindingFlags.Static)  
    Dim d1 As D1  
    Dim d2 As D2  
    Dim d3 As D3  
    Console.WriteLine(vbLf & "An instance method closed over C2.")  
    ' In this case, the delegate and the  
    ' method must have the same list of argument types; use  
    ' delegate type D2 with instance method M1.  
    '  
    Dim test As [Delegate] =  
        [Delegate].CreateDelegate(GetType(D2), c1, mi1, False)  
    ' Because False was specified for throwOnBindFailure  
    ' in the call to CreateDelegate, the variable 'test'  
    ' contains Nothing if the method fails to bind (for  
    ' example, if mi1 happened to represent a method of  
    ' some class other than C2).  
    '  
    If test IsNot Nothing Then  
        d2 = CType(test, D2)  
        ' The same instance of C2 is used every time the  
        ' delegate is invoked.  
        d2("Hello, World!")  
        d2("Hi, Mom!")  
    End If  
    Console.WriteLine(vbLf & "An open instance method.")  
    ' In this case, the delegate has one more  
    ' argument than the instance method; this argument comes  
    ' at the beginning, and represents the hidden instance  
    ' argument of the instance method. Use delegate type D1  
    ' with instance method M1.  
    '  
    d1 = CType([Delegate].CreateDelegate(GetType(D1), Nothing, mi1), D1)  
    ' An instance of C2 must be passed in each time the  
    ' delegate is invoked.  
    '  
    d1(c1, "Hello, World!")  
    d1(New C2(5280), "Hi, Mom!")  
    Console.WriteLine(vbLf & "An open Shared method.")  
    ' In this case, the delegate and the method must  
    ' have the same list of argument types; use delegate type  
    ' D2 with Shared method M2.  
    '  
    d2 = CType([Delegate].CreateDelegate(GetType(D2), Nothing, mi2), D2)  
    ' No instances of C2 are involved, because this is a Shared  
    ' method.  
    '  
    d2("Hello, World!")  
    d2("Hi, Mom!")  
    Console.WriteLine(vbLf & "A Shared method closed over the first argument (String).")  
    ' The delegate must omit the first argument of the method.  
    ' A string is passed as the firstArgument parameter, and  
    ' the delegate is bound to this string. Use delegate type  
    ' D3 with Shared method M2.  
    '  
    d3 = CType([Delegate].CreateDelegate(GetType(D3), "Hello, World!", mi2), D3)  
    ' Each time the delegate is invoked, the same string is  
    ' used.  
    d3()  
End Sub  
End Class
' This code example produces the following output:
'
'An instance method closed over C2.
'Instance method M1 on C2: id = 42, s = Hello, World!
'Instance method M1 on C2: id = 42, s = Hi, Mom!
'
'An open instance method.
'Instance method M1 on C2: id = 42, s = Hello, World!
'Instance method M1 on C2: id = 5280, s = Hi, Mom!
'
'An open Shared method.
'Shared method M2 on C2: s = Hello, World!
'Shared method M2 on C2: s = Hi, Mom!
'
'A Shared method closed over the first argument (String).
'Shared method M2 on C2: s = Hello, World!
'

7 (

Imports System.Reflection Imports System.Security.Permissions
' Declare three delegate types for demonstrating the combinations
' of Shared versus instance methods and open versus closed
' delegates.
'
Public Delegate Sub D1(ByVal c As C2, ByVal s As String)
Public Delegate Sub D2(ByVal s As String)
Public Delegate Sub D3()
' A sample class with an instance method and a Shared method.
'
Public Class C2 
Private id As Integer  
Public Sub New(ByVal id As Integer)  
    Me.id = id  
End Sub  
Public Sub M1(ByVal s As String)  
    Console.WriteLine("Instance method M1 on C2:  id = {0}, s = {1}",  
        Me.id, s)  
End Sub  
Public Shared Sub M2(ByVal s As String)  
    Console.WriteLine("Shared method M2 on C2:  s = {0}", s)  
End Sub  
End Class
Public Class Example2 Public Shared Sub Main()  
    Dim c1 As New C2(42)  
    ' Get a MethodInfo for each method.  
    '  
    Dim mi1 As MethodInfo = GetType(C2).GetMethod("M1",  
        BindingFlags.Public Or BindingFlags.Instance)  
    Dim mi2 As MethodInfo = GetType(C2).GetMethod("M2",  
        BindingFlags.Public Or BindingFlags.Static)  
    Dim d1 As D1  
    Dim d2 As D2  
    Dim d3 As D3  
    Console.WriteLine(vbLf & "An instance method closed over C2.")  
    ' In this case, the delegate and the  
    ' method must have the same list of argument types; use  
    ' delegate type D2 with instance method M1.  
    '  
    Dim test As [Delegate] =  
        [Delegate].CreateDelegate(GetType(D2), c1, mi1, False)  
    ' Because False was specified for throwOnBindFailure  
    ' in the call to CreateDelegate, the variable 'test'  
    ' contains Nothing if the method fails to bind (for  
    ' example, if mi1 happened to represent a method of  
    ' some class other than C2).  
    '  
    If test IsNot Nothing Then  
        d2 = CType(test, D2)  
        ' The same instance of C2 is used every time the  
        ' delegate is invoked.  
        d2("Hello, World!")  
        d2("Hi, Mom!")  
    End If  
    Console.WriteLine(vbLf & "An open instance method.")  
    ' In this case, the delegate has one more  
    ' argument than the instance method; this argument comes  
    ' at the beginning, and represents the hidden instance  
    ' argument of the instance method. Use delegate type D1  
    ' with instance method M1.  
    '  
    d1 = CType([Delegate].CreateDelegate(GetType(D1), Nothing, mi1), D1)  
    ' An instance of C2 must be passed in each time the  
    ' delegate is invoked.  
    '  
    d1(c1, "Hello, World!")  
    d1(New C2(5280), "Hi, Mom!")  
    Console.WriteLine(vbLf & "An open Shared method.")  
    ' In this case, the delegate and the method must  
    ' have the same list of argument types; use delegate type  
    ' D2 with Shared method M2.  
    '  
    d2 = CType([Delegate].CreateDelegate(GetType(D2), Nothing, mi2), D2)  
    ' No instances of C2 are involved, because this is a Shared  
    ' method.  
    '  
    d2("Hello, World!")  
    d2("Hi, Mom!")  
    Console.WriteLine(vbLf & "A Shared method closed over the first argument (String).")  
    ' The delegate must omit the first argument of the method.  
    ' A string is passed as the firstArgument parameter, and  
    ' the delegate is bound to this string. Use delegate type  
    ' D3 with Shared method M2.  
    '  
    d3 = CType([Delegate].CreateDelegate(GetType(D3), "Hello, World!", mi2), D3)  
    ' Each time the delegate is invoked, the same string is  
    ' used.  
    d3()  
End Sub  
End Class
' This code example produces the following output:
'
'An instance method closed over C2.
'Instance method M1 on C2: id = 42, s = Hello, World!
'Instance method M1 on C2: id = 42, s = Hi, Mom!
'
'An open instance method.
'Instance method M1 on C2: id = 42, s = Hello, World!
'Instance method M1 on C2: id = 5280, s = Hi, Mom!
'
'An open Shared method.
'Shared method M2 on C2: s = Hello, World!
'Shared method M2 on C2: s = Hi, Mom!
'
'A Shared method closed over the first argument (String).
'Shared method M2 on C2: s = Hello, World!
'

is more restrictive than the parameter type of the delegate (

Imports System.Reflection Imports System.Security.Permissions
' Declare three delegate types for demonstrating the combinations
' of Shared versus instance methods and open versus closed
' delegates.
'
Public Delegate Sub D1(ByVal c As C2, ByVal s As String)
Public Delegate Sub D2(ByVal s As String)
Public Delegate Sub D3()
' A sample class with an instance method and a Shared method.
'
Public Class C2 
Private id As Integer  
Public Sub New(ByVal id As Integer)  
    Me.id = id  
End Sub  
Public Sub M1(ByVal s As String)  
    Console.WriteLine("Instance method M1 on C2:  id = {0}, s = {1}",  
        Me.id, s)  
End Sub  
Public Shared Sub M2(ByVal s As String)  
    Console.WriteLine("Shared method M2 on C2:  s = {0}", s)  
End Sub  
End Class
Public Class Example2 Public Shared Sub Main()  
    Dim c1 As New C2(42)  
    ' Get a MethodInfo for each method.  
    '  
    Dim mi1 As MethodInfo = GetType(C2).GetMethod("M1",  
        BindingFlags.Public Or BindingFlags.Instance)  
    Dim mi2 As MethodInfo = GetType(C2).GetMethod("M2",  
        BindingFlags.Public Or BindingFlags.Static)  
    Dim d1 As D1  
    Dim d2 As D2  
    Dim d3 As D3  
    Console.WriteLine(vbLf & "An instance method closed over C2.")  
    ' In this case, the delegate and the  
    ' method must have the same list of argument types; use  
    ' delegate type D2 with instance method M1.  
    '  
    Dim test As [Delegate] =  
        [Delegate].CreateDelegate(GetType(D2), c1, mi1, False)  
    ' Because False was specified for throwOnBindFailure  
    ' in the call to CreateDelegate, the variable 'test'  
    ' contains Nothing if the method fails to bind (for  
    ' example, if mi1 happened to represent a method of  
    ' some class other than C2).  
    '  
    If test IsNot Nothing Then  
        d2 = CType(test, D2)  
        ' The same instance of C2 is used every time the  
        ' delegate is invoked.  
        d2("Hello, World!")  
        d2("Hi, Mom!")  
    End If  
    Console.WriteLine(vbLf & "An open instance method.")  
    ' In this case, the delegate has one more  
    ' argument than the instance method; this argument comes  
    ' at the beginning, and represents the hidden instance  
    ' argument of the instance method. Use delegate type D1  
    ' with instance method M1.  
    '  
    d1 = CType([Delegate].CreateDelegate(GetType(D1), Nothing, mi1), D1)  
    ' An instance of C2 must be passed in each time the  
    ' delegate is invoked.  
    '  
    d1(c1, "Hello, World!")  
    d1(New C2(5280), "Hi, Mom!")  
    Console.WriteLine(vbLf & "An open Shared method.")  
    ' In this case, the delegate and the method must  
    ' have the same list of argument types; use delegate type  
    ' D2 with Shared method M2.  
    '  
    d2 = CType([Delegate].CreateDelegate(GetType(D2), Nothing, mi2), D2)  
    ' No instances of C2 are involved, because this is a Shared  
    ' method.  
    '  
    d2("Hello, World!")  
    d2("Hi, Mom!")  
    Console.WriteLine(vbLf & "A Shared method closed over the first argument (String).")  
    ' The delegate must omit the first argument of the method.  
    ' A string is passed as the firstArgument parameter, and  
    ' the delegate is bound to this string. Use delegate type  
    ' D3 with Shared method M2.  
    '  
    d3 = CType([Delegate].CreateDelegate(GetType(D3), "Hello, World!", mi2), D3)  
    ' Each time the delegate is invoked, the same string is  
    ' used.  
    d3()  
End Sub  
End Class
' This code example produces the following output:
'
'An instance method closed over C2.
'Instance method M1 on C2: id = 42, s = Hello, World!
'Instance method M1 on C2: id = 42, s = Hi, Mom!
'
'An open instance method.
'Instance method M1 on C2: id = 42, s = Hello, World!
'Instance method M1 on C2: id = 5280, s = Hi, Mom!
'
'An open Shared method.
'Shared method M2 on C2: s = Hello, World!
'Shared method M2 on C2: s = Hi, Mom!
'
'A Shared method closed over the first argument (String).
'Shared method M2 on C2: s = Hello, World!
'

2), so that it is always safe to cast the return type of the method to the return type of the delegate.

The code example produces no output.

using System; using System.Reflection; // Define two classes to use in the demonstration, a base class and // a class that derives from it. // public class Base { } public class Derived : Base {

// Define a static method to use in the demonstration. The method
// takes an instance of Base and returns an instance of Derived.
// For the purposes of the demonstration, it is not necessary for
// the method to do anything useful.
//
public static Derived MyMethod(Base arg)
{
    Base dummy = arg;
    return new Derived();
}

}
// Define a delegate that takes an instance of Derived and returns an
// instance of Base.
//
public delegate Base Example5(Derived arg);
class Test
{public static void Main()
{
    // The binding flags needed to retrieve MyMethod.
    BindingFlags flags = BindingFlags.Public | BindingFlags.Static;
    // Get a MethodInfo that represents MyMethod.
    MethodInfo minfo = typeof(Derived).GetMethod("MyMethod", flags);
    // Demonstrate contravariance of parameter types and covariance
    // of return types by using the delegate Example5 to represent
    // MyMethod. The delegate binds to the method because the
    // parameter of the delegate is more restrictive than the
    // parameter of the method (that is, the delegate accepts an
    // instance of Derived, which can always be safely passed to
    // a parameter of type Base), and the return type of MyMethod
    // is more restrictive than the return type of Example5 (that
    // is, the method returns an instance of Derived, which can
    // always be safely cast to type Base).
    //
    Example5 ex =
        (Example5)Delegate.CreateDelegate(typeof(Example5), minfo);
    // Execute MyMethod using the delegate Example5.
    //
    Base b = ex(new Derived());
}
}

open System open System.Reflection // Define two classes to use in the demonstration, a base class and // a class that derives from it. type Base() = class end type Derived() =

inherit Base()
// Define a static method to use in the demonstration. The method
// takes an instance of Base and returns an instance of Derived.
// For the purposes of the demonstration, it is not necessary for
// the method to do anything useful.
static member MyMethod(arg: Base) =
    Derived()

// Define a delegate that takes an instance of Derived and returns an
// instance of Base.
type Example = delegate of Derived -> Base
// The binding flags needed to retrieve MyMethod.
let flags = BindingFlags.Public ||| BindingFlags.Static
// Get a MethodInfo that represents MyMethod.
let minfo = typeof.GetMethod("MyMethod", flags)
// Demonstrate contravariance of parameter types and covariance
// of return types by using the delegate Example to represent
// MyMethod. The delegate binds to the method because the
// parameter of the delegate is more restrictive than the
// parameter of the method (that is, the delegate accepts an
// instance of Derived, which can always be safely passed to
// a parameter of type Base), and the return type of MyMethod
// is more restrictive than the return type of Example (that
// is, the method returns an instance of Derived, which can
// always be safely cast to type Base).
let ex = Delegate.CreateDelegate(typeof, minfo) :?> Example
// Execute MyMethod using the delegate Example.
let b = Derived() |> ex.Invoke

Imports System.Reflection ' Define two classes to use in the demonstration, a base class and ' a class that derives from it. ' Public Class Base End Class Public Class Derived

Inherits Base
' Define a Shared method to use in the demonstration. The method 
' takes an instance of Base and returns an instance of Derived.  
' For the purposes of the demonstration, it is not necessary for 
' the method to do anything useful. 
'
Public Shared Function MyMethod(ByVal arg As Base) As Derived
    Dim dummy As Base = arg
    Return New Derived()
End Function

End Class
' Define a delegate that takes an instance of Derived and returns an
' instance of Base.
'
Public Delegate Function Example(ByVal arg As Derived) As Base
Module TestSub Main()
    ' The binding flags needed to retrieve MyMethod.
    Dim flags As BindingFlags = _
        BindingFlags.Public Or BindingFlags.Static
    ' Get a MethodInfo that represents MyMethod.
    Dim minfo As MethodInfo = _
        GetType(Derived).GetMethod("MyMethod", flags)
    ' Demonstrate contravariance of parameter types and covariance
    ' of return types by using the delegate Example to represent
    ' MyMethod. The delegate binds to the method because the
    ' parameter of the delegate is more restrictive than the 
    ' parameter of the method (that is, the delegate accepts an
    ' instance of Derived, which can always be safely passed to
    ' a parameter of type Base), and the return type of MyMethod
    ' is more restrictive than the return type of Example (that
    ' is, the method returns an instance of Derived, which can
    ' always be safely cast to type Base). 
    '
    Dim ex As Example = CType( _
        [Delegate].CreateDelegate(GetType(Example), minfo), _
        Example _
    )
    ' Execute MyMethod using the delegate Example.
    '        
    Dim b As Base = ex(New Derived())
End Sub
End Module

and methods

The functionality of these two overloads is the same except that one allows you to specify whether to throw on failure to bind, and the other always throws.

The delegate type and the method must have compatible return types. That is, the return type of

open System open System.Reflection // Define two classes to use in the demonstration, a base class and // a class that derives from it. type Base() = class end type Derived() =

inherit Base()
// Define a static method to use in the demonstration. The method
// takes an instance of Base and returns an instance of Derived.
// For the purposes of the demonstration, it is not necessary for
// the method to do anything useful.
static member MyMethod(arg: Base) =
    Derived()

// Define a delegate that takes an instance of Derived and returns an
// instance of Base.
type Example = delegate of Derived -> Base
// The binding flags needed to retrieve MyMethod.
let flags = BindingFlags.Public ||| BindingFlags.Static
// Get a MethodInfo that represents MyMethod.
let minfo = typeof.GetMethod("MyMethod", flags)
// Demonstrate contravariance of parameter types and covariance
// of return types by using the delegate Example to represent
// MyMethod. The delegate binds to the method because the
// parameter of the delegate is more restrictive than the
// parameter of the method (that is, the delegate accepts an
// instance of Derived, which can always be safely passed to
// a parameter of type Base), and the return type of MyMethod
// is more restrictive than the return type of Example (that
// is, the method returns an instance of Derived, which can
// always be safely cast to type Base).
let ex = Delegate.CreateDelegate(typeof, minfo) :?> Example
// Execute MyMethod using the delegate Example.
let b = Derived() |> ex.Invoke

2 must be assignable to the return type of

open System open System.Reflection // Define two classes to use in the demonstration, a base class and // a class that derives from it. type Base() = class end type Derived() =

inherit Base()
// Define a static method to use in the demonstration. The method
// takes an instance of Base and returns an instance of Derived.
// For the purposes of the demonstration, it is not necessary for
// the method to do anything useful.
static member MyMethod(arg: Base) =
    Derived()

// Define a delegate that takes an instance of Derived and returns an
// instance of Base.
type Example = delegate of Derived -> Base
// The binding flags needed to retrieve MyMethod.
let flags = BindingFlags.Public ||| BindingFlags.Static
// Get a MethodInfo that represents MyMethod.
let minfo = typeof.GetMethod("MyMethod", flags)
// Demonstrate contravariance of parameter types and covariance
// of return types by using the delegate Example to represent
// MyMethod. The delegate binds to the method because the
// parameter of the delegate is more restrictive than the
// parameter of the method (that is, the delegate accepts an
// instance of Derived, which can always be safely passed to
// a parameter of type Base), and the return type of MyMethod
// is more restrictive than the return type of Example (that
// is, the method returns an instance of Derived, which can
// always be safely cast to type Base).
let ex = Delegate.CreateDelegate(typeof, minfo) :?> Example
// Execute MyMethod using the delegate Example.
let b = Derived() |> ex.Invoke

3.

open System open System.Reflection // Define two classes to use in the demonstration, a base class and // a class that derives from it. type Base() = class end type Derived() =

inherit Base()
// Define a static method to use in the demonstration. The method
// takes an instance of Base and returns an instance of Derived.
// For the purposes of the demonstration, it is not necessary for
// the method to do anything useful.
static member MyMethod(arg: Base) =
    Derived()

// Define a delegate that takes an instance of Derived and returns an
// instance of Base.
type Example = delegate of Derived -> Base
// The binding flags needed to retrieve MyMethod.
let flags = BindingFlags.Public ||| BindingFlags.Static
// Get a MethodInfo that represents MyMethod.
let minfo = typeof.GetMethod("MyMethod", flags)
// Demonstrate contravariance of parameter types and covariance
// of return types by using the delegate Example to represent
// MyMethod. The delegate binds to the method because the
// parameter of the delegate is more restrictive than the
// parameter of the method (that is, the delegate accepts an
// instance of Derived, which can always be safely passed to
// a parameter of type Base), and the return type of MyMethod
// is more restrictive than the return type of Example (that
// is, the method returns an instance of Derived, which can
// always be safely cast to type Base).
let ex = Delegate.CreateDelegate(typeof, minfo) :?> Example
// Execute MyMethod using the delegate Example.
let b = Derived() |> ex.Invoke

4, the second parameter to these overloads, is the first argument of the method the delegate represents. If

open System open System.Reflection // Define two classes to use in the demonstration, a base class and // a class that derives from it. type Base() = class end type Derived() =

inherit Base()
// Define a static method to use in the demonstration. The method
// takes an instance of Base and returns an instance of Derived.
// For the purposes of the demonstration, it is not necessary for
// the method to do anything useful.
static member MyMethod(arg: Base) =
    Derived()

// Define a delegate that takes an instance of Derived and returns an
// instance of Base.
type Example = delegate of Derived -> Base
// The binding flags needed to retrieve MyMethod.
let flags = BindingFlags.Public ||| BindingFlags.Static
// Get a MethodInfo that represents MyMethod.
let minfo = typeof.GetMethod("MyMethod", flags)
// Demonstrate contravariance of parameter types and covariance
// of return types by using the delegate Example to represent
// MyMethod. The delegate binds to the method because the
// parameter of the delegate is more restrictive than the
// parameter of the method (that is, the delegate accepts an
// instance of Derived, which can always be safely passed to
// a parameter of type Base), and the return type of MyMethod
// is more restrictive than the return type of Example (that
// is, the method returns an instance of Derived, which can
// always be safely cast to type Base).
let ex = Delegate.CreateDelegate(typeof, minfo) :?> Example
// Execute MyMethod using the delegate Example.
let b = Derived() |> ex.Invoke

4 is supplied, it is passed to

open System open System.Reflection // Define two classes to use in the demonstration, a base class and // a class that derives from it. type Base() = class end type Derived() =

inherit Base()
// Define a static method to use in the demonstration. The method
// takes an instance of Base and returns an instance of Derived.
// For the purposes of the demonstration, it is not necessary for
// the method to do anything useful.
static member MyMethod(arg: Base) =
    Derived()

// Define a delegate that takes an instance of Derived and returns an
// instance of Base.
type Example = delegate of Derived -> Base
// The binding flags needed to retrieve MyMethod.
let flags = BindingFlags.Public ||| BindingFlags.Static
// Get a MethodInfo that represents MyMethod.
let minfo = typeof.GetMethod("MyMethod", flags)
// Demonstrate contravariance of parameter types and covariance
// of return types by using the delegate Example to represent
// MyMethod. The delegate binds to the method because the
// parameter of the delegate is more restrictive than the
// parameter of the method (that is, the delegate accepts an
// instance of Derived, which can always be safely passed to
// a parameter of type Base), and the return type of MyMethod
// is more restrictive than the return type of Example (that
// is, the method returns an instance of Derived, which can
// always be safely cast to type Base).
let ex = Delegate.CreateDelegate(typeof, minfo) :?> Example
// Execute MyMethod using the delegate Example.
let b = Derived() |> ex.Invoke

2 every time the delegate is invoked;

open System open System.Reflection // Define two classes to use in the demonstration, a base class and // a class that derives from it. type Base() = class end type Derived() =

inherit Base()
// Define a static method to use in the demonstration. The method
// takes an instance of Base and returns an instance of Derived.
// For the purposes of the demonstration, it is not necessary for
// the method to do anything useful.
static member MyMethod(arg: Base) =
    Derived()

// Define a delegate that takes an instance of Derived and returns an
// instance of Base.
type Example = delegate of Derived -> Base
// The binding flags needed to retrieve MyMethod.
let flags = BindingFlags.Public ||| BindingFlags.Static
// Get a MethodInfo that represents MyMethod.
let minfo = typeof.GetMethod("MyMethod", flags)
// Demonstrate contravariance of parameter types and covariance
// of return types by using the delegate Example to represent
// MyMethod. The delegate binds to the method because the
// parameter of the delegate is more restrictive than the
// parameter of the method (that is, the delegate accepts an
// instance of Derived, which can always be safely passed to
// a parameter of type Base), and the return type of MyMethod
// is more restrictive than the return type of Example (that
// is, the method returns an instance of Derived, which can
// always be safely cast to type Base).
let ex = Delegate.CreateDelegate(typeof, minfo) :?> Example
// Execute MyMethod using the delegate Example.
let b = Derived() |> ex.Invoke

4 is said to be bound to the delegate, and the delegate is said to be closed over its first argument. If

open System open System.Reflection // Define two classes to use in the demonstration, a base class and // a class that derives from it. type Base() = class end type Derived() =

inherit Base()
// Define a static method to use in the demonstration. The method
// takes an instance of Base and returns an instance of Derived.
// For the purposes of the demonstration, it is not necessary for
// the method to do anything useful.
static member MyMethod(arg: Base) =
    Derived()

// Define a delegate that takes an instance of Derived and returns an
// instance of Base.
type Example = delegate of Derived -> Base
// The binding flags needed to retrieve MyMethod.
let flags = BindingFlags.Public ||| BindingFlags.Static
// Get a MethodInfo that represents MyMethod.
let minfo = typeof.GetMethod("MyMethod", flags)
// Demonstrate contravariance of parameter types and covariance
// of return types by using the delegate Example to represent
// MyMethod. The delegate binds to the method because the
// parameter of the delegate is more restrictive than the
// parameter of the method (that is, the delegate accepts an
// instance of Derived, which can always be safely passed to
// a parameter of type Base), and the return type of MyMethod
// is more restrictive than the return type of Example (that
// is, the method returns an instance of Derived, which can
// always be safely cast to type Base).
let ex = Delegate.CreateDelegate(typeof, minfo) :?> Example
// Execute MyMethod using the delegate Example.
let b = Derived() |> ex.Invoke

2 is

Imports System.Reflection Imports System.Security.Permissions ' Declare three delegate types for demonstrating the combinations ' of Shared versus instance methods and open versus closed ' delegates. ' Public Delegate Sub D1(ByVal c As C2, ByVal s As String) Public Delegate Sub D2(ByVal s As String) Public Delegate Sub D3() ' A sample class with an instance method and a Shared method. ' Public Class C2

Private id As Integer
Public Sub New(ByVal id As Integer)
    Me.id = id
End Sub
Public Sub M1(ByVal s As String)
    Console.WriteLine("Instance method M1 on C2:  id = {0}, s = {1}",
        Me.id, s)
End Sub
Public Shared Sub M2(ByVal s As String)
    Console.WriteLine("Shared method M2 on C2:  s = {0}", s)
End Sub

End Class
Public Class Example2Public Shared Sub Main()
    Dim c1 As New C2(42)
    ' Get a MethodInfo for each method.
    '
    Dim mi1 As MethodInfo = GetType(C2).GetMethod("M1",
        BindingFlags.Public Or BindingFlags.Instance)
    Dim mi2 As MethodInfo = GetType(C2).GetMethod("M2",
        BindingFlags.Public Or BindingFlags.Static)
    Dim d1 As D1
    Dim d2 As D2
    Dim d3 As D3
    Console.WriteLine(vbLf & "An instance method closed over C2.")
    ' In this case, the delegate and the
    ' method must have the same list of argument types; use
    ' delegate type D2 with instance method M1.
    '
    Dim test As [Delegate] =
        [Delegate].CreateDelegate(GetType(D2), c1, mi1, False)
    ' Because False was specified for throwOnBindFailure 
    ' in the call to CreateDelegate, the variable 'test'
    ' contains Nothing if the method fails to bind (for 
    ' example, if mi1 happened to represent a method of 
    ' some class other than C2).
    '
    If test IsNot Nothing Then
        d2 = CType(test, D2)
        ' The same instance of C2 is used every time the
        ' delegate is invoked.
        d2("Hello, World!")
        d2("Hi, Mom!")
    End If
    Console.WriteLine(vbLf & "An open instance method.")
    ' In this case, the delegate has one more 
    ' argument than the instance method; this argument comes
    ' at the beginning, and represents the hidden instance
    ' argument of the instance method. Use delegate type D1
    ' with instance method M1.
    '
    d1 = CType([Delegate].CreateDelegate(GetType(D1), Nothing, mi1), D1)
    ' An instance of C2 must be passed in each time the 
    ' delegate is invoked.
    '
    d1(c1, "Hello, World!")
    d1(New C2(5280), "Hi, Mom!")
    Console.WriteLine(vbLf & "An open Shared method.")
    ' In this case, the delegate and the method must 
    ' have the same list of argument types; use delegate type
    ' D2 with Shared method M2.
    '
    d2 = CType([Delegate].CreateDelegate(GetType(D2), Nothing, mi2), D2)
    ' No instances of C2 are involved, because this is a Shared
    ' method. 
    '
    d2("Hello, World!")
    d2("Hi, Mom!")
    Console.WriteLine(vbLf & "A Shared method closed over the first argument (String).")
    ' The delegate must omit the first argument of the method.
    ' A string is passed as the firstArgument parameter, and 
    ' the delegate is bound to this string. Use delegate type 
    ' D3 with Shared method M2. 
    '
    d3 = CType([Delegate].CreateDelegate(GetType(D3), "Hello, World!", mi2), D3)
    ' Each time the delegate is invoked, the same string is
    ' used.
    d3()
End Sub
End Class
' This code example produces the following output:
'
'An instance method closed over C2.
'Instance method M1 on C2: id = 42, s = Hello, World!
'Instance method M1 on C2: id = 42, s = Hi, Mom!
'
'An open instance method.
'Instance method M1 on C2: id = 42, s = Hello, World!
'Instance method M1 on C2: id = 5280, s = Hi, Mom!
'
'An open Shared method.
'Shared method M2 on C2: s = Hello, World!
'Shared method M2 on C2: s = Hi, Mom!
'
'A Shared method closed over the first argument (String).
'Shared method M2 on C2: s = Hello, World!
'

5 (

Imports System.Reflection Imports System.Security.Permissions ' Declare three delegate types for demonstrating the combinations ' of Shared versus instance methods and open versus closed ' delegates. ' Public Delegate Sub D1(ByVal c As C2, ByVal s As String) Public Delegate Sub D2(ByVal s As String) Public Delegate Sub D3() ' A sample class with an instance method and a Shared method. ' Public Class C2

Private id As Integer
Public Sub New(ByVal id As Integer)
    Me.id = id
End Sub
Public Sub M1(ByVal s As String)
    Console.WriteLine("Instance method M1 on C2:  id = {0}, s = {1}",
        Me.id, s)
End Sub
Public Shared Sub M2(ByVal s As String)
    Console.WriteLine("Shared method M2 on C2:  s = {0}", s)
End Sub

End Class
Public Class Example2Public Shared Sub Main()
    Dim c1 As New C2(42)
    ' Get a MethodInfo for each method.
    '
    Dim mi1 As MethodInfo = GetType(C2).GetMethod("M1",
        BindingFlags.Public Or BindingFlags.Instance)
    Dim mi2 As MethodInfo = GetType(C2).GetMethod("M2",
        BindingFlags.Public Or BindingFlags.Static)
    Dim d1 As D1
    Dim d2 As D2
    Dim d3 As D3
    Console.WriteLine(vbLf & "An instance method closed over C2.")
    ' In this case, the delegate and the
    ' method must have the same list of argument types; use
    ' delegate type D2 with instance method M1.
    '
    Dim test As [Delegate] =
        [Delegate].CreateDelegate(GetType(D2), c1, mi1, False)
    ' Because False was specified for throwOnBindFailure 
    ' in the call to CreateDelegate, the variable 'test'
    ' contains Nothing if the method fails to bind (for 
    ' example, if mi1 happened to represent a method of 
    ' some class other than C2).
    '
    If test IsNot Nothing Then
        d2 = CType(test, D2)
        ' The same instance of C2 is used every time the
        ' delegate is invoked.
        d2("Hello, World!")
        d2("Hi, Mom!")
    End If
    Console.WriteLine(vbLf & "An open instance method.")
    ' In this case, the delegate has one more 
    ' argument than the instance method; this argument comes
    ' at the beginning, and represents the hidden instance
    ' argument of the instance method. Use delegate type D1
    ' with instance method M1.
    '
    d1 = CType([Delegate].CreateDelegate(GetType(D1), Nothing, mi1), D1)
    ' An instance of C2 must be passed in each time the 
    ' delegate is invoked.
    '
    d1(c1, "Hello, World!")
    d1(New C2(5280), "Hi, Mom!")
    Console.WriteLine(vbLf & "An open Shared method.")
    ' In this case, the delegate and the method must 
    ' have the same list of argument types; use delegate type
    ' D2 with Shared method M2.
    '
    d2 = CType([Delegate].CreateDelegate(GetType(D2), Nothing, mi2), D2)
    ' No instances of C2 are involved, because this is a Shared
    ' method. 
    '
    d2("Hello, World!")
    d2("Hi, Mom!")
    Console.WriteLine(vbLf & "A Shared method closed over the first argument (String).")
    ' The delegate must omit the first argument of the method.
    ' A string is passed as the firstArgument parameter, and 
    ' the delegate is bound to this string. Use delegate type 
    ' D3 with Shared method M2. 
    '
    d3 = CType([Delegate].CreateDelegate(GetType(D3), "Hello, World!", mi2), D3)
    ' Each time the delegate is invoked, the same string is
    ' used.
    d3()
End Sub
End Class
' This code example produces the following output:
'
'An instance method closed over C2.
'Instance method M1 on C2: id = 42, s = Hello, World!
'Instance method M1 on C2: id = 42, s = Hi, Mom!
'
'An open instance method.
'Instance method M1 on C2: id = 42, s = Hello, World!
'Instance method M1 on C2: id = 5280, s = Hi, Mom!
'
'An open Shared method.
'Shared method M2 on C2: s = Hello, World!
'Shared method M2 on C2: s = Hi, Mom!
'
'A Shared method closed over the first argument (String).
'Shared method M2 on C2: s = Hello, World!
'

6 in Visual Basic), the argument list supplied when invoking the delegate includes all parameters except the first; if

open System open System.Reflection // Define two classes to use in the demonstration, a base class and // a class that derives from it. type Base() = class end type Derived() =

inherit Base()
// Define a static method to use in the demonstration. The method
// takes an instance of Base and returns an instance of Derived.
// For the purposes of the demonstration, it is not necessary for
// the method to do anything useful.
static member MyMethod(arg: Base) =
    Derived()

// Define a delegate that takes an instance of Derived and returns an
// instance of Base.
type Example = delegate of Derived -> Base
// The binding flags needed to retrieve MyMethod.
let flags = BindingFlags.Public ||| BindingFlags.Static
// Get a MethodInfo that represents MyMethod.
let minfo = typeof.GetMethod("MyMethod", flags)
// Demonstrate contravariance of parameter types and covariance
// of return types by using the delegate Example to represent
// MyMethod. The delegate binds to the method because the
// parameter of the delegate is more restrictive than the
// parameter of the method (that is, the delegate accepts an
// instance of Derived, which can always be safely passed to
// a parameter of type Base), and the return type of MyMethod
// is more restrictive than the return type of Example (that
// is, the method returns an instance of Derived, which can
// always be safely cast to type Base).
let ex = Delegate.CreateDelegate(typeof, minfo) :?> Example
// Execute MyMethod using the delegate Example.
let b = Derived() |> ex.Invoke

2 is an instance method, then

open System open System.Reflection // Define two classes to use in the demonstration, a base class and // a class that derives from it. type Base() = class end type Derived() =

inherit Base()
// Define a static method to use in the demonstration. The method
// takes an instance of Base and returns an instance of Derived.
// For the purposes of the demonstration, it is not necessary for
// the method to do anything useful.
static member MyMethod(arg: Base) =
    Derived()

// Define a delegate that takes an instance of Derived and returns an
// instance of Base.
type Example = delegate of Derived -> Base
// The binding flags needed to retrieve MyMethod.
let flags = BindingFlags.Public ||| BindingFlags.Static
// Get a MethodInfo that represents MyMethod.
let minfo = typeof.GetMethod("MyMethod", flags)
// Demonstrate contravariance of parameter types and covariance
// of return types by using the delegate Example to represent
// MyMethod. The delegate binds to the method because the
// parameter of the delegate is more restrictive than the
// parameter of the method (that is, the delegate accepts an
// instance of Derived, which can always be safely passed to
// a parameter of type Base), and the return type of MyMethod
// is more restrictive than the return type of Example (that
// is, the method returns an instance of Derived, which can
// always be safely cast to type Base).
let ex = Delegate.CreateDelegate(typeof, minfo) :?> Example
// Execute MyMethod using the delegate Example.
let b = Derived() |> ex.Invoke

4 is passed to the hidden instance parameter (represented by

Imports System.Reflection ' Define two classes to use in the demonstration, a base class and ' a class that derives from it. ' Public Class Base End Class Public Class Derived

Inherits Base
' Define a Shared method to use in the demonstration. The method 
' takes an instance of Base and returns an instance of Derived.  
' For the purposes of the demonstration, it is not necessary for 
' the method to do anything useful. 
'
Public Shared Function MyMethod(ByVal arg As Base) As Derived
    Dim dummy As Base = arg
    Return New Derived()
End Function

End Class
' Define a delegate that takes an instance of Derived and returns an
' instance of Base.
'
Public Delegate Function Example(ByVal arg As Derived) As Base
Module TestSub Main()
    ' The binding flags needed to retrieve MyMethod.
    Dim flags As BindingFlags = _
        BindingFlags.Public Or BindingFlags.Static
    ' Get a MethodInfo that represents MyMethod.
    Dim minfo As MethodInfo = _
        GetType(Derived).GetMethod("MyMethod", flags)
    ' Demonstrate contravariance of parameter types and covariance
    ' of return types by using the delegate Example to represent
    ' MyMethod. The delegate binds to the method because the
    ' parameter of the delegate is more restrictive than the 
    ' parameter of the method (that is, the delegate accepts an
    ' instance of Derived, which can always be safely passed to
    ' a parameter of type Base), and the return type of MyMethod
    ' is more restrictive than the return type of Example (that
    ' is, the method returns an instance of Derived, which can
    ' always be safely cast to type Base). 
    '
    Dim ex As Example = CType( _
        [Delegate].CreateDelegate(GetType(Example), minfo), _
        Example _
    )
    ' Execute MyMethod using the delegate Example.
    '        
    Dim b As Base = ex(New Derived())
End Sub
End Module

3 in C#, or by

Imports System.Reflection ' Define two classes to use in the demonstration, a base class and ' a class that derives from it. ' Public Class Base End Class Public Class Derived

Inherits Base
' Define a Shared method to use in the demonstration. The method 
' takes an instance of Base and returns an instance of Derived.  
' For the purposes of the demonstration, it is not necessary for 
' the method to do anything useful. 
'
Public Shared Function MyMethod(ByVal arg As Base) As Derived
    Dim dummy As Base = arg
    Return New Derived()
End Function

End Class
' Define a delegate that takes an instance of Derived and returns an
' instance of Base.
'
Public Delegate Function Example(ByVal arg As Derived) As Base
Module TestSub Main()
    ' The binding flags needed to retrieve MyMethod.
    Dim flags As BindingFlags = _
        BindingFlags.Public Or BindingFlags.Static
    ' Get a MethodInfo that represents MyMethod.
    Dim minfo As MethodInfo = _
        GetType(Derived).GetMethod("MyMethod", flags)
    ' Demonstrate contravariance of parameter types and covariance
    ' of return types by using the delegate Example to represent
    ' MyMethod. The delegate binds to the method because the
    ' parameter of the delegate is more restrictive than the 
    ' parameter of the method (that is, the delegate accepts an
    ' instance of Derived, which can always be safely passed to
    ' a parameter of type Base), and the return type of MyMethod
    ' is more restrictive than the return type of Example (that
    ' is, the method returns an instance of Derived, which can
    ' always be safely cast to type Base). 
    '
    Dim ex As Example = CType( _
        [Delegate].CreateDelegate(GetType(Example), minfo), _
        Example _
    )
    ' Execute MyMethod using the delegate Example.
    '        
    Dim b As Base = ex(New Derived())
End Sub
End Module

4 in Visual Basic).

If

open System open System.Reflection // Define two classes to use in the demonstration, a base class and // a class that derives from it. type Base() = class end type Derived() =

inherit Base()
// Define a static method to use in the demonstration. The method
// takes an instance of Base and returns an instance of Derived.
// For the purposes of the demonstration, it is not necessary for
// the method to do anything useful.
static member MyMethod(arg: Base) =
    Derived()

// Define a delegate that takes an instance of Derived and returns an
// instance of Base.
type Example = delegate of Derived -> Base
// The binding flags needed to retrieve MyMethod.
let flags = BindingFlags.Public ||| BindingFlags.Static
// Get a MethodInfo that represents MyMethod.
let minfo = typeof.GetMethod("MyMethod", flags)
// Demonstrate contravariance of parameter types and covariance
// of return types by using the delegate Example to represent
// MyMethod. The delegate binds to the method because the
// parameter of the delegate is more restrictive than the
// parameter of the method (that is, the delegate accepts an
// instance of Derived, which can always be safely passed to
// a parameter of type Base), and the return type of MyMethod
// is more restrictive than the return type of Example (that
// is, the method returns an instance of Derived, which can
// always be safely cast to type Base).
let ex = Delegate.CreateDelegate(typeof, minfo) :?> Example
// Execute MyMethod using the delegate Example.
let b = Derived() |> ex.Invoke

4 is supplied, the first parameter of

open System open System.Reflection // Define two classes to use in the demonstration, a base class and // a class that derives from it. type Base() = class end type Derived() =

inherit Base()
// Define a static method to use in the demonstration. The method
// takes an instance of Base and returns an instance of Derived.
// For the purposes of the demonstration, it is not necessary for
// the method to do anything useful.
static member MyMethod(arg: Base) =
    Derived()

// Define a delegate that takes an instance of Derived and returns an
// instance of Base.
type Example = delegate of Derived -> Base
// The binding flags needed to retrieve MyMethod.
let flags = BindingFlags.Public ||| BindingFlags.Static
// Get a MethodInfo that represents MyMethod.
let minfo = typeof.GetMethod("MyMethod", flags)
// Demonstrate contravariance of parameter types and covariance
// of return types by using the delegate Example to represent
// MyMethod. The delegate binds to the method because the
// parameter of the delegate is more restrictive than the
// parameter of the method (that is, the delegate accepts an
// instance of Derived, which can always be safely passed to
// a parameter of type Base), and the return type of MyMethod
// is more restrictive than the return type of Example (that
// is, the method returns an instance of Derived, which can
// always be safely cast to type Base).
let ex = Delegate.CreateDelegate(typeof, minfo) :?> Example
// Execute MyMethod using the delegate Example.
let b = Derived() |> ex.Invoke

2 must be a reference type, and

open System open System.Reflection // Define two classes to use in the demonstration, a base class and // a class that derives from it. type Base() = class end type Derived() =

inherit Base()
// Define a static method to use in the demonstration. The method
// takes an instance of Base and returns an instance of Derived.
// For the purposes of the demonstration, it is not necessary for
// the method to do anything useful.
static member MyMethod(arg: Base) =
    Derived()

// Define a delegate that takes an instance of Derived and returns an
// instance of Base.
type Example = delegate of Derived -> Base
// The binding flags needed to retrieve MyMethod.
let flags = BindingFlags.Public ||| BindingFlags.Static
// Get a MethodInfo that represents MyMethod.
let minfo = typeof.GetMethod("MyMethod", flags)
// Demonstrate contravariance of parameter types and covariance
// of return types by using the delegate Example to represent
// MyMethod. The delegate binds to the method because the
// parameter of the delegate is more restrictive than the
// parameter of the method (that is, the delegate accepts an
// instance of Derived, which can always be safely passed to
// a parameter of type Base), and the return type of MyMethod
// is more restrictive than the return type of Example (that
// is, the method returns an instance of Derived, which can
// always be safely cast to type Base).
let ex = Delegate.CreateDelegate(typeof, minfo) :?> Example
// Execute MyMethod using the delegate Example.
let b = Derived() |> ex.Invoke

4 must be compatible with that type.

Important

If

open System open System.Reflection // Define two classes to use in the demonstration, a base class and // a class that derives from it. type Base() = class end type Derived() =

inherit Base()
// Define a static method to use in the demonstration. The method
// takes an instance of Base and returns an instance of Derived.
// For the purposes of the demonstration, it is not necessary for
// the method to do anything useful.
static member MyMethod(arg: Base) =
    Derived()

// Define a delegate that takes an instance of Derived and returns an
// instance of Base.
type Example = delegate of Derived -> Base
// The binding flags needed to retrieve MyMethod.
let flags = BindingFlags.Public ||| BindingFlags.Static
// Get a MethodInfo that represents MyMethod.
let minfo = typeof.GetMethod("MyMethod", flags)
// Demonstrate contravariance of parameter types and covariance
// of return types by using the delegate Example to represent
// MyMethod. The delegate binds to the method because the
// parameter of the delegate is more restrictive than the
// parameter of the method (that is, the delegate accepts an
// instance of Derived, which can always be safely passed to
// a parameter of type Base), and the return type of MyMethod
// is more restrictive than the return type of Example (that
// is, the method returns an instance of Derived, which can
// always be safely cast to type Base).
let ex = Delegate.CreateDelegate(typeof, minfo) :?> Example
// Execute MyMethod using the delegate Example.
let b = Derived() |> ex.Invoke

2 is

Imports System.Reflection Imports System.Security.Permissions ' Declare three delegate types for demonstrating the combinations ' of Shared versus instance methods and open versus closed ' delegates. ' Public Delegate Sub D1(ByVal c As C2, ByVal s As String) Public Delegate Sub D2(ByVal s As String) Public Delegate Sub D3() ' A sample class with an instance method and a Shared method. ' Public Class C2

Private id As Integer
Public Sub New(ByVal id As Integer)
    Me.id = id
End Sub
Public Sub M1(ByVal s As String)
    Console.WriteLine("Instance method M1 on C2:  id = {0}, s = {1}",
        Me.id, s)
End Sub
Public Shared Sub M2(ByVal s As String)
    Console.WriteLine("Shared method M2 on C2:  s = {0}", s)
End Sub

End Class
Public Class Example2Public Shared Sub Main()
    Dim c1 As New C2(42)
    ' Get a MethodInfo for each method.
    '
    Dim mi1 As MethodInfo = GetType(C2).GetMethod("M1",
        BindingFlags.Public Or BindingFlags.Instance)
    Dim mi2 As MethodInfo = GetType(C2).GetMethod("M2",
        BindingFlags.Public Or BindingFlags.Static)
    Dim d1 As D1
    Dim d2 As D2
    Dim d3 As D3
    Console.WriteLine(vbLf & "An instance method closed over C2.")
    ' In this case, the delegate and the
    ' method must have the same list of argument types; use
    ' delegate type D2 with instance method M1.
    '
    Dim test As [Delegate] =
        [Delegate].CreateDelegate(GetType(D2), c1, mi1, False)
    ' Because False was specified for throwOnBindFailure 
    ' in the call to CreateDelegate, the variable 'test'
    ' contains Nothing if the method fails to bind (for 
    ' example, if mi1 happened to represent a method of 
    ' some class other than C2).
    '
    If test IsNot Nothing Then
        d2 = CType(test, D2)
        ' The same instance of C2 is used every time the
        ' delegate is invoked.
        d2("Hello, World!")
        d2("Hi, Mom!")
    End If
    Console.WriteLine(vbLf & "An open instance method.")
    ' In this case, the delegate has one more 
    ' argument than the instance method; this argument comes
    ' at the beginning, and represents the hidden instance
    ' argument of the instance method. Use delegate type D1
    ' with instance method M1.
    '
    d1 = CType([Delegate].CreateDelegate(GetType(D1), Nothing, mi1), D1)
    ' An instance of C2 must be passed in each time the 
    ' delegate is invoked.
    '
    d1(c1, "Hello, World!")
    d1(New C2(5280), "Hi, Mom!")
    Console.WriteLine(vbLf & "An open Shared method.")
    ' In this case, the delegate and the method must 
    ' have the same list of argument types; use delegate type
    ' D2 with Shared method M2.
    '
    d2 = CType([Delegate].CreateDelegate(GetType(D2), Nothing, mi2), D2)
    ' No instances of C2 are involved, because this is a Shared
    ' method. 
    '
    d2("Hello, World!")
    d2("Hi, Mom!")
    Console.WriteLine(vbLf & "A Shared method closed over the first argument (String).")
    ' The delegate must omit the first argument of the method.
    ' A string is passed as the firstArgument parameter, and 
    ' the delegate is bound to this string. Use delegate type 
    ' D3 with Shared method M2. 
    '
    d3 = CType([Delegate].CreateDelegate(GetType(D3), "Hello, World!", mi2), D3)
    ' Each time the delegate is invoked, the same string is
    ' used.
    d3()
End Sub
End Class
' This code example produces the following output:
'
'An instance method closed over C2.
'Instance method M1 on C2: id = 42, s = Hello, World!
'Instance method M1 on C2: id = 42, s = Hi, Mom!
'
'An open instance method.
'Instance method M1 on C2: id = 42, s = Hello, World!
'Instance method M1 on C2: id = 5280, s = Hi, Mom!
'
'An open Shared method.
'Shared method M2 on C2: s = Hello, World!
'Shared method M2 on C2: s = Hi, Mom!
'
'A Shared method closed over the first argument (String).
'Shared method M2 on C2: s = Hello, World!
'

5 (

Imports System.Reflection Imports System.Security.Permissions ' Declare three delegate types for demonstrating the combinations ' of Shared versus instance methods and open versus closed ' delegates. ' Public Delegate Sub D1(ByVal c As C2, ByVal s As String) Public Delegate Sub D2(ByVal s As String) Public Delegate Sub D3() ' A sample class with an instance method and a Shared method. ' Public Class C2

Private id As Integer
Public Sub New(ByVal id As Integer)
    Me.id = id
End Sub
Public Sub M1(ByVal s As String)
    Console.WriteLine("Instance method M1 on C2:  id = {0}, s = {1}",
        Me.id, s)
End Sub
Public Shared Sub M2(ByVal s As String)
    Console.WriteLine("Shared method M2 on C2:  s = {0}", s)
End Sub

End Class
Public Class Example2Public Shared Sub Main()
    Dim c1 As New C2(42)
    ' Get a MethodInfo for each method.
    '
    Dim mi1 As MethodInfo = GetType(C2).GetMethod("M1",
        BindingFlags.Public Or BindingFlags.Instance)
    Dim mi2 As MethodInfo = GetType(C2).GetMethod("M2",
        BindingFlags.Public Or BindingFlags.Static)
    Dim d1 As D1
    Dim d2 As D2
    Dim d3 As D3
    Console.WriteLine(vbLf & "An instance method closed over C2.")
    ' In this case, the delegate and the
    ' method must have the same list of argument types; use
    ' delegate type D2 with instance method M1.
    '
    Dim test As [Delegate] =
        [Delegate].CreateDelegate(GetType(D2), c1, mi1, False)
    ' Because False was specified for throwOnBindFailure 
    ' in the call to CreateDelegate, the variable 'test'
    ' contains Nothing if the method fails to bind (for 
    ' example, if mi1 happened to represent a method of 
    ' some class other than C2).
    '
    If test IsNot Nothing Then
        d2 = CType(test, D2)
        ' The same instance of C2 is used every time the
        ' delegate is invoked.
        d2("Hello, World!")
        d2("Hi, Mom!")
    End If
    Console.WriteLine(vbLf & "An open instance method.")
    ' In this case, the delegate has one more 
    ' argument than the instance method; this argument comes
    ' at the beginning, and represents the hidden instance
    ' argument of the instance method. Use delegate type D1
    ' with instance method M1.
    '
    d1 = CType([Delegate].CreateDelegate(GetType(D1), Nothing, mi1), D1)
    ' An instance of C2 must be passed in each time the 
    ' delegate is invoked.
    '
    d1(c1, "Hello, World!")
    d1(New C2(5280), "Hi, Mom!")
    Console.WriteLine(vbLf & "An open Shared method.")
    ' In this case, the delegate and the method must 
    ' have the same list of argument types; use delegate type
    ' D2 with Shared method M2.
    '
    d2 = CType([Delegate].CreateDelegate(GetType(D2), Nothing, mi2), D2)
    ' No instances of C2 are involved, because this is a Shared
    ' method. 
    '
    d2("Hello, World!")
    d2("Hi, Mom!")
    Console.WriteLine(vbLf & "A Shared method closed over the first argument (String).")
    ' The delegate must omit the first argument of the method.
    ' A string is passed as the firstArgument parameter, and 
    ' the delegate is bound to this string. Use delegate type 
    ' D3 with Shared method M2. 
    '
    d3 = CType([Delegate].CreateDelegate(GetType(D3), "Hello, World!", mi2), D3)
    ' Each time the delegate is invoked, the same string is
    ' used.
    d3()
End Sub
End Class
' This code example produces the following output:
'
'An instance method closed over C2.
'Instance method M1 on C2: id = 42, s = Hello, World!
'Instance method M1 on C2: id = 42, s = Hi, Mom!
'
'An open instance method.
'Instance method M1 on C2: id = 42, s = Hello, World!
'Instance method M1 on C2: id = 5280, s = Hi, Mom!
'
'An open Shared method.
'Shared method M2 on C2: s = Hello, World!
'Shared method M2 on C2: s = Hi, Mom!
'
'A Shared method closed over the first argument (String).
'Shared method M2 on C2: s = Hello, World!
'

6 in Visual Basic) and its first parameter is of type Object or ValueType, then

open System open System.Reflection // Define two classes to use in the demonstration, a base class and // a class that derives from it. type Base() = class end type Derived() =

inherit Base()
// Define a static method to use in the demonstration. The method
// takes an instance of Base and returns an instance of Derived.
// For the purposes of the demonstration, it is not necessary for
// the method to do anything useful.
static member MyMethod(arg: Base) =
    Derived()

// Define a delegate that takes an instance of Derived and returns an
// instance of Base.
type Example = delegate of Derived -> Base
// The binding flags needed to retrieve MyMethod.
let flags = BindingFlags.Public ||| BindingFlags.Static
// Get a MethodInfo that represents MyMethod.
let minfo = typeof.GetMethod("MyMethod", flags)
// Demonstrate contravariance of parameter types and covariance
// of return types by using the delegate Example to represent
// MyMethod. The delegate binds to the method because the
// parameter of the delegate is more restrictive than the
// parameter of the method (that is, the delegate accepts an
// instance of Derived, which can always be safely passed to
// a parameter of type Base), and the return type of MyMethod
// is more restrictive than the return type of Example (that
// is, the method returns an instance of Derived, which can
// always be safely cast to type Base).
let ex = Delegate.CreateDelegate(typeof, minfo) :?> Example
// Execute MyMethod using the delegate Example.
let b = Derived() |> ex.Invoke

4 can be a value type. In this case

open System open System.Reflection // Define two classes to use in the demonstration, a base class and // a class that derives from it. type Base() = class end type Derived() =

inherit Base()
// Define a static method to use in the demonstration. The method
// takes an instance of Base and returns an instance of Derived.
// For the purposes of the demonstration, it is not necessary for
// the method to do anything useful.
static member MyMethod(arg: Base) =
    Derived()

// Define a delegate that takes an instance of Derived and returns an
// instance of Base.
type Example = delegate of Derived -> Base
// The binding flags needed to retrieve MyMethod.
let flags = BindingFlags.Public ||| BindingFlags.Static
// Get a MethodInfo that represents MyMethod.
let minfo = typeof.GetMethod("MyMethod", flags)
// Demonstrate contravariance of parameter types and covariance
// of return types by using the delegate Example to represent
// MyMethod. The delegate binds to the method because the
// parameter of the delegate is more restrictive than the
// parameter of the method (that is, the delegate accepts an
// instance of Derived, which can always be safely passed to
// a parameter of type Base), and the return type of MyMethod
// is more restrictive than the return type of Example (that
// is, the method returns an instance of Derived, which can
// always be safely cast to type Base).
let ex = Delegate.CreateDelegate(typeof, minfo) :?> Example
// Execute MyMethod using the delegate Example.
let b = Derived() |> ex.Invoke

4 is automatically boxed. Automatic boxing does not occur for any other arguments, as it would in a C# or Visual Basic function call.

If

open System open System.Reflection // Define two classes to use in the demonstration, a base class and // a class that derives from it. type Base() = class end type Derived() =

inherit Base()
// Define a static method to use in the demonstration. The method
// takes an instance of Base and returns an instance of Derived.
// For the purposes of the demonstration, it is not necessary for
// the method to do anything useful.
static member MyMethod(arg: Base) =
    Derived()

// Define a delegate that takes an instance of Derived and returns an
// instance of Base.
type Example = delegate of Derived -> Base
// The binding flags needed to retrieve MyMethod.
let flags = BindingFlags.Public ||| BindingFlags.Static
// Get a MethodInfo that represents MyMethod.
let minfo = typeof.GetMethod("MyMethod", flags)
// Demonstrate contravariance of parameter types and covariance
// of return types by using the delegate Example to represent
// MyMethod. The delegate binds to the method because the
// parameter of the delegate is more restrictive than the
// parameter of the method (that is, the delegate accepts an
// instance of Derived, which can always be safely passed to
// a parameter of type Base), and the return type of MyMethod
// is more restrictive than the return type of Example (that
// is, the method returns an instance of Derived, which can
// always be safely cast to type Base).
let ex = Delegate.CreateDelegate(typeof, minfo) :?> Example
// Execute MyMethod using the delegate Example.
let b = Derived() |> ex.Invoke

4 is a null reference and

open System open System.Reflection // Define two classes to use in the demonstration, a base class and // a class that derives from it. type Base() = class end type Derived() =

inherit Base()
// Define a static method to use in the demonstration. The method
// takes an instance of Base and returns an instance of Derived.
// For the purposes of the demonstration, it is not necessary for
// the method to do anything useful.
static member MyMethod(arg: Base) =
    Derived()

// Define a delegate that takes an instance of Derived and returns an
// instance of Base.
type Example = delegate of Derived -> Base
// The binding flags needed to retrieve MyMethod.
let flags = BindingFlags.Public ||| BindingFlags.Static
// Get a MethodInfo that represents MyMethod.
let minfo = typeof.GetMethod("MyMethod", flags)
// Demonstrate contravariance of parameter types and covariance
// of return types by using the delegate Example to represent
// MyMethod. The delegate binds to the method because the
// parameter of the delegate is more restrictive than the
// parameter of the method (that is, the delegate accepts an
// instance of Derived, which can always be safely passed to
// a parameter of type Base), and the return type of MyMethod
// is more restrictive than the return type of Example (that
// is, the method returns an instance of Derived, which can
// always be safely cast to type Base).
let ex = Delegate.CreateDelegate(typeof, minfo) :?> Example
// Execute MyMethod using the delegate Example.
let b = Derived() |> ex.Invoke

2 is an instance method, the result depends on the signatures of the delegate type

open System open System.Reflection // Define two classes to use in the demonstration, a base class and // a class that derives from it. type Base() = class end type Derived() =

inherit Base()
// Define a static method to use in the demonstration. The method
// takes an instance of Base and returns an instance of Derived.
// For the purposes of the demonstration, it is not necessary for
// the method to do anything useful.
static member MyMethod(arg: Base) =
    Derived()

// Define a delegate that takes an instance of Derived and returns an
// instance of Base.
type Example = delegate of Derived -> Base
// The binding flags needed to retrieve MyMethod.
let flags = BindingFlags.Public ||| BindingFlags.Static
// Get a MethodInfo that represents MyMethod.
let minfo = typeof.GetMethod("MyMethod", flags)
// Demonstrate contravariance of parameter types and covariance
// of return types by using the delegate Example to represent
// MyMethod. The delegate binds to the method because the
// parameter of the delegate is more restrictive than the
// parameter of the method (that is, the delegate accepts an
// instance of Derived, which can always be safely passed to
// a parameter of type Base), and the return type of MyMethod
// is more restrictive than the return type of Example (that
// is, the method returns an instance of Derived, which can
// always be safely cast to type Base).
let ex = Delegate.CreateDelegate(typeof, minfo) :?> Example
// Execute MyMethod using the delegate Example.
let b = Derived() |> ex.Invoke

3 and of

open System open System.Reflection // Define two classes to use in the demonstration, a base class and // a class that derives from it. type Base() = class end type Derived() =

inherit Base()
// Define a static method to use in the demonstration. The method
// takes an instance of Base and returns an instance of Derived.
// For the purposes of the demonstration, it is not necessary for
// the method to do anything useful.
static member MyMethod(arg: Base) =
    Derived()

// Define a delegate that takes an instance of Derived and returns an
// instance of Base.
type Example = delegate of Derived -> Base
// The binding flags needed to retrieve MyMethod.
let flags = BindingFlags.Public ||| BindingFlags.Static
// Get a MethodInfo that represents MyMethod.
let minfo = typeof.GetMethod("MyMethod", flags)
// Demonstrate contravariance of parameter types and covariance
// of return types by using the delegate Example to represent
// MyMethod. The delegate binds to the method because the
// parameter of the delegate is more restrictive than the
// parameter of the method (that is, the delegate accepts an
// instance of Derived, which can always be safely passed to
// a parameter of type Base), and the return type of MyMethod
// is more restrictive than the return type of Example (that
// is, the method returns an instance of Derived, which can
// always be safely cast to type Base).
let ex = Delegate.CreateDelegate(typeof, minfo) :?> Example
// Execute MyMethod using the delegate Example.
let b = Derived() |> ex.Invoke

2:

If the signature of open System open System.Reflection // Define two classes to use in the demonstration, a base class and // a class that derives from it. type Base() = class end type Derived() = inherit Base() // Define a static method to use in the demonstration. The method // takes an instance of Base and returns an instance of Derived. // For the purposes of the demonstration, it is not necessary for // the method to do anything useful. static member MyMethod(arg: Base) = Derived() // Define a delegate that takes an instance of Derived and returns an // instance of Base. type Example = delegate of Derived -> Base // The binding flags needed to retrieve MyMethod. let flags = BindingFlags.Public ||| BindingFlags.Static // Get a MethodInfo that represents MyMethod. let minfo = typeof.GetMethod("MyMethod", flags) // Demonstrate contravariance of parameter types and covariance // of return types by using the delegate Example to represent // MyMethod. The delegate binds to the method because the // parameter of the delegate is more restrictive than the // parameter of the method (that is, the delegate accepts an // instance of Derived, which can always be safely passed to // a parameter of type Base), and the return type of MyMethod // is more restrictive than the return type of Example (that // is, the method returns an instance of Derived, which can // always be safely cast to type Base). let ex = Delegate.CreateDelegate(typeof, minfo) :?> Example // Execute MyMethod using the delegate Example. let b = Derived() |> ex.Invoke
3 explicitly includes the hidden first parameter of
open System open System.Reflection // Define two classes to use in the demonstration, a base class and // a class that derives from it. type Base() = class end type Derived() = inherit Base() // Define a static method to use in the demonstration. The method // takes an instance of Base and returns an instance of Derived. // For the purposes of the demonstration, it is not necessary for // the method to do anything useful. static member MyMethod(arg: Base) = Derived() // Define a delegate that takes an instance of Derived and returns an // instance of Base. type Example = delegate of Derived -> Base // The binding flags needed to retrieve MyMethod. let flags = BindingFlags.Public ||| BindingFlags.Static // Get a MethodInfo that represents MyMethod. let minfo = typeof.GetMethod("MyMethod", flags) // Demonstrate contravariance of parameter types and covariance // of return types by using the delegate Example to represent // MyMethod. The delegate binds to the method because the // parameter of the delegate is more restrictive than the // parameter of the method (that is, the delegate accepts an // instance of Derived, which can always be safely passed to // a parameter of type Base), and the return type of MyMethod // is more restrictive than the return type of Example (that // is, the method returns an instance of Derived, which can // always be safely cast to type Base). let ex = Delegate.CreateDelegate(typeof, minfo) :?> Example // Execute MyMethod using the delegate Example. let b = Derived() |> ex.Invoke
2, the delegate is said to represent an open instance method. When the delegate is invoked, the first argument in the argument list is passed to the hidden instance parameter of
open System open System.Reflection // Define two classes to use in the demonstration, a base class and // a class that derives from it. type Base() = class end type Derived() = inherit Base() // Define a static method to use in the demonstration. The method // takes an instance of Base and returns an instance of Derived. // For the purposes of the demonstration, it is not necessary for // the method to do anything useful. static member MyMethod(arg: Base) = Derived() // Define a delegate that takes an instance of Derived and returns an // instance of Base. type Example = delegate of Derived -> Base // The binding flags needed to retrieve MyMethod. let flags = BindingFlags.Public ||| BindingFlags.Static // Get a MethodInfo that represents MyMethod. let minfo = typeof.GetMethod("MyMethod", flags) // Demonstrate contravariance of parameter types and covariance // of return types by using the delegate Example to represent // MyMethod. The delegate binds to the method because the // parameter of the delegate is more restrictive than the // parameter of the method (that is, the delegate accepts an // instance of Derived, which can always be safely passed to // a parameter of type Base), and the return type of MyMethod // is more restrictive than the return type of Example (that // is, the method returns an instance of Derived, which can // always be safely cast to type Base). let ex = Delegate.CreateDelegate(typeof, minfo) :?> Example // Execute MyMethod using the delegate Example. let b = Derived() |> ex.Invoke 2.
If the signatures of open System open System.Reflection // Define two classes to use in the demonstration, a base class and // a class that derives from it. type Base() = class end type Derived() = inherit Base() // Define a static method to use in the demonstration. The method // takes an instance of Base and returns an instance of Derived. // For the purposes of the demonstration, it is not necessary for // the method to do anything useful. static member MyMethod(arg: Base) = Derived() // Define a delegate that takes an instance of Derived and returns an // instance of Base. type Example = delegate of Derived -> Base // The binding flags needed to retrieve MyMethod. let flags = BindingFlags.Public ||| BindingFlags.Static // Get a MethodInfo that represents MyMethod. let minfo = typeof.GetMethod("MyMethod", flags) // Demonstrate contravariance of parameter types and covariance // of return types by using the delegate Example to represent // MyMethod. The delegate binds to the method because the // parameter of the delegate is more restrictive than the // parameter of the method (that is, the delegate accepts an // instance of Derived, which can always be safely passed to // a parameter of type Base), and the return type of MyMethod // is more restrictive than the return type of Example (that // is, the method returns an instance of Derived, which can // always be safely cast to type Base). let ex = Delegate.CreateDelegate(typeof, minfo) :?> Example // Execute MyMethod using the delegate Example. let b = Derived() |> ex.Invoke
2 and
open System open System.Reflection // Define two classes to use in the demonstration, a base class and // a class that derives from it. type Base() = class end type Derived() = inherit Base() // Define a static method to use in the demonstration. The method // takes an instance of Base and returns an instance of Derived. // For the purposes of the demonstration, it is not necessary for // the method to do anything useful. static member MyMethod(arg: Base) = Derived() // Define a delegate that takes an instance of Derived and returns an // instance of Base. type Example = delegate of Derived -> Base // The binding flags needed to retrieve MyMethod. let flags = BindingFlags.Public ||| BindingFlags.Static // Get a MethodInfo that represents MyMethod. let minfo = typeof.GetMethod("MyMethod", flags) // Demonstrate contravariance of parameter types and covariance // of return types by using the delegate Example to represent // MyMethod. The delegate binds to the method because the // parameter of the delegate is more restrictive than the // parameter of the method (that is, the delegate accepts an // instance of Derived, which can always be safely passed to // a parameter of type Base), and the return type of MyMethod // is more restrictive than the return type of Example (that // is, the method returns an instance of Derived, which can // always be safely cast to type Base). let ex = Delegate.CreateDelegate(typeof, minfo) :?> Example // Execute MyMethod using the delegate Example. let b = Derived() |> ex.Invoke 3 match (that is, all parameter types are compatible), then the delegate is said to be closed over a null reference. Invoking the delegate is like calling an instance method on a null instance, which is not a particularly useful thing to do.

If

open System open System.Reflection // Define two classes to use in the demonstration, a base class and // a class that derives from it. type Base() = class end type Derived() =

inherit Base()
// Define a static method to use in the demonstration. The method
// takes an instance of Base and returns an instance of Derived.
// For the purposes of the demonstration, it is not necessary for
// the method to do anything useful.
static member MyMethod(arg: Base) =
    Derived()

// Define a delegate that takes an instance of Derived and returns an
// instance of Base.
type Example = delegate of Derived -> Base
// The binding flags needed to retrieve MyMethod.
let flags = BindingFlags.Public ||| BindingFlags.Static
// Get a MethodInfo that represents MyMethod.
let minfo = typeof.GetMethod("MyMethod", flags)
// Demonstrate contravariance of parameter types and covariance
// of return types by using the delegate Example to represent
// MyMethod. The delegate binds to the method because the
// parameter of the delegate is more restrictive than the
// parameter of the method (that is, the delegate accepts an
// instance of Derived, which can always be safely passed to
// a parameter of type Base), and the return type of MyMethod
// is more restrictive than the return type of Example (that
// is, the method returns an instance of Derived, which can
// always be safely cast to type Base).
let ex = Delegate.CreateDelegate(typeof, minfo) :?> Example
// Execute MyMethod using the delegate Example.
let b = Derived() |> ex.Invoke

4 is a null reference and

open System open System.Reflection // Define two classes to use in the demonstration, a base class and // a class that derives from it. type Base() = class end type Derived() =

inherit Base()
// Define a static method to use in the demonstration. The method
// takes an instance of Base and returns an instance of Derived.
// For the purposes of the demonstration, it is not necessary for
// the method to do anything useful.
static member MyMethod(arg: Base) =
    Derived()

// Define a delegate that takes an instance of Derived and returns an
// instance of Base.
type Example = delegate of Derived -> Base
// The binding flags needed to retrieve MyMethod.
let flags = BindingFlags.Public ||| BindingFlags.Static
// Get a MethodInfo that represents MyMethod.
let minfo = typeof.GetMethod("MyMethod", flags)
// Demonstrate contravariance of parameter types and covariance
// of return types by using the delegate Example to represent
// MyMethod. The delegate binds to the method because the
// parameter of the delegate is more restrictive than the
// parameter of the method (that is, the delegate accepts an
// instance of Derived, which can always be safely passed to
// a parameter of type Base), and the return type of MyMethod
// is more restrictive than the return type of Example (that
// is, the method returns an instance of Derived, which can
// always be safely cast to type Base).
let ex = Delegate.CreateDelegate(typeof, minfo) :?> Example
// Execute MyMethod using the delegate Example.
let b = Derived() |> ex.Invoke

2 is static, the result depends on the signatures of the delegate type

open System open System.Reflection // Define two classes to use in the demonstration, a base class and // a class that derives from it. type Base() = class end type Derived() =

inherit Base()
// Define a static method to use in the demonstration. The method
// takes an instance of Base and returns an instance of Derived.
// For the purposes of the demonstration, it is not necessary for
// the method to do anything useful.
static member MyMethod(arg: Base) =
    Derived()

// Define a delegate that takes an instance of Derived and returns an
// instance of Base.
type Example = delegate of Derived -> Base
// The binding flags needed to retrieve MyMethod.
let flags = BindingFlags.Public ||| BindingFlags.Static
// Get a MethodInfo that represents MyMethod.
let minfo = typeof.GetMethod("MyMethod", flags)
// Demonstrate contravariance of parameter types and covariance
// of return types by using the delegate Example to represent
// MyMethod. The delegate binds to the method because the
// parameter of the delegate is more restrictive than the
// parameter of the method (that is, the delegate accepts an
// instance of Derived, which can always be safely passed to
// a parameter of type Base), and the return type of MyMethod
// is more restrictive than the return type of Example (that
// is, the method returns an instance of Derived, which can
// always be safely cast to type Base).
let ex = Delegate.CreateDelegate(typeof, minfo) :?> Example
// Execute MyMethod using the delegate Example.
let b = Derived() |> ex.Invoke

3 and of

open System open System.Reflection // Define two classes to use in the demonstration, a base class and // a class that derives from it. type Base() = class end type Derived() =

inherit Base()
// Define a static method to use in the demonstration. The method
// takes an instance of Base and returns an instance of Derived.
// For the purposes of the demonstration, it is not necessary for
// the method to do anything useful.
static member MyMethod(arg: Base) =
    Derived()

// Define a delegate that takes an instance of Derived and returns an
// instance of Base.
type Example = delegate of Derived -> Base
// The binding flags needed to retrieve MyMethod.
let flags = BindingFlags.Public ||| BindingFlags.Static
// Get a MethodInfo that represents MyMethod.
let minfo = typeof.GetMethod("MyMethod", flags)
// Demonstrate contravariance of parameter types and covariance
// of return types by using the delegate Example to represent
// MyMethod. The delegate binds to the method because the
// parameter of the delegate is more restrictive than the
// parameter of the method (that is, the delegate accepts an
// instance of Derived, which can always be safely passed to
// a parameter of type Base), and the return type of MyMethod
// is more restrictive than the return type of Example (that
// is, the method returns an instance of Derived, which can
// always be safely cast to type Base).
let ex = Delegate.CreateDelegate(typeof, minfo) :?> Example
// Execute MyMethod using the delegate Example.
let b = Derived() |> ex.Invoke

2:

If the signature of open System open System.Reflection // Define two classes to use in the demonstration, a base class and // a class that derives from it. type Base() = class end type Derived() = inherit Base() // Define a static method to use in the demonstration. The method // takes an instance of Base and returns an instance of Derived. // For the purposes of the demonstration, it is not necessary for // the method to do anything useful. static member MyMethod(arg: Base) = Derived() // Define a delegate that takes an instance of Derived and returns an // instance of Base. type Example = delegate of Derived -> Base // The binding flags needed to retrieve MyMethod. let flags = BindingFlags.Public ||| BindingFlags.Static // Get a MethodInfo that represents MyMethod. let minfo = typeof.GetMethod("MyMethod", flags) // Demonstrate contravariance of parameter types and covariance // of return types by using the delegate Example to represent // MyMethod. The delegate binds to the method because the // parameter of the delegate is more restrictive than the // parameter of the method (that is, the delegate accepts an // instance of Derived, which can always be safely passed to // a parameter of type Base), and the return type of MyMethod // is more restrictive than the return type of Example (that // is, the method returns an instance of Derived, which can // always be safely cast to type Base). let ex = Delegate.CreateDelegate(typeof, minfo) :?> Example // Execute MyMethod using the delegate Example. let b = Derived() |> ex.Invoke
2 and
open System open System.Reflection // Define two classes to use in the demonstration, a base class and // a class that derives from it. type Base() = class end type Derived() = inherit Base() // Define a static method to use in the demonstration. The method // takes an instance of Base and returns an instance of Derived. // For the purposes of the demonstration, it is not necessary for // the method to do anything useful. static member MyMethod(arg: Base) = Derived() // Define a delegate that takes an instance of Derived and returns an // instance of Base. type Example = delegate of Derived -> Base // The binding flags needed to retrieve MyMethod. let flags = BindingFlags.Public ||| BindingFlags.Static // Get a MethodInfo that represents MyMethod. let minfo = typeof.GetMethod("MyMethod", flags) // Demonstrate contravariance of parameter types and covariance // of return types by using the delegate Example to represent // MyMethod. The delegate binds to the method because the // parameter of the delegate is more restrictive than the // parameter of the method (that is, the delegate accepts an // instance of Derived, which can always be safely passed to // a parameter of type Base), and the return type of MyMethod // is more restrictive than the return type of Example (that // is, the method returns an instance of Derived, which can // always be safely cast to type Base). let ex = Delegate.CreateDelegate(typeof, minfo) :?> Example // Execute MyMethod using the delegate Example. let b = Derived() |> ex.Invoke 3 match (that is, all parameter types are compatible), the delegate is said to represent an open static method. This is the most common case for static methods. In this case, you can get slightly better performance by using the method overload.
If the signature of open System open System.Reflection // Define two classes to use in the demonstration, a base class and // a class that derives from it. type Base() = class end type Derived() = inherit Base() // Define a static method to use in the demonstration. The method // takes an instance of Base and returns an instance of Derived. // For the purposes of the demonstration, it is not necessary for // the method to do anything useful. static member MyMethod(arg: Base) = Derived() // Define a delegate that takes an instance of Derived and returns an // instance of Base. type Example = delegate of Derived -> Base // The binding flags needed to retrieve MyMethod. let flags = BindingFlags.Public ||| BindingFlags.Static // Get a MethodInfo that represents MyMethod. let minfo = typeof.GetMethod("MyMethod", flags) // Demonstrate contravariance of parameter types and covariance // of return types by using the delegate Example to represent // MyMethod. The delegate binds to the method because the // parameter of the delegate is more restrictive than the // parameter of the method (that is, the delegate accepts an // instance of Derived, which can always be safely passed to // a parameter of type Base), and the return type of MyMethod // is more restrictive than the return type of Example (that // is, the method returns an instance of Derived, which can // always be safely cast to type Base). let ex = Delegate.CreateDelegate(typeof, minfo) :?> Example // Execute MyMethod using the delegate Example. let b = Derived() |> ex.Invoke
3 begins with the second parameter of
open System open System.Reflection // Define two classes to use in the demonstration, a base class and // a class that derives from it. type Base() = class end type Derived() = inherit Base() // Define a static method to use in the demonstration. The method // takes an instance of Base and returns an instance of Derived. // For the purposes of the demonstration, it is not necessary for // the method to do anything useful. static member MyMethod(arg: Base) = Derived() // Define a delegate that takes an instance of Derived and returns an // instance of Base. type Example = delegate of Derived -> Base // The binding flags needed to retrieve MyMethod. let flags = BindingFlags.Public ||| BindingFlags.Static // Get a MethodInfo that represents MyMethod. let minfo = typeof.GetMethod("MyMethod", flags) // Demonstrate contravariance of parameter types and covariance // of return types by using the delegate Example to represent // MyMethod. The delegate binds to the method because the // parameter of the delegate is more restrictive than the // parameter of the method (that is, the delegate accepts an // instance of Derived, which can always be safely passed to // a parameter of type Base), and the return type of MyMethod // is more restrictive than the return type of Example (that // is, the method returns an instance of Derived, which can // always be safely cast to type Base). let ex = Delegate.CreateDelegate(typeof, minfo) :?> Example // Execute MyMethod using the delegate Example. let b = Derived() |> ex.Invoke
2 and the rest of the parameter types are compatible, then the delegate is said to be closed over a null reference. When the delegate is invoked, a null reference is passed to the first parameter of
open System open System.Reflection // Define two classes to use in the demonstration, a base class and // a class that derives from it. type Base() = class end type Derived() = inherit Base() // Define a static method to use in the demonstration. The method // takes an instance of Base and returns an instance of Derived. // For the purposes of the demonstration, it is not necessary for // the method to do anything useful. static member MyMethod(arg: Base) = Derived() // Define a delegate that takes an instance of Derived and returns an // instance of Base. type Example = delegate of Derived -> Base // The binding flags needed to retrieve MyMethod. let flags = BindingFlags.Public ||| BindingFlags.Static // Get a MethodInfo that represents MyMethod. let minfo = typeof.GetMethod("MyMethod", flags) // Demonstrate contravariance of parameter types and covariance // of return types by using the delegate Example to represent // MyMethod. The delegate binds to the method because the // parameter of the delegate is more restrictive than the // parameter of the method (that is, the delegate accepts an // instance of Derived, which can always be safely passed to // a parameter of type Base), and the return type of MyMethod // is more restrictive than the return type of Example (that // is, the method returns an instance of Derived, which can // always be safely cast to type Base). let ex = Delegate.CreateDelegate(typeof, minfo) :?> Example // Execute MyMethod using the delegate Example. let b = Derived() |> ex.Invoke 2.

Example

The following code example shows all the methods a single delegate type can represent: closed over an instance method, open over an instance method, open over a static method, and closed over a static method.

The code example defines two classes,

open System open System.Reflection // A sample class with an instance method and a static method. type C(id) =

member _.M1(s) =
    printfn $"Instance method M1 on C:  id = %i{id}, s = %s{s}"
static member M2(s) =
    printfn $"Static method M2 on C:  s = %s{s}"

// Declare three delegate types for demonstrating the combinations
// of static versus instance methods and open versus closed
// delegates.
type D1 = delegate of C * string -> unit
type D2 = delegate of string -> unit
type D3 = delegate of unit -> unit
let c1 = C 42
// Get a MethodInfo for each method.
//
let mi1 = typeof.GetMethod("M1", BindingFlags.Public ||| BindingFlags.Instance)
let mi2 = typeof.GetMethod("M2", BindingFlags.Public ||| BindingFlags.Static)
printfn "\nAn instance method closed over C."
// In this case, the delegate and the
// method must have the same list of argument types use
// delegate type D2 with instance method M1.
let test = Delegate.CreateDelegate(typeof, c1, mi1, false)
// Because false was specified for throwOnBindFailure
// in the call to CreateDelegate, the variable 'test'
// contains null if the method fails to bind (for
// example, if mi1 happened to represent a method of
// some class other than C).
if test <> null thenlet d2 = test :?> D2
// The same instance of C is used every time the
// delegate is invoked.
d2.Invoke "Hello, World!"
d2.Invoke "Hi, Mom!"
printfn "\nAn open instance method."
// In this case, the delegate has one more
// argument than the instance method this argument comes
// at the beginning, and represents the hidden instance
// argument of the instance method. Use delegate type D1
// with instance method M1.
let d1 = Delegate.CreateDelegate(typeof, null, mi1) :?> D1
// An instance of C must be passed in each time the
// delegate is invoked.
d1.Invoke(c1, "Hello, World!")
d1.Invoke(C 5280, "Hi, Mom!")
printfn "\nAn open static method."
// In this case, the delegate and the method must
// have the same list of argument types use delegate type
// D2 with static method M2.
let d2 = Delegate.CreateDelegate(typeof, null, mi2) :?> D2
// No instances of C are involved, because this is a static
// method.
d2.Invoke "Hello, World!"
d2.Invoke "Hi, Mom!"
printfn "\nA static method closed over the first argument (String)."
// The delegate must omit the first argument of the method.
// A string is passed as the firstArgument parameter, and
// the delegate is bound to this string. Use delegate type
// D3 with static method M2.
let d3 = Delegate.CreateDelegate(typeof, "Hello, World!", mi2) :?> D3
// Each time the delegate is invoked, the same string is used.
d3.Invoke()
// This code example produces the following output:
// An instance method closed over C.
// Instance method M1 on C: id = 42, s = Hello, World!
// Instance method M1 on C: id = 42, s = Hi, Mom!
//
// An open instance method.
// Instance method M1 on C: id = 42, s = Hello, World!
// Instance method M1 on C: id = 5280, s = Hi, Mom!
//
// An open static method.
// Static method M2 on C: s = Hello, World!
// Static method M2 on C: s = Hi, Mom!
//
// A static method closed over the first argument (String).
// Static method M2 on C: s = Hello, World!

1 and

Imports System.Reflection Imports System.Security.Permissions ' Declare a delegate type. The object of this code example ' is to show all the methods this delegate can bind to. ' Public Delegate Sub D(ByVal c As C) ' Declare two sample classes, C and F. Class C has an ID ' property so instances can be identified. ' Public Class C

Private _id As Integer
Public ReadOnly Property ID() As Integer 
    Get
        Return _id
    End Get
End Property
Public Sub New(ByVal newId As Integer) 
    Me._id = newId
End Sub
Public Sub M1(ByVal c As C) 
    Console.WriteLine("Instance method M1(c As C) on C:  this.id = {0}, c.ID = {1}", _
        Me.id, c.ID)
End Sub
Public Sub M2() 
    Console.WriteLine("Instance method M2() on C:  this.id = {0}", Me.id)
End Sub
Public Shared Sub M3(ByVal c As C) 
    Console.WriteLine("Shared method M3(c As C) on C:  c.ID = {0}", c.ID)
End Sub
Public Shared Sub M4(ByVal c1 As C, ByVal c2 As C) 
    Console.WriteLine("Shared method M4(c1 As C, c2 As C) on C:  c1.ID = {0}, c2.ID = {1}", _
        c1.ID, c2.ID)
End Sub

End Class
Public Class FPublic Sub M1(ByVal c As C) 
    Console.WriteLine("Instance method M1(c As C) on F:  c.ID = {0}", c.ID)
End Sub
Public Shared Sub M3(ByVal c As C) 
    Console.WriteLine("Shared method M3(c As C) on F:  c.ID = {0}", c.ID)
End Sub
Public Shared Sub M4(ByVal f As F, ByVal c As C) 
    Console.WriteLine("Shared method M4(f As F, c As C) on F:  c.ID = {0}", c.ID)
End Sub
End Class
Public Class Example5Public Shared Sub Main()
    Dim c1 As New C(42)
    Dim c2 As New C(1491)
    Dim f1 As New F()
    Dim d As D
    ' Instance method with one argument of type C.
    Dim cmi1 As MethodInfo = GetType(C).GetMethod("M1")
    ' Instance method with no arguments.
    Dim cmi2 As MethodInfo = GetType(C).GetMethod("M2")
    ' Shared method with one argument of type C.
    Dim cmi3 As MethodInfo = GetType(C).GetMethod("M3")
    ' Shared method with two arguments of type C.
    Dim cmi4 As MethodInfo = GetType(C).GetMethod("M4")
    ' Instance method with one argument of type C.
    Dim fmi1 As MethodInfo = GetType(F).GetMethod("M1")
    ' Shared method with one argument of type C.
    Dim fmi3 As MethodInfo = GetType(F).GetMethod("M3")
    ' Shared method with an argument of type F and an 
    ' argument of type C.
    Dim fmi4 As MethodInfo = GetType(F).GetMethod("M4")
    Console.WriteLine(vbLf & "An instance method on any type, with an argument of type C.")
    ' D can represent any instance method that exactly matches its
    ' signature. Methods on C and F are shown here.
    '
    d = CType([Delegate].CreateDelegate(GetType(D), c1, cmi1), D)
    d(c2)
    d = CType([Delegate].CreateDelegate(GetType(D), f1, fmi1), D)
    d(c2)
    Console.WriteLine(vbLf & "An instance method on C with no arguments.")
    ' D can represent an instance method on C that has no arguments;
    ' in this case, the argument of D represents the hidden first
    ' argument of any instance method. The delegate acts like a 
    ' Shared method, and an instance of C must be passed each time
    ' it is invoked.
    '
    d = CType([Delegate].CreateDelegate(GetType(D), Nothing, cmi2), D)
    d(c1)
    Console.WriteLine(vbLf & "A Shared method on any type, with an argument of type C.")
    ' D can represent any Shared method with the same signature.
    ' Methods on F and C are shown here.
    '
    d = CType([Delegate].CreateDelegate(GetType(D), Nothing, cmi3), D)
    d(c1)
    d = CType([Delegate].CreateDelegate(GetType(D), Nothing, fmi3), D)
    d(c1)
    Console.WriteLine(vbLf & "A Shared method on any type, with an argument of")
    Console.WriteLine("    that type and an argument of type C.")
    ' D can represent any Shared method with one argument of the
    ' type the method belongs and a second argument of type C.
    ' In this case, the method is closed over the instance of
    ' supplied for the its first argument, and acts like an instance
    ' method. Methods on F and C are shown here.
    '
    d = CType([Delegate].CreateDelegate(GetType(D), c1, cmi4), D)
    d(c2)
    Dim test As [Delegate] =
        [Delegate].CreateDelegate(GetType(D), f1, fmi4, False)
    ' This final example specifies False for throwOnBindFailure 
    ' in the call to CreateDelegate, so the variable 'test'
    ' contains Nothing if the method fails to bind (for 
    ' example, if fmi4 happened to represent a method of  
    ' some class other than F).
    '
    If test IsNot Nothing Then
        d = CType(test, D)
        d(c2)
    End If
End Sub
End Class
' This code example produces the following output:
'
'An instance method on any type, with an argument of type C.
'Instance method M1(c As C) on C: this.id = 42, c.ID = 1491
'Instance method M1(c As C) on F: c.ID = 1491
'
'An instance method on C with no arguments.
'Instance method M2() on C: this.id = 42
'
'A Shared method on any type, with an argument of type C.
'Shared method M3(c As C) on C: c.ID = 42
'Shared method M3(c As C) on F: c.ID = 42
'
'A Shared method on any type, with an argument of
' that type and an argument of type C.
'Shared method M4(c1 As C, c2 As C) on C: c1.ID = 42, c2.ID = 1491
'Shared method M4(f As F, c As C) on F: c.ID = 1491
'

2, and a delegate type

Imports System.Reflection Imports System.Security.Permissions ' Declare a delegate type. The object of this code example ' is to show all the methods this delegate can bind to. ' Public Delegate Sub D(ByVal c As C) ' Declare two sample classes, C and F. Class C has an ID ' property so instances can be identified. ' Public Class C

Private _id As Integer
Public ReadOnly Property ID() As Integer 
    Get
        Return _id
    End Get
End Property
Public Sub New(ByVal newId As Integer) 
    Me._id = newId
End Sub
Public Sub M1(ByVal c As C) 
    Console.WriteLine("Instance method M1(c As C) on C:  this.id = {0}, c.ID = {1}", _
        Me.id, c.ID)
End Sub
Public Sub M2() 
    Console.WriteLine("Instance method M2() on C:  this.id = {0}", Me.id)
End Sub
Public Shared Sub M3(ByVal c As C) 
    Console.WriteLine("Shared method M3(c As C) on C:  c.ID = {0}", c.ID)
End Sub
Public Shared Sub M4(ByVal c1 As C, ByVal c2 As C) 
    Console.WriteLine("Shared method M4(c1 As C, c2 As C) on C:  c1.ID = {0}, c2.ID = {1}", _
        c1.ID, c2.ID)
End Sub

End Class
Public Class FPublic Sub M1(ByVal c As C) 
    Console.WriteLine("Instance method M1(c As C) on F:  c.ID = {0}", c.ID)
End Sub
Public Shared Sub M3(ByVal c As C) 
    Console.WriteLine("Shared method M3(c As C) on F:  c.ID = {0}", c.ID)
End Sub
Public Shared Sub M4(ByVal f As F, ByVal c As C) 
    Console.WriteLine("Shared method M4(f As F, c As C) on F:  c.ID = {0}", c.ID)
End Sub
End Class
Public Class Example5Public Shared Sub Main()
    Dim c1 As New C(42)
    Dim c2 As New C(1491)
    Dim f1 As New F()
    Dim d As D
    ' Instance method with one argument of type C.
    Dim cmi1 As MethodInfo = GetType(C).GetMethod("M1")
    ' Instance method with no arguments.
    Dim cmi2 As MethodInfo = GetType(C).GetMethod("M2")
    ' Shared method with one argument of type C.
    Dim cmi3 As MethodInfo = GetType(C).GetMethod("M3")
    ' Shared method with two arguments of type C.
    Dim cmi4 As MethodInfo = GetType(C).GetMethod("M4")
    ' Instance method with one argument of type C.
    Dim fmi1 As MethodInfo = GetType(F).GetMethod("M1")
    ' Shared method with one argument of type C.
    Dim fmi3 As MethodInfo = GetType(F).GetMethod("M3")
    ' Shared method with an argument of type F and an 
    ' argument of type C.
    Dim fmi4 As MethodInfo = GetType(F).GetMethod("M4")
    Console.WriteLine(vbLf & "An instance method on any type, with an argument of type C.")
    ' D can represent any instance method that exactly matches its
    ' signature. Methods on C and F are shown here.
    '
    d = CType([Delegate].CreateDelegate(GetType(D), c1, cmi1), D)
    d(c2)
    d = CType([Delegate].CreateDelegate(GetType(D), f1, fmi1), D)
    d(c2)
    Console.WriteLine(vbLf & "An instance method on C with no arguments.")
    ' D can represent an instance method on C that has no arguments;
    ' in this case, the argument of D represents the hidden first
    ' argument of any instance method. The delegate acts like a 
    ' Shared method, and an instance of C must be passed each time
    ' it is invoked.
    '
    d = CType([Delegate].CreateDelegate(GetType(D), Nothing, cmi2), D)
    d(c1)
    Console.WriteLine(vbLf & "A Shared method on any type, with an argument of type C.")
    ' D can represent any Shared method with the same signature.
    ' Methods on F and C are shown here.
    '
    d = CType([Delegate].CreateDelegate(GetType(D), Nothing, cmi3), D)
    d(c1)
    d = CType([Delegate].CreateDelegate(GetType(D), Nothing, fmi3), D)
    d(c1)
    Console.WriteLine(vbLf & "A Shared method on any type, with an argument of")
    Console.WriteLine("    that type and an argument of type C.")
    ' D can represent any Shared method with one argument of the
    ' type the method belongs and a second argument of type C.
    ' In this case, the method is closed over the instance of
    ' supplied for the its first argument, and acts like an instance
    ' method. Methods on F and C are shown here.
    '
    d = CType([Delegate].CreateDelegate(GetType(D), c1, cmi4), D)
    d(c2)
    Dim test As [Delegate] =
        [Delegate].CreateDelegate(GetType(D), f1, fmi4, False)
    ' This final example specifies False for throwOnBindFailure 
    ' in the call to CreateDelegate, so the variable 'test'
    ' contains Nothing if the method fails to bind (for 
    ' example, if fmi4 happened to represent a method of  
    ' some class other than F).
    '
    If test IsNot Nothing Then
        d = CType(test, D)
        d(c2)
    End If
End Sub
End Class
' This code example produces the following output:
'
'An instance method on any type, with an argument of type C.
'Instance method M1(c As C) on C: this.id = 42, c.ID = 1491
'Instance method M1(c As C) on F: c.ID = 1491
'
'An instance method on C with no arguments.
'Instance method M2() on C: this.id = 42
'
'A Shared method on any type, with an argument of type C.
'Shared method M3(c As C) on C: c.ID = 42
'Shared method M3(c As C) on F: c.ID = 42
'
'A Shared method on any type, with an argument of
' that type and an argument of type C.
'Shared method M4(c1 As C, c2 As C) on C: c1.ID = 42, c2.ID = 1491
'Shared method M4(f As F, c As C) on F: c.ID = 1491
'

3 with one argument of type

open System open System.Reflection // A sample class with an instance method and a static method. type C(id) =

member _.M1(s) =
    printfn $"Instance method M1 on C:  id = %i{id}, s = %s{s}"
static member M2(s) =
    printfn $"Static method M2 on C:  s = %s{s}"

// Declare three delegate types for demonstrating the combinations
// of static versus instance methods and open versus closed
// delegates.
type D1 = delegate of C * string -> unit
type D2 = delegate of string -> unit
type D3 = delegate of unit -> unit
let c1 = C 42
// Get a MethodInfo for each method.
//
let mi1 = typeof.GetMethod("M1", BindingFlags.Public ||| BindingFlags.Instance)
let mi2 = typeof.GetMethod("M2", BindingFlags.Public ||| BindingFlags.Static)
printfn "\nAn instance method closed over C."
// In this case, the delegate and the
// method must have the same list of argument types use
// delegate type D2 with instance method M1.
let test = Delegate.CreateDelegate(typeof, c1, mi1, false)
// Because false was specified for throwOnBindFailure
// in the call to CreateDelegate, the variable 'test'
// contains null if the method fails to bind (for
// example, if mi1 happened to represent a method of
// some class other than C).
if test <> null thenlet d2 = test :?> D2
// The same instance of C is used every time the
// delegate is invoked.
d2.Invoke "Hello, World!"
d2.Invoke "Hi, Mom!"
printfn "\nAn open instance method."
// In this case, the delegate has one more
// argument than the instance method this argument comes
// at the beginning, and represents the hidden instance
// argument of the instance method. Use delegate type D1
// with instance method M1.
let d1 = Delegate.CreateDelegate(typeof, null, mi1) :?> D1
// An instance of C must be passed in each time the
// delegate is invoked.
d1.Invoke(c1, "Hello, World!")
d1.Invoke(C 5280, "Hi, Mom!")
printfn "\nAn open static method."
// In this case, the delegate and the method must
// have the same list of argument types use delegate type
// D2 with static method M2.
let d2 = Delegate.CreateDelegate(typeof, null, mi2) :?> D2
// No instances of C are involved, because this is a static
// method.
d2.Invoke "Hello, World!"
d2.Invoke "Hi, Mom!"
printfn "\nA static method closed over the first argument (String)."
// The delegate must omit the first argument of the method.
// A string is passed as the firstArgument parameter, and
// the delegate is bound to this string. Use delegate type
// D3 with static method M2.
let d3 = Delegate.CreateDelegate(typeof, "Hello, World!", mi2) :?> D3
// Each time the delegate is invoked, the same string is used.
d3.Invoke()
// This code example produces the following output:
// An instance method closed over C.
// Instance method M1 on C: id = 42, s = Hello, World!
// Instance method M1 on C: id = 42, s = Hi, Mom!
//
// An open instance method.
// Instance method M1 on C: id = 42, s = Hello, World!
// Instance method M1 on C: id = 5280, s = Hi, Mom!
//
// An open static method.
// Static method M2 on C: s = Hello, World!
// Static method M2 on C: s = Hi, Mom!
//
// A static method closed over the first argument (String).
// Static method M2 on C: s = Hello, World!

1. The classes have matching static and instance methods

open System open System.Reflection // A sample class with an instance method and a static method. type C(id) =

member _.M1(s) =
    printfn $"Instance method M1 on C:  id = %i{id}, s = %s{s}"
static member M2(s) =
    printfn $"Static method M2 on C:  s = %s{s}"

// Declare three delegate types for demonstrating the combinations
// of static versus instance methods and open versus closed
// delegates.
type D1 = delegate of C * string -> unit
type D2 = delegate of string -> unit
type D3 = delegate of unit -> unit
let c1 = C 42
// Get a MethodInfo for each method.
//
let mi1 = typeof.GetMethod("M1", BindingFlags.Public ||| BindingFlags.Instance)
let mi2 = typeof.GetMethod("M2", BindingFlags.Public ||| BindingFlags.Static)
printfn "\nAn instance method closed over C."
// In this case, the delegate and the
// method must have the same list of argument types use
// delegate type D2 with instance method M1.
let test = Delegate.CreateDelegate(typeof, c1, mi1, false)
// Because false was specified for throwOnBindFailure
// in the call to CreateDelegate, the variable 'test'
// contains null if the method fails to bind (for
// example, if mi1 happened to represent a method of
// some class other than C).
if test <> null thenlet d2 = test :?> D2
// The same instance of C is used every time the
// delegate is invoked.
d2.Invoke "Hello, World!"
d2.Invoke "Hi, Mom!"
printfn "\nAn open instance method."
// In this case, the delegate has one more
// argument than the instance method this argument comes
// at the beginning, and represents the hidden instance
// argument of the instance method. Use delegate type D1
// with instance method M1.
let d1 = Delegate.CreateDelegate(typeof, null, mi1) :?> D1
// An instance of C must be passed in each time the
// delegate is invoked.
d1.Invoke(c1, "Hello, World!")
d1.Invoke(C 5280, "Hi, Mom!")
printfn "\nAn open static method."
// In this case, the delegate and the method must
// have the same list of argument types use delegate type
// D2 with static method M2.
let d2 = Delegate.CreateDelegate(typeof, null, mi2) :?> D2
// No instances of C are involved, because this is a static
// method.
d2.Invoke "Hello, World!"
d2.Invoke "Hi, Mom!"
printfn "\nA static method closed over the first argument (String)."
// The delegate must omit the first argument of the method.
// A string is passed as the firstArgument parameter, and
// the delegate is bound to this string. Use delegate type
// D3 with static method M2.
let d3 = Delegate.CreateDelegate(typeof, "Hello, World!", mi2) :?> D3
// Each time the delegate is invoked, the same string is used.
d3.Invoke()
// This code example produces the following output:
// An instance method closed over C.
// Instance method M1 on C: id = 42, s = Hello, World!
// Instance method M1 on C: id = 42, s = Hi, Mom!
//
// An open instance method.
// Instance method M1 on C: id = 42, s = Hello, World!
// Instance method M1 on C: id = 5280, s = Hi, Mom!
//
// An open static method.
// Static method M2 on C: s = Hello, World!
// Static method M2 on C: s = Hi, Mom!
//
// A static method closed over the first argument (String).
// Static method M2 on C: s = Hello, World!

3,

Imports System.Reflection Imports System.Security.Permissions ' Declare a delegate type. The object of this code example ' is to show all the methods this delegate can bind to. ' Public Delegate Sub D(ByVal c As C) ' Declare two sample classes, C and F. Class C has an ID ' property so instances can be identified. ' Public Class C

Private _id As Integer
Public ReadOnly Property ID() As Integer 
    Get
        Return _id
    End Get
End Property
Public Sub New(ByVal newId As Integer) 
    Me._id = newId
End Sub
Public Sub M1(ByVal c As C) 
    Console.WriteLine("Instance method M1(c As C) on C:  this.id = {0}, c.ID = {1}", _
        Me.id, c.ID)
End Sub
Public Sub M2() 
    Console.WriteLine("Instance method M2() on C:  this.id = {0}", Me.id)
End Sub
Public Shared Sub M3(ByVal c As C) 
    Console.WriteLine("Shared method M3(c As C) on C:  c.ID = {0}", c.ID)
End Sub
Public Shared Sub M4(ByVal c1 As C, ByVal c2 As C) 
    Console.WriteLine("Shared method M4(c1 As C, c2 As C) on C:  c1.ID = {0}, c2.ID = {1}", _
        c1.ID, c2.ID)
End Sub

End Class
Public Class FPublic Sub M1(ByVal c As C) 
    Console.WriteLine("Instance method M1(c As C) on F:  c.ID = {0}", c.ID)
End Sub
Public Shared Sub M3(ByVal c As C) 
    Console.WriteLine("Shared method M3(c As C) on F:  c.ID = {0}", c.ID)
End Sub
Public Shared Sub M4(ByVal f As F, ByVal c As C) 
    Console.WriteLine("Shared method M4(f As F, c As C) on F:  c.ID = {0}", c.ID)
End Sub
End Class
Public Class Example5Public Shared Sub Main()
    Dim c1 As New C(42)
    Dim c2 As New C(1491)
    Dim f1 As New F()
    Dim d As D
    ' Instance method with one argument of type C.
    Dim cmi1 As MethodInfo = GetType(C).GetMethod("M1")
    ' Instance method with no arguments.
    Dim cmi2 As MethodInfo = GetType(C).GetMethod("M2")
    ' Shared method with one argument of type C.
    Dim cmi3 As MethodInfo = GetType(C).GetMethod("M3")
    ' Shared method with two arguments of type C.
    Dim cmi4 As MethodInfo = GetType(C).GetMethod("M4")
    ' Instance method with one argument of type C.
    Dim fmi1 As MethodInfo = GetType(F).GetMethod("M1")
    ' Shared method with one argument of type C.
    Dim fmi3 As MethodInfo = GetType(F).GetMethod("M3")
    ' Shared method with an argument of type F and an 
    ' argument of type C.
    Dim fmi4 As MethodInfo = GetType(F).GetMethod("M4")
    Console.WriteLine(vbLf & "An instance method on any type, with an argument of type C.")
    ' D can represent any instance method that exactly matches its
    ' signature. Methods on C and F are shown here.
    '
    d = CType([Delegate].CreateDelegate(GetType(D), c1, cmi1), D)
    d(c2)
    d = CType([Delegate].CreateDelegate(GetType(D), f1, fmi1), D)
    d(c2)
    Console.WriteLine(vbLf & "An instance method on C with no arguments.")
    ' D can represent an instance method on C that has no arguments;
    ' in this case, the argument of D represents the hidden first
    ' argument of any instance method. The delegate acts like a 
    ' Shared method, and an instance of C must be passed each time
    ' it is invoked.
    '
    d = CType([Delegate].CreateDelegate(GetType(D), Nothing, cmi2), D)
    d(c1)
    Console.WriteLine(vbLf & "A Shared method on any type, with an argument of type C.")
    ' D can represent any Shared method with the same signature.
    ' Methods on F and C are shown here.
    '
    d = CType([Delegate].CreateDelegate(GetType(D), Nothing, cmi3), D)
    d(c1)
    d = CType([Delegate].CreateDelegate(GetType(D), Nothing, fmi3), D)
    d(c1)
    Console.WriteLine(vbLf & "A Shared method on any type, with an argument of")
    Console.WriteLine("    that type and an argument of type C.")
    ' D can represent any Shared method with one argument of the
    ' type the method belongs and a second argument of type C.
    ' In this case, the method is closed over the instance of
    ' supplied for the its first argument, and acts like an instance
    ' method. Methods on F and C are shown here.
    '
    d = CType([Delegate].CreateDelegate(GetType(D), c1, cmi4), D)
    d(c2)
    Dim test As [Delegate] =
        [Delegate].CreateDelegate(GetType(D), f1, fmi4, False)
    ' This final example specifies False for throwOnBindFailure 
    ' in the call to CreateDelegate, so the variable 'test'
    ' contains Nothing if the method fails to bind (for 
    ' example, if fmi4 happened to represent a method of  
    ' some class other than F).
    '
    If test IsNot Nothing Then
        d = CType(test, D)
        d(c2)
    End If
End Sub
End Class
' This code example produces the following output:
'
'An instance method on any type, with an argument of type C.
'Instance method M1(c As C) on C: this.id = 42, c.ID = 1491
'Instance method M1(c As C) on F: c.ID = 1491
'
'An instance method on C with no arguments.
'Instance method M2() on C: this.id = 42
'
'A Shared method on any type, with an argument of type C.
'Shared method M3(c As C) on C: c.ID = 42
'Shared method M3(c As C) on F: c.ID = 42
'
'A Shared method on any type, with an argument of
' that type and an argument of type C.
'Shared method M4(c1 As C, c2 As C) on C: c1.ID = 42, c2.ID = 1491
'Shared method M4(f As F, c As C) on F: c.ID = 1491
'

6, and

Imports System.Reflection Imports System.Security.Permissions ' Declare a delegate type. The object of this code example ' is to show all the methods this delegate can bind to. ' Public Delegate Sub D(ByVal c As C) ' Declare two sample classes, C and F. Class C has an ID ' property so instances can be identified. ' Public Class C

Private _id As Integer
Public ReadOnly Property ID() As Integer 
    Get
        Return _id
    End Get
End Property
Public Sub New(ByVal newId As Integer) 
    Me._id = newId
End Sub
Public Sub M1(ByVal c As C) 
    Console.WriteLine("Instance method M1(c As C) on C:  this.id = {0}, c.ID = {1}", _
        Me.id, c.ID)
End Sub
Public Sub M2() 
    Console.WriteLine("Instance method M2() on C:  this.id = {0}", Me.id)
End Sub
Public Shared Sub M3(ByVal c As C) 
    Console.WriteLine("Shared method M3(c As C) on C:  c.ID = {0}", c.ID)
End Sub
Public Shared Sub M4(ByVal c1 As C, ByVal c2 As C) 
    Console.WriteLine("Shared method M4(c1 As C, c2 As C) on C:  c1.ID = {0}, c2.ID = {1}", _
        c1.ID, c2.ID)
End Sub

End Class
Public Class FPublic Sub M1(ByVal c As C) 
    Console.WriteLine("Instance method M1(c As C) on F:  c.ID = {0}", c.ID)
End Sub
Public Shared Sub M3(ByVal c As C) 
    Console.WriteLine("Shared method M3(c As C) on F:  c.ID = {0}", c.ID)
End Sub
Public Shared Sub M4(ByVal f As F, ByVal c As C) 
    Console.WriteLine("Shared method M4(f As F, c As C) on F:  c.ID = {0}", c.ID)
End Sub
End Class
Public Class Example5Public Shared Sub Main()
    Dim c1 As New C(42)
    Dim c2 As New C(1491)
    Dim f1 As New F()
    Dim d As D
    ' Instance method with one argument of type C.
    Dim cmi1 As MethodInfo = GetType(C).GetMethod("M1")
    ' Instance method with no arguments.
    Dim cmi2 As MethodInfo = GetType(C).GetMethod("M2")
    ' Shared method with one argument of type C.
    Dim cmi3 As MethodInfo = GetType(C).GetMethod("M3")
    ' Shared method with two arguments of type C.
    Dim cmi4 As MethodInfo = GetType(C).GetMethod("M4")
    ' Instance method with one argument of type C.
    Dim fmi1 As MethodInfo = GetType(F).GetMethod("M1")
    ' Shared method with one argument of type C.
    Dim fmi3 As MethodInfo = GetType(F).GetMethod("M3")
    ' Shared method with an argument of type F and an 
    ' argument of type C.
    Dim fmi4 As MethodInfo = GetType(F).GetMethod("M4")
    Console.WriteLine(vbLf & "An instance method on any type, with an argument of type C.")
    ' D can represent any instance method that exactly matches its
    ' signature. Methods on C and F are shown here.
    '
    d = CType([Delegate].CreateDelegate(GetType(D), c1, cmi1), D)
    d(c2)
    d = CType([Delegate].CreateDelegate(GetType(D), f1, fmi1), D)
    d(c2)
    Console.WriteLine(vbLf & "An instance method on C with no arguments.")
    ' D can represent an instance method on C that has no arguments;
    ' in this case, the argument of D represents the hidden first
    ' argument of any instance method. The delegate acts like a 
    ' Shared method, and an instance of C must be passed each time
    ' it is invoked.
    '
    d = CType([Delegate].CreateDelegate(GetType(D), Nothing, cmi2), D)
    d(c1)
    Console.WriteLine(vbLf & "A Shared method on any type, with an argument of type C.")
    ' D can represent any Shared method with the same signature.
    ' Methods on F and C are shown here.
    '
    d = CType([Delegate].CreateDelegate(GetType(D), Nothing, cmi3), D)
    d(c1)
    d = CType([Delegate].CreateDelegate(GetType(D), Nothing, fmi3), D)
    d(c1)
    Console.WriteLine(vbLf & "A Shared method on any type, with an argument of")
    Console.WriteLine("    that type and an argument of type C.")
    ' D can represent any Shared method with one argument of the
    ' type the method belongs and a second argument of type C.
    ' In this case, the method is closed over the instance of
    ' supplied for the its first argument, and acts like an instance
    ' method. Methods on F and C are shown here.
    '
    d = CType([Delegate].CreateDelegate(GetType(D), c1, cmi4), D)
    d(c2)
    Dim test As [Delegate] =
        [Delegate].CreateDelegate(GetType(D), f1, fmi4, False)
    ' This final example specifies False for throwOnBindFailure 
    ' in the call to CreateDelegate, so the variable 'test'
    ' contains Nothing if the method fails to bind (for 
    ' example, if fmi4 happened to represent a method of  
    ' some class other than F).
    '
    If test IsNot Nothing Then
        d = CType(test, D)
        d(c2)
    End If
End Sub
End Class
' This code example produces the following output:
'
'An instance method on any type, with an argument of type C.
'Instance method M1(c As C) on C: this.id = 42, c.ID = 1491
'Instance method M1(c As C) on F: c.ID = 1491
'
'An instance method on C with no arguments.
'Instance method M2() on C: this.id = 42
'
'A Shared method on any type, with an argument of type C.
'Shared method M3(c As C) on C: c.ID = 42
'Shared method M3(c As C) on F: c.ID = 42
'
'A Shared method on any type, with an argument of
' that type and an argument of type C.
'Shared method M4(c1 As C, c2 As C) on C: c1.ID = 42, c2.ID = 1491
'Shared method M4(f As F, c As C) on F: c.ID = 1491
'

7, and class

open System open System.Reflection // A sample class with an instance method and a static method. type C(id) =

member _.M1(s) =
    printfn $"Instance method M1 on C:  id = %i{id}, s = %s{s}"
static member M2(s) =
    printfn $"Static method M2 on C:  s = %s{s}"

// Declare three delegate types for demonstrating the combinations
// of static versus instance methods and open versus closed
// delegates.
type D1 = delegate of C * string -> unit
type D2 = delegate of string -> unit
type D3 = delegate of unit -> unit
let c1 = C 42
// Get a MethodInfo for each method.
//
let mi1 = typeof.GetMethod("M1", BindingFlags.Public ||| BindingFlags.Instance)
let mi2 = typeof.GetMethod("M2", BindingFlags.Public ||| BindingFlags.Static)
printfn "\nAn instance method closed over C."
// In this case, the delegate and the
// method must have the same list of argument types use
// delegate type D2 with instance method M1.
let test = Delegate.CreateDelegate(typeof, c1, mi1, false)
// Because false was specified for throwOnBindFailure
// in the call to CreateDelegate, the variable 'test'
// contains null if the method fails to bind (for
// example, if mi1 happened to represent a method of
// some class other than C).
if test <> null thenlet d2 = test :?> D2
// The same instance of C is used every time the
// delegate is invoked.
d2.Invoke "Hello, World!"
d2.Invoke "Hi, Mom!"
printfn "\nAn open instance method."
// In this case, the delegate has one more
// argument than the instance method this argument comes
// at the beginning, and represents the hidden instance
// argument of the instance method. Use delegate type D1
// with instance method M1.
let d1 = Delegate.CreateDelegate(typeof, null, mi1) :?> D1
// An instance of C must be passed in each time the
// delegate is invoked.
d1.Invoke(c1, "Hello, World!")
d1.Invoke(C 5280, "Hi, Mom!")
printfn "\nAn open static method."
// In this case, the delegate and the method must
// have the same list of argument types use delegate type
// D2 with static method M2.
let d2 = Delegate.CreateDelegate(typeof, null, mi2) :?> D2
// No instances of C are involved, because this is a static
// method.
d2.Invoke "Hello, World!"
d2.Invoke "Hi, Mom!"
printfn "\nA static method closed over the first argument (String)."
// The delegate must omit the first argument of the method.
// A string is passed as the firstArgument parameter, and
// the delegate is bound to this string. Use delegate type
// D3 with static method M2.
let d3 = Delegate.CreateDelegate(typeof, "Hello, World!", mi2) :?> D3
// Each time the delegate is invoked, the same string is used.
d3.Invoke()
// This code example produces the following output:
// An instance method closed over C.
// Instance method M1 on C: id = 42, s = Hello, World!
// Instance method M1 on C: id = 42, s = Hi, Mom!
//
// An open instance method.
// Instance method M1 on C: id = 42, s = Hello, World!
// Instance method M1 on C: id = 5280, s = Hi, Mom!
//
// An open static method.
// Static method M2 on C: s = Hello, World!
// Static method M2 on C: s = Hi, Mom!
//
// A static method closed over the first argument (String).
// Static method M2 on C: s = Hello, World!

1 also has an instance method

open System open System.Reflection // A sample class with an instance method and a static method. type C(id) =

member _.M1(s) =
    printfn $"Instance method M1 on C:  id = %i{id}, s = %s{s}"
static member M2(s) =
    printfn $"Static method M2 on C:  s = %s{s}"

// Declare three delegate types for demonstrating the combinations
// of static versus instance methods and open versus closed
// delegates.
type D1 = delegate of C * string -> unit
type D2 = delegate of string -> unit
type D3 = delegate of unit -> unit
let c1 = C 42
// Get a MethodInfo for each method.
//
let mi1 = typeof.GetMethod("M1", BindingFlags.Public ||| BindingFlags.Instance)
let mi2 = typeof.GetMethod("M2", BindingFlags.Public ||| BindingFlags.Static)
printfn "\nAn instance method closed over C."
// In this case, the delegate and the
// method must have the same list of argument types use
// delegate type D2 with instance method M1.
let test = Delegate.CreateDelegate(typeof, c1, mi1, false)
// Because false was specified for throwOnBindFailure
// in the call to CreateDelegate, the variable 'test'
// contains null if the method fails to bind (for
// example, if mi1 happened to represent a method of
// some class other than C).
if test <> null thenlet d2 = test :?> D2
// The same instance of C is used every time the
// delegate is invoked.
d2.Invoke "Hello, World!"
d2.Invoke "Hi, Mom!"
printfn "\nAn open instance method."
// In this case, the delegate has one more
// argument than the instance method this argument comes
// at the beginning, and represents the hidden instance
// argument of the instance method. Use delegate type D1
// with instance method M1.
let d1 = Delegate.CreateDelegate(typeof, null, mi1) :?> D1
// An instance of C must be passed in each time the
// delegate is invoked.
d1.Invoke(c1, "Hello, World!")
d1.Invoke(C 5280, "Hi, Mom!")
printfn "\nAn open static method."
// In this case, the delegate and the method must
// have the same list of argument types use delegate type
// D2 with static method M2.
let d2 = Delegate.CreateDelegate(typeof, null, mi2) :?> D2
// No instances of C are involved, because this is a static
// method.
d2.Invoke "Hello, World!"
d2.Invoke "Hi, Mom!"
printfn "\nA static method closed over the first argument (String)."
// The delegate must omit the first argument of the method.
// A string is passed as the firstArgument parameter, and
// the delegate is bound to this string. Use delegate type
// D3 with static method M2.
let d3 = Delegate.CreateDelegate(typeof, "Hello, World!", mi2) :?> D3
// Each time the delegate is invoked, the same string is used.
d3.Invoke()
// This code example produces the following output:
// An instance method closed over C.
// Instance method M1 on C: id = 42, s = Hello, World!
// Instance method M1 on C: id = 42, s = Hi, Mom!
//
// An open instance method.
// Instance method M1 on C: id = 42, s = Hello, World!
// Instance method M1 on C: id = 5280, s = Hi, Mom!
//
// An open static method.
// Static method M2 on C: s = Hello, World!
// Static method M2 on C: s = Hi, Mom!
//
// A static method closed over the first argument (String).
// Static method M2 on C: s = Hello, World!

2 that has no arguments.

A third class named

open System open System.Reflection // A sample class with an instance method and a static method. type C(id) =

member _.M1(s) =
    printfn $"Instance method M1 on C:  id = %i{id}, s = %s{s}"
static member M2(s) =
    printfn $"Static method M2 on C:  s = %s{s}"

// Declare three delegate types for demonstrating the combinations
// of static versus instance methods and open versus closed
// delegates.
type D1 = delegate of C * string -> unit
type D2 = delegate of string -> unit
type D3 = delegate of unit -> unit
let c1 = C 42
// Get a MethodInfo for each method.
//
let mi1 = typeof.GetMethod("M1", BindingFlags.Public ||| BindingFlags.Instance)
let mi2 = typeof.GetMethod("M2", BindingFlags.Public ||| BindingFlags.Static)
printfn "\nAn instance method closed over C."
// In this case, the delegate and the
// method must have the same list of argument types use
// delegate type D2 with instance method M1.
let test = Delegate.CreateDelegate(typeof, c1, mi1, false)
// Because false was specified for throwOnBindFailure
// in the call to CreateDelegate, the variable 'test'
// contains null if the method fails to bind (for
// example, if mi1 happened to represent a method of
// some class other than C).
if test <> null thenlet d2 = test :?> D2
// The same instance of C is used every time the
// delegate is invoked.
d2.Invoke "Hello, World!"
d2.Invoke "Hi, Mom!"
printfn "\nAn open instance method."
// In this case, the delegate has one more
// argument than the instance method this argument comes
// at the beginning, and represents the hidden instance
// argument of the instance method. Use delegate type D1
// with instance method M1.
let d1 = Delegate.CreateDelegate(typeof, null, mi1) :?> D1
// An instance of C must be passed in each time the
// delegate is invoked.
d1.Invoke(c1, "Hello, World!")
d1.Invoke(C 5280, "Hi, Mom!")
printfn "\nAn open static method."
// In this case, the delegate and the method must
// have the same list of argument types use delegate type
// D2 with static method M2.
let d2 = Delegate.CreateDelegate(typeof, null, mi2) :?> D2
// No instances of C are involved, because this is a static
// method.
d2.Invoke "Hello, World!"
d2.Invoke "Hi, Mom!"
printfn "\nA static method closed over the first argument (String)."
// The delegate must omit the first argument of the method.
// A string is passed as the firstArgument parameter, and
// the delegate is bound to this string. Use delegate type
// D3 with static method M2.
let d3 = Delegate.CreateDelegate(typeof, "Hello, World!", mi2) :?> D3
// Each time the delegate is invoked, the same string is used.
d3.Invoke()
// This code example produces the following output:
// An instance method closed over C.
// Instance method M1 on C: id = 42, s = Hello, World!
// Instance method M1 on C: id = 42, s = Hi, Mom!
//
// An open instance method.
// Instance method M1 on C: id = 42, s = Hello, World!
// Instance method M1 on C: id = 5280, s = Hi, Mom!
//
// An open static method.
// Static method M2 on C: s = Hello, World!
// Static method M2 on C: s = Hi, Mom!
//
// A static method closed over the first argument (String).
// Static method M2 on C: s = Hello, World!

7 contains the code that creates the delegates.

Delegates are created for instance method open System open System.Reflection // A sample class with an instance method and a static method. type C(id) = member _.M1(s) = printfn $"Instance method M1 on C: id = %i{id}, s = %s{s}" static member M2(s) = printfn $"Static method M2 on C: s = %s{s}" // Declare three delegate types for demonstrating the combinations // of static versus instance methods and open versus closed // delegates. type D1 = delegate of C * string -> unit type D2 = delegate of string -> unit type D3 = delegate of unit -> unit let c1 = C 42 // Get a MethodInfo for each method. // let mi1 = typeof.GetMethod("M1", BindingFlags.Public ||| BindingFlags.Instance) let mi2 = typeof.GetMethod("M2", BindingFlags.Public ||| BindingFlags.Static) printfn "\nAn instance method closed over C." // In this case, the delegate and the // method must have the same list of argument types use // delegate type D2 with instance method M1. let test = Delegate.CreateDelegate(typeof, c1, mi1, false) // Because false was specified for throwOnBindFailure // in the call to CreateDelegate, the variable 'test' // contains null if the method fails to bind (for // example, if mi1 happened to represent a method of // some class other than C). if test <> null then let d2 = test :?> D2 // The same instance of C is used every time the // delegate is invoked. d2.Invoke "Hello, World!" d2.Invoke "Hi, Mom!" printfn "\nAn open instance method." // In this case, the delegate has one more // argument than the instance method this argument comes // at the beginning, and represents the hidden instance // argument of the instance method. Use delegate type D1 // with instance method M1. let d1 = Delegate.CreateDelegate(typeof, null, mi1) :?> D1 // An instance of C must be passed in each time the // delegate is invoked. d1.Invoke(c1, "Hello, World!") d1.Invoke(C 5280, "Hi, Mom!") printfn "\nAn open static method." // In this case, the delegate and the method must // have the same list of argument types use delegate type // D2 with static method M2. let d2 = Delegate.CreateDelegate(typeof, null, mi2) :?> D2 // No instances of C are involved, because this is a static // method. d2.Invoke "Hello, World!" d2.Invoke "Hi, Mom!" printfn "\nA static method closed over the first argument (String)." // The delegate must omit the first argument of the method. // A string is passed as the firstArgument parameter, and // the delegate is bound to this string. Use delegate type // D3 with static method M2. let d3 = Delegate.CreateDelegate(typeof, "Hello, World!", mi2) :?> D3 // Each time the delegate is invoked, the same string is used. d3.Invoke() // This code example produces the following output: // An instance method closed over C. // Instance method M1 on C: id = 42, s = Hello, World! // Instance method M1 on C: id = 42, s = Hi, Mom! // // An open instance method. // Instance method M1 on C: id = 42, s = Hello, World! // Instance method M1 on C: id = 5280, s = Hi, Mom! // // An open static method. // Static method M2 on C: s = Hello, World! // Static method M2 on C: s = Hi, Mom! // // A static method closed over the first argument (String). // Static method M2 on C: s = Hello, World!
3 of type
open System open System.Reflection // A sample class with an instance method and a static method. type C(id) = member _.M1(s) = printfn $"Instance method M1 on C: id = %i{id}, s = %s{s}" static member M2(s) = printfn $"Static method M2 on C: s = %s{s}" // Declare three delegate types for demonstrating the combinations // of static versus instance methods and open versus closed // delegates. type D1 = delegate of C * string -> unit type D2 = delegate of string -> unit type D3 = delegate of unit -> unit let c1 = C 42 // Get a MethodInfo for each method. // let mi1 = typeof.GetMethod("M1", BindingFlags.Public ||| BindingFlags.Instance) let mi2 = typeof.GetMethod("M2", BindingFlags.Public ||| BindingFlags.Static) printfn "\nAn instance method closed over C." // In this case, the delegate and the // method must have the same list of argument types use // delegate type D2 with instance method M1. let test = Delegate.CreateDelegate(typeof, c1, mi1, false) // Because false was specified for throwOnBindFailure // in the call to CreateDelegate, the variable 'test' // contains null if the method fails to bind (for // example, if mi1 happened to represent a method of // some class other than C). if test <> null then let d2 = test :?> D2 // The same instance of C is used every time the // delegate is invoked. d2.Invoke "Hello, World!" d2.Invoke "Hi, Mom!" printfn "\nAn open instance method." // In this case, the delegate has one more // argument than the instance method this argument comes // at the beginning, and represents the hidden instance // argument of the instance method. Use delegate type D1 // with instance method M1. let d1 = Delegate.CreateDelegate(typeof, null, mi1) :?> D1 // An instance of C must be passed in each time the // delegate is invoked. d1.Invoke(c1, "Hello, World!") d1.Invoke(C 5280, "Hi, Mom!") printfn "\nAn open static method." // In this case, the delegate and the method must // have the same list of argument types use delegate type // D2 with static method M2. let d2 = Delegate.CreateDelegate(typeof, null, mi2) :?> D2 // No instances of C are involved, because this is a static // method. d2.Invoke "Hello, World!" d2.Invoke "Hi, Mom!" printfn "\nA static method closed over the first argument (String)." // The delegate must omit the first argument of the method. // A string is passed as the firstArgument parameter, and // the delegate is bound to this string. Use delegate type // D3 with static method M2. let d3 = Delegate.CreateDelegate(typeof, "Hello, World!", mi2) :?> D3 // Each time the delegate is invoked, the same string is used. d3.Invoke() // This code example produces the following output: // An instance method closed over C. // Instance method M1 on C: id = 42, s = Hello, World! // Instance method M1 on C: id = 42, s = Hi, Mom! // // An open instance method. // Instance method M1 on C: id = 42, s = Hello, World! // Instance method M1 on C: id = 5280, s = Hi, Mom! // // An open static method. // Static method M2 on C: s = Hello, World! // Static method M2 on C: s = Hi, Mom! // // A static method closed over the first argument (String). // Static method M2 on C: s = Hello, World!
1 and type
Imports System.Reflection Imports System.Security.Permissions ' Declare a delegate type. The object of this code example ' is to show all the methods this delegate can bind to. ' Public Delegate Sub D(ByVal c As C) ' Declare two sample classes, C and F. Class C has an ID ' property so instances can be identified. ' Public Class C Private id As Integer Public ReadOnly Property ID() As Integer Get Return _id End Get End Property Public Sub New(ByVal newId As Integer) Me._id = newId End Sub Public Sub M1(ByVal c As C) Console.WriteLine("Instance method M1(c As C) on C: this.id = {0}, c.ID = {1}", Me.id, c.ID) End Sub Public Sub M2() Console.WriteLine("Instance method M2() on C: this.id = {0}", Me.id) End Sub Public Shared Sub M3(ByVal c As C) Console.WriteLine("Shared method M3(c As C) on C: c.ID = {0}", c.ID) End Sub Public Shared Sub M4(ByVal c1 As C, ByVal c2 As C) Console.WriteLine("Shared method M4(c1 As C, c2 As C) on C: c1.ID = {0}, c2.ID = {1}", _ c1.ID, c2.ID) End Sub End Class Public Class F Public Sub M1(ByVal c As C) Console.WriteLine("Instance method M1(c As C) on F: c.ID = {0}", c.ID) End Sub Public Shared Sub M3(ByVal c As C) Console.WriteLine("Shared method M3(c As C) on F: c.ID = {0}", c.ID) End Sub Public Shared Sub M4(ByVal f As F, ByVal c As C) Console.WriteLine("Shared method M4(f As F, c As C) on F: c.ID = {0}", c.ID) End Sub End Class Public Class Example5 Public Shared Sub Main() Dim c1 As New C(42) Dim c2 As New C(1491) Dim f1 As New F() Dim d As D ' Instance method with one argument of type C. Dim cmi1 As MethodInfo = GetType(C).GetMethod("M1") ' Instance method with no arguments. Dim cmi2 As MethodInfo = GetType(C).GetMethod("M2") ' Shared method with one argument of type C. Dim cmi3 As MethodInfo = GetType(C).GetMethod("M3") ' Shared method with two arguments of type C. Dim cmi4 As MethodInfo = GetType(C).GetMethod("M4") ' Instance method with one argument of type C. Dim fmi1 As MethodInfo = GetType(F).GetMethod("M1") ' Shared method with one argument of type C. Dim fmi3 As MethodInfo = GetType(F).GetMethod("M3") ' Shared method with an argument of type F and an ' argument of type C. Dim fmi4 As MethodInfo = GetType(F).GetMethod("M4") Console.WriteLine(vbLf & "An instance method on any type, with an argument of type C.") ' D can represent any instance method that exactly matches its ' signature. Methods on C and F are shown here. ' d = CType([Delegate].CreateDelegate(GetType(D), c1, cmi1), D) d(c2) d = CType([Delegate].CreateDelegate(GetType(D), f1, fmi1), D) d(c2) Console.WriteLine(vbLf & "An instance method on C with no arguments.") ' D can represent an instance method on C that has no arguments; ' in this case, the argument of D represents the hidden first ' argument of any instance method. The delegate acts like a ' Shared method, and an instance of C must be passed each time ' it is invoked. ' d = CType([Delegate].CreateDelegate(GetType(D), Nothing, cmi2), D) d(c1) Console.WriteLine(vbLf & "A Shared method on any type, with an argument of type C.") ' D can represent any Shared method with the same signature. ' Methods on F and C are shown here. ' d = CType([Delegate].CreateDelegate(GetType(D), Nothing, cmi3), D) d(c1) d = CType([Delegate].CreateDelegate(GetType(D), Nothing, fmi3), D) d(c1) Console.WriteLine(vbLf & "A Shared method on any type, with an argument of") Console.WriteLine(" that type and an argument of type C.") ' D can represent any Shared method with one argument of the ' type the method belongs and a second argument of type C. ' In this case, the method is closed over the instance of ' supplied for the its first argument, and acts like an instance ' method. Methods on F and C are shown here. ' d = CType([Delegate].CreateDelegate(GetType(D), c1, cmi4), D) d(c2) Dim test As [Delegate] = [Delegate].CreateDelegate(GetType(D), f1, fmi4, False) ' This final example specifies False for throwOnBindFailure ' in the call to CreateDelegate, so the variable 'test' ' contains Nothing if the method fails to bind (for ' example, if fmi4 happened to represent a method of ' some class other than F). ' If test IsNot Nothing Then d = CType(test, D) d(c2) End If End Sub End Class ' This code example produces the following output: ' 'An instance method on any type, with an argument of type C. 'Instance method M1(c As C) on C: this.id = 42, c.ID = 1491 'Instance method M1(c As C) on F: c.ID = 1491 ' 'An instance method on C with no arguments. 'Instance method M2() on C: this.id = 42 ' 'A Shared method on any type, with an argument of type C. 'Shared method M3(c As C) on C: c.ID = 42 'Shared method M3(c As C) on F: c.ID = 42 ' 'A Shared method on any type, with an argument of ' that type and an argument of type C. 'Shared method M4(c1 As C, c2 As C) on C: c1.ID = 42, c2.ID = 1491 'Shared method M4(f As F, c As C) on F: c.ID = 1491 '
2; each is closed over an instance of the respective type. Method
open System open System.Reflection // A sample class with an instance method and a static method. type C(id) = member _.M1(s) = printfn $"Instance method M1 on C: id = %i{id}, s = %s{s}" static member M2(s) = printfn $"Static method M2 on C: s = %s{s}" // Declare three delegate types for demonstrating the combinations // of static versus instance methods and open versus closed // delegates. type D1 = delegate of C * string -> unit type D2 = delegate of string -> unit type D3 = delegate of unit -> unit let c1 = C 42 // Get a MethodInfo for each method. // let mi1 = typeof.GetMethod("M1", BindingFlags.Public ||| BindingFlags.Instance) let mi2 = typeof.GetMethod("M2", BindingFlags.Public ||| BindingFlags.Static) printfn "\nAn instance method closed over C." // In this case, the delegate and the // method must have the same list of argument types use // delegate type D2 with instance method M1. let test = Delegate.CreateDelegate(typeof, c1, mi1, false) // Because false was specified for throwOnBindFailure // in the call to CreateDelegate, the variable 'test' // contains null if the method fails to bind (for // example, if mi1 happened to represent a method of // some class other than C). if test <> null then let d2 = test :?> D2 // The same instance of C is used every time the // delegate is invoked. d2.Invoke "Hello, World!" d2.Invoke "Hi, Mom!" printfn "\nAn open instance method." // In this case, the delegate has one more // argument than the instance method this argument comes // at the beginning, and represents the hidden instance // argument of the instance method. Use delegate type D1 // with instance method M1. let d1 = Delegate.CreateDelegate(typeof, null, mi1) :?> D1 // An instance of C must be passed in each time the // delegate is invoked. d1.Invoke(c1, "Hello, World!") d1.Invoke(C 5280, "Hi, Mom!") printfn "\nAn open static method." // In this case, the delegate and the method must // have the same list of argument types use delegate type // D2 with static method M2. let d2 = Delegate.CreateDelegate(typeof, null, mi2) :?> D2 // No instances of C are involved, because this is a static // method. d2.Invoke "Hello, World!" d2.Invoke "Hi, Mom!" printfn "\nA static method closed over the first argument (String)." // The delegate must omit the first argument of the method. // A string is passed as the firstArgument parameter, and // the delegate is bound to this string. Use delegate type // D3 with static method M2. let d3 = Delegate.CreateDelegate(typeof, "Hello, World!", mi2) :?> D3 // Each time the delegate is invoked, the same string is used. d3.Invoke() // This code example produces the following output: // An instance method closed over C. // Instance method M1 on C: id = 42, s = Hello, World! // Instance method M1 on C: id = 42, s = Hi, Mom! // // An open instance method. // Instance method M1 on C: id = 42, s = Hello, World! // Instance method M1 on C: id = 5280, s = Hi, Mom! // // An open static method. // Static method M2 on C: s = Hello, World! // Static method M2 on C: s = Hi, Mom! // // A static method closed over the first argument (String). // Static method M2 on C: s = Hello, World!
3 of type
open System open System.Reflection // A sample class with an instance method and a static method. type C(id) = member _.M1(s) = printfn $"Instance method M1 on C: id = %i{id}, s = %s{s}" static member M2(s) = printfn $"Static method M2 on C: s = %s{s}" // Declare three delegate types for demonstrating the combinations // of static versus instance methods and open versus closed // delegates. type D1 = delegate of C * string -> unit type D2 = delegate of string -> unit type D3 = delegate of unit -> unit let c1 = C 42 // Get a MethodInfo for each method. // let mi1 = typeof.GetMethod("M1", BindingFlags.Public ||| BindingFlags.Instance) let mi2 = typeof.GetMethod("M2", BindingFlags.Public ||| BindingFlags.Static) printfn "\nAn instance method closed over C." // In this case, the delegate and the // method must have the same list of argument types use // delegate type D2 with instance method M1. let test = Delegate.CreateDelegate(typeof, c1, mi1, false) // Because false was specified for throwOnBindFailure // in the call to CreateDelegate, the variable 'test' // contains null if the method fails to bind (for // example, if mi1 happened to represent a method of // some class other than C). if test <> null then let d2 = test :?> D2 // The same instance of C is used every time the // delegate is invoked. d2.Invoke "Hello, World!" d2.Invoke "Hi, Mom!" printfn "\nAn open instance method." // In this case, the delegate has one more // argument than the instance method this argument comes // at the beginning, and represents the hidden instance // argument of the instance method. Use delegate type D1 // with instance method M1. let d1 = Delegate.CreateDelegate(typeof, null, mi1) :?> D1 // An instance of C must be passed in each time the // delegate is invoked. d1.Invoke(c1, "Hello, World!") d1.Invoke(C 5280, "Hi, Mom!") printfn "\nAn open static method." // In this case, the delegate and the method must // have the same list of argument types use delegate type // D2 with static method M2. let d2 = Delegate.CreateDelegate(typeof, null, mi2) :?> D2 // No instances of C are involved, because this is a static // method. d2.Invoke "Hello, World!" d2.Invoke "Hi, Mom!" printfn "\nA static method closed over the first argument (String)." // The delegate must omit the first argument of the method. // A string is passed as the firstArgument parameter, and // the delegate is bound to this string. Use delegate type // D3 with static method M2. let d3 = Delegate.CreateDelegate(typeof, "Hello, World!", mi2) :?> D3 // Each time the delegate is invoked, the same string is used. d3.Invoke() // This code example produces the following output: // An instance method closed over C. // Instance method M1 on C: id = 42, s = Hello, World! // Instance method M1 on C: id = 42, s = Hi, Mom! // // An open instance method. // Instance method M1 on C: id = 42, s = Hello, World! // Instance method M1 on C: id = 5280, s = Hi, Mom! // // An open static method. // Static method M2 on C: s = Hello, World! // Static method M2 on C: s = Hi, Mom! // // A static method closed over the first argument (String). // Static method M2 on C: s = Hello, World! 1 displays the `true`6 properties of the bound instance and of the argument.
A delegate is created for method open System open System.Reflection // A sample class with an instance method and a static method. type C(id) = member _.M1(s) = printfn $"Instance method M1 on C: id = %i{id}, s = %s{s}" static member M2(s) = printfn $"Static method M2 on C: s = %s{s}" // Declare three delegate types for demonstrating the combinations // of static versus instance methods and open versus closed // delegates. type D1 = delegate of C * string -> unit type D2 = delegate of string -> unit type D3 = delegate of unit -> unit let c1 = C 42 // Get a MethodInfo for each method. // let mi1 = typeof.GetMethod("M1", BindingFlags.Public ||| BindingFlags.Instance) let mi2 = typeof.GetMethod("M2", BindingFlags.Public ||| BindingFlags.Static) printfn "\nAn instance method closed over C." // In this case, the delegate and the // method must have the same list of argument types use // delegate type D2 with instance method M1. let test = Delegate.CreateDelegate(typeof, c1, mi1, false) // Because false was specified for throwOnBindFailure // in the call to CreateDelegate, the variable 'test' // contains null if the method fails to bind (for // example, if mi1 happened to represent a method of // some class other than C). if test <> null then let d2 = test :?> D2 // The same instance of C is used every time the // delegate is invoked. d2.Invoke "Hello, World!" d2.Invoke "Hi, Mom!" printfn "\nAn open instance method." // In this case, the delegate has one more // argument than the instance method this argument comes // at the beginning, and represents the hidden instance // argument of the instance method. Use delegate type D1 // with instance method M1. let d1 = Delegate.CreateDelegate(typeof, null, mi1) :?> D1 // An instance of C must be passed in each time the // delegate is invoked. d1.Invoke(c1, "Hello, World!") d1.Invoke(C 5280, "Hi, Mom!") printfn "\nAn open static method." // In this case, the delegate and the method must // have the same list of argument types use delegate type // D2 with static method M2. let d2 = Delegate.CreateDelegate(typeof, null, mi2) :?> D2 // No instances of C are involved, because this is a static // method. d2.Invoke "Hello, World!" d2.Invoke "Hi, Mom!" printfn "\nA static method closed over the first argument (String)." // The delegate must omit the first argument of the method. // A string is passed as the firstArgument parameter, and // the delegate is bound to this string. Use delegate type // D3 with static method M2. let d3 = Delegate.CreateDelegate(typeof, "Hello, World!", mi2) :?> D3 // Each time the delegate is invoked, the same string is used. d3.Invoke() // This code example produces the following output: // An instance method closed over C. // Instance method M1 on C: id = 42, s = Hello, World! // Instance method M1 on C: id = 42, s = Hi, Mom! // // An open instance method. // Instance method M1 on C: id = 42, s = Hello, World! // Instance method M1 on C: id = 5280, s = Hi, Mom! // // An open static method. // Static method M2 on C: s = Hello, World! // Static method M2 on C: s = Hi, Mom! // // A static method closed over the first argument (String). // Static method M2 on C: s = Hello, World!
2 of type
open System open System.Reflection // A sample class with an instance method and a static method. type C(id) = member _.M1(s) = printfn $"Instance method M1 on C: id = %i{id}, s = %s{s}" static member M2(s) = printfn $"Static method M2 on C: s = %s{s}" // Declare three delegate types for demonstrating the combinations // of static versus instance methods and open versus closed // delegates. type D1 = delegate of C * string -> unit type D2 = delegate of string -> unit type D3 = delegate of unit -> unit let c1 = C 42 // Get a MethodInfo for each method. // let mi1 = typeof.GetMethod("M1", BindingFlags.Public ||| BindingFlags.Instance) let mi2 = typeof.GetMethod("M2", BindingFlags.Public ||| BindingFlags.Static) printfn "\nAn instance method closed over C." // In this case, the delegate and the // method must have the same list of argument types use // delegate type D2 with instance method M1. let test = Delegate.CreateDelegate(typeof, c1, mi1, false) // Because false was specified for throwOnBindFailure // in the call to CreateDelegate, the variable 'test' // contains null if the method fails to bind (for // example, if mi1 happened to represent a method of // some class other than C). if test <> null then let d2 = test :?> D2 // The same instance of C is used every time the // delegate is invoked. d2.Invoke "Hello, World!" d2.Invoke "Hi, Mom!" printfn "\nAn open instance method." // In this case, the delegate has one more // argument than the instance method this argument comes // at the beginning, and represents the hidden instance // argument of the instance method. Use delegate type D1 // with instance method M1. let d1 = Delegate.CreateDelegate(typeof, null, mi1) :?> D1 // An instance of C must be passed in each time the // delegate is invoked. d1.Invoke(c1, "Hello, World!") d1.Invoke(C 5280, "Hi, Mom!") printfn "\nAn open static method." // In this case, the delegate and the method must // have the same list of argument types use delegate type // D2 with static method M2. let d2 = Delegate.CreateDelegate(typeof, null, mi2) :?> D2 // No instances of C are involved, because this is a static // method. d2.Invoke "Hello, World!" d2.Invoke "Hi, Mom!" printfn "\nA static method closed over the first argument (String)." // The delegate must omit the first argument of the method. // A string is passed as the firstArgument parameter, and // the delegate is bound to this string. Use delegate type // D3 with static method M2. let d3 = Delegate.CreateDelegate(typeof, "Hello, World!", mi2) :?> D3 // Each time the delegate is invoked, the same string is used. d3.Invoke() // This code example produces the following output: // An instance method closed over C. // Instance method M1 on C: id = 42, s = Hello, World! // Instance method M1 on C: id = 42, s = Hi, Mom! // // An open instance method. // Instance method M1 on C: id = 42, s = Hello, World! // Instance method M1 on C: id = 5280, s = Hi, Mom! // // An open static method. // Static method M2 on C: s = Hello, World! // Static method M2 on C: s = Hi, Mom! // // A static method closed over the first argument (String). // Static method M2 on C: s = Hello, World! 1. This is an open instance delegate, in which the argument of the delegate represents the hidden first argument on the instance method. The method has no other arguments. It is called as if it were a static method.

Delegates are created for static method

Imports System.Reflection Imports System.Security.Permissions
' Declare a delegate type. The object of this code example
' is to show all the methods this delegate can bind to.
'
Public Delegate Sub D(ByVal c As C)
' Declare two sample classes, C and F. Class C has an ID
' property so instances can be identified.
'
Public Class C 
Private id As Integer  
Public ReadOnly Property ID() As Integer  
    Get  
        Return _id  
    End Get  
End Property  
Public Sub New(ByVal newId As Integer)  
    Me._id = newId  
End Sub  
Public Sub M1(ByVal c As C)  
    Console.WriteLine("Instance method M1(c As C) on C:  this.id = {0}, c.ID = {1}",   
        Me.id, c.ID)  
End Sub  
Public Sub M2()  
    Console.WriteLine("Instance method M2() on C:  this.id = {0}", Me.id)  
End Sub  
Public Shared Sub M3(ByVal c As C)  
    Console.WriteLine("Shared method M3(c As C) on C:  c.ID = {0}", c.ID)  
End Sub  
Public Shared Sub M4(ByVal c1 As C, ByVal c2 As C)  
    Console.WriteLine("Shared method M4(c1 As C, c2 As C) on C:  c1.ID = {0}, c2.ID = {1}", _  
        c1.ID, c2.ID)  
End Sub  
End Class
Public Class F Public Sub M1(ByVal c As C)  
    Console.WriteLine("Instance method M1(c As C) on F:  c.ID = {0}", c.ID)  
End Sub  
Public Shared Sub M3(ByVal c As C)  
    Console.WriteLine("Shared method M3(c As C) on F:  c.ID = {0}", c.ID)  
End Sub  
Public Shared Sub M4(ByVal f As F, ByVal c As C)  
    Console.WriteLine("Shared method M4(f As F, c As C) on F:  c.ID = {0}", c.ID)  
End Sub  
End Class
Public Class Example5 Public Shared Sub Main()  
    Dim c1 As New C(42)  
    Dim c2 As New C(1491)  
    Dim f1 As New F()  
    Dim d As D  
    ' Instance method with one argument of type C.  
    Dim cmi1 As MethodInfo = GetType(C).GetMethod("M1")  
    ' Instance method with no arguments.  
    Dim cmi2 As MethodInfo = GetType(C).GetMethod("M2")  
    ' Shared method with one argument of type C.  
    Dim cmi3 As MethodInfo = GetType(C).GetMethod("M3")  
    ' Shared method with two arguments of type C.  
    Dim cmi4 As MethodInfo = GetType(C).GetMethod("M4")  
    ' Instance method with one argument of type C.  
    Dim fmi1 As MethodInfo = GetType(F).GetMethod("M1")  
    ' Shared method with one argument of type C.  
    Dim fmi3 As MethodInfo = GetType(F).GetMethod("M3")  
    ' Shared method with an argument of type F and an  
    ' argument of type C.  
    Dim fmi4 As MethodInfo = GetType(F).GetMethod("M4")  
    Console.WriteLine(vbLf & "An instance method on any type, with an argument of type C.")  
    ' D can represent any instance method that exactly matches its  
    ' signature. Methods on C and F are shown here.  
    '  
    d = CType([Delegate].CreateDelegate(GetType(D), c1, cmi1), D)  
    d(c2)  
    d = CType([Delegate].CreateDelegate(GetType(D), f1, fmi1), D)  
    d(c2)  
    Console.WriteLine(vbLf & "An instance method on C with no arguments.")  
    ' D can represent an instance method on C that has no arguments;  
    ' in this case, the argument of D represents the hidden first  
    ' argument of any instance method. The delegate acts like a  
    ' Shared method, and an instance of C must be passed each time  
    ' it is invoked.  
    '  
    d = CType([Delegate].CreateDelegate(GetType(D), Nothing, cmi2), D)  
    d(c1)  
    Console.WriteLine(vbLf & "A Shared method on any type, with an argument of type C.")  
    ' D can represent any Shared method with the same signature.  
    ' Methods on F and C are shown here.  
    '  
    d = CType([Delegate].CreateDelegate(GetType(D), Nothing, cmi3), D)  
    d(c1)  
    d = CType([Delegate].CreateDelegate(GetType(D), Nothing, fmi3), D)  
    d(c1)  
    Console.WriteLine(vbLf & "A Shared method on any type, with an argument of")  
    Console.WriteLine("    that type and an argument of type C.")  
    ' D can represent any Shared method with one argument of the  
    ' type the method belongs and a second argument of type C.  
    ' In this case, the method is closed over the instance of  
    ' supplied for the its first argument, and acts like an instance  
    ' method. Methods on F and C are shown here.  
    '  
    d = CType([Delegate].CreateDelegate(GetType(D), c1, cmi4), D)  
    d(c2)  
    Dim test As [Delegate] =  
        [Delegate].CreateDelegate(GetType(D), f1, fmi4, False)  
    ' This final example specifies False for throwOnBindFailure  
    ' in the call to CreateDelegate, so the variable 'test'  
    ' contains Nothing if the method fails to bind (for  
    ' example, if fmi4 happened to represent a method of  
    ' some class other than F).  
    '  
    If test IsNot Nothing Then  
        d = CType(test, D)  
        d(c2)  
    End If  
End Sub  
End Class
' This code example produces the following output:
'
'An instance method on any type, with an argument of type C.
'Instance method M1(c As C) on C: this.id = 42, c.ID = 1491
'Instance method M1(c As C) on F: c.ID = 1491
'
'An instance method on C with no arguments.
'Instance method M2() on C: this.id = 42
'
'A Shared method on any type, with an argument of type C.
'Shared method M3(c As C) on C: c.ID = 42
'Shared method M3(c As C) on F: c.ID = 42
'
'A Shared method on any type, with an argument of
' that type and an argument of type C.
'Shared method M4(c1 As C, c2 As C) on C: c1.ID = 42, c2.ID = 1491
'Shared method M4(f As F, c As C) on F: c.ID = 1491
'

6 of type

open System open System.Reflection
// A sample class with an instance method and a static method.
type C(id) = 
member _.M1(s) =  
    printfn $"Instance method M1 on C:  id = %i{id}, s = %s{s}"  
static member M2(s) =  
    printfn $"Static method M2 on C:  s = %s{s}"  
// Declare three delegate types for demonstrating the combinations
// of static versus instance methods and open versus closed
// delegates.
type D1 = delegate of C * string -> unit
type D2 = delegate of string -> unit
type D3 = delegate of unit -> unit
let c1 = C 42
// Get a MethodInfo for each method.
//
let mi1 = typeof.GetMethod("M1", BindingFlags.Public ||| BindingFlags.Instance)
let mi2 = typeof.GetMethod("M2", BindingFlags.Public ||| BindingFlags.Static)
printfn "\nAn instance method closed over C."
// In this case, the delegate and the
// method must have the same list of argument types use
// delegate type D2 with instance method M1.
let test = Delegate.CreateDelegate(typeof, c1, mi1, false)
// Because false was specified for throwOnBindFailure
// in the call to CreateDelegate, the variable 'test'
// contains null if the method fails to bind (for
// example, if mi1 happened to represent a method of
// some class other than C).
if test <> null then let d2 = test :?> D2  
// The same instance of C is used every time the  
// delegate is invoked.  
d2.Invoke "Hello, World!"  
d2.Invoke "Hi, Mom!"  
printfn "\nAn open instance method."
// In this case, the delegate has one more
// argument than the instance method this argument comes
// at the beginning, and represents the hidden instance
// argument of the instance method. Use delegate type D1
// with instance method M1.
let d1 = Delegate.CreateDelegate(typeof, null, mi1) :?> D1
// An instance of C must be passed in each time the
// delegate is invoked.
d1.Invoke(c1, "Hello, World!")
d1.Invoke(C 5280, "Hi, Mom!")
printfn "\nAn open static method."
// In this case, the delegate and the method must
// have the same list of argument types use delegate type
// D2 with static method M2.
let d2 = Delegate.CreateDelegate(typeof, null, mi2) :?> D2
// No instances of C are involved, because this is a static
// method.
d2.Invoke "Hello, World!"
d2.Invoke "Hi, Mom!"
printfn "\nA static method closed over the first argument (String)."
// The delegate must omit the first argument of the method.
// A string is passed as the firstArgument parameter, and
// the delegate is bound to this string. Use delegate type
// D3 with static method M2.
let d3 = Delegate.CreateDelegate(typeof, "Hello, World!", mi2) :?> D3
// Each time the delegate is invoked, the same string is used.
d3.Invoke()
// This code example produces the following output:
// An instance method closed over C.
// Instance method M1 on C: id = 42, s = Hello, World!
// Instance method M1 on C: id = 42, s = Hi, Mom!
//
// An open instance method.
// Instance method M1 on C: id = 42, s = Hello, World!
// Instance method M1 on C: id = 5280, s = Hi, Mom!
//
// An open static method.
// Static method M2 on C: s = Hello, World!
// Static method M2 on C: s = Hi, Mom!
//
// A static method closed over the first argument (String).
// Static method M2 on C: s = Hello, World!

1 and type

Imports System.Reflection Imports System.Security.Permissions
' Declare a delegate type. The object of this code example
' is to show all the methods this delegate can bind to.
'
Public Delegate Sub D(ByVal c As C)
' Declare two sample classes, C and F. Class C has an ID
' property so instances can be identified.
'
Public Class C 
Private id As Integer  
Public ReadOnly Property ID() As Integer  
    Get  
        Return _id  
    End Get  
End Property  
Public Sub New(ByVal newId As Integer)  
    Me._id = newId  
End Sub  
Public Sub M1(ByVal c As C)  
    Console.WriteLine("Instance method M1(c As C) on C:  this.id = {0}, c.ID = {1}",   
        Me.id, c.ID)  
End Sub  
Public Sub M2()  
    Console.WriteLine("Instance method M2() on C:  this.id = {0}", Me.id)  
End Sub  
Public Shared Sub M3(ByVal c As C)  
    Console.WriteLine("Shared method M3(c As C) on C:  c.ID = {0}", c.ID)  
End Sub  
Public Shared Sub M4(ByVal c1 As C, ByVal c2 As C)  
    Console.WriteLine("Shared method M4(c1 As C, c2 As C) on C:  c1.ID = {0}, c2.ID = {1}", _  
        c1.ID, c2.ID)  
End Sub  
End Class
Public Class F Public Sub M1(ByVal c As C)  
    Console.WriteLine("Instance method M1(c As C) on F:  c.ID = {0}", c.ID)  
End Sub  
Public Shared Sub M3(ByVal c As C)  
    Console.WriteLine("Shared method M3(c As C) on F:  c.ID = {0}", c.ID)  
End Sub  
Public Shared Sub M4(ByVal f As F, ByVal c As C)  
    Console.WriteLine("Shared method M4(f As F, c As C) on F:  c.ID = {0}", c.ID)  
End Sub  
End Class
Public Class Example5 Public Shared Sub Main()  
    Dim c1 As New C(42)  
    Dim c2 As New C(1491)  
    Dim f1 As New F()  
    Dim d As D  
    ' Instance method with one argument of type C.  
    Dim cmi1 As MethodInfo = GetType(C).GetMethod("M1")  
    ' Instance method with no arguments.  
    Dim cmi2 As MethodInfo = GetType(C).GetMethod("M2")  
    ' Shared method with one argument of type C.  
    Dim cmi3 As MethodInfo = GetType(C).GetMethod("M3")  
    ' Shared method with two arguments of type C.  
    Dim cmi4 As MethodInfo = GetType(C).GetMethod("M4")  
    ' Instance method with one argument of type C.  
    Dim fmi1 As MethodInfo = GetType(F).GetMethod("M1")  
    ' Shared method with one argument of type C.  
    Dim fmi3 As MethodInfo = GetType(F).GetMethod("M3")  
    ' Shared method with an argument of type F and an  
    ' argument of type C.  
    Dim fmi4 As MethodInfo = GetType(F).GetMethod("M4")  
    Console.WriteLine(vbLf & "An instance method on any type, with an argument of type C.")  
    ' D can represent any instance method that exactly matches its  
    ' signature. Methods on C and F are shown here.  
    '  
    d = CType([Delegate].CreateDelegate(GetType(D), c1, cmi1), D)  
    d(c2)  
    d = CType([Delegate].CreateDelegate(GetType(D), f1, fmi1), D)  
    d(c2)  
    Console.WriteLine(vbLf & "An instance method on C with no arguments.")  
    ' D can represent an instance method on C that has no arguments;  
    ' in this case, the argument of D represents the hidden first  
    ' argument of any instance method. The delegate acts like a  
    ' Shared method, and an instance of C must be passed each time  
    ' it is invoked.  
    '  
    d = CType([Delegate].CreateDelegate(GetType(D), Nothing, cmi2), D)  
    d(c1)  
    Console.WriteLine(vbLf & "A Shared method on any type, with an argument of type C.")  
    ' D can represent any Shared method with the same signature.  
    ' Methods on F and C are shown here.  
    '  
    d = CType([Delegate].CreateDelegate(GetType(D), Nothing, cmi3), D)  
    d(c1)  
    d = CType([Delegate].CreateDelegate(GetType(D), Nothing, fmi3), D)  
    d(c1)  
    Console.WriteLine(vbLf & "A Shared method on any type, with an argument of")  
    Console.WriteLine("    that type and an argument of type C.")  
    ' D can represent any Shared method with one argument of the  
    ' type the method belongs and a second argument of type C.  
    ' In this case, the method is closed over the instance of  
    ' supplied for the its first argument, and acts like an instance  
    ' method. Methods on F and C are shown here.  
    '  
    d = CType([Delegate].CreateDelegate(GetType(D), c1, cmi4), D)  
    d(c2)  
    Dim test As [Delegate] =  
        [Delegate].CreateDelegate(GetType(D), f1, fmi4, False)  
    ' This final example specifies False for throwOnBindFailure  
    ' in the call to CreateDelegate, so the variable 'test'  
    ' contains Nothing if the method fails to bind (for  
    ' example, if fmi4 happened to represent a method of  
    ' some class other than F).  
    '  
    If test IsNot Nothing Then  
        d = CType(test, D)  
        d(c2)  
    End If  
End Sub  
End Class
' This code example produces the following output:
'
'An instance method on any type, with an argument of type C.
'Instance method M1(c As C) on C: this.id = 42, c.ID = 1491
'Instance method M1(c As C) on F: c.ID = 1491
'
'An instance method on C with no arguments.
'Instance method M2() on C: this.id = 42
'
'A Shared method on any type, with an argument of type C.
'Shared method M3(c As C) on C: c.ID = 42
'Shared method M3(c As C) on F: c.ID = 42
'
'A Shared method on any type, with an argument of
' that type and an argument of type C.
'Shared method M4(c1 As C, c2 As C) on C: c1.ID = 42, c2.ID = 1491
'Shared method M4(f As F, c As C) on F: c.ID = 1491
'

2; these are open static delegates.

Finally, delegates are created for static method

Imports System.Reflection Imports System.Security.Permissions
' Declare a delegate type. The object of this code example
' is to show all the methods this delegate can bind to.
'
Public Delegate Sub D(ByVal c As C)
' Declare two sample classes, C and F. Class C has an ID
' property so instances can be identified.
'
Public Class C 
Private id As Integer  
Public ReadOnly Property ID() As Integer  
    Get  
        Return _id  
    End Get  
End Property  
Public Sub New(ByVal newId As Integer)  
    Me._id = newId  
End Sub  
Public Sub M1(ByVal c As C)  
    Console.WriteLine("Instance method M1(c As C) on C:  this.id = {0}, c.ID = {1}",   
        Me.id, c.ID)  
End Sub  
Public Sub M2()  
    Console.WriteLine("Instance method M2() on C:  this.id = {0}", Me.id)  
End Sub  
Public Shared Sub M3(ByVal c As C)  
    Console.WriteLine("Shared method M3(c As C) on C:  c.ID = {0}", c.ID)  
End Sub  
Public Shared Sub M4(ByVal c1 As C, ByVal c2 As C)  
    Console.WriteLine("Shared method M4(c1 As C, c2 As C) on C:  c1.ID = {0}, c2.ID = {1}", _  
        c1.ID, c2.ID)  
End Sub  
End Class
Public Class F Public Sub M1(ByVal c As C)  
    Console.WriteLine("Instance method M1(c As C) on F:  c.ID = {0}", c.ID)  
End Sub  
Public Shared Sub M3(ByVal c As C)  
    Console.WriteLine("Shared method M3(c As C) on F:  c.ID = {0}", c.ID)  
End Sub  
Public Shared Sub M4(ByVal f As F, ByVal c As C)  
    Console.WriteLine("Shared method M4(f As F, c As C) on F:  c.ID = {0}", c.ID)  
End Sub  
End Class
Public Class Example5 Public Shared Sub Main()  
    Dim c1 As New C(42)  
    Dim c2 As New C(1491)  
    Dim f1 As New F()  
    Dim d As D  
    ' Instance method with one argument of type C.  
    Dim cmi1 As MethodInfo = GetType(C).GetMethod("M1")  
    ' Instance method with no arguments.  
    Dim cmi2 As MethodInfo = GetType(C).GetMethod("M2")  
    ' Shared method with one argument of type C.  
    Dim cmi3 As MethodInfo = GetType(C).GetMethod("M3")  
    ' Shared method with two arguments of type C.  
    Dim cmi4 As MethodInfo = GetType(C).GetMethod("M4")  
    ' Instance method with one argument of type C.  
    Dim fmi1 As MethodInfo = GetType(F).GetMethod("M1")  
    ' Shared method with one argument of type C.  
    Dim fmi3 As MethodInfo = GetType(F).GetMethod("M3")  
    ' Shared method with an argument of type F and an  
    ' argument of type C.  
    Dim fmi4 As MethodInfo = GetType(F).GetMethod("M4")  
    Console.WriteLine(vbLf & "An instance method on any type, with an argument of type C.")  
    ' D can represent any instance method that exactly matches its  
    ' signature. Methods on C and F are shown here.  
    '  
    d = CType([Delegate].CreateDelegate(GetType(D), c1, cmi1), D)  
    d(c2)  
    d = CType([Delegate].CreateDelegate(GetType(D), f1, fmi1), D)  
    d(c2)  
    Console.WriteLine(vbLf & "An instance method on C with no arguments.")  
    ' D can represent an instance method on C that has no arguments;  
    ' in this case, the argument of D represents the hidden first  
    ' argument of any instance method. The delegate acts like a  
    ' Shared method, and an instance of C must be passed each time  
    ' it is invoked.  
    '  
    d = CType([Delegate].CreateDelegate(GetType(D), Nothing, cmi2), D)  
    d(c1)  
    Console.WriteLine(vbLf & "A Shared method on any type, with an argument of type C.")  
    ' D can represent any Shared method with the same signature.  
    ' Methods on F and C are shown here.  
    '  
    d = CType([Delegate].CreateDelegate(GetType(D), Nothing, cmi3), D)  
    d(c1)  
    d = CType([Delegate].CreateDelegate(GetType(D), Nothing, fmi3), D)  
    d(c1)  
    Console.WriteLine(vbLf & "A Shared method on any type, with an argument of")  
    Console.WriteLine("    that type and an argument of type C.")  
    ' D can represent any Shared method with one argument of the  
    ' type the method belongs and a second argument of type C.  
    ' In this case, the method is closed over the instance of  
    ' supplied for the its first argument, and acts like an instance  
    ' method. Methods on F and C are shown here.  
    '  
    d = CType([Delegate].CreateDelegate(GetType(D), c1, cmi4), D)  
    d(c2)  
    Dim test As [Delegate] =  
        [Delegate].CreateDelegate(GetType(D), f1, fmi4, False)  
    ' This final example specifies False for throwOnBindFailure  
    ' in the call to CreateDelegate, so the variable 'test'  
    ' contains Nothing if the method fails to bind (for  
    ' example, if fmi4 happened to represent a method of  
    ' some class other than F).  
    '  
    If test IsNot Nothing Then  
        d = CType(test, D)  
        d(c2)  
    End If  
End Sub  
End Class
' This code example produces the following output:
'
'An instance method on any type, with an argument of type C.
'Instance method M1(c As C) on C: this.id = 42, c.ID = 1491
'Instance method M1(c As C) on F: c.ID = 1491
'
'An instance method on C with no arguments.
'Instance method M2() on C: this.id = 42
'
'A Shared method on any type, with an argument of type C.
'Shared method M3(c As C) on C: c.ID = 42
'Shared method M3(c As C) on F: c.ID = 42
'
'A Shared method on any type, with an argument of
' that type and an argument of type C.
'Shared method M4(c1 As C, c2 As C) on C: c1.ID = 42, c2.ID = 1491
'Shared method M4(f As F, c As C) on F: c.ID = 1491
'

7 of type

open System open System.Reflection
// A sample class with an instance method and a static method.
type C(id) = 
member _.M1(s) =  
    printfn $"Instance method M1 on C:  id = %i{id}, s = %s{s}"  
static member M2(s) =  
    printfn $"Static method M2 on C:  s = %s{s}"  
// Declare three delegate types for demonstrating the combinations
// of static versus instance methods and open versus closed
// delegates.
type D1 = delegate of C * string -> unit
type D2 = delegate of string -> unit
type D3 = delegate of unit -> unit
let c1 = C 42
// Get a MethodInfo for each method.
//
let mi1 = typeof.GetMethod("M1", BindingFlags.Public ||| BindingFlags.Instance)
let mi2 = typeof.GetMethod("M2", BindingFlags.Public ||| BindingFlags.Static)
printfn "\nAn instance method closed over C."
// In this case, the delegate and the
// method must have the same list of argument types use
// delegate type D2 with instance method M1.
let test = Delegate.CreateDelegate(typeof, c1, mi1, false)
// Because false was specified for throwOnBindFailure
// in the call to CreateDelegate, the variable 'test'
// contains null if the method fails to bind (for
// example, if mi1 happened to represent a method of
// some class other than C).
if test <> null then let d2 = test :?> D2  
// The same instance of C is used every time the  
// delegate is invoked.  
d2.Invoke "Hello, World!"  
d2.Invoke "Hi, Mom!"  
printfn "\nAn open instance method."
// In this case, the delegate has one more
// argument than the instance method this argument comes
// at the beginning, and represents the hidden instance
// argument of the instance method. Use delegate type D1
// with instance method M1.
let d1 = Delegate.CreateDelegate(typeof, null, mi1) :?> D1
// An instance of C must be passed in each time the
// delegate is invoked.
d1.Invoke(c1, "Hello, World!")
d1.Invoke(C 5280, "Hi, Mom!")
printfn "\nAn open static method."
// In this case, the delegate and the method must
// have the same list of argument types use delegate type
// D2 with static method M2.
let d2 = Delegate.CreateDelegate(typeof, null, mi2) :?> D2
// No instances of C are involved, because this is a static
// method.
d2.Invoke "Hello, World!"
d2.Invoke "Hi, Mom!"
printfn "\nA static method closed over the first argument (String)."
// The delegate must omit the first argument of the method.
// A string is passed as the firstArgument parameter, and
// the delegate is bound to this string. Use delegate type
// D3 with static method M2.
let d3 = Delegate.CreateDelegate(typeof, "Hello, World!", mi2) :?> D3
// Each time the delegate is invoked, the same string is used.
d3.Invoke()
// This code example produces the following output:
// An instance method closed over C.
// Instance method M1 on C: id = 42, s = Hello, World!
// Instance method M1 on C: id = 42, s = Hi, Mom!
//
// An open instance method.
// Instance method M1 on C: id = 42, s = Hello, World!
// Instance method M1 on C: id = 5280, s = Hi, Mom!
//
// An open static method.
// Static method M2 on C: s = Hello, World!
// Static method M2 on C: s = Hi, Mom!
//
// A static method closed over the first argument (String).
// Static method M2 on C: s = Hello, World!

1 and type

Imports System.Reflection Imports System.Security.Permissions
' Declare a delegate type. The object of this code example
' is to show all the methods this delegate can bind to.
'
Public Delegate Sub D(ByVal c As C)
' Declare two sample classes, C and F. Class C has an ID
' property so instances can be identified.
'
Public Class C 
Private id As Integer  
Public ReadOnly Property ID() As Integer  
    Get  
        Return _id  
    End Get  
End Property  
Public Sub New(ByVal newId As Integer)  
    Me._id = newId  
End Sub  
Public Sub M1(ByVal c As C)  
    Console.WriteLine("Instance method M1(c As C) on C:  this.id = {0}, c.ID = {1}",   
        Me.id, c.ID)  
End Sub  
Public Sub M2()  
    Console.WriteLine("Instance method M2() on C:  this.id = {0}", Me.id)  
End Sub  
Public Shared Sub M3(ByVal c As C)  
    Console.WriteLine("Shared method M3(c As C) on C:  c.ID = {0}", c.ID)  
End Sub  
Public Shared Sub M4(ByVal c1 As C, ByVal c2 As C)  
    Console.WriteLine("Shared method M4(c1 As C, c2 As C) on C:  c1.ID = {0}, c2.ID = {1}", _  
        c1.ID, c2.ID)  
End Sub  
End Class
Public Class F Public Sub M1(ByVal c As C)  
    Console.WriteLine("Instance method M1(c As C) on F:  c.ID = {0}", c.ID)  
End Sub  
Public Shared Sub M3(ByVal c As C)  
    Console.WriteLine("Shared method M3(c As C) on F:  c.ID = {0}", c.ID)  
End Sub  
Public Shared Sub M4(ByVal f As F, ByVal c As C)  
    Console.WriteLine("Shared method M4(f As F, c As C) on F:  c.ID = {0}", c.ID)  
End Sub  
End Class
Public Class Example5 Public Shared Sub Main()  
    Dim c1 As New C(42)  
    Dim c2 As New C(1491)  
    Dim f1 As New F()  
    Dim d As D  
    ' Instance method with one argument of type C.  
    Dim cmi1 As MethodInfo = GetType(C).GetMethod("M1")  
    ' Instance method with no arguments.  
    Dim cmi2 As MethodInfo = GetType(C).GetMethod("M2")  
    ' Shared method with one argument of type C.  
    Dim cmi3 As MethodInfo = GetType(C).GetMethod("M3")  
    ' Shared method with two arguments of type C.  
    Dim cmi4 As MethodInfo = GetType(C).GetMethod("M4")  
    ' Instance method with one argument of type C.  
    Dim fmi1 As MethodInfo = GetType(F).GetMethod("M1")  
    ' Shared method with one argument of type C.  
    Dim fmi3 As MethodInfo = GetType(F).GetMethod("M3")  
    ' Shared method with an argument of type F and an  
    ' argument of type C.  
    Dim fmi4 As MethodInfo = GetType(F).GetMethod("M4")  
    Console.WriteLine(vbLf & "An instance method on any type, with an argument of type C.")  
    ' D can represent any instance method that exactly matches its  
    ' signature. Methods on C and F are shown here.  
    '  
    d = CType([Delegate].CreateDelegate(GetType(D), c1, cmi1), D)  
    d(c2)  
    d = CType([Delegate].CreateDelegate(GetType(D), f1, fmi1), D)  
    d(c2)  
    Console.WriteLine(vbLf & "An instance method on C with no arguments.")  
    ' D can represent an instance method on C that has no arguments;  
    ' in this case, the argument of D represents the hidden first  
    ' argument of any instance method. The delegate acts like a  
    ' Shared method, and an instance of C must be passed each time  
    ' it is invoked.  
    '  
    d = CType([Delegate].CreateDelegate(GetType(D), Nothing, cmi2), D)  
    d(c1)  
    Console.WriteLine(vbLf & "A Shared method on any type, with an argument of type C.")  
    ' D can represent any Shared method with the same signature.  
    ' Methods on F and C are shown here.  
    '  
    d = CType([Delegate].CreateDelegate(GetType(D), Nothing, cmi3), D)  
    d(c1)  
    d = CType([Delegate].CreateDelegate(GetType(D), Nothing, fmi3), D)  
    d(c1)  
    Console.WriteLine(vbLf & "A Shared method on any type, with an argument of")  
    Console.WriteLine("    that type and an argument of type C.")  
    ' D can represent any Shared method with one argument of the  
    ' type the method belongs and a second argument of type C.  
    ' In this case, the method is closed over the instance of  
    ' supplied for the its first argument, and acts like an instance  
    ' method. Methods on F and C are shown here.  
    '  
    d = CType([Delegate].CreateDelegate(GetType(D), c1, cmi4), D)  
    d(c2)  
    Dim test As [Delegate] =  
        [Delegate].CreateDelegate(GetType(D), f1, fmi4, False)  
    ' This final example specifies False for throwOnBindFailure  
    ' in the call to CreateDelegate, so the variable 'test'  
    ' contains Nothing if the method fails to bind (for  
    ' example, if fmi4 happened to represent a method of  
    ' some class other than F).  
    '  
    If test IsNot Nothing Then  
        d = CType(test, D)  
        d(c2)  
    End If  
End Sub  
End Class
' This code example produces the following output:
'
'An instance method on any type, with an argument of type C.
'Instance method M1(c As C) on C: this.id = 42, c.ID = 1491
'Instance method M1(c As C) on F: c.ID = 1491
'
'An instance method on C with no arguments.
'Instance method M2() on C: this.id = 42
'
'A Shared method on any type, with an argument of type C.
'Shared method M3(c As C) on C: c.ID = 42
'Shared method M3(c As C) on F: c.ID = 42
'
'A Shared method on any type, with an argument of
' that type and an argument of type C.
'Shared method M4(c1 As C, c2 As C) on C: c1.ID = 42, c2.ID = 1491
'Shared method M4(f As F, c As C) on F: c.ID = 1491
'

2; each method has the declaring type as its first argument, and an instance of the type is supplied, so the delegates are closed over their first arguments. Method

Imports System.Reflection Imports System.Security.Permissions
' Declare a delegate type. The object of this code example
' is to show all the methods this delegate can bind to.
'
Public Delegate Sub D(ByVal c As C)
' Declare two sample classes, C and F. Class C has an ID
' property so instances can be identified.
'
Public Class C 
Private id As Integer  
Public ReadOnly Property ID() As Integer  
    Get  
        Return _id  
    End Get  
End Property  
Public Sub New(ByVal newId As Integer)  
    Me._id = newId  
End Sub  
Public Sub M1(ByVal c As C)  
    Console.WriteLine("Instance method M1(c As C) on C:  this.id = {0}, c.ID = {1}",   
        Me.id, c.ID)  
End Sub  
Public Sub M2()  
    Console.WriteLine("Instance method M2() on C:  this.id = {0}", Me.id)  
End Sub  
Public Shared Sub M3(ByVal c As C)  
    Console.WriteLine("Shared method M3(c As C) on C:  c.ID = {0}", c.ID)  
End Sub  
Public Shared Sub M4(ByVal c1 As C, ByVal c2 As C)  
    Console.WriteLine("Shared method M4(c1 As C, c2 As C) on C:  c1.ID = {0}, c2.ID = {1}", _  
        c1.ID, c2.ID)  
End Sub  
End Class
Public Class F Public Sub M1(ByVal c As C)  
    Console.WriteLine("Instance method M1(c As C) on F:  c.ID = {0}", c.ID)  
End Sub  
Public Shared Sub M3(ByVal c As C)  
    Console.WriteLine("Shared method M3(c As C) on F:  c.ID = {0}", c.ID)  
End Sub  
Public Shared Sub M4(ByVal f As F, ByVal c As C)  
    Console.WriteLine("Shared method M4(f As F, c As C) on F:  c.ID = {0}", c.ID)  
End Sub  
End Class
Public Class Example5 Public Shared Sub Main()  
    Dim c1 As New C(42)  
    Dim c2 As New C(1491)  
    Dim f1 As New F()  
    Dim d As D  
    ' Instance method with one argument of type C.  
    Dim cmi1 As MethodInfo = GetType(C).GetMethod("M1")  
    ' Instance method with no arguments.  
    Dim cmi2 As MethodInfo = GetType(C).GetMethod("M2")  
    ' Shared method with one argument of type C.  
    Dim cmi3 As MethodInfo = GetType(C).GetMethod("M3")  
    ' Shared method with two arguments of type C.  
    Dim cmi4 As MethodInfo = GetType(C).GetMethod("M4")  
    ' Instance method with one argument of type C.  
    Dim fmi1 As MethodInfo = GetType(F).GetMethod("M1")  
    ' Shared method with one argument of type C.  
    Dim fmi3 As MethodInfo = GetType(F).GetMethod("M3")  
    ' Shared method with an argument of type F and an  
    ' argument of type C.  
    Dim fmi4 As MethodInfo = GetType(F).GetMethod("M4")  
    Console.WriteLine(vbLf & "An instance method on any type, with an argument of type C.")  
    ' D can represent any instance method that exactly matches its  
    ' signature. Methods on C and F are shown here.  
    '  
    d = CType([Delegate].CreateDelegate(GetType(D), c1, cmi1), D)  
    d(c2)  
    d = CType([Delegate].CreateDelegate(GetType(D), f1, fmi1), D)  
    d(c2)  
    Console.WriteLine(vbLf & "An instance method on C with no arguments.")  
    ' D can represent an instance method on C that has no arguments;  
    ' in this case, the argument of D represents the hidden first  
    ' argument of any instance method. The delegate acts like a  
    ' Shared method, and an instance of C must be passed each time  
    ' it is invoked.  
    '  
    d = CType([Delegate].CreateDelegate(GetType(D), Nothing, cmi2), D)  
    d(c1)  
    Console.WriteLine(vbLf & "A Shared method on any type, with an argument of type C.")  
    ' D can represent any Shared method with the same signature.  
    ' Methods on F and C are shown here.  
    '  
    d = CType([Delegate].CreateDelegate(GetType(D), Nothing, cmi3), D)  
    d(c1)  
    d = CType([Delegate].CreateDelegate(GetType(D), Nothing, fmi3), D)  
    d(c1)  
    Console.WriteLine(vbLf & "A Shared method on any type, with an argument of")  
    Console.WriteLine("    that type and an argument of type C.")  
    ' D can represent any Shared method with one argument of the  
    ' type the method belongs and a second argument of type C.  
    ' In this case, the method is closed over the instance of  
    ' supplied for the its first argument, and acts like an instance  
    ' method. Methods on F and C are shown here.  
    '  
    d = CType([Delegate].CreateDelegate(GetType(D), c1, cmi4), D)  
    d(c2)  
    Dim test As [Delegate] =  
        [Delegate].CreateDelegate(GetType(D), f1, fmi4, False)  
    ' This final example specifies False for throwOnBindFailure  
    ' in the call to CreateDelegate, so the variable 'test'  
    ' contains Nothing if the method fails to bind (for  
    ' example, if fmi4 happened to represent a method of  
    ' some class other than F).  
    '  
    If test IsNot Nothing Then  
        d = CType(test, D)  
        d(c2)  
    End If  
End Sub  
End Class
' This code example produces the following output:
'
'An instance method on any type, with an argument of type C.
'Instance method M1(c As C) on C: this.id = 42, c.ID = 1491
'Instance method M1(c As C) on F: c.ID = 1491
'
'An instance method on C with no arguments.
'Instance method M2() on C: this.id = 42
'
'A Shared method on any type, with an argument of type C.
'Shared method M3(c As C) on C: c.ID = 42
'Shared method M3(c As C) on F: c.ID = 42
'
'A Shared method on any type, with an argument of
' that type and an argument of type C.
'Shared method M4(c1 As C, c2 As C) on C: c1.ID = 42, c2.ID = 1491
'Shared method M4(f As F, c As C) on F: c.ID = 1491
'

7 of type

open System open System.Reflection
// A sample class with an instance method and a static method.
type C(id) = 
member _.M1(s) =  
    printfn $"Instance method M1 on C:  id = %i{id}, s = %s{s}"  
static member M2(s) =  
    printfn $"Static method M2 on C:  s = %s{s}"  
// Declare three delegate types for demonstrating the combinations
// of static versus instance methods and open versus closed
// delegates.
type D1 = delegate of C * string -> unit
type D2 = delegate of string -> unit
type D3 = delegate of unit -> unit
let c1 = C 42
// Get a MethodInfo for each method.
//
let mi1 = typeof.GetMethod("M1", BindingFlags.Public ||| BindingFlags.Instance)
let mi2 = typeof.GetMethod("M2", BindingFlags.Public ||| BindingFlags.Static)
printfn "\nAn instance method closed over C."
// In this case, the delegate and the
// method must have the same list of argument types use
// delegate type D2 with instance method M1.
let test = Delegate.CreateDelegate(typeof, c1, mi1, false)
// Because false was specified for throwOnBindFailure
// in the call to CreateDelegate, the variable 'test'
// contains null if the method fails to bind (for
// example, if mi1 happened to represent a method of
// some class other than C).
if test <> null then let d2 = test :?> D2  
// The same instance of C is used every time the  
// delegate is invoked.  
d2.Invoke "Hello, World!"  
d2.Invoke "Hi, Mom!"  
printfn "\nAn open instance method."
// In this case, the delegate has one more
// argument than the instance method this argument comes
// at the beginning, and represents the hidden instance
// argument of the instance method. Use delegate type D1
// with instance method M1.
let d1 = Delegate.CreateDelegate(typeof, null, mi1) :?> D1
// An instance of C must be passed in each time the
// delegate is invoked.
d1.Invoke(c1, "Hello, World!")
d1.Invoke(C 5280, "Hi, Mom!")
printfn "\nAn open static method."
// In this case, the delegate and the method must
// have the same list of argument types use delegate type
// D2 with static method M2.
let d2 = Delegate.CreateDelegate(typeof, null, mi2) :?> D2
// No instances of C are involved, because this is a static
// method.
d2.Invoke "Hello, World!"
d2.Invoke "Hi, Mom!"
printfn "\nA static method closed over the first argument (String)."
// The delegate must omit the first argument of the method.
// A string is passed as the firstArgument parameter, and
// the delegate is bound to this string. Use delegate type
// D3 with static method M2.
let d3 = Delegate.CreateDelegate(typeof, "Hello, World!", mi2) :?> D3
// Each time the delegate is invoked, the same string is used.
d3.Invoke()
// This code example produces the following output:
// An instance method closed over C.
// Instance method M1 on C: id = 42, s = Hello, World!
// Instance method M1 on C: id = 42, s = Hi, Mom!
//
// An open instance method.
// Instance method M1 on C: id = 42, s = Hello, World!
// Instance method M1 on C: id = 5280, s = Hi, Mom!
//
// An open static method.
// Static method M2 on C: s = Hello, World!
// Static method M2 on C: s = Hi, Mom!
//
// A static method closed over the first argument (String).
// Static method M2 on C: s = Hello, World!

1 displays the `true`6 properties of the bound instance and of the argument.

using System; using System.Reflection; // Declare a delegate type. The object of this code example // is to show all the methods this delegate can bind to. // public delegate void D(C1 c); // Declare two sample classes, C1 and F. Class C1 has an ID // property so instances can be identified. // public class C1 {

private int id;
public int ID { get { return id; } }
public C1(int id) { this.id = id; }
public void M1(C1 c)
{
    Console.WriteLine("Instance method M1(C1 c) on C1:  this.id = {0}, c.ID = {1}",
        this.id, c.ID);
}
public void M2()
{
    Console.WriteLine("Instance method M2() on C1:  this.id = {0}",
        this.id);
}
public static void M3(C1 c)
{
    Console.WriteLine("Static method M3(C1 c) on C1:  c.ID = {0}", c.ID);
}
public static void M4(C1 c1, C1 c2)
{
    Console.WriteLine("Static method M4(C1 c1, C1 c2) on C1:  c1.ID = {0}, c2.ID = {1}",
        c1.ID, c2.ID);
}

}
public class F
{public void M1(C1 c)
{
    Console.WriteLine("Instance method M1(C1 c) on F:  c.ID = {0}",
        c.ID);
}
public static void M3(C1 c)
{
    Console.WriteLine("Static method M3(C1 c) on F:  c.ID = {0}", c.ID);
}
public static void M4(F f, C1 c)
{
    Console.WriteLine("Static method M4(F f, C1 c) on F:  c.ID = {0}",
        c.ID);
}
}
public class Example
{public static void Main()
{
    C1 c1 = new C1(42);
    C1 c2 = new C1(1491);
    F f1 = new F();
    D d;
    // Instance method with one argument of type C1.
    MethodInfo cmi1 = typeof(C1).GetMethod("M1");
    // Instance method with no arguments.
    MethodInfo cmi2 = typeof(C1).GetMethod("M2");
    // Static method with one argument of type C1.
    MethodInfo cmi3 = typeof(C1).GetMethod("M3");
    // Static method with two arguments of type C1.
    MethodInfo cmi4 = typeof(C1).GetMethod("M4");
    // Instance method with one argument of type C1.
    MethodInfo fmi1 = typeof(F).GetMethod("M1");
    // Static method with one argument of type C1.
    MethodInfo fmi3 = typeof(F).GetMethod("M3");
    // Static method with an argument of type F and an argument
    // of type C1.
    MethodInfo fmi4 = typeof(F).GetMethod("M4");
    Console.WriteLine("\nAn instance method on any type, with an argument of type C1.");
    // D can represent any instance method that exactly matches its
    // signature. Methods on C1 and F are shown here.
    //
    d = (D)Delegate.CreateDelegate(typeof(D), c1, cmi1);
    d(c2);
    d = (D)Delegate.CreateDelegate(typeof(D), f1, fmi1);
    d(c2);
    Console.WriteLine("\nAn instance method on C1 with no arguments.");
    // D can represent an instance method on C1 that has no arguments;
    // in this case, the argument of D represents the hidden first
    // argument of any instance method. The delegate acts like a
    // static method, and an instance of C1 must be passed each time
    // it is invoked.
    //
    d = (D)Delegate.CreateDelegate(typeof(D), null, cmi2);
    d(c1);
    Console.WriteLine("\nA static method on any type, with an argument of type C1.");
    // D can represent any static method with the same signature.
    // Methods on F and C1 are shown here.
    //
    d = (D)Delegate.CreateDelegate(typeof(D), null, cmi3);
    d(c1);
    d = (D)Delegate.CreateDelegate(typeof(D), null, fmi3);
    d(c1);
    Console.WriteLine("\nA static method on any type, with an argument of");
    Console.WriteLine("    that type and an argument of type C1.");
    // D can represent any static method with one argument of the
    // type the method belongs and a second argument of type C1.
    // In this case, the method is closed over the instance of
    // supplied for the its first argument, and acts like an instance
    // method. Methods on F and C1 are shown here.
    //
    d = (D)Delegate.CreateDelegate(typeof(D), c1, cmi4);
    d(c2);
    Delegate test =
        Delegate.CreateDelegate(typeof(D), f1, fmi4, false);
    // This final example specifies false for throwOnBindFailure
    // in the call to CreateDelegate, so the variable 'test'
    // contains Nothing if the method fails to bind (for
    // example, if fmi4 happened to represent a method of
    // some class other than F).
    //
    if (test != null)
    {
        d = (D)test;
        d(c2);
    }
}
}
/ This code example produces the following output:
An instance method on any type, with an argument of type C1.
Instance method M1(C1 c) on C1: this.id = 42, c.ID = 1491
Instance method M1(C1 c) on F: c.ID = 1491
An instance method on C1 with no arguments.
Instance method M2() on C1: this.id = 42
A static method on any type, with an argument of type C1.
Static method M3(C1 c) on C1: c.ID = 42
Static method M3(C1 c) on F: c.ID = 42
A static method on any type, with an argument ofthat type and an argument of type C1.
Static method M4(C1 c1, C1 c2) on C1: c1.ID = 42, c2.ID = 1491
Static method M4(F f, C1 c) on F: c.ID = 1491
/

open System // Declare two sample classes, C and F. Class C has an ID // property so instances can be identified. type C(id) =

member _.ID = id 
member _.M1(c: C) =
    printfn $"Instance method M1(C c) on C:  this.id = {id}, c.ID = {c.ID}"
member _.M2() =
    printfn $"Instance method M2() on C:  this.id = {id}"
static member M3(c: C) =
    printfn $"Static method M3(C c) on C:  c.ID = {c.ID}"
static member M4(c1: C, c2: C) =
    printfn $"Static method M4(C c1, C c2) on C:  c1.ID = {c1.ID}, c2.ID = {c2.ID}"

// Declare a delegate type. The object of this code example
// is to show all the methods this delegate can bind to.
type D = delegate of C -> unit
type F() =member _.M1(c: C) =
    printfn $"Instance method M1(C c) on F:  c.ID = {c.ID}"
member _.M3(c: C) =
    printfn $"Static method M3(C c) on F:  c.ID = {c.ID}"
member _.M4(f: F, c: C) =
    printfn $"Static method M4(F f, C c) on F:  c.ID = {c.ID}"
[]
let main _ =let c1 = C 42
let c2 = C 1491
let f1 = F()
// Instance method with one argument of type C.
let cmi1 = typeof.GetMethod "M1"
// Instance method with no arguments.
let cmi2 = typeof.GetMethod "M2"
// Static method with one argument of type C.
let cmi3 = typeof.GetMethod "M3"
// Static method with two arguments of type C.
let cmi4 = typeof.GetMethod "M4"
// Instance method with one argument of type C.
let fmi1 = typeof.GetMethod "M1"
// Static method with one argument of type C.
let fmi3 = typeof.GetMethod "M3"
// Static method with an argument of type F and an argument
// of type C.
let fmi4 = typeof.GetMethod "M4"
printfn "\nAn instance method on any type, with an argument of type C."
// D can represent any instance method that exactly matches its
// signature. Methods on C and F are shown here.
let d = Delegate.CreateDelegate(typeof, c1, cmi1) :?> D
d.Invoke c2
let d =  Delegate.CreateDelegate(typeof, f1, fmi1) :?> D
d.Invoke c2
Console.WriteLine("\nAn instance method on C with no arguments.")
// D can represent an instance method on C that has no arguments
// in this case, the argument of D represents the hidden first
// argument of any instance method. The delegate acts like a
// static method, and an instance of C must be passed each time
// it is invoked.
let d = Delegate.CreateDelegate(typeof, null, cmi2) :?> D
d.Invoke c1
printfn "\nA static method on any type, with an argument of type C."
// D can represent any static method with the same signature.
// Methods on F and C are shown here.
let d = Delegate.CreateDelegate(typeof, null, cmi3) :?> D
d.Invoke c1
let d = Delegate.CreateDelegate(typeof, null, fmi3) :?> D
d.Invoke c1
printfn "\nA static method on any type, with an argument of"
printfn "    that type and an argument of type C."
// D can represent any static method with one argument of the
// type the method belongs and a second argument of type C.
// In this case, the method is closed over the instance of
// supplied for the its first argument, and acts like an instance
// method. Methods on F and C are shown here.
let d = Delegate.CreateDelegate(typeof, c1, cmi4) :?> D
d.Invoke c2
let test =
    Delegate.CreateDelegate(typeof, f1, fmi4, false)
// This final example specifies false for throwOnBindFailure
// in the call to CreateDelegate, so the variable 'test'
// contains Nothing if the method fails to bind (for
// example, if fmi4 happened to represent a method of
// some class other than F).
match test with
| :? D as d ->
    d.Invoke c2
| _ -> ()
0
// This code example produces the following output:
// An instance method on any type, with an argument of type C.
// Instance method M1(C c) on C: this.id = 42, c.ID = 1491
// Instance method M1(C c) on F: c.ID = 1491
//
// An instance method on C with no arguments.
// Instance method M2() on C: this.id = 42
//
// A static method on any type, with an argument of type C.
// Static method M3(C c) on C: c.ID = 42
// Static method M3(C c) on F: c.ID = 42
//
// A static method on any type, with an argument of
// that type and an argument of type C.
// Static method M4(C c1, C c2) on C: c1.ID = 42, c2.ID = 1491
// Static method M4(F f, C c) on F: c.ID = 1491

Imports System.Reflection Imports System.Security.Permissions ' Declare a delegate type. The object of this code example ' is to show all the methods this delegate can bind to. ' Public Delegate Sub D(ByVal c As C) ' Declare two sample classes, C and F. Class C has an ID ' property so instances can be identified. ' Public Class C

Private _id As Integer
Public ReadOnly Property ID() As Integer 
    Get
        Return _id
    End Get
End Property
Public Sub New(ByVal newId As Integer) 
    Me._id = newId
End Sub
Public Sub M1(ByVal c As C) 
    Console.WriteLine("Instance method M1(c As C) on C:  this.id = {0}, c.ID = {1}", _
        Me.id, c.ID)
End Sub
Public Sub M2() 
    Console.WriteLine("Instance method M2() on C:  this.id = {0}", Me.id)
End Sub
Public Shared Sub M3(ByVal c As C) 
    Console.WriteLine("Shared method M3(c As C) on C:  c.ID = {0}", c.ID)
End Sub
Public Shared Sub M4(ByVal c1 As C, ByVal c2 As C) 
    Console.WriteLine("Shared method M4(c1 As C, c2 As C) on C:  c1.ID = {0}, c2.ID = {1}", _
        c1.ID, c2.ID)
End Sub

End Class
Public Class FPublic Sub M1(ByVal c As C) 
    Console.WriteLine("Instance method M1(c As C) on F:  c.ID = {0}", c.ID)
End Sub
Public Shared Sub M3(ByVal c As C) 
    Console.WriteLine("Shared method M3(c As C) on F:  c.ID = {0}", c.ID)
End Sub
Public Shared Sub M4(ByVal f As F, ByVal c As C) 
    Console.WriteLine("Shared method M4(f As F, c As C) on F:  c.ID = {0}", c.ID)
End Sub
End Class
Public Class Example5Public Shared Sub Main()
    Dim c1 As New C(42)
    Dim c2 As New C(1491)
    Dim f1 As New F()
    Dim d As D
    ' Instance method with one argument of type C.
    Dim cmi1 As MethodInfo = GetType(C).GetMethod("M1")
    ' Instance method with no arguments.
    Dim cmi2 As MethodInfo = GetType(C).GetMethod("M2")
    ' Shared method with one argument of type C.
    Dim cmi3 As MethodInfo = GetType(C).GetMethod("M3")
    ' Shared method with two arguments of type C.
    Dim cmi4 As MethodInfo = GetType(C).GetMethod("M4")
    ' Instance method with one argument of type C.
    Dim fmi1 As MethodInfo = GetType(F).GetMethod("M1")
    ' Shared method with one argument of type C.
    Dim fmi3 As MethodInfo = GetType(F).GetMethod("M3")
    ' Shared method with an argument of type F and an 
    ' argument of type C.
    Dim fmi4 As MethodInfo = GetType(F).GetMethod("M4")
    Console.WriteLine(vbLf & "An instance method on any type, with an argument of type C.")
    ' D can represent any instance method that exactly matches its
    ' signature. Methods on C and F are shown here.
    '
    d = CType([Delegate].CreateDelegate(GetType(D), c1, cmi1), D)
    d(c2)
    d = CType([Delegate].CreateDelegate(GetType(D), f1, fmi1), D)
    d(c2)
    Console.WriteLine(vbLf & "An instance method on C with no arguments.")
    ' D can represent an instance method on C that has no arguments;
    ' in this case, the argument of D represents the hidden first
    ' argument of any instance method. The delegate acts like a 
    ' Shared method, and an instance of C must be passed each time
    ' it is invoked.
    '
    d = CType([Delegate].CreateDelegate(GetType(D), Nothing, cmi2), D)
    d(c1)
    Console.WriteLine(vbLf & "A Shared method on any type, with an argument of type C.")
    ' D can represent any Shared method with the same signature.
    ' Methods on F and C are shown here.
    '
    d = CType([Delegate].CreateDelegate(GetType(D), Nothing, cmi3), D)
    d(c1)
    d = CType([Delegate].CreateDelegate(GetType(D), Nothing, fmi3), D)
    d(c1)
    Console.WriteLine(vbLf & "A Shared method on any type, with an argument of")
    Console.WriteLine("    that type and an argument of type C.")
    ' D can represent any Shared method with one argument of the
    ' type the method belongs and a second argument of type C.
    ' In this case, the method is closed over the instance of
    ' supplied for the its first argument, and acts like an instance
    ' method. Methods on F and C are shown here.
    '
    d = CType([Delegate].CreateDelegate(GetType(D), c1, cmi4), D)
    d(c2)
    Dim test As [Delegate] =
        [Delegate].CreateDelegate(GetType(D), f1, fmi4, False)
    ' This final example specifies False for throwOnBindFailure 
    ' in the call to CreateDelegate, so the variable 'test'
    ' contains Nothing if the method fails to bind (for 
    ' example, if fmi4 happened to represent a method of  
    ' some class other than F).
    '
    If test IsNot Nothing Then
        d = CType(test, D)
        d(c2)
    End If
End Sub
End Class
' This code example produces the following output:
'
'An instance method on any type, with an argument of type C.
'Instance method M1(c As C) on C: this.id = 42, c.ID = 1491
'Instance method M1(c As C) on F: c.ID = 1491
'
'An instance method on C with no arguments.
'Instance method M2() on C: this.id = 42
'
'A Shared method on any type, with an argument of type C.
'Shared method M3(c As C) on C: c.ID = 42
'Shared method M3(c As C) on F: c.ID = 42
'
'A Shared method on any type, with an argument of
' that type and an argument of type C.
'Shared method M4(c1 As C, c2 As C) on C: c1.ID = 42, c2.ID = 1491
'Shared method M4(f As F, c As C) on F: c.ID = 1491
'

Compatible parameter types and return type

The parameter types and return type of a delegate created using this method overload must be compatible with the parameter types and return type of the method the delegate represents; the types do not have to match exactly.

A parameter of a delegate is compatible with the corresponding parameter of a method if the type of the delegate parameter is more restrictive than the type of the method parameter, because this guarantees that an argument passed to the delegate can be passed safely to the method.

Similarly, the return type of a delegate is compatible with the return type of a method if the return type of the method is more restrictive than the return type of the delegate, because this guarantees that the return value of the method can be cast safely to the return type of the delegate.

For example, a delegate with a parameter of type Hashtable and a return type of Object can represent a method with a parameter of type Object and a return value of type Hashtable.

Determine the methods a delegate can represent

Another useful way to think of the flexibility provided by the overload is that any given delegate can represent four different combinations of method signature and method kind (static versus instance). Consider a delegate type

Imports System.Reflection Imports System.Security.Permissions ' Declare a delegate type. The object of this code example ' is to show all the methods this delegate can bind to. ' Public Delegate Sub D(ByVal c As C) ' Declare two sample classes, C and F. Class C has an ID ' property so instances can be identified. ' Public Class C

Private _id As Integer
Public ReadOnly Property ID() As Integer 
    Get
        Return _id
    End Get
End Property
Public Sub New(ByVal newId As Integer) 
    Me._id = newId
End Sub
Public Sub M1(ByVal c As C) 
    Console.WriteLine("Instance method M1(c As C) on C:  this.id = {0}, c.ID = {1}", _
        Me.id, c.ID)
End Sub
Public Sub M2() 
    Console.WriteLine("Instance method M2() on C:  this.id = {0}", Me.id)
End Sub
Public Shared Sub M3(ByVal c As C) 
    Console.WriteLine("Shared method M3(c As C) on C:  c.ID = {0}", c.ID)
End Sub
Public Shared Sub M4(ByVal c1 As C, ByVal c2 As C) 
    Console.WriteLine("Shared method M4(c1 As C, c2 As C) on C:  c1.ID = {0}, c2.ID = {1}", _
        c1.ID, c2.ID)
End Sub

End Class
Public Class FPublic Sub M1(ByVal c As C) 
    Console.WriteLine("Instance method M1(c As C) on F:  c.ID = {0}", c.ID)
End Sub
Public Shared Sub M3(ByVal c As C) 
    Console.WriteLine("Shared method M3(c As C) on F:  c.ID = {0}", c.ID)
End Sub
Public Shared Sub M4(ByVal f As F, ByVal c As C) 
    Console.WriteLine("Shared method M4(f As F, c As C) on F:  c.ID = {0}", c.ID)
End Sub
End Class
Public Class Example5Public Shared Sub Main()
    Dim c1 As New C(42)
    Dim c2 As New C(1491)
    Dim f1 As New F()
    Dim d As D
    ' Instance method with one argument of type C.
    Dim cmi1 As MethodInfo = GetType(C).GetMethod("M1")
    ' Instance method with no arguments.
    Dim cmi2 As MethodInfo = GetType(C).GetMethod("M2")
    ' Shared method with one argument of type C.
    Dim cmi3 As MethodInfo = GetType(C).GetMethod("M3")
    ' Shared method with two arguments of type C.
    Dim cmi4 As MethodInfo = GetType(C).GetMethod("M4")
    ' Instance method with one argument of type C.
    Dim fmi1 As MethodInfo = GetType(F).GetMethod("M1")
    ' Shared method with one argument of type C.
    Dim fmi3 As MethodInfo = GetType(F).GetMethod("M3")
    ' Shared method with an argument of type F and an 
    ' argument of type C.
    Dim fmi4 As MethodInfo = GetType(F).GetMethod("M4")
    Console.WriteLine(vbLf & "An instance method on any type, with an argument of type C.")
    ' D can represent any instance method that exactly matches its
    ' signature. Methods on C and F are shown here.
    '
    d = CType([Delegate].CreateDelegate(GetType(D), c1, cmi1), D)
    d(c2)
    d = CType([Delegate].CreateDelegate(GetType(D), f1, fmi1), D)
    d(c2)
    Console.WriteLine(vbLf & "An instance method on C with no arguments.")
    ' D can represent an instance method on C that has no arguments;
    ' in this case, the argument of D represents the hidden first
    ' argument of any instance method. The delegate acts like a 
    ' Shared method, and an instance of C must be passed each time
    ' it is invoked.
    '
    d = CType([Delegate].CreateDelegate(GetType(D), Nothing, cmi2), D)
    d(c1)
    Console.WriteLine(vbLf & "A Shared method on any type, with an argument of type C.")
    ' D can represent any Shared method with the same signature.
    ' Methods on F and C are shown here.
    '
    d = CType([Delegate].CreateDelegate(GetType(D), Nothing, cmi3), D)
    d(c1)
    d = CType([Delegate].CreateDelegate(GetType(D), Nothing, fmi3), D)
    d(c1)
    Console.WriteLine(vbLf & "A Shared method on any type, with an argument of")
    Console.WriteLine("    that type and an argument of type C.")
    ' D can represent any Shared method with one argument of the
    ' type the method belongs and a second argument of type C.
    ' In this case, the method is closed over the instance of
    ' supplied for the its first argument, and acts like an instance
    ' method. Methods on F and C are shown here.
    '
    d = CType([Delegate].CreateDelegate(GetType(D), c1, cmi4), D)
    d(c2)
    Dim test As [Delegate] =
        [Delegate].CreateDelegate(GetType(D), f1, fmi4, False)
    ' This final example specifies False for throwOnBindFailure 
    ' in the call to CreateDelegate, so the variable 'test'
    ' contains Nothing if the method fails to bind (for 
    ' example, if fmi4 happened to represent a method of  
    ' some class other than F).
    '
    If test IsNot Nothing Then
        d = CType(test, D)
        d(c2)
    End If
End Sub
End Class
' This code example produces the following output:
'
'An instance method on any type, with an argument of type C.
'Instance method M1(c As C) on C: this.id = 42, c.ID = 1491
'Instance method M1(c As C) on F: c.ID = 1491
'
'An instance method on C with no arguments.
'Instance method M2() on C: this.id = 42
'
'A Shared method on any type, with an argument of type C.
'Shared method M3(c As C) on C: c.ID = 42
'Shared method M3(c As C) on F: c.ID = 42
'
'A Shared method on any type, with an argument of
' that type and an argument of type C.
'Shared method M4(c1 As C, c2 As C) on C: c1.ID = 42, c2.ID = 1491
'Shared method M4(f As F, c As C) on F: c.ID = 1491
'

3 with one argument of type

open System open System.Reflection // A sample class with an instance method and a static method. type C(id) =

member _.M1(s) =
    printfn $"Instance method M1 on C:  id = %i{id}, s = %s{s}"
static member M2(s) =
    printfn $"Static method M2 on C:  s = %s{s}"

// Declare three delegate types for demonstrating the combinations
// of static versus instance methods and open versus closed
// delegates.
type D1 = delegate of C * string -> unit
type D2 = delegate of string -> unit
type D3 = delegate of unit -> unit
let c1 = C 42
// Get a MethodInfo for each method.
//
let mi1 = typeof.GetMethod("M1", BindingFlags.Public ||| BindingFlags.Instance)
let mi2 = typeof.GetMethod("M2", BindingFlags.Public ||| BindingFlags.Static)
printfn "\nAn instance method closed over C."
// In this case, the delegate and the
// method must have the same list of argument types use
// delegate type D2 with instance method M1.
let test = Delegate.CreateDelegate(typeof, c1, mi1, false)
// Because false was specified for throwOnBindFailure
// in the call to CreateDelegate, the variable 'test'
// contains null if the method fails to bind (for
// example, if mi1 happened to represent a method of
// some class other than C).
if test <> null thenlet d2 = test :?> D2
// The same instance of C is used every time the
// delegate is invoked.
d2.Invoke "Hello, World!"
d2.Invoke "Hi, Mom!"
printfn "\nAn open instance method."
// In this case, the delegate has one more
// argument than the instance method this argument comes
// at the beginning, and represents the hidden instance
// argument of the instance method. Use delegate type D1
// with instance method M1.
let d1 = Delegate.CreateDelegate(typeof, null, mi1) :?> D1
// An instance of C must be passed in each time the
// delegate is invoked.
d1.Invoke(c1, "Hello, World!")
d1.Invoke(C 5280, "Hi, Mom!")
printfn "\nAn open static method."
// In this case, the delegate and the method must
// have the same list of argument types use delegate type
// D2 with static method M2.
let d2 = Delegate.CreateDelegate(typeof, null, mi2) :?> D2
// No instances of C are involved, because this is a static
// method.
d2.Invoke "Hello, World!"
d2.Invoke "Hi, Mom!"
printfn "\nA static method closed over the first argument (String)."
// The delegate must omit the first argument of the method.
// A string is passed as the firstArgument parameter, and
// the delegate is bound to this string. Use delegate type
// D3 with static method M2.
let d3 = Delegate.CreateDelegate(typeof, "Hello, World!", mi2) :?> D3
// Each time the delegate is invoked, the same string is used.
d3.Invoke()
// This code example produces the following output:
// An instance method closed over C.
// Instance method M1 on C: id = 42, s = Hello, World!
// Instance method M1 on C: id = 42, s = Hi, Mom!
//
// An open instance method.
// Instance method M1 on C: id = 42, s = Hello, World!
// Instance method M1 on C: id = 5280, s = Hi, Mom!
//
// An open static method.
// Static method M2 on C: s = Hello, World!
// Static method M2 on C: s = Hi, Mom!
//
// A static method closed over the first argument (String).
// Static method M2 on C: s = Hello, World!

1. The following describes the methods

Imports System.Reflection Imports System.Security.Permissions ' Declare a delegate type. The object of this code example ' is to show all the methods this delegate can bind to. ' Public Delegate Sub D(ByVal c As C) ' Declare two sample classes, C and F. Class C has an ID ' property so instances can be identified. ' Public Class C

Private _id As Integer
Public ReadOnly Property ID() As Integer 
    Get
        Return _id
    End Get
End Property
Public Sub New(ByVal newId As Integer) 
    Me._id = newId
End Sub
Public Sub M1(ByVal c As C) 
    Console.WriteLine("Instance method M1(c As C) on C:  this.id = {0}, c.ID = {1}", _
        Me.id, c.ID)
End Sub
Public Sub M2() 
    Console.WriteLine("Instance method M2() on C:  this.id = {0}", Me.id)
End Sub
Public Shared Sub M3(ByVal c As C) 
    Console.WriteLine("Shared method M3(c As C) on C:  c.ID = {0}", c.ID)
End Sub
Public Shared Sub M4(ByVal c1 As C, ByVal c2 As C) 
    Console.WriteLine("Shared method M4(c1 As C, c2 As C) on C:  c1.ID = {0}, c2.ID = {1}", _
        c1.ID, c2.ID)
End Sub

End Class
Public Class FPublic Sub M1(ByVal c As C) 
    Console.WriteLine("Instance method M1(c As C) on F:  c.ID = {0}", c.ID)
End Sub
Public Shared Sub M3(ByVal c As C) 
    Console.WriteLine("Shared method M3(c As C) on F:  c.ID = {0}", c.ID)
End Sub
Public Shared Sub M4(ByVal f As F, ByVal c As C) 
    Console.WriteLine("Shared method M4(f As F, c As C) on F:  c.ID = {0}", c.ID)
End Sub
End Class
Public Class Example5Public Shared Sub Main()
    Dim c1 As New C(42)
    Dim c2 As New C(1491)
    Dim f1 As New F()
    Dim d As D
    ' Instance method with one argument of type C.
    Dim cmi1 As MethodInfo = GetType(C).GetMethod("M1")
    ' Instance method with no arguments.
    Dim cmi2 As MethodInfo = GetType(C).GetMethod("M2")
    ' Shared method with one argument of type C.
    Dim cmi3 As MethodInfo = GetType(C).GetMethod("M3")
    ' Shared method with two arguments of type C.
    Dim cmi4 As MethodInfo = GetType(C).GetMethod("M4")
    ' Instance method with one argument of type C.
    Dim fmi1 As MethodInfo = GetType(F).GetMethod("M1")
    ' Shared method with one argument of type C.
    Dim fmi3 As MethodInfo = GetType(F).GetMethod("M3")
    ' Shared method with an argument of type F and an 
    ' argument of type C.
    Dim fmi4 As MethodInfo = GetType(F).GetMethod("M4")
    Console.WriteLine(vbLf & "An instance method on any type, with an argument of type C.")
    ' D can represent any instance method that exactly matches its
    ' signature. Methods on C and F are shown here.
    '
    d = CType([Delegate].CreateDelegate(GetType(D), c1, cmi1), D)
    d(c2)
    d = CType([Delegate].CreateDelegate(GetType(D), f1, fmi1), D)
    d(c2)
    Console.WriteLine(vbLf & "An instance method on C with no arguments.")
    ' D can represent an instance method on C that has no arguments;
    ' in this case, the argument of D represents the hidden first
    ' argument of any instance method. The delegate acts like a 
    ' Shared method, and an instance of C must be passed each time
    ' it is invoked.
    '
    d = CType([Delegate].CreateDelegate(GetType(D), Nothing, cmi2), D)
    d(c1)
    Console.WriteLine(vbLf & "A Shared method on any type, with an argument of type C.")
    ' D can represent any Shared method with the same signature.
    ' Methods on F and C are shown here.
    '
    d = CType([Delegate].CreateDelegate(GetType(D), Nothing, cmi3), D)
    d(c1)
    d = CType([Delegate].CreateDelegate(GetType(D), Nothing, fmi3), D)
    d(c1)
    Console.WriteLine(vbLf & "A Shared method on any type, with an argument of")
    Console.WriteLine("    that type and an argument of type C.")
    ' D can represent any Shared method with one argument of the
    ' type the method belongs and a second argument of type C.
    ' In this case, the method is closed over the instance of
    ' supplied for the its first argument, and acts like an instance
    ' method. Methods on F and C are shown here.
    '
    d = CType([Delegate].CreateDelegate(GetType(D), c1, cmi4), D)
    d(c2)
    Dim test As [Delegate] =
        [Delegate].CreateDelegate(GetType(D), f1, fmi4, False)
    ' This final example specifies False for throwOnBindFailure 
    ' in the call to CreateDelegate, so the variable 'test'
    ' contains Nothing if the method fails to bind (for 
    ' example, if fmi4 happened to represent a method of  
    ' some class other than F).
    '
    If test IsNot Nothing Then
        d = CType(test, D)
        d(c2)
    End If
End Sub
End Class
' This code example produces the following output:
'
'An instance method on any type, with an argument of type C.
'Instance method M1(c As C) on C: this.id = 42, c.ID = 1491
'Instance method M1(c As C) on F: c.ID = 1491
'
'An instance method on C with no arguments.
'Instance method M2() on C: this.id = 42
'
'A Shared method on any type, with an argument of type C.
'Shared method M3(c As C) on C: c.ID = 42
'Shared method M3(c As C) on F: c.ID = 42
'
'A Shared method on any type, with an argument of
' that type and an argument of type C.
'Shared method M4(c1 As C, c2 As C) on C: c1.ID = 42, c2.ID = 1491
'Shared method M4(f As F, c As C) on F: c.ID = 1491
'

3 can represent, ignoring the return type since it must match in all cases:

Imports System.Reflection Imports System.Security.Permissions
' Declare a delegate type. The object of this code example
' is to show all the methods this delegate can bind to.
'
Public Delegate Sub D(ByVal c As C)
' Declare two sample classes, C and F. Class C has an ID
' property so instances can be identified.
'
Public Class C 
Private id As Integer  
Public ReadOnly Property ID() As Integer  
    Get  
        Return _id  
    End Get  
End Property  
Public Sub New(ByVal newId As Integer)  
    Me._id = newId  
End Sub  
Public Sub M1(ByVal c As C)  
    Console.WriteLine("Instance method M1(c As C) on C:  this.id = {0}, c.ID = {1}",   
        Me.id, c.ID)  
End Sub  
Public Sub M2()  
    Console.WriteLine("Instance method M2() on C:  this.id = {0}", Me.id)  
End Sub  
Public Shared Sub M3(ByVal c As C)  
    Console.WriteLine("Shared method M3(c As C) on C:  c.ID = {0}", c.ID)  
End Sub  
Public Shared Sub M4(ByVal c1 As C, ByVal c2 As C)  
    Console.WriteLine("Shared method M4(c1 As C, c2 As C) on C:  c1.ID = {0}, c2.ID = {1}", _  
        c1.ID, c2.ID)  
End Sub  
End Class
Public Class F Public Sub M1(ByVal c As C)  
    Console.WriteLine("Instance method M1(c As C) on F:  c.ID = {0}", c.ID)  
End Sub  
Public Shared Sub M3(ByVal c As C)  
    Console.WriteLine("Shared method M3(c As C) on F:  c.ID = {0}", c.ID)  
End Sub  
Public Shared Sub M4(ByVal f As F, ByVal c As C)  
    Console.WriteLine("Shared method M4(f As F, c As C) on F:  c.ID = {0}", c.ID)  
End Sub  
End Class
Public Class Example5 Public Shared Sub Main()  
    Dim c1 As New C(42)  
    Dim c2 As New C(1491)  
    Dim f1 As New F()  
    Dim d As D  
    ' Instance method with one argument of type C.  
    Dim cmi1 As MethodInfo = GetType(C).GetMethod("M1")  
    ' Instance method with no arguments.  
    Dim cmi2 As MethodInfo = GetType(C).GetMethod("M2")  
    ' Shared method with one argument of type C.  
    Dim cmi3 As MethodInfo = GetType(C).GetMethod("M3")  
    ' Shared method with two arguments of type C.  
    Dim cmi4 As MethodInfo = GetType(C).GetMethod("M4")  
    ' Instance method with one argument of type C.  
    Dim fmi1 As MethodInfo = GetType(F).GetMethod("M1")  
    ' Shared method with one argument of type C.  
    Dim fmi3 As MethodInfo = GetType(F).GetMethod("M3")  
    ' Shared method with an argument of type F and an  
    ' argument of type C.  
    Dim fmi4 As MethodInfo = GetType(F).GetMethod("M4")  
    Console.WriteLine(vbLf & "An instance method on any type, with an argument of type C.")  
    ' D can represent any instance method that exactly matches its  
    ' signature. Methods on C and F are shown here.  
    '  
    d = CType([Delegate].CreateDelegate(GetType(D), c1, cmi1), D)  
    d(c2)  
    d = CType([Delegate].CreateDelegate(GetType(D), f1, fmi1), D)  
    d(c2)  
    Console.WriteLine(vbLf & "An instance method on C with no arguments.")  
    ' D can represent an instance method on C that has no arguments;  
    ' in this case, the argument of D represents the hidden first  
    ' argument of any instance method. The delegate acts like a  
    ' Shared method, and an instance of C must be passed each time  
    ' it is invoked.  
    '  
    d = CType([Delegate].CreateDelegate(GetType(D), Nothing, cmi2), D)  
    d(c1)  
    Console.WriteLine(vbLf & "A Shared method on any type, with an argument of type C.")  
    ' D can represent any Shared method with the same signature.  
    ' Methods on F and C are shown here.  
    '  
    d = CType([Delegate].CreateDelegate(GetType(D), Nothing, cmi3), D)  
    d(c1)  
    d = CType([Delegate].CreateDelegate(GetType(D), Nothing, fmi3), D)  
    d(c1)  
    Console.WriteLine(vbLf & "A Shared method on any type, with an argument of")  
    Console.WriteLine("    that type and an argument of type C.")  
    ' D can represent any Shared method with one argument of the  
    ' type the method belongs and a second argument of type C.  
    ' In this case, the method is closed over the instance of  
    ' supplied for the its first argument, and acts like an instance  
    ' method. Methods on F and C are shown here.  
    '  
    d = CType([Delegate].CreateDelegate(GetType(D), c1, cmi4), D)  
    d(c2)  
    Dim test As [Delegate] =  
        [Delegate].CreateDelegate(GetType(D), f1, fmi4, False)  
    ' This final example specifies False for throwOnBindFailure  
    ' in the call to CreateDelegate, so the variable 'test'  
    ' contains Nothing if the method fails to bind (for  
    ' example, if fmi4 happened to represent a method of  
    ' some class other than F).  
    '  
    If test IsNot Nothing Then  
        d = CType(test, D)  
        d(c2)  
    End If  
End Sub  
End Class
' This code example produces the following output:
'
'An instance method on any type, with an argument of type C.
'Instance method M1(c As C) on C: this.id = 42, c.ID = 1491
'Instance method M1(c As C) on F: c.ID = 1491
'
'An instance method on C with no arguments.
'Instance method M2() on C: this.id = 42
'
'A Shared method on any type, with an argument of type C.
'Shared method M3(c As C) on C: c.ID = 42
'Shared method M3(c As C) on F: c.ID = 42
'
'A Shared method on any type, with an argument of
' that type and an argument of type C.
'Shared method M4(c1 As C, c2 As C) on C: c1.ID = 42, c2.ID = 1491
'Shared method M4(f As F, c As C) on F: c.ID = 1491
'

3 can represent any instance method that has exactly one argument of type

open System open System.Reflection
// A sample class with an instance method and a static method.
type C(id) = 
member _.M1(s) =  
    printfn $"Instance method M1 on C:  id = %i{id}, s = %s{s}"  
static member M2(s) =  
    printfn $"Static method M2 on C:  s = %s{s}"  
// Declare three delegate types for demonstrating the combinations
// of static versus instance methods and open versus closed
// delegates.
type D1 = delegate of C * string -> unit
type D2 = delegate of string -> unit
type D3 = delegate of unit -> unit
let c1 = C 42
// Get a MethodInfo for each method.
//
let mi1 = typeof.GetMethod("M1", BindingFlags.Public ||| BindingFlags.Instance)
let mi2 = typeof.GetMethod("M2", BindingFlags.Public ||| BindingFlags.Static)
printfn "\nAn instance method closed over C."
// In this case, the delegate and the
// method must have the same list of argument types use
// delegate type D2 with instance method M1.
let test = Delegate.CreateDelegate(typeof, c1, mi1, false)
// Because false was specified for throwOnBindFailure
// in the call to CreateDelegate, the variable 'test'
// contains null if the method fails to bind (for
// example, if mi1 happened to represent a method of
// some class other than C).
if test <> null then let d2 = test :?> D2  
// The same instance of C is used every time the  
// delegate is invoked.  
d2.Invoke "Hello, World!"  
d2.Invoke "Hi, Mom!"  
printfn "\nAn open instance method."
// In this case, the delegate has one more
// argument than the instance method this argument comes
// at the beginning, and represents the hidden instance
// argument of the instance method. Use delegate type D1
// with instance method M1.
let d1 = Delegate.CreateDelegate(typeof, null, mi1) :?> D1
// An instance of C must be passed in each time the
// delegate is invoked.
d1.Invoke(c1, "Hello, World!")
d1.Invoke(C 5280, "Hi, Mom!")
printfn "\nAn open static method."
// In this case, the delegate and the method must
// have the same list of argument types use delegate type
// D2 with static method M2.
let d2 = Delegate.CreateDelegate(typeof, null, mi2) :?> D2
// No instances of C are involved, because this is a static
// method.
d2.Invoke "Hello, World!"
d2.Invoke "Hi, Mom!"
printfn "\nA static method closed over the first argument (String)."
// The delegate must omit the first argument of the method.
// A string is passed as the firstArgument parameter, and
// the delegate is bound to this string. Use delegate type
// D3 with static method M2.
let d3 = Delegate.CreateDelegate(typeof, "Hello, World!", mi2) :?> D3
// Each time the delegate is invoked, the same string is used.
d3.Invoke()
// This code example produces the following output:
// An instance method closed over C.
// Instance method M1 on C: id = 42, s = Hello, World!
// Instance method M1 on C: id = 42, s = Hi, Mom!
//
// An open instance method.
// Instance method M1 on C: id = 42, s = Hello, World!
// Instance method M1 on C: id = 5280, s = Hi, Mom!
//
// An open static method.
// Static method M2 on C: s = Hello, World!
// Static method M2 on C: s = Hi, Mom!
//
// A static method closed over the first argument (String).
// Static method M2 on C: s = Hello, World!

1, regardless of what type the instance method belongs to. When CreateDelegate is called,

open System open System.Reflection
// Define two classes to use in the demonstration, a base class and
// a class that derives from it.
type Base() = class end
type Derived() = 
inherit Base()  
// Define a static method to use in the demonstration. The method  
// takes an instance of Base and returns an instance of Derived.  
// For the purposes of the demonstration, it is not necessary for  
// the method to do anything useful.  
static member MyMethod(arg: Base) =  
    Derived()  
// Define a delegate that takes an instance of Derived and returns an
// instance of Base.
type Example = delegate of Derived -> Base
// The binding flags needed to retrieve MyMethod.
let flags = BindingFlags.Public ||| BindingFlags.Static
// Get a MethodInfo that represents MyMethod.
let minfo = typeof.GetMethod("MyMethod", flags)
// Demonstrate contravariance of parameter types and covariance
// of return types by using the delegate Example to represent
// MyMethod. The delegate binds to the method because the
// parameter of the delegate is more restrictive than the
// parameter of the method (that is, the delegate accepts an
// instance of Derived, which can always be safely passed to
// a parameter of type Base), and the return type of MyMethod
// is more restrictive than the return type of Example (that
// is, the method returns an instance of Derived, which can
// always be safely cast to type Base).
let ex = Delegate.CreateDelegate(typeof, minfo) :?> Example
// Execute MyMethod using the delegate Example.
let b = Derived() |> ex.Invoke

4 is an instance of the type

open System open System.Reflection
// Define two classes to use in the demonstration, a base class and
// a class that derives from it.
type Base() = class end
type Derived() = 
inherit Base()  
// Define a static method to use in the demonstration. The method  
// takes an instance of Base and returns an instance of Derived.  
// For the purposes of the demonstration, it is not necessary for  
// the method to do anything useful.  
static member MyMethod(arg: Base) =  
    Derived()  
// Define a delegate that takes an instance of Derived and returns an
// instance of Base.
type Example = delegate of Derived -> Base
// The binding flags needed to retrieve MyMethod.
let flags = BindingFlags.Public ||| BindingFlags.Static
// Get a MethodInfo that represents MyMethod.
let minfo = typeof.GetMethod("MyMethod", flags)
// Demonstrate contravariance of parameter types and covariance
// of return types by using the delegate Example to represent
// MyMethod. The delegate binds to the method because the
// parameter of the delegate is more restrictive than the
// parameter of the method (that is, the delegate accepts an
// instance of Derived, which can always be safely passed to
// a parameter of type Base), and the return type of MyMethod
// is more restrictive than the return type of Example (that
// is, the method returns an instance of Derived, which can
// always be safely cast to type Base).
let ex = Delegate.CreateDelegate(typeof, minfo) :?> Example
// Execute MyMethod using the delegate Example.
let b = Derived() |> ex.Invoke

2 belongs to, and the resulting delegate is said to be closed over that instance. (Trivially,

Imports System.Reflection Imports System.Security.Permissions
' Declare a delegate type. The object of this code example
' is to show all the methods this delegate can bind to.
'
Public Delegate Sub D(ByVal c As C)
' Declare two sample classes, C and F. Class C has an ID
' property so instances can be identified.
'
Public Class C 
Private id As Integer  
Public ReadOnly Property ID() As Integer  
    Get  
        Return _id  
    End Get  
End Property  
Public Sub New(ByVal newId As Integer)  
    Me._id = newId  
End Sub  
Public Sub M1(ByVal c As C)  
    Console.WriteLine("Instance method M1(c As C) on C:  this.id = {0}, c.ID = {1}",   
        Me.id, c.ID)  
End Sub  
Public Sub M2()  
    Console.WriteLine("Instance method M2() on C:  this.id = {0}", Me.id)  
End Sub  
Public Shared Sub M3(ByVal c As C)  
    Console.WriteLine("Shared method M3(c As C) on C:  c.ID = {0}", c.ID)  
End Sub  
Public Shared Sub M4(ByVal c1 As C, ByVal c2 As C)  
    Console.WriteLine("Shared method M4(c1 As C, c2 As C) on C:  c1.ID = {0}, c2.ID = {1}", _  
        c1.ID, c2.ID)  
End Sub  
End Class
Public Class F Public Sub M1(ByVal c As C)  
    Console.WriteLine("Instance method M1(c As C) on F:  c.ID = {0}", c.ID)  
End Sub  
Public Shared Sub M3(ByVal c As C)  
    Console.WriteLine("Shared method M3(c As C) on F:  c.ID = {0}", c.ID)  
End Sub  
Public Shared Sub M4(ByVal f As F, ByVal c As C)  
    Console.WriteLine("Shared method M4(f As F, c As C) on F:  c.ID = {0}", c.ID)  
End Sub  
End Class
Public Class Example5 Public Shared Sub Main()  
    Dim c1 As New C(42)  
    Dim c2 As New C(1491)  
    Dim f1 As New F()  
    Dim d As D  
    ' Instance method with one argument of type C.  
    Dim cmi1 As MethodInfo = GetType(C).GetMethod("M1")  
    ' Instance method with no arguments.  
    Dim cmi2 As MethodInfo = GetType(C).GetMethod("M2")  
    ' Shared method with one argument of type C.  
    Dim cmi3 As MethodInfo = GetType(C).GetMethod("M3")  
    ' Shared method with two arguments of type C.  
    Dim cmi4 As MethodInfo = GetType(C).GetMethod("M4")  
    ' Instance method with one argument of type C.  
    Dim fmi1 As MethodInfo = GetType(F).GetMethod("M1")  
    ' Shared method with one argument of type C.  
    Dim fmi3 As MethodInfo = GetType(F).GetMethod("M3")  
    ' Shared method with an argument of type F and an  
    ' argument of type C.  
    Dim fmi4 As MethodInfo = GetType(F).GetMethod("M4")  
    Console.WriteLine(vbLf & "An instance method on any type, with an argument of type C.")  
    ' D can represent any instance method that exactly matches its  
    ' signature. Methods on C and F are shown here.  
    '  
    d = CType([Delegate].CreateDelegate(GetType(D), c1, cmi1), D)  
    d(c2)  
    d = CType([Delegate].CreateDelegate(GetType(D), f1, fmi1), D)  
    d(c2)  
    Console.WriteLine(vbLf & "An instance method on C with no arguments.")  
    ' D can represent an instance method on C that has no arguments;  
    ' in this case, the argument of D represents the hidden first  
    ' argument of any instance method. The delegate acts like a  
    ' Shared method, and an instance of C must be passed each time  
    ' it is invoked.  
    '  
    d = CType([Delegate].CreateDelegate(GetType(D), Nothing, cmi2), D)  
    d(c1)  
    Console.WriteLine(vbLf & "A Shared method on any type, with an argument of type C.")  
    ' D can represent any Shared method with the same signature.  
    ' Methods on F and C are shown here.  
    '  
    d = CType([Delegate].CreateDelegate(GetType(D), Nothing, cmi3), D)  
    d(c1)  
    d = CType([Delegate].CreateDelegate(GetType(D), Nothing, fmi3), D)  
    d(c1)  
    Console.WriteLine(vbLf & "A Shared method on any type, with an argument of")  
    Console.WriteLine("    that type and an argument of type C.")  
    ' D can represent any Shared method with one argument of the  
    ' type the method belongs and a second argument of type C.  
    ' In this case, the method is closed over the instance of  
    ' supplied for the its first argument, and acts like an instance  
    ' method. Methods on F and C are shown here.  
    '  
    d = CType([Delegate].CreateDelegate(GetType(D), c1, cmi4), D)  
    d(c2)  
    Dim test As [Delegate] =  
        [Delegate].CreateDelegate(GetType(D), f1, fmi4, False)  
    ' This final example specifies False for throwOnBindFailure  
    ' in the call to CreateDelegate, so the variable 'test'  
    ' contains Nothing if the method fails to bind (for  
    ' example, if fmi4 happened to represent a method of  
    ' some class other than F).  
    '  
    If test IsNot Nothing Then  
        d = CType(test, D)  
        d(c2)  
    End If  
End Sub  
End Class
' This code example produces the following output:
'
'An instance method on any type, with an argument of type C.
'Instance method M1(c As C) on C: this.id = 42, c.ID = 1491
'Instance method M1(c As C) on F: c.ID = 1491
'
'An instance method on C with no arguments.
'Instance method M2() on C: this.id = 42
'
'A Shared method on any type, with an argument of type C.
'Shared method M3(c As C) on C: c.ID = 42
'Shared method M3(c As C) on F: c.ID = 42
'
'A Shared method on any type, with an argument of
' that type and an argument of type C.
'Shared method M4(c1 As C, c2 As C) on C: c1.ID = 42, c2.ID = 1491
'Shared method M4(f As F, c As C) on F: c.ID = 1491
'

3 can also be closed over a null reference if

open System open System.Reflection
// Define two classes to use in the demonstration, a base class and
// a class that derives from it.
type Base() = class end
type Derived() = 
inherit Base()  
// Define a static method to use in the demonstration. The method  
// takes an instance of Base and returns an instance of Derived.  
// For the purposes of the demonstration, it is not necessary for  
// the method to do anything useful.  
static member MyMethod(arg: Base) =  
    Derived()  
// Define a delegate that takes an instance of Derived and returns an
// instance of Base.
type Example = delegate of Derived -> Base
// The binding flags needed to retrieve MyMethod.
let flags = BindingFlags.Public ||| BindingFlags.Static
// Get a MethodInfo that represents MyMethod.
let minfo = typeof.GetMethod("MyMethod", flags)
// Demonstrate contravariance of parameter types and covariance
// of return types by using the delegate Example to represent
// MyMethod. The delegate binds to the method because the
// parameter of the delegate is more restrictive than the
// parameter of the method (that is, the delegate accepts an
// instance of Derived, which can always be safely passed to
// a parameter of type Base), and the return type of MyMethod
// is more restrictive than the return type of Example (that
// is, the method returns an instance of Derived, which can
// always be safely cast to type Base).
let ex = Delegate.CreateDelegate(typeof, minfo) :?> Example
// Execute MyMethod using the delegate Example.
let b = Derived() |> ex.Invoke

4 is a null reference.)

Imports System.Reflection Imports System.Security.Permissions ' Declare a delegate type. The object of this code example ' is to show all the methods this delegate can bind to. ' Public Delegate Sub D(ByVal c As C) ' Declare two sample classes, C and F. Class C has an ID ' property so instances can be identified. ' Public Class C Private id As Integer Public ReadOnly Property ID() As Integer Get Return _id End Get End Property Public Sub New(ByVal newId As Integer) Me._id = newId End Sub Public Sub M1(ByVal c As C) Console.WriteLine("Instance method M1(c As C) on C: this.id = {0}, c.ID = {1}", Me.id, c.ID) End Sub Public Sub M2() Console.WriteLine("Instance method M2() on C: this.id = {0}", Me.id) End Sub Public Shared Sub M3(ByVal c As C) Console.WriteLine("Shared method M3(c As C) on C: c.ID = {0}", c.ID) End Sub Public Shared Sub M4(ByVal c1 As C, ByVal c2 As C) Console.WriteLine("Shared method M4(c1 As C, c2 As C) on C: c1.ID = {0}, c2.ID = {1}", _ c1.ID, c2.ID) End Sub End Class Public Class F Public Sub M1(ByVal c As C) Console.WriteLine("Instance method M1(c As C) on F: c.ID = {0}", c.ID) End Sub Public Shared Sub M3(ByVal c As C) Console.WriteLine("Shared method M3(c As C) on F: c.ID = {0}", c.ID) End Sub Public Shared Sub M4(ByVal f As F, ByVal c As C) Console.WriteLine("Shared method M4(f As F, c As C) on F: c.ID = {0}", c.ID) End Sub End Class Public Class Example5 Public Shared Sub Main() Dim c1 As New C(42) Dim c2 As New C(1491) Dim f1 As New F() Dim d As D ' Instance method with one argument of type C. Dim cmi1 As MethodInfo = GetType(C).GetMethod("M1") ' Instance method with no arguments. Dim cmi2 As MethodInfo = GetType(C).GetMethod("M2") ' Shared method with one argument of type C. Dim cmi3 As MethodInfo = GetType(C).GetMethod("M3") ' Shared method with two arguments of type C. Dim cmi4 As MethodInfo = GetType(C).GetMethod("M4") ' Instance method with one argument of type C. Dim fmi1 As MethodInfo = GetType(F).GetMethod("M1") ' Shared method with one argument of type C. Dim fmi3 As MethodInfo = GetType(F).GetMethod("M3") ' Shared method with an argument of type F and an ' argument of type C. Dim fmi4 As MethodInfo = GetType(F).GetMethod("M4") Console.WriteLine(vbLf & "An instance method on any type, with an argument of type C.") ' D can represent any instance method that exactly matches its ' signature. Methods on C and F are shown here. ' d = CType([Delegate].CreateDelegate(GetType(D), c1, cmi1), D) d(c2) d = CType([Delegate].CreateDelegate(GetType(D), f1, fmi1), D) d(c2) Console.WriteLine(vbLf & "An instance method on C with no arguments.") ' D can represent an instance method on C that has no arguments; ' in this case, the argument of D represents the hidden first ' argument of any instance method. The delegate acts like a ' Shared method, and an instance of C must be passed each time ' it is invoked. ' d = CType([Delegate].CreateDelegate(GetType(D), Nothing, cmi2), D) d(c1) Console.WriteLine(vbLf & "A Shared method on any type, with an argument of type C.") ' D can represent any Shared method with the same signature. ' Methods on F and C are shown here. ' d = CType([Delegate].CreateDelegate(GetType(D), Nothing, cmi3), D) d(c1) d = CType([Delegate].CreateDelegate(GetType(D), Nothing, fmi3), D) d(c1) Console.WriteLine(vbLf & "A Shared method on any type, with an argument of") Console.WriteLine(" that type and an argument of type C.") ' D can represent any Shared method with one argument of the ' type the method belongs and a second argument of type C. ' In this case, the method is closed over the instance of ' supplied for the its first argument, and acts like an instance ' method. Methods on F and C are shown here. ' d = CType([Delegate].CreateDelegate(GetType(D), c1, cmi4), D) d(c2) Dim test As [Delegate] = [Delegate].CreateDelegate(GetType(D), f1, fmi4, False) ' This final example specifies False for throwOnBindFailure ' in the call to CreateDelegate, so the variable 'test' ' contains Nothing if the method fails to bind (for ' example, if fmi4 happened to represent a method of ' some class other than F). ' If test IsNot Nothing Then d = CType(test, D) d(c2) End If End Sub End Class ' This code example produces the following output: ' 'An instance method on any type, with an argument of type C. 'Instance method M1(c As C) on C: this.id = 42, c.ID = 1491 'Instance method M1(c As C) on F: c.ID = 1491 ' 'An instance method on C with no arguments. 'Instance method M2() on C: this.id = 42 ' 'A Shared method on any type, with an argument of type C. 'Shared method M3(c As C) on C: c.ID = 42 'Shared method M3(c As C) on F: c.ID = 42 ' 'A Shared method on any type, with an argument of ' that type and an argument of type C. 'Shared method M4(c1 As C, c2 As C) on C: c1.ID = 42, c2.ID = 1491 'Shared method M4(f As F, c As C) on F: c.ID = 1491 '
3 can represent an instance method of
open System open System.Reflection // A sample class with an instance method and a static method. type C(id) = member _.M1(s) = printfn $"Instance method M1 on C: id = %i{id}, s = %s{s}" static member M2(s) = printfn $"Static method M2 on C: s = %s{s}" // Declare three delegate types for demonstrating the combinations // of static versus instance methods and open versus closed // delegates. type D1 = delegate of C * string -> unit type D2 = delegate of string -> unit type D3 = delegate of unit -> unit let c1 = C 42 // Get a MethodInfo for each method. // let mi1 = typeof.GetMethod("M1", BindingFlags.Public ||| BindingFlags.Instance) let mi2 = typeof.GetMethod("M2", BindingFlags.Public ||| BindingFlags.Static) printfn "\nAn instance method closed over C." // In this case, the delegate and the // method must have the same list of argument types use // delegate type D2 with instance method M1. let test = Delegate.CreateDelegate(typeof, c1, mi1, false) // Because false was specified for throwOnBindFailure // in the call to CreateDelegate, the variable 'test' // contains null if the method fails to bind (for // example, if mi1 happened to represent a method of // some class other than C). if test <> null then let d2 = test :?> D2 // The same instance of C is used every time the // delegate is invoked. d2.Invoke "Hello, World!" d2.Invoke "Hi, Mom!" printfn "\nAn open instance method." // In this case, the delegate has one more // argument than the instance method this argument comes // at the beginning, and represents the hidden instance // argument of the instance method. Use delegate type D1 // with instance method M1. let d1 = Delegate.CreateDelegate(typeof, null, mi1) :?> D1 // An instance of C must be passed in each time the // delegate is invoked. d1.Invoke(c1, "Hello, World!") d1.Invoke(C 5280, "Hi, Mom!") printfn "\nAn open static method." // In this case, the delegate and the method must // have the same list of argument types use delegate type // D2 with static method M2. let d2 = Delegate.CreateDelegate(typeof, null, mi2) :?> D2 // No instances of C are involved, because this is a static // method. d2.Invoke "Hello, World!" d2.Invoke "Hi, Mom!" printfn "\nA static method closed over the first argument (String)." // The delegate must omit the first argument of the method. // A string is passed as the firstArgument parameter, and // the delegate is bound to this string. Use delegate type // D3 with static method M2. let d3 = Delegate.CreateDelegate(typeof, "Hello, World!", mi2) :?> D3 // Each time the delegate is invoked, the same string is used. d3.Invoke() // This code example produces the following output: // An instance method closed over C. // Instance method M1 on C: id = 42, s = Hello, World! // Instance method M1 on C: id = 42, s = Hi, Mom! // // An open instance method. // Instance method M1 on C: id = 42, s = Hello, World! // Instance method M1 on C: id = 5280, s = Hi, Mom! // // An open static method. // Static method M2 on C: s = Hello, World! // Static method M2 on C: s = Hi, Mom! // // A static method closed over the first argument (String). // Static method M2 on C: s = Hello, World!
1 that has no arguments. When CreateDelegate is called,
open System open System.Reflection // Define two classes to use in the demonstration, a base class and // a class that derives from it. type Base() = class end type Derived() = inherit Base() // Define a static method to use in the demonstration. The method // takes an instance of Base and returns an instance of Derived. // For the purposes of the demonstration, it is not necessary for // the method to do anything useful. static member MyMethod(arg: Base) = Derived() // Define a delegate that takes an instance of Derived and returns an // instance of Base. type Example = delegate of Derived -> Base // The binding flags needed to retrieve MyMethod. let flags = BindingFlags.Public ||| BindingFlags.Static // Get a MethodInfo that represents MyMethod. let minfo = typeof.GetMethod("MyMethod", flags) // Demonstrate contravariance of parameter types and covariance // of return types by using the delegate Example to represent // MyMethod. The delegate binds to the method because the // parameter of the delegate is more restrictive than the // parameter of the method (that is, the delegate accepts an // instance of Derived, which can always be safely passed to // a parameter of type Base), and the return type of MyMethod // is more restrictive than the return type of Example (that // is, the method returns an instance of Derived, which can // always be safely cast to type Base). let ex = Delegate.CreateDelegate(typeof, minfo) :?> Example // Execute MyMethod using the delegate Example. let b = Derived() |> ex.Invoke
4 is a null reference. The resulting delegate represents an open instance method, and an instance of
open System open System.Reflection // A sample class with an instance method and a static method. type C(id) = member _.M1(s) = printfn $"Instance method M1 on C: id = %i{id}, s = %s{s}" static member M2(s) = printfn $"Static method M2 on C: s = %s{s}" // Declare three delegate types for demonstrating the combinations // of static versus instance methods and open versus closed // delegates. type D1 = delegate of C * string -> unit type D2 = delegate of string -> unit type D3 = delegate of unit -> unit let c1 = C 42 // Get a MethodInfo for each method. // let mi1 = typeof.GetMethod("M1", BindingFlags.Public ||| BindingFlags.Instance) let mi2 = typeof.GetMethod("M2", BindingFlags.Public ||| BindingFlags.Static) printfn "\nAn instance method closed over C." // In this case, the delegate and the // method must have the same list of argument types use // delegate type D2 with instance method M1. let test = Delegate.CreateDelegate(typeof, c1, mi1, false) // Because false was specified for throwOnBindFailure // in the call to CreateDelegate, the variable 'test' // contains null if the method fails to bind (for // example, if mi1 happened to represent a method of // some class other than C). if test <> null then let d2 = test :?> D2 // The same instance of C is used every time the // delegate is invoked. d2.Invoke "Hello, World!" d2.Invoke "Hi, Mom!" printfn "\nAn open instance method." // In this case, the delegate has one more // argument than the instance method this argument comes // at the beginning, and represents the hidden instance // argument of the instance method. Use delegate type D1 // with instance method M1. let d1 = Delegate.CreateDelegate(typeof, null, mi1) :?> D1 // An instance of C must be passed in each time the // delegate is invoked. d1.Invoke(c1, "Hello, World!") d1.Invoke(C 5280, "Hi, Mom!") printfn "\nAn open static method." // In this case, the delegate and the method must // have the same list of argument types use delegate type // D2 with static method M2. let d2 = Delegate.CreateDelegate(typeof, null, mi2) :?> D2 // No instances of C are involved, because this is a static // method. d2.Invoke "Hello, World!" d2.Invoke "Hi, Mom!" printfn "\nA static method closed over the first argument (String)." // The delegate must omit the first argument of the method. // A string is passed as the firstArgument parameter, and // the delegate is bound to this string. Use delegate type // D3 with static method M2. let d3 = Delegate.CreateDelegate(typeof, "Hello, World!", mi2) :?> D3 // Each time the delegate is invoked, the same string is used. d3.Invoke() // This code example produces the following output: // An instance method closed over C. // Instance method M1 on C: id = 42, s = Hello, World! // Instance method M1 on C: id = 42, s = Hi, Mom! // // An open instance method. // Instance method M1 on C: id = 42, s = Hello, World! // Instance method M1 on C: id = 5280, s = Hi, Mom! // // An open static method. // Static method M2 on C: s = Hello, World! // Static method M2 on C: s = Hi, Mom! // // A static method closed over the first argument (String). // Static method M2 on C: s = Hello, World! 1 must be supplied each time it is invoked.
Imports System.Reflection Imports System.Security.Permissions ' Declare a delegate type. The object of this code example ' is to show all the methods this delegate can bind to. ' Public Delegate Sub D(ByVal c As C) ' Declare two sample classes, C and F. Class C has an ID ' property so instances can be identified. ' Public Class C Private id As Integer Public ReadOnly Property ID() As Integer Get Return _id End Get End Property Public Sub New(ByVal newId As Integer) Me._id = newId End Sub Public Sub M1(ByVal c As C) Console.WriteLine("Instance method M1(c As C) on C: this.id = {0}, c.ID = {1}", Me.id, c.ID) End Sub Public Sub M2() Console.WriteLine("Instance method M2() on C: this.id = {0}", Me.id) End Sub Public Shared Sub M3(ByVal c As C) Console.WriteLine("Shared method M3(c As C) on C: c.ID = {0}", c.ID) End Sub Public Shared Sub M4(ByVal c1 As C, ByVal c2 As C) Console.WriteLine("Shared method M4(c1 As C, c2 As C) on C: c1.ID = {0}, c2.ID = {1}", _ c1.ID, c2.ID) End Sub End Class Public Class F Public Sub M1(ByVal c As C) Console.WriteLine("Instance method M1(c As C) on F: c.ID = {0}", c.ID) End Sub Public Shared Sub M3(ByVal c As C) Console.WriteLine("Shared method M3(c As C) on F: c.ID = {0}", c.ID) End Sub Public Shared Sub M4(ByVal f As F, ByVal c As C) Console.WriteLine("Shared method M4(f As F, c As C) on F: c.ID = {0}", c.ID) End Sub End Class Public Class Example5 Public Shared Sub Main() Dim c1 As New C(42) Dim c2 As New C(1491) Dim f1 As New F() Dim d As D ' Instance method with one argument of type C. Dim cmi1 As MethodInfo = GetType(C).GetMethod("M1") ' Instance method with no arguments. Dim cmi2 As MethodInfo = GetType(C).GetMethod("M2") ' Shared method with one argument of type C. Dim cmi3 As MethodInfo = GetType(C).GetMethod("M3") ' Shared method with two arguments of type C. Dim cmi4 As MethodInfo = GetType(C).GetMethod("M4") ' Instance method with one argument of type C. Dim fmi1 As MethodInfo = GetType(F).GetMethod("M1") ' Shared method with one argument of type C. Dim fmi3 As MethodInfo = GetType(F).GetMethod("M3") ' Shared method with an argument of type F and an ' argument of type C. Dim fmi4 As MethodInfo = GetType(F).GetMethod("M4") Console.WriteLine(vbLf & "An instance method on any type, with an argument of type C.") ' D can represent any instance method that exactly matches its ' signature. Methods on C and F are shown here. ' d = CType([Delegate].CreateDelegate(GetType(D), c1, cmi1), D) d(c2) d = CType([Delegate].CreateDelegate(GetType(D), f1, fmi1), D) d(c2) Console.WriteLine(vbLf & "An instance method on C with no arguments.") ' D can represent an instance method on C that has no arguments; ' in this case, the argument of D represents the hidden first ' argument of any instance method. The delegate acts like a ' Shared method, and an instance of C must be passed each time ' it is invoked. ' d = CType([Delegate].CreateDelegate(GetType(D), Nothing, cmi2), D) d(c1) Console.WriteLine(vbLf & "A Shared method on any type, with an argument of type C.") ' D can represent any Shared method with the same signature. ' Methods on F and C are shown here. ' d = CType([Delegate].CreateDelegate(GetType(D), Nothing, cmi3), D) d(c1) d = CType([Delegate].CreateDelegate(GetType(D), Nothing, fmi3), D) d(c1) Console.WriteLine(vbLf & "A Shared method on any type, with an argument of") Console.WriteLine(" that type and an argument of type C.") ' D can represent any Shared method with one argument of the ' type the method belongs and a second argument of type C. ' In this case, the method is closed over the instance of ' supplied for the its first argument, and acts like an instance ' method. Methods on F and C are shown here. ' d = CType([Delegate].CreateDelegate(GetType(D), c1, cmi4), D) d(c2) Dim test As [Delegate] = [Delegate].CreateDelegate(GetType(D), f1, fmi4, False) ' This final example specifies False for throwOnBindFailure ' in the call to CreateDelegate, so the variable 'test' ' contains Nothing if the method fails to bind (for ' example, if fmi4 happened to represent a method of ' some class other than F). ' If test IsNot Nothing Then d = CType(test, D) d(c2) End If End Sub End Class ' This code example produces the following output: ' 'An instance method on any type, with an argument of type C. 'Instance method M1(c As C) on C: this.id = 42, c.ID = 1491 'Instance method M1(c As C) on F: c.ID = 1491 ' 'An instance method on C with no arguments. 'Instance method M2() on C: this.id = 42 ' 'A Shared method on any type, with an argument of type C. 'Shared method M3(c As C) on C: c.ID = 42 'Shared method M3(c As C) on F: c.ID = 42 ' 'A Shared method on any type, with an argument of ' that type and an argument of type C. 'Shared method M4(c1 As C, c2 As C) on C: c1.ID = 42, c2.ID = 1491 'Shared method M4(f As F, c As C) on F: c.ID = 1491 '
3 can represent a static method that takes one argument of type
open System open System.Reflection // A sample class with an instance method and a static method. type C(id) = member _.M1(s) = printfn $"Instance method M1 on C: id = %i{id}, s = %s{s}" static member M2(s) = printfn $"Static method M2 on C: s = %s{s}" // Declare three delegate types for demonstrating the combinations // of static versus instance methods and open versus closed // delegates. type D1 = delegate of C * string -> unit type D2 = delegate of string -> unit type D3 = delegate of unit -> unit let c1 = C 42 // Get a MethodInfo for each method. // let mi1 = typeof.GetMethod("M1", BindingFlags.Public ||| BindingFlags.Instance) let mi2 = typeof.GetMethod("M2", BindingFlags.Public ||| BindingFlags.Static) printfn "\nAn instance method closed over C." // In this case, the delegate and the // method must have the same list of argument types use // delegate type D2 with instance method M1. let test = Delegate.CreateDelegate(typeof, c1, mi1, false) // Because false was specified for throwOnBindFailure // in the call to CreateDelegate, the variable 'test' // contains null if the method fails to bind (for // example, if mi1 happened to represent a method of // some class other than C). if test <> null then let d2 = test :?> D2 // The same instance of C is used every time the // delegate is invoked. d2.Invoke "Hello, World!" d2.Invoke "Hi, Mom!" printfn "\nAn open instance method." // In this case, the delegate has one more // argument than the instance method this argument comes // at the beginning, and represents the hidden instance // argument of the instance method. Use delegate type D1 // with instance method M1. let d1 = Delegate.CreateDelegate(typeof, null, mi1) :?> D1 // An instance of C must be passed in each time the // delegate is invoked. d1.Invoke(c1, "Hello, World!") d1.Invoke(C 5280, "Hi, Mom!") printfn "\nAn open static method." // In this case, the delegate and the method must // have the same list of argument types use delegate type // D2 with static method M2. let d2 = Delegate.CreateDelegate(typeof, null, mi2) :?> D2 // No instances of C are involved, because this is a static // method. d2.Invoke "Hello, World!" d2.Invoke "Hi, Mom!" printfn "\nA static method closed over the first argument (String)." // The delegate must omit the first argument of the method. // A string is passed as the firstArgument parameter, and // the delegate is bound to this string. Use delegate type // D3 with static method M2. let d3 = Delegate.CreateDelegate(typeof, "Hello, World!", mi2) :?> D3 // Each time the delegate is invoked, the same string is used. d3.Invoke() // This code example produces the following output: // An instance method closed over C. // Instance method M1 on C: id = 42, s = Hello, World! // Instance method M1 on C: id = 42, s = Hi, Mom! // // An open instance method. // Instance method M1 on C: id = 42, s = Hello, World! // Instance method M1 on C: id = 5280, s = Hi, Mom! // // An open static method. // Static method M2 on C: s = Hello, World! // Static method M2 on C: s = Hi, Mom! // // A static method closed over the first argument (String). // Static method M2 on C: s = Hello, World!
1, and that method can belong to any type. When CreateDelegate is called,
open System open System.Reflection // Define two classes to use in the demonstration, a base class and // a class that derives from it. type Base() = class end type Derived() = inherit Base() // Define a static method to use in the demonstration. The method // takes an instance of Base and returns an instance of Derived. // For the purposes of the demonstration, it is not necessary for // the method to do anything useful. static member MyMethod(arg: Base) = Derived() // Define a delegate that takes an instance of Derived and returns an // instance of Base. type Example = delegate of Derived -> Base // The binding flags needed to retrieve MyMethod. let flags = BindingFlags.Public ||| BindingFlags.Static // Get a MethodInfo that represents MyMethod. let minfo = typeof.GetMethod("MyMethod", flags) // Demonstrate contravariance of parameter types and covariance // of return types by using the delegate Example to represent // MyMethod. The delegate binds to the method because the // parameter of the delegate is more restrictive than the // parameter of the method (that is, the delegate accepts an // instance of Derived, which can always be safely passed to // a parameter of type Base), and the return type of MyMethod // is more restrictive than the return type of Example (that // is, the method returns an instance of Derived, which can // always be safely cast to type Base). let ex = Delegate.CreateDelegate(typeof, minfo) :?> Example // Execute MyMethod using the delegate Example. let b = Derived() |> ex.Invoke
4 is a null reference. The resulting delegate represents an open static method, and an instance of
open System open System.Reflection // A sample class with an instance method and a static method. type C(id) = member _.M1(s) = printfn $"Instance method M1 on C: id = %i{id}, s = %s{s}" static member M2(s) = printfn $"Static method M2 on C: s = %s{s}" // Declare three delegate types for demonstrating the combinations // of static versus instance methods and open versus closed // delegates. type D1 = delegate of C * string -> unit type D2 = delegate of string -> unit type D3 = delegate of unit -> unit let c1 = C 42 // Get a MethodInfo for each method. // let mi1 = typeof.GetMethod("M1", BindingFlags.Public ||| BindingFlags.Instance) let mi2 = typeof.GetMethod("M2", BindingFlags.Public ||| BindingFlags.Static) printfn "\nAn instance method closed over C." // In this case, the delegate and the // method must have the same list of argument types use // delegate type D2 with instance method M1. let test = Delegate.CreateDelegate(typeof, c1, mi1, false) // Because false was specified for throwOnBindFailure // in the call to CreateDelegate, the variable 'test' // contains null if the method fails to bind (for // example, if mi1 happened to represent a method of // some class other than C). if test <> null then let d2 = test :?> D2 // The same instance of C is used every time the // delegate is invoked. d2.Invoke "Hello, World!" d2.Invoke "Hi, Mom!" printfn "\nAn open instance method." // In this case, the delegate has one more // argument than the instance method this argument comes // at the beginning, and represents the hidden instance // argument of the instance method. Use delegate type D1 // with instance method M1. let d1 = Delegate.CreateDelegate(typeof, null, mi1) :?> D1 // An instance of C must be passed in each time the // delegate is invoked. d1.Invoke(c1, "Hello, World!") d1.Invoke(C 5280, "Hi, Mom!") printfn "\nAn open static method." // In this case, the delegate and the method must // have the same list of argument types use delegate type // D2 with static method M2. let d2 = Delegate.CreateDelegate(typeof, null, mi2) :?> D2 // No instances of C are involved, because this is a static // method. d2.Invoke "Hello, World!" d2.Invoke "Hi, Mom!" printfn "\nA static method closed over the first argument (String)." // The delegate must omit the first argument of the method. // A string is passed as the firstArgument parameter, and // the delegate is bound to this string. Use delegate type // D3 with static method M2. let d3 = Delegate.CreateDelegate(typeof, "Hello, World!", mi2) :?> D3 // Each time the delegate is invoked, the same string is used. d3.Invoke() // This code example produces the following output: // An instance method closed over C. // Instance method M1 on C: id = 42, s = Hello, World! // Instance method M1 on C: id = 42, s = Hi, Mom! // // An open instance method. // Instance method M1 on C: id = 42, s = Hello, World! // Instance method M1 on C: id = 5280, s = Hi, Mom! // // An open static method. // Static method M2 on C: s = Hello, World! // Static method M2 on C: s = Hi, Mom! // // A static method closed over the first argument (String). // Static method M2 on C: s = Hello, World! 1 must be supplied each time it is invoked.

Imports System.Reflection Imports System.Security.Permissions
' Declare a delegate type. The object of this code example
' is to show all the methods this delegate can bind to.
'
Public Delegate Sub D(ByVal c As C)
' Declare two sample classes, C and F. Class C has an ID
' property so instances can be identified.
'
Public Class C 
Private id As Integer  
Public ReadOnly Property ID() As Integer  
    Get  
        Return _id  
    End Get  
End Property  
Public Sub New(ByVal newId As Integer)  
    Me._id = newId  
End Sub  
Public Sub M1(ByVal c As C)  
    Console.WriteLine("Instance method M1(c As C) on C:  this.id = {0}, c.ID = {1}",   
        Me.id, c.ID)  
End Sub  
Public Sub M2()  
    Console.WriteLine("Instance method M2() on C:  this.id = {0}", Me.id)  
End Sub  
Public Shared Sub M3(ByVal c As C)  
    Console.WriteLine("Shared method M3(c As C) on C:  c.ID = {0}", c.ID)  
End Sub  
Public Shared Sub M4(ByVal c1 As C, ByVal c2 As C)  
    Console.WriteLine("Shared method M4(c1 As C, c2 As C) on C:  c1.ID = {0}, c2.ID = {1}", _  
        c1.ID, c2.ID)  
End Sub  
End Class
Public Class F Public Sub M1(ByVal c As C)  
    Console.WriteLine("Instance method M1(c As C) on F:  c.ID = {0}", c.ID)  
End Sub  
Public Shared Sub M3(ByVal c As C)  
    Console.WriteLine("Shared method M3(c As C) on F:  c.ID = {0}", c.ID)  
End Sub  
Public Shared Sub M4(ByVal f As F, ByVal c As C)  
    Console.WriteLine("Shared method M4(f As F, c As C) on F:  c.ID = {0}", c.ID)  
End Sub  
End Class
Public Class Example5 Public Shared Sub Main()  
    Dim c1 As New C(42)  
    Dim c2 As New C(1491)  
    Dim f1 As New F()  
    Dim d As D  
    ' Instance method with one argument of type C.  
    Dim cmi1 As MethodInfo = GetType(C).GetMethod("M1")  
    ' Instance method with no arguments.  
    Dim cmi2 As MethodInfo = GetType(C).GetMethod("M2")  
    ' Shared method with one argument of type C.  
    Dim cmi3 As MethodInfo = GetType(C).GetMethod("M3")  
    ' Shared method with two arguments of type C.  
    Dim cmi4 As MethodInfo = GetType(C).GetMethod("M4")  
    ' Instance method with one argument of type C.  
    Dim fmi1 As MethodInfo = GetType(F).GetMethod("M1")  
    ' Shared method with one argument of type C.  
    Dim fmi3 As MethodInfo = GetType(F).GetMethod("M3")  
    ' Shared method with an argument of type F and an  
    ' argument of type C.  
    Dim fmi4 As MethodInfo = GetType(F).GetMethod("M4")  
    Console.WriteLine(vbLf & "An instance method on any type, with an argument of type C.")  
    ' D can represent any instance method that exactly matches its  
    ' signature. Methods on C and F are shown here.  
    '  
    d = CType([Delegate].CreateDelegate(GetType(D), c1, cmi1), D)  
    d(c2)  
    d = CType([Delegate].CreateDelegate(GetType(D), f1, fmi1), D)  
    d(c2)  
    Console.WriteLine(vbLf & "An instance method on C with no arguments.")  
    ' D can represent an instance method on C that has no arguments;  
    ' in this case, the argument of D represents the hidden first  
    ' argument of any instance method. The delegate acts like a  
    ' Shared method, and an instance of C must be passed each time  
    ' it is invoked.  
    '  
    d = CType([Delegate].CreateDelegate(GetType(D), Nothing, cmi2), D)  
    d(c1)  
    Console.WriteLine(vbLf & "A Shared method on any type, with an argument of type C.")  
    ' D can represent any Shared method with the same signature.  
    ' Methods on F and C are shown here.  
    '  
    d = CType([Delegate].CreateDelegate(GetType(D), Nothing, cmi3), D)  
    d(c1)  
    d = CType([Delegate].CreateDelegate(GetType(D), Nothing, fmi3), D)  
    d(c1)  
    Console.WriteLine(vbLf & "A Shared method on any type, with an argument of")  
    Console.WriteLine("    that type and an argument of type C.")  
    ' D can represent any Shared method with one argument of the  
    ' type the method belongs and a second argument of type C.  
    ' In this case, the method is closed over the instance of  
    ' supplied for the its first argument, and acts like an instance  
    ' method. Methods on F and C are shown here.  
    '  
    d = CType([Delegate].CreateDelegate(GetType(D), c1, cmi4), D)  
    d(c2)  
    Dim test As [Delegate] =  
        [Delegate].CreateDelegate(GetType(D), f1, fmi4, False)  
    ' This final example specifies False for throwOnBindFailure  
    ' in the call to CreateDelegate, so the variable 'test'  
    ' contains Nothing if the method fails to bind (for  
    ' example, if fmi4 happened to represent a method of  
    ' some class other than F).  
    '  
    If test IsNot Nothing Then  
        d = CType(test, D)  
        d(c2)  
    End If  
End Sub  
End Class
' This code example produces the following output:
'
'An instance method on any type, with an argument of type C.
'Instance method M1(c As C) on C: this.id = 42, c.ID = 1491
'Instance method M1(c As C) on F: c.ID = 1491
'
'An instance method on C with no arguments.
'Instance method M2() on C: this.id = 42
'
'A Shared method on any type, with an argument of type C.
'Shared method M3(c As C) on C: c.ID = 42
'Shared method M3(c As C) on F: c.ID = 42
'
'A Shared method on any type, with an argument of
' that type and an argument of type C.
'Shared method M4(c1 As C, c2 As C) on C: c1.ID = 42, c2.ID = 1491
'Shared method M4(f As F, c As C) on F: c.ID = 1491
'

3 can represent a static method that belongs to type

Imports System.Reflection Imports System.Security.Permissions
' Declare a delegate type. The object of this code example
' is to show all the methods this delegate can bind to.
'
Public Delegate Sub D(ByVal c As C)
' Declare two sample classes, C and F. Class C has an ID
' property so instances can be identified.
'
Public Class C 
Private id As Integer  
Public ReadOnly Property ID() As Integer  
    Get  
        Return _id  
    End Get  
End Property  
Public Sub New(ByVal newId As Integer)  
    Me._id = newId  
End Sub  
Public Sub M1(ByVal c As C)  
    Console.WriteLine("Instance method M1(c As C) on C:  this.id = {0}, c.ID = {1}",   
        Me.id, c.ID)  
End Sub  
Public Sub M2()  
    Console.WriteLine("Instance method M2() on C:  this.id = {0}", Me.id)  
End Sub  
Public Shared Sub M3(ByVal c As C)  
    Console.WriteLine("Shared method M3(c As C) on C:  c.ID = {0}", c.ID)  
End Sub  
Public Shared Sub M4(ByVal c1 As C, ByVal c2 As C)  
    Console.WriteLine("Shared method M4(c1 As C, c2 As C) on C:  c1.ID = {0}, c2.ID = {1}", _  
        c1.ID, c2.ID)  
End Sub  
End Class
Public Class F Public Sub M1(ByVal c As C)  
    Console.WriteLine("Instance method M1(c As C) on F:  c.ID = {0}", c.ID)  
End Sub  
Public Shared Sub M3(ByVal c As C)  
    Console.WriteLine("Shared method M3(c As C) on F:  c.ID = {0}", c.ID)  
End Sub  
Public Shared Sub M4(ByVal f As F, ByVal c As C)  
    Console.WriteLine("Shared method M4(f As F, c As C) on F:  c.ID = {0}", c.ID)  
End Sub  
End Class
Public Class Example5 Public Shared Sub Main()  
    Dim c1 As New C(42)  
    Dim c2 As New C(1491)  
    Dim f1 As New F()  
    Dim d As D  
    ' Instance method with one argument of type C.  
    Dim cmi1 As MethodInfo = GetType(C).GetMethod("M1")  
    ' Instance method with no arguments.  
    Dim cmi2 As MethodInfo = GetType(C).GetMethod("M2")  
    ' Shared method with one argument of type C.  
    Dim cmi3 As MethodInfo = GetType(C).GetMethod("M3")  
    ' Shared method with two arguments of type C.  
    Dim cmi4 As MethodInfo = GetType(C).GetMethod("M4")  
    ' Instance method with one argument of type C.  
    Dim fmi1 As MethodInfo = GetType(F).GetMethod("M1")  
    ' Shared method with one argument of type C.  
    Dim fmi3 As MethodInfo = GetType(F).GetMethod("M3")  
    ' Shared method with an argument of type F and an  
    ' argument of type C.  
    Dim fmi4 As MethodInfo = GetType(F).GetMethod("M4")  
    Console.WriteLine(vbLf & "An instance method on any type, with an argument of type C.")  
    ' D can represent any instance method that exactly matches its  
    ' signature. Methods on C and F are shown here.  
    '  
    d = CType([Delegate].CreateDelegate(GetType(D), c1, cmi1), D)  
    d(c2)  
    d = CType([Delegate].CreateDelegate(GetType(D), f1, fmi1), D)  
    d(c2)  
    Console.WriteLine(vbLf & "An instance method on C with no arguments.")  
    ' D can represent an instance method on C that has no arguments;  
    ' in this case, the argument of D represents the hidden first  
    ' argument of any instance method. The delegate acts like a  
    ' Shared method, and an instance of C must be passed each time  
    ' it is invoked.  
    '  
    d = CType([Delegate].CreateDelegate(GetType(D), Nothing, cmi2), D)  
    d(c1)  
    Console.WriteLine(vbLf & "A Shared method on any type, with an argument of type C.")  
    ' D can represent any Shared method with the same signature.  
    ' Methods on F and C are shown here.  
    '  
    d = CType([Delegate].CreateDelegate(GetType(D), Nothing, cmi3), D)  
    d(c1)  
    d = CType([Delegate].CreateDelegate(GetType(D), Nothing, fmi3), D)  
    d(c1)  
    Console.WriteLine(vbLf & "A Shared method on any type, with an argument of")  
    Console.WriteLine("    that type and an argument of type C.")  
    ' D can represent any Shared method with one argument of the  
    ' type the method belongs and a second argument of type C.  
    ' In this case, the method is closed over the instance of  
    ' supplied for the its first argument, and acts like an instance  
    ' method. Methods on F and C are shown here.  
    '  
    d = CType([Delegate].CreateDelegate(GetType(D), c1, cmi4), D)  
    d(c2)  
    Dim test As [Delegate] =  
        [Delegate].CreateDelegate(GetType(D), f1, fmi4, False)  
    ' This final example specifies False for throwOnBindFailure  
    ' in the call to CreateDelegate, so the variable 'test'  
    ' contains Nothing if the method fails to bind (for  
    ' example, if fmi4 happened to represent a method of  
    ' some class other than F).  
    '  
    If test IsNot Nothing Then  
        d = CType(test, D)  
        d(c2)  
    End If  
End Sub  
End Class
' This code example produces the following output:
'
'An instance method on any type, with an argument of type C.
'Instance method M1(c As C) on C: this.id = 42, c.ID = 1491
'Instance method M1(c As C) on F: c.ID = 1491
'
'An instance method on C with no arguments.
'Instance method M2() on C: this.id = 42
'
'A Shared method on any type, with an argument of type C.
'Shared method M3(c As C) on C: c.ID = 42
'Shared method M3(c As C) on F: c.ID = 42
'
'A Shared method on any type, with an argument of
' that type and an argument of type C.
'Shared method M4(c1 As C, c2 As C) on C: c1.ID = 42, c2.ID = 1491
'Shared method M4(f As F, c As C) on F: c.ID = 1491
'

2 and has two arguments, of type

Imports System.Reflection Imports System.Security.Permissions
' Declare a delegate type. The object of this code example
' is to show all the methods this delegate can bind to.
'
Public Delegate Sub D(ByVal c As C)
' Declare two sample classes, C and F. Class C has an ID
' property so instances can be identified.
'
Public Class C 
Private id As Integer  
Public ReadOnly Property ID() As Integer  
    Get  
        Return _id  
    End Get  
End Property  
Public Sub New(ByVal newId As Integer)  
    Me._id = newId  
End Sub  
Public Sub M1(ByVal c As C)  
    Console.WriteLine("Instance method M1(c As C) on C:  this.id = {0}, c.ID = {1}",   
        Me.id, c.ID)  
End Sub  
Public Sub M2()  
    Console.WriteLine("Instance method M2() on C:  this.id = {0}", Me.id)  
End Sub  
Public Shared Sub M3(ByVal c As C)  
    Console.WriteLine("Shared method M3(c As C) on C:  c.ID = {0}", c.ID)  
End Sub  
Public Shared Sub M4(ByVal c1 As C, ByVal c2 As C)  
    Console.WriteLine("Shared method M4(c1 As C, c2 As C) on C:  c1.ID = {0}, c2.ID = {1}", _  
        c1.ID, c2.ID)  
End Sub  
End Class
Public Class F Public Sub M1(ByVal c As C)  
    Console.WriteLine("Instance method M1(c As C) on F:  c.ID = {0}", c.ID)  
End Sub  
Public Shared Sub M3(ByVal c As C)  
    Console.WriteLine("Shared method M3(c As C) on F:  c.ID = {0}", c.ID)  
End Sub  
Public Shared Sub M4(ByVal f As F, ByVal c As C)  
    Console.WriteLine("Shared method M4(f As F, c As C) on F:  c.ID = {0}", c.ID)  
End Sub  
End Class
Public Class Example5 Public Shared Sub Main()  
    Dim c1 As New C(42)  
    Dim c2 As New C(1491)  
    Dim f1 As New F()  
    Dim d As D  
    ' Instance method with one argument of type C.  
    Dim cmi1 As MethodInfo = GetType(C).GetMethod("M1")  
    ' Instance method with no arguments.  
    Dim cmi2 As MethodInfo = GetType(C).GetMethod("M2")  
    ' Shared method with one argument of type C.  
    Dim cmi3 As MethodInfo = GetType(C).GetMethod("M3")  
    ' Shared method with two arguments of type C.  
    Dim cmi4 As MethodInfo = GetType(C).GetMethod("M4")  
    ' Instance method with one argument of type C.  
    Dim fmi1 As MethodInfo = GetType(F).GetMethod("M1")  
    ' Shared method with one argument of type C.  
    Dim fmi3 As MethodInfo = GetType(F).GetMethod("M3")  
    ' Shared method with an argument of type F and an  
    ' argument of type C.  
    Dim fmi4 As MethodInfo = GetType(F).GetMethod("M4")  
    Console.WriteLine(vbLf & "An instance method on any type, with an argument of type C.")  
    ' D can represent any instance method that exactly matches its  
    ' signature. Methods on C and F are shown here.  
    '  
    d = CType([Delegate].CreateDelegate(GetType(D), c1, cmi1), D)  
    d(c2)  
    d = CType([Delegate].CreateDelegate(GetType(D), f1, fmi1), D)  
    d(c2)  
    Console.WriteLine(vbLf & "An instance method on C with no arguments.")  
    ' D can represent an instance method on C that has no arguments;  
    ' in this case, the argument of D represents the hidden first  
    ' argument of any instance method. The delegate acts like a  
    ' Shared method, and an instance of C must be passed each time  
    ' it is invoked.  
    '  
    d = CType([Delegate].CreateDelegate(GetType(D), Nothing, cmi2), D)  
    d(c1)  
    Console.WriteLine(vbLf & "A Shared method on any type, with an argument of type C.")  
    ' D can represent any Shared method with the same signature.  
    ' Methods on F and C are shown here.  
    '  
    d = CType([Delegate].CreateDelegate(GetType(D), Nothing, cmi3), D)  
    d(c1)  
    d = CType([Delegate].CreateDelegate(GetType(D), Nothing, fmi3), D)  
    d(c1)  
    Console.WriteLine(vbLf & "A Shared method on any type, with an argument of")  
    Console.WriteLine("    that type and an argument of type C.")  
    ' D can represent any Shared method with one argument of the  
    ' type the method belongs and a second argument of type C.  
    ' In this case, the method is closed over the instance of  
    ' supplied for the its first argument, and acts like an instance  
    ' method. Methods on F and C are shown here.  
    '  
    d = CType([Delegate].CreateDelegate(GetType(D), c1, cmi4), D)  
    d(c2)  
    Dim test As [Delegate] =  
        [Delegate].CreateDelegate(GetType(D), f1, fmi4, False)  
    ' This final example specifies False for throwOnBindFailure  
    ' in the call to CreateDelegate, so the variable 'test'  
    ' contains Nothing if the method fails to bind (for  
    ' example, if fmi4 happened to represent a method of  
    ' some class other than F).  
    '  
    If test IsNot Nothing Then  
        d = CType(test, D)  
        d(c2)  
    End If  
End Sub  
End Class
' This code example produces the following output:
'
'An instance method on any type, with an argument of type C.
'Instance method M1(c As C) on C: this.id = 42, c.ID = 1491
'Instance method M1(c As C) on F: c.ID = 1491
'
'An instance method on C with no arguments.
'Instance method M2() on C: this.id = 42
'
'A Shared method on any type, with an argument of type C.
'Shared method M3(c As C) on C: c.ID = 42
'Shared method M3(c As C) on F: c.ID = 42
'
'A Shared method on any type, with an argument of
' that type and an argument of type C.
'Shared method M4(c1 As C, c2 As C) on C: c1.ID = 42, c2.ID = 1491
'Shared method M4(f As F, c As C) on F: c.ID = 1491
'

2 and type

open System open System.Reflection
// A sample class with an instance method and a static method.
type C(id) = 
member _.M1(s) =  
    printfn $"Instance method M1 on C:  id = %i{id}, s = %s{s}"  
static member M2(s) =  
    printfn $"Static method M2 on C:  s = %s{s}"  
// Declare three delegate types for demonstrating the combinations
// of static versus instance methods and open versus closed
// delegates.
type D1 = delegate of C * string -> unit
type D2 = delegate of string -> unit
type D3 = delegate of unit -> unit
let c1 = C 42
// Get a MethodInfo for each method.
//
let mi1 = typeof.GetMethod("M1", BindingFlags.Public ||| BindingFlags.Instance)
let mi2 = typeof.GetMethod("M2", BindingFlags.Public ||| BindingFlags.Static)
printfn "\nAn instance method closed over C."
// In this case, the delegate and the
// method must have the same list of argument types use
// delegate type D2 with instance method M1.
let test = Delegate.CreateDelegate(typeof, c1, mi1, false)
// Because false was specified for throwOnBindFailure
// in the call to CreateDelegate, the variable 'test'
// contains null if the method fails to bind (for
// example, if mi1 happened to represent a method of
// some class other than C).
if test <> null then let d2 = test :?> D2  
// The same instance of C is used every time the  
// delegate is invoked.  
d2.Invoke "Hello, World!"  
d2.Invoke "Hi, Mom!"  
printfn "\nAn open instance method."
// In this case, the delegate has one more
// argument than the instance method this argument comes
// at the beginning, and represents the hidden instance
// argument of the instance method. Use delegate type D1
// with instance method M1.
let d1 = Delegate.CreateDelegate(typeof, null, mi1) :?> D1
// An instance of C must be passed in each time the
// delegate is invoked.
d1.Invoke(c1, "Hello, World!")
d1.Invoke(C 5280, "Hi, Mom!")
printfn "\nAn open static method."
// In this case, the delegate and the method must
// have the same list of argument types use delegate type
// D2 with static method M2.
let d2 = Delegate.CreateDelegate(typeof, null, mi2) :?> D2
// No instances of C are involved, because this is a static
// method.
d2.Invoke "Hello, World!"
d2.Invoke "Hi, Mom!"
printfn "\nA static method closed over the first argument (String)."
// The delegate must omit the first argument of the method.
// A string is passed as the firstArgument parameter, and
// the delegate is bound to this string. Use delegate type
// D3 with static method M2.
let d3 = Delegate.CreateDelegate(typeof, "Hello, World!", mi2) :?> D3
// Each time the delegate is invoked, the same string is used.
d3.Invoke()
// This code example produces the following output:
// An instance method closed over C.
// Instance method M1 on C: id = 42, s = Hello, World!
// Instance method M1 on C: id = 42, s = Hi, Mom!
//
// An open instance method.
// Instance method M1 on C: id = 42, s = Hello, World!
// Instance method M1 on C: id = 5280, s = Hi, Mom!
//
// An open static method.
// Static method M2 on C: s = Hello, World!
// Static method M2 on C: s = Hi, Mom!
//
// A static method closed over the first argument (String).
// Static method M2 on C: s = Hello, World!

1. When CreateDelegate is called,

open System open System.Reflection
// Define two classes to use in the demonstration, a base class and
// a class that derives from it.
type Base() = class end
type Derived() = 
inherit Base()  
// Define a static method to use in the demonstration. The method  
// takes an instance of Base and returns an instance of Derived.  
// For the purposes of the demonstration, it is not necessary for  
// the method to do anything useful.  
static member MyMethod(arg: Base) =  
    Derived()  
// Define a delegate that takes an instance of Derived and returns an
// instance of Base.
type Example = delegate of Derived -> Base
// The binding flags needed to retrieve MyMethod.
let flags = BindingFlags.Public ||| BindingFlags.Static
// Get a MethodInfo that represents MyMethod.
let minfo = typeof.GetMethod("MyMethod", flags)
// Demonstrate contravariance of parameter types and covariance
// of return types by using the delegate Example to represent
// MyMethod. The delegate binds to the method because the
// parameter of the delegate is more restrictive than the
// parameter of the method (that is, the delegate accepts an
// instance of Derived, which can always be safely passed to
// a parameter of type Base), and the return type of MyMethod
// is more restrictive than the return type of Example (that
// is, the method returns an instance of Derived, which can
// always be safely cast to type Base).
let ex = Delegate.CreateDelegate(typeof, minfo) :?> Example
// Execute MyMethod using the delegate Example.
let b = Derived() |> ex.Invoke

4 is an instance of

Imports System.Reflection Imports System.Security.Permissions
' Declare a delegate type. The object of this code example
' is to show all the methods this delegate can bind to.
'
Public Delegate Sub D(ByVal c As C)
' Declare two sample classes, C and F. Class C has an ID
' property so instances can be identified.
'
Public Class C 
Private id As Integer  
Public ReadOnly Property ID() As Integer  
    Get  
        Return _id  
    End Get  
End Property  
Public Sub New(ByVal newId As Integer)  
    Me._id = newId  
End Sub  
Public Sub M1(ByVal c As C)  
    Console.WriteLine("Instance method M1(c As C) on C:  this.id = {0}, c.ID = {1}",   
        Me.id, c.ID)  
End Sub  
Public Sub M2()  
    Console.WriteLine("Instance method M2() on C:  this.id = {0}", Me.id)  
End Sub  
Public Shared Sub M3(ByVal c As C)  
    Console.WriteLine("Shared method M3(c As C) on C:  c.ID = {0}", c.ID)  
End Sub  
Public Shared Sub M4(ByVal c1 As C, ByVal c2 As C)  
    Console.WriteLine("Shared method M4(c1 As C, c2 As C) on C:  c1.ID = {0}, c2.ID = {1}", _  
        c1.ID, c2.ID)  
End Sub  
End Class
Public Class F Public Sub M1(ByVal c As C)  
    Console.WriteLine("Instance method M1(c As C) on F:  c.ID = {0}", c.ID)  
End Sub  
Public Shared Sub M3(ByVal c As C)  
    Console.WriteLine("Shared method M3(c As C) on F:  c.ID = {0}", c.ID)  
End Sub  
Public Shared Sub M4(ByVal f As F, ByVal c As C)  
    Console.WriteLine("Shared method M4(f As F, c As C) on F:  c.ID = {0}", c.ID)  
End Sub  
End Class
Public Class Example5 Public Shared Sub Main()  
    Dim c1 As New C(42)  
    Dim c2 As New C(1491)  
    Dim f1 As New F()  
    Dim d As D  
    ' Instance method with one argument of type C.  
    Dim cmi1 As MethodInfo = GetType(C).GetMethod("M1")  
    ' Instance method with no arguments.  
    Dim cmi2 As MethodInfo = GetType(C).GetMethod("M2")  
    ' Shared method with one argument of type C.  
    Dim cmi3 As MethodInfo = GetType(C).GetMethod("M3")  
    ' Shared method with two arguments of type C.  
    Dim cmi4 As MethodInfo = GetType(C).GetMethod("M4")  
    ' Instance method with one argument of type C.  
    Dim fmi1 As MethodInfo = GetType(F).GetMethod("M1")  
    ' Shared method with one argument of type C.  
    Dim fmi3 As MethodInfo = GetType(F).GetMethod("M3")  
    ' Shared method with an argument of type F and an  
    ' argument of type C.  
    Dim fmi4 As MethodInfo = GetType(F).GetMethod("M4")  
    Console.WriteLine(vbLf & "An instance method on any type, with an argument of type C.")  
    ' D can represent any instance method that exactly matches its  
    ' signature. Methods on C and F are shown here.  
    '  
    d = CType([Delegate].CreateDelegate(GetType(D), c1, cmi1), D)  
    d(c2)  
    d = CType([Delegate].CreateDelegate(GetType(D), f1, fmi1), D)  
    d(c2)  
    Console.WriteLine(vbLf & "An instance method on C with no arguments.")  
    ' D can represent an instance method on C that has no arguments;  
    ' in this case, the argument of D represents the hidden first  
    ' argument of any instance method. The delegate acts like a  
    ' Shared method, and an instance of C must be passed each time  
    ' it is invoked.  
    '  
    d = CType([Delegate].CreateDelegate(GetType(D), Nothing, cmi2), D)  
    d(c1)  
    Console.WriteLine(vbLf & "A Shared method on any type, with an argument of type C.")  
    ' D can represent any Shared method with the same signature.  
    ' Methods on F and C are shown here.  
    '  
    d = CType([Delegate].CreateDelegate(GetType(D), Nothing, cmi3), D)  
    d(c1)  
    d = CType([Delegate].CreateDelegate(GetType(D), Nothing, fmi3), D)  
    d(c1)  
    Console.WriteLine(vbLf & "A Shared method on any type, with an argument of")  
    Console.WriteLine("    that type and an argument of type C.")  
    ' D can represent any Shared method with one argument of the  
    ' type the method belongs and a second argument of type C.  
    ' In this case, the method is closed over the instance of  
    ' supplied for the its first argument, and acts like an instance  
    ' method. Methods on F and C are shown here.  
    '  
    d = CType([Delegate].CreateDelegate(GetType(D), c1, cmi4), D)  
    d(c2)  
    Dim test As [Delegate] =  
        [Delegate].CreateDelegate(GetType(D), f1, fmi4, False)  
    ' This final example specifies False for throwOnBindFailure  
    ' in the call to CreateDelegate, so the variable 'test'  
    ' contains Nothing if the method fails to bind (for  
    ' example, if fmi4 happened to represent a method of  
    ' some class other than F).  
    '  
    If test IsNot Nothing Then  
        d = CType(test, D)  
        d(c2)  
    End If  
End Sub  
End Class
' This code example produces the following output:
'
'An instance method on any type, with an argument of type C.
'Instance method M1(c As C) on C: this.id = 42, c.ID = 1491
'Instance method M1(c As C) on F: c.ID = 1491
'
'An instance method on C with no arguments.
'Instance method M2() on C: this.id = 42
'
'A Shared method on any type, with an argument of type C.
'Shared method M3(c As C) on C: c.ID = 42
'Shared method M3(c As C) on F: c.ID = 42
'
'A Shared method on any type, with an argument of
' that type and an argument of type C.
'Shared method M4(c1 As C, c2 As C) on C: c1.ID = 42, c2.ID = 1491
'Shared method M4(f As F, c As C) on F: c.ID = 1491
'

2. The resulting delegate represents a static method that is closed over that instance of

Imports System.Reflection Imports System.Security.Permissions
' Declare a delegate type. The object of this code example
' is to show all the methods this delegate can bind to.
'
Public Delegate Sub D(ByVal c As C)
' Declare two sample classes, C and F. Class C has an ID
' property so instances can be identified.
'
Public Class C 
Private id As Integer  
Public ReadOnly Property ID() As Integer  
    Get  
        Return _id  
    End Get  
End Property  
Public Sub New(ByVal newId As Integer)  
    Me._id = newId  
End Sub  
Public Sub M1(ByVal c As C)  
    Console.WriteLine("Instance method M1(c As C) on C:  this.id = {0}, c.ID = {1}",   
        Me.id, c.ID)  
End Sub  
Public Sub M2()  
    Console.WriteLine("Instance method M2() on C:  this.id = {0}", Me.id)  
End Sub  
Public Shared Sub M3(ByVal c As C)  
    Console.WriteLine("Shared method M3(c As C) on C:  c.ID = {0}", c.ID)  
End Sub  
Public Shared Sub M4(ByVal c1 As C, ByVal c2 As C)  
    Console.WriteLine("Shared method M4(c1 As C, c2 As C) on C:  c1.ID = {0}, c2.ID = {1}", _  
        c1.ID, c2.ID)  
End Sub  
End Class
Public Class F Public Sub M1(ByVal c As C)  
    Console.WriteLine("Instance method M1(c As C) on F:  c.ID = {0}", c.ID)  
End Sub  
Public Shared Sub M3(ByVal c As C)  
    Console.WriteLine("Shared method M3(c As C) on F:  c.ID = {0}", c.ID)  
End Sub  
Public Shared Sub M4(ByVal f As F, ByVal c As C)  
    Console.WriteLine("Shared method M4(f As F, c As C) on F:  c.ID = {0}", c.ID)  
End Sub  
End Class
Public Class Example5 Public Shared Sub Main()  
    Dim c1 As New C(42)  
    Dim c2 As New C(1491)  
    Dim f1 As New F()  
    Dim d As D  
    ' Instance method with one argument of type C.  
    Dim cmi1 As MethodInfo = GetType(C).GetMethod("M1")  
    ' Instance method with no arguments.  
    Dim cmi2 As MethodInfo = GetType(C).GetMethod("M2")  
    ' Shared method with one argument of type C.  
    Dim cmi3 As MethodInfo = GetType(C).GetMethod("M3")  
    ' Shared method with two arguments of type C.  
    Dim cmi4 As MethodInfo = GetType(C).GetMethod("M4")  
    ' Instance method with one argument of type C.  
    Dim fmi1 As MethodInfo = GetType(F).GetMethod("M1")  
    ' Shared method with one argument of type C.  
    Dim fmi3 As MethodInfo = GetType(F).GetMethod("M3")  
    ' Shared method with an argument of type F and an  
    ' argument of type C.  
    Dim fmi4 As MethodInfo = GetType(F).GetMethod("M4")  
    Console.WriteLine(vbLf & "An instance method on any type, with an argument of type C.")  
    ' D can represent any instance method that exactly matches its  
    ' signature. Methods on C and F are shown here.  
    '  
    d = CType([Delegate].CreateDelegate(GetType(D), c1, cmi1), D)  
    d(c2)  
    d = CType([Delegate].CreateDelegate(GetType(D), f1, fmi1), D)  
    d(c2)  
    Console.WriteLine(vbLf & "An instance method on C with no arguments.")  
    ' D can represent an instance method on C that has no arguments;  
    ' in this case, the argument of D represents the hidden first  
    ' argument of any instance method. The delegate acts like a  
    ' Shared method, and an instance of C must be passed each time  
    ' it is invoked.  
    '  
    d = CType([Delegate].CreateDelegate(GetType(D), Nothing, cmi2), D)  
    d(c1)  
    Console.WriteLine(vbLf & "A Shared method on any type, with an argument of type C.")  
    ' D can represent any Shared method with the same signature.  
    ' Methods on F and C are shown here.  
    '  
    d = CType([Delegate].CreateDelegate(GetType(D), Nothing, cmi3), D)  
    d(c1)  
    d = CType([Delegate].CreateDelegate(GetType(D), Nothing, fmi3), D)  
    d(c1)  
    Console.WriteLine(vbLf & "A Shared method on any type, with an argument of")  
    Console.WriteLine("    that type and an argument of type C.")  
    ' D can represent any Shared method with one argument of the  
    ' type the method belongs and a second argument of type C.  
    ' In this case, the method is closed over the instance of  
    ' supplied for the its first argument, and acts like an instance  
    ' method. Methods on F and C are shown here.  
    '  
    d = CType([Delegate].CreateDelegate(GetType(D), c1, cmi4), D)  
    d(c2)  
    Dim test As [Delegate] =  
        [Delegate].CreateDelegate(GetType(D), f1, fmi4, False)  
    ' This final example specifies False for throwOnBindFailure  
    ' in the call to CreateDelegate, so the variable 'test'  
    ' contains Nothing if the method fails to bind (for  
    ' example, if fmi4 happened to represent a method of  
    ' some class other than F).  
    '  
    If test IsNot Nothing Then  
        d = CType(test, D)  
        d(c2)  
    End If  
End Sub  
End Class
' This code example produces the following output:
'
'An instance method on any type, with an argument of type C.
'Instance method M1(c As C) on C: this.id = 42, c.ID = 1491
'Instance method M1(c As C) on F: c.ID = 1491
'
'An instance method on C with no arguments.
'Instance method M2() on C: this.id = 42
'
'A Shared method on any type, with an argument of type C.
'Shared method M3(c As C) on C: c.ID = 42
'Shared method M3(c As C) on F: c.ID = 42
'
'A Shared method on any type, with an argument of
' that type and an argument of type C.
'Shared method M4(c1 As C, c2 As C) on C: c1.ID = 42, c2.ID = 1491
'Shared method M4(f As F, c As C) on F: c.ID = 1491
'

2. Note that in the case where

Imports System.Reflection Imports System.Security.Permissions
' Declare a delegate type. The object of this code example
' is to show all the methods this delegate can bind to.
'
Public Delegate Sub D(ByVal c As C)
' Declare two sample classes, C and F. Class C has an ID
' property so instances can be identified.
'
Public Class C 
Private id As Integer  
Public ReadOnly Property ID() As Integer  
    Get  
        Return _id  
    End Get  
End Property  
Public Sub New(ByVal newId As Integer)  
    Me._id = newId  
End Sub  
Public Sub M1(ByVal c As C)  
    Console.WriteLine("Instance method M1(c As C) on C:  this.id = {0}, c.ID = {1}",   
        Me.id, c.ID)  
End Sub  
Public Sub M2()  
    Console.WriteLine("Instance method M2() on C:  this.id = {0}", Me.id)  
End Sub  
Public Shared Sub M3(ByVal c As C)  
    Console.WriteLine("Shared method M3(c As C) on C:  c.ID = {0}", c.ID)  
End Sub  
Public Shared Sub M4(ByVal c1 As C, ByVal c2 As C)  
    Console.WriteLine("Shared method M4(c1 As C, c2 As C) on C:  c1.ID = {0}, c2.ID = {1}", _  
        c1.ID, c2.ID)  
End Sub  
End Class
Public Class F Public Sub M1(ByVal c As C)  
    Console.WriteLine("Instance method M1(c As C) on F:  c.ID = {0}", c.ID)  
End Sub  
Public Shared Sub M3(ByVal c As C)  
    Console.WriteLine("Shared method M3(c As C) on F:  c.ID = {0}", c.ID)  
End Sub  
Public Shared Sub M4(ByVal f As F, ByVal c As C)  
    Console.WriteLine("Shared method M4(f As F, c As C) on F:  c.ID = {0}", c.ID)  
End Sub  
End Class
Public Class Example5 Public Shared Sub Main()  
    Dim c1 As New C(42)  
    Dim c2 As New C(1491)  
    Dim f1 As New F()  
    Dim d As D  
    ' Instance method with one argument of type C.  
    Dim cmi1 As MethodInfo = GetType(C).GetMethod("M1")  
    ' Instance method with no arguments.  
    Dim cmi2 As MethodInfo = GetType(C).GetMethod("M2")  
    ' Shared method with one argument of type C.  
    Dim cmi3 As MethodInfo = GetType(C).GetMethod("M3")  
    ' Shared method with two arguments of type C.  
    Dim cmi4 As MethodInfo = GetType(C).GetMethod("M4")  
    ' Instance method with one argument of type C.  
    Dim fmi1 As MethodInfo = GetType(F).GetMethod("M1")  
    ' Shared method with one argument of type C.  
    Dim fmi3 As MethodInfo = GetType(F).GetMethod("M3")  
    ' Shared method with an argument of type F and an  
    ' argument of type C.  
    Dim fmi4 As MethodInfo = GetType(F).GetMethod("M4")  
    Console.WriteLine(vbLf & "An instance method on any type, with an argument of type C.")  
    ' D can represent any instance method that exactly matches its  
    ' signature. Methods on C and F are shown here.  
    '  
    d = CType([Delegate].CreateDelegate(GetType(D), c1, cmi1), D)  
    d(c2)  
    d = CType([Delegate].CreateDelegate(GetType(D), f1, fmi1), D)  
    d(c2)  
    Console.WriteLine(vbLf & "An instance method on C with no arguments.")  
    ' D can represent an instance method on C that has no arguments;  
    ' in this case, the argument of D represents the hidden first  
    ' argument of any instance method. The delegate acts like a  
    ' Shared method, and an instance of C must be passed each time  
    ' it is invoked.  
    '  
    d = CType([Delegate].CreateDelegate(GetType(D), Nothing, cmi2), D)  
    d(c1)  
    Console.WriteLine(vbLf & "A Shared method on any type, with an argument of type C.")  
    ' D can represent any Shared method with the same signature.  
    ' Methods on F and C are shown here.  
    '  
    d = CType([Delegate].CreateDelegate(GetType(D), Nothing, cmi3), D)  
    d(c1)  
    d = CType([Delegate].CreateDelegate(GetType(D), Nothing, fmi3), D)  
    d(c1)  
    Console.WriteLine(vbLf & "A Shared method on any type, with an argument of")  
    Console.WriteLine("    that type and an argument of type C.")  
    ' D can represent any Shared method with one argument of the  
    ' type the method belongs and a second argument of type C.  
    ' In this case, the method is closed over the instance of  
    ' supplied for the its first argument, and acts like an instance  
    ' method. Methods on F and C are shown here.  
    '  
    d = CType([Delegate].CreateDelegate(GetType(D), c1, cmi4), D)  
    d(c2)  
    Dim test As [Delegate] =  
        [Delegate].CreateDelegate(GetType(D), f1, fmi4, False)  
    ' This final example specifies False for throwOnBindFailure  
    ' in the call to CreateDelegate, so the variable 'test'  
    ' contains Nothing if the method fails to bind (for  
    ' example, if fmi4 happened to represent a method of  
    ' some class other than F).  
    '  
    If test IsNot Nothing Then  
        d = CType(test, D)  
        d(c2)  
    End If  
End Sub  
End Class
' This code example produces the following output:
'
'An instance method on any type, with an argument of type C.
'Instance method M1(c As C) on C: this.id = 42, c.ID = 1491
'Instance method M1(c As C) on F: c.ID = 1491
'
'An instance method on C with no arguments.
'Instance method M2() on C: this.id = 42
'
'A Shared method on any type, with an argument of type C.
'Shared method M3(c As C) on C: c.ID = 42
'Shared method M3(c As C) on F: c.ID = 42
'
'A Shared method on any type, with an argument of
' that type and an argument of type C.
'Shared method M4(c1 As C, c2 As C) on C: c1.ID = 42, c2.ID = 1491
'Shared method M4(f As F, c As C) on F: c.ID = 1491
'

2 and

open System open System.Reflection
// A sample class with an instance method and a static method.
type C(id) = 
member _.M1(s) =  
    printfn $"Instance method M1 on C:  id = %i{id}, s = %s{s}"  
static member M2(s) =  
    printfn $"Static method M2 on C:  s = %s{s}"  
// Declare three delegate types for demonstrating the combinations
// of static versus instance methods and open versus closed
// delegates.
type D1 = delegate of C * string -> unit
type D2 = delegate of string -> unit
type D3 = delegate of unit -> unit
let c1 = C 42
// Get a MethodInfo for each method.
//
let mi1 = typeof.GetMethod("M1", BindingFlags.Public ||| BindingFlags.Instance)
let mi2 = typeof.GetMethod("M2", BindingFlags.Public ||| BindingFlags.Static)
printfn "\nAn instance method closed over C."
// In this case, the delegate and the
// method must have the same list of argument types use
// delegate type D2 with instance method M1.
let test = Delegate.CreateDelegate(typeof, c1, mi1, false)
// Because false was specified for throwOnBindFailure
// in the call to CreateDelegate, the variable 'test'
// contains null if the method fails to bind (for
// example, if mi1 happened to represent a method of
// some class other than C).
if test <> null then let d2 = test :?> D2  
// The same instance of C is used every time the  
// delegate is invoked.  
d2.Invoke "Hello, World!"  
d2.Invoke "Hi, Mom!"  
printfn "\nAn open instance method."
// In this case, the delegate has one more
// argument than the instance method this argument comes
// at the beginning, and represents the hidden instance
// argument of the instance method. Use delegate type D1
// with instance method M1.
let d1 = Delegate.CreateDelegate(typeof, null, mi1) :?> D1
// An instance of C must be passed in each time the
// delegate is invoked.
d1.Invoke(c1, "Hello, World!")
d1.Invoke(C 5280, "Hi, Mom!")
printfn "\nAn open static method."
// In this case, the delegate and the method must
// have the same list of argument types use delegate type
// D2 with static method M2.
let d2 = Delegate.CreateDelegate(typeof, null, mi2) :?> D2
// No instances of C are involved, because this is a static
// method.
d2.Invoke "Hello, World!"
d2.Invoke "Hi, Mom!"
printfn "\nA static method closed over the first argument (String)."
// The delegate must omit the first argument of the method.
// A string is passed as the firstArgument parameter, and
// the delegate is bound to this string. Use delegate type
// D3 with static method M2.
let d3 = Delegate.CreateDelegate(typeof, "Hello, World!", mi2) :?> D3
// Each time the delegate is invoked, the same string is used.
d3.Invoke()
// This code example produces the following output:
// An instance method closed over C.
// Instance method M1 on C: id = 42, s = Hello, World!
// Instance method M1 on C: id = 42, s = Hi, Mom!
//
// An open instance method.
// Instance method M1 on C: id = 42, s = Hello, World!
// Instance method M1 on C: id = 5280, s = Hi, Mom!
//
// An open static method.
// Static method M2 on C: s = Hello, World!
// Static method M2 on C: s = Hi, Mom!
//
// A static method closed over the first argument (String).
// Static method M2 on C: s = Hello, World!

1 are the same type, the static method has two arguments of that type. (In this case,

Imports System.Reflection Imports System.Security.Permissions
' Declare a delegate type. The object of this code example
' is to show all the methods this delegate can bind to.
'
Public Delegate Sub D(ByVal c As C)
' Declare two sample classes, C and F. Class C has an ID
' property so instances can be identified.
'
Public Class C 
Private id As Integer  
Public ReadOnly Property ID() As Integer  
    Get  
        Return _id  
    End Get  
End Property  
Public Sub New(ByVal newId As Integer)  
    Me._id = newId  
End Sub  
Public Sub M1(ByVal c As C)  
    Console.WriteLine("Instance method M1(c As C) on C:  this.id = {0}, c.ID = {1}",   
        Me.id, c.ID)  
End Sub  
Public Sub M2()  
    Console.WriteLine("Instance method M2() on C:  this.id = {0}", Me.id)  
End Sub  
Public Shared Sub M3(ByVal c As C)  
    Console.WriteLine("Shared method M3(c As C) on C:  c.ID = {0}", c.ID)  
End Sub  
Public Shared Sub M4(ByVal c1 As C, ByVal c2 As C)  
    Console.WriteLine("Shared method M4(c1 As C, c2 As C) on C:  c1.ID = {0}, c2.ID = {1}", _  
        c1.ID, c2.ID)  
End Sub  
End Class
Public Class F Public Sub M1(ByVal c As C)  
    Console.WriteLine("Instance method M1(c As C) on F:  c.ID = {0}", c.ID)  
End Sub  
Public Shared Sub M3(ByVal c As C)  
    Console.WriteLine("Shared method M3(c As C) on F:  c.ID = {0}", c.ID)  
End Sub  
Public Shared Sub M4(ByVal f As F, ByVal c As C)  
    Console.WriteLine("Shared method M4(f As F, c As C) on F:  c.ID = {0}", c.ID)  
End Sub  
End Class
Public Class Example5 Public Shared Sub Main()  
    Dim c1 As New C(42)  
    Dim c2 As New C(1491)  
    Dim f1 As New F()  
    Dim d As D  
    ' Instance method with one argument of type C.  
    Dim cmi1 As MethodInfo = GetType(C).GetMethod("M1")  
    ' Instance method with no arguments.  
    Dim cmi2 As MethodInfo = GetType(C).GetMethod("M2")  
    ' Shared method with one argument of type C.  
    Dim cmi3 As MethodInfo = GetType(C).GetMethod("M3")  
    ' Shared method with two arguments of type C.  
    Dim cmi4 As MethodInfo = GetType(C).GetMethod("M4")  
    ' Instance method with one argument of type C.  
    Dim fmi1 As MethodInfo = GetType(F).GetMethod("M1")  
    ' Shared method with one argument of type C.  
    Dim fmi3 As MethodInfo = GetType(F).GetMethod("M3")  
    ' Shared method with an argument of type F and an  
    ' argument of type C.  
    Dim fmi4 As MethodInfo = GetType(F).GetMethod("M4")  
    Console.WriteLine(vbLf & "An instance method on any type, with an argument of type C.")  
    ' D can represent any instance method that exactly matches its  
    ' signature. Methods on C and F are shown here.  
    '  
    d = CType([Delegate].CreateDelegate(GetType(D), c1, cmi1), D)  
    d(c2)  
    d = CType([Delegate].CreateDelegate(GetType(D), f1, fmi1), D)  
    d(c2)  
    Console.WriteLine(vbLf & "An instance method on C with no arguments.")  
    ' D can represent an instance method on C that has no arguments;  
    ' in this case, the argument of D represents the hidden first  
    ' argument of any instance method. The delegate acts like a  
    ' Shared method, and an instance of C must be passed each time  
    ' it is invoked.  
    '  
    d = CType([Delegate].CreateDelegate(GetType(D), Nothing, cmi2), D)  
    d(c1)  
    Console.WriteLine(vbLf & "A Shared method on any type, with an argument of type C.")  
    ' D can represent any Shared method with the same signature.  
    ' Methods on F and C are shown here.  
    '  
    d = CType([Delegate].CreateDelegate(GetType(D), Nothing, cmi3), D)  
    d(c1)  
    d = CType([Delegate].CreateDelegate(GetType(D), Nothing, fmi3), D)  
    d(c1)  
    Console.WriteLine(vbLf & "A Shared method on any type, with an argument of")  
    Console.WriteLine("    that type and an argument of type C.")  
    ' D can represent any Shared method with one argument of the  
    ' type the method belongs and a second argument of type C.  
    ' In this case, the method is closed over the instance of  
    ' supplied for the its first argument, and acts like an instance  
    ' method. Methods on F and C are shown here.  
    '  
    d = CType([Delegate].CreateDelegate(GetType(D), c1, cmi4), D)  
    d(c2)  
    Dim test As [Delegate] =  
        [Delegate].CreateDelegate(GetType(D), f1, fmi4, False)  
    ' This final example specifies False for throwOnBindFailure  
    ' in the call to CreateDelegate, so the variable 'test'  
    ' contains Nothing if the method fails to bind (for  
    ' example, if fmi4 happened to represent a method of  
    ' some class other than F).  
    '  
    If test IsNot Nothing Then  
        d = CType(test, D)  
        d(c2)  
    End If  
End Sub  
End Class
' This code example produces the following output:
'
'An instance method on any type, with an argument of type C.
'Instance method M1(c As C) on C: this.id = 42, c.ID = 1491
'Instance method M1(c As C) on F: c.ID = 1491
'
'An instance method on C with no arguments.
'Instance method M2() on C: this.id = 42
'
'A Shared method on any type, with an argument of type C.
'Shared method M3(c As C) on C: c.ID = 42
'Shared method M3(c As C) on F: c.ID = 42
'
'A Shared method on any type, with an argument of
' that type and an argument of type C.
'Shared method M4(c1 As C, c2 As C) on C: c1.ID = 42, c2.ID = 1491
'Shared method M4(f As F, c As C) on F: c.ID = 1491
'

3 is closed over a null reference if

open System open System.Reflection
// Define two classes to use in the demonstration, a base class and
// a class that derives from it.
type Base() = class end
type Derived() = 
inherit Base()  
// Define a static method to use in the demonstration. The method  
// takes an instance of Base and returns an instance of Derived.  
// For the purposes of the demonstration, it is not necessary for  
// the method to do anything useful.  
static member MyMethod(arg: Base) =  
    Derived()  
// Define a delegate that takes an instance of Derived and returns an
// instance of Base.
type Example = delegate of Derived -> Base
// The binding flags needed to retrieve MyMethod.
let flags = BindingFlags.Public ||| BindingFlags.Static
// Get a MethodInfo that represents MyMethod.
let minfo = typeof.GetMethod("MyMethod", flags)
// Demonstrate contravariance of parameter types and covariance
// of return types by using the delegate Example to represent
// MyMethod. The delegate binds to the method because the
// parameter of the delegate is more restrictive than the
// parameter of the method (that is, the delegate accepts an
// instance of Derived, which can always be safely passed to
// a parameter of type Base), and the return type of MyMethod
// is more restrictive than the return type of Example (that
// is, the method returns an instance of Derived, which can
// always be safely cast to type Base).
let ex = Delegate.CreateDelegate(typeof, minfo) :?> Example
// Execute MyMethod using the delegate Example.
let b = Derived() |> ex.Invoke

4 is a null reference.)

Collaborate with us on GitHub

The source for this content can be found on GitHub, where you can also create and review issues and pull requests. For more information, see our contributor guide.

là ai Hỏi Đáp Là gì Ngôn ngữ Nghĩa là gì Delegate C# LINQ string C# Func C# Callback in C# In keyword C# Params

Private delegate void dldislay string s có nghĩa là gì năm 2024

System.Delegate.CreateDelegate methods

In this article

method

Examples

Example 1

Example 2

and methods

Example

Compatible parameter types and return type

Determine the methods a delegate can represent

Bài Viết Liên Quan

Quảng Cáo

Có thể bạn quan tâm

Toplist được quan tâm

Quảng cáo

Xem Nhiều

Quảng cáo

Chúng tôi

Điều khoản

Trợ giúp

Mạng xã hội