vc调用c#写的dll

来源：互联网发布：热门聊天软件编辑：程序博客网时间：2024/05/16 02:00

转自：http://www.codeproject.com/csharp/ManagedCOM.asp

Download source - 5.21 Kb

Preface

COM Interoperability is the feature of Microsoft .NET that allows managed .NETcode to interact with unmanaged code using Microsoft's Component Object Model semantics.

This article is geared towards C# programmers who are familiar with developing COM components and familiar with the concept of an interface. I'll review some background on COM, explain how C# interacts with COM, and then show how to design .NET components to smoothly interact with COM.

For those die-hard COM experts, there will be some things in this article that are oversimplified, but the concepts, as presented, are the important points to know for those developers supplementing their COM code with .NET components.

Introduction

.NET Interfaces and Classes

The basis for accessing .NET objects either from other .NET code or from unmanaged code is the Class. A .NET class represents the encapsulation of the functionality (methods and properties) that the programmer wants to expose to other code. A .NET interface is the abstract declaration of the methods and properties that classes which implement the interface are expected to provide in their implementations. Declaring a .NET interface doesn't generate any code, and a .NET interface is not callable directly. But any class which implements ("inherits") the interface must provide the code that implements each of the methods and properties declared in the interface definition.

Microsoft realized that the very first version of .NET needed a way to work with the existing Windows technology used to develop applications over the past 8+ years: COM. With that in mind, Microsoft added support in the .NET runtime for interoperating with COM - simply called "COM Interop". The support goes both ways: .NET code can call COM components, and COM code can call .NET components.

Using the code

Steps to create a Managed .NET C# COM Object:

Open VS.NET2003->New Project->Visual C# Projects->Class Library.
Project name: MyInterop.

Create MyDoNetClass.cs file, and add the following lines of code:

using System.Runtime.InteropServices;                using System.Windows.Forms;

Create an Interface IMyDotNetInterface.
Create a class MyDoNetClass.

Add the following line for MyDotNetClass:

[ClassInterface(ClassInterfaceType.None)]

Although a .NET class is not directly invokable from unmanaged code, Microsoft has provided the capability of wrapping a .NET interface in an unmanaged layer of code that exposes the methods and properties of the .NET class as if the class were a COM object. There are two requirements for making a .NET class visible to unmanaged code as a COM object:

Requirement 1:

You have to add GUIDs - Globally Unique Identifiers - into your code for the interface and the class separately, through a GUID tool.

Now, create a GUID for the Interface, and add the following line for the interface:
```
[Guid("03AD5D2D-2AFD-439f-8713-A4EC0705B4D9")]
```
Now, create a GUID for the class, and add the following line for the class:
```
[Guid("0490E147-F2D2-4909-A4B8-3533D2F264D0")]
```

Your code will look like:

using System;                using System.Runtime.InteropServices;                using System.Windows.Forms;                namespace MyInterop                {                [Guid("03AD5D2D-2AFD-439f-8713-A4EC0705B4D9")]                interface IMyDotNetInterface                {                void ShowCOMDialog();                }                [ClassInterface(ClassInterfaceType.None)]                [Guid("0490E147-F2D2-4909-A4B8-3533D2F264D0")]                class MyDotNetClass : IMyDotNetInterface                {                // Need a public default constructor for COM Interop.                public MyDotNetClass()                {}                public void ShowCOMDialog()                {                System.Windows.Forms.MessageBox.Show(“I am a" +                "  Managed DotNET C# COM Object Dialog”);                }                }                }

Compile the solution.
You will see inside the project directory->obj->debug directory, the file “MyInterop.dll” generated after compilation.

Requirement 2:

Registration of the COM Class and Interfaces

For a COM class to be accessible by the client at runtime, the COM infrastructure must know how to locate the code that implements the COM class. COM doesn't know about .NET classes, but .NET provides a general "surrogate" DLL -mscoree.dll -- which acts as the wrapper and intermediary between the COM client and the .NET class.

Hard-code a specific version number in your AssemblyVersion attribute in theAssemblyInfo.cs file which is in your project.
Example:
```
[assembly: AssemblyVersion("1.0.0.0")]
```
Create a strong-name key pair for your assembly and point to it via the AssemblyKeyFile attribute in the AssemblyInfo.cs file which is in your project. Example:
```
sn -k TestKeyPair.snk
```
```
[assembly: AssemblyKeyFile("TestKeyPair.snk")]
```
Add your assembly to the GAC using the following command:
```
gacutil /i MyInterop.dll
```
Register your assembly for COM by using the REGASM command along with the "/tlb" option to generate a COM type library.
```
REGASM MyInterop.dll /tlb:com.MyInterop.tlb
```
Close the C# project.

Steps to create an Unmanaged C++ application to call a .NET Managed C# COM

Open VS.NET2003->New Project->Visual C++ Projects->Win32->Win32 Console Project.
Name: DotNet_COM_Call.

Include the following line in your DoNet_COM_Call.cpp file:

#import “<Full Path>\com.MyInterop.tlb" named_guids raw_interfaces_only

Compile the solution.
It will generate a “com.myinterop.tlh” file into your project->debug directory.
You can open this file and see the contents. This is basically the proxy code of the C# COM code.
Now, you can write the code to call the .NET Managed COM.

Please add the following lines of code before calling the COM exported functions:

CoInitialize(NULL);   //Initialize all COM Components                // <namespace>::<InterfaceName>                MyInterop::IMyDotNetInterfacePtr pDotNetCOMPtr;                // CreateInstance parameters                // e.g. CreateInstance (<namespace::CLSID_<ClassName>)                HRESULT hRes =                pDotNetCOMPtr.CreateInstance(MyInterop::CLSID_MyDotNetClass);                if (hRes == S_OK)                {                BSTR str;                pDotNetCOMPtr->ShowCOMDialog ();                //call .NET COM exported function ShowDialog ()                }                CoUninitialize ();   //DeInitialize all COM Components

Run this console application.
Expected result: a managed code (C# ) dialog should appear with the string “I am a Managed DotNET C# COM Object Dialog”.

Points of Interest

While creating an Interface for COM exported functions, creating GUIDs for the Interface and the class and registering the class are required steps, and doing all this is always interesting and fun. Calling parameterized exported functions also is very interesting.

About Atul Mani

Atul Mani Tripathi has been a professional developer since 1997 and working as a senior consultant with Cognizant Technology Solutions (CTS) .

Most of the time, his focus is on creating a clean and simple solution to development problems. He is a C++, Visual C++ and C# (Dot NET) guy who loves Visual Studio, Google, Code Project and developing personal projects.

首先对COM+组件的写法需要注意以下几点:

1.接口,事件,方法,属性必须是public,

2.方法和属性必须在接口中声明,事件也必须在事件接口中声明.

否则将在VC中无法调用,在接口中声明主要是为了在COM 中的vtab中.

3.必须对接口中的方法,属性,事件前声明[DispId(1)]

4.每个接口都必须有一个GUID

5.而且项目一定需要是COM Interop,并且具有强命名

示例:

//接口声明
[Guid("694C1820-04B6-4988-928F-FD858B95C880")]
    public interface DBCOM_Interface
    {
        [DispId(1)]
        void Init(string userid , string password);
        [DispId(2)]
        bool ExecuteSelectCommand(string selCommand);
        [DispId(3)]
        bool NextRow();
        [DispId(4)]
        void ExecuteNonSelectCommand(string insCommand);
        [DispId(5)]
        string GetColumnData(int pos);
    }
// // 事件接口声明
    [Guid("47C976E0-C208-4740-AC42-41212D3C34F0"),
    InterfaceType(ComInterfaceType.InterfaceIsIDispatch)]
    public interface DBCOM_Events
    {
    }
//对于实现类的声明
    [Guid("9E5E5FB2-219D-4ee7-AB27-E4DBED8E123E")]
    ClassInterface(ClassInterfaceType.None),
//不产生类接口,如果需要产生声明为ClassInterfaceAttribute
    ComSourceInterfaces(typeof(DBCOM_Events))]
//声明产生一个COMSource的事件列表
    public class DBCOM_Class : DBCOM_Interface
    {
    }

在VC中的调用方法如下:

在VC++中进行组件调用的步骤(以DBCOM.tlb为例)：

1、在头文件中导入类型库tlb 

#import “DBCOM.tlb” 

2、初始化COM以及产生智能指针(一般是在需要调用COM组件中提供的方法时就需要产生指向该接口的智能指针) 

CoInitialize(NULL);//初始化COM 
DBCOM::DBCOM_Interface p((__uuidof(DBCOM::DBCOM_Class ))); //名字空间：：接口Ptr p((__uuidof(名字空间：：类))) 
DBCOM::DBCOM_Interface * Test=p; //名字空间：：接口指向接口的智能指针

3、调用COM中的方法

_bstr_t m_string=”select * from user”; //传入参数
bool bRet=Test-> ExecuteSelectCommand(m_string);//调用ExecuteSelectCommand方法

4、释放环境

先贴上后面在结合已经做过的项目进行修改