Система Orphus

Библиотека ATL 8: внутренняя структура и применение. Microsoft Visual Studio 2005

Авторы: Кристофер Таваре
Кирк Фертитта
Брент Ректор
Крис Селлз
Издательство: Вильямс, 2007
736 страниц

Материал предоставил: Издательство ''Вильямс''
Найти в магазинах
Купить в Books.Ru

Аннотация

Содержание
Предисловие ко второму изданию
Предисловие к первому изданию
Краткая история ATL
Введение
Атрибуты
Кому адресована эта книга
Структура книги
Код примеров и дополнительная информация
Об авторах

Аннотация

Эта книга адресована программистам, работающим в Microsoft Visual Studio 2005, использующим C++/COM и собирающимся использовать библиотеку ATL 8. Эти разработчики создают приложения, которые должны работать на любых системах, начиная с Windows 95, со слишком старыми процессорами и малыми объемами памяти для .NET. Они не могут позволить себе роскошь тратить драгоценные ресурсы на сбор мусора, JIT-компиляцию или на огромные библиотеки, набитые ненужными им классами. Для них важнее всего скорость загрузки программ, их быстродействие и способность работать в любых условиях. Чтобы они стали использовать какую-то платформу, она должна быть свободна от накладных расходов на ненужные им возможности, обладать гибкостью и высокой производительностью. Именно для таких разработчиков и предназначена технология ATL 8, новейшая платформа для разработки Windows-приложений.

Клиентам ATL предоставляет оконные классы, интеллектуальные типы COM, поддержку элементов управления COM и размещения этих элементов, интеграцию с MFC (включая поддержку части классов MFC без необходимости использовать остальную часть MFC) и генерацию интерфейсов Web-служб.

Серверам ATL предлагает поддержку COM-серверов и объектов и механизмы для реализации высокопроизводительных многопоточных Web-служб и приложений.

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

Содержание

Предисловие ко второму изданию
Предисловие к первому изданию
Краткая история ATL
Введение
Атрибуты
Кому адресована эта книга
Структура книги
Оформление
Код примеров и дополнительная информация
Благодарности
Об авторах

ГЛАВА 1. Здравствуй, ATL
Что такое ATL?
Создание COM-сервера
Создание ATL-проекта
Результаты работы мастера ATL Project Wizard
Вставка COM-класса
Добавление простого объекта ATL
Результаты работы мастера ATL Simple Object Wizard
Добавление свойств и методов
Реализация дополнительных интерфейсов
Поддержка скриптов
Добавление поддержки сохраняемости
Добавление и генерация событий
Использование окна
Элементы управления COM
Использование элемента управления
C++-клиенты COM
Web-проекты ATL Server
Резюме

ГЛАВА 2. Строки и текст
Строковые типы данных, классы преобразования и вспомогательные функции
Обзор текстовых типов данных
Классы преобразования строк ATL
Замечание по управлению памятью
Вспомогательные строковые функции ATL
Макросы преобразования строк в ATL
Класс CComBSTR - интеллектуальный класс BSTR
Обзор строкового типа данных COM: BSTR
Класс CComBSTR
Разговор о BSTR, промежуточных символах NUL и о жизни в целом
Класс CString
Обзор класса CString
Анатомия CString
Конструкторы
Присваивание
Конкатенация строк CStringT
Преобразование регистра символов
Операции сравнения в CString
Действия над классом CString
Форматирование данных
Работа с BSTR и CString
Резюме

ГЛАВА 3. Интеллектуальные типы ATL
Типы VARIANT, SAFEARRAY и интерфейсные указатели
Класс CComVariant - интеллектуальный класс VARIANT
Обзор типа данных COM VARIANT
Класс CComVariant
Класс CComSafeArray - интеллектуальный класс SAFEARRAY
Обзор типа данных COM SAFEARRAY
Классы интеллектуальных указателей CComPtr и CComQIPtr
Обзор интеллектуальных указателей
Классы CComPtr и CComQIPtr
Операции сравнения в CComPtr
Специализация CComPtr для IDispatch
Класс CComGITPtr
Классы интеллектуальных указателей CAutoPtr и CAutoVectorPtr
Классы CAutoPtr и CAutoPtrVector
Менеджеры памяти ATL
Обзор управления памятью в Windows
Интерфейс IAtlMemMgr
Классы менеджеров памяти
Резюме

