Posted by: DOCSERVE | August 2, 2011

Programming VB.NET

Introduction

VB.NET is completely object oriented. This article uncovers some basic Object Oriented Programming features of Visual Basic. NET. The whole article is divided into ten lessons. The source code for these lessons is provided with the article.

This tutorial is designed with the following objectives:

  1. To provide a sound knowledge about Object Oriented Programming in VB.NET.
  2. To educate how Object Oriented techniques are used in VB.NET.
  3. To explain the following concepts in an easy and simple way:
    • Creating and using classes and objects in VB.NET.
    • Encapsulation, Abstraction, Inheritance and Polymorphism.
    • Overloading and Overriding.
    • Constructors and Destructors.
    • Static functions.

Go through this tutorial and you will start making sense of almost any .NET code. Also, Java/CPP programmers can use this to understand OOPs in VB.NET.

Using the Code

The source code for each lesson is available as a .vb source code file. You need Microsoft .NET framework SDK installed in your system to compile and execute the exercises in this article. You can download it from the Microsoft website. The VB.NET compiler (vbc.exe) normally resides in your FrameworkSDK\bin folder.

To manually compile a source code file, you may use the command prompt to type:

vbc filename.vb /out:”filename.exe” /r:”System.Windows.Forms.dll”,”System.dll”

  • A Namespace

    In VB.NET, classes and other data structures for a specific purpose are grouped together to form a namespace. You can use the classes in a namespace, by simply importing the namespace. The Imports keyword is used to import a namespace to your project. .NET framework provides a rich set of built in classes, grouped together to various namespaces. In this lesson, we are using the System namespace. Import the System namespace (already available in .NET).

    Collapse | Copy Code
    Imports System

  • A Class

    Probably, you are already familiar with classes and objects. Simply speaking, a Class is a definition of a real life object. For example, Human is a class for representing all human beings. Dog is a class to represent all Dogs. Classes can contain functions too. Animals is a namespace.

    Collapse | Copy Code
    Namespace Animals

    Dog is a class in the namespace Animals:

    Collapse | Copy Code
    Class Dog

    Bark is a function in this Class:

    Collapse | Copy Code
        Function Bark()        Console.Writeline ("Dog is barking")    End FunctionEnd ClassEnd Namespace

  • An Object

    An object is an instance of a Class. For example, Jimmy is an object of type Dog. We will create an object in the next section. Read on.

  • Modules

    You can use modules to write common functions. A Module is a group of functions. Unlike functions in classes, Public functions in modules can be called directly from anywhere else. VB provides Functions and Subroutines. Functions and Subroutines are almost the same, but the difference is that a subroutine can’t return a value.

    Collapse | Copy Code
    Public Module modMain

    Execution will start from the Main() subroutine:

    Collapse | Copy Code
    Sub Main()       'Call our function. See below       OurFunction()    End sub

    OurFunction: Our own little function to use the class Dog:

    Collapse | Copy Code
    Function OurFunction()           'Here is how we declare a variable Jimmy of type Dog.       'We use Animals.Dog because, the class Dog is in the       'namespace Animals (see above).           Dim Jimmy as Animals.Dog           'Create an object. Unlike in VB 6, it is not required to use       'the 'set' keyword.                  Jimmy = new Animals.Dog()           'Another way to create an object is       'Dim Jimmy as new Dog           'Call Jimmy's Main Function            Jimmy.Bark()End FunctionEnd module

 

The major access types are Public, Private, Friend and Protected. A Class may contain functions, variables etc., which can be either Public or Private or Protected or Friend. If they are Public, they can be accessed by creating objects of the Class. Private and Protected members can be accessed only by the functions inside the Class. Protected members are much like Private members, but they have some special use while inheriting a Class. We will see this later, in Inheritance (Lesson 5). Friend members can be accessed only by elements of the same project, and not by the ones outside the current project. Let us expand our dog class.

Import the System namespace (already available in .NET).

Collapse | Copy Code
Imports System

Animals is a namespace.

Collapse | Copy Code
Namespace Animals

Dog is a class in the namespace Animals.

Collapse | Copy Code
Public Class Dog    'A public variable        Public AgeOfDog as Integer

Bark is a function in this class. It is Public:

Collapse | Copy Code
    Public Function Bark()        Console.Writeline ("Dog is barking")    End Function

Walk is a function in this class. It is Private.

Collapse | Copy Code
    Private Function Walk()        Console.Writeline ("Dog is walking")    End FunctionEnd ClassEnd Namespace

Our Module:

Collapse | Copy Code
Public Module modMain

Execution will start from the Main() subroutine:

Collapse | Copy Code
Sub Main()       'Call our function. See below       OurFunction()    End sub    'OurFunction: Called from Main()    Function OurFunction()        Dim Jimmy as Animals.Dog        Jimmy=new Animals.Dog()        'This will work, because Bark & Ageofdog are public        Jimmy.Bark        Jimmy.AgeOfDog=10         'Calling the Walk function will not work here, because        'Walk() is outside the class Dog                'So this is wrong. Uncomment this and try to compile, it will        'cause an error.        'Jimmy.Walk    End Function        End Module
Additional Notes:

  • Encapsulation

    Putting all the data and related functions in a Class is called Encapsulation.

  • Data Hiding or Abstraction:

    Normally, in a Class, variables used to hold data (like the age of a dog) is declared as Private. Functions or property routines are used to access these variables. Protecting the data of an object from outside functions is called Abstraction or Data Hiding. This prevents accidental modification of data by functions outside the class.

Shared Functions

The shared members in a class (both functions and variables) can be used without creating objects of a class as shown. The Shared modifier indicates that the method does not operate on a specific instance of a type and may be invoked directly from a type rather than through a particular instance of a type.

Import the System namespace (already available in .NET).

Collapse | Copy Code
Imports System

Animals is a namespace.

Collapse | Copy Code
Namespace Animals

Dog is a class in the namespace Animals.

Collapse | Copy Code
Class Dog

Bark is a now a Public, shared function in this class.

Collapse | Copy Code
    Public Shared Function Bark()        Console.Writeline ("Dog is barking")    End Function

Walk is a Public function in this class. It is not shared.

Collapse | Copy Code
    Public Function Walk()        Console.Writeline ("Dog is walking")    End FunctionEnd ClassEnd Namespace

Our Module:

Collapse | Copy Code
Public Module modMain

Execution will start from the Main() subroutine.

Collapse | Copy Code
Sub Main()        'We can call the Bark() function directly,        'with out creating an object of type Dog -        'because it is shared.        Animals.Dog.Bark()        'We can call the Walk() function only        'after creating an object, because        'it is not shared.        Dim Jimmy as Animals.Dog        Jimmy=new Animals.Dog()        Jimmy.Walk()        'Now Guess? The WriteLine() function we used so far        'is a shared function in class Console :)         'Also, we can write the Main() function itself as a shared        'function in a class. i.e Shared Sub Main(). Try        'moving Main() from this module to the above classEnd subEnd Module
Overloadind

Overloading is a simple technique, to enable a single function name to accept parameters of different type. Let us see a simple Adder class. Import the System namespace (already available in .NET).

Collapse | Copy Code
Imports SystemClass Adder

Here, we have two Add() functions. This one adds two integers. Convert.ToString is equivalent to the good old CStr.

Collapse | Copy Code
    Overloads Public Sub Add(A as Integer, B as Integer)        Console.Writeline ("Adding Integers: " + Convert.ToString(a + b))    End Sub

This one adds two strings.

Collapse | Copy Code
    Overloads Public Sub Add(A as String, B as String)        Console.Writeline ("Adding Strings: " + a + b)    End Sub    'And both have the same name. This is possible because, we used the    'Overloads keyword, to overload them.    'Here, we have the Main Function with in this class. When you write.    'your main function inside the class, it should be a shared function.    Shared Sub Main()        Dim AdderObj as Adder        'Create the object        AdderObj=new Adder        'This will invoke first function        AdderObj.Add(10,20)        'This will invoke second function        AdderObj.Add("hello"," how are you")    End SubEnd Class
Inheritance

Inheritance is the property in which, a derived class acquires the attributes of its base class. In simple terms, you can create or ‘inherit’ your own class (derived class), using an existing class (base class). You can use the Inherits keyword for this.

Let us see a simple example. Import the System namespace (already available in .NET).

Collapse | Copy Code
Imports System

Our simple base class:

Collapse | Copy Code
Class Human    'This is something that all humans do    Public Sub Walk()        Console.Writeline ("Walking")    End SubEnd Class

Now, let us derive a class from Human.

A Programmer is a Human.

