VB.

NET

The .NET Framework Architecture:

The .NET framework is a software technology that is directed towards connecting information, people,
systems and devices seamlessly. The high level of software integration that has been attempted
through use of XML web services enables the creation of small, discrete, building block types of
applications. These applications are connected to other applications over the Internet.
Central to the .NET framework architecture is the effort to provide support to for the next generation
solutions. The direction of change is to ensure that software deployment and versioning conflicts are
avoided or minimized in the .NET Framework. User defined codes are released from the confines of the
local storage systems and can be stored anywhere on a network and executed from any point in the
network. Performance problems associated with scripted and interpreted environments are removed.
Codes can be safely executed and the developer experience is consistent across widely varying types
of applications, such as Windows based applications and web based applications. The thrust of design
is towards creating a standard communication facility that is standardized so that .NET codes can be
integrated with other codes easily and seamlessly.
At the core of the .NET infrastructure is the Common Language Runtime (CLR) and the .NET
Framework class library.
The runtime functions, like an agent, managing code at execution time. It provides core services such
as memory management, thread management and ‘remoting’. It enforces strict type safety and ensures
code accuracy. This makes for security and robustness and provides a platform for running managed
code.
The .NET Framework provides several runtime hosts. It also supports the development of third-party
runtime hosts. For example, ASP.NET hosts the runtime to provide a scalable, server-side environment
for managed code. ASP.NET works directly with the runtime to enable ASP.NET applications and XML
Web services.
The .NET Framework can be hosted by unmanaged components such as the Internet Explorer. These
load the common language runtime into their processes and initiate the execution of managed code.
This creates a software environment that can exploit both managed and unmanaged features. This
makes for mobility of the code.
Common Language Runtime (CLR)
The common language runtime (CLR) is the foundation upon which developers construct various kinds
of applications. The benefits of the CLR are many. It makes for a vastly simplified development. It
enables a seamless integration of code written in different languages. It provides evidence-based
security with code identity. The assembly based deployment eliminates the problems of DLL. The
versioning of reusable components makes for ease of usage. The implementation inheritance feature
enables the reuse of code. The automatic object lifetime management makes the application-
development comfortable. The self descriptive nature of objects makes for ease of programming and
debugging.
CLR includes both private and shared components. It provides for incremental download of code and
caching; native platform interoperability and seamless integration with COM. It offers dynamic
inspection capabilities, administration and configuration options. The developer is not required to know
all the runtime supported infrastructure. The tools and frameworks are designed to expose a subset of
the functionality in accordance with the kind of application being built.
The common language runtime is a virtual execution system that provides important services such as
memory management, security and also has a Just-in-Time compiler (JIT) which converts the
intermediate language (IL) into native code that can be executed by the physical machine. The
infrastructure provides a machine independent environment for application execution.
Tight security is maintained in implementing common language runtime. Managed components are
awarded varying degrees of trust. Access rights are determined by factors such as origin of the
component (Internet, enterprise network, or local computer). On the flip side this restricts access to file
and registry operations, even if the file being operated upon is on within the same active application.
The managed environment of the runtime eliminates many common software issues. For example, the
runtime automatically handles object layout and manages references to objects, releasing them when
they are no longer being used. This automatic memory management resolves the two most common
application errors--memory leaks and invalid memory references.
The futuristic design of the infrastructure is takes into consideration the need to integrate with the
legacy applications that are still in operation.
Interoperability between managed and unmanaged code enables developers to continue to use
necessary COM components and DLLs.
The use of ‘Common type’ system implements the features of the .NET infrastructure. The common
data types shared by multiple languages such as VB.NET, C#, ASP.NET eases the import of a class
created in one language into another. A common error handling facility makes for tighter integration
between languages and allows developers the freedom of working in the language of their choice.
.NET Framework Class Library
The .NET framework class library, as the name suggests, is a library of classes, interfaces and value
types. The applications, components and controls for applications are built on this framework and it
provides the developer the access to the system functionality. In other words, the classes and
structures can be leveraged as base building blocks for application development. These classes are
often described as an API and form a boundary interface between the application and the operating
system. Though the concept is not new to Visual basic Developers who have been using the ADO
library, the Win 32 API and COM + services, it forms a massive code base on which the application can
be built.

