Классы

свойства описываемых им объектов, методы (способы) получения информации об объектах,

изменения свойств и поведения объектов. Описание класса в языке C#:
namespace MyNameSpace // Пространство имён класса
{

class MyClass // Объявление класса
{
public static void Main()
{
/* Описание метода Main() класса MyClass */
}
}

}

Метод Main() при запуске приложения выполняется первым.

помощи ключевого слова new :
MyObject = new MyClass() ;

На базе

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

В .NET для классов, их методов и свойств доступны следующие модификаторы доступа:
– public – доступен всем;
– protected – доступен только самому объекту и его потомкам;
– private – доступен только самому объекту, но не его потомкам;
– internal – доступен в пределах текущей сборки;
– protected internal – доступен всем из текущей сборки.

Модификаторы доступа применимы к свойствам, методам и переменным класса. Однако если требуется открыть доступ к переменной класса, её лучше превратить в свойство.

классам.
Модификатор public делает класс доступным для всех объектов.
Модификатор internal делает

класс доступным только внутри определенной сборки.
Модификаторы private и protected могут использоваться только для вложенных классов.

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

Пример «опубликования» метода M1() класса MyClass :
class MyClass
{
public static void M1()
{ /* Описание метода M1() */ }
}

в рамках определенного класса. Тем не менее, в языке C#

свойства отличаются от переменных. В частности, переменные принято именовать с маленькой буквы, а свойства – с большой.

Пример описания переменных и методов класса:
class MyClass
{

int width; // Описание private-переменной класса
int height; // Описание private-переменной класса

public int Width { /* Описание свойства класса */ }
public int Height { /* Описание свойства класса */ }

}

корректную работу с данным свойством (например, задание значения свойства).
Доступ к

свойству осуществляется при помощи двух методов-аксессоров (от англ. access – доступ) get (для чтения значения) и set (для записи значения).

class MyClass
{
int width;
int height;

public int Width
{
get { return width; } // Описание аксессора get
set { width = value; } // Описание аксессора set
}
}

и свойство.
Ключевым отличием свойства от переменной является возможность ограничения операций

чтения и записи его значений.

class MyClass
{
int width;
int height;

public int Width // Свойство доступно только для чтения
{
get { return width; }
}
}

// только положительное значение
{
get { return width; }

set
{
if (value >

0) width = value;
}
}
}

и записываем в неё
// ссылку на созданный объект класса MyClass
MyClass

MyObject = new MyClass() ;

// Устанавливаем значение свойства Width объекта MyObject
MyObject . Width = 100;

// Выводим на консоль значение свойства Width (100)
Console.WriteLine( MyObject . Width );

height;

public int Width // Значение свойства
// нельзя изменить извне
{
get { return

width; }
private set { width = value; }
}
}

MyClass
{
double width;

public void MyMethod (double width) // Описание метода
{
Console.WriteLine(

width ); // Код метода
}
}

любой момент, вернув некоторое значение:

public double Sum (double a, double

b) // Сумма двух чисел
{
return a + b;
}

Ключевое слово return также может быть использовано для метода, не предполагающего возврата значения (тип – void):

public void MyMethod () // Метод, не возвращающий значение
{
return ;
}

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

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

static void Product (double a, double b) // Произведение чисел
{
Console.WriteLine( a * b ); // Вывод результата на консоль

a += 2; // Попытка изменить переменную a
b -= 2; // Попытка изменить переменную b

Console.WriteLine( a * b ); // Вывод нового результата
}

()
{
double a = 3, b = 4; // Объявляем переменные

Product(a,

b); // На консоль выводятся числа 12 и 10

Console.WriteLine( a ); // 3
Console.WriteLine( b ); // 4
}

Примечание. Вместо имен переменных в качестве параметров метода при его вызове могут быть указаны конкретные числа.
Product(3, 4); // Ошибки не возникнет

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

ключевое слово ref (от английского Reference – ссылка).
static void Product (ref double a, ref double b)
{
Console.WriteLine( a * b ); // Вывод результата на консоль

a += 2; // Попытка изменить переменную a
b -= 2; // Попытка изменить переменную b

Console.WriteLine( a * b ); // Вывод нового результата
}

Примечание. При вызове метода с параметром-ссылкой перед именем переменной также следует указывать ref. Переменная перед этим обязательно должна быть проинициализирована.

()
{
double a = 3, b = 4; // Объявляем переменные

Product(ref

a, ref b); // Выводятся числа 12 и 10

Console.WriteLine( a ); // 5
Console.WriteLine( b ); // 2
}