ГЛАВА 4. Объекты в ATL
Реализация интерфейса IUnknown
Уровни ATL
Поддержка потоковой модели
Поточно-ориентированные объекты
Синхронизация данных в экземплярах
Потоковая модель по умолчанию для сервера
Ядро IUnknown
Независимый подсчет ссылок
Табличный вариант QueryInterface
Поддержка агрегирования: управляемый внутренний объект
Продолжение следует
Ваш класс
Классы реализации ATL
Поддержка скриптов
Поддержка нескольких двойных интерфейсов
Класс CComObject и ему подобные
Независимая активация
Агрегированная активация
Альтернативные способы активации
Создание объектов ATL
Многоэтапное создание объектов
Классы Creator
Закрытая инициализация
Многоэтапное создание объектов в стеке
Отладка
Создание проверок
Гибкий вывод сообщений при отладке
Трассировка вызовов QueryInterface
Трассировка вызовов AddRef и Release
Символ _ATL_DEBUG_REFCOUNT
Резюме

ГЛАВА 5. COM-серверы
Обзор COM-серверов
Inproc-серверы
Локальные серверы и серверы, основанные на службах
Создаваемые и несоздаваемые классы COM
Карта объектов и класс CAtlModule
Карта объектов
Макросы карты объектов
Методы, необходимые для класса карты объектов
Методы поддержки регистрации классов
Макросы DECLARE_REGISTRY
Реестровые скрипты
Переменные регистровых скриптов
Регистрация сервера, а не класса
Инициализация и деинициализация классов
Запросы на создание объектов
Класс CAtlModule
Глобальная переменная _AtlModule
Поддержка регистрации в CAtlModule
Возвращаемся к CComCoClass
Методы Error
Методы создания экземпляров
ATL и библиотека C времени выполнения
Резюме

ГЛАВА 6. Таблицы интерфейсов
Именование в COM
Законы именования COM
Табличная реализация QueryInterface
Таблица чистых интерфейсов
Вспомогательные макросы
Функция AtlInternalQueryInterface
Множественное наследование
Прямое приведение
Ветвящееся приведение
Устранение конфликтов имен
Раскрашивание интерфейсов
Отделяемые интерфейсы
Стандартные отделяемые интерфейсы
Кешируемые отделяемые интерфейсы
Агрегирование: управляющий внешний объект
Планируемое и слепое агрегирование
Ручное и автоматическое создание
Агрегирование и свободнопоточный маршалер
Сцепление карт интерфейсов
Макрос COM_INTERFACE_ENTRY_CHAIN
Скажите ''нет''
Макрос COM_INTERFACE_ENTRY_NOINTERFACE
Отладка
Макрос COM_INTERFACE_ENTRY_BREAK
Расширяемость
Макросы COM_INTERFACE_ENTRY_FUNC и COM_INTERFACE_ENTRY_FUNC_BLIND
Прямой доступ к указателю this
Интерфейсы отдельных объектов
Резюме

ГЛАВА 7. Сохраняемость в ATL
Обзор сохраняемости в COM
Интерфейсы IPropertyBag и IPersistPropertyBag
Интерфейсы IPropertyBag2 и IPersistPropertyBag2
Реализация IPersistPropertyBag
Интерфейсы IStream, IPersistStreamInit и IPersistStream
Реализация IPersistStreamInit
Интерфейсы IStorage и IPersistStorage
Классы реализации сохраняемости в ATL
Таблица свойств
Реализации сохраняемости
Таблица свойств
Реализация IPersistPropertyBagImpl
Реализация IPersistStreamInitImpl
Реализация IPersistStorageImpl
Дополнительные реализации сохраняемости
Интерфейс IPersistMemory
Реализация интерфейса IPersistMemory
Использование шаблона IPersistMemoryImpl
Добавление семантики маршалинга по значению с помощью сохраняемости
Резюме

