Visual Basic .NET


Visual Basic .NET is the next revision of the popular Visual Basic programming language, which has roots in the BASIC programming language itself. Known for its rapid application development capability, Visual Basic .NET provides developers with the benefits of rapid development with a full-blown object-oriented (OO) programming language. Visual Basic .NET builds on the basic OO features present in Visual Basic and makes the object-orientedness of the language on par with that of Visual C# and even C++.

With its human-readable code syntax, Visual Basic .NET follows a task-oriented model. Focus on increased developer productivity still remains the core mantra for Visual Basic. Key features of the Visual Basic .NET programming language include the following:

  • A full, object-oriented, yet intuitive, programming language

  • Typical VB features such as implicit typing, late binding, default variable initialization, and optional parameters

  • Enhanced event handling

  • Parameterized properties

  • Redeclaration of interface members on implementation

  • Command-line/SDK compilers

Hello World

The program listing that follows will look both familiar and different to existing Visual Basic programmers. Familiar is the overall style, subroutines, and modules. What is different in the program is really the additional keyword ”Namespace ”and the use of the .NET Framework class library. An important thing to keep in mind is that Visual Basic .NET not a case-sensitive programming language.

LEVERAGE YOUR VB SKILLS WITH VISUAL BASIC .NET

A key highlight of the Visual Basic .NET programming language is that it allows developers to utilize their existing skills in Visual Basic development. Apart from skills reuse, Visual Basic .NET supports importing existing Visual Basic projects for migration.


 
 Imports System Namespace hks     Module HelloWorld         Public Sub Main()             Console.WriteLine("Hello World in VB")         End Sub     End Module End Namespace 

Visual Basic .NET programs are stored with the .vb extension. To compile a Visual Basic .NET program, use the Visual Basic. NET J# command-line compiler, vbc.exe.

 
 vbc HelloWorld.vb 

Comments

Visual Basic comments are plain old ' style line comments or are identified by Rem.

 
 Imports System Namespace hks     Module Comments         Rem Implement the Main Method         Public Sub Main()             ' Print Out Hello World             Console.WriteLine("Hello World in VB")         End Sub     End Module End Namespace 

Data Types

Table 3.2 describes how the Visual Basic .NET types are mapped to their corresponding .NET Framework types.

Table 3.2. Visual Basic .NET Data Types

VISUAL BASIC .NET TYPE

CORRESPONDING .NET FRAMEWORK TYPE

Boolean

System.Boolean

Byte

System.Byte

Char

System.Char

Decimal, Double, Single

System.Decimal, System.Double, System.Single

Short, Integer, Long

System.Int16, System.Int32, System.Int64

Object

System.Object

String

System.String

Enumerations

Enumerations are supported in Visual Basic .NET. Listing 3.6 illustrates a potential use.

Listing 3.6 Using Enumerations (Visual Basic .NET)
 Imports System Namespace hks     Module UseEnumerations         Public Enum CreditCard             Visa             MasterCard             AmericanExpress             Discover         End Enum         Public Sub Main()             Dim cc as CreditCard             cc = CreditCard.Visa             Console.WriteLine(cc)         End Sub     End Module End Namespace 

Arrays

Arrays, which are subclasses of the System.Array type, are supported in Visual Basic .NET (Listing 3.7).

Listing 3.7 Using Arrays (Visual Basic .NET)
 Imports System Namespace hks     Module UseArrays         Public Sub Main()             Dim days_of_week() as String = { _                 "Sunday", _                 "Monday", _                 "Tuesday", _                 "Wednesday", _                 "Thursday", _                 "Friday", _                 "Saturday" _             }             Dim I as Integer             For I = 0 to days_of_week.Length-1                 Console.WriteLine(days_of_week(I))             Next I         End Sub     End Module End Namespace 

Variables and Constants

Using variables is similar to the traditional Visual Basic programming, using the Dim keyword (see Listing 3.8).

Listing 3.8 Using Enumerations (Visual Basic .NET
 Imports System) Namespace hks     Module UseVariables         Public Sub Main()             Const HELLO_WORLD as String = "Hello World"             Dim msg as String = HELLO_WORLD & " in VB"             Dim mc as New MClass(msg)             Call mc.Print         End Sub     End Module     Class MClass         private message as String         Public Sub New(ByVal message as String)             Me.message = message         End Sub         Public Sub Print()             Console.WriteLine(message)         End Sub     End Class End Namespace 

Expressions

Expressions provide the capability to computerize and manipulate data.

 
 Imports System Namespace hks     Module UseExpressions         Public Sub Main()             Dim a as Integer = 10             Dim b as Integer = 10             Dim result as Integer = a * b             Dim check as Boolean = (a = b)             Console.WriteLine(result)             Console.WriteLine(check)         End Sub     End Module End Namespace 

Statements

Statements provide the necessary programming language procedural constructs.

 
 Imports System Namespace hks     Module UseStatements         Public Sub Main()             Dim msg() as String = {"Hello","World","in","Visual Basic.NET"}             Dim i as Integer             For i = 0 to (msg.Length-1)                 Console.Write(msg(i))             Next             Console.WriteLine("")             Dim a as Integer = 10             Dim b as Integer = 20             If (a<b) Then                 Console.WriteLine("a<b")             Else                 Console.WriteLine("a>=b")             End If         End Sub     End Module End Namespace 

Structures

Structures can be used for basic encapsulation of data.

 
 Imports System Namespace hks     Module UseStructures         Public Sub Main()             Dim hs as New Person("Hitesh","Seth")             Dim jd as Person = hs             jd.FirstName = "John"             jd.LastName = "Doe"             Console.WriteLine(hs.FirstName & "." & hs.LastName)             Console.WriteLine(jd.FirstName & "." & jd.LastName)         End Sub     End Module     Structure Person         Public FirstName, LastName as String         Public Sub New(ByVal FirstName as String, ByVal LastName as String)             Me.FirstName = FirstName             Me.LastName = LastName         End Sub     End Structure End Namespace 

Classes

Classes in Visual Basic are defined using the Class keyword. Like C#, VB classes can have members, constructors and destructors, properties, methods (which are classified into subroutines and functions, depending on whether they return a value), and events (Listing 3.9).

Listing 3.9 Using Classes (Visual Basic .NET)
 Imports System Namespace hks     Module Useclasses         Public Sub Main()             Dim hs as New Person("Hitesh","Seth")             Dim jd as Person = hs             jd.FirstName = "John"             jd.LastName = "Doe"             Console.WriteLine(hs.FirstName & "." & hs.LastName)             Console.WriteLine(jd.FirstName & "." & jd.LastName)         End Sub     End Module     Public Class Person         Private sFirstName, sLastName as String         Public Property FirstName() as String             Get                 Return sFirstName             End Get             Set(ByVal Value as String)                 sFirstName = Value             End Set         End Property         Public Property LastName() as String             Get                 Return sLastName             End Get             Set(ByVal Value as String)                 sLastName = Value             End Set         End Property         Public Sub New(ByVal FirstName as String, ByVal LastName as String)             Me.FirstName = FirstName             Me.LastName = LastName         End Sub         Public Function GetFullName() as String             Return Me.FirstName & "." & Me.LastName         End Function     End Class End Namespace 

Classes can be inherited for overriding and extending functionality present in the base class. The keywords Overridable and Overrides are used to set a method in base class as overridable and implementation of the overridden method in the derived class, respectively (Listing 3.10). Similar to C#, Visual Basic .NET also supports only single inheritance.

Listing 3.10 Using Inheritance (Visual Basic .NET)
 Imports System Namespace hks     Module HelloWorld         Public Sub Main()             Dim hs as New FullPerson("Hitesh","K","Seth")             Console.WriteLine(hs.GetFullName)         End Sub     End Module     Public Class Person         Public FirstName, LastName as String         Public Sub New(ByVal FirstName as String, ByVal LastName as String)             Me.FirstName = FirstName             Me.LastName = LastName         End Sub         Public Overridable Function GetFullName() as String             Return Me.FirstName & "." & Me.LastName         End Function     End Class     Public Class FullPerson         Inherits Person         Public MiddleInitial as String         Public Sub New(ByVal FirstName as String,                ByVal MiddleInitial as String, ByVal LastName as String)             MyBase.New(FirstName,LastName)             Me.MiddleInitial = MiddleInitial         End Sub         Public Overrides Function GetFullName() as String             Return Me.FirstName & "." & Me.MiddleInitial & "." & Me.LastName         End Function     End Class End Namespace 

Visual Basic .NET supports abstract classes by using the MustInherit and MustOverride keywords (Listing 3.11).

Listing 3.11 Using Abstract Classes (Visual Basic .NET)
 Imports System Namespace hks     Module UseAbstractClasses         Public Sub Main()             Dim hs as New Person("Hitesh","Seth")             Console.WriteLine(hs.FirstName & "." & hs.LastName)         End Sub     End Module     Public MustInherit Class Abstract         Public FirstName, LastName as String         Public Sub New(ByVal FirstName as String, ByVal LastName as String)             Me.FirstName = FirstName             Me.LastName = LastName         End Sub         Public MustOverride Function GetFullName as String     End Class     Public Class Person         Inherits Abstract         Public Sub New(ByVal FirstName as String, ByVal LastName as String)             MyBase.New(FirstName,LastName)         End Sub         Public Overrides Function GetFullName as String             GetFullName = FirstName & "." & LastName         End Function     End Class End Namespace 

Interfaces

Visual Basic .NET supports interfaces through the Interface keyword. A derived class can implement multiple interfaces and specifies the specific function/subroutine signature implemented through the Interface keyword (Listing 3.12).

Listing 3.12 Using Interfaces (Visual Basic .NET)
 Imports System Namespace hks     Module UseInterfaces         Public Sub Main()             Dim hs as New Person             hs.Name = "Hitesh Seth"             hs.Address = "1 Executive Drive, City, NJ 08520"             Console.WriteLine(hs.GetName())             Console.WriteLine(hs.GetAddress())         End Sub     End Module     Public Interface IName         Function GetName() as String     End Interface     Public Interface IAddress         Function GetAddress() as String     End Interface     Public Class Person         Implements IName, IAddress         Private s_name, s_address as String         Public Sub New()         End Sub         Public WriteOnly Property Name() as String             Set                 s_name = value             End Set         End Property         Public WriteOnly Property Address() as String             Set                 s_address = value             End Set         End Property         Public Function GetName() as String Implements IName.GetName             GetName = s_name         End Function         Public Function GetAddress() as String Implements IAddress.GetAddress             GetAddress = s_address         End Function     End Class End Namespace 

Exception Handling

New to Visual Basic .NET is structured exception handling, as illustrated in Listing 3.13. Visual Basic typically had the OnError/Goto construct for handling exceptions.

Listing 3.13 Exception Handling (Visual Basic .NET)
 Imports System Namespace hks     Module UseExceptions         Public Sub Main()             Try                 Dim a as Integer = 10                 Dim b as Integer = 10                 Dim c as Integer                 c = a/(a-b)             Catch ex as Exception                 Console.WriteLine(ex.Message)             End Try         End Sub     End Module End Namespace Imports System 

Similar to C#, apart from handling the extensive set of extensions defined by the .NET Framework library, custom exceptions can also be defined by subclassing the Exception class (Listing 3.14).

Listing 3.14 Creating Custom Exceptions (Visual Basic .NET)
 Namespace hks     Module UseCustomExceptions         Public Sub Main()             Try                 Dim big_discount as new Discount(56)             Catch ex as Exception                 Console.WriteLine(ex.Message)             End Try         End Sub     End Module     Public Class Discount         Private percent as Integer         Public Sub New(ByVal percent as Integer)             Me.percent = percent             If (percent > 50) Then                 Throw New TooBigDiscountException("Discount > 50%")             End If         End Sub     End Class     Public Class TooBigDiscountException         Inherits Exception         Public Sub New(ByVal msg as String)             MyBase.New(msg)         End Sub     End Class End Namespace 

Delegates

New to Visual Basic .NET is the capability of using delegates or function pointers (Listing 3.15).

Listing 3.15 Using Delegates (Visual Basic .NET)
 Imports System Namespace hks     Module Use Delegates         Delegate Sub MyDelegate(ByVal msg as String)         Public Sub Main()             Dim msg As String = "Hello Delegates"             Dim d1 as MyDelegate = AddressOf PrintOnce             Dim d2 as MyDelegate = AddressOf PrintTwice             d1(msg)             d2(msg)         End Sub         Public Sub PrintOnce(ByVal msg as String)             Console.WriteLine(msg)         End Sub         Public Sub PrintTwice(ByVal msg as String)             Console.WriteLine("1." & msg)             Console.WriteLine("2." & msg)         End Sub     End Module End Namespace 

Events

Visual Basic developers have traditionally enjoyed the benefits of an easy-to-use event handling system (Listing 3.16).

Listing 3.16 Using Events (Visual Basic .NET)
 Imports System Namespace hks     Module Events         Friend WithEvents button As Button         Public Sub Main()             button = New Button()             button.Click         End Sub         Public Sub Button_OnClick Handles button.OnClick             Console.WriteLine("Button Clicked")         End Sub     End Module     Public Class Button         Public Event OnClick         Public Sub Click()             RaiseEvent OnClick()         End Sub     End Class End Namespace 


Microsoft.Net Kick Start
Microsoft .NET Kick Start
ISBN: 0672325748
EAN: 2147483647
Year: 2003
Pages: 195
Authors: Hitesh Seth

flylib.com © 2008-2017.
If you may any questions please contact us: flylib@qtcs.net