The .NET Framework class Library is organized into namespaces. The namespace is a container for
functionality. Similar classes and constructs are grouped together in a namespace to define parent-
child relationships. Namespaces can be nested into namespaces.
All namespaces stem from the root namespace called System Namespace. It contains all data types
including the Object data type. Though all namespaces are subordinated to the System namespace,
User defined libraries can also coexist with the System namespace. They can have their own root
namespace which can be language focused namespaces such as Microsoft.Csharp,
Microsoft.VisualBasic.
The most significant feature of the .NET framework is the class Library collection of reusable types can
be integrated with CLR. The programmer can accomplish a range of common programming tasks, such
as string management; data collection; data base connectivity and file access using the .NET
framework class library. The developer can create console applications, Windows GUI applications,
ASP.NET applications, XML Web services or Windows services.
Microsoft Intermediate Language (MSIL)
MSIL are simple binary structures that are similar to the instruction sets of the CPU. Like the instruction
set, it encodes a wide spectrum of operations such as loading, storing, arithmetic and logical operations
and control flow. The similarity to the machine code enables the code to be compiled quickly in the Just
in time compiler. The type verification also becomes simpler because the DotNet binary contains tables
of metadata. The metadata defines each type and its signatures and also the other data that the
runtime locates and extracts from the file at the time of execution. The presence of the metadata makes
the module self descriptive and eliminates the need for IDL files and header files. However, unlike the
CPU instruction set, MSIL expresses object oriented concepts such as object creation, method
invocation, property access and exception handling.
It is the Microsoft Intermediate Language (MSIL) which makes applications language independent.
Applications may be created by programmers in any language of their choice—ASP.NET or VB.NET—
in a machine on which the .NET framework has been installed. The compiler then, gives an output in
the Microsoft Intermediate language. This language can be defined as a kind of assembly language at
a higher level of abstraction. The language is designed in a manner that makes it possible to convert it
into any kind of native machine code with ease. The CLR detects the Intermediate language and
invokes the Just-in-time compiler to convert the language into machine code.
In the next tutorial The .NET Framework Architecture Part 2 we will learn about Just-In-Time
(JIT) compilation, Assemblies, native assemblies, and the Global Assembly Cache (GAC).
Please let us know your feedback helps us to improve this training.
Just-In-Time (JIT) compilation
As stated above, the Just in time compiler is a facility that is invoked by the CLR to convert the IL into
machine code. The .NET framework assemblies (*.dll or *.exe) files cannot be executed by the target
processor unless it is converted into native code. When the Assembly is loaded the method calls are
invoked for compilation into native code. Since this is done just when the method needs to execute, it is
called Just in time compilation. When the JIT is invoked for the first time there is an overhead or
performance penalty, since the assembly is converted into its Native code or image using the Native
Image Generator (Ngen.exe). All subsequent calls will load faster as the Native image alone is invoked
thereafter from the Native image cache.
Significantly, the IL can coexist with the machine code in the application. This feature also enables the
developer modify the code or add to the code even when the application is actively deployed. This
functionality provided by JIT makes the .NET framework an efficient, agile and powerful means of
application development.
Assemblies, native assemblies, and the Global Assembly Cache (GAC)
The primary unit of deployment is the assembly. The assembly is used by the .NET CLR as the
smallest unit of deployment; version control; security; type grouping and code reuse. An assembly will
consist of a manifest and one or more modules or files. It can be defined as a logical DLL that contains
a manifest, type metadata, MSIL and resources. Assemblies can be application private or shared.
Private assemblies are restricted to use in a single application whereas shared assemblies can be used
across applications. Private applications also reside within the application folder while shared
assemblies reside in the common area-- GAC(Global Assembly Cache). They must have a globally
unique name.
The existence of the manifest within the assembly makes it self descriptive. It can be viewed by the IL
Disassembler (Ildasm.exe) which is part of the .NET framework SDK.
The assembly is identified by the manifest. It defines security requirements, lists other interdependent
assemblies and all the types and resources exposed by the assembly. Localized resources exposed by
assemblies and targeted by the application contain a default culture (language, currency, date/time
format etc).
The manifest contains several sections. Identity, Referenced Assemblies, file list and Custom Attributes
are some of the important sections of the manifest. The Identity section as the name suggests,
identifies the assembly. It contains a .assembly directive. The version directive specifies the version of
the assembly, so that the CLR identifies the different versions of an application. The Identity section
contains a strong name for shared assemblies and a public/private encryption key is used to distinguish
between assemblies of the same name. The Identity section also optionally contains the Culture which
defines the country and language of the assembly target. The .locale directive is used for this purpose
and the Culture-Neutral assemblies can be used by any assembly.
The Referenced Assemblies section of the manifest provides a reference to all the assemblies used in
an application.
Comparison of VB.NET, C#, and J#
The .NET framework architecture has made the language of coding immaterial to the final output. All
languages also have equal access to all development capabilities and revolve around the .NET
classes. The language syntax, operations etc look similar in all the languages of this group. Moreover,
code can be shared by all .NET languages and so a class made in C# or J# can be used in VB.NET
and vice versa.
In this context choice of language is no longer significant. Finally, all languages are transformed by the
compiler into Microsoft Intermediate language. It is the programmer’s familiarity with the language that
makes it material whether he is coding in VB.NET or C# or J#. However, the option settings in the
compiler will have to be set to the language of coding before the compiler is used.
The speed of performance of the compiler will also vary with the language being compiled. For instance
C# compiles faster than VB.NET. Subject to the above observation, the features of the languages will
be dicussed in the next tutorial.
Differences between VB.NET 1.0 and VB.NET 2.0
VB.NET 2005 comes with a number of enhancements. The IntelliSense Code snippets, the Windows
Forms designer updates, IntelliSense filtering, debugger data tips, exception Assistant etc make the
software a pleasure to work with. The language has been spruced up with generics, unsigned types,
Operator overloading etc.
The My Namespace is the most significant enhancement that provides a single reference to commonly
used functionalities within the .NET framework. It includes classes like Application, Computer, Forms,
Resources, Settings and Users. This enables users to ping a computer with a simple line of code or
play a audio file with a one line code.
Example:
My Computer Audio Play(“….\*(name of file).wav)
A number of mundane problems being faced by coders have been solved in the process. The
IntelliSense has taken away much of the pain of development by correcting errors and making
suggestions even during the process of development. This improves the quality of codes and reduces
the time taken to develop and debug large applications.
New Operators
A number of new operators have been introduced into the language to facilitate the coder. For instance
the IsNot operator facilitates comparisons with Nothing. This was not possible earlier.
Just My Code
This feature of VB.NET enables the coder to skip over all the code that was not written by him. This is
extremely useful when debugging custom code as all machine generated code is avoided. This feature
becomes enabled when “Enable Just My Code Stepping” option is activated. This feature is enabled by
default but can be disabled by the coder if he wishes to.
Support for Generics
The .NET framework has attempted to overcome some of the limitations of VB 6 with regard to
collections. Errors in object storage under a collection, which were detectable at compile time has been
resolved by providing the coder with many more types of collections. The coder can now import
Systems Collections namespace which gives access to BitArray, HashTable, Queue, StoredList and
Stack. In other words use of Generics has solved the problems in .NET Framework 2005.
Certain new concepts have been introduced in VB.NET 2005. The Operator overloading feature allows
the coder define the behavior of classes when used with intrinsic language operators such as +, -,<,>,=,
and <>. The appropriate outcome for operations are defined when applied to instances for user defined
classes.
The DotNet Framework architecture has revolutionized the process of application development. In the
lessons that follow we will be examining in greater detail how this framework helps the Visual Basic.
NET developer.
Introducing Windows Forms
Designing Windows Application is simpler and less time consuming with Visual Basic 2005. A number
of new facilities and enhancements have been made to assist the developer complete the project in
time and with lesser number of errors. Windows Form is the cynosure of the Windows Application.
Visual studio 2005 packs more features to the already enriched area of Windows Forms, both at design
and run time. Among the several features that have been added some standout as prominent. The
management of layout of the form is made easier by providing the snap lines that make it easy to align
controls with other controls as the layout is formed. A new deployment technology called ClickOnce for
forms is added.
Creating a Windows Application
1. Understanding Classes, Inheritance, and Namespaces
2. Using The System.Windows.Forms.Form class
3. Designing a Form using Windows Forms Designer
4. Exploring the Forms Designer generated code
5. Using the Application class
6. Using the MessageBox class
Setting and Adding Properties to a Windows Form
1. Using the Visual Designer to set Windows Form Properties
2. Setting Windows Forms Properties programatically
3. Adding new Property to a Windows Form
4. Using Visual Inheritance
Event Handling
1. Handling Events by attaching a delegate
2. Handling Events by overriding protected method of base class.
Building graphical interface elements
1. Understanding The Graphics Object
 2. Understanding The Windows Forms Coordinate System
