Все структуры неявно получаются из класса System.ValueType. С точки зрения функциональности, единственной целью System.ValueType является "переопределение" виртуальных методов System.Object (этот объект будет описан чуть позже) с целью учета особенностей семантики типов, заданных значениями, в противоположность ссылочным типам. Методы экземпляра, определенные с помощью System.ValueType, будут идентичны соответствующим методам System.Object.
// Структуры и перечни являются расширениями System.ValueType.
public abstract class ValueType: object {
public virtual bool Equals(object obj);
public virtual int GetHashCode();
public Type GetType();
public virtual string ToString();
}
Предположим, что вы создали C#-структуру с именем MyPoint, используя ключевое слово C# struct.
// Структуры являются типами, которые характеризуются значениями.
struct MyPoint {
public int x, у;
}
Чтобы разместить в памяти тип структуры, можно использовать ключевое слово new, что, кажется, противоречит интуиции, поскольку обычно подразумевается, что new всегда размещает данные в динамически распределяемой памяти. Это частица общего "тумана", сопровождающего CLR. Мы можем полагать, что вообще все в программе является объектами и значениями, создаваемыми с помощью new. Однако в том случае, когда среда выполнения обнаруживает тип. полученный из System.ValueType, выполняется обращение к стеку.
// Все равно используется стек!
MyPoint р = new MyPoint();
Структуры могут создаваться и без использования ключевою слова new.
MyPoint p1;
p1.x = 100;
p1.y = 100;
Но при использовании этого подхода вы должны выполнить инициализацию всех полей данных до их использования. Если этого не сделать, возникнет ошибка компиляции.
Типы, характеризуемые значениями, ссылочные типы и оператор присваивания
Теперь изучите следующий метод Main() и рассмотрите его вывод, показанный на рис. 3.12.
static void Main(string[] args) {
Console.WriteLine("*** Типы, характеризуемые значением / Ссылочные типы ***");
Console.WriteLine(''-› Создание p1");
MyPoint p1 = new MyPoint();
p1.x = 100;
p1.у = 100;
Console.WriteLine("-› Приcваивание p1 типу p2n");
MyPoint p2 = p1;
// Это p1.
Console.WriteLine"p1.x = {0}", p1.x);
Console.WriteLine"p1.y = {0}", p1.y);
// Это р2.
Console.WriteLine("p2.x = {0}", p2.x);
Console.WriteLine("p2.у = {0}", p2.y);
// Изменение p2.x. Это НЕ влияет на p1.x.
Console.WriteLine("-› Замена значения p2.x на 900");
р2.х = 900;
// Новая печать.
Console.WriteLine("-› Это снова значения х… ");
Console.WriteLine("p1.x = {0}", p1.x);
Console.WriteLine("p2.x = {0}", р2.х);
Console ReadLine();
}
Рис. 3.12. Для типов, характеризуемых значениями, присваивание означает буквальное копирование каждого поля
Здесь создается переменная типа MyPoint (с именем p1), которая затем присваивается другой переменной типа MyPoint (р2). Ввиду того, что MyPoint является типом, характеризуемым значением, в результате в стеке будет две копии типа MyPoint, каждая из которых может обрабатываться независимо одна от другой. Поэтому, когда изменяется значение р2.х, значение p1.x остается прежним (точно так же, как в предыдущем примере с целочисленными данными).
Ссылочные типы (классы], наоборот, размещаются в управляемой динамически распределяемой памяти (managed heap). Эти объекты остаются в памяти до тех пор, пока сборщик мусора .NET не уничтожит их. По умолчанию в результате присваивания ссылочных типов создается новая ссылка на тот же объект в динамической памяти. Для иллюстрации давайте изменим определение типа MyPoint со структуры на класс.
// Классы всегда оказываются ссылочными типами,
class MyPoint { // ‹= Теперь это класс!
public int х, у;
}
Если выполнить программу теперь, то можно заметить изменения в ее поведении (рис. 3.13).
Рис. 3.13. Для ссылочных типов присваивание означает копирование ссылки
В данном случае имеется две ссылки на один и тот же объект в управляемой динамической памяти. Поэтому, если изменить значение x с помощью ссылки р2, то мы увидим, что p1.х укажет на измененное значение.
Типы, характеризуемые значениями и содержащие ссылочные типы
Теперь, когда вы чувствуете разницу между типами, характеризуемыми значением, и ссылочными типами, давайте рассмотрим более сложный пример. Предположим, что имеется следующий ссылочный тип (класс), обрабатывающий информационную строку, которую можно установить с помощью пользовательского конструктора.
class ShapeInfo {
public string infoString;
public ShapeInfo(string info) { infoString = info; }
}
Предположим также, что вы хотите поместить переменную этого типа класса в тип с именем MyReсtangle (прямоугольник), характеризуемый значением. Чтобы позволить внешним объектам устанавливать значение внутреннего поля ShapeInfо, вы должны создать новый конструктор (при этом конструктор структуры, заданный по умолчанию, является зарезервированным и не допускает переопределения).
struct MyRectangle {
// Структура MyRectangle содержит член ссылочного типа.
public ShapeInfo reсtInfo;
public int top, left, bottom, right;
public MyRactangle(string info) {
rectInfo = new ShapeInfo(info);
top = left = 10;
bottom = right = 100;
}
}
Теперь вы имеете ссылочный тип. внутри типа, характеризуемого значением. И здесь возникает вопрос на миллион долларов: что случится, если присвоить одну переменную типа MyRectangle другой такой же переменной? С учетом того, что вы уже знаете о типах, характеризуемых значениями, вы можете сделать правильное предположение о том, что целые данные (которые на самом деле и формируют эту структуру) для каждой переменной MyRectangle должны быть независимыми элементами. Но что можно сказать о внутреннем ссылочном типе? Будет скопировано полное состояние этого объекта или будет скопирована ссылка на этот объект? Проанализируйте следующий программный код и рассмотрите рис. 3.14, который может подсказать правильный ответ.
static void Main(string[] args) {
// Создание первого объекта MyRectangle.
Console.WriteLine("-› Создание r1");
MyRectangle r1 = new MyRectangle("Это мой первый прямоугольник");
// Присваивание новому MyRectangle значений r1.
Console.WriteLine("-› Присваивание r1 типу r2");
MyRectangle r2;
r2 = r1;
// Изменение значений r2.
Console.WriteLine("-› Изменение значений r2");
r2.rectInfo.InfoString = "Это новая информация!");
r2.bottom = 4444;
// Print values
Console.WriteLine("-› Значения после изменений:");
Console.WriteLine("-› r1.rectInfo.infoString: {0}", r1.rectInfo.infoString);
Console.WriteLine("-› r2.rectInfo.infoString: {0}", r2.rectInfo.infoString);
Console.WriteLine("-› r1.bottom: {0}", r1.bottom);
Console.WriteLine("-› r2.bottom: {0}", r2.bottom);
}
Рис. 3.14. Внутренние ссылки указывают на один и тот же объект
Как видите, при изменении значения информирующей строки с помощью ссылки r2 ссылка r1 отображает точно такое же значение. По умолчанию, когда тип, характеризуемый значением, содержит ссылочные типы, присваивание приводит к копированию ссылок. В результате вы получаете две независимые структуры, каждая из которых содержит ссылки, указывающие на один и тот же объект в памяти (т.е. "поверхностную копию"). Если вы хотите иметь "детальную копию", когда состояние внутренних ссылок полностью Копируется в новый объект, необходимо реализовать интерфейс ICloneable (это будет обсуждаться в главе 7).
Исходный код. Проект ValAndRef размещен в подкаталоге, соответствующем главе 3.
Передача ссылочных типов по значению
Очевидно, что ссылочные типы могут передаваться членам типов, как параметры. Но передача объекта по ссылке отличается от его передачи по значению. Чтобы понять суть различий, предположим, что у нас есть класс Person (персона), определенный следующим образом.
class Person {
public string fullName;
public byte age;
public Person(string n, byte a) {
fullName = n;
age = a;
}
public Person() {}
public void PrintInfo() { Console.WriteLine("{0}, {1} года (лет)", fullName, age); }
}
Теперь создадим метод, который позволяет вызывающей стороне переслать тип Person по значению (обратите внимание на отcутcтвие модификаторов параметра).
