COM组件与DLL制作及调用示例教程

钭胥冉

于 2024-09-14 15:54:21 发布

阅读量1.1k

点赞数 20

本文链接：https://blog.csdn.net/weixin_35899324/article/details/142287848

版权

本文还有配套的精品资源，点击获取

简介：在Windows开发中，DLL是用于共享代码和资源的组件，而COM技术则提供了一种实现跨语言组件互操作性的标准。本教程将介绍DLL和COM组件的基础知识，包括如何创建和使用DLL，特别是通过COM接口的实例。教程内容包括FirstCom示例DLL的创建、MFC类库在DLL调用中的应用，以及控制台程序对DLL的调用方式。通过实例源码的分析和编译调试，学习者能够深入理解DLL和COM组件，并掌握它们在Windows平台编程中的应用。 Com的dll制作和调用实例源码

1. 动态链接库（DLL）的概念和优势

在现代软件开发中，动态链接库（Dynamic Link Library，简称DLL）是实现代码复用和模块化的重要技术手段。DLL文件是一组程序代码、数据和资源的集合，这些代码和数据可以在运行时被多个程序共享。相较于静态库，DLL提供了更灵活的代码管理方式，能够在不重新编译整个应用程序的情况下更新或替换。

DLL的优势在于： 1. 模块化设计 ：开发者可以将应用程序分割成独立的模块，每个模块实现特定的功能，便于管理和维护。 2. 资源优化 ：DLL文件被加载到内存后，可以在多个运行的应用程序之间共享，减少内存占用。 3. 动态加载 ：程序可以根据需要动态加载或卸载DLL，提供更灵活的扩展性和升级能力。

为了深入理解DLL的工作机制，下一章将探讨COM组件如何实现跨语言和跨进程的互操作性，进而更好地展现DLL在实际开发中的应用价值。

2. COM组件的跨语言和跨进程互操作性

2.1 COM组件的原理与结构

2.1.1 接口和实现的分离

COM（Component Object Model）组件的核心在于其接口和实现的分离原则。在COM中，接口（Interface）是定义了一组方法的抽象类，这些方法可以由多种编程语言实现。而具体实现（Implementation）则是接口的一个或多个方法的具体逻辑。

接口定义使用IDL（Interface Definition Language）文件，它描述了接口的名称、方法和参数。实现部分则是在具体的COM对象中进行编码，对象通常由COM类工厂创建。

为了维持接口与实现的分离，COM定义了两个重要的概念：引用计数和虚函数表（v-table）。引用计数允许一个对象知道有多少个客户拥有对它的引用，这样当最后一个引用释放时，对象可以自行销毁。虚函数表则用于运行时解析接口方法到相应对象的实现。

2.1.2 COM的全局唯一标识符（GUID）

为了保证组件的唯一性，COM定义了一种全局唯一标识符（GUID）。每个COM接口、类和组件都有一个唯一的GUID。它通常通过工具生成，并保证在全球范围内唯一。

GUID在COM中的应用包括：

接口标识符（Interface Identifier，IID）：用于识别特定的接口。
类标识符（Class Identifier，CLSID）：用于标识具体的类实现。
应用程序唯一标识符（AppID）：用于应用程序或服务。

GUID的使用使得跨语言、跨进程的组件能够被唯一识别和引用，这是COM互操作性的关键之一。

2.2 COM组件的互操作性实现

2.2.1 语言无关性

COM组件的另一个显著优势是其语言无关性。COM不依赖于任何特定的编程语言，它使用标准的接口定义和二进制标准，这意味着COM组件可以用任何支持COM的语言进行编写和调用。

语言无关性的实现主要依赖于以下机制：

抽象接口 ：所有交互都是通过接口来完成的，不依赖于具体的语言。
虚拟函数表（v-table） ：方法调用是通过v-table完成的，这样可以不用关心对象是用什么语言实现的。
标准数据类型转换 ：COM定义了一套标准的数据类型转换规则，以保证不同语言间的数据可以互换。

2.2.2 进程间通信机制

COM组件还支持跨进程通信（IPC），使得组件可以在不同的地址空间中运行。这是通过代理（proxy）和存根（stub）机制实现的。代理和存根是一个中间层，它们负责在不同进程间转发方法调用和数据。

代理和存根机制的运作流程大致如下：

客户端通过接口指针调用方法。
代理拦截该调用，并将其序列化为可以在另一进程中识别的格式。
系统将序列化后的调用传递给目标进程的存根。
存根解析调用，将其转换为对目标对象的实际调用。
目标对象执行后，将结果返回给存根。
存根将结果反序列化，并传递回代理。
代理将结果返回给客户端。