ГЛАВА 8. Коллекции и перечисления
Интерфейсы коллекций и перечислений COM
Стандартные контейнеры и итераторы С++
Коллекции и перечислители COM
Перечисления и Visual Basic 6.0
Серверная сторона перечисления
Перечисление массивов
Класс CComEnum
Классы политик копирования
Класс CComEnumImpl
Использование CComEnum
Перечисления для стандартных коллекций C++
Класс CComEnumOnSTL
Интерфейс IEnumOnSTLImpl
Использование CComEnumOnSTL
Преобразование данных по требованию
Предоставление собственной копии данных CComEnumOnSTL
Вычисление данных по требованию
Коллекции
Класс ICollectionOnSTLImpl
Использование ICollectionOnSTLImpl
Стандартные коллекции C++ типов данных ATL
Адаптер интеллектуальных типов ATL
Использование класса CAdapt
Использование ICollectionOnSTLImpl с CAdapt
Коллекции ATL
Класс CAtlArray
Класс CAtlList
Класс CAtlMap
Объектные модели
Реализация объекта верхнего уровня
Реализация объекта коллекции
Реализация подобъектов
Использование объектной модели
Резюме

ГЛАВА 9. Точки соединения
Обзор точек соединения
Интерфейс IConnectionPoint
Интерфейс IConnectionPointContainer
Создание соединяемого объекта с помощью ATL
Пример проблемы и ее решение
Семь шагов к соединяемому объекту
Создание объекта, принимающего события
Как все это работает: детали реализации
Классы, используемые источником событий
Классы, используемые приемником событий
Резюме

ГЛАВА 10. Работа с окнами
Структура приложения Windows
Класс CWindow
Обертка HWND
Использование CWindow
Класс CWindowImpl
Класс окна
Обработка сообщений
Отражение и перенаправление сообщений
Сцепление таблиц обработчиков сообщений
Класс CDialogImpl
Отображение диалогового окна
Простые диалоговые окна
Обмен данными и их проверка
Обертки оконных элементов управления
Управление дочерними окнами
Улучшенный класс оберток
Класс CContainedWindow
Родительское окно, обрабатывающее сообщения дочерних
Создание внутренних окон
Создание подклассов внутренних окон
Обертки в классе CContainedWindow
Резюме

ГЛАВА 11. Элементы управления ActiveX
Обзор элементов управления ActiveX
Функциональность элементов управления ActiveX
Функциональность страниц свойств
Требования к элементу управления BullsEye
Требования: свойства и методы
Требования: события
Создание заготовки для элемента управления с помощью мастера ATL
Задание настроек для класса реализации CBullsEye
Базовые классы, используемые в генерируемых мастером классах
Сгенерированные файлы с исходным кодом элемента управления
Начальная версия объявления класса CBullsEye
Базовая версия интерфейса IBullsEye
Базовая версия интерфейса диспетчеризации _IBullsEyeEvents
Создание элемента управления BullsEye - шаг за шагом
Стандартные свойства и методы
Пользовательские свойства и методы
Стандартные и пользовательские события
Отрисовка элемента управления по требованию
Сохраняемость свойств
Интерфейс IQuickActivate
Категории компонентов
Интерфейс ICategorizeProperties
Последовательный просмотр свойств
Работа с клавиатурой и элементы управления ActiveX
Резюме