3. Drawing Text on a Form
4. Drawing Shapes
Implementing Class Library Object in VB.NET 2005
Class: Classical Object Oriented Concepts explain a class as a cookie cutter. A class allows you to
create objects of the class. As a programmer you define a class with data fields, properties, methods
and events. Then you can create objects based on that class that have state (fields, properties) and
behavior (methods, events). A class can be considered as a specification of how the object of the class
should look like and behave.
An object of the class is nothing other than a sequence of bytes at a specific memory location in the
memory heap. Thus we can understand that an object is an instance of the class. We can see an
illustration of a class.
Let's see an illustration of a class
Public Class Class1
Private VehicleType As String
Private VehicleModel As String
Private VehicleColor As String
Public Sub Accelerate()
' add code to Accelerate
End Sub
ReadOnly Property engineCapacity() As Decimal
Get
Return engineCapacity
End Get
End Property
End Class
Creating a Class Library project
1. On the File menu, select New Project.
2. On the Templates pane, in the New Project dialog box, click Class Library.
3. In the Name box, type DemoClass1 and then click OK.
4. A new Class Library project opens, and the Code Editor displays the Class module
Class1.vb.
5. In the Solution Explorer, right-click Class1.vb and select Rename, and then change the
name to DemoClass1.vb.
6. Note that the name in the Code Editor also changed to DemoClass.vb.
7. On the File menu, select Save All.
8. In the Save Project dialog box, click Save
Let us see the screen shots for doing this exercise:

Opening the new project:

Codes for the new DemoClass1
Designing .NET Class Libraries: Conclusion and Q&A Session Video Presentations
Introduction and Implementing Inheritance in VB.NET 2005
The usefulness of inheritance is depnding on the choice of its usage. You can use inheritance if the
derived class is a kind of base class but not has a relationship with the base class. Such a situation
empowers you to reuse the code from the base class. It is also more useful if the hierarchy is very
shallow. The developer can effect global changed to the derived class by changing the base class.
Understanding Inheritance
Inheritance is an important feature of any OOP Language. Let us examine the following lines of code:
Public Class DemoForm
Inherits System.Windows.Forms.Form
…………
End Class
Note the use of public in the above code. You can use any of the four access specifiers namely Public,
Private, Protected, and private, while declaring the classes. This usage depends upon the need of the
program to make the other classes capable of inheriting from this class.
Note the use of public in the above code. You can use any of the four access specifiers namely Public,
Private, Protected, and private, while declaring the classes. This usage depends upon the need of the
program to make the other classes capable of inheriting from this class.
In the above code we have created a new class DemoForm based on the class
System.Windows.Forms.Form. The new class DemoForm is the derived class and the class Form is
the base class.
Some of the points of interest about inheritances are given below:
• In Visual Basic .NET only single inheritance is permitted; that is, any derived class can
have only one base class
• You can inherit all classes except those marked with keywork NotInheritable.
• You can restrict certain items in base class from being exposed by using access
specifiers. Access type of a derived class must be equal or more restrictive than its base
class for the inheritance to succeed.
Inherits keyword is used before the base class to specify the base class. MustInherit modifier is used to
specify that the class is intended for use as a base class only.
The derived class inherits all the methods defined in the base class by default. You may come across
some instances that a particular method needs to behave differently in the derived class. In such a
case, the method can be overridden in the derived class. In this case you have to specify a new
implementation of the method in the derived class. This is possible only if the method in the base class
is marked with keywork overridable.
The method in the derived class should be declared as overrides. Declaring a method as
NotOverridable prevents you from overriding the method in a derived class. Public mehtods are
NotOverridable by default. You can also declare a method as MustOverride which makes it mandatory
for you to override the method in a derived class. Any method that is declared as MustInherit should not
contain any body in the method statement.
You can refer to any method in the base class by using the keyword MyBase as illustrated in the code
fragment given below.
Public Class BaseClass1
Public Overridable Sub someMethod()
'… your code
End Sub
End Class
Class DerivedClass1
Inherits BaseClass1
Public Overrides Sub someMethod()
'The codes for the Sub …
End Sub
Public Sub baseClassMethod()
MyBase.someMethod()
End Sub
End Class
Public Class Form1
Private Sub Form1_Load(ByVal sender As System.Object, ByVal e As System.EventArgs) Handles
MyBase.Load
Dim DerivedClass As New DerivedClass1
DerivedClass.someMethod()
DerivedClass.baseClassMethod()
End Sub
End Class
In the above illustration calling the sub someMethod calls the overridden method in the derived class.
However the statement MyBase.someMethod calls the Sub defined in the base class. MyBase keyword
can be used to access the immediate base class and its inherited members. Private members of the
base class cannot be accessed using MyBase keyword.
It is not an object and therefore cannot be assigned to variables or passed on procedure or used for Is
comparison. However MyBase keyword cannot be used to access a Sub declared as MustOverride in
the base class.MyBase cannot be used in modules and to access base class members that are marked
as friend if the base class is in a different assembly.
MyClass keyword
This keyword allows you to call an overridable method implemented in your clas and make sure that
implementation of the method in the specified class is called instead of the overridden method in the
derived class.Like MyBase MyClass is also a keyword and not a class. MyClass keyword can be used
to refer the containing class and its inherited members.
MyClass can be used to qualify the shared members and it cannot be used in standard modules. In
case the method has no implementation in the derived class MyClass keyword can be used to refer the
method in the base class and therefore the effect of such usage is the same as the use of MyBase.
Implementing Inhertance
Class BaseClass1
Sub Method1()
MessageBox.Show("This is a method in the base class.")
End Sub
Overridable Sub Method2()
MessageBox.Show("This is another method in the base class.")
End Sub
End Class
Class DerivedClass2
Inherits BaseClass1
Public Field2 As Integer
Overrides Sub Method2()
Messagebox.Show("This is a method in a derived class.")
End Sub
Protected Sub TestInheritance()
Dim C1 As New BaseClass1()
Dim C2 As New DerivedClass2()
C1.Method1() ' Calls a method in the base class.
C1.Method2() ' Calls another method from the base class.
C2.Method1() ' Calls an inherited method from the base class.
C2.Method2() ' Calls a method from the derived class.
End Sub
End Class
When you run the procedure TestInheritance, you see the following messages:

