Creating and Using a COM Object by Using Visual Studio 2005

现在的位置: 首页 > 综合 > 正文

Creating and Using a COM Object by Using Visual Studio 2005

2018年04月05日 ⁄ 综合 ⁄ 共 20675字 ⁄ 字号小中大 ⁄ 评论关闭

In this exercise, you will create a COM object that you will use from within a .NET Compact Framework 2.0 application. This exercise is the starting point for this section of the HOL, in which you will build a complete Pocket PC application through a number of exercises. As you will find out, you can use Visual Studio 2005 to create managed .NET Compact Framework applications and native C++ applications for devices—even with ATL or MFC support.

To open an existing solution and add a new project to it

On the desktop computer, click Start | All Programs | Microsoft Visual Studio 2005 | Microsoft Visual Studio 2005.
In Visual Studio 2005, click File | Open | Project/Solution.
In the Open Project dialog box, browse to C:/Program Files/Windows Mobile Developer Samples/HOLs/MEDC06_HOL301/HOL301Exercise1.
Select HOL301Exercise1.sln, and then click Open. The solution opens.
In Solution Explorer, right-click Solution 'HOL301Exercise1' (1 project), and then select Add | New Project to add a new project to the solution.
In the Add New Project dialog box under Project types, ensure that Other Languages | Visual C++ | Smart Device is selected.

Note Depending on your Visual Studio configuration, the Visual C++ project type may be located at the outer-most outline level instead of under Other Languages.
Under Templates, ensure ATL Smart Device Project is selected.
In the Name box, change the name to MyCOMObject, as shown in Figure 1.

Figure 1. Add New Project dialog box. Click the thumbnail for a larger image.
Click OK to start the ATL Smart Device Project Wizard.
The wizard is going to assist you in creating your COM object. You need to provide some basic information, but you can leave most of the settings as they are.
On the welcome page of the wizard, click Next.
On the Platforms page of the ATL Smart Device Project Wizard, as shown in Figure 2, be sure that only Windows Mobile 5.0 Pocket PC SDK is listed under Selected SDKs. Use the add and remove arrow buttons to move the appropriate SDKs.

Figure 2. Platforms page of the ATL Smart Device Project Wizard. Click the thumbnail for a larger image.
Click Next.
On the Application Settings page of the ATL Smart Device Project Wizard, be sure that Dynamic-link library (DLL) is selected under Server type, and be sure that the additional options boxes are not selected.
Click Finish to exit the wizard.
The wizard has created a new project called MyCOMObject that contains all of the code to act as a COM component. To turn this project into a meaningful COM object, you have to add functionality for your specific COM object.

To add a new class to the COM object

In Solution Explorer, right-click the MyCOMObject project, point to Add, and then click Class.

(Alternatively, you can click Project | Add Class from the Visual Studio 2005 menu.)
In the Add Class dialog box, in the Categories tree, select ATL, and be sure that ATL Simple Object is selected in the list of available templates, as shown in Figure 3.

Figure 3. Add Class dialog box. Click the thumbnail for a larger image.
Click the Add button.
The ATL Simple Object Wizard starts. In this wizard, you will give your new object a name and set some specific object settings.
On the left side of the Welcome to the ATL Simple Object Wizard page, select Names.
In the C++ Short name box, type SimpleCalc. Leave all of the other values as default, as shown in Figure 4.

Figure 4. Names page of the ATL Simple Object Wizard. Click the thumbnail for a larger image.
Click Next.
On the Options page of the ATL Simple Object Wizard, under Threading model, select Free.
Under Interface, select Custom, as shown in Figure 5.

Figure 5. Options page of the ATL Simple Object Wizard. Click the thumbnail for a larger image.
Click Finish to close the wizard and create the new class.
The ATL Simple Object Wizard has created a number of new files for you, in which you will add methods and interfaces that bring functionality to your COM object. The COM object that you are about to implement contains a few basic math functions, like add, subtract, multiply, and divide. The functionality is straightforward, but it should help you understand how a managed .NET Compact Framework application can interoperate with a COM object.

You will now work on the implementation of SimpleCalc. All methods that you are going to write will be exposed through COM interfaces. A COM client can access the methods and, thanks to COM Interop, a managed client application can access SimpleCalc's methods (as you will see in this HOL).

To implement the functionality of SimpleCalc

In Visual Studio 2005, change to Class View by clicking View | Class View or by using the keyboard shortcut CTRL+W+C.
In the Class View pane, expand MyCOMObject, right-click the interface ISimpleCalc, and then select Add | Add Method, as shown in Figure 6.
The Add Method Wizard appears. In this wizard, you will specify the signature of the method that you are going to add.