Collapse | Copy Code
Class Programmer    Inherits Human    'We already have the above Walk() function    'This is something that all programmers do ;)     Public Sub StealCode()        Console.Writeline ("Stealing code")    End SubEnd Class

Just a MainClass.

Collapse | Copy Code
Class MainClass    'Our main function    Shared Sub Main()        Dim Tom as Programmer        Tom=new Programmer                'This call is okie because programmer got this function        'from its base class        Tom.Walk()                'This is also correct because Tom is a programmer        Tom.StealCode()    End SubEnd Class
Additional Notes:
  • MustInheritThe MustInherit keyword specifies that a class cannot be instantiated and can be used only as a base class. I.e., if you declare our Human class as “MustInherit Class Human“, then you can’t create objects of type Human without inheriting it.
  • NotInheritableThe NotInheritable keyword specifies that a class cannot be inherited. I.e., if you specify ‘NotInheritable Class Human‘, no derived classes can be made from the Human class.
Overriding

By default, a derived class Inherits methods from its base class. If an inherited property or method needs to behave differently in the derived class it can be overridden; that is, you can define a new implementation of the method in the derived class. The Overridable keyword is used to mark a function as overridable. The keyword Overrides is used to mark that a function is overriding some base class function. Let us see an example.

Import the System namespace (already available in .NET).

Collapse | Copy Code
Imports System

Our simple base class:

Collapse | Copy Code
Class Human    'Speak() is declared Overridable    Overridable Public Sub Speak()        Console.Writeline ("Speaking")    End SubEnd Class

Now, let us derive a class from Human:

An Indian is a Human:

Collapse | Copy Code
Class Indian    Inherits Human    'Let us make Indian speak Hindi, the National Language    'in India    'Speak() is overriding Speak() in its base class (Human)    Overrides Public Sub Speak()        Console.Writeline ("Speaking Hindi")    'Important: As you expect, any call to Speak() inside this class    'will invoke the Speak() in this class. If you need to    'call Speak() in base class, you can use MyBase keyword.    'Like this    'Mybase.Speak()    End SubEnd Class

Just a class to put our Main().

Collapse | Copy Code
Class MainClass    'Our main function    Shared Sub Main()        'Tom is a generic Human        Dim Tom as Human        Tom=new Human        'Tony is a human and an Indian        Dim Tony as Indian        Tony=new Indian        'This call will invoke the Speak() function        'in class Human        Tom.Speak()        'This call will invoke the Speak() function        'in class Indian        Tony.Speak()    End SubEnd Class
Polymorphism

Polymorphism is the property in which a single object can take more than one form. For example, if you have a base class named Human, an object of Human type can be used to hold an object of any of its derived type. When you call a function in your object, the system will automatically determine the type of the object to call the appropriate function. For example, let us assume that you have a function named speak() in your base class. You derived a child class from your base class and overloaded the function speak(). Then, you create a child class object and assign it to a base class variable. Now, if you call the speak() function using the base class variable, the speak() function defined in your child class will work. On the contrary, if you are assigning an object of the base class to the base class variable, then the speak() function in the base class will work. This is achieved through runtime type identification of objects. See the example.

Import the System namespace (already available in .NET).

Collapse | Copy Code
Imports System

This example is exactly the same as the one we saw in the previous lesson. The only difference is in the Shared Sub Main() in the class MainClass. So scroll down and see an example:

Our simple base class:

Collapse | Copy Code
Class Human    'Speak() is declared Overridable    Overridable Public Sub Speak()        Console.Writeline ("Speaking")    End SubEnd Class

Now, let us derive a class from Human.

An Indian is a Human.

Collapse | Copy Code
Class Indian    Inherits Human    'Let us make Indian speak Hindi, the National Language    'in India    'Speak() is overriding Speak() in its base class (Human)    Overrides Public Sub Speak()        Console.Writeline ("Speaking Hindi")    'Important: As you expect, any call to Speak() inside this class    'will invoke the Speak() in this class. If you need to    'call Speak() in base class, you can use MyBase keyword.    'Like this    'Mybase.Speak()    End SubEnd Class

Carefully examine the code in Main():