Примечание. Если при вызове метода вместо имени переменной в качестве параметра-ссылки будет указано конкретное число, возникнет ошибка.
Product(3, 4); // Ошибка

для возврата через неё значения бз использования внутри метода, то

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

static void Product (double a, double b , out double res)
{
res = a * b; // Результат запишется в переменную res

Console.WriteLine( a * b ); // И будет показан в консоли
}

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

()
{
double a = 3, b = 4; // Объявляем переменные

Product(ref

a, ref b); // Выводятся числа 12 и 10

Console.WriteLine( a ); // 5
Console.WriteLine( b ); // 2
}

Примечание. Если при вызове метода вместо имени переменной в качестве параметра-ссылки будет указано конкретное число, возникнет ошибка.
Product(3, 4); // Ошибка

однотипных параметров. Для этого всё множество однотипных параметров указывается как

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

static double Sum (params double[] parameters)
{
double s = 0; // Инициализируем переменную суммы

foreach (double par in parameters) s += par; // Суммируем

return s; // Возврат суммы переданных параметров
}

Пример вызова: Console.WriteLine( Sum(1, 2, 4, 6, 8) ); // 21

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

параметров. Без этих двух условий компилятор не смог бы определить окончание произвольного списка параметров.
Примеры ошибочного использования модификатора params:

static double Sum(params string[] str, params double[] pars)
{ /* Код метода */ }

static double Sum(params double[] pars, string str)
{ /* Код метода */ }


Правильное описание:
static double Sum(string str, params double[] pars)
{ /* Код метода */ }

количеством и типом параметров. В этом случае компилятор по составу

параметров сможет определить, какой из одноименных методов следует использовать.
class Box // Описание класса объектов «Ящик»
{
double length; double width; double height; // Размеры

public double Length // Свойство «Длина» ящика
{ get { return length; } set { length = value; } }

public double Width // Свойство «Ширина» ящика
{ get { return width; } set { width = value; } }

public double Height // Свойство «Высота» ящика
{ get { return height; } set { height = value; } }
// Здесь идёт описание методов (см. на следующем слайде)
}

Length
}

public void Change(double l , double w)
{
Length = l; // Меняем

значение свойства Length
Width = w; // Меняем значение свойства Width
}

public void Change(double l, double w, double h)
{
Length = l; // Меняем значение свойства Length
Width = w; // Меняем значение свойства Width
Height = h; // Меняем значение свойства Height
}


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

«Ящик»
b.Length = 0; // Инициализируем длину ящика
b.Width = 0; //

Инициализируем ширину ящика
b.Height = 0; // Инициализируем высоту ящика

b.Change(1); // Меняем длину ящика
Console.WriteLine(b.Length + "; " + b.Width + "; " + b.Height);
// 1; 0; 0

b.Change(2, 3); // Меняем длину и ширину ящика
Console.WriteLine(b.Length + "; " + b.Width + "; " + b.Height);
// 2; 3; 0

b.Change(4, 5, 6); // Инициализируем длину, ширину, высоту
Console.WriteLine(b.Length + "; " + b.Width + "; " + b.Height);
// 4; 5; 6

параметров (количеством и типом), поскольку компилятор не сможет их различить

и выдаст ошибку.
Следующий метод вступит в конфликт с предыдущим:
public void Change(double l, double w, double v)
{
Length = l; // Меняем длину ящика
Width = w; // Меняем ширину ящика
Height = v / l / w; // Вычисляем высоту через объём v
}

Решение 1. Описать один из методов с меньшим или большим количеством параметров.
Решение 2. Изменить тип хотя бы одного из параметров одного из методов.
Решение 3. Комбинация предыдущих вариантов.
Решение 4. Дать одному из методов другое имя (например, Change_l_w_v).

при модификации одного из методов.

public void Change(int l, double w,

double v)
{
Length = l; // Меняем длину ящика
Width = w; // Меняем ширину ящика
Height = v / l / w; // Вычисляем высоту через объём v
}

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

b.Change(4, 5, 6); // Инициализируем длину, ширину, высоту
Console.WriteLine(b.Length + "; " + b.Width + "; " + b.Height);
// 4; 5; 0,3

приведёт к ошибке при попытке компиляции.

public void Change(int l, double

w, double v)
{
Length = l; // Меняем длину ящика
Width = w; // Меняем ширину ящика
Height = v / l / w; // Вычисляем высоту через объём v
}