ГЛАВА 12. Использование элементов управления
Размещение элементов управления в контейнерах
Простейший вариант использования элемента управления
Создание элемента управления
Классы окон CAxWindow2 и AtlAxWinLic80
Использование элемента управления
Прием событий, генерируемых элементами управления
Изменения свойств
Фоновые свойства
Размещение страниц свойств
Сохраняемость элемента управления
Трансляция акселераторов
Размещение элементов управления в диалоговых окнах
Добавление элемента управления к ресурсам диалогового окна
Класс CAxDialogImpl
Присоединение объекта CAxWindow
Метод GetDlgControl
Составные элементы управления
Декларативные пользовательские интерфейсы для элементов управления
Класс CComCompositeControl
Прорисовка составных элементов управления
Элементы управления HTML
Генерация элемента управления HTML
Создание элементов управления HTML
Расположение элементов
Доступ к коду HTML из элемента управления
Прием событий элемента WebBrowser
Доступ к элементу управления из HTML
Обработка событий элементов HTML в C++
Расширенная работа с пользовательским интерфейсом
Размещение HTML не ограничивается элементами управления HTML
Ограничения использования элементов управления в ATL
Резюме

ГЛАВА 13. Здравствуй, ATL Server
Web-платформа Microsoft (Internet Information Services)
IIS и ISAPI
DLL расширений ISAPI
Простейшее работоспособное расширение ISAPI
Написание расширения
Конфигурирование сервера
Конфигурирование проекта
Обертки для ISAPI
Обертки для запросов и ответов
ATL Server
Здравствуй, ATL Server
Web-сервисы в ATL Server
Работа с Web-службой в C++
Почему ATL Server плохо подходит для создания Web!служб
Резюме

ГЛАВА 14. Внутренняя структура ATL Server
Реализация ISAPI в ATL Server
Производительность и многопоточность
Пул потоков ATL Server
Файлы ответа сервера
Выбор обработчиков запросов
Обработчики запросов
Пример обработчика запросов
Обработка ввода
Обмен данными и их проверка
Регулярные выражения
Управление сессиями
Использование состояния сессии
Реализации состояний сессии
Кеширование данных
Кеширование блоков в памяти
Кеширование файлов
Резюме

ПРИЛОЖЕНИЕ А. Шаблоны C++ в примерах
Для чего нужны шаблоны
Основные элементы шаблонов
Специализации шаблонов
Шаблоны как базовые классы
Альтернативный вариант полиморфизма
Использование классов поведения
Имитация динамического связывания
Шаблоны функций
Шаблоны методов
Резюме

ПРИЛОЖЕНИЕ Б. Заголовочные файлы ATL

ПРИЛОЖЕНИЕ В. Переход к ATL 8
Строки, наборы символов и преобразования
Макросы преобразования символов
Стандартная библиотека C с усиленной безопасностью
Общие классы с MFC
Реализация COM-серверов
Класс CComModule
Макрос OBJECT_MAP
Элементы управления ActiveX и их размещение
Изменения в ATL_MIN_CRT
Резюме

ПРИЛОЖЕНИЕ Г. Атрибуты в ATL
Основы атрибутов в ATL
Введение в атрибуты
Создание COM!сервера на ATL с атрибутами
Код, генерируемый атрибутами
Будущее атрибутов в ATL
Резюме

Предметный указатель

Предисловие ко второму изданию

Прошло много времени с тех пор, как я написал предисловие к первому изданию этой книги. Сейчас, читая старое предисловие, я погружаюсь в воспоминания. Я с трудом могу поверить, что прошло почти восемь лет. Вскоре после его написания я вошел в команду разработчиков Windows в Microsoft, затем, спустя год, ушел из нее, снова вернулся (на этот раз в команду Visual C++) и сейчас работаю с несколькими командами разработчиков, связанными с Visual C++. Одна из этих команд занимается библиотеками, в том числе и ATL, и мне приятно снова работать с ATL. Ян и Кристиан уже ушли из этой команды, а Ненад вынес оконные классы ATL, которые я упоминал в старом предисловии, в отдельную библиотеку, которая называется WTL (Windows Template Library). Сейчас WTL - это проект Microsoft с открытыми исходными кодами, которым управляет Ненад.

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