Figure 6. Adding a method to ISimpleCalc. Click the thumbnail for a larger image.
In the Add Method Wizard, type Add in the Method name box.
Type int in the Parameter type box.
Type iFirstValue in the Parameter name box.
Select the in check box under Parameter attributes.
Click the Add button.
Type int in the Parameter type box.
Type iSecondValue in the Parameter name box.
Select the in check box under Parameter attributes.
Click the Add button.
Type int* in the Parameter type box.
Type piResult in the Parameter name box.
Select the retval check box under Parameter attributes.
Click the Add button.
The Add Method Wizard's Names page should now look like Figure 7.

Figure 7. Names page of the Add Method Wizard. Click the thumbnail for a larger image.
Click Finish.
You have just created a new empty method with a COM interface. You can find the method's interface in the header file SimpleCalc.h, the (still empty) implementation in the source file SimpleCalc.cpp. Next, you will add a few more methods to the component. You will also automatically see the new methods appear in the Class View pane.
In the Class View pane, right-click the interface ISimpleCalc, and then click Add | Add Method.
Type Subtract in the Method name box.
Repeat Steps 4 through 16 to add parameters to the method. You must enter exactly the same parameters.
Repeating the same steps, add a new method called Multiply.
Again, repeating the same steps, add a new method called Divide.
The only thing left to do to finish your COM component is add functionality.
In Solution Explorer, (View | Solution Explorer View), open the file SimpleCalc.cpp by double-clicking it. You can find this file under Source Files.
Find the method CSimpleCalc::Add, and then add the following statement to the method (prior to the statement return S_OK).
Copy Code
```
*piResult = iFirstValue + iSecondValue;
```
Find the method CSimpleCalc::Subtract, and then add the following statement to the method (prior to the statement return S_OK).
Copy Code
```
*piResult = iFirstValue - iSecondValue;
```
Find the method CSimpleCalc::Multiply, and then add the following statement to the method (prior to the statement return S_OK).
Copy Code
```
*piResult = iFirstValue * iSecondValue;
```

Find the method CSimpleCalc::Divide, and then replace all of its code with the following code example.

Copy Code

if (iSecondValue != 0)
{
    *piResult = iFirstValue / iSecondValue;
    return S_OK;
}
else
{
    *piResult = 0;
    return E_FAIL;
}

Compile the COM object by clicking Build | Build Solution or by pressing F6.
Assuming you didn't get any compilation errors, you are now going to use the COM object inside a managed application.

To use the COM object inside a managed application

In Solution Explorer, browse to the project ManagedCOMClient, and then expand it (if it is not expanded already).
Open the file Form1.cs in the form designer by double-clicking it in Solution Explorer.
To save time, the user interface is already created for you, which should look like Figure 8.

Figure 8. User interface for ManagedCOMClient. Click the thumbnail for a larger image.

The next thing you will do is add functionality to the application to make use of MyCOMObject. Before you can use the COM component, you have to add a reference to it to make it available in the managed application. When you are adding a reference to a COM object, code is automatically generated by Visual Studio 2005 to be able to use your COM object inside a managed application.

You need a so-called Interop Assembly to be able to call into a COM object. The Interop Assembly contains managed definitions of COM interfaces and types. It can be generated manually by the Type Library Importer (tlbimp.exe), or it can be generated automatically by Visual Studio 2005 when you add a reference to the COM object's Type Library (*.tlb) file, which you will see in a moment. To a managed client application, the COM object looks like a managed type, as shown in Figure 9. The Runtime Callable Wrapper hides all COM details for you.

Figure 9. Calling a COM component from a managed client. Click the thumbnail for a larger image.

To generate an Interop Assembly to be able to access the COM component from within managed code, you need to add a reference to MyCOMObject.tlb.
In Solution Explorer, right-click References, and then click Add Reference to add a reference to the ManagedCOMClient project.
In the Add Reference dialog box, click the Browse tab, and then browse to MyCOMObject.tlb in C:/Program Files/Windows Mobile Developer Samples/HOLs/MEDC06_HOL301/HOL301Exercise1/MyCOMObject/Windows Mobile 5.0 Pocket PC SDK (ARMV4I)/Debug.

