Язык программирования C#9 и платформа .NET5

С точки зрения платформы .NET Core наиболее фундаментальной программной конструкцией является тип класса. Формально класс — это определяемый пользователем тип, состоящий из полей данных (часто называемых переменными-членами) и членов, которые оперируют полями данных (к ним относятся конструкторы, свойства, методы, события и т.д.). Коллективно набор полей данных представляет "состояние" экземпляра класса (также известного как объект). Мощь объектно-ориентированных языков, таких как С#, заключается в том, что за счет группирования данных и связанной с ними функциональности в унифицированное определение класса вы получаете возможность моделировать свое программное обеспечение в соответствии с сущностями реального мира.

Для начала создайте новый проект консольного приложения C# по имени

SimpleClassExample

Car.cs

Car.cs

using

using System;

namespace SimpleClassExample

{

}

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

Класс определяется в C# с применением ключевого слова

class

SimpleClassExample

class Car

{

}

После определения типа класса необходимо определить набор переменных-членов, которые будут использоваться для представления его состояния. Например, вы можете принять решение, что объекты

Car

int

string

Car

class Car 

{ 

  // 'Состояние' объекта Car. 

  public string petName; 

  public int currSpeed; 

} 

Обратите внимание, что переменные-члены объявлены с применением модификатора доступа

public

public

new

