Текст книги "Полное руководство. С# 4.0"
Автор книги: Герберт Шилдт
Жанр:
Программирование
сообщить о нарушении
Текущая страница: 43 (всего у книги 58 страниц)
Раньше для обработки неиспользуемых полей приходилось применять заполняю щие значения или дополнительные поля, которые просто указывали, используется поле или нет. Безусловно, заполняющие значения пригодны лишь в том случае, если они подставляются вместо значения, которое в противном случае окажется недействи тельным, но так бывает далеко не всегда. А дополнительные поля, указывающие, ис пользуется поле или нет, пригодны во всех случаях, но их ввод и обработка вручную до ставляют немало хлопот. Оба эти затруднения позволяет преодолеть обнуляемый тип. Основы применения обнуляемых типов
Обнуляемый тип – это особый вариант типа значения, представленный структу рой. Помимо значений, определяемых базовым типом, обнуляемый тип позволяет хранить пустые значения (null). Следовательно, обнуляемый тип имеет такой же диа пазон представления чисел и характеристики, как и его базовый тип. Он предоставляет дополнительную возможность обозначить значение, указывающее на то, что перемен ная данного типа не инициализирована. Обнуляемые типы являются объектами типа System.Nullаble<Т>, где Т – тип значения, которое не должно быть обнуляемым.
ПРИМЕЧАНИЕ Обнуляемые эквиваленты могут быть только у типов значений.
Обнуляемый тип может быть указан двумя способами. Во-первых, объекты типа Nullable
И во-вторых, обнуляемый тип объявляется более кратким и поэтому чаще исполь зуемым способом с указанием знака ? после имени базового типа. В приведенном ниже примере демонстрируется более распространенный способ объявления обну ляемых переменных типа int и bool. int? count; bool? done;
Когда в коде применяются обнуляемые типы, создаваемый обнуляемый объект обычно выглядит следующим образом. int? count = null;
В данной строке кода переменная count явно инициализируется пустым значени ем (null). Это вполне соответствует принятому правилу: прежде чем использовать переменную, ей нужно присвоить значение. В данном случае присваиваемое значение означает, что переменная не определена.
Значение может быть присвоено обнуляемой переменной обычным образом, по скольку преобразование базового типа в обнуляемый определено заранее. Например, в следующей строке кода переменной count присваивается значение 100. count = 100;
Определить, имеет переменная обнуляемого типа пустое или конкретное значение, можно двумя способами. Во-первых, можно проверить переменную на пустое значе ние. Так, если переменная count объявлена так, как показано выше, то в следующей строке определяется, имеет ли эта переменная конкретное значение. if (count != null) // переменная имеет значение
Если переменная count не является пустой, то она содержит конкретное значение. И во-вторых, можно воспользоваться доступным только для чтения свойством HasValue типа Nullable
Свойство HasValue возвращает логическое значение true, если экземпляр объекта, для которого оно вызывается, содержит конкретное значение, а иначе оно возвраща ет логическое значение false. Ниже приведен пример, в котором конкретное значе ние обнуляемого объекта count определяется вторым способом с помощью свойства HasValue. if(count.HasValue) // переменная имеет значение
Если обнуляемый объект содержит конкретное значение, то получить это значение можно с помощью доступного только для чтения свойства Value типа Nullable. Т Value
Свойство Value возвращает экземпляр обнуляемого объекта, для которо го оно вызывается. Если же попытаться получить с помощью этого свойства зна чение пустой переменной, то в итоге будет сгенерировано исключение System. InvalidOperationException. Кроме того, значение экземпляра обнуляемого объек та можно получить путем приведения к его базовому типу.
В следующей программе демонстрируется основной механизм обращения с обну ляемым типом. // Продемонстрировать применение обнуляемого типа. using System; class NullableDemo { static void Main() { int? count = null; if(count.HasValue) Console.WriteLine("Переменная count имеет следующее значение: " + count.Value); else Console.WriteLine("У переменной count отсутствует значение"); count = 100; if(count.HasValue) Console.WriteLine("Переменная count имеет следующее значение: " + count.Value); else Console.WriteLine("У переменной count отсутствует значение"); } }
Вот к какому результату приводит выполнение этой программы. У переменной count отсутствует значение Переменная count имеет следующее значение: 100 Применение обнуляемых объектов в выражениях
Обнуляемый объект может использоваться в тех выражениях, которые являются действительными для его базового типа. Более того, обнуляемые объекты могут со четаться с необнуляемыми объектами в одном выражении. И это вполне допустимо благодаря предопределенному преобразованию базового типа в обнуляемый. Когда обнуляемые и необнуляемые типы сочетаются в одной операции, ее результатом ста новится значение обнуляемого типа.
В приведенной ниже программе демонстрируется применение обнуляемых типов в выражениях. // Использовать обнуляемые объекты в выражениях. using System; class NullableDemo { static void Main() { int? count = null; int? result = null; int incr = 10; // переменная incr не является обнуляемой // переменная result содержит пустое значение. // переменная оказывается count пустой. result = count + incr; if(result.HasValue) Console.WriteLine("Переменная result имеет следующее значение: " + result.Value); else Console.WriteLine("У переменной result отсутствует значение"); // Теперь переменная count получает свое значение, и поэтому // переменная result будет содержать конкретное значение. count = 100; result = count + incr; if(result.HasValue) Console.WriteLine("Переменная result имеет следующее значение: " + result.Value); else Console.WriteLine("У переменной result отсутствует значение"); } }
При выполнении этой программы получается следующий результат. У переменной result отсутствует значение Переменная result имеет следующее значение: 110 Оператор ??
Попытка преобразовать обнуляемый объект в его базовый тип путем при ведения типов обычно приводит к генерированию исключения System. InvalidOperationException, если обнуляемый объект содержит пустое значение. Это может произойти, например, в том случае, если значение обнуляемого объекта присваивается переменной его базового типа с помощью приведения типов. Появле ния данного исключения можно избежать, если воспользоваться оператором ??, на зываемым нулеобъединяющим оператором. Этот оператор позволяет указать значение, которое будет использоваться по умолчанию, если обнуляемый объект содержит пу стое значение. Он также исключает потребность в приведении типов.
Ниже приведена общая форма оператора ??. обнуляемый_объект ?? значение_по_умолчанию
Если обнуляемыйобъект содержит конкретное значение, то результатом опера ции ?? будет именно это значение. В противном случае результатом операции ?? ока жется значениепо_умолчанию.
Например, в приведенном ниже фрагменте кода переменная balance содержит пустое значение. Вследствие этого переменной currentBalance присваивается зна чение 0.0, используемое по умолчанию, и тем самым устраняется причина для гене рирования исключения. double? balance = null; double currentBalance; currentBalance = balance ?? 0.0;
В следующем фрагменте кода переменной balance присваивается значение 123.75. double? balance = 123.75; double currentBalance; currentBalance = balance ?? 0.0;
Теперь переменная currentBalance содержит значение 123.75 переменной balance.
И еще одно замечание: выражение в правой части оператора ?? вычисляется толь ко в том случае, если выражение в левой его части не содержит значение. Этот факт демонстрируется в приведенной ниже программе. // Применение оператора ?? using System; class NullableDemo2 { // Возвратить нулевой остаток. static double GetZeroBal() { Console.WriteLine("В методе GetZeroBalO."); return 0.0; } static void Main() { double? balance = 123.75; double currentBalance; // Здесь метод GetZeroBal() не вызывается, поскольку // переменная balance содержит конкретное значение. currentBalance = balance ?? GetZeroBal(); Console.WriteLine(currentBalance); } }
В этой программе метод GetZeroBal() не вызывается, поскольку переменная balance содержит конкретное значение. Как пояснялось выше, если выражение в ле вой части оператора ?? содержит конкретное значение, то выражение в правой его части не вычисляется. Обнуляемые объекты, операторы отношения и логические операторы
Обнуляемые объекты могут использоваться в выражениях отношения таким же образом, как и соответствующие объекты необнуляемого типа. Но они должны под чиняться следующему дополнительному правилу: когда два обнуляемых объекта срав ниваются в операциях сравнения <, >, <= или >=, то их результат будет ложным, если любой из обнуляемых объектов оказывается пустым, т.е. содержит значение null. В качестве примера рассмотрим следующий фрагмент кода. byte? lower = 16; byte? upper = null;
// Здесь переменная lower определена, а переменная upper не определена. if(lower < upper) // ложно
В данном случае проверка того, что значение одной переменой меньше значения другой, дает ложный результат. Хотя это и не совсем очевидно, как, впрочем, и следую щая проверка противоположного характера. if(lower > upper) // .. также ложно!
Следовательно, если один или оба сравниваемых обнуляемых объекта оказываются пустыми, то результат их сравнения всегда будет ложным. Это фактически означает, что пустое значение (null) не участвует в отношении порядка.
Тем не менее с помощью операторов == и != можно проверить, содержит ли обну ляемый объект пустое значение. Например, следующая проверка вполне допустима и дает истинный результат. if(upper == null) // ...
Если в логическом выражении участвуют два объекта типа bool?, то его результат может иметь одно из трех следующих значений: true (истинное), false (ложное) или null (неопределенное). Ниже приведены результаты применения логических опера торов & и | к объектам типа bool?. P Q P | Q P & Q true null true null false null null false null true true null null false null false null null null null
И наконец, если логический оператор ! применяется к значению типа bool?, ко торое является пустым (null), то результат этой операции будет неопределенным (null). Частичные типы
Начиная с версии 2.0, в C# появилась возможность разделять определение класса, структуры или интерфейса на две или более части с сохранением каждой из них в от дельном файле. Это делается с помощью контекстного ключевого слова partial. Все эти части объединяются вместе во время компиляции программы.
Если модификатор partial используется для создания частичного типа, то он принимает следующую общую форму: partial тип имя_типа { // ...
где имя_типа обозначает имя класса, структуры или интерфейса, разделяемого на ча сти. Каждая часть получающегося частичного типа должна указываться вместе с моди фикатором partial.
Рассмотрим пример разделения простого класса, содержащего координаты XY, на три отдельных файла. Ниже приведено содержимое первого файла.
partial class XY { public XY(int a, int b) { X = a; Y = b; } }
Далее следует содержимое второго файла. partial class XY { public int X { get; set; } }
И наконец, содержимое третьего файла. partial class XY { public int Y { get; set; } } В приведенном ниже файле исходного текста программы демонстрируется при менение класса XY.
// Продемонстрировать определения частичного класса. using System;
class Test { static void Main() { XY xy = new XY (1, 2); Console.WriteLine(xy.X + + xy.Y); } } Для того чтобы воспользоваться классом XY, необходимо включить в компиля цию все его файлы. Так, если файлы класса XY называются xy1.cs, ху2.cs и ху3.cs, а класс Test содержится в файле test.cs, то для его компиляции достаточно ввести в командной строке следующее.
csc test.cs xy1.cs xy2.cs хуЗ.cs И последнее замечание: в C# допускаются частичные обобщенные классы. Но пара метры типа в объявлении каждого такого класса должны совпадать с теми, что указы ваются в остальных его частях. ## Частичные методы Как пояснялось в предыдущем разделе, с помощью модификатора partial мож но создать класс частичного типа. Начиная с версии 3.0, в C# появилась возможность использовать этот модификатор и для создания частичного метода в элементе данных частичного типа. Частичный метод объявляется в одной его части, а реализуется в дру гой. Следовательно, с помощью модификатора partial можно отделить объявление метода от его реализации в частичном классе или структуре. Главная особенность частичного метода заключается в том, что его реализация не требуется! Если частичный метод не реализуется в другой части класса или структуры, то все его вызовы молча игнорируются. Это дает возможность определить, но не вос требовать дополнительные, хотя и не обязательные функции класса. Если эти функции не реализованы, то они просто игнорируются. Ниже приведена расширенная версия предыдущей программы, в которой создает ся частичный метод Show(). Этот метод вызывается другим методом, ShowXY(). Ради удобства все части класса XY представлены в одном файле, но они могут быть распре делены по отдельным файлам, как было показано в предыдущем разделе.
// Продемонстрировать применение частичного метода. using System;
partial class XY { public XY(int a, int b) { X = a; Y = b; } // Объявить частичный метод. partial void Show();
}
partial class XY { public int X { get; set; } // Реализовать частичный метод. partial void Show() { Console.WriteLine("{0}, {1}", X, Y); }
}
partial class XY { public int Y { get; set; } // Вызвать частичный метод. public void ShowXY() { Show(); }
}
class Test { static void Main() { XY xy = new XY(1, 2); xy.ShowXY(); } } Обратите внимание на то, что метод Show() объявляется в одной части класса XY, а реализуется в другой его части. В реализации этого метода выводятся значения ко ординат X и Y. Это означает, что когда метод Show() вызывается из метода ShowXY(), то данный вызов действительно имеет конкретные последствия: вывод значений координат X и Y. Но если закомментировать реализацию метода Show(), то его вызов из метода ShowXY() ни к чему не приведет. Частичным методам присущ ряд следующих ограничений. Они должны возвра щать значение типа void. У них не может быть модификаторов доступа и они не могут быть виртуальными. В них нельзя также использовать параметры out. ## Создание объектов динамического типа Как уже упоминалось не раз, начиная с главы 3, C# является строго типизирован ным языком программирования. Вообще говоря, это означает, что все операции про веряются во время компиляции на соответствие типов, и поэтому действия, не под держиваемые конкретным типом, не подлежат компиляции. И хотя строгий контроль типов дает немало преимуществ программирующему, помогая создавать устойчивые и надежные программы, он может вызвать определенные осложнения в тех случаях, когда тип объекта остается неизвестным вплоть до времени выполнения. Нечто по добное может произойти при использовании рефлексии, доступе к COM-объекту или же в том случае, если требуется возможность взаимодействия с таким динамическим языком, как, например, IronPython. До появления версии C# 4.0 подобные ситуации были трудноразрешимы. Поэтому для выхода из столь затруднительного положения в версии C# 4.0 был внедрен новый тип данных под названием dynamic. За одним важным исключением, тип dynamic очень похож на тип object, по скольку его можно использовать для ссылки на объект любого типа. А отличается он от типа object тем, что вся проверка объектов типа dynamic на соответствие типов откладывает до времени выполнения, тогда как объекты типа object подлежат этой проверке во время компиляции. Преимущество откладывания подобной проверки до времени выполнения состоит в том, что во время компиляции предполагается, что объект типа dynamic поддерживает любые операции, включая применение операто ров, вызовы методов, доступ к полям и т.д. Это дает возможность скомпилировать код без ошибок. Конечно, если во время выполнения фактический тип, присваиваемый объекту, не поддерживает ту или иную операцию, то возникнет исключительная си туация во время выполнения. В приведенном ниже примере программы применение типа dynamic демонстри руется на практике.
// Продемонстрировать применение типа dynamic. using System; using System.Globalization;
class DynDemo { static void Main() { // Объявить две динамические переменные. dynamic str; dynamic val; // Поддерживается неявное преобразование в динамические типы. // Поэтому следующие присваивания вполне допустимы. str = "Это строка"; val = 10; Console.WriteLine("Переменная str содержит: " + str); Console.WriteLine("Переменная val содержит: " + val + 'n'); str = str.ToUpper(CultureInfo.CurrentCulture); Console.WriteLine("Переменная str теперь содержит: " + str); val = val + 2; Console.WriteLine("Переменная val теперь содержит: " + val + 'n'); string str2 = str.ToLower(CultureInfo.CurrentCulture); Console.WriteLine("Переменная str2 содержит: " + str2); // Поддерживаются неявные преобразования из динамических типов. int х = val * 2; Console.WriteLine("Переменная x содержит: " + х); }
} Выполнение этой программы дает следующий результат.
Переменная str содержит: Это строка Переменная val содержит: 10
Переменная str теперь содержит: ЭТО СТРОКА Переменная val теперь содержит: 12
Переменная str2 содержит: это строка Переменная х содержит: 24 Обратите внимание в этой программе на две переменные str и val, объявляемые с помощью типа dynamic. Это означает, что проверка на соответствие типов операций с участием обеих переменных не будет произведена во время компиляции. В итоге для них оказывается пригодной любая операция. В данном случае для переменной str вызываются методы ToUpper() и ToLower() класса String, а переменная уча ствует в операциях сложения и умножения. И хотя все перечисленные выше действия совместимы с типами объектов, присваиваемых обеим переменным в рассматривае мом здесь примере, компилятору об этом ничего не известно – он просто принимает. И это, конечно, упрощает программирование динамических процедур, хотя и допу скает возможность появления ошибок в подобных действиях во время выполнения. В разбираемом здесь примере программа ведет себя "правильно" во время выпол нения, поскольку объекты, присваиваемые упомянутым выше переменным, поддер живают действия, выполняемые в программе. В частности, переменной val присваи вается целое значение, и поэтому она поддерживает такие целочисленные операции, как сложение. А переменной str присваивается символьная строка, и поэтому она поддерживает строковые операции. Следует, однако, иметь в виду, что ответственность за фактическую поддержку типом объекта, на который делается ссылка, всех операций над данными типа dynamic возлагается на самого программирующего. В противном случае выполнение программы завершится аварийным сбоем. В приведенном выше примере обращает на себя внимание еще одно обстоятель ство: переменной типа dynamic может быть присвоен любой тип ссылки на объект благодаря неявному преобразованию любого типа в тип dynamic. Кроме того, тип dynamic автоматически преобразуется в любой другой тип. Разумеется, если во время выполнения такое преобразование окажется неправильным, то произойдет ошибка при выполнении. Так, если добавить в конце рассматриваемой здесь программы сле дующую строку кода:
bool b = val; то возникнет ошибка при выполнении из-за отсутствия неявного преобразования типа int (который оказывается типом переменной val во время выполнения) в тип bool. Поэтому данная строка кода приведет к ошибке при выполнении, хотя она и будет скомпилирована безошибочно. Прежде чем оставить данный пример программы, попробуйте поэксперименти ровать с ней. В частности, измените тип переменных str и val на object, а затем попытайтесь скомпилировать программу еще раз. В итоге появятся ошибки при ком пиляции, поскольку тип object не поддерживает действия, выполняемые над обеи ми переменными, что и будет обнаружено во время компиляции. В этом, собственно, и заключается основное отличие типов object и dynamic. Несмотря на то что оба типа могут использоваться для ссылки на объект любого другого типа, над перемен ной типа object можно производить только те действия, которые поддерживаются типом object. Если же вы используете тип dynamic, то можете указать какое угодно действие, при условии что это действие поддерживается конкретным объектом, на ко торый делается ссылка во время выполнения. Для того чтобы стало понятно, насколько тип dynamic способен упростить реше ние некоторых задач, рассмотрим простой пример его применения вместе с рефлек сией. Как пояснялось в главе 17, чтобы вызвать метод для объекта класса, получаемого во время выполнения с помощью рефлексии, можно, в частности, обратиться к методу Invoke(). И хотя такой способ оказывается вполне работоспособным, нужный метод намного удобнее вызвать по имени в тех случаях, когда его имя известно. Например, вполне возможна такая ситуация, когда в некоторой сборке содержится конкретный класс, поддерживающий методы, имена и действия которых заранее известны. Но по скольку эта сборка подвержена изменениям, то приходится постоянно убеждаться в том, что используется последняя ее версия. Для проверки текущей версии сборки можно, например, воспользоваться рефлексией, сконструировать объект искомого класса, а за тем вызвать методы, определенные в этом классе. Теперь эти методы можно вызвать по имени с помощью типа dynamic, а не метода Invoke(), поскольку их имена известны. Разместите сначала приведенный ниже код в файле с именем MyClass.cs. Этот код будет динамически загружаться посредством рефлексии.
public class DivBy { public bool IsDivBylint a, int b) { if((a % b) == 0) return true; return false; } public bool IsEven(int a) { if((a % 2) == 0) return true; return false; }
} Затем скомпилируйте этот файл в библиотеку DLL под именем MyClass.dll. Если вы пользуетесь компилятором командной строки, введите в командной строке следующее.
csc /t:library MyClass.cs Далее составьте программу, в которой применяется библиотека MyClass.dll, как показано ниже.
// Использовать тип dynamic вместе с рефлексией. using System; using System.Reflection;
class DynRefDemo { static void Main() { Assembly asm = Assembly.LoadFrom("MyClass.dll"); Type[] all = asm.GetTypes(); // Найти класс DivBy. int i; for(i = 0; i < all.Length; i++) if(all[i].Name == "DivBy") break; if(i == all.Length) { Console.WriteLine("Класс DivBy не найден в сборке."); return; } Type t = all[i]; //А теперь найти используемый по умолчанию конструктор. ConstructorInfо[] ci = t.GetConstructors(); int j; for(j = 0; j < ci.Length; j++) if(ci[j].GetParameters().Length == 0) break; if(j == ci.Length) { Console.WriteLine("Используемый по умолчанию конструктор не найден."); return; } // Создать объект класса DivBy динамически. dynamic obj = ci[j].Invoke (null); // Далее вызвать по имени методы для переменной obj. Это вполне допустимо, // поскольку переменная obj относится к типу dynamic, а вызовы методов // проверяются на соответствие типов во время выполнения, а не компиляции. if(obj.IsDivBy(15, 3)) Console.WriteLine("15 делится нацело на 3."); else Console.WriteLine("15 HE делится нацело на 3."); if(obj.IsEven(9)) Console.WriteLine("9 четное число."); else Console.WriteLine("9 HE четное число."); }
} Как видите, в данной программе сначала динамически загружается библиотека MyClass.dll, а затем используется рефлексия для построения объекта класса DivBy. Построенный объект присваивается далее переменной obj типа dynamic. А раз так, то методы IsDivBy() и IsEven() могут быть вызваны для переменной obj по имени, а не с помощью метода Invoke(). В данном примере это вполне допустимо, посколь ку переменная obj на самом деле ссылается на объект класса DivBy. В противном слу чае выполнение программы завершилось бы неудачно. Приведенный выше пример сильно упрощен и несколько надуман. Тем не менее он наглядно показывает главное преимущество, которое дает тип dynamic в тех случаях, когда типы получаются во время выполнения. Когда характеристики искомого типа, в том числе методы, операторы, поля и свойства, заранее известны, эти характеристи ки могут быть получены по имени с помощью типа dynamic, как следует из приведен ного выше примера. Благодаря этому код становится проще, короче и понятнее. Применяя тип dynamic, следует также иметь в виду, что при компиляции програм мы тип dynamic фактически заменяется объектом, а для описания его применения во время выполнения предоставляется соответствующая информация. И поскольку тип dynamic компилируется в тип object для целей перегрузки, то оба типа dynamic и object расцениваются как одно и то же. Поэтому при компиляции двух следующих перегружаемых методов возникнет ошибка.
static void f(object v) { // ... } static void f(dynamic v) { // ... } // Ошибка! И последнее замечание: тип dynamic поддерживается компонентом DLR (Dynamic Language Runtime – Средство создания динамических языков во время выполнения), внедренным в .NET 4.0. ## Возможность взаимодействия с моделью СОМ В версии C# 4.0 внедрены средства, упрощающие возможность взаимодействия с неуправляемым кодом, определяемым моделью компонентных объектов (СОМ) и применяемым, в частности, в COM-объекте Office Automation. Некоторые из этих средств, в том числе тип dynamic, именованные и необязательные свойства, пригодны для применения помимо возможности взаимодействия с моделью СОМ. Тема модели СОМ вообще и COM-объекта Office Automation в частности весьма обширна, а порой и довольно сложна, чтобы обсуждать ее в этой книге. Поэтому возможность взаимодей ствия с моделью СОМ выходит за рамки данной книги. Тем не менее две особенности, имеющие отношение к возможности взаимодей ствия с моделью СОМ, заслуживают краткого рассмотрения в этом разделе. Первая из них состоит в применении индексированных свойств, а вторая – в возможности пере давать аргументы значения тем COM-методам, которым требуется ссылка. Как вам должно быть уже известно, в C# свойство обычно связывается только с одним значением с помощью одного из аксессоров get или set. Но совсем иначе дело обсто ит со свойствами модели СОМ. Поэтому, начиная с версии C# 4.0, в качестве выхода из этого затруднительного положения во время работы с COM-объектом появилась воз можность пользоваться индексированным свойством для доступа к COM-свойству, име ющему несколько параметров. С этой целью имя свойства индексируется, почти так же, как это делается с помощью индексатора. Допустим, что имеется объект myXLApp, который относится к типу Microsoft.Office.Interop.Execl.Application. В прошлом для установки строкового значения "OК" в ячейках С1-СЗ электронной таблицы Excel можно было бы воспользоваться оператором, аналогичным следую щему.
myXLapp.get_Range("C1", "С3").set_Value(Type.Missing, "OK"); В этой строке кода интервал ячеек электронной таблицы получается при вызове метода get_Range(), для чего достаточно указать начало и конец интервала. А значе ния задаются при вызове метода set_Value(), для чего достаточно указать тип (что не обязательно) и конкретное значение. В этих методах используются свойства Range и Value, поскольку у обоих свойств имеются два параметра. Поэтому в прошлом к ним нельзя было обращаться как к свойствам, но приходилось пользоваться упомянутыми выше методами. Кроме того, аргумент Type.Missing служил в качестве обычного за полнителя, который передавался для указания на тип, используемый по умолчанию. Но, начиная с версии C# 4.0, появилась возможно переписать приведенный выше опе ратор, приведя его к следующей более удобной форме.
myXLapp.Range["C1", "С3"].Value = "OK"; В этом случае значения интервала ячеек электронной таблицы передаются с ис пользованием синтаксиса индексаторов, а заполнитель Туре.Missing уже не нужен, поскольку данный параметр теперь задается по умолчанию. Как правило, при определении в методе параметра ref приходится передавать ссылку на этот параметр. Но, работая с моделью СОМ, можно передавать параметру ref значение, не заключая его предварительно в оболочку объекта. Дело в том, что компилятор будет автоматически создавать временный аргумент, который уже заклю чен в оболочку объекта, и поэтому указывать параметр ref в списке аргументов уже не нужно. ## Дружественные сборки Одну сборку можно сделать дружественной по отношению к другой. Такой сборке доступны закрытые члены дружественной ей сборки. Благодаря этому средству стано вится возможным коллективное использование членов выбранных сборок, причем эти члены не нужно делать открытыми. Для того чтобы объявить дружественную сборку, необходимо воспользоваться атрибутом InternalsVisibleTo. ## Разные ключевые слова В заключение этой главы в частности и всей части I вообще будут вкратце представ лены ключевые слова, определенные в C# и не упоминавшиеся в предыдущих главах данной книги. ### Ключевое слов lock Ключевое слово lock используется при создании многопоточных программ. Под робнее оно рассматривается в главе 23, где речь пойдет о многопоточном программи ровании. Но ради полноты изложения ниже приведено краткое описание этого клю чевого слова. Программа на C# может состоять из нескольких потоков исполнения. В этом случае программа считается многопоточной, и отдельные ее части выполняются параллельно, т.е. одновременно и независимо друг от друга. В связи с такой организацией програм мы возникает особого рода затруднение, когда два потока пытаются воспользоваться ресурсом, которым можно пользоваться только по очереди. Для разрешения этого за труднения можно создать критический раздел кода, который будет одновременно вы полняться одним и только одним потоком. И это делается с помощью ключевого слова lock. Ниже приведена общая форма этого ключевого слова:
lock(obj) { // критический раздел кода } где obj обозначает объект, для которого согласуется блокировка кода. Если один поток уже вошел в критический раздел кода, то второму потоку придется ждать до тех пор, пока первый поток не выйдет из данного критического раздела кода. Когда же первый поток покидает критический раздел кода, блокировка снимается и предоставляется второму потоку. С этого момента второй поток может выполнять критический раздел кода. **ПРИМЕЧАНИЕ** Более подробно ключевое слово lock рассматривается в главе 23. ### Ключевое слово readonly Отдельное поле можно сделать доступным в классе только для чтения, объявив его как readonly. Значение такого поля можно установить только с помощью инициали затора, когда оно объявляется или же когда ему присваивается значение в конструк торе. После того как значение доступного только для чтения поля будет установлено, оно не подлежит изменению за пределами конструктора. Следовательно, поле типа readonly удобно для установки фиксированного значения с помощью конструктора. Такое поле можно, например, использовать для обозначения размера массива, кото рый часто используется в программе. Допускаются как статические, так и нестатиче ские поля типа readonly. **ПРИМЕЧАНИЕ** Несмотря на кажущееся сходство, поля типа readonly не следует путать с полями типа const, которые рассматриваются далее в этой главе. Ниже приведен пример применения поля с ключевым словом readonly.