Note You can easily browse to the type library file by clicking the Up One Level button on the toolbar of the Add Reference dialog box, after which you can browse through the MyCOMObject project tree to reach the MyCOMObject.tlb file.
Click OK to add the selected reference to the project.
You can now use the methods from MyCOMObject as if it were a managed object, as you will see when you are adding functionality to the button click event handlers of the ManagedCOMClient application.
In Solution Explorer, right-click Form1.cs, and then click View Code.
Create an alias for the "System.Runtime.InteropServices" namespace by adding the following statement immediately under the other using statements at the beginning of the Form1.cs file (this is the file into which all other code will be added as well).
Copy Code
```
using System.Runtime.InteropServices;
```
Create an alias for your COM component by adding the following statement.
Copy Code
```
using MyCOMObjectLib;
```
Add the following instance variable to the Form1 class.
Copy Code
```
private ISimpleCalc calculator = new SimpleCalc();
```
You now have declared an interface variable of type ISimpleCalc and instantiated it with a SimpleCalc object. This is, in fact, an instantiation of your COM component.
Add the following code to the btnAdd_Click event handler.
Copy Code
```
int firstValue = Convert.ToInt32(tbValue1.Text);
int secondValue = Convert.ToInt32(tbValue2.Text);
int result = calculator.Add(firstValue, secondValue);
tbResult.Text = result.ToString();
```
As you saw when entering the Add method for the calculator, it looks like a managed object and even has full Microsoft IntelliSense support. If you compare the managed call to the Add method as defined in the COM component, you will see a remarkable difference.

The signature of the managed Add method looks like the following.
Copy Code
```
 int Add (int iFirstValue, int iSecondValue);
```
The signature of the COM Add method looks like the following.
Copy Code
```
  HRESULT Add ([in]int iFirstValue,
                                        [in]int iSecondValue, 
                                        [out, retval]int* piResult);
```
The translation of the COM method to the managed method happened automatically when you added a reference to the Type Library file.

Add the following code to the btnSubtract_Click event handler.

Copy Code

int firstValue = Convert.ToInt32(tbValue1.Text);
int secondValue = Convert.ToInt32(tbValue2.Text);
int result = calculator.Subtract(firstValue, secondValue);
tbResult.Text = result.ToString();

Add the following code to the btnMultiply_Click event handler.

Copy Code

int firstValue = Convert.ToInt32(tbValue1.Text);
int secondValue = Convert.ToInt32(tbValue2.Text);
int result = calculator.Multiply(firstValue, secondValue);
tbResult.Text = result.ToString();

Add the following code to the btnDivide_Click event handler.

Copy Code

int firstValue = Convert.ToInt32(tbValue1.Text);
int secondValue = Convert.ToInt32(tbValue2.Text);
int result = calculator.Divide(firstValue, secondValue);
tbResult.Text = result.ToString();

Compile the entire solution, including the code that you just entered by clicking Build | Build Solution or by pressing F6.
Assuming you didn't get compilation errors, you can now test the ManagedCOMClient application in the Windows Mobile 5.0 Pocket PC emulator.

To test the ManagedCOMClient application in the emulator

In Visual Studio 2005, press F5 or select Debug | Start Debugging to start the application in debugging mode.
In the Deploy ManagedCOMClient dialog box, be sure that the Windows Mobile 5.0 Pocket PC Emulator is selected, and then click the Deploy button.

Note If you receive an error during deployment that indicates that the process or file is in use, this means that the program is still running on the emulator and must be closed before a new copy can be deployed and run. This error may appear anytime in the lab that you deploy the emulator. See Appendix A in this HOL for instructions about exiting a running application.
Be sure that the emulator is visible by clicking its button in the Windows taskbar.
After a while, you will see the application running inside the Windows Mobile 5.0 Pocket PC emulator. Now it is time to test the application. It may take some time to deploy the application for the first time. The first time you are using the emulator, prior to deploying the application, the .NET Compact Framework 2.0 will be deployed to the emulator as well. When the .NET Compact Framework 2.0 is already found on the emulator, this step is skipped.
Enter different numbers in the text boxes for Value1 and for Value2.
Click all four buttons one after another, and examine the result. Every time a button is clicked, a method in the COM object is called. The running application should look like Figure 10.

Figure 10. ManagedCOMClient application running in the emulator
Enter the number 0 in the Value2 box, and then click the divide button. You will see an exception being thrown, as shown in Figure 11.

Figure 11. Exception that is thrown from the divide method call. Click the thumbnail for a larger image.

This is the default behavior when a method call of a COM object returns a value other than S_OK as HRESULT. Therefore, it is always advisable to add exception handling when calling into COM objects.
Stop the debugger by clicking Debug | Stop Debugging.