На заметку! Поля данных класса редко (если вообще когда-нибудь) должны определяться как открытые. Чтобы обеспечить целостность данных состояния, намного лучше объявлять данные закрытыми (

private

protected

После определения набора переменных-членов, представляющих состояние класса, следующим шагом в проектировании будет установка членов, которые моделируют его поведение. Для этого примера в классе

Car

SpeedUp()

PrintState()

Car

class Car

{

  // 'Состояние' объекта Car.

  public string petName;

  public int currSpeed;

  // Функциональность Car.

  // Использовать синтаксис членов, сжатых до выражений,

  // который рассматривался в главе 4.

  public void PrintState()

    => Console.WriteLine("{0} is going {1} MPH.", petName, currSpeed);

  public void SpeedUp(int delta)

    => currSpeed += delta;

}

Метод

PrintState()

Car

SpeedUp()

Car

int

Program.cs

Console.WriteLine("***** Fun with Class Types *****\n");

// Разместить в памяти и сконфигурировать объект Car.

Car myCar = new Car();

myCar.petName = "Henry";

myCar.currSpeed = 10;

// Увеличить скорость автомобиля в несколько раз и вывести новое состояние.

for (int i = 0; i <= 10; i++)

{

  myCar.SpeedUp(5);

  myCar.PrintState();

}

Console.ReadLine();

Запустив программу, вы увидите, что переменная

Car

myCar

***** Fun with Class Types *****

Henry is going 15 MPH.

Henry is going 20 MPH.

Henry is going 25 MPH.

Henry is going 30 MPH.

Henry is going 35 MPH.

Henry is going 40 MPH.

Henry is going 45 MPH.

Henry is going 50 MPH.

Henry is going 55 MPH.

Henry is going 60 MPH.

Henry is going 65 MPH.

Размещение объектов с помощью ключевого слова new

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

new

new

Console.WriteLine("***** Fun with Class Types *****\n");

// Ошибка на этапе компиляции! Забыли использовать new для создания объекта!

Car myCar;

myCar.petName = "Fred";

Чтобы корректно создать объект с применением ключевого слова

new

Car

Console.WriteLine("***** Fun with Class Types *****\n");

Car myCar = new Car();

myCar.petName = "Fred";

В качестве альтернативы определение и размещение в памяти экземпляра класса может осуществляться в отдельных строках кода:

Console.WriteLine("***** Fun with Class Types *****\n");

Car myCar;

myCar = new Car();

myCar.petName = "Fred";

Здесь первый оператор кода просто объявляет ссылку на определяемый объект типа

Car

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

Car

Учитывая наличие у объекта состояния (представленного значениями его переменных-членов), обычно желательно присвоить подходящие значения полям объекта перед тем, как работать с ним. В настоящее время класс

Car

petName

currSpeed

К счастью, язык C# поддерживает использование конструкторов, которые позволяют устанавливать состояние объекта в момент его создания. Конструктор — это специальный метод класса, который неявно вызывается при создании объекта с применением ключевого слова new. Однако в отличие от "нормального" метода конструктор никогда не имеет возвращаемого значения (даже

void

Роль стандартного конструктора

Каждый класс C# снабжается "бесплатным" стандартным конструктором, который в случае необходимости может быть переопределен. По определению стандартный конструктор никогда не принимает аргументов. После размещения нового объекта в памяти стандартный конструктор гарантирует установку всех полей данных в соответствующие стандартные значения (стандартные значения для типов данных C# были описаны в главе 3).

Если вас не устраивают такие стандартные присваивания, тогда можете переопределить стандартный конструктор в соответствии со своими нуждами. В целях иллюстрации модифицируем класс C# следующим образом:

class Car

{

  // 'Состояние' объекта Car.

  public string petName;

  public int currSpeed;

  // Специальный стандартный конструктор.

  public Car()

  {

   petName = "Chuck";

   currSpeed = 10;

...

}

В данном случае мы заставляем объекты

Car

Chuck

Car

Console.WriteLine("***** Fun with Class Types *****\n");

// Вызов стандартного конструктора.

Car chuck = new Car();

// Выводит строку "Chuck is going 10 MPH."

chuck.PrintState();

...

Определение специальных конструкторов

Car

class Car

{

  // 'Состояние' объекта Car.

  public string petName;

  public int currSpeed;

  // Специальный стандартный конструктор.

  public Car()

  {

   petName = "Chuck";

   currSpeed = 10;

  }

  // Здесь currSpeed получает стандартное значение для типа int (0).

  public Car(string pn)

  {

   petName = pn;

  }

  // Позволяет вызывающему коду установить полное состояние объекта Car.

  public Car(string pn, int cs)

  {

   petName = pn;

   currSpeed = cs;

  }

...

}

Car

Car

Console.WriteLine("***** Fun with Class Types *****\n");

// Создать объект Car по имени Chuck со скоростью 10 миль в час.

Car chuck = new Car();

chuck.PrintState();

// Создать объект Car по имени Mary со скоростью 0 миль в час.

Car mary = new Car("Mary");

mary.PrintState();

// Создать объект Car по имени Daisy со скоростью 75 миль в час.

Car daisy = new Car("Daisy", 75);

daisy.PrintState();

...

get/set

// Здесь currSpeed получит стандартное

// значение для типа int (0).

public Car(string pn) => petName = pn;

out

Car

public Car(string pn, int cs, out bool inDanger)

{

  petName = pn;

  currSpeed = cs;

  if (cs > 100)

  {

   inDanger = true;

  }

  else

  {

   inDanger = false;

  }

}

out

inDanger

Еще раз о стандартном конструкторе

Как вы только что узнали, все классы снабжаются стандартным конструктором. Добавьте в свой проект новый файл по имени

Motorcycle.cs

Motorcycle

using System;

namespace SimpleClassExample

{

  class Motorcycle

  {

   public void PopAWheely()

   {

    Console.WriteLine("Yeeeeeee Haaaaaeewww!");

   }

  }

}

Теперь появилась возможность создания экземпляров

Motorcycle

Console.WriteLine("***** Fun with Class Types *****\n");

Motorcycle mc = new Motorcycle();

mc.PopAWheely();

...

Тем не менее, как только определен специальный конструктор с любым числом параметров, стандартный конструктор молча удаляется из класса и перестает быть доступным. Воспринимайте это так: если вы не определили специальный конструктор, тогда компилятор C# снабжает класс стандартным конструктором, давая возможность пользователю размещать в памяти экземпляр вашего класса с набором полей данных, которые установлены в корректные стандартные значения. Однако когда вы определяете уникальный конструктор, то компилятор предполагает, что вы решили взять власть в свои руки.

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

Motorcycle

class Motorcycle

{

  public int driverIntensity;

  public void PopAWheely()

  {

   for (int i = 0; i <= driverIntensity; i++)

   {

    Console.WriteLine("Yeeeeeee Haaaaaeewww!");

   }

  }

  // Вернуть стандартный конструктор, который будет.

  // устанавливать все члены данных в стандартные значения

  public Motorcycle() {}

  // Специальный конструктор.

  public Motorcycle(int intensity)

  {

   driverIntensity = intensity;

  }

}

На заметку! Теперь, когда вы лучше понимаете роль конструкторов класса, полезно узнать об одном удобном сокращении. В Visual Studio и Visual Studio Code предлагается фрагмент кода

ctor

ctor

В языке C# имеется ключевое слово

this

this

Motorcycle

string

name

SetDriverName()

class Motorcycle

{

  public int driverIntensity;

  // Новые члены для представления имени водителя.

  public string name;

  public void SetDriverName(string name) => name = name;

...

}

Хотя приведенный код нормально скомпилируется, компилятор C# выдаст сообщение с предупреждением о том, что переменная присваивается сама себе! В целях иллюстрации добавьте в свой код вызов метода

SetDriverName()

// Создать объект Motorcycle с мотоциклистом по имени Tiny?

Motorcycle c = new Motorcycle(5);

c.SetDriverName("Tiny");

c.PopAWheely();

Console.WriteLine("Rider name is {0}", c.name);  // Выводит пустое значение name!

Проблема в том, что реализация метода

SetDriverName()

name

name

name

this

public void SetDriverName(string name) => this.name = name;

Если неоднозначность отсутствует, тогда применять ключевое слово

this

string

name

driverName

this

class Motorcycle

{

  public int driverIntensity;

  public string driverName;

  public void SetDriverName(string name)

  {

   // These two statements are functionally the same.

   driverName = name;

   this.driverName = name;

  }

...

}

Несмотря на то что применение ключевого слова

this

this

На заметку! Общепринятое соглашение об именовании предусматривает снабжение имен закрытых (или внутренних) переменных уровня класса префиксом в виде символа подчеркивания (скажем,

_driverName

Построение цепочки вызовов конструкторов с использованием this

Еще один сценарий применения ключевого слова

this

Motorcycle

class Motorcycle

{

  public int driverIntensity;

  public string driverName;

  public Motorcycle() { }

  // Избыточная логика конструктора!

  public Motorcycle(int intensity)

  {

   if (intensity > 10)

   {

  intensity = 10;

   }

   driverIntensity = intensity;

  }

  public Motorcycle(int intensity, string name)

  {

   if (intensity > 10)

   {

    intensity = 10;

   }

   driverIntensity = intensity;

   driverName = name;

  }

...

}

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

Один из способов улучшить создавшуюся ситуацию предусматривает определение в классе

Motorcycle

class Motorcycle

{

  public int driverIntensity;

  public string driverName;

  // Конструкторы.

  public Motorcycle() { }

  public Motorcycle(int intensity)

  {

   SetIntensity(intensity);

  }

  public Motorcycle(int intensity, string name)

  {

   SetIntensity(intensity);

   driverName = name;

  }

  public void SetIntensity(int intensity)

  {

   if (intensity > 10)

   {

    intensity = 10;

   }

  driverIntensity = intensity;

  }

...

}

Более совершенный подход предполагает назначение конструктора, который принимает наибольшее количество аргументов, в качестве "главного конструктора" и выполнение требуемой логики проверки достоверности внутри его реализации. Остальные конструкторы могут применять ключевое слово

this

Ниже представлена финальная реализация класса

Motorcycle

this

class Motorcycle

{

  public int driverIntensity;

  public string driverName;

  // Связывание конструкторов в цепочку.

  public Motorcycle() {}

  public Motorcycle(int intensity)

   : this(intensity, "") {}

  public Motorcycle(string name)

   : this(0, name) {}

  // Это 'главный' конструктор, выполняющий всю реальную работу.

  public Motorcycle(int intensity, string name)

  {

   if (intensity > 10)

   {

    intensity = 10;

   }

   driverIntensity = intensity;

   driverName = name;

  }

...

}

Имейте в виду, что использовать ключевое слово

this

На заметку! Вспомните из главы 4, что в языке C# поддерживаются необязательные параметры. Если вы будете использовать в конструкторах своих классов необязательные параметры, то сможете добиться тех же преимуществ, что и при связывании конструкторов в цепочку, но с меньшим объемом кода. Вскоре вы увидите, как это делается.

Исследование потока управления конструкторов

Напоследок отметим, что как только конструктор передал аргументы выделенному главному конструктору (и главный конструктор обработал данные), первоначально вызванный конструктор продолжит выполнение всех оставшихся операторов кода. В целях прояснения модифицируйте конструкторы класса

Motorcycle

Console.WriteLine()

class Motorcycle

{

  public int driverIntensity;

  public string driverName;

  // Связывание конструкторов в цепочку.

  public Motorcycle()

  {

   Console.WriteLine("In default ctor");

           // Внутри стандартного конструктора

  }

  public Motorcycle(int intensity) 

: this(intensity, "")

  {

   Console.WriteLine("In ctor taking an int");

          // Внутри конструктора, принимающего int

  }

  public Motorcycle(string name) 

: this(0, name)

  {

   Console.WriteLine("In ctor taking a string");

           // Внутри конструктора, принимающего string

  }

  // Это 'главный' конструктор, выполняющий всю реальную работу.

  public Motorcycle(int intensity, string name)

  {

   Console.WriteLine("In master ctor ");

           // Внутри главного конструктора

   if (intensity > 10)

   {

    intensity = 10;

   }

   driverIntensity = intensity;

   driverName = name;

  }

  ...

}

Теперь измените операторы верхнего уровня, чтобы они работали с объектом

Motorcycle

Console.WriteLine("***** Fun with class Types *****\n");

// Создать объект Motorcycle.

Motorcycle c = new Motorcycle(5);

c.SetDriverName("Tiny");

c.PopAWheely();

Console.WriteLine("Rider name is {0}", c.driverName);

        // вывод имени гонщика

Console.ReadLine();

Вот вывод, полученный в результате выполнения показанного выше кода:

***** Fun with Motorcycles *****

In master ctor

In ctor taking an int

Yeeeeeee Haaaaaeewww!

Yeeeeeee Haaaaaeewww!

Yeeeeeee Haaaaaeewww!

Yeeeeeee Haaaaaeewww!

Yeeeeeee Haaaaaeewww!

Yeeeeeee Haaaaaeewww!

Rider name is Tiny

Ниже описан поток логики конструкторов.

• Первым делом создается объект путем вызова конструктора, принимающего один аргумент типа

int

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

• Главный конструктор присваивает входные данные полям данных объекта.

• Управление возвращается первоначально вызванному конструктору, который выполняет оставшиеся операторы кода.

В построении цепочек конструкторов примечательно то, что данный шаблон программирования будет работать с любой версией языка C# и платформой .NET Core. Тем не менее, если целевой платформой является .NET 4.0 или последующая версия, то решение задач можно дополнительно упростить, применяя необязательные аргументы в качестве альтернативы построению традиционных цепочек конструкторов.

Еще раз о необязательных аргументах

В главе 4 вы изучили необязательные и именованные аргументы. Вспомните, что необязательные аргументы позволяют определять стандартные значения для входных аргументов. Если вызывающий код устраивают стандартные значения, то указывать уникальные значения не обязательно, но это нужно делать, чтобы снабдить объект специальными данными. Рассмотрим следующую версию класса

Motorcycle

class Motorcycle

{

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

  public Motorcycle(int intensity = 0, string name = "")

  {

   if (intensity > 10)

   {

    intensity = 10;

   }

   driverIntensity = intensity;

  driverName = name;

  }

...

}

С помощью такого единственного конструктора можно создавать объект

Motorcycle

static void MakeSomeBikes()

{

  // driverName = "", driverIntensity = 0

  Motorcycle m1 = new Motorcycle();

  Console.WriteLine("Name= {0}, Intensity= {1}",

   m1.driverName, m1.driverIntensity);

  // driverName = "Tiny", driverIntensity = 0

  Motorcycle m2 = new Motorcycle(name:"Tiny");

  Console.WriteLine("Name= {0}, Intensity= {1}",

   m2.driverName, m2.driverIntensity);

  // driverName = "", driverIntensity = 7

  Motorcycle m3 = new Motorcycle(7);

  Console.WriteLine("Name= {0}, Intensity= {1}",

   m3.driverName, m3.driverIntensity);

}

В любом случае к настоящему моменту вы способны определить класс с полями данных (т.е. переменными-членами) и разнообразными операциями, такими как методы и конструкторы. А теперь формализуем роль ключевого слова

static

В классе C# можно определять любое количество статических членов, объявляемых с применением ключевого слова

static

System.Console

WriteLine()

// Ошибка на этапе компиляции! WriteLine() - не метод уровня объекта!

Console c = new Console();

c.WriteLine("I can't be printed...");

Взамен статический член

WriteLine()

// Правильно! WriteLine() - статический метод.

Console.WriteLine("Much better! Thanks...");

Выражаясь просто, статические члены — это элементы, которые проектировщик класса посчитал настолько общими, что перед обращением к ним даже нет нужды создавать экземпляр класса. Наряду с тем, что определять статические члены можно в любом классе, чаще всего они обнаруживаются внутри обслуживающих классов. По определению обслуживающий класс представляет собой такой класс, который не поддерживает какое-либо состояние на уровне объектов и не предполагает создание своих экземпляров с помощью ключевого слова new. Взамен обслуживающий класс открывает доступ ко всей функциональности посредством членов уровня класса (также известных под названием статических).

Например, если бы вы воспользовались браузером объектов Visual Studio (выбрав пункт меню View►Object Browser (Вид►Браузер объектов)) для просмотра пространства имен

System

Console

Math

Environment

GC

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

static

• данные класса;

• методы класса;

• свойства класса;

• конструктор;

• полное определение класса;

• в сочетании с ключевым словом

using

Давайте рассмотрим все варианты, начав с концепции статических данных.

На заметку! Роль статических свойств будет объясняться позже в главе во время исследования самих свойств.

Определение статических полей данных

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

Чтобы увидеть разницу, создайте новый проект консольного приложения под названием

StaticDataAndMembers

SavingsAccount.cs

SavingsAccount

using System;

namespace StaticDataAndMembers

{

  // Простой класс депозитного счета.

  class SavingsAccount

  {

   // Данные уровня экземпляра.

   public double currBalance;

   public SavingsAccount(double balance)

   {

    currBalance = balance;

   }

  }

}

При создании объектов

SavingsAccount

currBalance

SavingsAccount

С другой стороны, память под статические данные распределяется один раз и используется всеми объектами того же самого класса. Добавьте в класс

SavingsAccount

currInterestRate

0.04

// Простой класс депозитного счета.

class SavingsAccount

{

  // Статический элемент данных.

  public static double currInterestRate = 0.04;

  // Данные уровня экземпляра.

  public double currBalance;

  public SavingsAccount(double balance)

  {

   currBalance = balance;

  }

}

Создайте три экземпляра класса

SavingsAccount

using System;

using StaticDataAndMembers;

  Console.WriteLine("***** Fun with Static Data *****\n");

  SavingsAccount s1 = new SavingsAccount(50);

  SavingsAccount s2 = new SavingsAccount(100);

  SavingsAccount s3 = new SavingsAccount(10000.75);

  Console.ReadLine();

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

Здесь предполагается, что все депозитные счета должны иметь одну и ту же процентную ставку. Поскольку статические данные разделяются всеми объектами той же самой категории, если вы измените процентную ставку каким-либо образом, тогда все объекты будут "видеть" новое значение при следующем доступе к статическим данным, т.к. все они по существу просматривают одну и ту же ячейку памяти. Чтобы понять, как изменять (или получать) статические данные, понадобится рассмотреть роль статических методов.

Определение статических методов

Модифицируйте класс

SavingsAccount

GetInterestRate()

SetInterestRate()

// Простой класс депозитного счета.

class SavingsAccount

{

  // Данные уровня экземпляра.

  public double currBalance;

  // Статический элемент данных.

  public static double currInterestRate = 0.04;

  public SavingsAccount(double balance)

  {

   currBalance = balance;

  }

  // Статические члены для установки/получения процентной ставки.

  public static void SetInterestRate(double newRate)

   => currInterestRate = newRate;

  public static double GetInterestRate()

   => currInterestRate;

}

Рассмотрим показанный ниже сценарий использования класса:

using System;

using StaticDataAndMembers;

Console.WriteLine("***** Fun with Static Data *****\n");

SavingsAccount s1 = new SavingsAccount(50);

SavingsAccount s2 = new SavingsAccount(100);

// Вывести текущую процентную ставку.

Console.WriteLine("Interest Rate is: {0}", SavingsAccount.GetInterestRate());

// Создать новый объект; это не 'сбросит' процентную ставку.

SavingsAccount s3 = new SavingsAccount(10000.75);

Console.WriteLine("Interest Rate is: {0}", SavingsAccount.GetInterestRate());

Console.ReadLine();

Вывод предыдущего кода выглядит так:

***** Fun with Static Data *****

Interest Rate is: 0.04

Interest Rate is: 0.04

Как видите, при создании новых экземпляров класса

SavingsAccount

SavingsAccount

currInterestRate

Когда проектируется любой класс С#, одна из задач связана с выяснением того, какие порции данных должны быть определены как статические члены, а какие — нет. Хотя строгих правил не существует, запомните, что поле статических данных разделяется между всеми объектами конкретного класса. Поэтому, если необходимо, чтобы часть данных совместно использовалась всеми объектами, то статические члены будут самым подходящим вариантом.

Посмотрим, что произойдет, если поле

currInterestRate

static

SavingAccount

currInterestRate

SavingAccount

SetInterestRate()

На заметку! Ссылка на нестатические члены внутри реализации статического члена приводит к ошибке на этапе компиляции. В качестве связанного замечания: ошибкой также будет применение ключевого слова

this

this

Определение статических конструкторов

Типичный конструктор используется для установки значений данных уровня экземпляра во время его создания. Однако что произойдет, если вы попытаетесь присвоить значение статическому элементу данных в типичном конструкторе? Вы можете быть удивлены, обнаружив, что значение сбрасывается каждый раз, когда создается новый объект.

В целях иллюстрации модифицируйте код конструктора класса

SavingsAccount

currInterestRate

class SavingsAccount

{

  public double currBalance;

  public static double currInterestRate;

  // Обратите внимание, что наш конструктор устанавливает

  // значение статического поля currInterestRate.

  public SavingsAccount(double balance)

  {

   currInterestRate = 0.04; // Это статические данные!

   currBalance = balance;

  }

  ...

}

Теперь добавьте к операторам верхнего уровня следующий код:

// Создать объект счета.

SavingsAccount s1 = new SavingsAccount(50);

// Вывести текущую процентную ставку.

Console.WriteLine("Interest Rate is: {0}", SavingsAccount.GetInterestRate());

// Попытаться изменить процентную ставку через свойство.

SavingsAccount.SetInterestRate(0.08);

// Создать второй объект счета.

SavingsAccount s2 = new SavingsAccount(100);

// Должно быть выведено 0.08, не так ли?

Console.WriteLine("Interest Rate is: {0}", SavingsAccount.GetInterestRate());

Console.ReadLine();

При выполнении этого кода вы увидите, что переменная

currInterestRate

SavingsAccount

0.04

class SavingsAccount

{

  public double currBalance;

  // Статические данные.

  public static double currInterestRate = 0.04;

  ...

}

Такой подход обеспечит установку статического поля только один раз независимо от того, сколько объектов создается. Но что, если значение статических данных необходимо получать во время выполнения? Например, в типичном банковском приложении значение переменной, представляющей процентную ставку, будет читаться из базы данных или внешнего файла. Решение задач подобного рода обычно требует области действия метода, такого как конструктор, для выполнения соответствующих операторов кода.

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

class SavingsAccount

{

  public double currBalance;

  public static double currInterestRate;

  public SavingsAccount(double balance)

  {

   currBalance = balance;

  }

 // Статический конструктор!

  static SavingsAccount()

  {

   Console.WriteLine("In static ctor!");

   currInterestRate = 0.04;

  }

...

}

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

"In static ctor!"

***** Fun with Static Data *****

In static ctor!

Interest Rate is: 0.04

Interest Rate is: 0.08

Ниже отмечено несколько интересных моментов, касающихся статических конструкторов.

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

• Статический конструктор не имеет модификатора доступа и не может принимать параметры.

• Статический конструктор выполняется только один раз вне зависимости от количества создаваемых объектов заданного класса.

• Исполняющая система вызывает статический конструктор, когда создает экземпляр класса или перед доступом к первому статическому члену из вызывающего кода.

• Статический конструктор выполняется перед любым конструктором уровня экземпляра.

С учетом такой модификации при создании новых объектов

SavingsAccount

Определение статических классов

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

static

new

static

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

На первый взгляд такое средство может показаться довольно странным, учитывая невозможность создания экземпляров класса. Тем не менее, в первую очередь класс, который содержит только статические члены и/или константные данные, не нуждается в выделении для него памяти. В целях иллюстрации определите новый класс по имени

TimeUtilClass

using System;

namespace StaticDataAndMembers

{

  // Статические классы могут содержать только статические члены!

  static class TimeUtilClass

  {

   public static void PrintTime()

    => Console.WriteLine(DateTime.Now.ToShortTimeString());

   public static void PrintDate()

    => Console.WriteLine(DateTime.Today.ToShortDateString());

  }

}

Так как класс

TimeUtilClass

static

new

// Это работает нормально.

TimeUtilClass.PrintDate();

TimeUtilClass.PrintTime();

// Ошибка на этапе компиляции!

// Создавать экземпляры статического класса невозможно!

TimeUtilClass u = new TimeUtilClass ();

Console.ReadLine();

Импортирование статических членов с применением ключевого слова using языка C#

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

using

WriteLine()

Console

Now

Today

DateTime

using

System

using static

// Импортировать статические члены классов Console и DateTime. 

using static System.Console; 

using static System.DateTime; 

После такого "статического импортирования" в файле кода появляется возможность напрямую применять статические методы классов

Console

DateTime

TimeUtilClass

static class TimeUtilClass

{

 public static void PrintTime()

   => WriteLine(Now.ToShortTimeString());

  public static void PrintDate()

   => WriteLine(Today.ToShortDateString());

}

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

System.Math

using static

Math

Однако имейте в виду, что злоупотребление операторами статического импортирования может привести в результате к путанице. Во-первых, как быть, если метод

WriteLine()

WriteLine()

Console

using static

К настоящему моменту вы должны уметь определять простые типы классов, содержащие конструкторы, поля и разнообразные статические (и нестатические) члены. Обладая такими базовыми знаниями о конструкции классов, можно приступать к ознакомлению с тремя основными принципами объектно-ориентированного программирования (ООП).

Все объектно-ориентированные языки (С#, Java, C++, Visual Basic и т.д.) должны поддерживать три основных принципа ООП.

• Инкапсуляция. Каким образом язык скрывает детали внутренней реализации объектов и предохраняет целостность данных?

• Наследование. Каким образом язык стимулирует многократное использование кода?

• Полиморфизм. Каким образом язык позволяет трактовать связанные объекты в сходной манере?

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

Роль инкапсуляции

Первый основной принцип ООП называется инкапсуляцией. Такая характерная черта описывает способность языка скрывать излишние детали реализации от пользователя объекта. Например, предположим, что вы имеете дело с классом по имени

DatabaseReader

Open()

Close()

// Пусть этот класс инкапсулирует детали открытия и закрытия базы данных.

DatabaseReader dbReader = new DatabaseReader();

dbReader.Open(@"C:\AutoLot.mdf");

// Сделать что-то с файлом данных и закрыть файл.

dbReader.Close();

Вымышленный класс

DatabaseReader

DatabaseReader

AutoLot.mdf

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

private

internal

protected

Роль наследования

Следующий принцип ООП — наследование — отражает возможность языка разрешать построение определений новых классов на основе определений существующих классов. По сути, наследование позволяет расширять поведение базового (или родительского) класса за счет наследования его основной функциональности производным подклассом (также называемым дочерним классом). На рис. 5.2 показан простой пример.

Диаграмма на рис. 5.2 читается так: "шестиугольник (

Hexagon

Shape

Object

Здесь можно предположить, что класс

Shape

Hexagon

Shape

Shape

Object

На заметку! В рамках платформ .NET/.NET Core класс

System.Object

В мире ООП существует еще одна форма повторного использования кода: модель включения/делегации, также известная как отношение "имеет" ("has-a") или агрегация. Такая форма повторного использования не применяется для установки отношений "родительский-дочерний". На самом деле отношение "имеет" позволяет одному классу определять переменную-член другого класса и опосредованно (когда требуется) открывать доступ к его функциональности пользователю объекта.

Например, предположим, что снова моделируется автомобиль. Может возникнуть необходимость выразить идею, что автомобиль "имеет" радиоприемник. Было бы нелогично пытаться наследовать класс

Car

Radio

Car

Radio

Car

Radio

class Radio

{

  public void Power(bool turnOn)

  {

   Console.WriteLine("Radio on: {0}", turnOn);

  }

}

class Car

{

  // Car 'имеет' Radio.

  private Radio myRadio = new Radio();

  public void TurnOnRadio(bool onOff)

  {

   // Делегировать вызов внутреннему объекту.

   myRadio.Power(onOff);

  }

}

Обратите внимание, что пользователю объекта ничего не известно об использовании классом

Car

Radio

// Call is forwarded to Radio internally.

Car viper = new Car();

viper.TurnOnRadio(false);

Роль полиморфизма

Последним основным принципом ООП является полиморфизм. Указанная характерная черта обозначает способность языка трактовать связанные объекты в сходной манере. В частности, данный принцип ООП позволяет базовому классу определять набор членов (формально называемый полиморфным интерфейсом), которые доступны всем наследникам. Полиморфный интерфейс класса конструируется с применением любого количества виртуальных или абстрактных членов (подробности ищите в главе 6).

Выражаясь кратко, виртуальный член — это член базового класса, определяющий стандартную реализацию, которую можно изменять (или более формально переопределять) в производном классе. В отличие от него абстрактный метод — это член базового класса, который не предоставляет стандартную реализацию, а предлагает только сигнатуру. Если класс унаследован от базового класса, в котором определен абстрактный метод, то такой метод должен быть переопределен в производном классе. В любом случае, когда производные классы переопределяют члены, определенные в базовом классе, по существу они переопределяют свою реакцию на тот же самый запрос.

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

Shape

Draw()

Hexagon

Circle

Draw()

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

Hexagon

Circle

Shape

Shape

Shape

Draw()

Рассмотрим следующий код, который заставляет массив элементов производных от

Shape

Draw()

Shape[] myShapes = new Shape[3];

myShapes[0] = new Hexagon();

myShapes[1] = new Circle();

myShapes[2] = new Hexagon();

foreach (Shape s in myShapes)

{

  // Использовать полиморфный интерфейс!

  s.Draw();

}

Console.ReadLine();

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

При работе с инкапсуляцией вы должны всегда принимать во внимание то, какие аспекты типа являются видимыми различным частям приложения. В частности, типы (классы, интерфейсы, структуры, перечисления и делегаты), а также их члены (свойства, методы, конструкторы и поля) определяются с использованием специального ключевого слова, управляющего "видимостью" элемента для других частей приложения. Хотя в C# для управления доступом предусмотрены многочисленные ключевые слова, они отличаются в том, к чему могут успешно применяться (к типу или члену). Модификаторы доступа и особенности их использования описаны в табл. 5.1.

В текущей главе рассматриваются только ключевые слова

public

private

internal

protected internal

protected

Использование стандартных модификаторов доступа

По умолчанию члены типов являются неявно закрытыми (

private

internal

internal

private

// Внутренний класс с закрытым стандартным конструктором.

class Radio

{

  Radio(){}

}

Если вы предпочитаете явное объявление, тогда можете добавить соответствующие ключевые слова без каких-либо негативных последствий (помимо дополнительных усилий по набору):

// Внутренний класс с закрытым стандартным конструктором.

internal class Radio

{

  private Radio(){}

}

Чтобы позволить другим частям программы обращаться к членам объекта, вы должны определить эти члены с ключевым словом

public

protected

Radio

public

// Открытый класс с открытым стандартным конструктором.

public class Radio

{

  public Radio(){}

}

Использование модификаторов доступа и вложенных типов

Как упоминалось в табл. 5.1, модификаторы доступа

private

protected

protected internal

private protected

CarColor

SportsCar

public class SportsCar

{

  // Нормально! Вложенные типы могут быть помечены как private.

  private enum CarColor

  {

   Red, Green, Blue

  }

}

Здесь допустимо применять модификатор доступа

private

SportsCar

public

internal

// Ошибка! Невложенный тип не может быть помечен как private!

public class Radio

{

  public Radio(){}

}

Концепция инкапсуляции вращается вокруг идеи о том, что данные класса не должны быть напрямую доступными через его экземпляр. Наоборот, данные класса определяются как закрытые. Если пользователь объекта желает изменить его состояние, тогда он должен делать это косвенно, используя открытые члены. Чтобы проиллюстрировать необходимость в службах инкапсуляции, предположим, что создано такое определение класса:

// Класс с единственным открытым полем.

class Book

{

  public int numberOfPages;

}

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

int

// Хм... Ничего себе мини-новелла!

Book miniNovel = new Book();

miniNovel.numberOfPages = 30_000_000;

Хотя границы типа данных

int

На заметку! Говоря точнее, члены класса, которые представляют состояние объекта, не должны помечаться как

public

Инкапсуляция предлагает способ предохранения целостности данных состояния для объекта. Вместо определения открытых полей (которые могут легко привести к повреждению данных) необходимо выработать у себя привычку определять закрытые данные, управление которыми осуществляется опосредованно с применением одного из двух главных приемов:

• определение пары открытых методов доступа и изменения;

• определение открытого свойства.

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

Инкапсуляция с использованием традиционных методов доступа и изменения

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

EmployeeApp

Employee.cs

Employee

using System;

namespace EmployeeApp

{

 class Employee

  {

   // Поля данных.

   private string _empName;

   private int _empId;

   private float _currPay;

   // Конструкторы.

   public Employee() {}

   public Employee(string name, int id, float pay)

   {

    _empName = name;

    _empId = id;

    _currPay = pay;

   }

  // Методы.

   public void GiveBonus(float amount) => _currPay += amount;

   public void DisplayStats()

   {

    Console.WriteLine("Name: {0}", _empName);  // имя сотрудника

    Console.WriteLine("ID: {0}", _empId);    // идентификационный

                         // номер сотрудника

    Console.WriteLine("Pay: {0}", _currPay);  // текущая выплата

   }

  }

}

Обратите внимание, что поля класса

Employee

private

empName

empID

currPay

Employee emp = new Employee();

// Ошибка! Невозможно напрямую обращаться к закрытым полям объекта!

emp._empName = "Marv";

Если нужно, чтобы внешний мир взаимодействовал с полным именем сотрудника, то традиционный подход предусматривает определение методов доступа (метод

get

set

get

set

В целях иллюстрации давайте инкапсулируем поле

empName

Employee

SetName()

empName

На заметку! В случае класса производственного уровня проверку длины строки с именем сотрудника следовало бы предусмотреть также и внутри логики конструктора. Мы пока проигнорируем указанную деталь, но улучшим код позже, во время исследования синтаксиса свойств.

class Employee

{

  // Поля данных.

  private string _empName;

  ...

  // Метод доступа (метод get).

  public string GetName() => _empName;

  // Метод изменения (метод set).

  public void SetName(string name)

  {

   // Перед присваиванием проверить входное значение.

   if (name.Length > 15)

   {

    Console.WriteLine("Error! Name length exceeds 15 characters!");

            // Ошибка! Длина имени превышает 15 символов!

   }

   else

   {

    _empName = name;

   }

  }

}

Такой подход требует наличия двух уникально именованных методов для управления единственным элементом данных. Чтобы протестировать новые методы, модифицируйте свой код следующим образом:

Console.WriteLine("***** Fun with Encapsulation *****\n");

Employee emp = new Employee("Marvin", 456, 30_000);

emp.GiveBonus(1000);

emp.DisplayStats();

// Использовать методы get/set для взаимодействия

// с именем сотрудника, представленного объектом.

emp.SetName("Marv");

Console.WriteLine("Employee is named: {0}", emp.GetName());

Console.ReadLine();

Благодаря коду в методе

SetName()

Console.WriteLine("***** Fun with Encapsulation *****\n");

...

// Длиннее 15 символов! На консоль выводится сообщение об ошибке.

Employee emp2 = new Employee();

emp2.SetName("Xena the warrior princess");

Console.ReadLine();

Пока все идет хорошо. Мы инкапсулировали закрытое поле

empName

GetName()

SetName()

Employee

GetID()

SetID()

GetCurrentPay()

SetCurrentPay()

Инкапсуляция с использованием свойств

get

set

get

set

Employee

get

set

class Employee

{

  // Поля данных.

  private string _empName;

  private int _empId;

  private float _currPay;

  // Свойства!

  public string Name

  {

   get { return _empName; }

   set

   {

    if (value.Length > 15)

    {

     Console.WriteLine("Error! Name length exceeds 15 characters!");

             // Ошибка! Длина имени превышает 15 символов!

    }

    else

    {

     _empName = value;

    }

   }

  }

  // Можно было бы добавить дополнительные бизнес-правила для установки

  // данных свойств, но в настоящем примере в этом нет необходимости.

  public int Id

  {

   get { return _empId; }

   set { _empId = value; }

  }

  public float Pay

  {

   get { return _currPay; }

   set { _currPay = value; }

  }

...

}

get

set

Id

// int представляет тип данных, инкапсулируемых этим свойством.

public int Id // Обратите внимание на отсутствие круглых скобок.

{

  get { return _empId; }

  set { _empID = value; }

}

set

value

value

value

set

Name

public string Name

{

  get { return _empName; }

  set

  {

   // Здесь value на самом деле имеет тип string.

   if (value.Length > 15)

   {  Console.WriteLine("Error! Name length exceeds 15 characters!");

             // Ошибка! Длина имени превышает 15 символов!

   }

   else

   {

    empName = value;

   }

  }

}

get

set

Console.WriteLine("***** Fun with Encapsulation *****\n");

Employee emp = new Employee("Marvin", 456, 30000);

emp.GiveBonus(1000);

emp.DisplayStats();

// Переустановка и аатем получение свойства Name.

emp.Name = "Marv";

Console.WriteLine("Employee is named: {0}", emp.Name); // имя сотрудника

Console.ReadLine();

Employee

class Employee

{

  ...

  // Новое поле и свойство.

  private int _empAge;

  public int Age

  {

   get { return _empAge; }

   set { _empAge = value; }

  }

  // Обновленные конструкторы.

  public Employee() {}

  public Employee(string name, int id, float pay)

  :this(name, 0, id, pay){}

  public Employee(string name, int age, int id, float pay)

  {

   _empName = name;

   _empId = id;

   _empAge = age;

   _currPay = pay;

  }

  // Обновленный метод DisplayStats() теперь учитывает возраст.

  public void DisplayStats()

  {

   Console.WriteLine("Name: {0}", _empName); // имя сотрудника

   Console.WriteLine("ID: {0}", _empId);

           // идентификационный номер сотрудника

   Console.WriteLine("Age: {0}", _empAge);  // возраст сотрудника

   Console.WriteLine("Pay: {0}", _currPay);  // текущая выплата

  }

}

Employee

joe

set

get

Employee joe = new Employee();

joe.SetAge(joe.GetAge() + 1);

empAge

Age

Employee joe = new Employee();

joe.Age++;

set

get

Age

public int Age

{

  get => empAge;

  set => empAge = value;

}

Использование свойств внутри определения класса

Свойства, в частности их порция

set

Employee

Name

ID

Рау

Age

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

public Employee(string name, int age, int id, float pay)

{

  /// Похоже на проблему. ..

  if (name.Length > 15)

  {

   Console.WriteLine("Error! Name length exceeds 15 characters!");

           // Ошибка! Длина имени превышает 15 символов!

  }

  else

  {

   _empName = name;

  }

  _empId = id;

  _empAge = age;

  _currPay = pay;

}

Наверняка вы заметили проблему, связанную с таким подходом. Свойство

Name

public Employee(string name, int age, int id, float pay)

{

  // Уже лучше! Используйте свойства для установки данных класса.

  // Это сократит количество дублированных проверок на предмет ошибок.

  Name = name;

  Age = age;

  ID = id;

  Pay = pay;

}

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

Employee

class Employee

{

 // Поля данных.

 private string _empName;

 private int _empId;

 private float _currPay;

 private int _empAge;

 // Конструкторы.

 public Employee() { }

 public Employee(string name, int id, float pay)

   :this(name, 0, id, pay){}

 public Employee(string name, int age, int id, float pay)

 {

   Name = name;

   Age = age;

   ID = id;

   Pay = pay;

 }

 // Методы.

 public void GiveBonus(float amount) => Pay += amount;

 public void DisplayStats()

 {

   Console.WriteLine("Name: {0}", Name); // имя сотрудника

   Console.WriteLine("ID: {0}", Id);

           // идентификационный номер сотрудника

   Console.WriteLine("Age: {0}", Age);  // возраст сотрудника

   Console.WriteLine("Pay: {0}", Pay);  // текущая выплата

 }

  // Свойства остаются прежними...

  ...

}

Свойства, допускающие только чтение

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

set

SocialSecurityNumber

empSSN

public string SocialSecurityNumber

{

  get { return _empSSN; }

}

Свойства, которые имеют только метод

get

public string SocialSecurityNumber => _empSSN;

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

SocialSecurityNumber

public Employee(string name, int age, int id, float pay, string ssn)

{

  Name = name;

  Age = age;

  ID = id;

  Pay = pay;

  // Если свойство предназначено только для чтения, это больше невозможно!

  SocialSecurityNumber = ssn;

}

Если только вы не готовы переделать данное свойство в поддерживающее чтение и запись (что вскоре будет сделано), тогда единственным вариантом со свойствами, допускающими только чтение, будет применение лежащей в основе переменной-члена

empSSN

public Employee(string name, int age, int id, float pay, string ssn)

{

  ...

  // Проверить надлежащим образом входной параметр ssn

  // и затем установить значение.

  empSSN = ssn;

}

Свойства, допускающие только запись

Если вы хотите сконфигурировать свойство как допускающее только запись, тогда опустите блок

get

public int Id

{

  set { _empId = value; }

}

Смешивание закрытых и открытых методов get/set в свойствах

При определении свойств уровень доступа для методов

get

set

get

set

public string SocialSecurityNumber

{

  get => _empSSN;

  private set => _empSSN = value;

}

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

Еще раз о ключевом слове static: определение статических свойств

Ранее в главе рассказывалось о роли ключевого слова

static

StaticDataAndMembers

SavingsAccount

static

// Простой класс депозитного счета.

class SavingsAccount

{

 // Данные уровня экземпляра.

 public double currBalance;

 // Статический элемент данных.

 private static double _currInterestRate = 0.04;

 // Статическое свойство.

 public static double InterestRate

 {

   get { return _currInterestRate; }

   set { _currInterestRate = value; }

 }

  ...

}

Если вы хотите использовать свойство

InterestRate

// Вывести текущую процентную ставку через свойство.

Console.WriteLine("Interest Rate is: {0}", SavingsAccount.InterestRate);

Сопоставление с образцом и шаблоны свойств (нововведение в версии 8.0)

Шаблон свойств позволяет сопоставлять со свойствами объекта. В качестве примера добавьте к проекту новый файл (

EmployeePayTypeEnum.cs

namespace EmployeeApp

{

   public enum EmployeePayTypeEnum

   {

     Hourly,    // почасовая оплата

     Salaried,   // оклад

     Commission  // комиссионное вознаграждение

   }

}

Обновите класс

Employee

private EmployeePayTypeEnum _payType;

public EmployeePayTypeEnum PayType

{

  get => _payType;

  set => _payType = value;

}

public Employee(string name, int id, float pay, string empSsn)

  : this(name,0,id,pay, empSsn, EmployeePayTypeEnum.Salaried)

{

}

public Employee(string name, int age, int id,

  float pay, string empSsn, EmployeePayTypeEnum payType)

{

  Name = name;

  Id = id;

  Age = age;

  Pay = pay;

  SocialSecurityNumber = empSsn;

  PayType = payType;

}

Теперь, когда все элементы на месте, метод

GiveBonus()

GiveBonus()

public void GiveBonus(float amount)

{

  Pay = this switch

  {

   {PayType: EmployeePayTypeEnum.Commission }

    => Pay += .10F * amount,

   {PayType: EmployeePayTypeEnum.Hourly }

    => Pay += 40F * amount/2080F,

   {PayType: EmployeePayTypeEnum.Salaried }

    => Pay += amount,

   _ => Pay+=0

  };

}

Как и с другими операторами

switch

case

switch

case

Чтобы протестировать внесенные обновления, добавьте к операторам верхнего уровня следующий код:

Employee emp = new Employee("Marvin",45,123,1000,"111-11-1111",

                EmployeePayTypeEnum.

Salaried);

Console.WriteLine(emp.Pay);

emp.GiveBonus(100);

Console.WriteLine(emp.Pay);

При создании свойств для инкапсуляции данных часто обнаруживается, что области

set

// Тип Car, использующий стандартный синтаксис свойств.

class Car

{

  private string carName = "";

  public string PetName

  {

   get { return carName; }

   set { carName = value; }

  }

}

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

Чтобы упростить процесс обеспечения простой инкапсуляции данных полей, можно использовать синтаксис автоматических свойств. Как следует из названия, это средство перекладывает работу по определению закрытых поддерживающих полей и связанных с ними свойств C# на компилятор за счет применения небольшого нововведения в синтаксисе. В целях иллюстрации создайте новый проект консольного приложения по имени

AutoProps

Car.cs

Car

using System;

namespace AutoProps

{

  class Car

  {

   // Автоматические свойства! Нет нужды определять поддерживающие поля.

   public string PetName { get; set; }

   public int Speed { get; set; }

   public string Color { get; set; }

  }

}

На заметку! Среды Visual Studio и Visual Studio Code предоставляют фрагмент кода

prop

prop

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

get/set

get/set

На заметку! Имя автоматически сгенерированного закрытого поддерживающего поля будет невидимым для вашей кодовой базы С#. Просмотреть его можно только с помощью инструмента вроде

ildasm.exe

Начиная с версии C# 6, разрешено определять "автоматическое свойство только для чтения", опуская область

set

// Свойство только для чтения? Допустимо!

public int MyReadOnlyProp { get; }

// Свойство только для записи? Ошибка!

public int MyWriteOnlyProp { set; }

Взаимодействие с автоматическими свойствами

Поскольку компилятор будет определять закрытые поддерживающие поля на этапе компиляции (и учитывая, что эти поля в коде C# непосредственно не доступны), в классе, который имеет автоматические свойства, для установки и чтения лежащих в их основе значений всегда должен применяться синтаксис свойств. Указанный факт важно отметить, т.к. многие программисты напрямую используют закрытые поля внутри определения класса, что в данном случае невозможно. Например, если бы класс

Car

DisplayStats()

class Car

{

  // Автоматические свойства!

  public string PetName { get; set; }

  public int Speed { get; set; }

  public string Color { get; set; }

  public void DisplayStats()

  {

   Console.WriteLine("Car Name: {0}", PetName);

   Console.WriteLine("Speed: {0}", Speed);

   Console.WriteLine("Color: {0}", Color);

  }

}

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

using System;

using AutoProps;

Console.WriteLine("***** Fun with Automatic Properties *****\n");

Car c = new Car();

c.PetName = "Frank";

c.Speed = 55;

c.Color = "Red";

Console.WriteLine("Your car is named {0}? That's odd...",

           c.PetName);

c.DisplayStats();

Console.ReadLine();

Автоматические свойства и стандартные значения

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

false

0

null

Добавьте к текущему проекту новый файл класса по имени

Garage

Car

namespace AutoProps

{

  class Garage

  {

   // Скрытое поддерживающее поле int установлено в О!

   public int NumberOfCars { get; set; }

   // Скрытое поддерживающее поле Car установлено в null!

   public Car MyAuto { get; set; }

  }

}

Имея стандартные значения C# для полей данных, значение

NumberOfCars

0

MyAuto

null

Car

Garage g = new Garage();

// Нормально, выводится стандартное значение 0.

Console.WriteLine("Number of Cars: {0}", g.NumberOfCars);

// Ошибка во время выполнения!

// Поддерживающее поле в данный момент равно null!

Console.WriteLine(g.MyAuto.PetName);

Console.ReadLine();

Чтобы решить проблему, можно модифицировать конструкторы класса, обеспечив безопасное создание объекта. Ниже показан пример:

class Garage

{

  // Скрытое поддерживающее поле установлено в 0!

  public int NumberOfCars { get; set; }

  // Скрытое поддерживающее поле установлено в null!

  public Car MyAuto { get; set; }

  // Для переопределения стандартных значений, присвоенных скрытым

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

  public Garage()

  {

   MyAuto = new Car();

   NumberOfCars = 1;

  }

  public Garage(Car car, int number)

  {

   MyAuto = car;

   NumberOfCars = number;

  }

}

После такого изменения объект

Car

Garage

Console.WriteLine("***** Fun with Automatic Properties *****\n");

// Создать объект автомобиля.

Car c = new Car();

c.PetName = "Frank";

c.Speed = 55;

c.Color = "Red";

c.DisplayStats();

// Поместить автомобиль в гараж.

Garage g = new Garage();

g.MyAuto = c;

// Вывести количество автомобилей в гараже

Console.WriteLine("Number of Cars in garage: {0}", g.NumberOfCars);

// Вывести название автомобиля.

Console.WriteLine("Your car is named: {0}", g.MyAuto.PetName);

Console.ReadLine();

Инициализация автоматических свойств

Наряду с тем, что предыдущий подход работает вполне нормально, в версии C# 6 появилась языковая возможность, которая содействует упрощению способа присваивания автоматическим свойствам их начальных значений. Как упоминалось ранее в главе, полю данных в классе можно напрямую присваивать начальное значение при его объявлении. Например:

class Car

{

  private int numberOfDoors = 2;

}

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

Ниже приведена модифицированная версия класса

Garage

MyAuto

Car

class Garage

{

   // Скрытое поддерживающее поле установлено в 1.

   public int NumberOfCars { get; set; } = 1;

   // Скрытое поддерживающее поле установлено в новый объект Car.

   public Car MyAuto { get; set; } = new Car();

   public Garage(){}

   public Garage(Car car, int number)

   {

     MyAuto = car;

     NumberOfCars = number;

   }

}

Наверняка вы согласитесь с тем, что автоматические свойства — очень полезное средство языка программирования С#, т.к. отдельные свойства в классе можно определять с применением модернизированного синтаксиса. Конечно, если вы создаете свойство, которое помимо получения и установки закрытого поддерживающего поля требует дополнительного кода (такого как логика проверки достоверности, регистрация в журнале событий, взаимодействие с базой данных и т.д.), то его придется определять как "нормальное" свойство .NET Core вручную. Автоматические свойства C# не делают ничего кроме обеспечения простой инкапсуляции для лежащей в основе порции (сгенерированных компилятором) закрытых данных.

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

Обзор синтаксиса инициализации объектов

Для упрощения процесса создания и подготовки объекта в C# предлагается синтаксис инициализации объектов. Такой прием делает возможным создание новой объектной переменной и присваивание значений многочисленным свойствам и/или открытым полям в нескольких строках кода. Синтаксически инициализатор объекта выглядит как список разделенных запятыми значений, помещенный в фигурные скобки (

{}

Чтобы увидеть данный синтаксис в действии, создайте новый проект консольного приложения по имени

ObjectInitializers

Point

class Point

{

  public int X { get; set; }

  public int Y { get; set; }

  public Point(int xVal, int yVal)

  {

   X = xVal;

   Y = yVal;

  }

  public Point() { }

  public void DisplayStats()

  {

   Console.WriteLine("[{0}, {1}]", X, Y);

  }

}

А теперь посмотрим, как создавать объекты

Point

Console.WriteLine("***** Fun with Object Init Syntax *****\n");

// Создать объект Point, устанавливая каждое свойство вручную.

Point firstPoint = new Point();

firstPoint.X = 10;

firstPoint.Y = 10;

firstPoint.DisplayStats();

// Или создать объект Point посредством специального конструктора.

Point anotherPoint = new Point(20, 20);

anotherPoint.DisplayStats();

// Или создать объект Point, используя синтаксис инициализации объектов.

Point finalPoint = new Point { X = 30, Y = 30 };

finalPoint.DisplayStats();

Console.ReadLine();

При создании последней переменной

Point

X

Y

На заметку! Важно помнить о том, что процесс инициализации объектов неявно использует методы установки свойств. Если метод установки какого-то свойства помечен как

private

Использование средства доступа только для инициализации (нововведение в версии 9.0)

В версии C# 9.0 появилось новое средство доступа только для инициализации. Оно позволяет устанавливать свойство во время инициализации, но после завершения конструирования объекта свойство становится доступным только для чтения. Свойства такого типа называются неизменяемыми. Добавьте к проекту новый файл класса по имени

ReadOnlyPointAfterCreation.cs

using System;

namespace ObjectInitializers

{

  class PointReadOnlyAfterCreation

  {

   public int X { get; init; }

   public int Y { get; init; }

   public void DisplayStats()

   {

    Console.WriteLine("InitOnlySetter: [{0}, {1}]", X, Y);

   }

   public PointReadOnlyAfterCreation(int xVal, int yVal)

   {

    X = xVal;

    Y = yVal;

   }

   public PointReadOnlyAfterCreation() { }

  }

}

Новый класс тестируется с применением приведенного ниже кода:

// Создать объект точки, допускающий только чтение

// после конструирования

PointReadOnlyAfterCreation firstReadonlyPoint =

  new PointReadOnlyAfterCreation(20, 20);

firstReadonlyPoint.DisplayStats();

// Или создать объект точки с использованием синтаксиса только

// для инициализации.

PointReadOnlyAfterCreation secondReadonlyPoint =

 new PointReadOnlyAfterCreation { X = 30, Y 

= 30 };

secondReadonlyPoint.DisplayStats();

Обратите внимание, что в коде для класса

Point

X

Y

// Следующие две строки не скомпилируются

secondReadonlyPoint.X = 10;

secondReadonlyPoint.Y = 10;

Вызов специальных конструкторов с помощью синтаксиса инициализации

В предшествующих примерах объекты типа

Point

// Здесь стандартный конструктор вызывается неявно.

Point finalPoint = new Point { X = 30, Y = 30 };

При желании стандартный конструктор допускается вызывать и явно:

// Здесь стандартный конструктор вызывается явно.

Point finalPoint = new Point() { X = 30, Y = 30 };

Имейте в виду, что при конструировании объекта типа с использованием синтаксиса инициализации можно вызывать любой конструктор, определенный в классе. В настоящий момент в типе

Point

Point

X

100

Y

100

10

16

// Вызов специального конструктора.

Point pt = new Point(10, 16) { X = 100, Y = 100 };

Имея текущее определение типа

Point

Point

PointColor

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

PointColorEnum.cs

namespace ObjectInitializers

{

  enum PointColorEnum

  {

   LightBlue,

   BloodRed,

   Gold

  }

}

Обновите код класса

Point

class Point

{

  public int X { get; set; }

  public int Y { get; set; }

  public PointColorEnum Color{ get; set; }

  public Point(int xVal, int yVal)

  {

   X = xVal;

   Y = yVal;

   Color = PointColorEnum.Gold;

  }

  public Point(PointColorEnum ptColor)

  {

   Color = ptColor;

  }

  public Point() : this(PointColorEnum.BloodRed){ }

  public void DisplayStats()

  {

   Console.WriteLine("[{0}, {1}]", X, Y);

   Console.WriteLine("Point is {0}", Color);

  }

}

Посредством нового конструктора теперь можно создавать точку золотистого цвета (в позиции (90, 20)):

// Вызов более интересного специального конструктора

// с помощью синтаксиса инициализации.

Point goldPoint = new Point(PointColorEnum.Gold){ X = 90, Y = 20 };

goldPoint.DisplayStats();

Инициализация данных с помощью синтаксиса инициализации

Как кратко упоминалось ранее в главе (и будет подробно обсуждаться в главе 6), отношение "имеет" позволяет формировать новые классы, определяя переменные-члены существующих классов. Например, пусть определен класс

Rectangle

Point

null

using System;

namespace ObjectInitializers

{

  class Rectangle

  {

   private Point topLeft = new Point();

   private Point bottomRight = new Point();

   public Point TopLeft

   {

    get { return topLeft; }

    set { topLeft = value; }

   }

   public Point BottomRight

   {

    get { return bottomRight; }

    set { bottomRight = value; }

   }

   public void DisplayStats()

   {

    Console.WriteLine("[TopLeft: {0}, {1}, {2} BottomRight: {3},

                   {4}, {5}]",

      topLeft.X, topLeft.Y, topLeft.Color,

      bottomRight.X, bottomRight.Y, bottomRight.Color);

   }

  }

}

С помощью синтаксиса инициализации объектов можно было бы создать новую переменную

Rectangle

Point

// Создать и инициализировать объект Rectangle.

Rectangle myRect = new Rectangle

{

  TopLeft = new Point { X = 10, Y = 10 },

  BottomRight = new Point { X = 200, Y = 200}

};

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

Rectangle

// Традиционный подход.

Rectangle r = new Rectangle();

Point p1 = new Point();

p1.X = 10;

p1.Y = 10;

r.TopLeft = p1;

Point p2 = new Point();

p2.X = 200;

p2.Y = 200;

r.BottomRight = p2;

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

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

Понятие константных полей данных

Язык C# предлагает ключевое слово

const

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

MyMathClass

π

3.14

ConstData

MyMathClass.cs

π

//MyMathClass.cs

using System;

namespace ConstData

{

  class MyMathClass

  {

   public const double PI = 3.14;

  }

}

Приведите код в файле

Program.cs

using System;

using ConstData;

Console.WriteLine("***** Fun with Const *****\n");

Console.WriteLine("The value of PI is: {0}", MyMathClass.PI);

// Ошибка! Константу изменять нельзя!

// MyMathClass.PI = 3.1444;

Console.ReadLine();

Обратите внимание, что ссылка на константные данные, определенные в классе

MyMathClass

MyMathClass.PI

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; }

}

В версии C# 9.0 появился особый вид классов — записи. Записи являются ссылочными типами, которые предоставляют синтезированные методы с целью обеспечения семантики значений для эквивалентности. По умолчанию типы записей неизменяемы. Хотя по существу дела вы могли бы создать неизменяемый класс, но с применением комбинации средств доступа только для инициализации и свойств, допускающих только чтение, типы записей позволяют избавиться от такой дополнительной работы.

Чтобы приступить к экспериментам с записями, создайте новый проект консольного приложения по имени

FunWithRecords

Car

class Car

{

  public string Make { get; set; }

  public string Model { get; set; }

  public string Color { get; set; }

  public Car() {}

  public Car(string make, string model, string color)

   {

   Make = make;

   Model = model;

   Color = color;

  }

}

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

public string Make { get; init; }

public string Model { get; init; }

public string Color { get; init; }

Для использования нового класса

Car

Program.cs

using System;

using FunWithRecords;

Console.WriteLine("Fun with Records!");

// Использовать инициализацию объекта

Car myCar = new Car

{

   Make = "Honda",

   Model = "Pilot",

   Color = "Blue"

};

Console.WriteLine("My car: ");

DisplayCarStats(myCar);

Console.WriteLine();

// Использовать специальный конструктор

Car anotherMyCar = new Car("Honda", "Pilot", "Blue");

Console.WriteLine("Another variable for my car: ");

DisplayCarStats(anotherMyCar);

Console.WriteLine();

// Попытка изменения свойства приводит к ошибке на этапе компиляции.

// myCar.Color = "Red";

Console.ReadLine();

static void DisplayCarStats(Car c)

{

  Console.WriteLine("Car Make: {0}", c.Make);

  Console.WriteLine("Car Model: {0}", c.Model);

  Console.WriteLine("Car Color: {0}", c.Color);

}

Вполне ожидаемо оба метода создания объекта работают, значения свойств отображаются, а попытка изменить свойство после конструирования приводит к ошибке на этапе компиляции.

Чтобы создать тип записи

CarRecord

CarRecord.cs

record CarRecord

{

  public string Make { get; init; }

  public string Model { get; init; }

  public string Color { get; init; }

  public CarRecord () {}

  public CarRecord (string make, string model, string color)

  {

   Make = make;

   Model = model;

   Color = color;

  }

}

Запустив приведенный далее код из

Program.cs

CarRecord

Car

Console.WriteLine("/*************** RECORDS *********************/");

// Использовать инициализацию объекта

CarRecord myCarRecord = new CarRecord

{

   Make = "Honda",

   Model = "Pilot",

   Color = "Blue"

};

Console.WriteLine("My car: ");

DisplayCarRecordStats(myCarRecord);

Console.WriteLine();

// Использовать специальный конструктор

CarRecord anotherMyCarRecord = new CarRecord("Honda", "Pilot", "Blue");

Console.WriteLine("Another variable for my car: ");

Console.WriteLine(anotherMyCarRecord.ToString());

Console.WriteLine();

// Попытка изменения свойства приводит к ошибке на этапе компиляции.

// myCarRecord . Color = "Red";

Console.ReadLine();

Хотя мы пока еще не обсуждали эквивалентность (см. следующий раздел) или наследование (см. следующую главу) с типами записей, первое знакомство с записями не создает впечатления, что они обеспечивают большое преимущество. Текущий пример записи

CarRecord

ToString()

/*************** RECORDS *********************/

My car:

CarRecord { Make = Honda, Model = Pilot, Color = Blue }

Another variable for my car:

CarRecord { Make = Honda, Model = Pilot, Color = Blue }

Но взгляните на следующее обновленное определение записи

Car

record CarRecord(string Make, string Model, string Color);

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

Эквивалентность с типами записей

В примере класса

Car

Car

Console.WriteLine($"Cars are the same? {myCar.Equals(anotherMyCar)}");

         // Эквивалентны ли экземпляры Car?

Однако они не эквивалентны. Вспомните, что типы записей представляют собой специализированный вид класса, а классы являются ссылочными типами. Чтобы два ссылочных типа были эквивалентными, они должны указывать на тот же самый объект в памяти. В качестве дальнейшей проверки выясним, указывают ли два экземпляра

Car

Console.WriteLine($"Cars are the same reference?

 {ReferenceEquals(myCar, anotherMyCar)}");

         // Указывают ли экземпляры Car на тот же самый объект?

Запуск программы дает приведенный ниже результат:

Cars are the same? False

CarRecords are the same? False

Типы записей ведут себя по-другому. Они неявно переопределяют

Equals()

==

!=

Console.WriteLine($"CarRecords are the same?

  {myCarRecord.Equals(anotherMyCarRecord)}");

         // Эквивалентны ли экземпляры CarRecord?

Console.WriteLine($"CarRecords are the same reference?

 {ReferenceEquals(myCarRecord,another

MyCarRecord)}");

         // Указывают ли экземпляры CarRecord на тот же самый объект?

Console.WriteLine($"CarRecords are the same?

 {myCarRecord == anotherMyCarRecord}");

Console.WriteLine($"CarRecords are not the same?

 {myCarRecord != anotherMyCarRecord}");

Вот результирующий вывод:

/*************** RECORDS *********************/

My car:

CarRecord { Make = Honda, Model = Pilot, Color = Blue }

Another variable for my car:

CarRecord { Make = Honda, Model = Pilot, Color = Blue }

CarRecords are the same? True

CarRecords are the same reference? false

CarRecords are the same? True

CarRecords are not the same? False

Обратите внимание, что записи считаются эквивалентными, невзирая на то, что переменные указывают на два разных объекта в памяти.

Копирование типов записей с использованием выражений with

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

CarRecord carRecordCopy = anotherMyCarRecord;

Console.WriteLine("Car Record copy results");

Console.WriteLine($"CarRecords are the same?

 {carRecordCopy.Equals(anotherMyCarRecord)}");

Console.WriteLine($"CarRecords are the same?

 {ReferenceEquals(carRecordCopy, 

anotherMyCarRecord)}");

В результате запуска кода обе проверки возвращают

True

Для создания подлинной копии записи с модифицированным одним или большим числом свойств в версии C# 9.0 были введены выражения

with

with

CarRecord ourOtherCar = myCarRecord with {Model = "Odyssey"};

Console.WriteLine("My copied car:");

Console.WriteLine(ourOtherCar.ToString());

Console.WriteLine("Car Record copy using with expression results");

         // Результаты копирования CarRecord

         // с использованием выражения with

Console.WriteLine($"CarRecords are the same?

 {ourOtherCar.Equals(myCarRecord)}");

Console.WriteLine($"CarRecords are the same?

 {ReferenceEquals(ourOtherCar, myCarRecord)}");

В коде создается новый экземпляр типа

CarRecord

Make

Color

myCarRecord

Model

"Odyssey"

/*************** RECORDS *********************/

My copied car:

CarRecord { Make = Honda, Model = Odyssey, Color = Blue }

Car Record copy using with expression results

CarRecords are the same? False

CarRecords are the same? False

С применением выражений

with

Вспомните из главы 5, что наследование — это аспект ООП, упрощающий повторное использование кода. Говоря более точно, встречаются две разновидности повторного использования кода: наследование (отношение "является") и модель включения/делегации (отношение "имеет"). Давайте начнем текущую главу с рассмотрения классической модели наследования, т.е. отношения "является".

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

BasicInheritance

Предположим, что вы спроектировали класс

Car

namespace BasicInheritance

{

  // Простой базовый класс.

  class Car

  {

   public readonly int MaxSpeed;

   private int _currSpeed;

   public Car(int max)

   {

    MaxSpeed = max;

   }

  public Car()

   {

    MaxSpeed = 55;

   }

   public int Speed

   {

    get { return _currSpeed; }

    set

    {

     _currSpeed = value;

     if (_currSpeed > MaxSpeed)

     {

      _currSpeed = MaxSpeed;

     }

    }

   }

  }

}

Обратите внимание, что класс

Car

_currSpead

Speed

Car

using System;

using BasicInheritance;

Console.WriteLine("***** Basic Inheritance *****\n");

// Создать объект Car и установить максимальную и текущую скорости.

Car myCar = new Car(80) {Speed = 50};

// Вывести значение текущей скорости.

Console.WriteLine("My car is going {0} MPH", myCar.Speed);

Console.ReadLine();

Указание родительского класса для существующего класса

Теперь предположим, что планируется построить новый класс по имени

MiniVan

Car

MiniVan

Speed

Car

MiniVan

MiniVan

Car

Существующий класс, который будет служить основой для нового класса, называется базовым классом, суперклассом или родительским классом. Роль базового класса заключается в определении всех общих данных и членов для классов, которые его расширяют. Расширяющие классы формально называются производными или дочерними классами. В языке C# для установления между классами отношения "является" применяется операция двоеточия в определении класса. Пусть вы написали новый класс

MiniVan

namespace BasicInheritance

{

  // MiniVan "является" Car.

  sealed class MiniVan : Car

  {

  }

}

В текущий момент никаких членов в новом классе не определено. Так чего же мы достигли за счет наследования

MiniVan

Car

MiniVan

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

Учитывая отношение между этими двумя типами классов, вот как можно работать с классом

MiniVan

Console.WriteLine("***** Basic Inheritance *****\n");

...

// Создать объект MiniVan.

MiniVan myVan = new MiniVan {Speed = 10};

Console.WriteLine("My van is going {0} MPH", myVan.Speed);

Console.ReadLine();

Обратите внимание, что хотя в класс

MiniVan

Speed

MiniVan

Car

Speed

Всегда помните о том, что наследование предохраняет инкапсуляцию, а потому следующий код вызовет ошибку на этапе компиляции, т.к. закрытые члены не могут быть доступны через объектную ссылку:

Console.WriteLine("***** Basic Inheritance *****\n");

...

// Создать объект MiniVan.

MiniVan myVan = new MiniVan();

myVan.Speed = 10;

Console.WriteLine("My van is going {0} MPH",

           myVan.Speed);

// Ошибка! Доступ к закрытым членам невозможен!

myVan._currSpeed = 55;

Console.ReadLine();

В качестве связанного примечания: даже когда класс

MiniVan

Car

MiniVan

// Класс MiniVan является производным от Car.

class MiniVan : Car

{

  public void TestMethod()

  {

   // Нормально! Доступ к открытым членам родительского

   // типа в производном типе возможен.

   Speed = 10;

   // Ошибка! Нельзя обращаться к закрытым членам

   // родительского типа из производного типа!

   _currSpeed = 10;

  }

}

Замечание относительно множества базовых классов

Говоря о базовых классах, важно иметь в виду, что язык C# требует, чтобы отдельно взятый класс имел в точности один непосредственный базовый класс. Создать тип класса, который был бы производным напрямую от двух и более базовых классов, невозможно (такой прием, поддерживаемый в неуправляемом языке C++, известен как множественное наследование). Попытка создать класс, для которого указаны два непосредственных родительских класса, как продемонстрировано в следующем коде, приведет к ошибке на этапе компиляции:

// Недопустимо! Множественное наследование

// классов в языке C# не разрешено!

class WontWork

  : BaseClassOne, BaseClassTwo

{}

В главе 8 вы увидите, что платформа .NET Core позволяет классу или структуре реализовывать любое количество дискретных интерфейсов. Таким способом тип C# может поддерживать несколько линий поведения, одновременно избегая сложностей, которые связаны с множественным наследованием. Применяя этот подход, можно строить развитые иерархии интерфейсов, которые моделируют сложные линии поведения (см. главу 8).

Использование ключевого слова sealed

Язык C# предлагает еще одно ключевое слово,

sealed

sealed

MiniVan

// Класс Minivan не может быть расширен!

sealed class MiniVan : Car

{

}

Если вы или ваш коллега попытаетесь унаследовать от запечатанного класса

MiniVan

// Ошибка! Нельзя расширять класс, помеченный ключевым словом sealed!

class DeluxeMiniVan

  : MiniVan

{

}

Запечатывание класса чаще всего имеет наибольший смысл при проектировании обслуживающего класса. Скажем, в пространстве имен

System

String

MiniVan

System.String

// Еще одна ошибка! Нельзя расширять класс, помеченный как sealed!

class MyString

  : String

{

}

На заметку! В главе 4 вы узнали о том, что структуры C# всегда неявно запечатаны (см. табл. 4.3). Следовательно, создать структуру, производную от другой структуры, класс, производный от структуры, или структуру, производную от класса, невозможно. Структуры могут применяться для моделирования только отдельных, атомарных, определяемых пользователем типов. Если вы хотите задействовать отношение "является", тогда должны использовать классы.

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

sealed