Reflection дава възможност на една програма динамично да анализира и открива елементи (като fields, methods, constructors, attributes) на типове (като класове, интерфейси, структури) във вече съществуващи асемблита, тъй като всеки компилатор който генерира CLR код, генерира и metadata която описва съответните елементи. Като получим тази информация, може просто да я покажем (decompilers, class browsers, object inspectors) или да инстанциираме и извикваме функционалност по много динамичен начин. Reflection не се ограничава само до анализ на съществуващ компилиран код. Може да се използва за генериране на нови типове изцяло в паметта и пак да ги извикваме като обикновен код. Например: код който изучава функционалноста на един интерфейс и му генерира динамично wrapper class (познато още като adapter или proxy). Това се използва в .NET remoting architecture, която на мене ми била супер мътна според много хора в този форум.
Ако тази идея за self-generating code се развие достатъчно завбъдеще, програмата може да стане автор на самата себе си и тя да решава как ще се изпълянва. Нещо като The Matrix ... така един алгоритъм може да се изгради динамично без изобщо да е писан от програмист или да се съхранява на сорс файл, примерно generic algorithms които сами си модифицират поведението за да намерят решение на трудна математическа задача.

На пръв поглед reflection може да изглежда трудно за разбиране или ненужно, обаче много tools като IntelliSense, Class View, Property Windows използват reflection особено усилено :)). Освен това .Net Framework го използва за object serialization, the .NET remoting architecture, and dynamic method dispatch. Всъщност виртуално всяка една .net програма използва reflection по много начини без даже програмиста да осъзнава за това.

Най-важен в цялата тази работа е класа Type. Той съдържа информация (metadata) за останалите типове. Но в същността си е просто един тип клас най-обикновен, малко абстрактен но пък ти позволява достъп то metadata-а на другите класове.

Как работи цялата тази работа:

Най-важното е че всеки тип наследяващ Object поддържа GetType метода, който ти връща обект от тип Type.

Type* Object::GetType()

Type класа има много методи, можеш да ги видиш в документацията, обаче ми е съвестно ако не се спра на най-важните:

Можеш да вземеш типа на даден клас чрез името му:

Type* Type::GetType(String* typeName)

или атрибутите му:

TypeAttributes Type::get_Attributes()

или базовия клас:

Type* Type::get_BaseType()

или всичките му методи:

MethodInfo* Type::GetMethods() []

и така нататък ...

За да рефлектираш определен тип, първо трябва да заредиш асемблито му в паметта. Това става най-лесно с Assembly класа.

Assembly* Assembly::LoadFrom(String* assemblyFile)

и после си го разглеждаш както искаш, примерно:

Type* Assembly::GetTypes() []

Когато го получиш този масив, може да рефлектираш всеки тип в него като му достъпваш: MethodInfo, FieldInfo, ParameterInfo и каквото там ти трябва.

Аз лично най-често ползвам reflection за custom attributes, interface wrappers, и stored procedures wrappers ... а за stored proc-овете направо се е разбило ... нали се сещаш как се викаха stored procs от ADO ... описваш всеки параметър един по един за всяка процедура ... и в една голяма бизнес система смятай за кво писане на конвеир става въпрос ... с reflection работата с stored procedures добива нови измерения

Съдържаниет е скрито
Влезте за да го видите