这个过程使得COM组件能够在保持组件独立性的同时，实现复杂的交互和资源共享。

. . . 使用C++编写COM组件的代码示例

#include <windows.h>
#include <iostream>

// 定义COM接口
IFACEMETHODIMP Add(int a, int b, int* result) {
    *result = a + b;
    return S_OK;
}

// 导出函数，供COM使用
HRESULT DllCanUnloadNow() { return S_OK; }
HRESULT DllGetClassObject(REFCLSID, REFIID, LPVOID*) { return E_NOTIMPL; }
HRESULT DllRegisterServer() { return E_NOTIMPL; }
HRESULT DllUnregisterServer() { return E_NOTIMPL; }

// DLL入口点
BOOL APIENTRY DllMain(HMODULE hModule, DWORD ul_reason_for_call, LPVOID lpReserved) {
    switch (ul_reason_for_call) {
    case DLL_PROCESS_ATTACH:
    case DLL_THREAD_ATTACH:
    case DLL_THREAD_DETACH:
    case DLL_PROCESS_DETACH:
        break;
    }
    return TRUE;
}

在这个示例代码中，我们定义了一个简单的COM接口，它包含了一个 Add 方法。同时，我们声明了几个导出函数，这些是DLL运行时必须的。 DllMain 是DLL的入口点，处理进程的附加和分离事件。

. . . 创建COM类工厂的代码示例

// COM类工厂的实现
class CClassFactory : public IClassFactory {
public:
    IFACEMETHODIMP CreateInstance(IUnknown* pUnkOuter, REFIID riid, void** ppvObject) override {
        if (pUnkOuter != NULL)
            return CLASS_E_NOAGGREGATION;
        // 实例化COM对象，这里应该是具体的创建逻辑
        // 例如:
        // CComObject<YourCOMClass>* pYourCOMClass = NULL;
        // HRESULT hr = CComObject<YourCOMClass>::CreateInstance(&pYourCOMClass);
        // if (FAILED(hr)) return hr;
        // return pYourCOMClass->QueryInterface(riid, ppvObject);
        return E_NOTIMPL;
    }

    IFACEMETHODIMP LockServer(BOOL fLock) override {
        return E_NOTIMPL;
    }
};

在这里，我们创建了一个COM类工厂 CClassFactory ，它是 IClassFactory 接口的实现。 CreateInstance 方法负责创建COM对象的实例。这个工厂类将被用于客户端请求对象时。

以上代码片段展示如何使用C++编写COM组件和COM类工厂。实际创建COM组件涉及到更多的步骤，包括注册组件、使用注册表或Windows清单等，以确保COM组件可以在操作系统中被正确地注册和识别。

. . . 注册COM组件的代码示例

// 注册COM组件
HRESULT RegisterClassFactory() {
    CLSID clsid;
    HRESULT hr = CLSIDFromProgID(L"YourComProgID", &clsid);
    if (SUCCEEDED(hr)) {
        IClassFactory* pClassFactory = new CClassFactory();
        hr = RegisterClassObject(clsid, pClassFactory);
    }
    return hr;
}

// 注销COM组件
HRESULT UnregisterClassFactory() {
    CLSID clsid;
    HRESULT hr = CLSIDFromProgID(L"YourComProgID", &clsid);
    if (SUCCEEDED(hr)) {
        hr = RevokeClassObject(clsid);
    }
    return hr;
}

在上面的示例中， RegisterClassFactory 函数注册了COM组件。它首先获取组件的CLSID，然后创建类工厂的实例，并通过 RegisterClassObject 函数注册。相应地， UnregisterClassFactory 函数取消注册。

这个过程是通过 IClassFactory 接口的 RegisterClassObject 方法来完成的，它是将组件的类工厂注册到系统的COM子系统中，以便客户端能够通过 CoCreateInstance 或 CoGetClassObject 创建组件实例。

请注意，由于COM涉及到很多底层操作和二进制兼容性的细节，因此这里展示的代码仅为概念性的示例，实际的COM组件开发会更加复杂，并且需要遵循COM的标准流程和约定。

3. FirstCom示例DLL的设计和实现

3.1 FirstCom DLL的设计思路

3.1.1 模块功能规划