Когда я упоминал в старом предисловии "новые способы доступа к функциональности", я имел в виду атрибуты. Эта технология появилась в Visual Studio .NET 2002, но она так и не стала тем, на что мы рассчитывали. Атрибуты работают и в новой версии Visual Studio, и они дают немало интересных возможностей. Однако развивать их дальше не планируется. В новой версии этой книги атрибуты рассматриваются, но она не предполагает, что вы будете активно их использовать. Кроме того, в этой версии есть хороший обзор ATL Server, позволяющий быстро создавать эффективные Web-приложения. Если для вас прежде всего важна производительность, ATL Server - это именно то, что вам нужно. Среди других новшеств ATL 8 следует упомянуть новые функции безопасности, поддержку 64-битовых вычислений, лучшую масштабируемость, улучшенные возможности отладки, поддержку C++/CLI и управляемых компонентов ATL.

В 1998 году то, что сейчас превратилось в платформу .NET, только зарождалось. Для многих программистов .NET стала революцией, и с течением времени эта платформа будет обрастать все новыми возможностями. Однако программирование под COM (в том числе с использованием ATL) по-прежнему востребованно, и им занимаются множество программистов и в Microsoft, и вне ее. Второе издание этой книги, как и первое, содержит детали, которые позволят вам извлечь максимум пользы из этих технологий.

Джим Спрингфилд (Jim Springfield)

Апрель 2006 года

Предисловие к первому изданию

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

Краткая история ATL

Я впервые столкнулся с шаблонами в 1995 году, когда был разработчиком в команде, работавшей над MFC. Мой друг в то время изучал варианты STL от разных разработчиков, выбирая наиболее подходящий для включения в Visual C++, и он постоянно обсуждал со мной шаблоны. Я немного повозился с шаблонами, но особо ими не заинтересовался. Позже из команды Visual C++ была выделена отдельная группа, занимавшаяся исключительно Visual C++ 4.2 Enterprise (первый продукт Visual C++ серии Enterprise). В этой группе я отвечал за библиотеки. В то время мы рассматривали целый ряд идей. В то время Microsoft Transaction Server только зарождался, и мы много говорили о COM, транзакциях, базах данных и коммерческих приложениях. Вскоре мы поняли, что нам нужен более удобный механизм создания объектов COM в C++. В то время со мной работали Ян Фалкин (Jan Falkin) и Кристиан Бомонт (Christian Beaumont). Ян занимался интерфейсом автоматизации для источников данных ODBC (предшественником современных потребительских шаблонов OLEDB). Я работал над инфраструктурой COM, потому что уже в то время все сводилось к COM.

На первых порах я просто пробовал то одно, то другое, но постепенно мне стало понятно, что нужно сосредоточиться на нескольких базовых концепциях. Я с самого начала хотел обеспечить поддержку всех потоковых моделей, но не хотел тратить на эту поддержку ресурсы, если она оказывалась не востребованной. То же самое относилось и к агрегированию. Я не хотел, чтобы у кого-то были поводы отказываться от ATL (вроде, да, ATL - это круто, но я могу сэкономить пару байтов там и тут, если сделаю все сам). Таким образом производительность и гибкость стали первоочередными требованиями, и ценой за их выполнение стала сложность. Одной из основных идей стало то, что на самом деле должны создаваться объекты не того класса, который напишет пользователь. Такой подход позволял реализовать множество оптимизаций, которые в других вариантах были невозможны. Среди других концепций были множественное наследование для интерфейсов, функции "создателей" и таблицы макросов. Мы продемонстрировали результаты наших усилий и получили в общем положительные отзывы. Некоторые люди считали, что мы должны предоставить наши достижения потребителям как можно быстрее, поэтому сетевой выпуск состоялся в начале лета 1996 года. Это была ATL 1.0. Рабочим названием для нее было MEC (Microsoft Enterprise Classes), но спецы по маркетингу решили, что нам нужно придумать что-то, более четко отражающее назначение библиотеки. Поскольку эта библиотека предназначалась для работы с COM, а в то время в названиях чего угодно обязательно присутствовало слово Active, мы решили назвать библиотеку Active Template Library. Отзывы о ней были неплохи, и в конце лета 1996 года мы выпустили ATL 1.1. К тому времени Ян и Кристиан стали работать непосредственно над ATL. В ATL 1.1 был исправлен ряд ошибок и добавлены новые возможности, например, поддержка точек соединения, служб NT, реестровых скриптов RGS и функций безопасности.