public void Change(double l, int w, double h)
{
Length = l; // Меняем значение свойства Length
Width = w; // Меняем значение свойства Width
Height = h; // Меняем значение свойства Height
}

значения их свойствам и переменным (то есть, инициализировать их). Для

автоматизации данного процесса удобно пользоваться конструктором экземпляра класса.
Конструктор – это специальный метод, вызываемый при создании экземпляра класса. Конструктор ничего не возвращает, а только производит подготовительные операции при создании объекта класса (при этом ключевое слово void указывать не требуется).
Имя конструктора всегда совпадает с именем класса:
class MyClass
{
double width;
public MyClass () // Обращение к конструктору класса
{
width = 0; // Инициализация переменной width
}
}

данного класса в других классах. Чтобы отменить такую возможность, следует

использовать модификатор доступа private (или же просто не указывать его):
class MyClass
{
double width;
private MyClass () // Или просто MyClass()
{
width = 0; // Инициализация переменной width
}
}

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

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

из параметров. Например:
class MyClass
{
double width;
public MyClass (double width)
{
width = width; // Совпадение имён
// переменной и параметра
}
}

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

this. Например:
class MyClass
{
double width;
public MyClass (double width)
{
this.width =

width; // Теперь имена переменной
// и параметра различимы
}
}

Замечание. Вместо this.width нельзя писать MyClass.width, поскольку в этом случае мы обращаемся не к конкретному объекту, а к классу, для которого не выделяется память под хранение значений переменных.

Однако можно создать дополнительный конструктор для определённого набора параметров. Таких

конструкторов может быть создано сколько угодно для различных ситуаций.
Также имеется возможность использовать в конструкторе по умолчанию один из дополнительных конструкторов. Для указания ссылки на текущий объект следует использовать ключевое слово this. Например:
class MyClass
{
double width;
// Описание конструктора MyClass(double width)
public MyClass() : this.MyClass (0)
{
// this.width = 0; теперь писать не нужно
}
}

а представляют собой лишь шаблонное описание бесконечного множества схожих объектов.

Как следствие, класс в принципе не способен осуществлять вызов методов объектов.
Статичный метод может использовать только те внешние переменные, которые сами объявлены как статичные. Это связано с тем, что статичные методы и переменные привязываются к классу, а не к его объектам. Таким образом, на базе рассматриваемого класса может быть создано сколь угодно много объектов, но статичная переменная класса для всех этих объектов всегда будет одна.
Для придания статичности методу или переменной используется ключевое слово static перед их описанием:
static ТипПеременной ИмяПеременной ;
static ТипВозвращаемогоЗначения ИмяМетода (СписокПараметров);

Пример:
static int MyVar; // Статичная переменная MyVar
static int MyMethod (int MyVar); // Статичный метод MyMethod

подсчёта количества объектов, созданных на базе рассматриваемого класса:

class MyClass
{
static

int ObjectNumber; // Переменная счётчика

public int GetObjectNumber()
{
return ObjectNumber; // Получаем количество
}

public MyClass()
{
ObjectNumber++; // Увеличиваем счётчик
}
}

= new MyClass() ;

// Получаем значение счётчика
Console.WriteLine( MyObject1 .

GetObjectNumber() ); // 1

// Создаем первый объект класса MyClass
MyClass MyObject2 = new MyClass() ;

// Получаем значение счётчика
Console.WriteLine( MyObject2 . GetObjectNumber() ); // 2
Console.WriteLine( MyObject1 . GetObjectNumber() ); // 2

процессе работы памяти. Определение ненужности объекта в текущий момент работы

программы определяется по количеству оставшихся ссылок на него. Как только количество ссылок станет равно нулю, объект добавляется в список подлежащих уничтожению. Впоследствии память из-под такого объекта будет освобождена так называемым сборщиком мусора, и объект прекратит свое существование. Для принудительного начала сборки мусора нужно обратиться к методу Collect() класса GC, соответствующего сборщику мусора:
GC.Collect();

Метод, вызываемый в ответ на уничтожение объекта, называется деструктором. Как и у конструктора, его имя совпадает с именем класса, но перед ним добавляется символ тильды:
class MyClass
{
~MyClass () { } // Обращение к деструктору класса
}

существующих классов с наследованием их методов и свойств. При этом

