Skip to main content

Namespaces in C# With Examples


Namespaces in C#

Namespaces are concepts in C# used to organize and provide a level of separation of codes. They can be considered as a container which consists of other namespaces, classes, etc.

A namespace can have following types as its members:
Namespaces (Nested Namespace)
Classes
Interfaces
Structures
Delegates

Namespaces are not mandatory in a C# program, but they do play an important role in writing cleaner codes and managing larger projects.

Let's understand the concept of namespace with a real life scenario. We have a large number of files and folders in our computer. Imagine how difficult it would be to manage them if they are placed in a single directory. This is why we put related files and folders in a separate directory. This helps us to manage our data properly.

The concept of namespace is similar in C#. It helps us to organize different members by putting related members in the same namespace.

Namespace also solves the problem of naming conflict. Two or more classes when put into different namespaces can have same name.

Defining Namespace in C#


We can define a namespace in C# using the namespace keyword as shown below

namespace NamespaceName
{
    //Body of namespace
}

Example
using System;

namespace CshapNaijaNamespace
{
    public class CsharpnaijaClass
    {
        public void CsharpnaijaMethod()
        {
Console.WriteLine("Displayed from a Method in a class from CsharpNaijaNamespace");
        }
    }
}

In the above example, a namespace CshapNaijaNamespace is created. It consists of a class CsharpnaijaClass as its member. CsharpnaijaMethod is a method of class Program.

Accessing Members of Namespace in C#

The members of a namespace can be accessed using the dot(.) operator. The syntax for accessing the member of namespace is,
NamespaceName.MemberName

For example, if we need to create an object of CsharpnaijaClass, it can be done as below,

CshapNaijaNamespace.CsharpnaijaClass myClass = new CshapNaijaNamespace.CsharpnaijaClass ();

We have just created an object of CsharpnaijaClass by accessing the class with dot (.) on the namespace

 Introducing Namespace in C# Program

namespace CshapNaijaNamespace
{
    public class CsharpnaijaClass
    {
        public void CsharpnaijaMethod()
        {
            Console.WriteLine("Displayed from a Method in a class from                          CsharpNaijaNamespace");
        }
    }
}
namespace TestCsharpnaija
{
    public class TestCsharp
    {
        public void Main(string[] args)
        {
            CshapNaijaNamespace.CsharpnaijaClass csharpnaijaClass =             new CshapNaijaNamespace.CsharpnaijaClass();
            csharpnaijaClass.CsharpnaijaMethod();
        }
    }
}

When we run the program, the output would be as shown below

Displayed from a Method in a class from CsharpNaijaNamespace

In the above program, we have created our own namespace CshapNaijaNamespace and accessed its members from Main() method inside TestCsharp. As said earlier, the dot (.) operator is used to access the member of namespace.

In the Main() method, CsharpnaijaMethod() method is called using the dot (.) operator.

Using a Namespace in C# [using Keyword]

A namespace can be included in a program using the using keyword. The syntax is as shown below

using NamespaceName;

For Instance

using System;

The advantage of this approach is we don't have to specify the fully qualified name of the members of that namespace every time we are accessing it.

Once the line using System; is included at the top of the program. We can write

Console.WriteLine("Hello World!");

Instead of the fully qualified name i.e.

System.Console.WriteLine("Hello World!");

Example

using System;

namespace NamespaceTutorial
{
    class Program
    {
        static void Main(string[] args)
        {
            Console.WriteLine("Namespace creation Example");
        }
    }
}

Nested Namespace in C#

A namespace can contain another namespace. It is called nested namespace. The nested namespace and its members can also be accessed using the dot (.) operator.

The syntax for creating nested namespace is as follows:

namespace CsharpNamespace
{
    namespace NestedNamespace
    {
        // Body of nested namespace
    }
}

Example of Nested Namespace in C#

namespace MainNamespace
{
    namespace NestedNamespace
    {
        public class SampleClass
        {
            public static void myMethod()
            {
                Console.WriteLine("Nested Namespace Example");
            }
        }
    }
}

namespace MyProgram
{
    public class MyClass
    {
        public static void Main()
        {
            MainNamespace.NestedNamespace.SampleClass.myMethod();
        }
    }
}

This example illustrates how nested namespace can be implemented in C#.

Here, we now have an extra namespace inside MainNamespace called NestedNamespace. 

So, instead of using 

MainNamespace.SampleClass.myMethod(), 

we have to use MainNamespace. NestedNamespace.SampleClass.myMethod().

Labels:
Location: Abuja, Nigeria

Comments

Post a Comment

Popular posts from this blog

Collections in C#

Collections in C# In our previous article , we have learned about how we can use arrays in C#. Arrays in programming are used to group a set of related objects. So one could create an array or a set of Integers, which could be accessed via one variable name. What is Collections in C#? Collections are similar to Arrays, it provides a more flexible way of working with a group of objects. In arrays, you would have noticed that you need to define the number of elements in an array beforehand. This had to be done when the array was declared. But in a collection, you don't need to define the size of the collection beforehand. You can add elements or even remove elements from the collection at any point of time. This article will focus on how we can work with the different collections available in C#. There are three distinct collection types in C#: standard generic concurrent The standard collections are found under the System.Collections. They do not store elemen...
Post a Comment
Read more

The String.Join Method in C# Explained

The String.Join Method in C#   The string.Join concatenates the elements of a specified array or the members of a collection, using the specified separator between each element or member. Overloads of string.Join Method Description Join(Char, Object[]) Concatenates the string representations of an array of objects, using the specified separator between each member. Join(Char, String[]) Concatenates an array of strings, using the specified separator between each member. Join(String, IEnumerable<String>) Concatenates the members of a constructed IEnumerable<T> collection of type String, using the specified separator between each member. Join(String, Object[]) Concatenates the elements of an object array, using the specified separator between each element. Join(String, String[]) Concatenates all the elements of a string array, usi...
Post a Comment
Read more

System.IO Namesapce in C#

  System.IO Namesapce in C# A  file  is a collection of data stored in a disk with a specific name and a directory path. When a file is opened for reading or writing, it becomes a  stream . The stream is basically the sequence of bytes passing through the communication path. There are two main streams: the  input stream  and the  output stream . The  input stream  is used for reading data from file (read operation) and the  output stream  is used for writing into the file (write operation). From the above definition of file, the C# provides a namespace that enable us to manipulate file in C# called System.IO.   System.IO  is a  namespace  and it contains a standard IO (input/output) types such as classes , structures , enumerations , and  delegates  to perform a read/write operations on different sources like file, memory, network, etc.   System.IO Classes The table below shows differen...
Post a Comment
Read more