Понятие «Переменная», «Поле» и «Константа»

Понятие «Переменная», «Поле» и «Константа»

 

Понятие «Переменная»

 

Синтаксис объявления переменных в С# выглядит следующим образом:

 

<тип данных> <имя идентификатора>

 

Например:

 

int i;

 

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

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

Инициализация переменной

 

Задать значение переменной можно, в частности, с помощью оператора присваивания. Кроме того, задать начальное значение переменной можно при её объявлении. Для этого после имени переменной указывается знак равенства «=» и присваиваемое значение. Если две или более переменные одного и того же типа объявляются списком, разделяемым запятыми, то этим переменным можно задать, например, начальное значение. Ниже приведена общая форма инициализации переменной:

 

int i = 10; // Задаём целочисленной переменной i значение 10

char symbol = 'Z'; // Инициализируем переменную symbol буквенным значением Z

float f = 15.7F; // Переменная f инициализируется числовым значением 15.7

int x = 5, y = 10, z = 12; // Инициализируем несколько переменных одного типа

 

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

 

В С# используются два метода для обеспечения инициализации переменных перед пользованием:

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

 

Например, в С# поступить следующим образом нельзя:

 

public static int Main()

{

int d;

Console.WriteLine(d); // Так нельзя!

// Необходимо инициализировать d перед использованием

return 0;

}

 

Динамическая инициализация

 

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

 

int i1 = 3, i2 = 4;

// Инициализируем динамически переменную result

double result = Math.Sqrt(i1*i1 + i2*i2);

 

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

Неявно типизированные переменные

 

Как пояснялось выше, все переменные в С# должны быть объявлены. Как правило, при объявлении переменной сначала указывается тип, например int или bool, а затем имя переменной. Но начиная с версии С# 3.0, компилятору предоставляется возможность самому определить тип локальной переменной, исходя из значения, которым она инициализируется. Такая переменная называется неявно типизированной.

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

 

var i = 12; // Переменная i инициализируется целочисленным литералом

var d = 12.3; // Переменная d инициализируется литералом с плавающей точкой,

// имеющему тип double

var f = 0.34F; // Переменная f теперь имеет тип float

 

Единственное отличие неявно типизированной переменной от обычной, явно типизированной переменной, — в способе определения её типа. Как только этот тип будет определён, он закрепляется за переменной до конца ее существования.

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

 

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

 

using System;

using System.Collections.Generic;

using System.Linq;

using System.Text;

 

namespace LC_Console

{

class Program

{

static void Main(string[] args)

{

var name = "John A.";

var age = 24;

var isProgrammer = true;

// Определяем тип переменных

Type nameType = name.GetType();

Type ageType = age.GetType();

Type isProgrammerType = isProgrammer.GetType();

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

Console.WriteLine("Тип name: {0}", nameType);

Console.WriteLine("Тип age: {0}", ageType);

Console.WriteLine("Тип isProgrammer: {0}", isProgrammerType);

Console.WriteLine("Для продолжения нажмите любую клавишу... ");

Console.ReadKey();

}

}

}

/* Выведет:

* Тип name: System.String

* Тип age: System.Int32

* Тип isProgrammer: System.Boolean

* Для продолжения нажмите любую клавишу...

*/

 

Понятие «Поле»

 

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

Класс или структура могут иметь поля экземпляра или статические поля, либо поля обоих типов. Поля экземпляра определяются экземпляром типа. Если имеется класс T и поле экземпляра F, можно создать два объекта типа T и изменить значение поля F в каждом объекте, не изменяя значение в другом объекте. В противоположность этому, статическое поле относится к самому классу, и является общим для всех экземпляров этого класса. Изменения, выполненные из экземпляра А, будут немедленно видны экземплярам В и С, если они обращаются к полю.

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

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

Поля объявляются в блоке класса путём указания уровня доступа поля, за которым следует тип поля и имя поля. Пример:

 

public class CalendarEntry

