Как найти пространство имен

Пространства имен (namespace) позволяют выделять определенные части ваших приложений (классы, интерфейсы и т.д.) в логические блоки. Такой подход позволяет сделать код приложения более читабельным и понятным. Сама платформа .NET активно использует пространства имен для создания стройной и логичной структуры своих классов и объектов. Например, в пространстве имен System расположены все основные классы и объекты для работы (тот же класс Console), а в пространстве имен System.Text.Json — классы для работы с JSON и так далее.

  Чтобы определить пространство имен используется следующая конструкция:

namespace [название_пространства_имен]
{
  [код приложения]
}

С пространствами имен мы сталкиваемся уже на этапе знакомства с C#. Например, шаблонное консольное приложение для .NET 5 и более ранних версий выглядит следующим образом:

using System;

namespace ConsoleApp1
{
    internal class Program
    {
        static void Main(string[] args)
        {
            Console.WriteLine("Hello World!");
        }
    }
}

Здесь уже создано пространство имен для нашего приложения — ConsoleApp1.

Чтобы ваше приложение имело возможность использовать какие-либо классы платформы .NET необходимо подключить требуемое пространство имен в ваш проект. Для подключения пространства имен в проект используется ключевое слово using. Например, подключим к нашему проекту пространство имен, которое позволит работать с текстом:

using System;
using System.Text; //подключаем пространство имен

namespace ConsoleApp1
{
    internal class Program
    {
        static void Main(string[] args)
        {
            StringBuilder stringBuilder = new();
            //для .NET Core 3.1 и более ранних версий: StringBuilder stringBuilder = new StringBuilder();
            stringBuilder.AppendLine("Hello World");
            stringBuilder.AppendLine("Учимся подключать пространства имен");
            Console.WriteLine(stringBuilder.ToString());
        }
    }
}

Вложенные пространства имен

Пространства имен в C# могут быть вложенными. Например, мы можем организовать вот такую логическую структуру нашего проекта:

using System;
using System.Text; //подключаем пространство имен

namespace ConsoleApp1
{
    //вложенное пространство имен
    namespace MyNamespace
    {
        public class Data
        { 
            public string Name { get; set; } 
            public string Value { get; set; }   
        }
    }


    internal class Program
    {
        static void Main(string[] args)
        {
                       
        }
    }
}

Здесь мы определили вложенное пространство имен (namespace) MyNamespace. Теперь, чтобы использовать класс Data мы должны сделать так:

internal class Program
{
    static void Main(string[] args)
    {
        MyNamespace.Data data = new()
        {
            Name = "Привет",
            Value = "Мир!"
        };
    }
}

то есть, перед именем класса (Data) мы указываем название пространства имен (MyNamespace).

Более предпочтительным с точки зрения читабельности и поддержки проекта является организация пространства имен непосредственно через обозреватель решений Visual Studio. По умолчанию Visual Studio создает новое пространство имен в проекте на каждую папку в проекте. Например, создадим в нашем проекте попку с именем Base:

Теперь кликнем по папке правой кнопкой мыши, выберем в меню пункт «Добавить» и «Создать элемент»:

Создадим новый класс с названием BaseClass:

Обратите внимание на то, какое имя пространству имен присвоила Visual Studio:

По умолчанию, Visual Studio создала новый класс в пространстве имен составленному по шаблону: [Имя_проекта].[Папка_с_файлом]

Аналогичным образом мы можем создать поддиректорию в папке Base и пространство имен снова будет соответствовать физическому пути на диске, например:

namespace ConsoleApp1.Base.Interfaces
{
    internal interface IView
    {
    }
}

Физически этот интерфейс располагается по пути /Base/Interfaces/IView.cs

Таким образом, мы, с одной стороны можем логически разделять отдельные классы и объекты по пространствам имен, а, с другой стороны — подобное разделение (с использованием папок) будет наглядно видно в «Обозревателе решений»:

Глобальные пространства имен и пространства имен уровня файла

Глобальные пространства имен

Глобальные пространства имен удобно использовать в том случае, если вам необходимо использовать это пространство имен во всем (или в большинстве файлов) проекте. Например, уже используемое нами пространство имен System можно определить как глобальное. Чтобы определить глобальное пространство имен необходимо перед его объявлением использовать ключевое слово global.

global using System; //глобальное пространство имен

