Introduction
Software projects consist of several pieces of code such as classes, declarations, procedures and functions etc., known as the component or identifiers of the software project. In large projects the number of these components can be very large. These components can be grouped into smaller subcategories. This logical grouping construct is known as a "Namespace" or we can say that the group of code having a specific name is a "Namespace". In a Namespace the groups of components are somehow related to each other. Namespaces are similar in concept to a folder in a computer file system. Like folders, namespaces enable classes to have a unique name or we can say that it is a logical naming scheme for grouping related types. A Namespace is sometimes also called a name scope. An identifier defined in a Namespace belongs to that Namespace and the same identifier can be independently defined in multiple Namespaces with a different or the same meaning. Every project in C# or VB.NET starts with a Namespace, by default the same name as the name of the project.
Why we need it
We must add a reference of the Namespace object before using that object in a project. Several references are automatically added in the project by default. The VB.Net "Imports" keyword is used to add a reference of a namespace manually.
Example
Imports System
Note: Imports allow access to classes in the referenced Namespace only not in its internal or child Namespaces. If we want to access internal Namespace we might need to write:
Imports System.Collections
Namespaces are basically used to avoid naming collisions, when we have multiple classes with the same name, and it is also helpful for organizing classes libraries in a hierarchal structure. Namespaces allow us to organize Classes so that they can be easily accessed in other applications. Namespaces also enable reusability.
A class in .Net Framework cannot belong to multiple Namespaces. One class should belong to only one Namespace. VB.NET does not allow two classes with the same name to be used in a program.
Declaring a Namespace
We can define a Namespace using the "Namespace" keyword. The syntax for declaring a Namespace is:
Namespace <Namespace_name>
// Classes and/or structs and/or enums etc.
End Namespace
Example
Note: All the classes in the .Net Framework belongs to the System Namespace. The "system" Namespace has built-in VB functionality and all other Namespaces are based on this "system" Namespace.
Accessing Members of a Namespace
We can access a member of a Namespace by using a dot(.) operator, also known as the period operator. The members of a Namespace are the variables, procedures and classes that are defined within a Namespace. To access the member of a namespace in a desired location type the name of the namespace followed by the dot or period operator followed by the desired member of the namespace.
Example
MyNamespace.Class1.disp() 'Accessing elements of the MyNamspace
we can access a member of a namespace in various ways. The following program shows accessing the element of a namespace in various ways.
Imports System
Namespace Birds 'user defined namespace Bird
Class Parrot 'Parrot is a class in the namespace Animals
Public Shared Function fly() 'Fly is a function in this Class
Console.WriteLine("Parrot can fly")
End Function
Public Shared Function color() ' color is another function in parrot class
Console.WriteLine("normally Parrots are green")
End Function
Public Shared Function type()
Console.WriteLine("Different type of parrot are found around the world")
End Function
End Class
End Namespace
Module Module1
Public Function myfunction()
Dim P As Birds.Parrot
P = New Birds.Parrot()
P.type() 'accessing member of the namespace bird
End Function
Sub main()
Console.Clear()
Birds.Parrot.fly() 'accessing member of the namespace
ConsoleApplication5.Birds.Parrot.color() 'another way to access member of the
namespace
myfunction()
End Sub
End Module
Output
Namespace MyNamespace 'class with in a namespace
Public Class Class1
Public Shared Function disp() 'function declared within the class
Console.Write("hello" & vbCrLf)
End Function
End Class
End Namespace
Nesting a Namespace
Nesting a Namespace means create a namespace inside a namespace. A good way to organize namespaces is to put them in a hierarchal order, i.e. general name at the top of the hierarchy and put specific names at the lower level.
Example
Imports System
Namespace outer 'declare an outer namespace
Public Class nameout
Public Shared Function disp() 'create a function inside a outer namespace
Console.WriteLine("hi this is outer name space")
End Function
End Class
Namespace inner 'decalre an inner namespace
Public Class nameinn
Public Shared Function disp() 'create a function inside the inner namespace
Console.WriteLine("hi this is inner namespace")
End Function
End Class
End Namespace
End Namespace
Module module1
Sub main()
Console.Clear()
outer.nameout.disp() 'accesing function of the outer namespace
outer.inner.nameinn.disp() 'accessing fucntion of the inner namespace
End Sub
End Module
Output
Note: You can not have two classes with the same name in the same scope. In other words, class overloading is not allowed.
Example
Namespace MyNamespace
Public Class one 'sample class with in a namespace
Public Shared Function disp() 'function declared within the class
Console.Write("hello" & vbCrLf)
End Function
End Class
Public Class one 'this is not allowed
Public Shared Function disp1()
Console.Write("hi")
End Function
End Class
End Namespace
You can avoid this by putting classes with the same name in a different scope.
Example
Namespace outerscope 'sample class with in a namespace
Public Class one
Public Shared Function disp() 'function declared within the class
Console.Write("hello class with outerscope" & vbCrLf)
End Function
End Class
Namespace innerscope
Public Class one 'same class with different scope
Public Shared Function disp1()
Console.Write("hi this class is wihtin innerscope of outscope namespace " & vbCrLf)
End Function
End Class
End Namespace
End Namespace
Module module1
Sub main()
Console.Clear()
outerscope.one.disp()
outerscope.innerscope.one.disp1()
End Sub
End Module
Output
Aliases of the Namespaces
Aliases are created when we have nested Namespaces. It is easy to access the members of the namespaces by the alias. An alias is a shortcut for a nested namespace with a shorter label. An alias of a namespace is created with the help of the "imports" keyword. Aliasing is useful when we are working with a large project.
Example
Imports ally = ConsoleApplication6.outerscope.innerscope 'creating an alias name for inner scope
Namespace outerscope 'sample class with in a namespace
Public Class one
Public Shared Function disp() 'function declared within the class
Console.Write("hello class with outer scope" & vbCrLf)
End Function
End Class
Namespace innerscope
Public Class one 'same class with different scope
Public Shared Function disp1()
Console.Write("hi accessing the member with the alias name" & vbCrLf)
End Function
End Class
End Namespace
End Namespace
Module module1
Sub main()
Console.Clear()
outerscope.one.disp() 'accessing member of the outerscope namespace without alias name
ally.one.disp1() 'accessing member of the innerscope by alias name
End Sub
End Module
Output