{

// private поле

private DateTime date;

 

// public поле (не рекомендуется так делать.)

public string day;

 

// public свойство, безопасно предоставляет переменную даты

public DateTime Date

{

get

{

return date;

}

set

{

// Устанавливаем некоторые разумные границы вероятной даты рождения

if (value.Year > 1900 && value.Year <= DateTime.Today.Year)

{

date = value;

}

else

throw new ArgumentOutOfRangeException();

}

 

}

 

// public метод, также безопасно предоставляет переменную даты

// Вызов: birthday.SetDate("2012, 12, 21");

public void SetDate(string dateString)

{

DateTime dt = Convert.ToDateTime(dateString);

// Устанавливаем некоторые разумные границы вероятной даты рождения

if (dt.Year > 1900 && dt.Year <= DateTime.Today.Year)

{

date = dt;

}

else

throw new ArgumentOutOfRangeException();

}

 

public TimeSpan GetTimeSpan(string dateString)

{

DateTime dt = Convert.ToDateTime(dateString);

 

if (dt!= null && dt.Ticks < date.Ticks)

{

return date - dt;

}

else

throw new ArgumentOutOfRangeException();

 

}

}

 

Для доступа к члену объекта нужно добавить точку после имени объекта и указать имя поля: objectname.fieldname. Пример:

 

CalendarEntry birthday = new CalendarEntry();

birthday.day = "Пятница";

 

Полю можно назначить первоначальное значение, используя оператор присвоения при объявлении поля. Например, чтобы автоматически присвоить полю day значение «Понедельник», можно объявить поле day как указано в следующем примере:

 

public class CalendarDateWithInitialization

{

public string day = "Понедельник";

//...

}

 

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

Поля могут быть отмечены модификаторами public, private, protected, internal или protected internal. Эти модификаторы доступа определяют порядок доступа к полю для пользователей класса.

Также при необходимости поле может быть объявлено с модификатором static. При этом поле становится доступным для вызова в любое время, даже экземпляр класса отсутствует.

Также при необходимости поле может быть объявлено с модификатором readonly. Полю с этим модификатором (то есть полю, доступному только для чтения) значения могут быть присвоены только при инициализации или в конструкторе. Поле с модификаторами staticreadonly (статическое, доступное только для чтения) очень похоже на константу, за исключением того, что компилятор C# не имеет доступа к значению такого поля при компиляции: доступ возможен только во время выполнения.

 

Понятие «Константа»

 

Константы представляют собой неизменные значения, известные во время компиляции и неизменяемые на протяжении времени существования программы. Константы объявляются с модификатором const. Только встроенные типы C# (за исключением System.Object) могут быть объявлены как const. Определяемые пользователем типы, включая классы, структуры и массивы, не могут быть const. Для создания класса, структуры или массива, которые инициализируются один раз во время выполнения (например, в конструкторе) и после этого не могут быть изменены, используется модификатор readonly.

Язык C# не поддерживает методы, свойства и события с ключевым словом const.

Тип перечисления позволяет определять именованные константы для целочисленных встроенных типов (например, int, uint, long и т. д.).

 

Константы нужно инициализировать сразу после объявления. Пример:

 

class Calendar1

{

public const int months = 12;

}

 

В этом примере константа months всегда имеет значение 12, и её значение не может быть изменено даже самим классом. Когда компилятор встречает идентификатор константы в исходном коде C# (например, months), он подставляет литеральное значение непосредственно в его создающий код IL (Intermediate Language). Поскольку адрес переменной, связанный с константой во время выполнения, отсутствует, поля const не могут быть переданы по ссылке и отображены как значение в выражении.

 

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

 

Несколько констант одного типа можно объявить одновременно, например:

 

class Calendar2

{

const int months = 12, weeks = 52, days = 365;

}

 

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

 

class Calendar3

{

const int months = 12;

const int weeks = 52;

const int days = 365;

 

const double daysPerWeek = (double)days / (double)weeks;

const double daysPerMonth = (double)days / (double)months;

}

 

Константы могут быть отмечены модификаторами public, private, protected, internal или protected internal. Эти модификаторы доступа определяют порядок доступа к константе для пользователей класса.

 

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

 

int birthstones = Calendar.months;