Constants &Variables
A variable is a named memory location. They are programming elements that can change during program execution. Data that needs to be stored in memory & accessed at a later time are stored in variables. Instead of referring to the memory location by the actual memory address you refer to it with a variable name.
Variables are declared as follows
Dim a as Integer
They can also be initialized at the time of declaration as follows:
Dim a as Integer = 10
Constants are very similar to variables. The main difference is that the value contained in memory cannot be changed once the constant is declared. When you declare a constant its value is also specified and this value cannot be changed during program execution.
Constants are used in situations where we need to keep the value in some memory location constant. If you use hard-coded values, and the value is changed then it has to be changed in all the locations in the code where it has been used. Instead if we are using constants, all we will need to do is to change the value of the constant. This would propagate the changes to our entire application.
Constants are declared as follows
Const x as Integer
VB.NET supports block-level scoping of variables. That is you can declare and use variables as and when you need them. Thus, if a variable is required within a ‘for’ block it can be declared within the block and its scope will be the end of the block.
Simple Types (Primitive Data types)
Simple or value type variables are those, which are assigned space in the stack instead of the heap. All the primitive types such as int, double etc are value type variables. The simple types basically consist of Boolean and Numeric types, where Numeric is further divided into Integral and Floating Point.
The first rule of value types is that they cannot be null. Anytime you declare a variable of value type, you have allocated the number of bytes associated with that type on the stack and are working directly with that allocated array of bits. In addition, when you pass a variable of value type, you are passing that variable’s value and not a reference to the underlying object.
Object Type
Object type or reference type variables are those, which are allocated storage space in the heap. Reference type objects can be null. When a reference type is allocated under the covers a value is allocated on the heap and a reference to that value is returned. There are basically four reference types: classes, interfaces, delegates and arrays.
Class Type
Custom data types are available in .NET framework in the form of classes or class type. It is nothing but a set of data and related behavior that is defined by the developer.
Object type and class type are both reference type variables. The only difference comes from the fact that object type consists of objects predefined and available with the .NET framework such as string whereas class type consists of custom user defined data types such as the Class Employee given below.
Class Employee
Dim empid As Integer
Dim empname As String
Public Sub New()
empid = 10
empname = "Reshmi"
End Sub
End Class
Overloading and Overriding of the Class
Overloading provides the ability to create multiple methods or properties with the same name, but with different parameters lists. This is a feature of polymorphism. It is accomplished by using the Overloads keyword in VB.NET. A simple example would be an addition function, which will add the numbers if two integer parameters are passed to it and concatenate the strings if two strings are passed to it.
Class test
Public Overloads Function Add(ByVal x As Integer, ByVal y As Integer)
Return x + y
End Function
Public Overloads Function Add(ByVal x As String, ByVal y As String)
Return x & y
End Function
Shared Sub main()
Dim a As new test
Dim b As Integer
Dim c As String
b = a.Add(1, 2)
c = a.Add("Reshmi", " Nair")
System.Console.Writeline(b)
System.Console.Writeline(c)
End Sub
End Class
O/P:
3
Reshmi Nair
Overriding
Class inheritance causes the methods and properties present in the base class also to be derived into the derived class. There might arise a situation wherein you would like to change the functionality of an inherited method or property. In such cases we can override the method or property of the base class. This is another feature of polymorphism. You can accomplish this in VB.NET by using the Overridable keyword with the base class method and the Overrides keyword with the derived class method.
Public Class shapes
Public Overridable Sub display()
Console.WriteLine("Shapes")
End Sub
End Class
Public Class square
Inherits shapes
Public Overrides Sub display()
Console.WriteLine("This is a square")
End Sub
End Class
Public Class rectangle
Inherits shapes
Public Overrides Sub display()
Console.WriteLine("This is a rectangle")
End Sub
End Class
The above example is just an indication to how overriding can be implemented in either VB.NET.
Properties
Properties are named members of classes, structs, and interfaces. They provide a flexible mechanism to read, write, or compute the values of private fields through accessors.
Properties are an extension of fields and are accessed using the same syntax. Unlike fields, properties do not designate storage locations. Instead, properties have accessors
that read, write, or compute their values.
Get accessor
The execution of the get accessor is equivalent to reading the value of the field.
The following is a get accessor that returns the value of a private field name:
Dim name as String ’ the name field
Property Name() As String ’ the name property
Get
Return name
End Get
End Property
Set accessor
The set accessor is similar to a method that returns void. It uses an implicit parameter called value, whose type is the type of the property. In the following example, a set accessor is added to the Name property:
Dim name as String ’ the name field
Property Name() As String ’ the name property
Get
Return name
End Get
Set(ByVal Value As String)
Name = value
End Set
End Property
When you assign a value to the property, the set accessor is invoked with an argument that provides the new value. For example:
e1.Name = "Reshmi" // The set accessor is invoked here
It is an error to use the implicit parameter name (value) for a local variable declaration in a set accessor.
How to make a Property Read Only/Write Only
There are times when we may want a property to be read-only – such that it can’t be changed. This is where read-only properties come into the picture. A Read Only property is one which includes only the get accessor, no set accessor.
For instance,
Public ReadOnly Property EmpID() as Integer
Get
Return empid
End Get
End Property
Similar to read-only properties there are also situations where we would need something known as write-only properties. In this case the value can be changed but not retrieved. To create a write-only property, use the WriteOnly keyword and only implement the set block in the code as shown in the example below.
Public WriteOnly Property e as string
Set
e = Value
End Set
End Property
Structures :
A structure allows you to create your own custom data types and it contains one or more members that can be of different data types. It can contain fields, methods, Etc., Structures are very similar to classes but there are some restrictions present in the case of structures that are absent in the case of classes. For example you cannot initialize structure members. Also you cannot inherit a structure whereas classes can be inherited.
Another important feature of structures differentiating it from classes is that a structure can't have a default parameter-less constructor or a destructor. A structure is created on the stack and dies when you reach the closing brace in C# or the End structure in VB.NET.
But one of the most important differences between structures and classes is that structures are referenced by value and classes by reference. As a value type, allocated on the stack, structs provide a significant opportunity to increase program efficiency. Objects on the stack are faster to allocate and de-allocate. A struct is a good choice for data-bound objects, which don’t require too much memory. The memory requirements should be considered based on the fact that the size of memory available on the stack is limited than the memory available on the heap.
Thus we must use classes in situations where large objects with lots of logic are required.
Struct – Code: Sample code showing the Class vs. Structures
Imports System
Class Test
Dim classvar As Integer
Dim anothervar As Integer = 20
Sub New()
classvar = 28
End Sub
Structure ExampleStruct
Dim i As Integer
Sub New(ByVal j As Integer)
i = j
End Sub
Sub trialMethod()
Console.WriteLine("Inside Trial Method")
End Sub
End Structure
Shared Sub main()
Dim t As New Test()
Dim strct As New ExampleStruct(20)
Console.WriteLine(strct.i)
strct.i = 10
Console.WriteLine(t.classvar)
Console.WriteLine(strct.i)
strct.trialMethod()
End Sub
End Class
O/P: -
28
20
10
Inside Trial Method
In the above example, I have declared and used a constructor with a single parameter for a structure. Instead if I had tried to use a default parameter-less parameter I would have got an error. But the same is possible in the case of classes as shown by the default parameter-less constructor, which initializes the classvar variable to 28. Another point to note is that a variable called anothervar has been declared and initialized within the class whereas the same cannot be done for members of a structure.
Why Namespaces
Namespaces are used in .Net to organize class libraries into a hierarchical structure and reduce conflicts between various identifiers in a program. By helping organize classes, namespaces help programmers manage their projects efficiently and in a meaningful way that is understood by consumers of the class library. Namespaces enables reusable components from different companies to be used in the same program without the worry of ambiguity caused by multiple instances of the same identifier.
Namespaces provide a logical organization for programs to exist. Starting with a toplevel namespace, sub-namespaces are created to further categorize code, based upon its purpose.
In .Net, the base class library begins at the System namespace. There are several classes at the System level such as Console, Exception etc. The namespace name gives a good idea of the types of classes that are contained within the namespace. The fully qualified name of a class is the class name prefixed with the namespace name. There are also several nested namespaces within the System namespace such as System.Security, System.IO, System.Data, System.Collections etc.
Reducing conflict is the greatest strength of namespaces. Class and method names often collide when using multiple libraries. This risk increases as programs get larger and include more third-party tools.
Boxing Conversions
Boxing is the implicit conversion of a value type to a reference type or to any interface type implemented by this value type. This is possible due to the principle of type system unification where everything is an object.
When boxing occurs, the contents of value type are copied from the stack into the memory allocated on the managed heap. The new reference type created contains a copy of the value type and can be used by other types that expect an object reference. The value contained in the value type and the created reference types are not associated in any way. If you change the original value type, the reference type is not affected. Boxing,
thus, enables everything to appear to be an object, thereby avoiding the overhead required if everything actually were an object.
Example:
VB.NET
Dim n as Integer = 10
Dim obj as Object
obj = n
Explanation:
In the above code segment, a value-type variable n is declared and is assigned the value 10. The next statement declares an object-type variable obj. The last statement implicitly performs boxing operation on the variable n.
UnBoxing Conversions
UnBoxing is the explicit conversion from a reference type to a value type or from an interface type to a value type that implements the interface.
When unboxing occurs, memory is copied from the managed heap to the stack. For an unboxing conversion to a given value type to succeed at run time, the value of the source argument must be a reference to an object that was previously created by boxing a value of that value type otherwise an exception is thrown.
VB.Net does not support the ability to explicitly unbox values. It relies on the helper functions in the Microsoft.VisualBasic.Helpers namespace to carry out unboxing. Since these helper functions are considerably less efficient than C# support for explicit unboxing. Thus it is recommended to avoid excessive use of variables of type Object.
Boxing and UnBoxing have performance implications. Every time a value type is boxed, a new reference type is created and the value type is copied onto the managed heap. Depending on the size of the value type and the number of times value types are boxed and unboxed, the CLR can spend a lot of CPU cycles just doing these conversions.
It is recommended to perform boxing and unboxing in a scenario where you have to pass a value parameter multiple times to a method that accepts a reference parameter. In such a case, it is advantageous to box the value parameter once before passing it multiple times to methods that accept reference methods.
Enumerations
Enumerations are types that inherit from System.Enum. The elements of an enumeration are expressed in words rather than numbers, which makes it convenient for understanding the meaning of the value being used. Enumerations symbolically represent a set of values of one of the primitive integral types.
The type of the elements of an enumeration can be Byte, Short, Integer or Long. If no type is specified explicitly, the default type is Integer.
Example:
Enum month As Byte
Jan = 2
Feb = 5
Mar = 10
End Enum
Explanation:
In the above code segment, an enumeration type month is declared. The underlying type of the elements has been specified as Byte. It has three elements viz: Jan, Feb and Mar. These three elements have been assigned specific values. In case of an enumeration, if no values are specified, the value of the first element corresponds to 0 and so on.
Delegates
The runtime supports constructs called delegates, which enable late-bound operations such as method invocation and callback procedures. With delegates, a program can dynamically call different methods at runtime. They are type safe, secure, managed objects that always point to a valid object and cannot corrupt the memory of another object. The closest equivalent of a delegate in other languages is a function pointer, but
whereas a function pointer can only reference Shared functions, a delegate can reference both Shared and instance methods. Delegates are Marshal by Value Objects.
The members of a delegate are the members inherited from class System.Delegate. A delegate defines the signature and return type of a method. The resulting delegate can reference any method with a matching signature. Each instance of a delegate can forward a call to one or more methods that take those parameters and return the same type. Once a method has been assigned to a delegate, it is called when the delegate is invoked.
Example:
Module delegate_example
Delegate Function calculation(ByVal a As Integer, ByVal b As Integer) As Integer
Public Function add(ByVal num1 As Integer, ByVal num2 As Integer) As Integer
add = num1 + num2
End Function
Sub Main()
Dim calc_delegate As New calculation(AddressOf add)
Dim result As Integer
result = calc_delegate(50, 70)
End Sub
End Module
Explanation:
Four steps are required to implement delegates viz.
• Defining Delegates
The foremost step is to define the delegate. The definition of the delegate specifies the method signature, return type of the method, access modifier and the delegate name. The method signature specifies the order and type of each argument. The definition of a delegate is indicated by the usage of the Delegate keyword. As
shown in the above code segment, the delegate name is calculation, it's access modifier is public, it receives two integer arguments and returns an integer value.
• Creating Delegate Method Handler(s)
The next step is to define the method(s) that will be associated with the delegate. In the above code segment, a method named add is defined. This method must have same method signature as that of the delegate, as shown in the above code segment.
• Hooking up Delegates and Method Handlers
For a delegate method handler to be invoked, it must be assigned to a delegate object. In the above code, the delegate object is calc_delegate and is hooked up to the method handler add.
• Invoking the method through the Delegate
The last step is to invoke the methods that are associated with the delegate. A delegate method handler is invoked by making a method call on the delegate itself. This causes the method handler to invoke with the assigned input parameters as if they were invoked directly by the program, as shown in the above code
A variable is a named memory location. They are programming elements that can change during program execution. Data that needs to be stored in memory & accessed at a later time are stored in variables. Instead of referring to the memory location by the actual memory address you refer to it with a variable name.
Variables are declared as follows
Dim a as Integer
They can also be initialized at the time of declaration as follows:
Dim a as Integer = 10
Constants are very similar to variables. The main difference is that the value contained in memory cannot be changed once the constant is declared. When you declare a constant its value is also specified and this value cannot be changed during program execution.
Constants are used in situations where we need to keep the value in some memory location constant. If you use hard-coded values, and the value is changed then it has to be changed in all the locations in the code where it has been used. Instead if we are using constants, all we will need to do is to change the value of the constant. This would propagate the changes to our entire application.
Constants are declared as follows
Const x as Integer
VB.NET supports block-level scoping of variables. That is you can declare and use variables as and when you need them. Thus, if a variable is required within a ‘for’ block it can be declared within the block and its scope will be the end of the block.
Simple Types (Primitive Data types)
Simple or value type variables are those, which are assigned space in the stack instead of the heap. All the primitive types such as int, double etc are value type variables. The simple types basically consist of Boolean and Numeric types, where Numeric is further divided into Integral and Floating Point.
The first rule of value types is that they cannot be null. Anytime you declare a variable of value type, you have allocated the number of bytes associated with that type on the stack and are working directly with that allocated array of bits. In addition, when you pass a variable of value type, you are passing that variable’s value and not a reference to the underlying object.
Object Type
Object type or reference type variables are those, which are allocated storage space in the heap. Reference type objects can be null. When a reference type is allocated under the covers a value is allocated on the heap and a reference to that value is returned. There are basically four reference types: classes, interfaces, delegates and arrays.
Class Type
Custom data types are available in .NET framework in the form of classes or class type. It is nothing but a set of data and related behavior that is defined by the developer.
Object type and class type are both reference type variables. The only difference comes from the fact that object type consists of objects predefined and available with the .NET framework such as string whereas class type consists of custom user defined data types such as the Class Employee given below.
Class Employee
Dim empid As Integer
Dim empname As String
Public Sub New()
empid = 10
empname = "Reshmi"
End Sub
End Class
Overloading and Overriding of the Class
Overloading provides the ability to create multiple methods or properties with the same name, but with different parameters lists. This is a feature of polymorphism. It is accomplished by using the Overloads keyword in VB.NET. A simple example would be an addition function, which will add the numbers if two integer parameters are passed to it and concatenate the strings if two strings are passed to it.
Class test
Public Overloads Function Add(ByVal x As Integer, ByVal y As Integer)
Return x + y
End Function
Public Overloads Function Add(ByVal x As String, ByVal y As String)
Return x & y
End Function
Shared Sub main()
Dim a As new test
Dim b As Integer
Dim c As String
b = a.Add(1, 2)
c = a.Add("Reshmi", " Nair")
System.Console.Writeline(b)
System.Console.Writeline(c)
End Sub
End Class
O/P:
3
Reshmi Nair
Overriding
Class inheritance causes the methods and properties present in the base class also to be derived into the derived class. There might arise a situation wherein you would like to change the functionality of an inherited method or property. In such cases we can override the method or property of the base class. This is another feature of polymorphism. You can accomplish this in VB.NET by using the Overridable keyword with the base class method and the Overrides keyword with the derived class method.
Public Class shapes
Public Overridable Sub display()
Console.WriteLine("Shapes")
End Sub
End Class
Public Class square
Inherits shapes
Public Overrides Sub display()
Console.WriteLine("This is a square")
End Sub
End Class
Public Class rectangle
Inherits shapes
Public Overrides Sub display()
Console.WriteLine("This is a rectangle")
End Sub
End Class
The above example is just an indication to how overriding can be implemented in either VB.NET.
Properties
Properties are named members of classes, structs, and interfaces. They provide a flexible mechanism to read, write, or compute the values of private fields through accessors.
Properties are an extension of fields and are accessed using the same syntax. Unlike fields, properties do not designate storage locations. Instead, properties have accessors
that read, write, or compute their values.
Get accessor
The execution of the get accessor is equivalent to reading the value of the field.
The following is a get accessor that returns the value of a private field name:
Dim name as String ’ the name field
Property Name() As String ’ the name property
Get
Return name
End Get
End Property
Set accessor
The set accessor is similar to a method that returns void. It uses an implicit parameter called value, whose type is the type of the property. In the following example, a set accessor is added to the Name property:
Dim name as String ’ the name field
Property Name() As String ’ the name property
Get
Return name
End Get
Set(ByVal Value As String)
Name = value
End Set
End Property
When you assign a value to the property, the set accessor is invoked with an argument that provides the new value. For example:
e1.Name = "Reshmi" // The set accessor is invoked here
It is an error to use the implicit parameter name (value) for a local variable declaration in a set accessor.
How to make a Property Read Only/Write Only
There are times when we may want a property to be read-only – such that it can’t be changed. This is where read-only properties come into the picture. A Read Only property is one which includes only the get accessor, no set accessor.
For instance,
Public ReadOnly Property EmpID() as Integer
Get
Return empid
End Get
End Property
Similar to read-only properties there are also situations where we would need something known as write-only properties. In this case the value can be changed but not retrieved. To create a write-only property, use the WriteOnly keyword and only implement the set block in the code as shown in the example below.
Public WriteOnly Property e as string
Set
e = Value
End Set
End Property
Structures :
A structure allows you to create your own custom data types and it contains one or more members that can be of different data types. It can contain fields, methods, Etc., Structures are very similar to classes but there are some restrictions present in the case of structures that are absent in the case of classes. For example you cannot initialize structure members. Also you cannot inherit a structure whereas classes can be inherited.
Another important feature of structures differentiating it from classes is that a structure can't have a default parameter-less constructor or a destructor. A structure is created on the stack and dies when you reach the closing brace in C# or the End structure in VB.NET.
But one of the most important differences between structures and classes is that structures are referenced by value and classes by reference. As a value type, allocated on the stack, structs provide a significant opportunity to increase program efficiency. Objects on the stack are faster to allocate and de-allocate. A struct is a good choice for data-bound objects, which don’t require too much memory. The memory requirements should be considered based on the fact that the size of memory available on the stack is limited than the memory available on the heap.
Thus we must use classes in situations where large objects with lots of logic are required.
Struct – Code: Sample code showing the Class vs. Structures
Imports System
Class Test
Dim classvar As Integer
Dim anothervar As Integer = 20
Sub New()
classvar = 28
End Sub
Structure ExampleStruct
Dim i As Integer
Sub New(ByVal j As Integer)
i = j
End Sub
Sub trialMethod()
Console.WriteLine("Inside Trial Method")
End Sub
End Structure
Shared Sub main()
Dim t As New Test()
Dim strct As New ExampleStruct(20)
Console.WriteLine(strct.i)
strct.i = 10
Console.WriteLine(t.classvar)
Console.WriteLine(strct.i)
strct.trialMethod()
End Sub
End Class
O/P: -
28
20
10
Inside Trial Method
In the above example, I have declared and used a constructor with a single parameter for a structure. Instead if I had tried to use a default parameter-less parameter I would have got an error. But the same is possible in the case of classes as shown by the default parameter-less constructor, which initializes the classvar variable to 28. Another point to note is that a variable called anothervar has been declared and initialized within the class whereas the same cannot be done for members of a structure.
Why Namespaces
Namespaces are used in .Net to organize class libraries into a hierarchical structure and reduce conflicts between various identifiers in a program. By helping organize classes, namespaces help programmers manage their projects efficiently and in a meaningful way that is understood by consumers of the class library. Namespaces enables reusable components from different companies to be used in the same program without the worry of ambiguity caused by multiple instances of the same identifier.
Namespaces provide a logical organization for programs to exist. Starting with a toplevel namespace, sub-namespaces are created to further categorize code, based upon its purpose.
In .Net, the base class library begins at the System namespace. There are several classes at the System level such as Console, Exception etc. The namespace name gives a good idea of the types of classes that are contained within the namespace. The fully qualified name of a class is the class name prefixed with the namespace name. There are also several nested namespaces within the System namespace such as System.Security, System.IO, System.Data, System.Collections etc.
Reducing conflict is the greatest strength of namespaces. Class and method names often collide when using multiple libraries. This risk increases as programs get larger and include more third-party tools.
Boxing Conversions
Boxing is the implicit conversion of a value type to a reference type or to any interface type implemented by this value type. This is possible due to the principle of type system unification where everything is an object.
When boxing occurs, the contents of value type are copied from the stack into the memory allocated on the managed heap. The new reference type created contains a copy of the value type and can be used by other types that expect an object reference. The value contained in the value type and the created reference types are not associated in any way. If you change the original value type, the reference type is not affected. Boxing,
thus, enables everything to appear to be an object, thereby avoiding the overhead required if everything actually were an object.
Example:
VB.NET
Dim n as Integer = 10
Dim obj as Object
obj = n
Explanation:
In the above code segment, a value-type variable n is declared and is assigned the value 10. The next statement declares an object-type variable obj. The last statement implicitly performs boxing operation on the variable n.
UnBoxing Conversions
UnBoxing is the explicit conversion from a reference type to a value type or from an interface type to a value type that implements the interface.
When unboxing occurs, memory is copied from the managed heap to the stack. For an unboxing conversion to a given value type to succeed at run time, the value of the source argument must be a reference to an object that was previously created by boxing a value of that value type otherwise an exception is thrown.
VB.Net does not support the ability to explicitly unbox values. It relies on the helper functions in the Microsoft.VisualBasic.Helpers namespace to carry out unboxing. Since these helper functions are considerably less efficient than C# support for explicit unboxing. Thus it is recommended to avoid excessive use of variables of type Object.
Boxing and UnBoxing have performance implications. Every time a value type is boxed, a new reference type is created and the value type is copied onto the managed heap. Depending on the size of the value type and the number of times value types are boxed and unboxed, the CLR can spend a lot of CPU cycles just doing these conversions.
It is recommended to perform boxing and unboxing in a scenario where you have to pass a value parameter multiple times to a method that accepts a reference parameter. In such a case, it is advantageous to box the value parameter once before passing it multiple times to methods that accept reference methods.
Enumerations
Enumerations are types that inherit from System.Enum. The elements of an enumeration are expressed in words rather than numbers, which makes it convenient for understanding the meaning of the value being used. Enumerations symbolically represent a set of values of one of the primitive integral types.
The type of the elements of an enumeration can be Byte, Short, Integer or Long. If no type is specified explicitly, the default type is Integer.
Example:
Enum month As Byte
Jan = 2
Feb = 5
Mar = 10
End Enum
Explanation:
In the above code segment, an enumeration type month is declared. The underlying type of the elements has been specified as Byte. It has three elements viz: Jan, Feb and Mar. These three elements have been assigned specific values. In case of an enumeration, if no values are specified, the value of the first element corresponds to 0 and so on.
Delegates
The runtime supports constructs called delegates, which enable late-bound operations such as method invocation and callback procedures. With delegates, a program can dynamically call different methods at runtime. They are type safe, secure, managed objects that always point to a valid object and cannot corrupt the memory of another object. The closest equivalent of a delegate in other languages is a function pointer, but
whereas a function pointer can only reference Shared functions, a delegate can reference both Shared and instance methods. Delegates are Marshal by Value Objects.
The members of a delegate are the members inherited from class System.Delegate. A delegate defines the signature and return type of a method. The resulting delegate can reference any method with a matching signature. Each instance of a delegate can forward a call to one or more methods that take those parameters and return the same type. Once a method has been assigned to a delegate, it is called when the delegate is invoked.
Example:
Module delegate_example
Delegate Function calculation(ByVal a As Integer, ByVal b As Integer) As Integer
Public Function add(ByVal num1 As Integer, ByVal num2 As Integer) As Integer
add = num1 + num2
End Function
Sub Main()
Dim calc_delegate As New calculation(AddressOf add)
Dim result As Integer
result = calc_delegate(50, 70)
End Sub
End Module
Explanation:
Four steps are required to implement delegates viz.
• Defining Delegates
The foremost step is to define the delegate. The definition of the delegate specifies the method signature, return type of the method, access modifier and the delegate name. The method signature specifies the order and type of each argument. The definition of a delegate is indicated by the usage of the Delegate keyword. As
shown in the above code segment, the delegate name is calculation, it's access modifier is public, it receives two integer arguments and returns an integer value.
• Creating Delegate Method Handler(s)
The next step is to define the method(s) that will be associated with the delegate. In the above code segment, a method named add is defined. This method must have same method signature as that of the delegate, as shown in the above code segment.
• Hooking up Delegates and Method Handlers
For a delegate method handler to be invoked, it must be assigned to a delegate object. In the above code, the delegate object is calc_delegate and is hooked up to the method handler add.
• Invoking the method through the Delegate
The last step is to invoke the methods that are associated with the delegate. A delegate method handler is invoked by making a method call on the delegate itself. This causes the method handler to invoke with the assigned input parameters as if they were invoked directly by the program, as shown in the above code