Что такое atl visual studio
После нажатия на кнопку Finish (Готово) Visual Studio . NET начнет генерирование файлов согласно параметрам по умолчанию мастера проекта сервера ATL . Любой из упомянутых в шаге 3 шаблонов ( ATL Server Web Service [Веб-служба сервера ATL ] или ATL Server Project [Проект сервера ATL ]) сгенерирует в Visual Studio . NET два проекта. Стартовый проект представляет собой главный проект, имя которого мы ввели в диалоговом окне New Project (Новый проект). Второй генерируемый проект носит то же имя, что и стартовый, но к его имени добавляется окончание ISAPI . Создаваемому проекту ATL Server присвоено имя NewSimpleATLServer (см. рис. 4.3). В Visual Studio . NET имеется Solution Explorer (Обозреватель решения) для просмотра проектов и связанных с ними файлов. В его окне представлено иерархическое дерево проектов и файлов, связанных с открытым в данный момент программным решением. Solution Explorer можно открыть с помощью команды View\ Solution Explorer (Вид\Обозреватель решения). В окне Solution Explorer мы видим проекты NewSimpleATLServer и NewSimpleATLServerISAPI . Проект NewSimpleATLServer содержит код, специфичный для приложения. Его результатом является DLL -библиотека веб-приложения и файл ответа сервера (SRF). Продуктом проекта NewSimpleATLServerISAPI является только ISAPI DLL .
После установки относительного пути , имени виртуального каталога и связей приложения для проектов в решении ATL Server реализация файлов произойдет при первом же выполнении команды построения.
Поскольку сложная конфигурация ATL Server требует запуска программы Hello World , разработчик должен хорошо разбираться в процессах, происходящих внутри IIS и технологии . NET . Использование мощи ATL Server очень выгодно для разработки, но требует серьезных навыков и знаний от программиста.
Совет. Если при работе с IIS и ATL Server по непонятной причине возникают неполадки, попробуйте перезапустить веб-службы. Это помогает, если разработчик или системный инженер установил связь с расширением ISAPI вручную, либо после внесения изменений в конфигурацию экземпляра IIS или виртуального каталога.
Библиотека шаблонных классов ATL — это набор классов C++, которые позволяют создавать небольшие и быстрые объекты модели COM. Он имеет специальную поддержку для основных компонентов модели COM, включая стандартные реализации, сдвоенные интерфейсы, стандартные интерфейсы перечислителя COM, точки подключения, перемещаемые интерфейсы и элементы управления ActiveX.
в этом разделе
Введение в модель COM и ATL
Объясняет основные понятия модели COM. В этой статье также приводится краткое описание библиотеки ATL и вариантов ее использования.
Основы COM-объектов ATL
Описание отношений между различными классами ATL и реализации этих классов.
Сдвоенные интерфейсы и ATL
Описание сдвоенных интерфейсов с точки зрения ATL.
Коллекции и перечислители ATL
Описание реализации и создания коллекций и перечислителей в ATL.
Основные сведения о составном элементе управления
Содержит пошаговые инструкции для создания составного элемента управления. Составной элемент управления — это тип элемента управления ActiveX, который может содержать другие элементы управления ActiveX или элементы управления Windows.
Вложение элемента управления ATL: вопросы и ответы
Рассматриваются основные вопросы, связанные с размещением элементов управления с помощью ATL.
Поддержка ATL для элементов управления DHTML
Содержит пошаговые инструкции для создания элемента управления DHTML.
Точки подключения ATL
Описание точек подключения и их реализации библиотекой ATL.
Обработка событий и ATL
Описание действий, которые необходимо выполнить для обработки событий COM с помощью классов библиотеки ATL IDispEventImpl и IDispEventSimpleImpl.
ATL и бесплатный потоковый модуль упаковки
Содержит сведения о параметре мастера простых объектов ATL, который позволяет классу вычислять упаковщик в режиме свободного потока (FTM).
Указание потоковой модели проекта
Описывает макросы, доступные для контроля производительности в среде выполнения в связи с потоками в проекте.
Классы модулей ATL
Описывает новые классы модуля в ATL 7.0. Классы модуля реализуют базовые возможности, необходимые для библиотеки ATL.
Службы ATL
Описывает последовательность событий, возникающих при реализации службы. Также рассказывает о некоторых понятиях, связанных с разработкой службы.
Классы окон ATL
Описывает способы создания и настройки суперкласса и подкласса окон в ATL. Классы окон ATL не совпадают с классами COM.
Классы коллекций ATL
Описывает, как использовать массивы и схемы в ATL.
Компонент реестра ATL (регистратор)
Описывает синтаксис и заменяемые параметры в скрипте ATL. Также описывает настройку статической ссылки на регистратор.
Программирование с помощью ATL и кода Run-Time C
Описывает преимущества статического или динамического связывания в библиотеке среды выполнения C (CRT).
Программирование с использованием CComBSTR
Рассматривает несколько ситуаций, требующих осторожности при программировании с использованием CComBSTR .
Справочник по кодировке
Описывает функции и макросы, которые поддерживают кодирование в различных распространенных стандартах Интернета, например uuencode, шестнадцатеричная кодировка и UTF8 в atlenc.h.
Справочник по служебным программам
Предоставляет код для управления путями и URL-адресами в форме CPathT и CUrl. Пул потоков CThreadPool можно использовать в собственных приложениях. Этот код можно найти в файлах atlpath.h и atlutil.h.
Связанные разделы
Учебник по ATL
Описывает создание элементов управления и демонстрирует некоторые основные сведения об ATL в процессе.
Примеры ATL
Предоставляет описания и ссылки на примеры программ ATL.
Создание проекта ATL
Содержит сведения о мастере проектов ATL.
Атрибутивное программирование
Общие сведения об использовании атрибутов для упрощения программирования с моделью COM, а также ссылки на более подробные разделы.
Общие сведения о классе ATL
Предоставляет справочные сведения и ссылки на классы ATL.
В интернете существует множество учебников по использованию ATL, и в частности, по созданию COM-компонентов с его помощью, в том числе и ActiveX/OLE контролов, но большинство из них почему-то описывают процесс тыкания мышкой в разные интересные места Visual Studio, использование графических инструментов последней, и мало какой из них затрагивает нутро сгенерированного средой разработки кода в достаточно глубоком объеме. В русскоязычном сегменте интернета ситуация и того хуже — материалов по ATL крайне мало, практически нет(да и не только по ATL, а и по созданию COM-компонентов вообще), поэтому я решил этот недостаток компенсировать.
Ну, начать следует, наверное, с краткого описания того, что из себя представляют ActiveX-компоненты и что такое ATL.
ActiveX это ребрендинг аббревиатуры OLE, «Object Linking and Embedding», технологии от Microsoft, основанной на COM, Component Object Model — языконезависимой компонентной модели, придуманной MS. OLE позволяет встраивать отдельные контролы, документы, да или просто компоненты в разные программы, написанные на разных языках программирования, работающие под Windows. ActiveX-контролы, в частности, известны тем, что их можно «вклеивать» в веб-браузер Internet Explorer, и одним из самых известных таких компонентов для IE является, к примеру, модуль Adobe Flash.
Интерфейс ActiveX-компонента поставляют с собой многие известные и популярные программы для Windows, как от самой Microsoft(Windows Media Player, или, например, программы из Microsoft Office, в частности Word, Excel и т.п.), так и от сторонних компаний(уже вышеупомянутый флеш, Adobe Reader, плюс многие другие программы того же Adobe — например Photoshop, если я правильно помню).
Есть мнение, что технология устаревает, или уже устарела, но тем не менее, я лично считаю, что она просто вытесняется в область низкоуровневого программирования и системных сервисов, и пока ядро Windows пишется на Си, а многие компоненты системы используют COM, и основаны на COM-интерфейсах, она уж точно никуда не денется.
Теперь про то, что такое ATL. ATL, Active Template Library — известная библиотека от Microsoft, которая упрощает работу с Winapi на C++. В ATL входят классы/шаблоны не только для работы с COM/OLE/ActiveX, но и классы для, к примеру, построения и управления GUI и т.п.
ATL обычно поставляется с полноценными версиями Microsoft Visual Studio, но если у вас ее нет, то можете взять эту библиотеку из Windows DDK.
Так вот, в данной статье я опишу процесс создания простенького компонента, который будет у нас средствами DirectX 11 рисовать крутящуюся растеризованную в wireframe сферу, и у которого будет два метода — Run — запустить вращение сферы, и Stop — остановить вращение.
Для начала нам нужно придумать интерфейс нашего модуля, придумать GUID для библиотеки, интерфейсов и класса компонента, и записать все это, как водится, в MIDL, Microsoft Interface Definition Language.
Сохраним это дело в файл, и назовем MyActiveX.idl
Как видно, мы записали определение двух интерфейсов, а также описание COM-класса, который реализует наши интерфейсы. Первый, IMyControl, у нас представляет собой собственно интерфейс компонента, а второй нужен для оповещения внешнего мира о событиях, которые случаются с нашим контролом. Событий у нас не записано, и мы их делать в нашем примере не будем, поэтому этот интерфейс у нас пустой.
Интерфейс, реализуемый нашим классом, относится к так называемым dual-интерфейсам. Это значит, что его можно использовать не только из языков, способных на общение с native-кодом, а соответственно, и способных общаться с COM-компонентами через таблицы виртуальных методов, но и из скриптовых языков, посредством интерфейса IDispatch.
Далее нам нужно записать определения IMyControl и _IMyControlEvents в заголовочном файле для C++ — MyControl.hpp
Макрос MIDL_INTERFACE раскрывается во что-то вроде «struct __declspec(novtable) __declspec(uuid(строка GUID для интерфейса))». Microsoft довольно удобно интегрировали COM в свой компилятор C++, и это позволяет(и дальше это будет видно особенно хорошо) нам работать с интерфейсами и компонентами COM из MSVC++, как с более-менее обычными классами и структурами C++.
Макрос DEFINE_GUID же, в свою очередь, раскрывается в зависимости от определения макроса INITGUID — в случае отсутствия оного, он декларирует extern-переменную типа GUID с определенным названием. В случае INITGUID, он ее еще и инициализирует.
Теперь следует определить переменную _Module, которая принадлежит классу CComModule из ATL.
Запишем декларацию переменной в отдельный заголовочный файл, скажем MyActiveX.hpp
CComModule это класс, реализующий функциональность COM-модуля, в частности регистрацию классов компонентов, инициализацию COM-сервера и прочие подобные вещи.
Для регистрации COM-серверов в реестре(а COM работает именно через реестр) мы могли бы написать reg-файл, или вручную создать в реестре соответствующие записи, но также мы можем использовать программу regsvr32.exe, входящую в состав Windows, и позволяющую проводить автоматическую регистрацию, средствами самого компонента. Для этого необходимо, чтобы наша библиотека экспортировала некоторые функции, и в частности DllRegisterServer и DllUnregisterServer.
CComModule упрощает весь процесс автоматической регистрации, и позволяет сводить ее к вызову соответствующих методов в вышеупомянутых экспортируемых функциях библиотеки, но ему требуется, чтобы в секции ресурсов dll, реализующего компонент, находился скрипт регистрации. Назовем файл, который мы позже добавим в ресурсы, MyControl.rgs, и добавим туда такой текст:
Наиболее значимые части скрипта регистрации — CLSID, то есть GUID класса нашего компонента, ProgID, т.е. человекочитаемое представление CLSID, и ThreadingModel — модель многопоточности нашего компонента, которая в данном случае устанавливается в Apartment, что значит что напрямую к нашему контролу можно обращаться только из того потока, в котором он был создан, а все внешние вызовы, в том числе извне процесса(или даже с другого компьютера — через DCOM) будут сериализоваться и синхронизироваться средствами рантайма COM.
Кстати, о сериализации, то есть, вернее сказать, о маршалинге. В теории, для того чтобы сериализовать вызовы методов нашего компонента и указатели на его интерфейсы, мы должны поставить параллельно с ним отдельную библиотеку, так называемую прокси-dll, которая будет подгружаться как в клиентское приложение(если оно на другом компьютере), так и к процессу, куда загружен наш COM-компонент.
Компилятор MIDL от Microsoft мог бы генерировать код для прокси-библиотеки, или как она в данном случае называлась бы, proxy/stub, но в нашем случае можно поступить проще — так как типы данных у нас более-менее стандартные, мы может использовать встроенный маршалинг рантайма OLE. Для данного дела нам нужно из нашего IDL-файла, опять же средствами компилятора MIDL, midl.exe(входит в состав как Windows SDK, так и VS), скомпилировать так называемую библиотеку типов(type library, tlb), и поставить с нашим компонентом ее. Более того, мы можем еще дальше упростить все это дело, и включить скомпилированную библиотеку типов в секцию ресурсов DLL, что мы и сделаем.
Заголовочный файл для ресурсов нашего модуля:
IDR_MYCONTROL — id ресурса скрипта регистрации.
IDB_MAIN_ICON — иконка 16x16 для нашего компонента, в формате BMP. Я лично для этого файла взял иконку DirectX из MS DirectX SDK.
IDS_SHADER и SHADER_RESOURCE — id ресурса и типа ресурса, содержащего код шейдеров для отрисовки сферы.
Сам файл ресурсов, MyActiveX.rc, такой:
Теперь перейдем непосредственно к реализации нашего контрола.
Назовем класс CMyControl, и создадим заголовочный файл CMyControl.hpp
Как видно, определение класса получилось довольно большим.
Для реализации ActiveX-контрола наш класс, на самом деле, должен реализовать крайне немаленькое количество разнообразных COM-интерфейсов, начиная от IDispatch, но так как мы используем ATL, процесс очень сильно упрощается, благодаря наследованию от специальных классов, названия которых оканчиваются на «Impl», которые собственно говоря, и реализуют необходимую для интерфейсов функциональность в стандартном виде.
Три наиболее важных базовых класса нашего CMyControl — CComObjectRootEx, управляющий, в частности, подсчетом ссылок объектов нашего класса, CComCoClass, реализующий фабрику класса(IClassFactory), и CComControl, в свою очередь наследующийся от CWindowImpl(класс, обертывающий HWND, то есть дескриптор окна), и реализующий большую часть необходимой для встроенных ActiveX-контролов фунциональности.
Наиболее значимые макросы в теле класса:
DECLARE_REGISTRY_RESOURCEID — указывает id ресурса, в котором находится скрипт регистрации компонента.
BEGIN_COM_MAP + END_COM_MAP — реализуют метод QueryInterface интерфейса IUnknown(который является вершиной иерархии интерфейсов COM), который позволяет получать ссылки на разные интерфейсы объекта(и каждая из COM_INTERFACE_ENTRY указывает один из вариантов).
BEGIN_CONNECTION_POINT_MAP и соответствующий END — необходимы для реализации интерфейсов, связанных с оповещениями о событиях контрола.
Вся функциональность нашего компонента, и, в частности, работа с Direct3D, реализуется приватным классом CMyControlImpl, согласно паттерну pimpl, в файле CMyControl.cpp. Я не буду в деталях его описывать, отмечу только то, что в конструкторе самого CMyControl необходимо выставить внутреннее свойство m_bWindowOnly в TRUE — это будет означать, что наш компонент поддерживает встраивание исключительно в графические приложение.
Также, стоит отметить что в реализации компонента для управления подсчетом ссылок на COM-интерфейсы активно используется шаблонный класс умного указателя CComPtr из ATL, очень похожий на intrusive_ptr из boost.
Теперь создадим файл MyActiveX.cpp, в котором у нас будет определены GUID класса и интерфейсов, переменная _Module, а также реализована точка входа DLL и необходимые для ActiveX-модуля экспортируемые функции:
Прежде чем скомпилировать dll, определим, какие функции наш модуль экспортирует, в def-файле:
Весь исходный код проекта, включая Makefile для сборки с помощью Windows SDK, приведен на github, по ссылке в конце статьи. Но сначала несколько примеров встраивания компонента:
предполагая, что я только используя их для "нормальных" GUI-программ (без COM, без ActiveX, ничего необычного), в чем принципиальная разница, которую я увижу между ATL и MFC, чтобы помочь мне понять, какой из них использовать?
"ATL-это быстрый и простой способ создания com-компонента на C++ и поддержания небольшого объема. Используйте ATL для создания элемента управления, если вам не нужны все встроенные функции, которые автоматически предоставляет MFC."
на самом деле не отвечает на мой вопрос, потому что:
Я не работать с COM.
означает ли это MFC не быстро? Почему / как?
" MFC позволяет создавать полные приложения, элементы управления ActiveX и активные документы. Если вы уже создали элемент управления с MFC, вы можете продолжить разработку в MFC. При создании нового элемента управления рассмотрите возможность использования ATL, если вам не нужны все встроенные функции MFC."
также не отвечает мой вопрос, потому что:
Я даже не знаю, что такое ActiveX is в первую очередь.
похоже, что Microsoft не поощряет использование MFC, но я не могу понять, почему.
что именно is "встроенная функциональность" MFC, которую ATL не предоставляет?
В общем, это не ответ на мой вопрос потому что это не объясняет минусы и их причины.
потому что прямо или косвенно все, кажется, связано с предыдущей страницей:
"ATL & MFC несколько сложнее выбрать. [[не шучу!]] Я бы сослался вам!--91-- > страница MSDN для выбора, чтобы выбирать между ними."
очевидно, это не ответ на мой вопрос. :)
что я в настоящее время наблюдается (в течение последних нескольких дней, при попытке узнать оба):
- ATL основан на шаблонах или полиморфизме времени компиляции.
- методы ATL, как правило, не являются виртуальными и имеют тенденцию возвращать ссылки.
- методы MFC, как правило, виртуальные и, как правило, возвращают указатели.
но тогда, если нет никакой реальной разницы, кроме аспекта времени компиляции и времени выполнения, то почему они оба существуют? Разве одного из них недостаточно?
что я пропустила?
Я думаю, что ответ на ваш вопрос в основном исторический, если вы оглянетесь на то, как две библиотеки возникли и развивались во времени.
короткий ответ: если вы не делаете ничего "причудливого", используйте ATL. Он отлично подходит для простых пользовательских интерфейсов с COM.
долгий ответ: MFC был построен в начале 90 - х годов, чтобы опробовать этот новый язык под названием C++ и применить его к Windows. Это сделало Office как функции, доступные для сообщества разработчиков, когда у ОС их еще не было.
[Edit embellishment: я не работал в Microsoft, поэтому я не знаю, был ли Office когда-либо построен на MFC, но я думаю, что ответ нет. В Win 3.1, Win 95 days, команда Office UI будет изобретать новые элементы управления, упаковывать их в библиотеки, а затем команды Windows и MFC будут включать обертки и API для этих элементов управления с распространяемыми библиотеками DLL. Я бы предположил, что между этими командами было немного сотрудничества и совместного использования кода. В конце концов те элементы управления сделают его базовой операционной системой в пакетах обновления или следующей версии Windows. Этот шаблон продолжался с лентой Office, которая была добавлена в Windows в качестве дополнительного компонента после отправки Office и теперь является частью ОС Windows.]
в то время библиотека была довольно примитивной, как из-за языка C++, так и из-за того, что компилятор был новым, и Microsoft создавала его с течением времени по мере развития Office.
из-за этой истории, MFC:
- имеет довольно неуклюжий дизайн. Он начинался как легкая обертка вокруг Windows API, но рос. Есть куча маленьких "функций", которые нужно было изобрести, потому что компилятор и язык просто не поддерживали их. Не было шаблонов,они изобрели класс string, они изобрели классы list, они разработали свою собственную идентификацию типа времени выполнения и т. д.
- инкапсулирует 20 лет Office и Windows evolution, которая включает в себя целую нагрузку дерьма из вещей, которые вы, вероятно, никогда не будете использовать: один и несколько интерфейсов документов, DDE, COM, COM+, DCOM, связывание документов и встраивание (так что вы можете встраивать документ word в свое приложение, если хотите), элементы управления ActiveX (эволюция встраивания объектов для интернета!), Структурированное хранение документов, сериализация и управление версиями, автоматизация (с ранних лет VBA) и, конечно же, MVC. Последние версии поддерживают стыковку окон в стиле Visual Studio и ленту Office. В основном каждая технология из Редмонда через 20 лет где-то там. Он просто огромный!
- имеет тонну маленьких gotchas, ошибок, обходных путей, предположений, поддержки вещей, которые все еще там, что вы никогда не будете использовать, и они вызывают проблемы. Вы должны быть хорошо знакомы с реализацией многих классов и тем, как они взаимодействуют, чтобы использовать его в проекте приличного размера. Распространено погружение в исходный код MFC во время отладки. Нахождение 15-летней технической заметки на некотором указателе, являющемся нулевым, вызывает авария все еще происходит. Предположения об инициализации древнего документа, встраивающего материал, могут повлиять на ваше приложение странным образом. В MFC нет такой вещи, как абстракция, вам нужно ежедневно работать с ее причудами и внутренними особенностями, она ничего не скрывает. И не заставляй меня начинать с классного мастера.
ATL был изобретен по мере развития языка C++, и появились шаблоны. ATL была демонстрацией того, как использовать шаблоны, чтобы избежать проблем во время выполнения MFC библиотека:
[Edit Embellishment: во время создания ATL техническая дорожная карта Microsoft была в основном сосредоточена на "управлении документами". Apple убивала их в настольном издательском бизнесе. Документ Office ' Увязка и внедрение "было одним из основных компонентов повышения" управления документацией " функции офиса, чтобы конкурировать в этом пространстве. COM была основной технологией, изобретенной для интеграции приложений, и API внедрения документов были основаны на COM. MFC было трудно использовать для этого случая использования. ATL было хорошим решением, чтобы сделать эту конкретную технологию проще для 3-й стороны реализовать COM и использовать функции встраивания документов.]
эти небольшие улучшения делают ATL чрезвычайно легче дело с простым приложением, которое не нуждается во всех офисных, как функции MFC. Что-то с простым пользовательским интерфейсом и некоторой автоматизацией Office. Это маленький, это быстро, это время компиляции, экономя много времени и головной боли. MFC имеет огромную библиотеку классов, которые могут быть неуклюжими и трудными для работы.
[Edit Embellishment: Microsoft поняла, что эта "интернет-вещь" будет большой. Их техническая дорожная карта резко изменилась, чтобы сосредоточиться на Internet Explorer, Windows Server, IIS, ASP, SQL Server, COM/DCOM в распределенном сервере транзакций. Таким образом, связывание и внедрение документов больше не было приоритетным.]
огромный след MFC сделал невозможным для них сбросить, поэтому он все еще развивается медленно. Шаблоны были включены обратно в библиотеку, а также другие улучшения языка и API. (Я не слышал о WTL, пока не увидел этот вопрос. :)
в конечном итоге, какой из них использовать-это просто вопрос предпочтений. Большинство функций, которые вам нужны, находятся в базовом API ОС, который вы можете вызвать непосредственно из любой библиотеки, если в библиотеке нет подходящей оболочки.
только мои 2 цента, основанные на использовании MFC в течение многих лет,и я использую его ежедневно. Я баловался ATL когда он был впервые выпущен на нескольких проектах в течение пары лет. В те дни это был глоток свежего воздуха, но никогда никуда не уходил. А потом появилась паутина, и я забыл о ней.
Edit: этот ответ имеет удивительную долговечность. Поскольку он продолжает появляться на моей странице переполнения стека, я подумал, что добавлю некоторые украшения к первоначальному ответу, который, как я думал, отсутствовал.
Active Template Library (ATL) is a lightweight library used to develop COM-based components using Visual C++. Through ATL we can quickly develop COM components or COM services.
In this article, I am trying to explain the steps to create an ATL COM component using Microsoft Visual C++ and Microsoft Visual Studio 2012 IDE (Integrated Development Environment).
Step 1. Open Visual Studio 2012 IDE.
Step 2. Click on the File menu. Visual Studio will display a pull-down menu.
Visual Studio – File – New menu
Step 3. From the pull-down menu, select New menu item. This will show a sub-menu.
Step 4. From the sub-menu, select the “New Project…” menu item. Visual Studio will display the “New Project” dialog; where it displays project types in the left side pane; once the project type is selected, its associated templates are displayed in its middle pane.
Visual Studio 2012 – “New Project” dialog – “ATL Project” template
Step 5. Select Installed node from left side pane. Visual Studio expands the node and shows its sub-nodes.
Step 6. Select the ATL project type under the “Visual C++” sub-node. Visual Studio displays the “ATL Project” template in the middle pane. Select the “ATL Project” template. This template will create an ATL project to enable to use of Active Template Library (ATL).
Step 7. Now we need to name the project and select the location where we want to store the project.
- Enter the name of the project in the “Name:” field.
- Select the location where to store the project in the “Location:” field. I know the path where to store the project, we can directly enter the path in the “Location:” field. Otherwise, select the “Browse…” button to select the location where to store the created project from the “Project Location” dialog.
- Provide the solution name in the “Solution name:” field.
- Check the “Create the directory for solution” checkbox. This will create a solution and projects in different folders. Otherwise, solutions and projects will create in the same folder.
Step 8. Click on the OK button to create the ATL-based project. Visual Studio will start creating the project. It will display the “ATL Project Wizard” dialog to allow to selection of application settings.
Visual Studio 2012 – “ATL Project Wizard” – Overview wizard
Step 9. Click on the Next button on the “ATL Project Wizard” dialog to go to the “Application Settings” wizard.
Step 10. From the “Application Settings” wizard:
- Select the “Dynamic-link library (DLL)” option; which is under the “Application type:” group. This option will create a DLL project. That means, we cannot run the project as self-executable. But we can load this project into the other applications. To create it as an executable select EXE as an application type.
- To support MFC(Microsoft Foundation Classes) framework, select the “Support MFC” checkbox from the “Support options:” options.
- Then click on the Finish button.
Visual Studio will create a project and generate some code. We have created our project using the “ATL Project” template; so, this template creates most of the common functionality of the COM component to make our job much easier. That means, for example, we no need to write functionality to register the ATL COM component with the registry; because the functionality has been written for us already.
Now we need to add our functionality to the project. We will discuss it in our next article.
Читайте также: