C# ПІДРУЧНИКИ / c# / MS Press - Msdn Training Programming Net Framework With C#

Instructor Notes

Materials and Preparation

This section provides the materials and preparation tasks that you need to teach this module.

Required Materials

To teach this module, you need the Microsoft PowerPoint® file 2349B_15.ppt.

Preparation Tasks

To prepare for this module, you should:

!Read all of the materials for this module.

!Complete the lab.

Demonstration: Using the Type Library Exporter

In this demonstration, students will see how to use the Type Library Exporter to generate a type library that describes the types defined in a common language runtime assembly.

!To generate a type library from an assembly by using the Type Library Exporter

1.In a Visual Studio .NET Command Prompt window, change the current folder to <install folder>\Democode\Mod15\Demo15.2.

2.To create a type library for Calculator.dll, type the following command:

tlbexp Calculator.dll /out:Calculator.tlb

3. The Type Library Exporter creates the Calculator.tlb file.

!To view the contents of the type library

1.Start a Visual Studio .NET Command Prompt.

2.Type oleview and press Enter.

3.In the OLE/COM Object Viewer window, on the File menu, click View TypeLib.

4.In the Open dialog box, move to <install_folder>\Democode\ Mod15\Demo15.2, select Calculator.tlb, and then click Open. The ITypeLib Viewer window appears with the information that is found in the type library.

*****************************ILLEGAL FOR NON-TRAINER USE******************************

After completing this module, you will be able to:

!State the need for interoperability between Microsoft® .NET assemblies and COM components.

!Use platform invoke to call a function in a dynamic-link library (DLL).

!Expose the methods and properties of a COM object to an assembly.

!Describe the three ways to generate runtime callable wrappers.

!Use Microsoft Visual Studio® .NET to call a COM object.

!Use the Type Library Importer to generate metadata from a type library.

!Expose the methods and properties of a .NET Framework class to a COM client.

!Use the Type Library Exporter to generate a type library for an assembly.

!Use the ClassInterfaceAttribute to control and modify the type of interface that is generated for a .NET Framework class.

2Module 15 (Optional): Interoperating Between Managed and Unmanaged Code

" Integration Services

*****************************ILLEGAL FOR NON-TRAINER USE******************************

When you adopt the .NET Framework to develop your applications, you may still have a lot of unmanaged code libraries implemented as DLLs and COM components. Code executing under the control of the runtime is called managed code. Conversely, code that runs outside the runtime is called unmanaged code. COM components, Microsoft ActiveX® interfaces, and Microsoft Win32® API functions are examples of unmanaged code.

You do not have to convert all of your existing unmanaged code to managed code before you can use it with .NET Framework applications. The Microsoft

.NET Framework promotes interaction with COM components, COM+ services, external type libraries, and many operating system services. Data types, method signatures, and error-handling mechanisms vary between managed and unmanaged object models. The .NET Framework offers two services—platform invoke and COM interoperability services—that allow managed code to interoperate with existing unmanaged code.

Note The ActiveX Control Importer (Aximp.exe) can be used to convert type definitions in a COM type library for an ActiveX control into a Microsoft Windows® Forms control. For additional information, see “Tools and Debuggers; Windows Forms ActiveX Control Importer (Aximp.exe)” in the

.NET Framework SDK documentation.

Introduction to Platform Invoke

*****************************ILLEGAL FOR NON-TRAINER USE******************************

Platform invoke allows managed code to call unmanaged functions that are implemented in a DLL. Platform invoke provides the mechanism for finding and invoking unmanaged functions, as well as marshaling managed arguments to and from unmanaged code.

When managed code calls an unmanaged function that is implemented in a DLL, platform invoke locates the DLL that implements the function, loads the DLL into memory, and locates the function address in memory. It then pushes the function’s arguments onto the stack, marshals any data that has to be marshaled, enables pre-emptive garbage collection, and transfers control to the address of the unmanaged code.

4Module 15 (Optional): Interoperating Between Managed and Unmanaged Code

Introduction to COM Interoperability

*****************************ILLEGAL FOR NON-TRAINER USE******************************

COM differs from the .NET Framework object model in several important ways:

!Clients of COM objects must manage the lifetime of those objects; the common language runtime manages the lifetime of objects in its environment.

!Clients of COM objects discover whether a service is available by requesting an interface that provides that service and getting back an interface pointer, or not. Clients of .NET objects can obtain a description of an object's functionality using Reflection.

!Managed objects reside in memory managed by the .NET Framework execution environment. The execution environment can move objects around in memory for performance reasons and update all references to the objects it moves. Unmanaged clients, having obtained a pointer to an object, rely on the object to remain at the same location. These clients have no mechanism for dealing with an object whose location is not fixed.

To overcome these differences, the runtime provides wrapper classes to make both managed and unmanaged clients think they are calling objects within their respective environment. Whenever your managed client calls a method on a COM object, the runtime creates a runtime callable wrapper (RCW). RCWs abstract the differences between managed and unmanaged reference mechanisms, among other things. The runtime also creates a COM callable wrapper (CCW) to reverse the process, enabling a COM client to call a method on a .NET object.