"This is a method in the base class."

"This is another method in the base class."

"This is a method in the base class."

"This is a method in a derived class."

When to use inhertance
The usefulness of inheritance is depnding on the choice of its usage. You can use inheritance if the
derived class is a kind of base class but not has a relationship with the base class. Such a situation
empowers you to reuse the code from the base class. It is also more useful if the hierarchy is very
shallow. The developer can effect global changed to the derived class by changing the base class.
Inheritance and .NET Framework
In .NET Framework the inheritance is implemented with additional functionality. Any class created in
any of the programing language in the Framework can be inherited in another language. Thus cross
language inheritance is also implemented in this Framework.

The System.Object class serves as a common base class for all objects in the .NET framework, that
ensures interoperability of objects developed using Visual Studio .NET. New classes implicitly inherit
the System.Object class; therefore it is never necessary to explicitly name this class with an Inherits
statement. Among the methods that objects inherit from System.Object, one of the most useful is
Object.GetType, which is used to return the exact type of the current object.
VB.NET 2005 Free Training : Visual Studio.NET Namespaces
The .NET Framework class library has thousands of classes which are needed for developing and
deploying solutions. In order to organize all those classes for ease of use .NET Framework uses
namespaces. This Gives the Classes their own space and prevents conflicts between the various
names in these classes. For instance if two classes contain a method Paint(), then to avoid conflicts in
names we can place these classes in two different namespaces. Thus namespaces allow classes to be
grouped in a consistent, hierarchical manner.
The writing convention is that the word after the right–most dot is the name of the type and the string up
to the dot is the name of the namespace. We shall see an example of this in the following statement.
System.Windows.Forms.Button
In the above statement the name of the namespace is System.Windows.Form and the type name is
Button.

A namespace can contain classes, structures, enumerations, delegates, interfaces, and other
namespaces. Namespaces can be nested and can have any number of members. The typical
namespaces begin with Microsoft or System. The new namespace My is added in .NET 2005. If there
is a conflict in the namespace in such a way that even fully qualified Object name is also not usable,
then the classes cannot be used.

You can create a namespace by using the Namespace … End Namespace block. With in the
namespace Block, you can create classes, enumerations, structures, delegates, interfaces, or other
namespaces. It is not imperative that all the code should be kept in one single file. A namespace can
span multiple files and even multiple assemblies.
Namespace VBTutorial
Class Class1
…….
End Class
Namespace Lesson2
Class Class2
…..
Public Sub Teach()
End Sub
End Class
End namespace
End Namespace

In order to access the methods teach defined in class2 you have to instantiate the class Class2.
Dim lessonObj as new VBTutorial.Lesson2.Class2
lessonObj.Teach()
Alternatively you can use the following lines of code:
Imports VBTutorial.Lesson2
Dim lessonObj as new Class2
lessonObj.Teach()
Let us quickly see some of the namespaces defined in .NET

System.ComponentModel Liending and design time implementation of components

System.Data Data Access
System.Data.SQLClient SQL Server data access
System.Data.OLEDB OLE DB data access
System.Data.SML XML processing
System.Diagnostics Provides debugging and tracing services
System.Messaging Microsoft Message Queue management
System.Net Programmable access to network protocol
My.Computer Gives access to local computer
My.User Gives access to the local user logged in
Using The System.Windows.Forms.Form class
System.Windows .Forms.Form class is the foundation class for all forms to be created. All the forms
that are created in VB .NET are also inheriting from this base class. This class provides for all the
facilities needed for the form. Additional functionality can be added by separate codes.
In the .NET Framework, a number of new features have been added to the Form Class and the
Controls. We shall see some of the new features quickly. For most detailed information is available in
the Microsoft website. We will see some of the members that have been added to Windows Forms
Classes within the .NET Framework:
Application
Application.Activating event : Gives notification that this application is to become the active application
Button
This comes with added members like BorderColor property that gets or sets the color of the border of
the button and the BorderSize property that gets or sets the size in pixels of the border of the button.
ComboBox
This control comes with additional members that make the control more functional.
AutoCompleteCustomSource property that gets or sets a custom StringCollection to use when the
AutoCompleteSource property is set to custom source. Beginupdate method maintains the
performance as the items are added to the combo box. EndUpdate method is also included that
resumes painting the ComboBox control after the BeginUpdate method suspends the painting.
Form
The .NET Framework gives us a complete, object-oriented, extensible set of classes that helps us to
develop solutions using rich Windows applications. Windows Forms can also be used as the user
interface in the solution. The forms are objects that expose properties that spell their appearance,
methods which define their behavior and event which defines the interaction with the user. You can set
these properties of the form and also write codes to respond to its events. A form can be a standard
window, dialog boxes, display background for other graphical objects, or multiple document interfaces.
Flash method is added which gives visual notification to the user of events that happen in you your
application. StopFlash method which stops the activity that is described in the flash method.
RestoreBounds property gets or sets the location and size of the form in its normal window state.

