Garbage collection
Garbage collection is a process of releasing the memory used by the objects, which are no longer referenced. This is done in different ways and different manners in various platforms and languages. We will see how garbage collection is being done in .NET. The .Net Framework provides a new mechanism for releasing unreferenced objects from the memory (that is we no longer needed that objects in the program) ,this process is called Garbage Collection (GC). When a program creates an Object, the Object takes up the memory. Later when the program has no more references to that Object, the Object's memory becomes unreachable, but it is not immediately freed. The Garbage Collection checks to see if there are any Objects in the heap that are no longer being used by the application. If such Objects exist, then the memory used by these Objects can be reclaimed. So these unreferenced Objects should be removed from memory , then the other new Objects you create can find a place in the Heap.
The reclaimed Objects have to be Finalized later. Finalization allows a resource to clean up after itself when it is being collected. This releasing of unreferenced Objects is happening automatically in .Net languages by the Garbage Collector (GC). The programming languages like C++, programmers are responsible for allocating memory for Objects they created in the application and reclaiming the memory when that Object is no longer needed for the program. In .Net languages there is a facility that we can call Garbage Collector (GC) explicitly in the program by calling System.GC.Collect.(GC.collect)
Garbage Collection basis * Almost every program uses resources such as database connection, file system objects etc. In order to make use of these things some resources should be available to us. * First we allocate a block of memory in the managed memory by using the new keyword. (This will emit the newobj instruction in the Microsoft intermediate language code generated from C#, VB.NET, Jscript.NET or any other .NET compliance language). * Use the constructor of the class to set the initial state of the object. * Use the resources by accessing the type’s members. * At last CLEAR THE MEMORY.

Inheritance Terminology * One of the key features of Object Oriented Programming (OOP) languages is inheritance. Inheritance is the ability to use all of the functionality of an existing class, and extend those capabilities without re-writing the original class. Prior to the availability of Microsoft® Visual Basic® .NET, Visual Basic programmers did not have this capability. In Visual Basic .NET, you are able to inherit from classes that ship in the Microsoft .NET Framework, as well as from classes that you create. In this document, you will learn how to use inheritance, and see how it can significantly cut down your programming time. * Before we delve too deeply into this topic, let's define a few terms. A new class that is created by inheritance is sometimes called a child class or a subclass. The class you originally inherited from is called the base class, parent class, or the superclass. In some OOP languages, a base class may inherit from more than one base class. This means that if you had a Person class and a Car class, a Driver class might inherit all of the properties and methods from each of these two classes. In the .NET world, only single inheritance is allowed, so each subclass will have only one base class. * There are three types of inheritance that .NET supports: implementation, interface, and visual. Implementation inheritance refers to the ability to use a base class's properties and methods with no additional coding. Interface inheritance refers to the ability to use just the names of the properties and methods, but the child class must provide the implementation. Visual inheritance refers to the ability for a child form (class) to use the base forms (class) visual representation as well as the implemented code. * A class in .NET may inherit from a class that has already inherited from another class. In addition you may use an interface or even multiple interfaces within a class.

Must Inherit
Specifies that a class can be used only as a base class and that you cannot create an object directly from it.

The purpose of a base class (also known as an abstract class) is to define functionality that is common to all the classes derived from it. This saves the derived classes from having to redefine the common elements. In some cases, this common functionality is not complete enough to make a usable object, and each derived class defines the missing functionality. In such a case, you want the consuming code to create objects only from the derived classes. You use MustInherit on the base class to enforce this.
Another use of a MustInherit class is to restrict a variable to a set of related classes. You can define a base class and derive all these related classes from it. The base class does not need to provide any functionality common to all the derived classes, but it can serve as a filter for assigning values to variables. If your consuming code declares a variable as the base class, Visual Basic allows you to assign only an object from one of the derived classes to that variable.
The .NET Framework defines several MustInherit classes, among them Array, Enum, and ValueType. ValueType is an example of a base class that restricts a variable. All value types derive from ValueType. If you declare a variable as ValueType, you can assign only value types to that variable.
Rules
Declaration Context. You can use MustInherit only in a Class statement.
Combined Modifiers. You cannot specify MustInherit together with NotInheritable in the same declaration.
Example

The following example illustrates both forced inheritance and forced overriding. The base class shape defines a variable acrossLine. The classes circle and square derive from shape. They inherit the definition of acrossLine, but they must define the function area because that calculation is different for each kind of shape.
VB

Public MustInherit Class shape Public acrossLine As Double Public MustOverride Function area() As Double
End Class
Public Class circle : Inherits shape Public Overrides Function area() As Double Return Math.PI * acrossLine End Function
End Class
Public Class square : Inherits shape Public Overrides Function area() As Double Return acrossLine * acrossLine End Function
End Class
Public Class consumeShapes Public Sub makeShapes() Dim shape1, shape2 As shape shape1 = New circle shape2 = New square End Sub
End Class

You can declare shape1 and shape2 to be of type shape. However, you cannot create an object from shape because it lacks the functionality of the function area and is marked MustInherit.
Because they are declared as shape, the variables shape1 and shape2 are restricted to objects from the derived classes circle and square. Visual Basic does not allow you to assign any other object to these variables, which gives you a high level of type safety.

ADO.NET is a set of classes that comes with the Microsoft .NET framework to facilitate data access from managed languages. ADO.NET has been in existence for a long time and it provides a comprehensive and complete set of libraries for data access. The strength of ADO.NET is firstly that it lets applications access various types of data using the same methodology. If I know how to use ADO.NET to access a SQL Server database then the same methodology can be used to access any other type of database (like Oracle or MS Access) by just using a different set of classes. Secondly, ADO.NET provides two models for data access: a connected model where I can keep the connection with the database and perform data access, and another way is to get all the data in ADO.NET objects that let us perform data access on disconnected objects.

* DataReader - A DataReader is an object that can be used to access the results sequentially from a database. The DataReader is used to get forward only sequential results as the query executes. This is used with the Command object (we will see the usage shortly). * Dataset - The Dataset can be thought of as an in-memory representation of a database. ADataSet is a disconnected data access object. The result of the query can be stored in a Dataset. The DataSet contains DataTables. The DataTables contain DataRow and DataColumns. A DataSet or a DataTable can be used with a Command and a DataAdapter object to store query results. * DataAdapter - A DataAdapter object is used to fill a DataSet/DataTable with query results. This can be thought of as the adapter between the connected and disconnected data models. A Command object will be used to execute the query and aDataAdapter will use this Command object and fill the query results coming from the database into a DataSet/DataTable.

Constructors
Constructors used in a class are member functions to initialize or set the objects of a class in VB.net. They dont return any value and are defined in a Sub with a keyword New.
Shared constructors
Instance constructors

Implementation of Shared Constructors
Shared constructors are used to initialize the shared variables of a type.
Shared variables are created using the Shared keyword and store values that can be shared by all the instances of a class. Shared constructors have an implicit public access. A shared constructor will not run more than once during a single execution of a program.

The following example is an illustration of the shared constructor.

Public Class class1
Shared x As Integer

Shared Sub New() x=0 End Sub
End Class
We can increment the value of a shared variable in an instance constructor to keep track of the number of instances created in a class. The following code illustrates the use of a shared variable within an instance constructor.

Sub New x=x+1 MessageBox.Show("Number of instances are:" & i)
End Sub

To test how shared constructor works, create a form and name it as Form1 and place a button Button1.

Public Class Form1
Inherits System.windows.Forms.Form

Private Sub Button1_Click(ByVal sender As System.Object, Byval e As System.EvenArgs) Handles Button1.Click

Dim c1 As class1 = New class1
Dim c2 As class1 = New class1
End Sub
End Class

The above code illustrates the use of a shared variable within an instance constructor to keep track of the number of instances of a class.
Instance Constructor in Visual Basic 2005
Instance constructors are used to initialize variables that are declared with Dim, Public, Private, Friend, Protected, and Protected Friend keywords. Write the following code in the class module.
Public Class ItemClass Private ItemCode As String Private ItemName As String Private ItemDescription As String Private ItemCategory As String Private ItemPrice As Single Private ItemUnit As String

Public Sub New(ByVal Category As string) ItemCategory = Category End Sub

End Class

In the Instance Constructor, the statement, ItemCategory = Category assigns Item Category to class variable ItemCategory.

To test how Instance constructor works, create a form and name it as Form1 and place a button Button1.

Public Class Form1
Inherits System.windows.Forms.Form

Private Sub Button1_Click(ByVal sender As System.Object, Byval e As System.EvenArgs) Handles Button1.Click
Dim objItem As New ItemClass("I")
End Sub
End Class

This is how we can instantiate the Item class which in turn calls the instance constructor

Destructors:
Destructors or finalizer is a method used to deallocate the resources of an object that are no longer used, its invoked automatically by the VB.net environment. The keyword Overrides is used with the Finalizer method.
Events
An event is a message sent by an object announcing that something has happened. Events are implemented using delegates, a form of object-oriented function pointer that allows a function to be invoked indirectly by way of a reference to the function.