Язык программирования C#9 и платформа .NET5 - Эндрю Троелсен
Шрифт:
Интервал:
Закладка:
static void LocalConstStringVariable()
{
// Доступ к локальным константным данным можно получать напрямую.
const string fixedStr = "Fixed string Data";
Console.WriteLine(fixedStr);
// Ошибка!
// fixedStr = "This will not work!";
}
Независимо от того, где вы определяете константную часть данных, всегда помните о том, что начальное значение, присваиваемое константе, должно быть указано в момент ее определения. Присваивание значения РI внутри конструктора класса приводит к ошибке на этапе компиляции:
class MyMathClass
{
// Попытка установить PI в конструкторе?
public const double PI;
public MyMathClass()
{
// Невозможно - присваивание должно осуществляться в момент объявления.
PI = 3.14;
}
}
Такое ограничение связано с тем фактом, что значение константных данных должно быть известно на этапе компиляции. Как известно, конструкторы (или любые другие методы) вызываются во время выполнения.
Понятие полей данных, допускающих только чтение
С константными данными тесно связано понятие полей данных, допускающих только чтение (которое не следует путать со свойствами, доступными только для чтения). Подобно константе поле только для чтения нельзя изменять после первоначального присваивания, иначе вы получите ошибку на этапе компиляции. Тем не менее, в отличие от константы значение, присваиваемое такому полю, может быть определено во время выполнения и потому может на законном основании присваиваться внутри конструктора, но больше нигде.
Поле только для чтения полезно в ситуации, когда значение не известно вплоть до стадии выполнения (возможно из-за того, что для его получения необходимо прочитать внешний файл), но нужно гарантировать, что впоследствии оно не будет изменяться. В целях иллюстрации рассмотрим следующую модификацию класса MyMathClass:
class MyMathClass
{
// Поля только для чтения могут присваиваться
// в конструкторах, но больше нигде.
public readonly double PI;
public MyMathClass ()
{
PI = 3.14;
}
}
Любая попытка выполнить присваивание полю, помеченному как readonly, за пределами конструктора приведет к ошибке на этапе компиляции:
class MyMathClass
{
public readonly double PI;
public MyMathClass ()
{
PI = 3.14;
}
// Ошибка!
public void ChangePI()
{ PI = 3.14444;}
}
Понятие статических полей, допускающих только чтение
В отличие от константных полей поля, допускающие только чтение, не являются неявно статическими. Таким образом, если необходимо предоставить доступ к PI на уровне класса, то придется явно использовать ключевое слово static. Если значение статического поля только для чтения известно на этапе компиляции, тогда начальное присваивание выглядит очень похожим на такое присваивание в случае константы (однако в этой ситуации проще применить ключевое слово const, потому что поле данных присваивается в момент его объявления):
class MyMathClass
{
public static readonly double PI = 3.14;
}
// Program.cs
Console.WriteLine("***** Fun with Const *****");
Console.WriteLine("The value of PI is: {0}", MyMathClass.PI);
Console.ReadLine();
Тем не менее, если значение статического поля только для чтения не известно вплоть до времени выполнения, то должен использоваться статический конструктор, как было описано ранее в главе:
class MyMathClass
{
public static readonly double PI;
static MyMathClass()
{ PI = 3.14; }
}
Понятие частичных классов
При работе с классами важно понимать роль ключевого слова partial языка С#. Ключевое слово partial позволяет разбить одиночный класс на множество файлов кода. Когда вы создаете шаблонные классы Entity Framework Core из базы данных, то все полученные в результате классы будут частичными. Таким образом, любой код, который вы написали для дополнения этих файлов, не будет перезаписан при условии, что код находится в отдельных файлах классов, помеченных с помощью ключевого слова partial. Еще одна причина связана с тем, что ваш класс может со временем разрастись и стать трудным в управлении, и в качестве промежуточного шага к его рефакторингу вы разбиваете код на части.
В языке C# одиночный класс можно разносить по нескольким файлам кода для отделения стереотипного кода от более полезных (и сложных) членов. Чтобы ознакомиться с ситуацией, когда частичные классы могут быть удобными, загрузите ранее созданный проект EmployееАрр в Visual Studio и откройте файл Employee.cs для редактирования. Как вы помните, этот единственный файл содержит код для всех аспектов класса:
class Employee
{
// Поля данных
// Конструкторы
// Методы
// Свойства
}
С применением частичных классов вы могли бы перенести (скажем) свойства, конструкторы и поля данных в новый файл по имени Employee.Core.cs (имя файла к делу не относится). Первый шаг предусматривает добавление ключевого слова partial к текущему определению класса и вырезание кода, подлежащего помещению в новый файл:
// Employee.cs
partial class Employee
{
// Методы
// Свойства
}
Далее предположив, что к проекту был добавлен новый файл класса, в него можно переместить поля данных и конструкторы с помощью простой операции вырезания и вставки. Кроме того, вы обязаны добавить ключевое слово partial к этому аспекту определения класса. Вот пример:
// Employee.Core.cs
partial class Employee
{
// Поля данных
// Свойства
}
На заметку! Не забывайте, что каждый частичный класс должен быть помечен ключевым словом partial!
После компиляции модифицированного проекта вы не должны заметить вообще никакой разницы. Вся идея, положенная в основу частичного класса, касается только стадии проектирования. Как только приложение скомпилировано, в сборке оказывается один целостный класс. Единственное требование при определении частичных классов связано с тем, что разные части должны иметь одно и то же имя класса и находиться внутри того же самого пространства имен .NET Core.
Использование записей (нововведение