Выпустив ATL 1.1, мы начали работу над ATL 2.0. В ней основной целью было упрощение создания элементов управления ActiveX. Ян и Кристиан много работали над этой задачей, а я по-прежнему возился с базовыми механизмами (например, переписал точки соединения, чтобы сделать их более компактными). В то время к нам присоединился Ненад Стефанович (Nenad Stefanovic), который занялся поддержкой оконных классов в ATL и поддержкой составных элементов управления в Visual C++ 6.0. Изначально мы планировали распространять ATL 2.0 по сети для Visual C++ 4.2. Однако позже наши планы изменились - мы собрались выпустить ATL 2.0 вместе с Visual C++ 5.0 (в декабре 1996 года) и выпустили ATL 2.1 c альфа-версией Visual C++ 5.0. Единственным отличием ATL 2.1 от ATL 2.0 были несколько исправленных ошибок для платформ Alpha, MIPS и PowerPC. Кроме того, мы одновременно выпустили ATL 2.1 в сети вместе с поддержкой мастеров для Visual C++ 4.2. После пары месяцев работы над ATL 3.0 (в то время она называлась ATL 2.5) Кристиан и я перегорели и решили на некоторое время переключиться на другую работу, а ведущим разработчиком ATL стал Ян. Через несколько месяцев мы вернулись, и ведущим разработчиком стал Кристиан, а я занялся некоторыми другими вещами в Visual C++, хотя, как и раньше, время от времени работаю с исходными кодами.

В июне 1998 года мы выпустили Visual C++ 6.0 и начали работу над следующей версией. В ATL появилось много новых классов и новые способы доступа к ранее существовавшим классам. Я рад, что ATL продолжает развиваться, позволяя в то же время генерировать компактный, быстрый код. Читайте эту книгу, учитесь новым фокусам и разбирайтесь в том, как все это работает.

Джим Спрингфилд

Октябрь 1998

Введение

Платформа .NET пронеслась по миру Windows-разработчиков, как торнадо, мгновенно сделав привычные нам способы написания программ устаревшими. В ней есть практически все, что нужно для Web-приложений и служб, а также для бизнес-приложений, для которых раньше мы использовали Visual Basic и MFC.

Однако существуют упрямые разработчики, которые перейдут на новую платформу и забросят свои прежние наработки только под угрозой расстрела. Это люди с многолетним опытом программирования на чистом C++, недоверчиво относящиеся к новомодным ключам компиляторов, превращающим их код в "управляемый". Они не станут переносить свой код на новую платформу, независимо от того, выгодно это или нет. Отчасти эта книга предназначена именно для них, если их можно убедить перенести проекты с ATL 3/Visual Studio 6 на ATL 8/Visual Studio 2005.

На других разработчиков, обитающих в "трущобах" Windows, торнадо не оказывают воздействия - они вообще не замечают этих торнадо. Эти разработчики создают приложения, которые должны работать на любых системах, начиная с Windows 95, со слишком старыми процессорами и малыми объемами памяти для .NET. Они не могут позволить себе роскошь тратить драгоценные ресурсы на сбор мусора, JIT-компиляцию или на огромные библиотеки, набитые ненужными им классами. Для них важнее всего скорость загрузки программ, их быстродействие и способность работать в любых условиях. Чтобы они стали использовать какую-то платформу, она должна быть свободна от накладных расходов на ненужные им возможности, обладать гибкостью и высокой производительностью. Именно для таких разработчиков и предназначена ATL 8, новейшая платформа для разработки Windows-приложений.

