Использование рефлексии для расширения программ .NET

Автор: James T. Johnson, перевод выполнил kpumuk специально для Realcoding.NET
оригинал  http://www.codeproject.com/csharp/reflection.asp

• Загрузить исходные тексты - 12 кб
• Загрузить демо проект - 8 кб

• Введение
• Что вам нужно
  • Шаг 1: Интерфейсы
  • Шаг 2: Расширенный тип
  • Шаг 3: Главная программа
    • Загрузка сборок из файлов
    • Использование Type для создания экземпляров объектов
• Тестирование вашей программы
• Возможные применения этой техники

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

Я не особо представляю, как можно сделать такое же на .NET, потому принялся писать эту статью.

Для краткости в моем коде будут использованы только маленькие блоки try/catch, в вашем же реальном проекте следует ожидать любого исключения из описанных в документации как возможные. Думаю, я включил достаточно комментариев в мой код или статью, чтобы сделать все достаточно ясным. Если это не так - напишите мне на e-mail или оставьте комментарий в разделе ниже.

Я буду использовать Visual Studio.NET RC0 (т.е. PDC выпуск), но все, что я делаю, возможно из командной строки так же хорошо. Вам следует обратиться к документации для установки правильных опций компилятора, чтобы использовать его.

Если вы используете более раннюю версию VS.NET/.NET Framework, следует перекомпилировать пример для его работы. Как ExtendedType, так и MainProgram должны иметь ссылку на проект BaseType.

Вам нужны три сборки .NET для компиляции нашего проекта.

1. Интерфейсы, которые определяют, как компоненты и наша программа будут взаимодействовать
2. Сборка, основанная на #1
3. Главная программа, которая будет использовать #1 для взаимодействия с #2

В этом решении у нас будет 3 проекта. Главная программа, интерфейс, который свяжет вашу программу с дополнениями и простой плагин. Вы можете поместить интерфейс и главную программу в один проект, но тогда вы будете давать любому плагину больший доступ к вашему внутреннему коду.

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

Теперь щелкните на названии решения правой кнопкой и выберите "Add Project", создайте новый проект Class Library (библиотека классов) для решения, назвав его "Reflection.BaseType". Название имени просто устанавливает корневое пространство имен, как и имя каталога. Оно будет основываться на проекте BaseType.

Правый щелчок на названии решения, добавьте другой проект библиотеки классов, назвав его "Reflection.ExtendedType". Правый щелчок на названии проекта, и в Solution Explorer (инспекторе решения) выберите Add Reference (добавить ссылку). На закладке Projects (проекты) вы увидите проект BaseType. Выберите этот проект и нажмите OK. Теперь, когда проект будет компилироваться, также будет скомпилирован проект BaseType, чтобы убедиться в том, что вы ссылаетесь на последний код. Это будет плагин или проект ExtendedType.

И, наконец, добавим консольное приложение в ваше решение, назвав его "Reflection.MainProgram". И снова добавим ссылку на проект BaseType. Это позволит главной программе загружать дополнения в режиме реального времени.

Так как это всего лишь пример, мы будем использовать крайне простой интерфейс; в реальном мире простой интерфейс врядли справится. Нам нужно использовать один или несколько интерфейсов для расширения программы. Один из путей сделать это - это иметь один интерфейс, в котором есть свойства для всех остальных интерфейсов, которые вам могут понадобиться. Это сведет поиск в сборках к минимуму.

using System;

namespace Reflection.BaseType
{
    /// <summary>
    /// ISayHello - наш шлюз к расширению системы дополнительными типами
    /// из нашей программы. Весь обмен данными, который происходит, будет выполняться
    /// через один из наших интерфейсов.
    /// </summary>
    public interface ISayHello
    {
        /// <summary>
        /// Свойство: Name
        /// Доступ:   ReadOnly
        /// Описание: Возвращает имя класса, который реализует интерфейс. 
        /// </summary>
        string Name { get; }

        /// <summary>
        /// Метод:    SayHello
        /// Доступ:   Public
        /// Описание: Когда вызывается, на консоль будет выведено приветственное сообщение
        /// </summary>
        void SayHello();
    }
}

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

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

Выберите проект BaseType и переименуйте Class1.cs в HelloFromMTU.cs. В этом файле вы можете создать ваш класс, который будет реализовывать базовый интерфейс, ISayHello

using System;
using Reflection.BaseType;