在设计DLL时，首先需要明确该DLL的功能，比如是作为数据处理模块、通信模块还是用户界面模块。在我们的FirstCom示例中，我们将其设计为一个简单的数学运算模块，提供加、减、乘、除等基本运算功能。这种功能模块化的设计思路有助于提高代码的复用性、维护性和扩展性。模块功能规划应该包括功能的描述、输入输出要求以及与其他模块的交互关系。

3.1.2 接口定义与实现

在确定了模块的功能后，接下来就是定义模块对外提供的接口。接口定义需要明确方法名、参数列表以及返回值。在FirstCom DLL中，我们可以定义如下接口：

extern "C" __declspec(dllexport) double Add(double a, double b);
extern "C" __declspec(dllexport) double Subtract(double a, double b);
extern "C" __declspec(dllexport) double Multiply(double a, double b);
extern "C" __declspec(dllexport) double Divide(double a, double b);

这些接口将会被导出，并且可以在其他程序中被调用。实现这些接口的内部逻辑就是典型的函数编写工作，例如：

double Add(double a, double b) {
    return a + b;
}

3.2 FirstCom DLL的编码实现

3.2.1 类与方法的封装

将功能相似的方法封装到类中是一种常见的设计模式。在FirstCom DLL中，我们可以创建一个 Calculator 类，将所有的运算方法都封装在这个类中。这样做的好处是，当运算逻辑发生变化时，只需修改类内部的方法实现即可，而调用接口则保持不变。这个类的简单实现如下：

class Calculator {
public:
    double Add(double a, double b) {
        return a + b;
    }

    double Subtract(double a, double b) {
        return a - b;
    }

    double Multiply(double a, double b) {
        return a * b;
    }

    double Divide(double a, double b) {
        return b != 0 ? a / b : 0; // 简单处理除数为0的情况
    }
};

3.2.2 实例化与资源管理

在DLL中进行实例化时，需要考虑资源的管理和内存泄漏的问题。例如，在上述 Calculator 类中，如果我们在类的构造函数中分配了资源，则必须确保在析构函数中释放这些资源。DLL中实例化对象和资源管理的关键点在于确保所有资源在不再需要时都能够被正确释放。

为了在DLL中创建 Calculator 类的实例，我们可以使用工厂方法模式，提供一个静态方法来创建实例：

class Calculator {
public:
    static Calculator* CreateInstance() {
        return new Calculator();
    }
};

在客户端调用时，客户端负责删除由 CreateInstance 返回的实例：

Calculator* calc = Calculator::CreateInstance();
// 使用calc进行计算...
delete calc;

通过这种方式，我们保持了DLL的封装性和资源管理的简洁性。这种方式也容易被其他编程语言调用，因为只需要遵循C++的命名规范即可。

4. MFC类库在DLL调用中的使用

4.1 MFC类库概述

4.1.1 MFC的基本组成

Microsoft Foundation Classes（MFC）是一套C++类库，由微软提供，用于简化Windows平台下的应用程序开发。MFC封装了许多底层的API调用，让开发者能够用面向对象的方式来编写Windows程序。MFC的核心功能包括窗口管理、图形设备接口（GDI）、对话框、控件、文档/视图架构、网络、数据库和通用的数据访问等。

在DLL的使用场景中，MFC不仅可以简化DLL本身的开发流程，还可以让DLL的功能更加丰富，与Windows应用程序更加紧密地集成。MFC封装的类和对象可以作为DLL对外提供的接口的一部分，使得客户端程序能够以直观的对象操作方式与DLL交互。

4.1.2 MFC在DLL中的应用

MFC应用在DLL中，可以创建两种类型的DLL：常规DLL和扩展DLL。常规DLL使用MFC的静态链接库，它们可以被非MFC应用程序调用。扩展DLL则使用MFC的动态链接库（DLL版本的MFC），它们主要被其他MFC应用程序调用。

在创建MFC扩展DLL时，主要的工作是导出MFC类的派生类实例。为了与客户端应用程序交互，通常将类的实例化和操作封装在 DLL 中，并通过函数指针或直接导出类的成员函数来进行接口调用。

4.2 MFC DLL的构建与调用

4.2.1 MFC DLL的分类

MFC DLL主要有两种类型：Regular DLL（常规DLL）和Extension DLL（扩展DLL）。这两者的主要区别在于它们支持的应用程序类型和内部使用的技术。

常规DLL使用MFC的静态链接库。这些DLL可以被使用C++和C的非MFC应用程序调用。它们通常包含一些可以被任意应用程序使用的函数。