Клиентам ATL предоставляет оконные классы, интеллектуальные типы COM, поддержку элементов управления COM и размещения этих элементов, интеграцию с MFC (включая поддержку части классов MFC без необходимости использовать остальную часть MFC) и генерацию интерфейсов Web-служб. Серверам ATL предлагает поддержку COM-серверов и объектов и механизмы для реализации высокопроизводительных многопоточных Web-служб и приложений. И в клиентском, и в серверном коде в ATL широко используются макросы и шаблоны, обеспечивающие максимум гибкости при минимуме накладных расходов. Это гарантирует, что в приложения не будут включены неиспользуемые возможности, а разработчики смогут легко понять, как классы их приложений связываются с функциями платформы. Кроме того, ATL снабжена обширным набором мастеров для создания разнообразных проектов.

Атрибуты

Как попытка повысить продуктивность труда разработчиков в ATL 7 и Visual Studio 2003 в ATL появились атрибуты, которые позволяли добавлять в исходный код элементы метаданных, обычно использовавшиеся в файлах IDL и дополнительных ресурсах (например, атрибут uuid). Собственно говоря, все были в таком восторге от появления атрибутов, что в Visual Studio 2003 все мастера по умолчанию генерировали код с атрибутами. Однако в том, что касается атрибутов, отнюдь не все так безоблачно. В .NET и IDL атрибуты являются частью модели программирования; они поддерживаются повсеместно. В ATL атрибуты представляют собой просто надстройку над компилятором, вроде супермакросов, которая генерирует базовые классы, таблицы макросов, реестровые скрипты и файлы IDL.

Однако в отличие от макросов атрибуты в ATL не являются прозрачными - вы не можете ясно увидеть, какой код будет сгенерирован для каждого атрибута. У компилятора есть ключ, который должен позволять просмотреть этот код, но в Visual Studio 2005 этот ключ работает с ошибками. Соответственно, появились проблемы с отладкой программ, в которых использовались атрибуты. Я не хочу сказать, что в остальном в ATL (или вообще в какой-то программе) ошибок нет, но если ошибки находятся в базовых классах или макросах, их можно было обойти. Собственно говоря, солидная часть кода в первом издании этой книги как раз и была предназначена для обхода ошибок.

Определенные признаки в Visual Studio 2005 показывают, что атрибуты, похоже, перестали считаться будущим ATL. Например, ключи компилятора, связанные с атрибутами, выдают меньше информации. Однако самое важное знамение - то, что мастера в Visual Studio 2005 больше не генерируют код с атрибутами по умолчанию. Поэтому в этом издании мы не будем использовать атрибуты во всех главах, хотя им и посвящено приложение Г, "Атрибуты в ATL". По моему скромному мнению, вам вряд ли понравится применять в своих проектах атрибуты, если вы не можете точно выяснить, что они делают.

Кому адресована эта книга

Она адресована программистам, использующим C++/COM и собирающимся перейти на ATL 8, работая в Visual Studio 2005. ATL основывается на ряде предположений, и чтобы эффективно ее использовать, вы должны понимать не только, как устроена ATL, но и почему она устроена именно так, а не иначе. Разумеется, чтобы понять это, вам нужно понять, в какой среде ATL создавалась: COM. Вместо того чтобы спрессовать в пару глав все, что вам нужно знать о COM, авторы предполагают, что вы уже знаете COM, поэтому мы будем рассматривать только непосредственно ATL. Если вы хотите изучить COM, попробуйте почитать, например, книгу Box D. Essential COM (Addison-Wesley Professional, 1997).

Структура книги

За исключением первой главы каждая глава в книге требует прочтения предшествующих глав. Глава 1 представляет собой краткий обзор областей применения ATL и мастеров, помогающих в работе с ней. Однако если приходится погружаться в детали, эта глава будет отсылать вас к главам, в которых эти детали рассматриваются.