namespace Reflection.ExtendedType
{
    /// <summary>
    /// Общее описание для Class1.
    /// </summary>
    public class HelloFromMTU : Reflection.BaseType.ISayHello 
    {
        /// <summary>
        /// Конструктор по умолчанию, ничего не требуется
        /// </summary>
        public HelloFromMTU()
        {
        }

        /// <summary>
        /// ISayHello.Name
        /// 
        /// Я мог использовать объект типа HelloFromMTU, чтобы получить 
        /// имя, но так проще :)
        /// </summary>
        public string Name
        {
            get
            {
                return "HelloFromMTU";
            }
        }

        /// <summary>
        /// ISayHello.SayHello
        /// 
        /// Выводит приветствие на консоль
        /// </summary>
        public void SayHello()
        {
            Console.WriteLine("Привет от Michigan Tech, страны холода");
        }
    }
}

Теперь вы можете начать писать главную программу. Сейчас тип проекта будет Console Application, но вы можете так же легко использовать эту технику с любыми другими типами проектов. Даже приложения ASP.NET могут ее использовать, но при этом они будут следовать специальным условиям, диктуемым природой программирования ASP, не сохраняющей состояние.

Простейшим способом загрузки сборок является использование метода Assembly.LoadFrom(), который принимает строку, имя файла сборки. Из сборки мы можем легко найти фактически все о ее содержании, включая то, какие типы сохранены в ней, их базовые классы и интерфейсы, которые они реализуют.

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

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

Обратите внимание, что вам следует отлавливать исключение BadImageFormatException, которое выбрасывает Assembly.LoadFrom, когда вы пытаетесь загрузить файл, не являющийся сборкой. Если у вас есть другие типы DLL в каталоге, будет произведена попытка загрузить их при поиске в каталоге библиотек DLL.

public int LoadTypes()
{
    string currentDirectory = System.IO.Directory.GetCurrentDirectory();
    string [] dllFilenames = System.IO.Directory.GetFiles(currentDirectory, "*.dll");
    
    foreach(string filename in dllFilenames)
    {
        try
        {
            Assembly asm = Assembly.LoadFrom(filename);

            Type [] typesInAssembly = asm.GetTypes();
            foreach(Type type in typesInAssembly)
            {        
                if(null != type.GetInterface(typeof(Reflection.BaseType.ISayHello).FullName))
                {
                    // Мы нашли тип, загрузить его
                    Console.WriteLine(string.Format("Сборка: {0} имеет тип {1}, который " + 
                                                    "реализует ISayHello", 
                                                     asm.FullName, type.FullName));
                    
                    types.Add(type);
                }
            }
        }
        catch(BadImageFormatException e)
        {
            // Неправильная сборка, отбросить
        }
    }

    // Сообщает Main количество загруженных типов
    return types.Count;
}

Теперь у вас есть ArrayList объектов Type, что же вы можете с ними делать? Хорошо, вероятно вы хотите создать экземпляры этих типов. Используя Activator.CreateInstance, вы можете создать экземпляр чего угодно, при условии, что вы имеет Type для работы с ним.

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

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

public void SayHello()
{
    foreach(Type type in types)
    {
        ISayHello ish = (ISayHello) Activator.CreateInstance(type);

        Console.WriteLine(String.Format("{0} произносит:", ish.Name));
        ish.SayHello();
    }
}

Теперь вам нужно скомпилировать все решение. Перед запуском программы, вам осталось выполнить последний шаг. Скопируйте dll расширенного типа в тот же каталог, что и ваша программа, потому что именно в нем происходит поиск ваших типов.

Как только вы скопировали dll, предварительные этапы закончились! Теперь можно запустить программу и посмотреть простой случай рефлексии в работе. Я уже выполнил этот шаг в демонстрационном zip-файле, однако, если у вас нет VS.NET версии RC0, вам нужно перекомпилировать проект, чтобы он заработал, так как вам нужны те же версии системных сборок, что и у меня.

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

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

Для использования техники базового класса, вам следует использовать метод Type IsSubclassOf вместо поиска интерфейса.

В этой статье я показал, как легко использовать рефлексию для расширения вашей программы способами, которые могут сделать работу программиста проще и быстрее. Эта техника использовалась в программах COM годами, в инструментах вроде IE и Visual Studio. Теперь разработчики .NET получают возможность делать то же самое, только в этот раз без мучений с реестром.

Если кто-либо найдет любые огрехи или будет иметь любые комментарии,- оставляйте их ниже, и я отвечу. Наслаждайтесь моей первой статьей.