Designing a Form using Windows Forms Designer Window

New form is created with default options when you start a Windows Application. You can add additional
forms to the projects by clicking New from the File Menu. In the text box for name type NewForm.vb
and click ok to create a new form. Alternatively you can right-click the project in the solution explorer
and choose add form the menu and choose the option Windows Form
Below is the screen shot of showing the new MyForm

Exploring the Forms Designer generated code

As you create a new project in the Visual Basic, the IDE generally automatically adds lots of lines of
code on its own. Visual Basic 2005 comes with an option to skip over this behavior of the Visual Basic
IDE. The default option comes with this behavior enabled.
These codes are introduced with an aim that the user can continue to use the form without bothering
about write codes to instantiate the form with a function new() and also the code includes the
declaration and instantiation of all the controls that have been dragged and dropped on to the form. As
a developer you may need to add controls like text boxes, grid controls, database controls and also
need to bind data to some control at design time.
Much of these activities can be done at design time and visually without adding any line of code. The
Visual Basic IDE is equipped with inbuilt facility that generates codes for these features. The more
interesting part is not just that. You can actually add functionality to the form by adding codes to these
functions like new() which is the first function to be executed and can be used to perform additional
tasks at the start time of the application or even before the form load takes place.
This code is stored in a new file Form1.Designer.vb. Let us take a closer look at this now. These codes
that we are going to see have been taken from one of the demos of this tutorial.
<Global.Microsoft.VisualBasic.CompilerServices.DesignerGenerated() > _
Partial Public Class Form1
Inherits System.Windows.Forms.Form
'Form overrides dispose to clean up the component list.
<System.Diagnostics.DebuggerNonUserCode()> _
Protected Overloads Overrides Sub Dispose(ByVal disposing As Boolean)
If disposing AndAlso components IsNot Nothing Then
components.Dispose()
End If
MyBase.Dispose(disposing)
End Sub
'Required by the Windows Form Designer
Private components As System.ComponentModel.IContainer
'NOTE: The following procedure is required by the Windows Form Designer
'It can be modified using the Windows Form Designer.
'Do not modify it using the code editor.
<System.Diagnostics.DebuggerStepThrough()> _
Private Sub InitializeComponent()
Me.Button1 = New System.Windows.Forms.Button
Me.Button2 = New System.Windows.Forms.Button
Me.Button3 = New System.Windows.Forms.Button
Me.Button4 = New System.Windows.Forms.Button
Me.Button5 = New System.Windows.Forms.Button
Me.Button6 = New System.Windows.Forms.Button
Me.Button7 = New System.Windows.Forms.Button
Me.SuspendLayout()
'Button1
Me.Button1.Location = New System.Drawing.Point(13, 238)
Me.Button1.Name = "Button1"
Me.Button1.Size = New System.Drawing.Size(75, 23)
Me.Button1.TabIndex = 0
Me.Button1.Text = "Line"
'Button2
Me.Button2.Location = New System.Drawing.Point(98, 238)
Me.Button2.Name = "Button2"
Me.Button2.Size = New System.Drawing.Size(75, 23)
Me.Button2.TabIndex = 1
Me.Button2.Text = "Ellipse"
'Form1
'
Me.AutoScaleDimensions = New System.Drawing.SizeF(6.0!, 13.0!)
Me.AutoScaleMode = System.Windows.Forms.AutoScaleMode.Font
Me.ClientSize = New System.Drawing.Size(612, 273)
Me.Controls.Add(Me.Button2)
Me.Controls.Add(Me.Button1)
Me.Name = "Form1"
Me.Text = "Painting Shapes and Fill Objects"
Me.ResumeLayout(False)
End Sub
 Friend WithEvents Button1 As System.Windows.Forms.Button
Friend WithEvents Button2 As System.Windows.Forms.Button
End Class
Definitions
InitializeComponent: This method helps to persist the property values that you have set in the
Designer.
Public Sub New():The class constructor. You can put include some code that you want at the start up.
However the best location for this code is the forms Load event.
Security in Windows Form:
The .NET Framework provides a superior security features in the application by introducing new
features. The code access security allows you to permit varied degrees or trust to the code depending
on where the code originates and also other factors that define the identity of the code. Security
permissions are implemented to ensure security. Code can request the permissions it needs.
The .NET Framework security system determines whether such requests are honored. Requests are
honored after verifying the code's evidence and only relevant requests are granted those permissions.
The permission given to the code never exceeds the current security settings. However, code will be
granted less permission based upon a request.

