Язык программирования C#9 и платформа .NET5

Возможность полного описания типов (классов, интерфейсов, структур, перечислений и делегатов) с помощью метаданных является ключевым элементом платформы .NET Core. Многим технологиям .NET Core, таким как сериализация объектов, требуется способность выяснения формата типов во время выполнения. Кроме того, межъязыковое взаимодействие, многие службы компилятора и средства IntelliSense в IDE-среде опираются на конкретное описание типа.

Вспомните, что утилита

ildasm.exe

CarLibrary

METAINFO

CarLibrary.il

// ==== M E T A I N F O ===

// ===========================================================

// ScopeName : CarLibrary.dll

// MVID    : {598BC2B8-19E9-46EF-B8DA-672A9E99B603}

// ===========================================================

// Global functions

// -------------------------------------------------------

//

// Global fields

// -------------------------------------------------------

//

// Global MemberRefs

// -------------------------------------------------------

//

// TypeDef #1

// -------------------------------------------------------

//  TypDefName: CarLibrary.Car

//  Flags   : [Public] [AutoLayout] [Class] [Abstract] [AnsiClass] [BeforeFieldInit]

//  Extends  : [TypeRef] System.Object

//  Field #1

//  -------------------------------------------------------

//   Field Name: value__

//   Flags   : [Private]

//   CallCnvntn: [FIELD]

//   Field type:  String

//

Как видите, утилита

ildasm.exe

CarLibrary.dll

CarLibrary.dll

На заметку! Не стоит слишком глубоко вникать в синтаксис каждого фрагмента метаданных .NET Core, приводимого в нескольких последующих разделах. Важно усвоить, что метаданные .NET Core являются исключительно описательными и учитывают каждый внутренне определенный (и внешне ссылаемый) тип, который найден в имеющейся кодовой базе.

Просмотр (частичных) метаданных для перечисления EngineStateEnum

Каждый тип, определенный внутри текущей сборки, документируется с применением маркера

TypeDef #n

TypeDef

TypeRef #n

TypeRef

TypeRef

TypeDef

TypeRef

ildasm.exe

В случае сборки

CarLibrary.dll

TypeDef

CarLibrary.EngineStateEnum

TypeDef

TypeDef

// TypeDef #2

// -------------------------------------------------------

//  TypDefName: CarLibrary.EngineStateEnum

//  Flags   : [Public] [AutoLayout] [Class] [Sealed] [AnsiClass]

//  Extends  : [TypeRef] System.Enum

//  Field #1

//  -------------------------------------------------------

//   Field Name: value__

//   Flags   : [Public] [SpecialName] [RTSpecialName]

//   CallCnvntn: [FIELD]

//   Field type:  I4

//

//  Field #2

//  -------------------------------------------------------

//   Field Name: EngineAlive

//   Flags   : [Public] [Static] [Literal] [HasDefault]

//   DefltValue: (I4) 0

//   CallCnvntn: [FIELD]

//   Field type:  ValueClass CarLibrary.EngineStateEnum

//

...

Маркер

TypDefName

CarLibrary.EngineStateEnum

Extends

System.Enum

Field #n

На заметку! Хотя это выглядит как опечатка, в

TypDefName

е

Просмотр (частичных) метаданных для типа Car

Ниже показана часть метаданных класса

Car

• как поля определяются в терминах метаданных .NET Core;

• как методы документируются посредством метаданных .NET Core;

• как автоматическое свойство представляется в метаданных .NET Core.

// TypeDef #1

// -------------------------------------------------------

//  TypDefName: CarLibrary.Car

//  Flags   : [Public] [AutoLayout] [Class] [Abstract] [AnsiClass] [BeforeFieldInit]

//  Extends  : [TypeRef] System.Object

//  Field #1

//  -------------------------------------------------------

//   Field Name: k__BackingField

//   Flags   : [Private]

//   CallCnvntn: [FIELD]

//   Field type:  String

...

  Method #1

-------------------------------------------------------

   MethodName: get_PetName

   Flags    : [Public] [HideBySig] [ReuseSlot] [SpecialName]

   RVA     : 0x000020d0

   ImplFlags  : [IL] [Managed]

   CallCnvntn: [DEFAULT]

   hasThis

   ReturnType: String

   No arguments.

...

//  Method #2

//  -------------------------------------------------------

//   MethodName: set_PetName

//   Flags   : [Public] [HideBySig] [ReuseSlot] [SpecialName]

//   RVA    : 0x00002058

//   ImplFlags : [IL] [Managed]

//   CallCnvntn: [DEFAULT]

//   hasThis

//   ReturnType: Void

//   1 Arguments

//    Argument #1:  String

//   1 Parameters

//    (1) ParamToken : Name : value flags: [none]

...

//  Property #1

//  -------------------------------------------------------

//   Prop.Name : PetName

//   Flags   : [none]

//   CallCnvntn: [PROPERTY]

//   hasThis

//   ReturnType: String

//   No arguments.

//   DefltValue:

//   Setter   : set_PetName

//   Getter   : get_PetName

//   0 Others

...

Прежде всего, метаданные класса

Car