один класс может порождать несколько классов-наследников. В то же время, каждый класс может иметь только одного предка. Такое наследование называется последовательным (если бы у класса могло быть несколько предков, то наследование называлось бы параллельным, или множественным).
Иллюстрацией принципа последовательного наследования может служить класс Box («Ящик»), обладающий свойствами Length, Width, Height («Длина», «Ширина», «Высота») и методами их изменения. На основе данного класса можно создать класс-наследник Garage («Гараж»), который будет обладать теми же свойствами и методами, что и его предок. Однако у объектов класса «Гараж» будет учтено дополнительное свойство Material («Материал») типа string и присутствовать метод его задания SetMaterial(string M).
Точно так же на основе класса Garage может быть описан House («Дом»), у которого добавятся свойства RoofHeight («Высота крыши») и RoofMaterial («Материал крыши») и методы их изменения SetRoofHeight(double H) и SetRoofMaterial(string M).

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

средствам управления поведением объекта.
В роли пользователя может выступать как программист, работающий с объектами в процессе написания программы, так и класс-наследник, использующий для работы с собственными объектами уже имеющиеся свойства и методы класса-предка. В качестве конечного пользователя также может рассматриваться и сам объект, однако у него всегда имеется полный доступ к собственным свойствам и методам.
Настройка доступа к внутреннему устройству объектов осуществляется при помощи модификаторов доступа public, protected, private.
Результатом использования механизма инкапсуляции является представление объекта в виде «черного ящика» (капсулы), механизм функционирования которого скрыт, однако для которого имеется возможность подавать на его вход управляющие воздействия и получать на выходе отклик (результат), определяющийся его внутренним устройством.

подсчёта количества объектов, созданных на базе рассматриваемого класса:

class Class1
{
public void

PrintHello()
{
Console.WriteLine(«Hello!»);
}
}

class Class1
{
static int ObjectNumber; // Переменная счётчика

public int GetObjectNumber()
{
return ObjectNumber; // Получаем количество
}

public MyClass()
{
ObjectNumber++; // Увеличиваем счётчик
}
}

все классы наследуются от класса Object. В рамках принципа полиморфизма

имеется возможность создать переменную класса Object и присвоить ей объект любого класса (наследника):
Object o = new House();
(House) o.Height = 100;

В данном примере объявляется переменная o, которая может содержать ссылку на объект класса Object. Тем не менее, мы присваиваем ей ссылку на объект класса Box, наследника класса Object. В результате мы имеем возможность работать с нашим объектом как с домом, а не как с объектом базового класса. Для этого требуется выполнить приведение типов, указав (House) перед заданием действия с переменной. В принципе, благодаря полиморфизму мы можем работать с домом и как с ящиком (ведь дом также является наследником класса Box):
(Box) o.Height = 1;


латформа .NET по мере необходимости осуществляет автоматическое освобождение выделенной в процессе работы памяти. Определение ненужности объекта в текущий момент работы программы определяется по количеству оставшихся ссылок на него. Как только количество ссылок станет равно нулю, объект добавляется в список подлежащих уничтожению. Впоследствии память из-под такого объекта будет освобождена так называемым сборщиком мусора, и объект прекратит свое существование. Для принудительного начала сборки мусора нужно обратиться к методу Collect() класса GC, соответствующего сборщику мусора:
GC.Collect();

Метод, вызываемый в ответ на уничтожение объекта, называется деструктором. Как и у конструктора, его имя совпадает с именем класса, но перед ним добавляется символ тильды:
class MyClass
{
~MyClass () { } // Обращение к деструктору класса
}

описываемых в программе. Поэтому если при описании класса не указать,

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

class Person
{
// Описание класса
}


class Person: System.Object
{
// Описание класса
}

этими методами обладает любой другой класс как наследник класса Object.

Этими методами являются:
Equals(Object o) – метод сравнивает вызвавший его объект с объектом o. Если объект-хозяин и объект o одинаковы (ссылки содержат адреса на одну и ту же область памяти), то метод возвращает true, иначе – false.
GetHashCode() – возвращает хеш-код вызвавшего метод объекта.
GetType() – возвращает объект класса System.Type, идентичный типу объекта, вызвавшего метод.
ToString() – преобразует класс в строку.
Finalize() – метод вызывается автоматически при высвобождении памяти из-под объекта (уничтожении объекта).
MemberwiseClone() – метод, создает в памяти копию вызвавшего его объекта и возвращает ссылку на эту копию.

объект которого хранит имя и фамилию человека.

class Person
{
public string FirstName

{ get; set; }
public string SecondName { get; set; }

public Person(string firstName, string secondName)
{
FirstName = firstName;
SecondName = secondName;
}
}

имя и фамилию человека.

Person p = new Person(«Имя», «Фамилия»);
Console.WriteLine(p.ToString()); //

ПространствоИмен.Person

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