The identity of the code forms the basis for granting the runtime permissions, also the level of trust the
code is granted is determined by the security policy.
Code can demand that its callers have specific permissions. If you place a demand for certain
permission on your code, all code that uses your code must have that permission to run.
There are three kinds of permissions, each with a specific purpose
Code access permissions, which represent access to a protected resource or the ability to perform a
protected operation.
Identity permissions, which indicate that code has credentials that support a particular kind of identity.
Role-based security permissions, which provide a mechanism for discovering whether a user has a
particular identity or is a member of a specified role. Thus a very robust and well managed security is
provided in the .NET Framework.
Using Application Class
Visual Basic 2005 introduces a speedy way to access many important classes relating to the Computer
on which the application is running, the user running it, the application itself, its forms and any
associated web services. The best part of it all is that you can access it all using the new My object.
The new My object has added features that help the programmer to gain access to some functionality
that was really hard to achieve.
My.Application Object contains information about running application, such as the title, working
directory, version, and the common language runtime (CLR) version in use. It also gives access to
environment variables, allow you to easily write to the local application log or to a custom log, and so
on.
You can access the Application information easily as can be seen in the following lines of code
My.Application.AssemblyInfo.DirectoryPath
My.Application.AssemblyInfo.ProductName
My.Application.Log.WriteEntry(“Application Starting”, EventLogEntryType.Information,
Nothing)
The above lines of code will retrieve this information from the assembly which can used by the
application on run time.
The following table gives the properties and methods of the My.Application Object
ApplicationContext Gives access to the context associated with the current thread.
AssmblyInfo Allows easy access to data from the AssemblyInfo.vb file, including CompanyName,
ProductName, Title and Version.
ChangeCurrentCulture Allows Change the culture in which the current thread is running, which affects
such things as string manipulation and formatting
ChangeCurrentUICulture Allows changing the culture that the current thread uses for retrieving
culture-specific resources
CommandLineArgs Return a collection of command-line arguments
CurrentCulture Returns a collection of command-line arguments
CurrentDirectory Returns the folder where the application resides
CurrentUICulture Returns the culture that the current thread is using for retrieving culture-specific
resources
DoEvents Causes all messages in the message queue to be processed
GetEnvironmentVariable Returns a specific environment variable on the local maching\e
IsNetWorkDeployed Returns True if the application was network-deployed else returns False.
Log Allows writing to application log on the local machine
MainForm A read-write property that allows setting or getting the form that the application will use as
its main form
Run Sets up and starts the VB Startup/Shutdown Application model
SplashScreen Lets setting or getting the application's splash screen
Using the MessageBox class
Message boxes are often used objects. They are derived form Form Class, displayed modally and used
to take user’s acknowledgement and also inform the user or alert the user of any thing that needs to be
informed or alerted.
You cannot create a new instance of the System.Windows.Forms.MessageBox class. To display a
message box, call the static method System.Windows.Forms.MessageBox.Show. The title, message,
buttons, and icons displayed in the message box are determined by parameters that you pass to this
method.
The following example shows how to use a System.Windows.Forms.MessageBox to inform the user
of a missing entry in a System.Windows.Forms.TextBox.
This example assumes that the method is called from an existing form with a
System.Windows.Forms.Button and a System.Windows.Forms.TextBox on it.

Protected Sub button1_Click(sender As Object, e As System.EventArgs)

If textBox1.Text = "" Then
MessageBox.Show("You must enter a name.", "Name Entry Error", _
MessageBoxButtons.OK, MessageBoxIcon.Exclamation)
Else
' Code to act on the data entered would go here.
End If
End Sub
The following example shows how to ask the user a Yes or No question and make a decision based on
the response
Private Sub ValidateUserEntry()
' Checks the value of the text.
If ServerName.Text.Length = 0 Then
' Initializes variables to pass to the MessageBox.Show method.
Dim Message As String = "You did not enter a server name. Cancel this operation?"
Dim Caption As String = "No Server Name Specified"
Dim Buttons As MessageBoxButtons = MessageBoxButtons.YesNo
Dim Result As DialogResult
'Displays the MessageBox
Result = MessageBox.Show(Me, Message, Caption, Buttons)
' Gets the result of the MessageBox display.
If Result = DialogResult.Yes Then
' Closes the parent form.
Me.Close()
End If
End If
End Sub
The above example also shows that we can take a response from the message box and use the value
of the result to perform specific actions.
Visual Basic has a public function MsgBox. It displays a message in a dialog box, waits for the user to
click a button, and then returns an integer indicating which button the user clicked.
Public Function MsgBox( _ ByVal Prompt As Object, _ Optional ByVal Buttons As MsgBoxStyle =
MsgBoxStyle.OKOnly, _ Optional ByVal Title As Object = Nothing _) As MsgBoxResult
MessageBox class Parameters
Prompt
Required. String expression displayed as the message in the dialog box. The maximum length of
Prompt is approximately 1024 characters, depending on the width of the characters used. If Prompt has
more than one line, you can separate the lines using a carriage return character (Chr(13)), a linefeed
character (Chr(10)), or a carriage return/linefeed character combination (Chr(13) & Chr(10)) between
each line.
Buttons
Optional. Numeric expression that is the sum of values specifying the number and type of buttons to
display, the icon style to use, the identity of the default button, and the modality of the message box. If
you omit Buttons, the default value is zero.
Title
Optional. String expression displayed in the title bar of the dialog box. If you omit Title, the application
name is placed in the title bar.
Settings
The MsgBoxStyle enumeration values are listed in the following table.
Enumeration Value Description

OKOnly 0
Displays OK button only.

OKCancel 1 Displays OK and Cancel buttons.

AbortRetryIgnore 2 Displays Abort, Retry, and Ignore buttons.

YesNoCancel 3 Displays Yes, No, and Cancel buttons.

YesNo 4 Displays Yes and No buttons.

RetryCancel 5 Displays Retry and Cancel buttons.

Critical 16 Displays Critical Message icon.

Question 32 Displays Warning Query icon.

Exclamation 48 Displays Warning Message icon.

Information 64 Displays Information Message icon.

DefaultButton1 0 First button is default.

DefaultButton2 256 Second button is default.

DefaultButton3 512 Third button is default.

Application is modal. The user must respond to the message box

ApplicationModal 0
before continuing work in the current application.

System is modal. All applications are suspended until the user

SystemModal 4096
responds to the message box.

MsgBoxSetForeground 65536 Specifies the message box window as the foreground window.

MsgBoxRight 524288 Text is right-aligned.