(System.Object

[Public]

[Abstract]

Car

Обратите внимание, что автоматическое свойство дает в результате сгенерированное компилятором закрытое поддерживающее поле (по имени

k_BackingField

get_PetName()

set_PetName()

Setter

Getter

Исследование блока TypeRef

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

Car

EnginestateEnum

CarLibrary.dll

System.Enum

TypeRef

// TypeRef #19

// -------------------------------------------------------

// Token:       0x01000013

// ResolutionScope:  0x23000001

// TypeRefName:    System.Enum

Документирование определяемой сборки

В файле

CarLibrary.il

Assembly

CarLibrary.dll

// Assembly

// -------------------------------------------------------

//  Token: 0x20000001

//  Name : CarLibrary

//  Public Key   :

//  Hash Algorithm : 0x00008004

//  Version: 1.0.0.1

//  Major Version: 0x00000001

//  Minor Version: 0x00000000

//  Build Number: 0x00000000

//  Revision Number: 0x00000001

//  Locale: 

//  Flags : [none] (00000000)

Документирование ссылаемых сборок

В дополнение к маркеру

Assembly

TypeDef

TypeRef

AssemblyRef #n

System.Runtime

AssemblyRef

System.Runtime

// AssemblyRef #1 (23000001)

// -------------------------------------------------------

//  Token: 0x23000001

//  Public Key or Token: b0 3f 5f 7f 11 d5 0a 3a

//  Name: System.Runtime

//  Version: 5.0.0.0

//  Major Version: 0x00000005

//  Minor Version: 0x00000000

//  Build Number: 0x00000000

//  Revision Number: 0x00000000

//  Locale: 

//  HashValue Blob:

//  Flags: [none] (00000000) 

Документирование строковых литералов

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

User Strings

// User Strings

// -------------------------------------------------------

// 70000001 : (23) L"CarLibrary Version 2.0!"

// 70000031 : (13) L"Quiet time..."

// 7000004d : (11) L"Jamming {0}"

// 70000065 : (32) L"Eek! Your engine block exploded!"

// 700000a7 : (34) L"Ramming speed! Faster is better..."

На заметку! Всегда помните о том, что все строки явным образом документируются в метаданных сборки, как продемонстрировано в представленном выше листинге метаданных. Это может привести к крупным последствиям в плане безопасности, если вы применяете строковые литералы для хранения паролей, номеров кредитных карт или другой конфиденциальной информации.

У вас может возникнуть вопрос о том, каким образом задействовать такую информацию в разрабатываемых приложениях (в лучшем сценарии) или зачем вообще заботиться о метаданных (в худшем сценарии). Чтобы получить ответ, необходимо ознакомиться со службами рефлексии .NET Core. Следует отметить, что полезность рассматриваемых далее тем может стать ясной только ближе к концу главы, а потому наберитесь терпения.

На заметку! В разделе

METAINFO

CustomAttribute

В мире .NET Core рефлексией называется процесс обнаружения типов во время выполнения. Службы рефлексии дают возможность получать программно ту же самую информацию о метаданных, которую генерирует утилита

ildasm.exe

*.dll

*.ехе

Как и любое другое пространство имен,

System.Reflection

System.Runtime.dll

System.Reflection

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

System.Reflection

System.Туре

Класс System.Туре

В классе

System.Туре

System.Reflection

Туре.GetMethods()

MethodInfo

Type.GetFields()

FieldInfo

System.Туре

System.Туре

Получение информации о типе с помощью System.Object.GetType()

Экземпляр класса

Туре

Туре

new

Туре

System.Object

GetType()

Туре

// Получить информацию о типе с применением экземпляра SportsCar.

SportsCar sc = new SportsCar();

Type t = sc.GetType();

Очевидно, что такой подход будет работать, только если подвергаемый рефлексии тип (

SportsCar

ildasm.exe

System.Object.GetType()

ildasm.exe

Получение информации о типе с помощью typeof()

Следующий способ получения информации о типе предполагает применение операции

typeof

// Получить информацию о типе с использованием операции typeof.

Type t = typeof(SportsCar);

В отличие от метода

System.Object.GetType()

typeof

typeof

Получение информации о типе с помощью System.Туре.GetType()

Для получения информации о типе в более гибкой манере можно вызывать статический метод

GetType()

System.Туре

Type.GetType()

System.String

На заметку! Когда речь идет о том, что при вызове метода

Туре.GetType()

Метод

Туре.GetType()

// Получить информацию о типе с использованием статического

// метода Туре.GetType().

// (Не генерировать исключение, если тип SportsCar не удается найти,

// и игнорировать регистр символов.)

Type t = Type.GetType("CarLibrary.SportsCar", false, true);

В приведенном выше примере обратите внимание на то, что в строке, передаваемой методу

GetType()

// Получить информацию о типе из внешней сборки.

Type t = Type.GetType("CarLibrary.SportsCar, CarLibrary");

Кроме того, в передаваемой методу

GetType()

+

SpyOptions

JamesBondCar

// Получить информацию о типе для вложенного перечисления

// внутри текущей сборки.

Type t = Type.GetType("CarLibrary.JamesBondCar+SpyOptions");

Чтобы ознакомиться с базовым процессом рефлексии (и выяснить полезность класса

System.Туре

MyTypeViewer

System.Runtime.dll

MyTypeViewer

System

System.Reflection

System.Linq

// Эти пространства имен должны импортироваться для выполнения

// любой рефлексии!

using System;

using System.Linq;

using System.Reflection;

Рефлексия методов

В класс

Program

System.Туре

void

ListMethods()

Туре.GetMethods()

System.Reflection.MethodInfo

foreach

// Отобразить имена методов в типе.

static void ListMethods(Type t)

{

  Console.WriteLine("***** Methods *****");

  MethodInfo[] mi = t.GetMethods();

  foreach(MethodInfo m in mi)

  {

   Console.WriteLine("->{0}", m.Name);

  }

  Console.WriteLine();

}

Здесь просто выводится имя метода с применением свойства

MethodInfo.Name

MethodInfo

MethodInfo

ListMethods()

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

using System.Linq;

static void ListMethods(Type t)

{

  Console.WriteLine("***** Methods *****");

  var methodNames = from n in t.GetMethods() select n.Name;

  foreach (var name in methodNames)

  {

   Console.WriteLine("->{0}", name);

  }

  Console.WriteLine();

}

Рефлексия полей и свойств

Реализация метода

ListFields()

Туре

GetFields()

FieldInfо

// Отобразить имена полей в типе.

static void ListFields(Type t)

{

  Console.WriteLine("***** Fields *****");

   var fieldNames = from f in t.GetFields() select f.Name;

  foreach (var name in fieldNames)

  {

   Console.WriteLine("->{0}", name);

  }

  Console.WriteLine();

}

Логика для отображения имен свойств типа аналогична:

// Отобразить имена свойств в типе.

static void ListProps(Type t)

{

  Console.WriteLine("***** Properties *****");

  var propNames = from p in t.GetProperties() select p.Name;

  foreach (var name in propNames)

  {

   Console.WriteLine("->{0}", name);

  }

  Console.WriteLine();

}

Рефлексия реализованных интерфейсов

Следующим создается метод по имени

ListInterfaces()

GetInterfaces()

System.Туре

// Отобразить имена интерфейсов, которые реализует тип.

static void ListInterfaces(Type t)

{

  Console.WriteLine("***** Interfaces *****");

  var ifaces = from i in t.GetInterfaces() select i;

  foreach(Type i in ifaces)

  {

   Console.WriteLine("->{0}", i.Name);

  }

}

На заметку! Имейте в виду, что большинство методов "получения" в

System.Туре

GetMethods()

GetInterfaces()

BindingFlags

Отображение разнообразных дополнительных деталей

В качестве последнего, но не менее важного действия, осталось реализовать финальный вспомогательный метод, который будет отображать различные статистические данные о входном типе (является ли он обобщенным, какой его базовый класс, запечатан ли он и т.п.):

// Просто ради полноты картины.

static void ListVariousStats(Type t)

{

  Console.WriteLine("***** Various Statistics *****");

  Console.WriteLine("Base class is: {0}", t.BaseType);     // Базовый класс

  Console.WriteLine("Is type abstract? {0}", t.IsAbstract);  // Абстрактный?

  Console.WriteLine("Is type sealed? {0}", t.IsSealed);    // Запечатанный?

  Console.WriteLine("Is type generic? {0}", t.IsGenericTypeDefinition); // Обобщенный?

  Console.WriteLine("Is type a class type? {0}", t.IsClass); // Тип класса?

  Console.WriteLine();

}

Добавление операторов верхнего уровня

Операторы верхнего уровня в файле

Program.cs

Туре.GetType()

System.Туре

Console.WriteLine("***** Welcome to MyTypeViewer *****");

string typeName = "";

do

{

  Console.WriteLine("\nEnter a type name to evaluate");

           // Пригласить ввести имя типа.

  Console.Write("or enter Q to quit: "); // или Q для завершения

  // Получить имя типа

  typeName = Console.ReadLine();

  // Пользователь желает завершить программу?

  if (typeName.Equals("Q",StringComparison.OrdinalIgnoreCase))

  {

   break;

  }

  // Попробовать отобразить информацию о типе.

  try

  {

   Type t = Type.GetType(typeName);

   Console.WriteLine("");

   ListVariousStats(t);

   ListFields(t);

   ListProps(t);

   ListMethods(t);

   ListInterfaces(t);

  }

  catch

  {

   Console.WriteLine("Sorry, can't find type");

  }

} while (true);

В настоящий момент приложение

MyTypeViewer.exe

Туре.GetType()

•

System.Int32

•

System.Collections.ArrayList

•

System.Threading.Thread

•

System.Void

•

System.10.BinaryWriter

•

System.Math

•

MyTypeViewer.Program

Ниже показан частичный вывод при указании

System.Math

***** Welcome to MyTypeViewer *****

Enter a type name to evaluate

or enter Q to quit: System.Math

***** Various Statistics *****

Base class is: System.Object

Is type abstract? True

Is type sealed? True

Is type generic? False

Is type a class type? True

***** Fields *****

->PI

->E

***** Properties *****

***** Methods *****

->Acos

->Asin

->Atan

->Atan2

->Ceiling

->Cos

...

Рефлексия статических типов

Если вы введете

System.Console

t

null

Туре.GetType(typeName)

typeof

System.Туре

System.Console

Type t = Type.GetType(typeName);

if (t == null && typeName.Equals("System.Console",

   StringComparison.OrdinalIgnoreCase))

{

  t = typeof(System.Console);

}

Рефлексия обобщенных типов

При вызове

Type.GetType()

'

System.Collections.Generic.List

System.Collections.Generic.List`1

Здесь указано числовое значение

1

List

Dictionary

2

System.Collections.Generic.Dictionary`2

Рефлексия параметров и возвращаемых значений методов

Пока все хорошо! Далее мы внесем небольшое усовершенствование в текущее приложение. В частности, вы обновите вспомогательную функцию

ListMethods()

MethodInfo

ReturnType

GetParameters()

foreach

static void ListMethods(Type t)

{

  Console.WriteLine("***** Methods *****");

  MethodInfo[] mi = t.GetMethods();

  foreach (MethodInfo m in mi)

  {

   // Получить возвращаемый тип.

   string retVal = m.ReturnType.FullName;

   string paramInfo = "( ";

   // Получить параметры.

   foreach (ParameterInfo pi in m.GetParameters())

   {

    paramInfo += string.Format("{0} {1} ", pi.ParameterType, pi.Name);

   }

   paramInfo += " )";

   Теперь выведите на экран базовый метод sig.

   Console.WriteLine("->{0} {1} {2}", retVal, m.Name, paramInfo);

  }

  Console.WriteLine();

}

Если вы запустите это обновленное приложение, вы обнаружите, что методы данного типа стали гораздо более подробными. Если вы введете в программу в качестве входных данных вашего доброго друга

System.Object

***** Methods *****

->System.Type GetType (  )

->System.String ToString (  )

->System.Boolean Equals ( System.Object obj  )

->System.Boolean Equals ( System.Object objA System.Object objB  )

->System.Boolean ReferenceEquals ( System.Object objA System.Object objB  )

->System.Int32 GetHashCode (  )

Текущая реализация

ListMethods()

System.Reflection

XXXInfo

MethodInfo

PropertyInfo

EventInfo

ToString()

ListMethods()

MethodInfo

Name

static void ListMethods(Type t)

{

  Console.WriteLine("***** Methods *****");

  var methodNames = from n in t.GetMethods() select n;

  foreach (var name in methodNames)

  {

   Console.WriteLine("->{0}", name);

  }

  Console.WriteLine();

}

Интересный материал, да? Очевидно, что пространство имен

System.Reflection

System.Type

MyTypeViewer

Тем не менее, на данном этапе вы создали (в некоторой степени способный) браузер объектов. Основное ограничение в этом конкретном примере заключается в том, что у вас нет возможности отразить не только текущую сборку (

MyTypeViewer

mscorlib.dll

Динамическая загрузка сборок

Бывают случаи, когда вам нужно программно загрузить сборки на лету, даже если нет записи о данной сборке в манифесте. Формально говоря, акт загрузки внешних сборок по требованию называется динамической загрузкой.

System.Reflection

Assembly

Assembly

Assembly

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

ExternalAssemblyReflector

DisplayTypes()

using System;

using System.Reflection;

using System.IO; // Для определения FileNotFoundException.

Console.WriteLine("***** External Assembly Viewer *****");

string asmName = "";

Assembly asm = null;

do

{

  Console.WriteLine("\nEnter an assembly to evaluate");

           // Пригласить ввести имя сборки.

  Console.Write("or enter Q to quit: "); // или Q для завершения

  // Получить имя сборки.

  asmName = Console.ReadLine();

  // Пользователь желает завершить программу?

  if (asmName.Equals("Q",StringComparison.OrdinalIgnoreCase))

  {

   break;

  }

  // Попробовать загрузить сборку.

  try

  {

   asm = Assembly.LoadFrom(asmName);

   DisplayTypesInAsm(asm);

  }

  catch

  {

   Console.WriteLine("Sorry, can't find assembly.");

         // Сборка не найдена. 

  }

} while (true);

static void DisplayTypesInAsm(Assembly asm)

{

  Console.WriteLine("\n***** Types in Assembly *****");

  Console.WriteLine("->{0}", asm.FullName);

  Type[] types = asm.GetTypes();

  foreach (Type t in types)

  {

   Console.WriteLine("Type: {0}", t);

  }

  Console.WriteLine("");

}

Если вы хотите проводить рефлексию по

CarLibrary.dll

ExternalAssemblyReflector

CarLibrary.dll

\bin\Debug\net5.0

CarLibrary

***** External Assembly Viewer *****

Enter an assembly to evaluate

or enter Q to quit: CarLibrary

***** Types in Assembly *****

->CarLibrary, Version=1.0.0.1, Culture=neutral, PublicKeyToken=null

Type: CarLibrary.MyInternalClass

Type: CarLibrary.EngineStateEnum

Type: CarLibrary.MusicMedia

Type: CarLibrary.Car

Type: CarLibrary.MiniVan

Type: CarLibrary.SportsCar

Метод

LoadFrom()

С:\MyApp\MyAsm.dll

CarLibrary.dll

С:\MyCode

С:\MyCode\CarLibrary

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

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

new

Activator

Класс System.Activato

Класс

System.Activator

Activator.Createlnstance()

CreateInstance()

Туре

Создайте новый проект консольного приложения по имени

LateBindingApp

using

System.IO

System.Reflection

Program.cs

using System;

using System.IO;

using System.Reflection;

// Это приложение будет загружать внешнюю сборку и

// создавать объект, используя позднее связывание.

Console.WriteLine("***** Fun with Late Binding *****");

// Попробовать загрузить локальную копию CarLibrary.

Assembly a = null;

try

{

  a = Assembly.LoadFrom("CarLibrary");

}

catch(FileNotFoundException ex)

{

  Console.WriteLine(ex.Message);

  return;

}

if(a != null)

{

  CreateUsingLateBinding(a);

}

Console.ReadLine();

static void CreateUsingLateBinding(Assembly asm)

{

  try

  {

   // Получить метаданные для типа MiniVan.

   Type miniVan = asm.GetType("CarLibrary.MiniVan");

   // Создать экземпляр MiniVan на лету.

   object obj = Activator.CreateInstance(miniVan);

   Console.WriteLine("Created a {0} using late binding!", obj);

  }

  catch(Exception ex)

  {

   Console.WriteLine(ex.Message);

  }

}

Перед запуском нового приложения понадобится вручную скопировать файл

CarLibrary.dll

bin\Debug\net5.0

На заметку! Не добавляйте ссылку на

CarLibrary.dll

Обратите внимание, что метод

Activator.Createlnstance()

System.Object

MiniVan

obj

MiniVan

// Привести к типу MiniVan, чтобы получить доступ к его членам?

// Нет! Компилятор сообщит об ошибке!

object obj = (MiniVan)Activator.CreateInstance(minivan);

Однако из-за того, что в приложение не была добавлена ссылка на сборку

CarLibrary.dll

using

CarLibrary

MiniVan

MiniVan

System.Object

Вызов методов без параметров

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

TurboBoost()

MiniVan

MethodInf

TurboBoost()

Туре.GetMethod()

MethodInfо

MiniVan.TurboBoost()

Invoke()

MethodInfо.Invoke()

MethodInfо

System.Object

Поскольку метод

TurboBoost()

null

CreateUsingLateBinding()

static void CreateUsingLateBinding(Assembly asm)

{

  try

  {

   // Получить метаданные для типа Minivan.

   Type miniVan = asm.GetType("CarLibrary.MiniVan");

   // Создать объект MiniVan на лету.

   object obj = Activator.CreateInstance(miniVan);

   Console.WriteLine($"Created a {obj} using late binding!");

   // Получить информацию о TurboBoost.

   MethodInfo mi = miniVan.GetMethod("TurboBoost");

   // Вызвать метод (null означает отсутствие параметров).

   mi.Invoke(obj, null);

  }

  catch(Exception ex)

  {

   Console.WriteLine(ex.Message);

  }

}

Теперь после запуска приложения вы увидите в окне консоли сообщение о том, что двигатель вышел из строя (

"Eek! Your engine block exploded!"

Вызов методов с параметрами

Когда позднее связывание нужно применять для вызова метода, ожидающего параметры, аргументы потребуется упаковать в слабо типизированный массив

object

Car

public void TurnOnRadio(bool musicOn, MusicMediaEnum mm)

   => MessageBox.Show(musicOn ? $"Jamming {mm}" : "Quiet time...");

Метод

TurnOnRadio()

public enum MusicMediaEnum

{

  musicCd,   // 0

  musicTape,  // 1

  musicRadio, // 2

  musicMp3   // 3

}

Ниже приведен код нового метода класса

Program

TurnOnRadio()

MusicMediaEnum

static void InvokeMethodWithArgsUsingLateBinding(Assembly asm)

{

  try

  {

   // Получить описание метаданных для типа SportsCar.

   Type sport = asm.GetType("CarLibrary.SportsCar");

   // Создать объект типа SportsCar.

   object obj = Activator.CreateInstance(sport);

   // Вызвать метод TurnOnRadio() с аргументами.

   MethodInfo mi = sport.GetMethod("TurnOnRadio");

   mi.Invoke(obj, new object[] { true, 2 });

  }

  catch (Exception ex)

  {

   Console.WriteLine(ex.Message);

  }

}

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

Вас все еще может интересовать вопрос: когда описанные приемы должны применяться в разрабатываемых приложениях? Ответ прояснится ближе к концу главы, а пока мы займемся исследованием роли атрибутов .NET Core.

Как было показано в начале главы, одной из задач компилятора .NET Core является генерация описаний метаданных для всех определяемых типов и для типов, на которые имеются ссылки. Помимо стандартных метаданных, содержащихся в любой сборке, платформа .NET Core предоставляет программистам способ встраивания в сборку дополнительных метаданных с использованием атрибутов. Выражаясь кратко, атрибуты — это всего лишь аннотации кода, которые могут применяться к заданному типу (классу, интерфейсу, структуре и т.п.), члену (свойству, методу и т.д.), сборке или модулю.

Атрибуты .NET Core представляют собой типы классов, расширяющие абстрактный базовый класс

System.Attribute

Attribute

Библиотеки базовых классов .NET Core предлагают атрибуты в различных пространствах имен. В табл. 17.3 описаны некоторые (безусловно, далеко не все) предопределенные атрибуты.

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

Потребители атрибутов

Как нетрудно догадаться, в состав .NET Core входят многочисленные утилиты, которые действительно ищут разнообразные атрибуты. Сам компилятор C# (

csc.exe

[CLSCompilant]

[Obsolete]

В дополнение к инструментам разработки многие методы в библиотеках базовых классов . NET Core изначально запрограммированы на распознавание определенных атрибутов посредством рефлексии. В главе 20 рассматривается сериализация XML и JSON, которая задействует атрибуты для управления процессом сериализации.

Наконец, можно строить приложения, способные распознавать специальные атрибуты, а также любые атрибуты из библиотек базовых классов .NET Core. По сути, тем самым создается набор "ключевых слов", которые понимает специфичное множество сборок.

Применение атрибутов в C#

Чтобы ознакомиться со способами применения атрибутов в С#, создайте новый проект консольного приложения по имени

ApplyingAttributes

System.Text.Json

Motorcycle

[JsonIgnore]

public class Motorcycle

{

  [JsonIgnore]

  public float weightOfCurrentPassengers;

  // Эти поля остаются сериализируемыми.

  public bool hasRadioSystem;

  public bool hasHeadSet;

  public bool hasSissyBar;

}

На заметку! Атрибут применяется только к элементу, находящемуся непосредственно после него.

В данный момент пусть вас не беспокоит фактический процесс сериализации объектов (он подробно рассматривается в главе 20). Просто знайте, что для применения атрибута его имя должно быть помещено в квадратные скобки.

Нетрудно догадаться, что к одиночному элементу можно применять множество атрибутов. Предположим, что у вас есть унаследованный тип класса C# (

НоrseAndBuggy

[Obsolete]

using System;

using System.Xml.Serialization;

namespace ApplyingAttributes

{

   [XmlRoot(Namespace = "http://www.MyCompany.com"),

       Obsolete("Use another vehicle!")]

   // Используйте другое транспортное средство!

   public class HorseAndBuggy

   {

     // ...

   }

}

В качестве альтернативы применить множество атрибутов к единственному элементу можно также, указывая их друг за другом (конечный результат будет идентичным):

[XmlRoot(Namespace = "http://www.MyCompany.com")]

[Obsolete("Use another vehicle!")]

public class HorseAndBuggy

{

  // ...

}

Сокращенная система обозначения атрибутов C#

Заглянув в документацию по .NET Core, вы можете заметить, что действительным именем класса, представляющего атрибут

[Obsolete]

ObsoleteAttribute

Obsolete

Attribute

Attribute

HorseAndBuggy

[SerializableAttribute]

[ObsoleteAttribute("Use another vehicle!")]

public class HorseAndBuggy

{

  // ...

}

Имейте в виду, что такая сокращенная система обозначения для атрибутов предлагается только в С#. Ее поддерживают не все языки .NET Core.

Указание параметров конструктора для атрибутов

Обратите внимание, что атрибут

[Obsolete]

[Obsolete]

System.String

public sealed class ObsoleteAttribute : Attribute

{

  public ObsoleteAttribute(string message, bool error);

  public ObsoleteAttribute(string message);

  public ObsoleteAttribute();

  public bool IsError { get; }

  public string? Message { get; }

}

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

Атрибут [Obsolete] в действии

Теперь, поскольку класс

HorseAndBuggy

using System;

using ApplyingAttributes;

Console.WriteLine("Hello World!");

HorseAndBuggy mule = new HorseAndBuggy();

приводит к выдаче компилятором предупреждающего сообщения, а именно — предупреждения CS0618 с сообщением, включающим информацию, которая передавалась атрибуту:

‘HorseAndBuggy’ is obsolete: ‘Use another vehicle!'

HorseAndBuggy устарел: Используйте другое транспортное средство!

Среды Visual Studio и Visual Studio Code оказывают помощь также посредством IntelliSense, получая информацию через рефлексию.

На рис. 17.1 показаны результаты действия атрибута

[Obsolete]

В идеальном случае к настоящему моменту вы уже должны понимать перечисленные ниже ключевые моменты, касающиеся атрибутов .NET Core:

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

System.Attribute

• атрибуты дают в результате встроенные метаданные;

• атрибуты в основном бесполезны до тех пор, пока другой агент не проведет в их отношении рефлексию;

• атрибуты в языке C# применяются с использованием квадратных скобок.

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

Первый шаг при построении специального атрибута предусматривает создание нового класса, производного от

System.Attribute

AttributedCarLibrary

VehicleDescriptionAttribute

using System;

// Специальный атрибут.

public sealed class VehicleDescriptionAttribute :Attribute

{

  public string Description { get; set; }

  public VehicleDescriptionAttribute(string description)

  => Description = description;

  public VehicleDescriptionAttribute(){ }

}

Как видите, класс

VehicleDescriptionAttribute

Description

System.Attribute

На заметку! По причинам, связанным с безопасностью, установившейся практикой в .NET Core считается проектирование всех специальных атрибутов как запечатанных. На самом деле среды Visual Studio и Visual Studio Code предлагают фрагмент кода под названием

Attribute

System.Attribute

Применение специальных атрибутов

С учетом того, что класс

VehicleDescriptionAttribute

System.Attribute

// Motorcycle.cs

namespace AttributedCarLibrary

{

  // Назначить описание с помощью "именованного свойства".

  [Serializable]

  [VehicleDescription(Description = "My rocking Harley")]

                  // Мой покачивающийся Харли

  public class Motorcycle

  {

  }

// HorseAndBuggy.cs

namespace AttributedCarLibrary

{

  [Serializable]

  [Obsolete ("Use another vehicle!")]

  [VehicleDescription("The old gray mare, she ain't what she used to be...")]

           // Старая серая лошадка, она уже не та...

  public class HorseAndBuggy

  {

  }

}

// Winnebago.cs

namespace AttributedCarLibrary

{

  [VehicleDescription("A very long, slow, but feature-rich auto")]

           // Очень длинный, медленный, но обладающий высокими

           // техническими характеристиками автомобиль

  public class Winnebago

  {

  }

}

Синтаксис именованных свойств

Обратите внимание, что классу

Motorcycle

[VehicleDescription]

Description

Description

По контрасту для типов

HorseAndBuggy

Winnebago

AttributedCarLibrary

ildasm.exe

Winnebago

// CustomAttribute #1

// -------------------------------------------------------

//  CustomAttribute Type: 06000005

//  CustomAttributeName: AttributedCarLibrary.VehicleDescriptionAttribute :: instance void 

.ctor(class System.String)

//  Length: 45

//  Value : 01 00 28 41 20 76 65 72  79 20 6c 6f 6e 67 2c 20 >  (A very long, <

//     : 73 6c 6f 77 2c 20 62 75  74 20 66 65 61 74 75 72 >slow, but feature<

//     : 65 2d 72 69 63 68 20 61  75 74 6f 00 00      >e-rich auto   <

//  ctor args: ("A very long, slow, but feature-rich auto")

Ограничение использования атрибутов

По умолчанию специальные атрибуты могут быть применены практически к любому аспекту кода (методам, классам, свойствам и т.д.). Таким образом, если бы это имело смысл, то

VehicleDescription

[VehicleDescription("A very long, slow, but feature-rich auto")]

public class Winnebago

{

  [VehicleDescription("My rocking CD player")]

  public void PlayMusic(bool On)

  {

   ...

  }

}

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

[AttributeUsage]

AttributeTargets

// Это перечисление определяет возможные целевые элементы для атрибута.

public enum AttributeTargets

{

  All, Assembly, Class, Constructor,

  Delegate, Enum, Event, Field, GenericParameter,

  Interface, Method, Module, Parameter,

  Property, ReturnValue, Struct

}

Кроме того, атрибут

[AttributeUsage]

AllowMultiple

false

[AttributeUsage]

Inherited

true

Модифицируйте определение

VehicleDescriptionAttribute

[VehicleDescription]

// На этот раз для аннотирования специального атрибута

// используется атрибут AttributeUsage.

[AttributeUsage(AttributeTargets.Class | AttributeTargets.Struct, Inherited = false)]

public sealed class VehicleDescriptionAttribute : System.Attribute

{

  ...

}

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

[VehicleDescription]

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

[assembly:]

AssemblyAttributes.cs

AssemblyInfо.cs

На заметку! Какая-либо формальная причина для использования отдельного файла отсутствует; это связано чисто с удобством поддержки вашего кода. Помещение атрибутов сборки в отдельный файл проясняет тот факт, что в вашем проекте используются атрибуты уровня сборки, и показывает, где они находятся.

При добавлении в проект атрибутов уровня сборки или модуля имеет смысл придерживаться следующей рекомендуемой схемы для файла кода:

// Первыми перечислить операторы using.

using System;

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

// Обеспечить совместимость с CLS для всех открытых типов в данной сборке.

[assembly: CLSCompliant(true)]

Если теперь добавить фрагмент кода, выходящий за рамки спецификации CLS (вроде открытого элемента данных без знака), тогда компилятор выдаст предупреждение:

// Тип ulong не соответствует спецификации CLS.

public class Winnebago

{

  public ulong notCompliant;

}

На заметку! В .NET Core внесены два значительных изменения. Первое касается того, что файл

AssemblyInfo.cs

Version

Company

Использование файла проекта для атрибутов сборки

Как было демонстрировалось в главе 16 с классом

InternalsVisibleToAttribute

На заметку! На момент написания главы в хранилище GitHub для MSBuild шло активное обсуждение относительно добавления возможности поддержки нестроковых параметров, что позволило бы добавлять атрибут

CLSCompliant

*.cs

Установите несколько свойств (таких как

Authors

Description

InternalsVisibleToAttribute

   net5.0

   Philip Japikse

   Apress

   This is a simple car library with attributes

    <_Parameter1>CSharpCarClient

После компиляции своего проекта перейдите в каталог \

obj\Debug\net5.0

AttributedCarLibrary.AssemblyInfo.cs

using System;

using System.Reflection;

[assembly: System.Runtime.CompilerServices.InternalsVisibleToAttribute

("CSharpCarClient")]

[assembly: System.Reflection.AssemblyCompanyAttribute("Philip Japikse")]

[assembly: System.Reflection.AssemblyConfigurationAttribute("Debug")]

[assembly: System.Reflection.AssemblyDescriptionAttribute("This is a

sample car library with 

attributes")]

[assembly: System.Reflection.AssemblyFileVersionAttribute("1.0.0.0")]

[assembly: System.Reflection.AssemblyInformationalVersionAttribute("1.0.0")]

[assembly: System.Reflection.AssemblyProductAttribute("AttributedCarLibrary")]

[assembly: System.Reflection.AssemblyTitleAttribute("AttributedCarLibrary")]

[assembly: System.Reflection.AssemblyVersionAttribute("1.0.0.0")]

И последнее замечание, касающееся атрибутов сборки: вы можете отключить генерацию файла

AssemblyInfо.cs

В последующих разделах будет рассмотрен пример создания расширяемого приложения, которое может быть дополнено функциональностью внешних сборок. Расширяемое приложение образовано из следующих сборок.

•

CommonSnappableTypes.dll

•

CSharpSnapIn.dll

CommonSnappableTypes.dll

•

VBSnapIn.dll

CommonSnappableTypes.dll

•

MyExtendableApp.ехе

В приложении будут использоваться динамическая загрузка, рефлексия и позднее связывание для динамического получения функциональности сборок, о которых заранее ничего не известно.

На заметку! Вы можете подумать о том, что вам вряд ли будет ставиться задача построения консольного приложения, и тут вы вероятно правы! Бизнес-приложения, создаваемые на языке С#, обычно относятся к категории интеллектуальных клиентов (Windows Forms или WPF), веб-приложений/служб REST (ASP.NET Core) или автоматических процессов (функций Azure, служб Windows и т.д.). Консольные приложения применяются здесь, чтобы сосредоточиться на специфических концепциях примеров, в данном случае — на динамической загрузке, рефлексии и позднем связывании. Позже в книге вы узнаете, как строить "реальные" пользовательские приложения с использованием WPF и ASP.NET Core.

Построение мультипроектного решения ExtendableApp

dotnet new sln -n Chapter17_ExtendableApp

dotnet new classlib -lang c# -n CommonSnappableTypes

 -o .\CommonSnappableTypes -f net5.0

dotnet sln .\Chapter17_ExtendableApp.sln add .\CommonSnappableTypes

dotnet new classlib -lang c# -n CSharpSnapIn -o .\CSharpSnapIn -f net5.0

dotnet sln .\Chapter17_ExtendableApp.sln add .\CSharpSnapIn

dotnet add CSharpSnapin reference CommonSnappableTypes

dotnet new classlib -lang vb -n VBSnapIn -o .\VBSnapIn -f net5.0

dotnet sln .\Chapter17_ExtendableApp.sln add .\VBSnapIn

dotnet add VBSnapIn reference CommonSnappableTypes

dotnet new console -lang c# -n MyExtendableApp -o .\MyExtendableApp -f net5.0

dotnet sln .\Chapter17_ExtendableApp.sln add .\MyExtendableApp

dotnet add MyExtendableApp reference CommonSnappableTypes

dotnet run

CSharpSnapin.csproj

VBSnapIn.vbproj

MyExtendableApp

MyExtendableApp\bin\debug\net5.0

MyExtendableApp

Создание решения и проектов с помощью Visual Studio

Вспомните, что по умолчанию среда Visual Studio назначает решению такое же имя, как у первого проекта, созданного в этом решении. Тем не менее, вы можете легко изменять имя решения.

Чтобы создать решение

ExtendableApp

, выберите в меню пункт File►New Project (Файл►Создать проект). В открывшемся диалоговом окне Add New Project (Добавление нового проекта) выберите элемент Class Library (Библиотека классов) и введите

CommonSnappableTypes

в поле Project name (Имя проекта). Прежде чем щелкать на кнопке Create (Создать), введите

ExtendableApp

в поле Solution name (Имя решения), как показано на рис. 17.3.

Чтобы добавить к решению еще один проект, щелкните правой кнопкой мыши на имени решения(

ExtendableApp

) в окне Solution Explorer и выберите в контекстном меню пункт Add►New Project (Добавить► Новый проект) или выберите в меню пункт File►Add►New Project (Файл►Добавить►Новый проект). При добавлении дополнительного проекта к существующему решению содержимое диалогового окна Add New Project слегка отличается; параметры решения теперь отсутствуют, так что вы увидите только информацию о проекте (имя и местоположение). Назначьте проекту библиотеки классов имя

CSharpSnapIn

и щелкните на кнопке Create.

Далее добавьте в проект

CSharpSnapIn

ссылку на проект

CommonSnappableTypes

. В среде Visual Studio щелкните правой кнопкой мыши на имени проекта

CSharpSnapIn

и выберите в контекстном меню пункт Add►Project Reference (Добавить►Ссылка на проект). В открывшемся диалоговом окне Reference Manager (Диспетчер ссылок) выберите элемент Projects►Solution (Проекты►Решение) в левой части (если он еще не выбран) и отметьте флажок рядом с

CommonSnappableTypes

.

Повторите процесс для нового проекта библиотеки классов Visual Basic (VBSnapIn), которая ссылается на проект

CommonSnappableTypes

.

Наконец, добавьте к решению новый проект консольного приложения .NET Core по имени

MyExtendableApp

. Добавьте в него ссылку на проект

CommonSnappableTypes

и установите проект консольного приложения в качестве стартового для решения. Для этого щелкните правой кнопкой мыши на имени проекта

MyExtendableApp

в окне Solution Explorer и выберите в контекстном меню пункт Set as Startup Project (Установить как стартовый проект).

На заметку! Если вы щелкнете правой кнопкой мыши на имени решения

ExtendableApp

, а не на имени одного из проектов, то в контекстном меню отобразится пункт Set Startup Projects (Установить стартовые проекты). Помимо запуска по щелчку на кнопке Run (Запустить) только одного проекта можно настроить запуск множества проектов, что будет демонстрироваться позже в книге.

Установка зависимостей проектов при компиляции

Когда среде Visual Studio поступает команда запустить решение, стартовый проект и все проекты, на которые имеются ссылки, компилируются в случае обнаружения любых изменений; однако проекты, ссылки на которые отсутствуют, не компилируются. Положение дел можно изменить, устанавливая зависимости проектов. Для этого щелкните правой кнопкой мыши на имени решения в окне Solution Explorer, выберите в контекстном меню пункт Project Build Order (Порядок компиляции проектов), в открывшемся диалоговом окне перейдите на вкладку Dependencies (Зависимости) и в раскрывающемся списке Projects (Проекты) выберите

MyExtendableApp

.

Обратите внимание, что проект

CommonSnappableTypes

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

CSharpSnapIn

и

VBSnapIn

(рис. 17.4).

Теперь при каждой компиляции проекта

MyExtendableApp

будут также компилироваться проекты

CSharpSnapIn

и

VBSnapIn

.

Добавление событий PostBuild

Откройте окно свойств проекта для

CSharpSnapIn

(щелкнув правой кнопкой мыши на имени проекта в окне Solution Explorer и выбрав в контекстном меню пункт Properties (Свойства)) и перейдите в нем на вкладку Build Events (События при компиляции). Щелкните на кнопке Edit Post-build (Редактировать события после компиляции) и затем щелкните на Macros>> (Макросы). Здесь вы можете видеть доступные для использования макросы, которые ссылаются на пути и/или имена файлов. Преимущество применения этих макросов в событиях, связанных с компиляцией, заключается в том, что они не зависят от машины и работают с относительными путями. Скажем, кто-то работает в каталоге по имени

c-sharp-wf\code\chapterl7

. Вы можете работать в другом каталоге (вероятнее всего так и есть). За счет применения макросов инструмент MSBuild всегда будет использовать корректный путь относительно файлов

*.csproj

.

Введите в области PostBuild (После компиляции) следующие две строки:

copy $(TargetPath) $(SolutionDir)MyExtendableApp\$(OutDir)$(TargetFileName) /Y

copy $(TargetPath) $(SolutionDir)MyExtendableApp\$(TargetFileName) /Y

Сделайте то же самое для проекта

VBSnapin

, но здесь вкладка в окне свойств называется Compile (Компиляция) и на ней понадобится щелкнуть на кнопке Build Events (События при компиляции).

Когда показанные выше команды событий после компиляции добавлены, все сборки при каждой компиляции будут копироваться в каталог проекта и выходной каталог приложения

MyExtendableApp

.

Построение сборки CommonSnappableTypes.dll

Удалите стандартный файл класса

Class1.cs

CommonSnappableTypes

AppFunctionality.cs

namespace CommonSnappableTypes

{

  public interface IAppFunctionality

  {

   void DoIt();

  }

}

Добавьте файл класса по имени

CompanyInfoAttribute.cs

using System;

namespace CommonSnappableTypes

{

  [AttributeUsage(AttributeTargets.Class)]

  public sealed class CompanyInfoAttribute : System.Attribute

  {

   public string CompanyName { get; set; }

   public string CompanyUrl { get; set; }

  }

}

Тип

IAppFunctionality

DoIt()

Тип

CompanyInfoAttribute

[CompanyInfо]

Построение оснастки на C#

Удалите стандартный файл

Class1.cs

CSharpSnapIn

CSharpModule.cs

using System;

using CommonSnappableTypes;

namespace CSharpSnapIn

{

  [CompanyInfo(CompanyName = "FooBar", CompanyUrl = "www.FooBar.com")]

  public class CSharpModule : IAppFunctionality

  {

   void IAppFunctionality.DoIt()

   {

    Console.WriteLine("You have just used the C# snap-in!");

   }

  }

}

Обратите внимание на явную реализацию интерфейса

IAppFunctionality

IAppFunctionality

DoIt()

CSharpModule

Построение оснастки на Visual Basic

Теперь перейдите к проекту

VBSnapIn

Class1.vb

VBSnapIn.vb

Imports CommonSnappableTypes

Public Class VBSnapIn

  Implements IAppFunctionality

  Public Sub DoIt() Implements CommonSnappableTypes.IAppFunctionality.DoIt

   Console.WriteLine("You have just used the VB snap in!")

  End Sub

End Class

Как видите, применение атрибутов в синтаксисе Visual Basic требует указания угловых скобок (

<>

[]