扩展DLL使用MFC的动态链接库。这些DLL被设计为扩展MFC类库的。它们通常为MFC应用程序提供特定的功能。扩展DLL必须使用MFC的共享版本，即使是MFC的非 Unicode版本。

4.2.2 MFC DLL与客户端的交互

MFC DLL与客户端的交互通常涉及以下几个步骤：

导出类和函数 ：在扩展DLL中，需要导出类的构造函数和成员函数。这样，客户端可以创建DLL内部类的实例，并调用这些函数。
实例化与管理 ：DLL需要提供机制来处理客户端对类实例的创建、使用和销毁。这通常通过创建工厂函数来完成，这些函数由客户端调用，用来创建对象的实例。
消息和回调 ：DLL可能需要提供回调机制或自定义消息，以便在某些事件发生时通知客户端应用程序。
资源管理 ：DLL应该负责管理内部资源，并提供清理机制，以避免资源泄漏。
文档与示例 ：为了让客户端能够正确使用DLL，开发者通常会提供详细的文档和示例代码。

接下来，我们将深入了解如何创建一个MFC DLL，并探讨它如何被控制台程序或图形界面应用程序调用。我们将详细分析代码样例，并展示如何将MFC DLL集成到应用程序中。

5. 控制台程序对DLL的调用方法

在讨论如何实现控制台程序对DLL的调用之前，理解DLL的基本原理是关键。动态链接库（Dynamic Link Library，DLL）是一种Windows操作系统中用于实现共享函数库概念的文件格式。与静态库不同，DLL文件中的代码在运行时才被加载到内存中，多个程序可以同时使用它，这有助于减少内存的使用，提升性能。

5.1 控制台程序调用DLL的原理

5.1.1 DLL的加载机制

DLL的加载机制涉及到程序启动、运行时或运行后加载。对于控制台程序来说，主要关注的是运行时加载。当程序启动时，操作系统不会自动加载DLL，需要程序显式地调用API函数来加载。一旦加载成功，DLL中的函数就可以被程序调用。

5.1.2 导出函数的使用方法

DLL导出函数的使用方法分为两种：隐式链接和显式链接。隐式链接在编译时将DLL文件链接到应用程序中，这涉及到 #include 头文件和链接到相应的.lib文件。显式链接，则是在运行时使用API函数如 LoadLibrary 或者 LoadLibraryEx 加载DLL，之后再使用 GetProcAddress 获取函数地址来调用。

5.2 实际操作中的调用示例

5.2.1 DLL的动态加载与卸载

动态加载DLL需要使用到几个关键函数： LoadLibrary （加载DLL）、 GetProcAddress （获取函数地址）、 FreeLibrary （卸载DLL）、 GetModuleHandle （获取已加载DLL的句柄）。举一个简单的示例来演示如何使用这些API函数。

#include <windows.h>
#include <stdio.h>

int main() {
    // 加载DLL
    HMODULE hLib = LoadLibrary(TEXT("example.dll"));
    if (hLib == NULL) {
        printf("LoadLibrary failed. Error: %d\n", GetLastError());
        return 1;
    }

    // 获取函数地址
    typedef void (*MyFunction)(void);
    MyFunction myFunc = (MyFunction)GetProcAddress(hLib, "FunctionName");
    if (myFunc == NULL) {
        printf("GetProcAddress failed. Error: %d\n", GetLastError());
        FreeLibrary(hLib);
        return 1;
    }

    // 调用函数
    myFunc();

    // 卸载DLL
    FreeLibrary(hLib);
    return 0;
}

5.2.2 错误处理与异常管理

在使用DLL时，需要进行适当的错误处理和异常管理。示例代码中通过 GetLastError() 来获取错误信息并打印，这是处理DLL加载和使用过程中错误的基础方法。此外，还可以通过设置异常处理函数来捕获并处理程序运行时出现的异常情况。

DLL调用的一个关键环节是处理其返回的错误代码。在实际编程中，应该为可能的错误编写处理逻辑，以避免程序崩溃。这通常需要熟悉系统定义的错误代码，比如通过检查 GetLastError() 的返回值来实现。

通过本章节的介绍，我们了解了控制台程序与DLL交互的基本原理和方法。接下来，我们将详细介绍如何创建DLL，以及在C++中如何加载和访问DLL中的函数。

6. 创建DLL的步骤与接口定义

6.1 DLL项目的基本创建步骤

6.1.1 开发环境的搭建

在开始创建动态链接库（DLL）之前，首先需要配置好开发环境。对于C++开发人员来说，Microsoft Visual Studio是最常见的选择。以下是创建DLL的基本步骤：

