Какое из свойств связано с соединением полей методов и свойств в одном объекте

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

ля используются для обеспечения выполнения операций внутри класса.

При объявлении имен полей принято к названию добавлять заглавную букву F.Например FSomeField.

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

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

Свойства представляют собой атрибуты, которые составляют индивидуальность объекта и помогают описать его. Например, обычная кнопка в окне приложения обладает такими свойствами, как цвет, размеры, положение. Для экземпляра класса “кнопка” значения этих атрибутов задаются при по-

мощи свойств — специальных переменных, определяемых ключевым словом property. Цвет может задаваться свойством color, размеры — свойствами Width И Height и т.д.

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

type

TAnObject = class(TObject)

function GetColor: TSomeType;

procedure SetColor(ANewValue: TSomeType);

property AColor: TSomeType read GetColor write SetColor;

end;

В данном примере доступ к значению свойства AColor осуществляется через вызовы методов GetColor и SetColor. Однако в обращении к этим методам в явном виде нет необходимости: достаточно написать:

AnObject.AColor := AValue;

AVariable := AnObject.AColor;

и компилятор самостоятельно оттранслирует обращение к свойству AColor в вызовы методов Getcoior или Setcoior. To есть внешне свойство выглядит в точности как обычное поле, но за всяким обращением к нему могут стоять нужные вам действия. Например, если у вас есть объект, представляющий собой квадрат на экране, и его свойству “цвет” вы присваиваете значение “белый”, то произойдет немедленная перерисовка, приводящая реальный цвет на экране в соответствие со значением свойства. Выполнение этой операции осуществляется методом, который связан с установкой значения свойства “цвет”.В методах, входящих в состав свойств, может осуществляться проверка устанавливаемой величины на попадание в допустимый диапазон значений и вызов других процедур, зависящих от вносимых изменений. Если же потребности в специальных процедурах чтения и/или записи нет, можно вместо имен методов применять имена полей. Рассмотрим следующую конст-

рукцию:

TPropObject = class(TObject)

FValue: TSomeType;

procedure DoSomething;

function Correct(AValue: Integer):boolean;

procedure SetValue(NewValue: Integer);

property AValue: Integer read FValue write SetValue;

end;

procedure TPropObject.SetValue(NewValue: Integer);

begin

if (NewValueOFValue) and Correct (NewValue) then FValue := NewValue;

DoSomething;

end;

В этом примере чтение значения свойства AValue означает просто чтение поля F/aiue. Зато при присвоении значения внутри SetValue вызывается сразу два метода.Если свойство должно только читаться или записываться, в его описании может присутствовать соответствующий метод:

type

TAnObject = class(TObject)

property AProperty: TSomeType read GetValue;

end;

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

Для присвоения свойству значения по умолчанию используется ключевое СЛОВО default:

property Visible: boolean read FVisible write SetVisible default True;

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

Свойство может быть и векторным; в этом случае оно внешне выглядит как массив:

property APoints[Index : Integer]:TPoint read GetPoint write SetPoint;

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

function GetPoint(Index:Integer):TPoint;

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

procedure SetPoint(Index:Integer; NewPoint:TPoint);

У векторных свойств есть еще одна важная особенность. Некоторые классы в Delphi (списки TList, наборы строк TStrings) “построены” вокруг основного векторного свойства (см. гл. 7). Основной метод такого класса дает доступ к некоторому массиву, а все остальные методы являются как бы вспомогательными. Специально для облегчения работы в этом случае векторное свойство может быть описано с ключевым словом default:

type

TMyObject = class;

property Strings[Index: Integer]: string read Get write Put; default;

end;

Если у объекта есть такое свойство, то можно его не упоминать, а ставить индекс в квадратных скобках сразу после имени объекта:

var AMyObject: TMyObject;

begin

AMyObject.Strings[1] := ‘ F i r s t 1 ; {первый способ}

AMyObj ect[2] := ‘Second’; {второй способ}

end.

Будьте внимательны, применяя зарезервированное слово default, — как мы увидели, для обычных и векторных свойств оноупотребляется в разных случаях и с различным синтаксисом.О роли свойств в Delphi красноречиво говорит следующий факт: у всех имеющихся в распоряжении программиста стандартных классов 100% полей недоступны и заменены базирующимися на них свойствами. Рекомендуем при разработке собственных классов придерживаться этого же правила. Внимательный читатель обратил внимание, что при объяснении терминов “поле” и “свойство” мы использовали понятие метода, и наверняка понял его общий смысл. Итак, методом называется объявленная в классе функция или процедура, которая используется для работы с полями и свойствами класса. Согласно принципам ООП (см. разд. “Инкапсуляция” далее в этой главе), обращаться к свойствам класса можно только через его методы. От обычных процедур и функций методы отличаются тем, что им при вызове

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

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

Введение

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

class Building
{
public double width;
public double length;
public double height;

//Конструктор
public Building(double width, double length, double height = 3)
{
this.width = width;
this.length = length;
this.height = height;
}

public Building(): this(20, 20, 3)
{

}

//метод
public double GetVolume()
{
return width * length * height;
}
}

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

Модификаторы доступа

Всего в C# существует четыре ключевых слова для указания уровня доступа к классам и членам класса: public, private, protected и internal. Из этих ключевых слов определяются шесть уровней доступа:

1. public — доступ к типу или члену класса возможен из любого другого кода в том числе из извне.
2. private — доступ к типу или члену возможен только из кода в том же объекте class или struct.
3. protected — доступ к типу или члену возможен только из кода в том же объекте class либо в class, производном от этого class.
4. internal — доступ к типу или члену возможен из любого кода в той же сборке, но не из другой сборки.
5. protected internal — доступ к типу или члену возможен из любого кода в той сборке, где он был объявлен, или из производного class в другой сборке.
6. private protected — доступ к типу или члену возможен только из его объявляющей сборки из кода в том же class либо в типе, производном от этого class. Этот уровень доступа можно использовать, начиная с версии C# 7.2.

Модификаторы доступа можно указывать явно, например, как в нашем классе:

public double width;
public double length;
public double height;

а можем не указывать, тогда к члену класса по умолчанию будет применен модификатор private. Классы (class) и структуры (struct), которые объявляются без модификатора, по умолчанию имеют доступ internal. Также,  все классы и структуры, определенные в пространствах имен и не являющиеся вложенными в другие классы, могут иметь только два модификатора доступа — public или internal. Примеры использования различных модификаторов доступа рассмотрим на примере нашего класса, но, прежде, чем мы это сделаем, стоит разобраться с тем, что такое свойство.

Свойства

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

Почему не стоит давать прямой доступ к полям класса? Это можно, опять же продемонстрировать на таком простом примере как наш Building: сейчас мы открыли доступ к полям width, length и height извне. При этом, все три поля имеют тип double. Таким образом, зная,что из себя представляет этот тип данных, мы можем без проблем сделать вот так:

Building building = new Building();
building.height = -100.5;

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

В общем случае, свойство определяется в классе следующим образом:

[модификатор_доступа] тип имя_свойства
{
get {возвращаемое_значение;}
set {устанавливаемое_значение;}
}

Здесь модификатор_доступа — это один из шести модификаторов доступа, рассмотренных выше. В большинстве ситуаций используется модификатор public. Далее идёт  тип_данных и имя свойства.  В фигурных скобках содержатся блоки get — для чтения поля,которому соответствует свойство и set — для записи поля.  Например, создадим свойство, с помощью которого мы будем определять высоту здания (представлена только часть кода, демонстрирующая объявление свойства):

class Building
{
double height;

public double Height
{
get { return height; }
set
{
if (value < 0)
throw new Exception(“Высота здания не может быть менее 0 метров”);
else
height = value;
}
}
}

На что здесь стоит обратить внимание:

1. поле height у нас теперь без модификатора доступа (по умолчанию оно стало private)
2. объявлено публичное свойство Height, причем в блоке set (запись поля) реализована дополнительная логика — проверка того, что задается положительное значение высоты здания.

Теперь, если попробовать запустить приложение и выполнить вот такое присваивание:

Building building = new Building();
building.Height = -100.5;

то программа выдаст ошибку:

Так же, мы можем объявлять свойства доступные только для чтения (у таких свойств будет отсутствовать блок set) и только для записи (у таких свойств отсутствует блок get). Второй вариант свойств (только для записи) встречается крайне редко, а вот свойства только для чтения — довольно часто. Например, мы можем создать свойство «Объем» следующим образом:

class Building
{
//метод
private double GetVolume()
{
return width * length * height;
}

//Свойства
public double Volume { get { return GetVolume(); } }
}

здесь мы объявили свойство Volume доступное только для чтения. При этом, методу GetVolume() мы установили модификатор private, а свойству — public.

Теперь, познакомившись с тем, что такое свойства в C# перепишем допишем наш класс и создадим необходимые свойства для задания параметров:

class Building
{
private double width;
private double length;
private double height;

public Building()
{
width = 10;
length = 10;
height = 2;
}

//метод
private double GetVolume()
{
return width * length * height;
}

//Свойства
public double Height
{
get { return height; }
set
{
if (value < 0)
throw new Exception(“Высота здания не может быть менее 0 метров”);
else
height = value;
}
}

public double Width
{
get { return width; }
set
{
if (value < 0)
throw new Exception(“Ширина здания не может быть менее 0 метров”);
else
width = value;
}
}

public double Length
{
get { return length; }
set
{
if (value < 0)
throw new Exception(“Длина здания не может быть менее 0 метров”);
else
length = value;
}
}

public double Volume { get { return GetVolume(); } }
}

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

Сокращенная форма записи свойств в C#

Если в блоках get и set свойства не реализуется никакая дополнительная логика, то допускается сокращенная записи свойства. Например, добавим в наш объект свойство Name (название здания) и применим сокращенную форму записи:

class Building
{
public string Name { get; set; }
}

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

Выражения для свойств в C#

Если реализация свойства представляет собой одиночное выражение, в качестве метода получения или задания можно использовать выражения для свойств. Например, у нас в классе у свойств Width, Length, Height и Volume в блоке get используется одиночное выражение, более, того, в логическую операцию в блоке set мы также можем «свернуть», используя тернарную операцию, поэтому мы можем упростить код нашего класса, используя выражения C#:

class Building
{
private double width;
private double length;
private double height;

public Building()
{
width = 10;
length = 10;
height = 2;
}

//метод
private double GetVolume()
{
return width * length * height;
}

//Свойства
public double Height
{
get => height;
set => height = value > 0 ? value : throw new Exception(“Высота здания не может быть менее 0 метров”);
}

public double Width
{
get => width;
set => width = value > 0 ? value : throw new Exception(“Ширина здания не может быть менее 0 метров”);
}

public double Length
{
get => length;
set => length = value > 0 ? value : throw new Exception(“Длина здания не может быть менее 0 метров”);
}

public double Volume => GetVolume();
}

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

Значение свойства по умолчанию в C#

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

class Building
{
public string Name { get; set; } = “Неизвестное здание”;
}

То есть сразу после закрывающей скобки } для свойства ставится равно и пишется значение свойства по умолчанию.

Итого

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