Текст книги "C# 4.0: полное руководство"
Автор книги: Герберт Шилдт
Жанр:
Программирование
сообщить о нарушении
Текущая страница: 41 (всего у книги 83 страниц)
Помимо модификаторов доступа public, private и protected, использовавшихся в представленных ранее примерах программ, в C# предусмотрен также модификатор доступа internal. Этот модификатор определяет доступность члена во всех файлах сборки и его недоступность за пределами сборки. Проще говоря, о члене, обозначенном как internal, известно только в самой программе, но не за ее пределами. Модификатор доступа internal особенно полезен для создания программных компонентов.
Модификатор доступа internal можно применять к классам и их членам, а также к структурам и членам структур. Кроме того, модификатор internal разрешается использовать в объявлениях интерфейсов и перечислений.
Из модификаторов protected и internal можно составить спаренный модификатор доступа protected internal. Уровень доступа protected internal может быть задан только для членов класса. Член, объявленный как protected internal, доступен лишь в пределах собственной сборки или для производных типов.
Ниже приведен пример применения модификатора доступа internal.
// Использовать модификатор доступа internal.
using System;
class InternalTest {
internal int x;
}
class InternalDemo {
static void Main() {
InternalTest ob = new InternalTest();
ob.x = 10; // доступно, потому что находится в том же файле
Console.WriteLine("Значение ob.x: " + ob.x);
}
}
В классе InternalTest поле х объявляется как internal. Это означает, что поле х доступно в самой программе, но, как показывает код класса InternalDemo, оно недоступно за пределами программы.
В этой главе рассматриваются три эффективных средства: динамическая идентификация типов, рефлексия и атрибуты. Динамическая идентификация типов представляет собой механизм, позволяющий определить тип данных во время выполнения программы. Рефлексия – это средство для получения сведений о типе данных. Используя эти сведения, можно конструировать и применять объекты во время выполнения. Это довольно эффективное средство, поскольку оно дает возможность расширять функции программы динамически, т.е. в процессе ее выполнения. Атрибут описывает характеристики определенного элемента программы на С#. Атрибуты можно, в частности, указать для классов, методов и полей. Во время выполнения программы разрешается опрашивать атрибуты для получения сведений о них. Для этой цели в атрибутах используется динамическая идентификация типов и рефлексия.
Динамическая идентификация типов (RTTI) позволяет определить тип объекта во время выполнения программы. Она оказывается полезной по целому ряду причин. В частности, по ссылке на базовый класс можно довольно точно определить тип объекта, доступного по этой ссылке. Динамическая идентификация типов позволяет также проверить заранее, насколько удачным будет исход приведения типов, предотвращая исключительную ситуацию в связи с неправильным приведением типов. Кроме того, динамическая идентификация типов является главной составляющей рефлексии.
Для поддержки динамической идентификации типов в C# предусмотрены три ключевых слова: is, as и typeof. Каждое из этих ключевых слов рассматривается далее по очереди.
Проверка типа с помощью оператора is
Конкретный тип объекта можно определить с помощью оператора is. Ниже приведена его общая форма:
выражение is тип
где выражение обозначает отдельное выражение, описывающее объект, тип которого проверяется. Если выражение имеет совместимый или такой же тип, как и проверяемый тип, то результат этой операции получается истинным, в противном случае – ложным. Так, результат будет истинным, если выражение имеет проверяемый тип в той или иной форме. В операторе is оба типа определяются как совместимые, если они одного и того же типа или если предусмотрено преобразование ссылок, упаковка или распаковка.
Ниже приведен пример применения оператора is.
// Продемонстрировать применение оператора is.
using System;
class A {}
class В : A {}
class UseIs {
static void Main() {
A a = new A();
В b = new В();
if (a is A)
Console.WriteLine(«а имеет тип A»);
if(b is A)
Console.WriteLine («b совместим с А, поскольку он производный от А»);
if(a is В)
Console.WriteLine(«Не выводится, поскольку а не производный от В»);
if(b is В)
Console.WriteLine(«В имеет тип В»);
if(a is object)
Console.WriteLine(«а имеет тип object»);
}
}
Вот к какому результату приводит выполнение этого кода.
а имеет тип А
b совместим с А, поскольку он производный от А
b имеет тип В
а имеет тип object
Большая часть выражений is в приведенном выше примере не требует пояснений, но два из них необходимо все же разъяснить. Прежде всего, обратите внимание на следующую строку кода.
if (b is А)
Console.WriteLine(«b совместим с А, поскольку он производный от А»);
Условный оператор if выполняется, поскольку b является объектом типа В, производным от типа А. Но обратное несправедливо. Так, если в строке кода
if(a is В)
Console.WriteLine(«Не выводится, поскольку а не производный от В»);
условный оператор if не выполняется, поскольку а является объектом типа А, не производного от типа В. Поэтому а не относится к типу В.
Применение оператора as
Иногда преобразование типов требуется произвести во время выполнения, но не генерировать исключение, если исход этого преобразования окажется неудачным, что вполне возможно при приведении типов. Для этой цели служит оператор as, имеющий следующую общую форму:
выражение as тип
где выражение обозначает отдельное выражение, преобразуемое в указанный тип. Если исход такого преобразования оказывается удачным, то возвращается ссылка на тип, а иначе – пустая ссылка. Оператор as может использоваться только для преобразования ссылок, идентичности, упаковки, распаковки.
В некоторых случаях оператор as может служить удобной альтернативой оператору is. В качестве примера рассмотрим следующую программу, в которой оператор is используется для предотвращения неправильного приведения типов.
// Использовать оператор is для предотвращения неправильного приведения типов.
using System;
class A { }
class В : A { }
class CheckCast {
static void Main() {
A a = new A();
В b = new В();
// Проверить, можно ли привести а к типу В.
if (a is В) // если да, то выполнить приведение типов
b = (В)a;
else // если нет, то пропустить приведение типов
b = null;
if (b == null)
Console.WriteLine(«Приведение типов b = (В) HE допустимо.»);
else
Console.WriteLine(«Приведение типов b = (В) допустимо.»);
}
}
Эта программа дает следующий результат.
Приведение типов b = (В) НЕ допустимо.
Как следует из результата выполнения приведенной выше программы, тип объекта а не совместим с типом В, и поэтому его приведение к типу В не допустимо и предотвращается в условном операторе if. Но такую проверку приходится выполнять в два этапа. Сначала требуется убедиться в обоснованности операции приведения типов, а затем выполнить ее. Оба этапа могут быть объединены в один с помощью оператора as, как демонстрирует приведенная ниже программа.
// Продемонстрировать применение оператора as.
using System;
class A {}
class В : A {}
class CheckCast {
static void Main() {
A a = new A();
В b = new В();
b = a as В; // выполнить приведение типов, если это возможно
if(b==null)
Console.WriteLine(«Приведение типов b = (В) НЕ допустимо.»);
else
Console.WriteLine(«Приведение типов b = (В) допустимо.»);
}
}
Эта программа дает прежний результат.
Приведение типов b = (В) НЕ допустимо.
В данном варианте программы в одном и том же операторе as сначала проверяется обоснованность операции приведения типов, а затем выполняется сама операция приведения типов, если она допустима.
Применение оператора typeof
Несмотря на всю свою полезность, операторы as и is проверяют лишь совместимость двух типов. Но зачастую требуется информация о самом типе. Для этой цели в C# предусмотрен оператор typeof. Он извлекает объект класса System.Туре для заданного типа. С помощью этого объекта можно определить характеристики конкретного типа данных. Ниже приведена общая форма оператора typeof:
typeof(тип)
где тип обозначает получаемый тип. Информация, описывающая тип, инкапсулируется в возвращаемом объекте класса Туре.
Получив объект класса Туре для заданного типа, можно извлечь информацию о нем, используя различные свойства, поля и методы, определенные в классе Туре. Класс Туре довольно обширен и содержит немало членов, поэтому его рассмотрение придется отложить до следующего раздела, посвященного рефлексии. Но в качестве краткого введения в этот класс ниже приведена программа, в которой используются три его свойства: FullName, IsClass и IsAbstract. Для получения полного имени типа служит свойство FullName. Свойство IsClass возвращает логическое значение true, если тип относится к классу. А свойство IsAbstract возвращает логическое значение true, если класс является абстрактным.
// Продемонстрировать применение оператора typeof.
using System;
using System.IO;
class UseTypeof {
static void Main() {
Type t = typeof(StreamReader);
Console.WriteLine(t.FullName);
if (t.IsClass)
Console.WriteLine(«Относится к классу.»);
if (t.IsAbstract)
Console.WriteLine(«Является абстрактным классом.»);
else
Console.WriteLine(«Является конкретным классом.»);
}
}
Эта программа дает следующий результат.
System.10.StreamReader
Относится к классу.
Является конкретным классом.
В данной программе сначала извлекается объект класса Туре, описывающий тип StreamReader. Затем выводится полное имя этого типа данных и определяется его принадлежность к классу, а далее – к абстрактному или конкретному классу.
Рефлексия – это средство, позволяющее получать сведения о типе данных. Термин рефлексия, или отражение, происходит от принципа действия этого средства: объект класса Туре отражает базовый тип, который он представляет. Для получения информации о типе данных объекту класса Туре делаются запросы, а он возвращает (отражает) обратно информацию, связанную с определяемым типом. Рефлексия является эффективным механизмом, поскольку она позволяет выявлять и использовать возможности типов данных, известные только во время выполнения.
Многие классы, поддерживающие рефлексию, входят в состав прикладного интерфейса .NET Reflection API, относящегося к пространству имен System.Reflection. Поэтому для применения рефлексии в код программы обычно вводится следующая строка.
using System.Reflection;
Класс System.Type – ядро подсистемы рефлексии
Класс System.Туре составляет ядро подсистемы рефлексии, поскольку он инкапсулирует тип данных. Он содержит многие свойства и методы, которыми можно пользоваться для получения информации о типе данных во время выполнения. Класс Туре является производным от абстрактного класса System.Reflection.MemberInfо.
В классе MemberInfо определены приведенные ниже свойства, доступные только для чтения.
Свойство – Описание
Type DeclaringType – Тип класса или интерфейса, в котором объявляется отражаемый член
MemberTypes MemberType – Тип члена. Это значение обозначает, является ли член полем, методом, свойством, событием или конструктором
int MetadataToken – Значение, связанное к конкретными метаданными
Module Module – Объект типа Module, представляющий модуль (исполняемый файл), в котором находится отражаемый тип
string Name – Имя типа
Type ReflectedType – Тип отражаемого объекта
Следует иметь в виду, что свойство MemberType возвращает тип MemberTypes – перечисление, в котором определяются значения, обозначающие различные типы членов. К их числу относятся следующие.
MemberTypes.Constructor
MemberTypes.Method
MemberTypes.Field
MemberTypes.Event
MemberTypes.Property
Следовательно, тип члена можно определить, проверив свойство MemberType. Так, если свойство MemberType имеет значение MemberTypes.Method, то проверяемый член является методом.
В класс Memberlnfо входят два абстрактных метода: GetCustomAttributes() и IsDefined(). Оба метода связаны с атрибутами. Первый из них получает список специальных атрибутов, имеющих отношение к вызывающему объекту, а второй устанавливает, определен ли атрибут для вызывающего метода. В версию .NET Framework Version 4.0 внедрен метод GetCustomAttributesData(), возвращающий сведения о специальных атрибутах. (Подробнее об атрибутах речь пойдет далее в этой главе.)
Класс Туре добавляет немало своих собственных методов и свойств к числу тех, что определены в классе Memberlnfо. В качестве примера ниже перечислен ряд наиболее часто используемых методов класса Туре.
Метод – Назначение
Constructorlnfо[] GetConstructors() – Получает список конструкторов для заданного типа
EventInfo[] GetEvents() – Получает список событий для заданного типа
Fieldlnfо[] GetFields() – Получает список полей для заданного типа
Type[] GetGenericArguments() – Получает список аргументов типа, связанных с закрыто сконструированным обобщенным типом, или же список параметров типа, если заданный тип определен как обобщенный. Для открыто сконструированного типа этот список может содержать как аргументы, так и параметры типа. (Более подробно обобщения рассматриваются в главе 18.)
MemberInfo[] GetMembers() – Получает список членов для заданного типа
MethodInfo[] GetMethods() – Получает список методов для заданного типа
PropertyInfo[] GetProperties() – Получает список свойств для заданного типа
Далее приведен ряд наиболее часто используемых свойств, доступных только для чтения и определенных в классе Туре.
Свойство – Назначение
Assembly Assembly – Получает сборку для заданного типа
TypeAttributes Attributes – Получает атрибуты для заданного типа
Type BaseType – Получает непосредственный базовый тип для заданного типа
string FullName – Получает полное имя заданного типа
bool IsAbstract – Истинно, если заданный тип является абстрактным
bool isArray – Истинно, если заданный тип является массивом
bool IsClass – Истинно, если заданный тип является классом
bool IsEnum – Истинно, если заданный тип является перечислением
bool IsGenericParameter – Истинно, если заданный тип является параметром обобщенного типа. (Более подробно обобщения рассматриваются в главе 18.)
bool IsGenericType – Истинно, если заданный тип является обобщенным. (Более подробно обобщения рассматриваются в главе 18.)
string Namespace – Получает пространство имен для заданного типа
С помощью методов и свойств класса Туре можно получить подробные сведения о типе данных во время выполнения программы. Это довольно эффективное средство. Ведь получив сведения о типе данных, можно сразу же вызвать его конструкторы и методы или воспользоваться его свойствами. Следовательно, рефлексия позволяет использовать код, который не был доступен во время компиляции.
Прикладной интерфейс Reflection API весьма обширен и поэтому не может быть полностью рассмотрен в этой главе. Ведь для этого потребовалась бы целая книга! Но прикладной интерфейс Reflection API имеет ясную логическую структуру, а следовательно, уяснив одну его часть, нетрудно понять и все остальное. Принимая во внимание это обстоятельство, в последующих разделах демонстрируются четыре основных способа применения рефлексии: получение сведений о методах, вызов методов, конструирование объектов и загрузка типов данных из сборок.
Получение сведений о методах
Имея в своем распоряжении объект класса Туре, можно получить список методов, поддерживаемых отдельным типом данных, используя метод GetMethods(). Ниже приведена одна из форм, подходящих для этой цели.
MethodInfo[] GetMethods()
Этот метод возвращает массив объектов класса Methodlnfо, которые описывают методы, поддерживаемые вызывающим типом. Класс MethodInfo находится в пространстве имен System.Reflection.
Класс MethodInfo является производным от абстрактного класса MethodBase, который в свою очередь наследует от класса MemberInfо. Это дает возможность пользоваться всеми свойствами и методами, определенными в этих трех классах. Например, для получения имени метода служит свойство Name. Особый интерес вызывают два члена класса MethodInfo: ReturnType и GetParameters().
Возвращаемый тип метода находится в доступном только для чтения свойстве ReturnType, которое является объектом класса Туре.
Метод GetParameters() возвращает список параметров, связанных с анализируемым методом. Ниже приведена его общая форма.
Parameterlnfо[] GetParameters();
Сведения о параметрах содержатся в объекте класса ParameterInfо. В классе Parameterlnfо определено немало свойств и методов, описывающих параметры. Особое значение имеют два свойства: Name – представляет собой строку, содержащую имя параметра, a ParameterType – описывает тип параметра, который инкапсулирован в объекте класса Туре.
В качестве примера ниже приведена программа, в которой рефлексия используется для получения методов, поддерживаемых классом MyClass. В этой программе выводится возвращаемый тип и имя каждого метода, а также имена и типы любых параметров, которые может иметь каждый метод.
// Анализ методов с помощью рефлексии.
using System;
using System.Reflection;
class MyClass {
int x;
int y;
public MyClass(int i, int j) {
x = i;
y = j;
}
public int Sum() {
return x + y;
}
public bool IsBetween(int i) {
if (x < i && i < y) return true;
else return false;
}
public void Set(int a, int b) {
x = a;
y = b;
}
public void Set(double a, double b) {
x = (int)a; y = (int)b;
}
public void Show() {
Console.WriteLine(« x: {0}, у: {1}», x, y);
}
}
class ReflectDemo {
static void Main() {
Type t = typeof(MyClass); // получить объект класса Type,
// представляющий класс MyClass
Console.WriteLine("Анализ методов, определенных " +
"в классе " + t.Name);
Console.WriteLine();
Console.WriteLine("Поддерживаемые методы: ");
MethodInfo[] mi = t.GetMethods();
// Вывести методы, поддерживаемые в классе MyClass.
foreach (MethodInfo m in mi) {
// Вывести возвращаемый тип и имя каждого метода.
Console.Write(" " + m.ReturnType.Name + " " + m.Name + "(");
// Вывести параметры.
ParameterInfo[] pi = m.GetParameters();
for (int i = 0; i < pi.Length; i++) {
Console.Write(pi[i].ParameterType.Name + " " + pi[i].Name);
if (i + 1 < pi.Length) Console.Write(", ");
}
Console.WriteLine(")");
Console.WriteLine();
}
}
}
Эта программа дает следующий результат.
Поддерживаемые методы:
Int32 Sum()
Boolean IsBetween (Int32 i)
Void Set(Int32 a, Int32 b)
Void Set (Double a, Double b)'
Void Show()
String ToString()
Boolean Equals(Object ob j )
Int32 GetHashCode()
Type GetType()
Как видите, помимо методов, определенных в классе MyClass, в данной программе выводятся также методы, определенные в классе object, поскольку все типы данных в C# наследуют от класса object. Кроме того, в качестве имен типов указываются имена структуры .NET. Обратите также внимание на то, что метод Set() выводится дважды, поскольку он перегружается. Один из его вариантов принимает аргументы типа int, а другой – аргументы типа double.
Рассмотрим эту программу более подробно. Прежде всего следует заметить, что в классе MyClass определен открытый конструктор и ряд открытых методов, в том числе и перегружаемый метод Set().
Объект класса Туре, представляющий класс MyClass, создается в методе Main() в следующей строке кода.
Type t = typeof(MyClass); // получить объект класса Туре,
// представляющий класс MyClass
Напомним, что оператор typeof возвращает объект класса Туре, представляющий конкретный тип данных (в данном случае – класс MyClass).
С помощью переменной t и прикладного интерфейса Reflection API в данной программе затем выводятся сведения о методах, поддерживаемых в классе MyClass. Для этого в приведенной ниже строке кода сначала выводится список соответствующих методов.
MethodInfo[] mi = t.GetMethods();
Затем в цикле foreach организуется обращение к элементам массива mi. На каждом шаге этого цикла выводится возвращаемый тип, имя и параметры отдельного метода, как показано в приведенном ниже фрагменте кода.
foreach(MethodInfo m in mi) {
// Вывести возвращаемый тип и имя каждого метода.
Console.Write(" " + m.ReturnType.Name + " " + m.Name + "(");
// Вывести параметры.
ParameterInfo[] pi = m.GetParameters();
for(int i=0; i < pi.Length; i++) {
Console.Write(pi[i].ParameterType.Name + " " + pi[i].Name);
if(i+1 < pi.Length)
Console.Write(", ");
}
}
В этом фрагменте кода параметры, связанные с каждым методом, сначала создаются с помощью метода GetParameters() и сохраняются в массиве pi. Затем в цикле for происходит обращение к элементам массива pin выводится тип и имя каждого параметра. Самое главное, что все эти сведения создаются динамически во время выполнения программы, не опираясь на предварительную осведомленность о классе MyClass.
Вторая форма метода GetMethods()
Существует вторая форма метода GetMethods(), позволяющая указывать различные флажки для отфильтровывания извлекаемых сведений о методах. Ниже приведена эта общая форма метода GetMethods().
MethodInfo[] GetMethods(BindingFlags флажки)
В этом варианте создаются только те методы, которые соответствуют указанным критериям. BindingFlags представляет собой перечисление. Ниже перечислен ряд наиболее часто используемых его значений.
Значение – Описание
DeclaredOnly – Извлекаются только те методы, которые определены в заданном классе. Унаследованные методы в извлекаемые сведения не включаются
Instance – Извлекаются методы экземпляра
NonPublic – Извлекаются методы, не являющиеся открытыми
Public – Извлекаются открытые методы
Static – Извлекаются статические методы
Два или несколько флажков можно объединить с помощью логической операции ИЛИ. Но как минимум флажок Instance или Static следует указывать вместе с флажком Public или NonPublic. В противном случае не будут извлечены сведения ни об одном из методов.
Форма BindingFlags метода GetMethods() чаще всего применяется для получения списка методов, определенных в классе, без дополнительного извлечения наследуемых методов. Это особенно удобно в тех случаях, когда требуется исключить получение сведений о методах, определяемых в классе конкретного объекта. В качестве примера попробуем выполнить следующую замену в вызове метода GetMethods() из предыдущей программы.
// Теперь получаются сведения только о тех методах,
// которые объявлены в классе MyClass.
MethodInfo[] mi = t.GetMethods(BindingFlags.DeclaredOnly |
BindingFlags.Instance |
BindingFlags.Public);
После этой замены программа дает следующий результат.
Анализ методов, определенных в классе MyClass
Поддерживаемые методы:
Int32 Sum()
Boolean IsBetween(Int32 i)
Void Set(Int32 a, Int32 b)
Void Set(Double a, Double b)
Void Show()
Как видите, теперь выводятся только те методы, которые явно определены в классе MyClass.
Вызов методов с помощью рефлексии
Как только методы, поддерживаемые определенным типом данных, становятся известны, их можно вызывать. Для этой цели служит метод Invoke(), входящий в состав класса Methodlnfо. Ниже приведена одна из форм этого метода:
object Invoke(object obj, object[] parameters)
где obj обозначает ссылку на объект, для которого вызывается метод. Для вызова статических методов (static) в качестве параметра obj передается пустое значение (null). Любые аргументы, которые должны быть переданы методу, указываются в массиве parameters. Если же аргументы не нужны, то вместо массива parameters указывается пустое значение (null). Кроме того, количество элементов массива parameters должно точно соответствовать количеству передаваемых аргументов. Так, если требуется передать два аргумента, то массив parameters должен состоять из двух элементов, но не из трех или четырех. Значение, возвращаемое вызываемым методом, передается методу Invoke(), который и возвращает его.
Для вызова конкретного метода достаточно вызвать метод Invoke() для экземпляра объекта типа Methodlnfо, получаемого при вызове метода GetMethods(). Эта процедура демонстрируется в приведенном ниже примере программы.
// Вызвать методы с помощью рефлексии.
using System;
using System.Reflection;
class MyClass {
int x;
int y;
public MyClass(int i, int j) {
x = i;
y = j;
}
public int Sum() {
return x + y;
}
public bool IsBetween(int i) {
if ((x < i) && (i < y)) return true;
else return false;
}
public void Set(int a, int b) {
Console.Write("В методе Set (int, int). ");
x = a;
y = b;
Show();
}
// Перегрузить метод Set.
public void Set(double a, double b) {
Console.Write("В методе Set(double, double). ");
x = (int)a;
y = (int)b;
Show();
}
public void Show() {
Console.WriteLine(«Значение x: {0}, значение у: {1}», x, y);
}
}
class InvokeMethDemo {
static void Main() {
Type t = typeof(MyClass);
MyClass reflectOb = new MyClass(10, 20);
int val;
Console.WriteLine("Вызов методов, определенных в классе " + t.Name);
Console.WriteLine();
MethodInfo[] mi = t.GetMethods();
// Вызвать каждый метод,
foreach (MethodInfo m in mi) {
// Получить параметры.
ParameterInfo[] pi = m.GetParameters();
if (m.Name.CompareTo(«Set») == 0 && pi[0].ParameterType == typeof(int)) {
object[] args = new object[2];
args[0] = 9;
args[1] = 18;
m.Invoke(reflectOb, args);
}
else if (m.Name.CompareTo(«Set») == 0 &&
pi[0].ParameterType == typeof(double)) {
object[] args = new object[2];
args[0] = 1.12;
args[1] = 23.4;
m.Invoke(reflectOb, args);
}
else if (m.Name.CompareTo(«Sum») == 0) {
val = (int)m.Invoke(reflectOb, null);
Console.WriteLine("Сумма равна " + val);
}
else if (m.Name.CompareTo(«IsBetween») == 0) {
object[] args = new object[1];
args[0] = 14;
if ((bool)m.Invoke(reflectOb, args))
Console.WriteLine(«Значение 14 находится между x и у»);
}
else if (m.Name.CompareTo(«Show») == 0) {
m.Invoke(reflectOb, null);
}
}
}
}
Вот к какому результату приводит выполнение этой программы.
Вызов методов, определенных в классе MyClass
Сумма равна 30
Значение 14 находится между х и у
В методе Set (int, int). Значение х: 9, значение у: 18
В методе Set(double, double). Значение х: 1, значение у: 23
Значение х: 1, значение у: 23
Рассмотрим подробнее порядок вызова методов. Сначала создается список методов. Затем в цикле foreach извлекаются сведения об их параметрах. Далее каждый метод вызывается с указанием соответствующего типа и числа аргументов в последовательном ряде условных операторов if/else. Обратите особое внимание на перегрузку метода Set() в приведенном ниже фрагменте кода.
if(m.Name.CompareTo(«Set»)==0 &&
pi(0].ParameterType == typeof(int)) {
object[] args = new object[2];
args[0] = 9;
args[l] = 18;
m.Invoke(reflectOb, args);
}
else if(m.Name.CompareTo(«Set»)==0 &&
pi[0].ParameterType == typeof(double)) {
object[] args = new object[2];
args[0] = 1.12;
args[1 ] = 23.4;
m.Invoke(reflectOb, args);
}
Если имя метода – Set, то проверяется тип первого параметра, чтобы выявить конкретный вариант этого метода. Так, если это метод Set(int, int), то его аргументы загружаются в массив args. В противном случае используются аргументы типа double.
Получение конструкторов конкретного типа
В предыдущем примере при вызове методов, определенных в классе MyClass, преимущества рефлексии не использовались, поскольку объект типа MyClass создавался явным образом. В таком случае было бы намного проще вызвать для него методы обычным образом. Но сильные стороны рефлексии проявляются наиболее заметно лишь в том случае, если объект создается динамически во время выполнения. И для этого необходимо получить сначала список конструкторов, а затем экземпляр объекта заданного типа, вызвав один из этих конструкторов. Такой механизм позволяет получать во время выполнения экземпляр объекта любого типа, даже не указывая его имя в операторе объявления.
Конструкторы конкретного типа получаются при вызове метода GetConstructors() для объекта класса Туре. Ниже приведена одна из наиболее часто используемых форм этого метода.
ConstructorInfo[] GetConstructors()
Метод GetConstructors() возвращает массив объектов класса ConstructorInfo, описывающих конструкторы.
Класс ConstructorInfo является производным от абстрактного класса MethodBase, который в свою очередь наследует от класса Memberlnfо. В нем также определен ряд собственных методов. К их числу относится интересующий нас метод GetConstructors(), возвращающий список параметров, связанных с конструктором. Этот метод действует таким же образом, как и упоминавшийся ранее метод GetParameters(), определенный в классе MethodInfо.
Как только будет обнаружен подходящий конструктор, для создания объекта вызывается метод Invoke(), определенный в классе ConstructorInfo. Ниже приведена одна из форм этого метода.
object Invoke(object[] parameters)
Любые аргументы, которые требуется передать методу, указываются в массиве parameters. Если же аргументы не нужны, то вместо массива parameters указывается пустое значение (null). Но в любом случае количество элементов массива parameters должно совпадать с количеством передаваемых аргументов, а типы аргументов – с типами параметров. Метод Invoke() возвращает ссылку на сконструированный объект.
В приведенном ниже примере программы рефлексия используется для создания экземпляра объекта класса MyClass.