Collapse | Copy Code
Class MainClass    'Our main function    Shared Sub Main()        'Let us define Tom as a human (base class)        Dim Tom as Human        'Now, I am assiging an Indian (derived class)        Tom=new Indian        'The above assignment is legal, because        'Indian IS_A human.        'Now, let me call Speak as        Tom.Speak()        'Which Speak() will work? The Speak() in Indian, or the        'Speak() in human?        'The question arises because, Tom is declared as a Human,        'but an object of type Indian is assigned to Tom.        'The Answer is, the Speak() in Indian will work. This is because,        'most object oriented languages like Vb.net can automatically        'detect the type of the object assigned to a base class variable.        'This is called Polymorphism    End SubEnd Class
Constructors & Destructors

Import the System namespace (already available in .NET).

Collapse | Copy Code
Imports System

A Constructor is a special function which is called automatically when a class is created. In VB.NET, you should use useNew() to create constructors. Constructors can be overloaded (see Lesson 4), but unlike the functions, the Overloads keyword is not required. A Destructor is a special function which is called automatically when a class is destroyed. In VB.NET, you should use useFinalize() routine to create Destructors. They are similar to Class_Initialize and Class_Terminate in VB 6.0.

Dog is a class:

Collapse | Copy Code
Class Dog    'The age variable    Private Age as integer

The default constructor:

Collapse | Copy Code
    Public Sub New()        Console.Writeline ("Dog is Created With Age Zero")        Age=0    End Sub

The parameterized constructor:

Collapse | Copy Code
    Public Sub New(val as Integer)        Console.Writeline ("Dog is Created With Age " + Convert.ToString(val))        Age=val    End Sub

This is the destructor:

Collapse | Copy Code
    Overrides Protected Sub Finalize()        Console.Writeline ("Dog is Destroyed")    End Sub    'The Main Function    Shared Sub Main()        Dim Jimmy, Jacky as Dog        'Create the objects        'This will call the default constructor        Jimmy=new Dog        'This will call the parameterized constructor        Jacky=new Dog(10)    End Sub    'The Destruction will be done automatically, when    'the program ends. This is done by the Garbage    'Collector.End Class

Property Routines

You can use both properties and fields to store information in an object. While fields are simply Public variables, properties use property procedures to control how values are set or returned. You can use the Get/Set keywords for getting/setting properties. See the following example. Import the System namespace (already available in .NET).

Collapse | Copy Code
Imports System

Dog is a class.

Collapse | Copy Code
Public Class Dog    'A private variable    to hold the value    Private mAgeOfDog as Integer

This is our property routine:

Collapse | Copy Code
Public Property Age() As Integer    'Called when someone tries to retreive the valueGet    Console.Writeline ("Getting Property")    Return mAgeOfdogEnd GetSet(ByVal Value As Integer)    'Called when someone tries to assign a value         Console.Writeline ("Setting Property")    mAgeOfDog=ValueEnd SetEnd PropertyEnd Class

Another class:

Collapse | Copy Code
Class MainClass    'Our main function. Execution starts here.    Shared Sub Main()    'Let us create an object.    Dim Jimmy as Dog    Jimmy=new Dog            'We can't access mAgeofDog directly, so we should    'use Age() property routine.    'Set it. The Age Set routine will work    Jimmy.Age=30    'Get it back. The Age GEt routine will work    Dim curAge=Jimmy.Age()    End SubEnd Class

 

Let us analyze a simple program. First, let us import the required namespaces:

Collapse | Copy Code
Imports SystemImports System.ComponentModelImports System.Windows.FormsImports System.Drawing    'We are inheriting a class named SimpleForm, from the    'class System.Windows.Forms.Form    '    'i.e, Windows is a namespace in system, Forms is a    'namespace in Windows, and Form is a class in Forms.Public Class SimpleFormInherits System.Windows.Forms.Form        'Our constructorPublic Sub New()    'This will invoke the constructor of the base    'classMyBase.New()

Set the text property of this class. We inherited this property from the base class:

Collapse | Copy Code
Me.Text = "Hello, How Are You?"End SubEnd Class
Collapse | Copy Code
Public Class MainClass    Shared Sub Main()        'Create an object from our SimpleForm class        Dim sf as SimpleForm        sf=new SimpleForm                'Pass this object to the Run() function to start         System.Windows.Forms.Application.Run(sf)    End SubEnd Class

That is it. Now you can atleast read and understand most of those VB.NET source code, and probably implement more OOP features in your VB.NET programs. Now, in my next article, I’ll try to cover the patterns and practices in VB.NET.

vb.dot net book(pdf)

Posted in .NET | Tags: , ,

«
»

Categories