Change the code for the btnDivide_Click event handler in source file Form1.cs to the following.

Copy Code

int firstValue = Convert.ToInt32(tbValue1.Text);
int secondValue = Convert.ToInt32(tbValue2.Text);
try
{
    int result = calculator.Divide(firstValue, secondValue);
    tbResult.Text = result.ToString();
}
catch
{
    tbResult.Text = "Undefined";
}

In Visual Studio, press F5 or click Debug | Start Debugging to start the application in debugging mode.
In the Deploy ManagedCOMClient dialog box, be sure that the Windows Mobile 5.0 Pocket PC Emulator is selected, and then click the Deploy button.
Watch what happens if you enter the number 0 in the Value2 box and then click the divide button (at least the behavior is now much more acceptable, simply by adding an exception handler), as shown in Figure 12.

Figure 12. The application continues to run when attempting to divide by zero
Close the application by clicking the ok button in the upper-right corner of the application.

In the .NET Compact Framework 2.0, it is not only possible to call methods on COM components without the need to write your own wrapper. It is also possible to call back from the COM object into the managed client, thanks to the fact that the .NET Compact Framework 2.0 also allows calling from native to managed code.

You will now extend MyCOMObject by adding a new interface and implementing callback functionality. The callback functionality that you are implementing simply displays a message passed from the COM component to a managed message box. Note that even though callbacks are supported, activation of .NET types from COM is not supported.

To callback from COM into the managed client

In Solution Explorer, double-click the MyCOMObject.idl to open it. You can find the file in the tree view by clicking MyComObject | Source Files.

In the MyCOMObject.idl file, look for the definition of the line import atliface.idl, and then manually add a new interface immediately below it. Enter the following code for the new interface.

Copy Code

[
  object,
  uuid(),
  helpstring("ISimpleCalcCallBack Interface"),
  pointer_default(unique)
]
interface ISimpleCalcCallBack : IUnknown{
  [, helpstring("method ShowMsg")] HRESULT ShowMsg([in] LPTSTR 
pMsg);
};

Add a new universally unique identifier (UUID) to the interface to distinguish it from other interfaces. (You can generate a UUID in Visual Studio 2005 by clicking Tools | Create GUID.)
In the Create GUID dialog box, be sure that the Registry Format option is selected, as shown in Figure 13.

Figure 13. Generating a new GUID to identify the newly created interface
Click New GUID, and then immediately click Copy.
Click Exit to close the Create GUID dialog box.
In MyCOMObject.idl, place the cursor between the brackets behind the UUID attribute in the code that you just entered, and then paste the created GUID in there. Be sure to remove the braces that were copied as part of the GUID.
Verify that the interface you added in the MyCOMObject.idl file, including the GUID you pasted in it, looks like the following.
Copy Code
```
[
  object,
  uuid(54BE93A8-84F3-424a-AE3F-04A6EA833BD5),
  helpstring("ISimpleCalcCallBack Interface"),
  pointer_default(unique)
]
interface ISimpleCalcCallBack : IUnknown{
   [, helpstring("method ShowMsg")] HRESULT ShowMsg([in] LPTSTR 
pMsg);
};
```
Note The value of the GUID that you pasted in differs from the value that you see in this example. You have just created a new interface for your COM component, and this interface contains only one method called ShowMsg. This is the only method that the ISimpleCalcCallBack interface exposes. This method acts as the callback from managed code, so you will write the implementation for this particular interface later in managed code. First, however, you need to do something else. To store the callback function in the COM object, you have to pass a reference to it from managed code. Therefore, you will add another method to the ISimpleCalc interface.
In the Class View pane, right-click the interface ISimpleCalc, and then select Add | Add Method.
This step displays the Add Method Wizard, in which you will specify the signature of the method you are going to add.
Type Initialize in the Method name box.
Type ISimpleCalcCallBack* as the Parameter type.
Type callbackInterface in the Parameter name box.
Select the in check box under Parameter attributes.
Click the Add button, and then click the Finish button.
You have now created all interfaces, but to be able to use the callback function, you also have to implement the Initialize method.
In Visual Studio 2005, in Solution Explorer, double-click SimpleCalc.cpp to open it. You can find this file under Source Files.

Find the CSimpleCalc::Initialize method, and then add the following code to the method (prior to the statement return S_OK).

Copy Code

pClientCallback = callbackInterface;

// Because you are using a new interface for the first time, be
// sure to increment its reference count.
pClientCallback->AddRef();