Главы 2-5 посвящены ядру ATL. В главе 2, "Строки и текст", рассматриваются вопросы, связанные с обработкой строк в C++, COM и ATL. В главе 3, "Интеллектуальные типы ATL", обсуждаются интеллектуальные типы, например, CComPtr, CComQIPtr, CComBSTR и CComVariant. Глава 4, "Объекты в ATL", посвящена реализации объектов в ATL и возможным вариантам реализации интерфейса IUnknown. В главе 5, "COM-серверы", рассматривается код, предоставляющий доступ к COM-объектам через COM-серверы. В главе 6, "Таблицы интерфейсов", мы возвращаемся к реализациям IUnknown, но на этот раз сосредотачиваемся на реализации метода QueryInterface; в этой главе рассматриваются отделяемые интерфейсы и агрегирование. Главы 7, "Сохраняемость в ATL", 8, "Коллекции и перечислители", и 9, "Точки соединения", посвящены соответственно поставляемым с ATL реализациям интерфейсов, предоставляющих поддержку сохраняемости объектов, коллекций и перечислителей и точек соединения. Главы 10, "Работа с окнами", 11, "Элементы управления ActiveX", и 12, "Использование элементов управления", посвящены созданию оконных приложений и компонентов пользовательских интерфейсов. В них рассматриваются оконные классы ATL, элементы управления и использование этих элементов в программах. И наконец, главы 13, "Здравствуй, ATL Server", и 14, "Внутренняя структура ATL Server", посвящены ATL Server, части ATL, позволяющей создавать Web-приложения на основе IIS. В главе 13 рассматриваются ISAPI и основы работы с ATL Server, а в главе 14 - внутренние механизмы ATL Server.

Значительная часть сложностей в разборе исходного кода ATL вызвана широким применением в ней шаблонов. Создание и применение шаблонов подробно рассматриваются в приложении А, "Шаблоны C++ в примерах". Если вы просматривали исходный код ATL и вам интересно, зачем имя производного класса передается в качестве параметра шаблону базового класса, это приложение вам пригодится. В приложении Б, "Заголовочные файлы ATL", приведен список заголовочных файлов с кратким описанием содержимого каждого файла. Это приложение позволит быстро найти файл, содержащий нужную часть ATL. Если вы уже знакомы с ATL 3 и хотите быстро узнать, что нового появилось в ATL 8, для вас предназначено приложение В, "Переход к ATL 8". И наконец, если вы хотите побольше узнать об атрибутах (и о том, почему мы вынесли их обсуждение в последнее приложение), прочитайте приложение Г, "Атрибуты в ATL".

Код примеров и дополнительная информация

Исходный код примеров из книги и дополнительная информация доступны по адресу http://www.sellsbrothers.com/writing/atlbook. Кроме того, на этом сайте вы можете оставить отзыв о книге или сообщить о найденных ошибках.

Об авторах

Крис Таварес (Chris Tavares) в данный момент работает инженером по разработке программного обеспечения в Microsoft, изучая методики эффективной разработки ПО на платформах Microsoft. Он впервые начал эксперименты с компьютером в третьем классе, вручную составляя программы в машинных кодах для машины с процессором Intel 8080, 512 байтами (да, байтами) оперативной памяти и 7-сегментным ЖК-дисплеем.

Кирк Фертитта (Kirk Fertitta) работает в компании Pacific MindWorks, передовом поставщике измерительных и контрольных электронных устройств. Он активно занимается технологиями генерации кода и дополнениями к Visual Studio. Кроме того, он работает инструктором по .NET/C# в компании Pluralsight.

Брент Ректор (Brent Rector), президент и основатель компании Wise Owl Consulting - известный оратор, консультант и автор, специализирующийся на .NET, ASP.NET, XML, COM+ и ATL.

Крис Селлз (Chris Sells) работает менеджером по программному обеспечению в компании Connected Systems Division. Он написал несколько книг, например, Programming Windows Presentation Foundation, Windows Forms Programming in C# и ATL Internals. В свободное время Крис участвует в различных конференциях и проявляет худшие стороны своего характера, обсуждая на закрытых форумах продукты Microsoft. Дополнительная информация о Крисе и его проектах доступна на сайте http://www.sellsbrothers.com.