C# ПІДРУЧНИКИ / c# / Hungry Minds - C# Bible

// Create a handler for the event private __COMObject_COMEventEventHandler

COMEventHandlerInstance;

private void button1_Click(object sender, System.EventArgs e)

{

// create new instance of the COMObject class COMObject ObjectInstance;

short Num1; short Num2; short Sum;

ObjectInstance = new COMObjectClass();

Num1 = 5;

Num2 = 6;

//Call the SquareIt method

Sum = ObjectInstance.SquareIt(ref Num1, ref

Num2);

listBox1.Items.Add (Sum.ToString()); listBox1.Items.Add (ObjectInstance.Message);

// Set the value of message different than the

default

ObjectInstance.Message = "C# Rocks";

COMEventHandlerInstance = new __COMObject_COMEventEventHandler(COMEventHandler);

ObjectInstance.COMEvent += COMEventHandlerInstance;

ObjectInstance.FireCOMEvent();

}

void COMEventHandler(ref string Message)

{

listBox1.Items.Add(Message);

}

}

}

The output from this application looks similar to what is shown in Figure 34-6.

Figure 34-6: Output from the C# client using the COM component

Like any other object in .NET, you use the new operator to create a new instance of the COMObject class, as the following snippet demonstrates:

ObjectInstance = new COMObject();

Once the variable name ObjectInstance is instantiated, you use the object just as you would any other .NET object; nothing special needs to be done. The RCW handles all of the Interop, type conversions and object marshalling for the types, so you are completely hidden from any of the COM marshalling internals that are occurring.

If you have used COM Interop from VB .NET, you will notice something different about the way the parameters are passed to the methods in C#. If you look at the C# code for the SquareIt method, note the addition of the Ref keyword:

Num1 = 5;

Num2 = 6;

//Call the SquareIt method

Sum = ObjectInstance.SquareIt(ref Num1, ref Num2);

Visual Basic COM servers may pass values by value or by reference. Your C# code needs to use the appropriate keywords when passing parameters into COM method calls. You can use ILDASM to help you determine whether a parameter should be passed by value or by reference.

Open the assembly generated by Tlbimp using the ILDASM tool and look at the definition of the method that you want to call. In this case, you need to call the SquareIt() method. The SquareIt() method is listed in the assembly with the following signature:

SquareIt : int16(int16&,int16&)

The type of the return value returned by the method follows the colon. The signature of the SquareIt() method lists a return type of int16, which, in Intermediate Language parlance, denotes a 16-bit integer. The ampersands that follow the parameter types signify that the

In the .NET Framework, the CLR reports errors by throwing exceptions when things go wrong. In COM, HRESULTs are the avenue in which errors are reported, so the RCW needs to be able the map the HRESULT for a given error to the equivalent .NET exception.

Table 34-2 maps the standard HRESULTs in COM to their counterparts as .NET exceptions.

Table 34-2: HRESULTs to .NET Exceptions

Table 34-2: HRESULTs to .NET Exceptions

[DllImport("user32.dll")]

public static extern int MessageBox(int hWnd, String text, String caption, uint type);

When using platform invoke, you may need to alter the default behavior of the interoperability between the managed and unmanaged code. You can do this by modify the fields of the DLLImportAttribute class. Table 34-4 describes the fields that can be customized for the DLLImportAttribute class.

Calling DLL functions from C# is similar to calling them from Visual Basic 6. With the DLLImport attribute, however, you are simply passing the DLL's name and the method that you need to call.

Note It is recommended that your DLL function calls be grouped in separate classes. This simplifies coding, isolates the external function calls, and reduces overhead.

Summary

This chapter described how to use COM objects in .NET code and how to use the Tlbimp utility to generate .NET assemblies. You also took a brief look at how to interpret generated assemblies. In addition, you learned how to write COM client code in C#, including calling COM methods and working with COM properties. As you can see, the .NET Framework enables you to easily integrate existing COM code into your .NET applications. This easy integration gives you the opportunity to slowly move portions of an application to .NET, without having to rewrite all of the COM component logic in C#.

Chapter 35: Working with COM+ Services

In This Chapter

Microsoft has steadily enhanced the functionality of the COM subsystem since it was first released in 1993. One of the most significant enhancements to the COM programming model was introduced in 1997 with the release of Microsoft Transaction Server (MTS). MTS, first released as an add-on to Windows NT 4.0, enabled developers to develop components using an object broker that provided transaction, role-based security, and resource pooling services.

With the release of Windows 2000, Microsoft elevated the programming model offered by MTS to a first-class subsystem. COM+ is, in large part, a merging of the traditional COM programming model and the MTS programming model. For the first time, Windows provided support for both traditional COM (or unconfigured) components with attributed (or configured) MTS-style components directly from the operating system.

The .NET Framework offers both styles of components to developers writing componentbased software. This chapter examines how to develop C# classes that you can use as configured components with COM+.

Caution Although the .NET Framework is available on a variety of operating system platforms, COM+ is not available on the same set of platforms. Components written in C# that take advantage of COM+ services can only be used on platforms that support COM+. The COM+ class code built into the .NET Framework throws an exception of class PlatformNotSupported if your code attempts to access a feature that does not exist on the runtime platform.

Understanding the System.EnterpriseServices Namespace

Any C# class can be used by COM clients as a COM component, regardless of the class's inheritance tree. C# classes can be derived from nothing more than System.Object and still be used as COM components. Taking advantage of COM+ services within your C# classes, however, requires a more stringent inheritance policy.

The System.EnterpriseServices namespace provides the classes, enumerations, structures, delegates, and interfaces that you need to write applications that take advantage of COM+ and its enterprise-level services. If you have written components in C++ or Visual Basic 6 that ended up running inside of the COM+ Services Runtime, most of this chapter will seem familiar to you. From the standpoint of an experienced COM+ developer, the System.EnterpriseServices namespace wraps the functionality to which you previously had programmatic access. If you have written components in VB6, then you will be happy to see that previously unavailable features, such as object pooling, are now fully available to you through the Framework. Services, such as just-in-time (JIT) activation, object pooling, transaction processing, and shared property management, are all available as classes or attributes in the System.EnterpriseServices namespace.

Table 35-1 describes each of the classes available in the System.EnterpriseServices namespace.