// and callback into managed code for the first time
pClientCallback->ShowMsg(_T("Managed Callback installed!"));

Find the CSimpleCalc::Divide method, and then add the following code to the method to give the user an error message. Add the code prior to the statement return E_FAIL.
Copy Code
```
if (pClientCallback)
    pClientCallback->ShowMsg(_T("Oops, you should not divide by 
zero!"));
```
As you can see in the code for the Initialize method, the callback method is stored locally. However, you still need to declare a variable to store the callback method into. Finally, you are also providing some code to release the interface after you finish with the object.
In Solution Explorer, double-click SimpleCalc.h to open it. You can find this file under Header Files.
Add the following code toward the end of the CSimpleCalc class.
Copy Code
```
private:
    ISimpleCalcCallBack* pClientCallback;
```
In the SimpleCalc.h header file, look for the FinalRelease method inside the CSimpleCalc class, and then add the following code to the method.
Copy Code
```
if (pClientCallback)
    pClientCallback->Release();
```
Compile the COM component that you just extended by clicking Build | Build Solution, or by pressing F6.
Before you can use the callback functionality that you just have implemented, you need to provide the COM component with a managed function that can act as a callback. You will create the callback method as part of a new class that you will now add to the ManagedCOMClient project.
In Solution Explorer, right-click the project ManagedCOMClient, and then select Add | Class.
In the Add New Item dialog box, be sure that Class is selected in the Templates list.
Change the name of the class to NewMsgNotification.cs, and then click the Add button.
Replace all of the code in the NewMsgNotification.cs source file that you just created with the following code.
Copy Code
```
using System;
using System.Collections.Generic;
using System.Text;
using System.Windows.Forms;
using System.Runtime.InteropServices;
using MyCOMObjectLib;

namespace ManagedCOMClient
{
    public class NewMsgNotification : ISimpleCalcCallBack
    {
        public void ShowMsg(string message)
        {
            MessageBox.Show(message);
        }
    }
}
```
As you can see, the NewMsgNotification class derives from the ISimpleCalcCallBack interface, which is the interface that you created in the COM component. The interface expects one function, called ShowMsg, that is defined in the class as well. Finally, you need to connect the callback function to the COM component.
In Code view, open the Form1.cs source file in Visual Studio 2005.
Add an instance variable for the new class that you just created by adding the following code.
Copy Code
```
private NewMsgNotification newMsg = new NewMsgNotification();
```
Find the constructor of the Form1 class, and then add a call to the Initialize method of the calculator COM object to tell the COM object what callback function to use (add the following statement immediately under InitializeComponent()):
Copy Code
```
calculator.Initialize((ISimpleCalcCallBack)newMsg);
```
In Visual Studio, press F5 or click Debug | Start Debugging to start the application in debugging mode.
In the Deploy ManagedCOMClient dialog box, be sure that the Windows Mobile 5.0 Pocket PC Emulator is selected, and then click the Deploy button.
After a while, you will see the application running inside the Windows Mobile 5.0 Pocket PC emulator. Immediately, you will notice that a message appears and informs you that the managed callback is installed, as shown in Figure 14.

Figure 14. Managed callback installation dialog box. Click the thumbnail for a larger image.

This message box resides inside managed code (in the newly created class), but it is called from inside the COM component. Now, watch what happens if you divide by zero.
Click ok to close the message.
Type 1 in the Value1 box, and then type 0 for Value2.
Click the divide button, and verify that another message appears, as shown in Figure 15.

Figure 15. The divide by zero message
Click ok to close the message, and then close the application by clicking the ok button in the upper-right corner of the application.

This step concludes the first exercise. You have created a COM component by using ATL and used that component inside a managed client application. Not only is it possible to call methods in the COM component from inside managed code, but it is also possible to register a managed callback function in the COM component. As you just have seen, it is very simple to access COM components from within managed code—without the need to write your own wrapper—as was the case in the .NET Compact Framework version 1.0. In the next exercise, you will use a popular, existing COM component inside a managed application.

【上篇】Windows消息机制要点
【下篇】dos批处理命令详解

作者: slimline

该日志由 slimline 于6年前发表在综合分类下，最后更新于 2018年04月05日.
转载请注明: Creating and Using a COM Object by Using Visual Studio 2005 | 学步园 +复制链接

抱歉!评论已关闭.

学步园

Creating and Using a COM Object by Using Visual Studio 2005

作者: slimline

书签

最新文章New

本站推荐

返回首页