MsgBoxRtlReading 1048576
Specifies text should appear as right-to-left reading on Hebrew and
Arabic systems.
The first group of values (0–5) describes the number and type of buttons displayed in the dialog box;
the second group (16, 32, 48, 64) describes the icon style; the third group (0, 256, 512) determines
which button is the default; the fourth group (0, 4096) determines the modality of the message box, and
the fifth group specifies whether or not the message box window is the foreground window, along with
the alignment and direction of the text. When adding numbers to create a final value for the Buttons
argument, use only one number from each group.
Setting and Adding Properties to a Windows Form
In this tutorial we wil leran about Setting and Adding Properties to a Windows Form, Using the Visual
Designer to set Windows Form Properties, Setting Windows Forms Properties programatically and
Using Visual Inheritance along with the sample project and screen shots.
Using the Visual Designer to set Windows Form Properties
The properties of the Widows properties can be edited in the properties window visually. Both the
inherited properties and also those added in the current class can be edited using the property window.
If this window is not visible, you can click on the menu view and choose property window. Alternatively
you can click F4 to invoke this window.
This window can be docked to a side and can be hidden or pinned to the desk. If it is hidden then if the
mouse hovers over the title bar of the property window it then becomes visible. We and see how the
properties of a text box and a grid control can be edited in the illustration:
In the above screen shot, see the button titled OK and all the properties of the button are available so
that it can changed.

We can also see another illustration involving grid box control: The screen shot below displays
properties that can be changed.
Setting Windows Forms Properties programmatically
You may have a clear idea of value of the properties and the controls at design time and they can be
edited using the method explained above. However most of the time the value of the property of several
items cannot be identified at design time and they have to be set at run time based on several
considerations. Visual Basic provides facility to edit and initialize or substitute the value of the
properties programmatically. Le us see an illustration.

Start a new project and add a form to the project. This form will be the starting form by default. Add two
text boxes and a command button to the form and place them as shown below:
Now you can proceed to add the codes for the program by double clicking the form. You will see the
controls.vb file opened. Add the following codes to the form as given below:

We have added two labels to the form class. These classes are merely declared in the class. The
Contols_Load Sub contains the codes to edit the properties and to add them. The visible property of the
form is set to true so these controls will be visible on the form. Now let us look at the value for the labels
lblFirstNm and lblSeconNm which are initially assigned a value "Enter your First Name" and "Enter your
Last Name".
Now take a look at the sub addNames. This sub takes two arguments, viz firstNm and SecondNm. The
sub assigns the value of firstNm to lblFirstNm and the value of SeconNm to lblSecondNm. We also
make some cosmetic change by making the font bold.
The action comes from the sub btnOk_click. Here we declare two string variables firstNm and
secondNm. The value of the text from the two text box are captured and assigned to these variables in
the respective order. Then the sub addNames is called here with the two names as arguments and the
result can be seen in the two graphics that are given below:

See the screenshot below after the “Enter” button is clicked: You will also see that the value in the text
boxe have been reset to null values.
Using Visual Inheritance
Inheritance allows you to derive one class from another class. Visual Basic provides a facility by which,
while deriving a class from another class, you can also inherit the visual aspects of the class.

To derive a form from a Form1 which will inherit all aspects of Form1, including the controls on the
form. Let us create a new project VisualInheritance and add a form Form1 to it. Now add a button
botton1 to the form. Now click on the Build menu and click on Build VisualInheritance. This will enable
the form to be available for being inherited.
Now right click on the project and you choose Add Inherited Form. You will see a window named
inheritance picker. Choose the form Form1 in the window. The new inherited form will have the controls
that were placed on the base form Form1.
Introduction to Event Handling
One of the most useful capabilities of the OOP Languages is their inbuilt ability to be aware of a
large number of events like MouseOver, MouseClick, and so on so that we can write codes to react
to any event that we are interested. This is made possible by the rich set of classes that have been
built in the .NET Framework
The events handling is very simple as we have seen in the previous example where buttonClicked
event is handled by the following code:
Private Sub btnOk_Click(ByVal sender As System.Object, ByVal e As System.EventArgs)
Handles btnOk.Click
The Handles keyword is used to tell the program to look for the specific event. The sub or the
function that handles the event will be called immediately when the event occurs. This is a simple
implementation. In some cases you may have to raise an application event which will be caught by
the event handler. Please see the following code fragment to understand this.
Public Event TimeExpired(ByVal Status As String)
RaiseEvent TimeExpired("Your time has run out")
The first line declares the event Time expired and the second statement raises the event. In order
that this code works you need to make a reference to the System namespace. The Event statement
should be located outside any procedure or Sub and at the class level. The RaiseEvent statement
should be available inside some procedure in the application. Events must be raised within the
scope of the class or module or structure where they are declared. Thus you cannot raise an event
declared in the base class from within a derived class. The object that raised the event is the
sender or the source of the event. Some of the examples of these kinds of objects are forms,
controls etc.
An event handler can be any procedure that is called when the corresponding event occurs. You
cannot use a function as an event handler as it would necessitate the function to return a value to
the source object. The event handler cannot be made use of unless you first associate the
procedure with the event by using the keyword Handles or AddHandler statement.
While handles clause is used with design time activity AddHandler and RemoveHandler statements
are more flexible and they allow you to dynamically connect or disconnect the events with one or
more event handlers at run time. You are also relieved from adding one more line of code using
withEvents.
Let us see an example of event handling using Handles clause.
Dim withEvents AnEvent as new EventRaised()
Sub EventEgs()
AnEvent.RaiseEvents()
End Sub
Sub AnEvent_EventHandler() Handles AnEvent.EventOne, AnEvent.EventTwo
MsgBox(“Received Event”)
End Sub
Class EventRaised
Public Event EventOne()
Public Event EventTwo()
Sub RaiseEvents()
RaiseEvent EventOne()
RaiseEvent EventTwo()
End Sub
End Class
There are some limitations in using this kind of solution as listed below:
• You cannot use a WithEvents variable as a object variable. That is, you cannot declare it as
Object — you must specify the class name when you declare the variable.
• You cannot use WithEvents to declaratively handle shared events, since they are not tied to an
instance that can be assigned to a WithEvents variable. Similarily, you cannot use WithEvents or
Handles to handle events from a Structure. In both cases, you can use the AddHandler statement
to handle those events.
• You cannot create arrays of WithEvents variables.
• WithEvents variables allow a single event handler to handle one or more kind of event, or one or
more event handlers to handle the same kind of event.
The other method is employing the AddHandler and RemoveHandler clause. We shall see this in the
next section
A delegate is kind of OO function pointer that permits a function to be invoked indirectly by making
reference to the function. They are employed to attach to event handlers and pass a procedure
from on procedure to another. However delegates can also be used for other tasks not related to
events like free threading or procedures that need to call different versions of functions at compile
time. An illustration on the use of delegates is given by the following codes:
Click here for Sample Code
The output is given below:

5 is positive; use the sign "+".

-3 is negative; use the sign "-".
0 is zero; use the sign "".
Delegates are reference type based on the class System.Delegate and are capable of referencing
both share methods and instance methods. Using Delegates is particularly advantageous in
situations where you need an intermediary between a calling procedure and the procedure being
called. In some cases it may be required that when an object raises an event, you may want to
raise different event handlers under different circumstances.
In these situations the object that raised the event cannot know in advance, which EventHandler
will handle the specific event. These situations are handled well by use of delegates. While creating
your own delegates is allowed, Visual Basic creates the delegates in most cases and also manages
the details. Thus the Event statement implicitly defines a delegate class which is given a name
EventHandler as a nested class containing the Event statement.
It has the same signature as the event and also creates the AddressOf statement implicity. Event
Delegates are multicast, in other words they can keep references to more than one event handling
method. A delegate serves as an event dispatcher for the class which had raised the event by
maintaining a list of registered event handlers for the event.
The AddHandler and Removehandler statements allow you to start and stop event handling at any
time during the program execution. Unlike the keyword Hanles which specifies the event handling
procedure at design time, the AddHandler statement connects the procedures to events at run
time. Addhandler statement invokes the event’s AddHandler accessor for custom events. Let us see
and illustration for this:
Sub TestEvents()
Dim Obj As New Class1()
' Associate an event handler with an event.
AddHandler Obj.Ev_Event, AddressOf EventHandler
Obj.CauseSomeEvent() ' Ask the object to raise an event.
End Sub

Sub EventHandler()
' This procedure handles events raised by the object Obj.
MsgBox("EventHandler caught event.") ' Handle the event.
End Sub

Public Class Class1

Public Event Ev_Event() ' Declare an event.
Sub CauseSomeEvent()
RaiseEvent Ev_Event() ' Raise an event.
End Sub
End Class
The next illustration demostrates declaring and consuming events.This code defines the behaviour
of Laughing Doll that takes user input to start and stop laugh and to pause laughing. I this case the
event is raised on one class and the hadling of the event is done in another class.
Click here for sample Code
Handling Events by overriding protected method of base class
When you inherit from a control or a component, you create a new control or component that
incorporates all of the functionality of its base class. Any event handlers that are defined by the
base class will be included in the inherited component.
The following example shows a typical event handler:
Private Sub Button1_Click(ByVal sender As System.Object, ByVal e As _
System.EventArgs) Handles Button1.Click
Static Counter As Integer = 0
Counter += 1
MessageBox.Show(" This button has been clicked " & _
Counter.ToString() & " time(s).")
End Sub
In order to allow this method to be overridden in an inheriting class, you must add the Overridable
keyword and change the access level to Protected, Protected Friend, or Public. The following
example shows an event handler that can be overridden:
Protected Overridable Sub Button1_Click(ByVal sender As System.Object, _
ByVal e As System.EventArgs) Handles Button1.Click
Static Counter As Integer = 0
Counter += 1
MessageBox.Show(" This button has been clicked " & _
Counter.ToString() & " time(s).")
End Sub
Overriding an inherited event handler is the same as overriding any other kind of inherited method,
with one important difference: When you override an inherited event handler, you have to remove
the Handles clause.
To override a method in an inherited component
• Add the Overrides keyword to your method declaration.
Note You should not add a Handles clause to the method. The event handler is already associated
with the event in the base class, and this association is passed on to the inheriting class. In other
words, the method will be executed when the event is fired and does not require an additional
Handles clause.
The following example shows how to override the event handler from the previous example:
Protected Overrides Sub Button1_Click(ByVal sender As System.Object, _
ByVal e As System.EventArgs)
Static Counter As Integer = 0
Counter += 1
MessageBox.Show(" This inherited button has been clicked " & _
Counter.ToString() & " times.")
End Sub
The Handles clause is no longer associated with the method. This is not an oversight, but rather an
important part of how events are handled in the .NET Framework. The event handler is already
associated with the event in the base class, and this association is passed on to the inheriting class.
In other words, the method will be executed when the event is fired and does not require an
additional Handles clause. Adding an additional Handles clause, as shown below, will create an
additional association with the event, and will cause the method to be executed twice per event.
' INCORRECT
Protected Overrides Sub Button1_Click(ByVal sender As System.Object, _
ByVal e as System.EventArgs) Handles Button1.Click
Static Counter as Integer = 0
' This variable will be incremented twice each time the button is clicked.
Counter += 1
' The message box will be displayed twice for every time the button is clicked, and will
display 'inaccurate information.
MessageBox.Show (" This inherited button has been clicked " & _
Counter.ToString() & " times.")
End Sub
This problem caused by overriding event handlers might not be intuitive and can lead to bugs that
are difficult to isolate. Setting the appropriate associations with your event handlers is very
important. Use caution, and be aware of event associations that are already in place.