打开Microsoft Visual Studio。
创建一个新项目，选择“动态链接库(DLL)”作为项目类型。
命名你的项目并选择一个位置来保存它。
点击“创建”按钮，Visual Studio会为你创建一个基本的DLL项目结构。

6.1.2 工程设置与配置

一旦创建了DLL项目，接下来就是进行工程的设置与配置。这通常包括：

预编译头文件（PCH）的配置 ：通常用于加速编译过程。
源文件和头文件的创建 ：添加你的实现代码和函数声明。
项目属性配置 ：设置输出文件名、路径，以及与DLL相关的其他属性。
导入库和依赖项的管理 ：添加必要的库文件，确保编译过程可以找到所有必需的头文件。

6.2 DLL接口的设计与导出

6.2.1 接口规范的制定

DLL接口规范是DLL用户必须遵循的规则，以确保DLL功能的正确使用。制定接口规范时，需要考虑以下几点：

函数命名约定 ：通常使用前缀来区分DLL中的函数。
函数参数与返回值 ：明确指定每个函数的参数类型和数量，以及返回值的类型。
错误处理约定 ：确保DLL和调用者之间有共同的错误处理机制。
版本管理 ：随着DLL更新，要确保旧版本的兼容性，通常通过修改DLL的版本号来实现。

6.2.2 导出函数的声明与实现

在DLL中导出函数是关键的一步。在C++中，你可以使用 __declspec(dllexport) 关键字来导出函数。下面是一个简单的示例：

// MyLibrary.h
#ifdef MYLIBRARY_EXPORTS
#define MYLIBRARY_API __declspec(dllexport)
#else
#define MYLIBRARY_API __declspec(dllimport)
#endif

extern "C" MYLIBRARY_API int Add(int a, int b); // 函数声明

在上面的代码中， MYLIBRARY_EXPORTS 宏会在编译DLL时定义，使得函数 Add 被导出。在使用DLL的客户端代码中，该宏将不会定义， Add 函数将被导入。

// MyLibrary.cpp
#include "MyLibrary.h"

MYLIBRARY_API int Add(int a, int b) {
    return a + b;
}

在实现文件中，我们使用 MYLIBRARY_API 宏来标记函数为导出。

导出函数后，你需要确保在客户端项目中正确引用DLL。这通常通过在客户端项目的配置中添加DLL的路径到系统的PATH环境变量，或者在程序中动态加载DLL。

创建DLL和设计接口是一个复杂的过程，但遵循上述步骤，可以确保DLL的开发顺利进行。

7. C++中DLL的加载和函数访问方式

7.1 DLL加载机制与方法

在C++中，DLL的加载是指将DLL文件映射到进程的地址空间的过程。这个过程可以通过两种主要方式来实现：静态加载和动态加载。

7.1.1 静态加载与动态加载的区别

静态加载通常是指在编译时，将DLL文件中的函数直接链接到可执行文件中。这种方式下，DLL必须与应用程序一起存在，且在程序启动时自动加载。它的优点是使用简单，不需要开发者手动管理DLL的加载过程；缺点是不够灵活，且若DLL版本更新，可能需要重新编译应用程序。

动态加载则是在程序运行时，通过特定的API函数手动加载和卸载DLL。常见的动态加载函数包括 LoadLibrary 和 FreeLibrary 。动态加载的优点在于灵活性高，可以根据需要加载和卸载DLL，支持热插拔。例如，应用程序可以在运行时根据配置文件或者用户的选择动态地加载所需的DLL，增加了程序的可扩展性和可维护性。

7.1.2 DLL加载的API函数

动态加载DLL通常涉及到以下几个API函数：

LoadLibrary ：加载指定的DLL文件，返回DLL模块的句柄。
GetProcAddress ：从已加载的DLL中获取指定函数的地址。
FreeLibrary ：卸载已经加载的DLL文件，减少系统的负担。

下面是使用这些API加载和使用DLL函数的简单示例代码：

// 加载DLL并获取函数地址
HMODULE hModule = LoadLibrary(TEXT("example.dll"));
if (hModule != NULL)
{
    // 获取DLL中的函数地址
    FARPROC procAddress = GetProcAddress(hModule, "FunctionName");
    if (procAddress != NULL)
    {
        // 转换得到函数指针类型
        void (*funcPtr)() = (void(*)())procAddress;
        // 调用函数
        funcPtr();
    }
    // 卸载DLL
    FreeLibrary(hModule);
}