{"id":1426,"date":"2023-04-08T10:01:46","date_gmt":"2023-04-08T03:01:46","guid":{"rendered":"https:\/\/csharptutorial.net\/?page_id=1426"},"modified":"2023-04-08T10:06:58","modified_gmt":"2023-04-08T03:06:58","slug":"csharp-namespaces","status":"publish","type":"page","link":"https:\/\/www.csharptutorial.net\/csharp-tutorial\/csharp-namespaces\/","title":{"rendered":"C# Namespaces"},"content":{"rendered":"\n

Summary<\/strong>: in this tutorial, you’ll learn about C# namespaces and how to use namespaces to organize code.<\/p>\n\n\n\n

Introduction to the C# namespaces<\/h2>\n\n\n\n

C# namespaces allow you to group related classes<\/a>, interfaces<\/a>, structs, enums<\/a>, and delegates<\/a> into a single logical unit. Namespaces also help you avoid naming conflict issues.<\/p>\n\n\n\n

To declare a namespace, you use the namespace<\/code> keyword followed by the namespace name as follows:<\/p>\n\n\n

namespace<\/span> namespaceName<\/span>\n{\n   \/\/ code elements<\/span>\n}<\/code><\/span>Code language:<\/span> C#<\/span> (<\/span>cs<\/span>)<\/span><\/small><\/pre>\n\n\n
For example, you can create the HR.cs<\/code> file and define a new namespace called HR<\/code><\/code>:<\/p>\n\n\n
namespace<\/span> HR<\/span>\n{\n    \/\/ code elements<\/span>\n}<\/code><\/span>Code language:<\/span> C#<\/span> (<\/span>cs<\/span>)<\/span><\/small><\/pre>\n\n\n
In this example, HR<\/code><\/code> is the name of the namespace. Inside the HR<\/code><\/code> namespace, you can define types like classes and interfaces. For instance:<\/p>\n\n\n
namespace<\/span> HR<\/span>\n{\n    class<\/span> Employee<\/span>\n    {\n        public<\/span> string<\/span> Name\n        {\n            get<\/span>; set<\/span>;\n        }\n        public<\/span> string<\/span> JobTitle\n        {\n            get<\/span>; set<\/span>;\n        }\n\n        public<\/span> override<\/span> string<\/span> ToString<\/span>(<\/span>)<\/span> => $\"{Name}<\/span> ({JobTitle}<\/span>)\"<\/span>;\n    }\n}<\/code><\/span>Code language:<\/span> C#<\/span> (<\/span>cs<\/span>)<\/span><\/small><\/pre>\n\n\n
All the types that you define inside the curly braces of the HR<\/code><\/code> namespace will belong to the HR<\/code><\/code> namespace.<\/p>\n\n\n\n
Starting from C# 10, you can simplify the namespace syntax by removing the opening and closing curly braces like this:<\/p>\n\n\n
namespace<\/span> HR<\/span>;\n\nclass<\/span> Employee<\/span>\n{\n    public<\/span> string<\/span> Name\n    {\n        get<\/span>; set<\/span>;\n    }\n    public<\/span> string<\/span> JobTitle\n    {\n        get<\/span>; set<\/span>;\n    }\n\n    public<\/span> override<\/span> string<\/span> ToString<\/span>(<\/span>)<\/span> => $\"{Name}<\/span> ({JobTitle}<\/span>)\"<\/span>;\n}<\/code><\/span>Code language:<\/span> C#<\/span> (<\/span>cs<\/span>)<\/span><\/small><\/pre>\n\n\n
By doing this, all the types that you define in the HR.cs<\/code> file will belong to the HR<\/code><\/code> namespace. <\/p>\n\n\n\n
This new syntax looks cleaner and saves horizontal space. It also makes your code easier to read. <\/p>\n\n\n\n
To use the Employee<\/code> class inside the Program.cs<\/code> file, you can reference the fully qualified name of the class like this:<\/p>\n\n\n
var<\/span> employee = new<\/span> HR.Employee()\n{\n    Name = \"John Doe\"<\/span>,\n    JobTitle = \"C# Developer\"<\/span>\n};\n\nConsole.WriteLine(employee);<\/code><\/span>Code language:<\/span> C#<\/span> (<\/span>cs<\/span>)<\/span><\/small><\/pre>\n\n\n
Typically, you use the using<\/code> statement to reference a class in a namespace without specifying the fully qualified namespace of that class. For example:<\/p>\n\n\n
using<\/span> HR;\n\nvar<\/span> employee = new<\/span> Employee()\n{\n    Name = \"John Doe\"<\/span>,\n    JobTitle = \"C# Developer\"<\/span>\n};\n\nConsole.WriteLine(employee);<\/code><\/span>Code language:<\/span> C#<\/span> (<\/span>cs<\/span>)<\/span><\/small><\/pre>\n\n\n
In this example, we use the using statement to explicitly import the HR<\/code> namespace and reference the Employee<\/code> class using just the class name only.<\/p>\n\n\n\n
Nested namespaces<\/h2>\n\n\n\n
Nested namespaces are namespaces that you define in another namespace. They allow you to organize the code elements more granularly especially when you work with larger codebases.<\/p>\n\n\n\n
To define nested namespaces in C#, you simply declare them inside another namespace. For example:<\/p>\n\n\n
namespace<\/span> HR<\/span>\n{\n    namespace<\/span> Personnel<\/span>\n    {\n        class<\/span> Employee<\/span>\n        {\n            public<\/span> string<\/span> Name\n            {\n                get<\/span>; set<\/span>;\n            }\n            public<\/span> string<\/span> JobTitle\n            {\n                get<\/span>; set<\/span>;\n            }\n\n            public<\/span> override<\/span> string<\/span> ToString<\/span>(<\/span>)<\/span> => $\"{Name}<\/span> ({JobTitle}<\/span>)\"<\/span>;\n        }\n    }\n    namespace<\/span> Payroll<\/span>\n    {\n        class<\/span> SalaryCalculator<\/span>\n        {\n        }\n    \n    }\n}<\/code><\/span>Code language:<\/span> C#<\/span> (<\/span>cs<\/span>)<\/span><\/small><\/pre>\n\n\n
In this example, we define two nested namespaces Personnel<\/code> and Payroll<\/code> inside the HR<\/code> namespace. The Personnel<\/code> namespace has the Employee<\/code> class and the Payroll<\/code> namespace has the SalaryCalculator<\/code> class.<\/p>\n\n\n\n
To reference a nested namespace, you use dot notation to indicate the parent-child relationship between the namespaces. For example:<\/p>\n\n\n
using<\/span> HR.Personnel;\nusing<\/span> HR.Payroll;<\/code><\/span>Code language:<\/span> C#<\/span> (<\/span>cs<\/span>)<\/span><\/small><\/pre>\n\n\n
In this example, we use the using<\/code> statement to import the Personnel<\/code> and Payroll<\/code> namespaces from the HR<\/code> namespace.<\/p>\n\n\n\n
And you can reference the types in these nested namespaces without the fully qualified names:<\/p>\n\n\n
using<\/span> HR.Personnel;\nusing<\/span> HR.Payroll;\n\nvar<\/span> employee = new<\/span> Employee()\n{\n    Name = \"John Doe\"<\/span>,\n    JobTitle = \"C# Developer\"<\/span>\n};\n\nConsole.WriteLine(employee);\n\nvar<\/span> salaryCalculator = new<\/span> SalaryCalculator();<\/code><\/span>Code language:<\/span> C#<\/span> (<\/span>cs<\/span>)<\/span><\/small><\/pre>\n\n\n
When you use nested namespaces, it’s important to keep the nesting level at a reasonable level. If you nest too deeply, your code will be harder to understand and maintain.  It’s a common practice to aim for a nesting level of no more than 3 or 4 levels deep.<\/p>\n\n\n\n
Notice that when you import a namespace, it doesn’t automatically import the nested namespace. For example:<\/p>\n\n\n
using<\/span> HR;\n\nvar<\/span> employee = new<\/span> Employee() \/\/ ERROR<\/span>\n{\n    Name = \"John Doe\"<\/span>,\n    JobTitle = \"C# Developer\"<\/span>\n};\n\nConsole.WriteLine(employee);<\/code><\/span>Code language:<\/span> C#<\/span> (<\/span>cs<\/span>)<\/span><\/small><\/pre>\n\n\n
In this example, the using HR<\/code><\/code> statement only imports the types in the HR<\/code><\/code> namespace but types in the nested namespace. Therefore, it results in an error.<\/p>\n\n\n\n
To fix it, you need to import the HR<\/code>.Personnel namespace or reference the Employee<\/code> class using a fully qualified name.<\/p>\n\n\n\n
Using C# namespace to avoid naming conflict<\/h2>\n\n\n\n
Namespaces can help you avoid naming conflicts. For example, you may have the same class name in different namespaces.<\/p>\n\n\n\n
This is because namespaces act as a container for code elements and when you prefix the code elements with namespaces, the code elements will be uniquely identifiable.<\/p>\n\n\n\n
For example:<\/p>\n\n\n
namespace<\/span> HR<\/span>\n{\n    namespace<\/span> Dependents<\/span>\n    {\n        class<\/span> Person<\/span>\n        {\n            public<\/span> string<\/span> Name\n            {\n                get<\/span>; set<\/span>;\n            }\n        }\n    }\n\n    namespace<\/span> Personnel<\/span>\n    {\n        class<\/span> Person<\/span>\n        {\n            public<\/span> string<\/span> Name\n            {\n                get<\/span>; set<\/span>;\n            }\n        }\n        class<\/span> Employee<\/span> : Person<\/span>\n        {\n\n            public<\/span> string<\/span> JobTitle\n            {\n                get<\/span>; set<\/span>;\n            }\n            public<\/span> override<\/span> string<\/span> ToString<\/span>(<\/span>)<\/span> => $\"{Name}<\/span> ({JobTitle}<\/span>)\"<\/span>;\n        }\n    }\n\n}<\/code><\/span>Code language:<\/span> C#<\/span> (<\/span>cs<\/span>)<\/span><\/small><\/pre>\n\n\n
In this example, we have the same Person class in different namespaces Dependents<\/code> and Personnel<\/code>. If you import both HR.Personnel<\/code> and HR.Dependents<\/code> namespaces into the same file, you’ll get an error:<\/p>\n\n\n
using<\/span> HR.Personnel;\nusing<\/span> HR.Dependents;\n\nvar<\/span> child = new<\/span> Person(); \/\/ ERROR<\/span><\/code><\/span>Code language:<\/span> C#<\/span> (<\/span>cs<\/span>)<\/span><\/small><\/pre>\n\n\n
The reason is that when you reference the Person<\/code> class, the compiler doesn’t know the exact namespace of the Person<\/code> class.<\/p>\n\n\n\n
To fix this, you need to use a fully qualified class name and only import the namespace that you use often in the code. For example:<\/p>\n\n\n
using<\/span> HR.Dependents;\n\n\/\/ comes from HR.Dependents<\/span>\nvar<\/span> child = new<\/span> Person();\n\n\/\/ comes from HR.Personnel<\/span>\nvar<\/span> father = new<\/span> HR.Personnel.Employee(); <\/code><\/span>Code language:<\/span> C#<\/span> (<\/span>cs<\/span>)<\/span><\/small><\/pre>\n\n\n
In this example, the Person<\/code> class refers to the Person class in the HR.Dependents<\/code> namespace. To reference the Employee<\/code> class in the HR.Personnel<\/code> namespace, you need to use the fully qualified class name.<\/p>\n\n\n\n
C# namespace best practices<\/h2>\n\n\n\n
The following are the best practices when it comes to using namespaces in C#:<\/p>\n\n\n\n
    \n
  • Use meaningful and descriptive namespace names.<\/li>\n\n\n\n
  • Use nested namespaces to further organize code elements but avoid using nested namespaces that are too deep or complex.<\/li>\n\n\n\n
  • Use using directives sparingly and only for frequently used namespaces.<\/li>\n<\/ul>\n\n\n\n
    Summary<\/h2>\n\n\n\n
      \n
    • Use namespace and nested namespace to make your code more organized, especially when working with a large codebase.<\/li>\n\n\n\n
    • Use namespaces to avoid naming conflicts.<\/li>\n<\/ul>\n
      \n\t
      \n\t\t
      Was this tutorial helpful ?<\/div>\n\t\t
      \n\t\t\t\n\t\t\t\t\n\t\t\t\t\t<\/path>\n\t\t\t\t<\/svg>\n\t\t\t\t Yes <\/span>\n\t\t\t<\/button>\n\n\t\t\t\n\t\t\t\t\n\t\t\t\t\t<\/path>\n\t\t\t\t<\/svg>\n\t\t\t\t No <\/span>\n\t\t\t<\/button>\n\t\t<\/div>\n\t<\/header>\n\n\t
      \n\t\t
      \n\t\t\t
      <\/div>\n\t\t\t\n\t\t\t