namespace ConsoleApp1
{
    internal class Program
    {
        static void Main(string[] args)
        {
            Console.WriteLine("Привет Мир!");
        }
    }
}

Теперь нам нет необходимости в каждом файле проекта для которого необходимо использование пространства имен System использовать конструкцию using System;.

namespace ConsoleApp1.Base
{
    internal class BaseClass
    {
        public BaseClass()
        {
            Console.WriteLine("Привет, Мир!");//класс Console взят из глобального пространства имен
        }
    }
}

Глобальные пространства имен можно определять в любом месте проекта, однако при этом, пространство имен с параметром global всегда должно находиться в коде выше, чем пространство имен без global:

Как можно видеть на скриншоте, Visual Studio указывает нам на то, что пространство имен с global необходимо перенести ВЫШЕ. И хоть мы имеем право определить глобальное пространство в любом удобном для нас месте, все же стоит придерживаться элементарных правил хорошего тона и постараться обеспечить поддержку нашего проекта в любом обозримом будущем. Поэтому все глобальные пространства имен лучше вынести в отдельный файл и назвать этот файл наиболее подходящим образом, например, GlobalUsings.cs или GlobalNamespaces.cs:

//Файл с глобальными пространствами имен
global using System; 
global using System.Data;
global using System.Data.Common;

В обозревателе решений этот файл находится на самом верхнем уровне в проекте:

Пространства имен уровня файла

Пространство имен уровня файла указывает на то, что всё, что содержится в файле относится к этому пространству имен. Чтобы определить пространство имен уровня файла в C# необходимо использовать конструкцию namespace без фигурных скобок, например:

//всё содержимое файла относится к этому пространству имен    
namespace ConsoleApp1.Base;

    internal class BaseClass
    {
        public BaseClass()
        {
        //класс Console взят из глобального пространства имен
        Console.WriteLine("Привет, Мир!");
        }
    }

Итого

Пространства имен в C# (namespace) — это, в первую очередь, логические структуры, которые позволяют разделить используемые в проекте классы и объекты по определенным признакам и сделать проект полее комфортным с точки зрения его поддержки. Начиная с .NET 6 C# 10, пространства имен могут быть глобальными (обозначаются ключевым словом global) и пространствами имен уровня файла.

В этом руководстве вы узнаете о пространствах имен, о том, как их определять, как получать доступ к их членам и использовать в программах на C#.

Пространства имен в C# определяет область кода, в которой гарантируется уникальность всех идентификаторов. Это своеобразные контейнеры, в которых находятся другие пространства имен, классы и т. д.

Пространство имен может включать следующие типы данных:

1. другие пространства имен;
2. классы;
3. интерфейсы;
4. структуры; 
5. делегаты.

Мы обсудим эти темы в следующих уроках. Пока поговорим только о классах и пространствах имен.

Пространства имен — необязательная часть программы на C#. Они нужны, чтобы управлять крупными проектами и писать чистый код.

Давайте разберемся с концепцией пространства имен на примере из реальной жизни. У вас на компьютере, скорее всего, куча файлов и папок. Представьте, как бы сложно было ими управлять, если бы они все лежали в одном каталоге. Вот почему мы помещаем связанные файлы и папки в отдельные каталоги. Это упрощает работу с данными.

Так же и с пространствами имен: они помогают нам организовывать разные члены, если мы поместим их в одно и то же пространства.

Пространство имен еще и решает проблему конфликта имен. Он возникает, когда два одинаковых идентификатора находятся в одной области видимости, и компилятор не может понять, какой из этих двух следует использовать в конкретной ситуации.

Определяем пространства имен

В C# определить пространство имен можно с помощью ключевого слова namespace.

namespace имя_пространства_имен
{
    // Тело пространства имен
}

Например:

namespace MyNamespace
{
    class MyClass
    {
        public void MyMethod()
        {
            System.Console.WriteLine("Создаем пространство имен");
		}
	}
}

В приведенном выше примере мы создали пространство имен с именем MyNamespace. Оно состоит из класса MyClass. MyMethod в свою очередь — метод класса MyClass.

Доступ к членам пространства имен

Доступ к членам пространства имен можно получить с помощью оператора .. Вот, как это делается:

Имя_пространства_имен.Имя_члена

Например, если нам нужно создать объект класса MyClass, это можно сделать вот так:

MyNamespace.MyClass myClass = new MyNamespace.MyClass();

Мы обсудим создание объектов в следующих уроках. А пока просто постарайтесь понять, как мы получаем доступ к классу MyClass.

Пример 1. Объявляем пространство имен

using System;

namespace MyNamespace
{
    public class SampleClass
    {
        public static void myMethod()
        {
            Console.WriteLine("Создаем пространство имен");
        }
    }
}
 
namespace MyProgram
{
    public class MyClass
    {
        public static void Main()
        {
            MyNamespace.SampleClass.myMethod();
        }
    }
}

Вывод:

Создаем пространство имен

В приведенной выше программе мы создали пространство имен MyNamespace и получили доступ к его членам из метода Main() класса MyClass. Как было сказано ранее, оператор . используется для доступа к членам пространства имен.

В методе Main() метод myMethod() вызывается с помощью оператора ..

Ключевое слово using

Пространство имен можно включить в программу с помощью ключевого слова using. Вот, как это делается:

using Namespace-Name;

Например:

using System

Преимущество такого подхода заключается в том, что нам не нужно указывать полное имя члена пространства имен каждый раз, когда мы обращаемся к нему.

Если в начале программы мы написали

using System

дальше спокойно можно писать

Console.WriteLine ("Привет, мир!");

вместо полного имени

System.Console.WriteLine ("Привет, мир!");

Вложенное пространство имен

Внутри одного пространства имен может содержаться другое пространство имен. Это называется вложенным пространством имен. Доступ к вложенному пространству имен и его членам получается точно так же, с помощью оператора ..

Синтаксис

namespace Имя_пространства_имен
{
    namespace Имя_вложенного_пространства_имен
    {
        // Тело вложенного пространства имен
	}
}

Пример 2. Работаем с вложенным пространством имен

using System;
 
// Вложенное пространство имен
namespace MyNamespace
{
    namespace Nested
    {
        public class SampleClass
        {
            public static void myMethod()
            {
                Console.WriteLine("Пример вложенного пространства имен");
            }
        }
    }
}
 
namespace MyProgram
{
    public class MyClass
    {
        public static void Main()
        {
            MyNamespace.Nested.SampleClass.myMethod();
        }
    }
}

Вывод:

Пример вложенного пространства имен

#include <iostream>

//После ключевого слова namespace указываем название пространства имён
namespace mynames
{
    //Всё, что находится внутри этого блока, относится к mynames
    const double Pi = 3.14;

    int sum(int a, int b)
    {
   	 return a + b;
    }
}

int main()
{
    //Для вызова функции sum нужно сначала указать пространство имён
    int a = mynames::sum(5, 12);

    std::cout << "a = " << a << "n";

    //Так же при использовании переменных и констант
    std::cout << "Pi = " << mynames::Pi << "n";
}

using namespace std;
using namespace mynames;

int main()
{
    int a = sum(5, 12);

    cout << "a = " << a << "n";
    cout << "Pi = " << Pi << "n";
}

//Подключить пространство имён std
using namespace std;

//Подключить функцию sum() из пространства имён mynames
using mynames::sum;

int main()
{
    int a = sum(5, 12);

    cout << "a = " << a << "n";
    cout << "Pi = " << mynames::Pi << "n";
}

namespace mymath
{
    const double Pi = 3.14;

    int sum(int a, int b)
    {
   	 return a + b;
    }

    int pow(int base, int exponent)
    {
   	 int result = base;

   	 for(int i = 1; i < exponent; i++)
   	 {
   		 result *= base;
   	 }

   	 return result;
    }
} 

//Подключаем в нашу библиотеку две другие
#include <iostream>
#include <cmath>

namespace math2
{
	void printPow(int base, int exponent)
	{
    	    //Обратите внимание, что функция pow(), которая находится в cmath, не относится ни к какому пространству имён
              //Точно так же вы можете создавать библиотеки без пространств имён
    	    int result = pow(base, exponent);

    	    std::cout << base << "^" << exponent << " = " << result << "n";
	}
}

#include <iostream>
#include "mylib.h"

using namespace std;

int main()
{
    int base = 5;
    int exponent = 4;

    int result = mymath::pow(base, exponent);

    cout << base << "^" << exponent << " = " << result << "n";
}

Научитесь: Профессия Разработчик на C++
Узнать больше