Type Library to Assembly 转换摘要
COM_style type library ==> .NET Framework metadata.
The .NET Framework provides both tools and an API to perform type library to
assembly conversion. Although you have several mechanisms for generating an
assembly from a type library, each produces the same results. For simplicity, this
section describes only the Type Library Importer (Tlbimp.exe) tool in conjunction
with the conversion rules for importing type information.
$1、Imported Library Conversion
(Describes how the import process converts type library information. )
When the import process converts a type library, it automatically places the types
defined within the library in a namespace of the same name as the type library.
For example, if you run Tlbimp.exe on the following type library, the utility
imports all types defined within the AcmeLib type library into the AcmeLib
namespace.
library AcmeLib {
interface Widget {};
coclass Slingshot {};
};
==>
namespace AcmeLib {
interface Widget {};
class Slingshot {};
};
可以通过以下技术实现命名空间的重命名（和原来类型库名不一样）。
[
uuid(...),
version(1.0),
custom(0F21F359-AB84-41e8-9A78-36D110E6D2F9, "Acme.WidgetLib") //Here is it!
]
library AcmeLib {
interface Widget {};
coclass Slingshot {};
};
By using the user-defined attribute, you can force Tlbimp.exe to import the
AcmeLib type library into the Acme.WidgetLib namespace. The Slingshot class
becomes Acme.WidgetLib.Slingshot in managed code.
$2、Imported Module Conversion
(Describes how the import process converts modules containing the definitions of
constants and methods. )
A type library can have one or more modules containing the definitions of
constants and methods. Constants defined within modules are imported as public
constant static members of a class with the same name as the original module.
Constants defined outside of a module are not imported.
[
uuid(12345678-1234-1234-1234-123456789ABC),
]
library TestConstants
{
[
uuid(12345678-1234-1234-1234-123456789ABC),
dllname("test.dll")
]
module Constants
{
const short FRAME_COLOR = 0x10;
const short WINDOW_COLOR = 0x20;
const short BUTTON_COLOR = 0x40;
...
};
};
==> Converted types appear as follows:
public class Constants
{
public const short FRAME_COLOR = 0x10;
public const short WINDOW_COLOR = 0x20;
public const short BUTTON_COLOR = 0x40;
}
$3、Imported Type Conversion
（Describes how the import process converts interfaces, classes, structures,
enumerations, constants, and typedefs. ）
This topic describes how the import process converts the following types:
Interfaces
Classes
Structures
Enumerations
Constants
Typedefs
In general, Tlbimp.exe imports types with the same name they had in the original
type library. Names within a type library must be unique, thereby eliminating
naming conflicts during the conversion process. All valid type-library names are
valid assembly names.
Imported types are scoped by the namespace to which they belong, which is the same
as the original type library. Types are individually identified by their complete
namespace and type names.
You can explicitly control the managed name of an imported type by using a type
library attribute in the type library. This user-defined attribute identifier is
0F21F359-AB84-41e8-9A78-36D110E6D2F9. The following type library shows the
addition of the user-defined attribute.
Type library representation：
[ uuid(...),
version(1.0)
]
library AcmeLib {
interface Widget {};
[custom(0F21F359-AB84-41e8-9A78-36D110E6D2F9,
"Acme.WidgetLib.Slingshot")]
coclass Slingshot {};
};
Even though Tlbimp.exe imports the type library into the AcmeLib namespace, the
Slingshot class becomes Acme.WidgetLib.Slingshot.
Interfaces
When the import process converts an interface, it strips out all IUnknown and
IDispatch methods. The conversion applies the GuidAttribute to the interface to
retain the interface identifier (IID) assigned in the type library and the
InterfaceTypeAttribute unless the interface is dual (an interface deriving from
IDispatch).
Type library representation：
[uuid(...), ]
interface IWidget : IUnknown {
HRESULT New()
HRESULT Start()
};
[uuid(...), ]
interface IGadget : IWidget {
HRESULT Baz()
};
==>
During conversion, the import process adds the methods of the base interface to
the derived interface. In the following example, New and Start are added to the
IGadget interface:
[Guid(...), InterfaceType(ComInterfaceType.InterfaceIsIUnknown)]
interface IWidget {
void New();
void Start();
};
[Guid(...), InterfaceType(ComInterfaceType.InterfaceIsIUnknown)]
interface IGadget : IWidget {
new void New();
new void Start();
void Baz();
};
Classes
The import process creates a managed class to represent each COM coclass, giving
the managed class the same name as the original coclass appended with Class. For
example, the NewNewer coclass becomes NewNewerClass. The conversion adds the
GuidAttribute to the class to capture the class identifier (CLSID) of the coclass.
In addition to the managed class, the import process adds an interface with the
same name as the coclass and applies the CoClassAttribute to identify the CLSID of
the original coclass. This interface has the same IID as the default interface for
the coclass. With this interface, clients can always register as event sinks.
Unlike a COM coclass, a managed class can contain class members. In keeping with
the .NET Framework approach, the conversion adds to each class the members
associated with each interface implemented by the coclass. Users of the managed
class can invoke methods and properties of the managed type without first casting
to a specific interface. The import process also adds a default constructor to
each converted coclass. A constructor makes it possible to create the class from
managed code. (Classes without a constructor cannot be created). The default
constructor has no arguments; its implementation calls the base class constructor.
If the noncreatable type library attribute is applied to the coclass, the import
process does not create a default constructor for the class.
Since interface member names are not always unique, name and DispId collisions
among members can occur. TlbImp.exe resolves name collisions by prefixing the
interface name and an underscore to the name of each colliding member of the
class. Where the names of members collide, the first interface listed in the
coclass statement remains unchanged.
When DispId collisions occur, the import process assigns DispIds to members of the
coclass's default interface and none to the conflicting class members. However,
the import process always assigns DispIds to members of the interface.
Type library representation:
[uuid(...)]
interface INew : IDispatch {
[id(0x100)] HRESULT DoFirst();
[id(0x101)] HRESULT DoSecond();
}
[uuid(...)]
interface INewer : IDispatch {
[id(0x100)] HRESULT DoNow();
[id(0x101)] HRESULT DoSecond();
}
[uuid(...)]
coclass NewNewer {
[default] interface INew;
interface INewer;
}
==>
The converted types appear as follows:
[Guid(...)]
public interface INew {...}
[Guid(...)]
public interface INewer {...}
[Guid(...)]
public interface NewNewer : INew {...}
[Guid(...)]
public class NewNewer : INew, INewer, NewNewer{
// Method implementation.
[DispId(100)]...
}
Structures
Structures defined within a type library are imported as metadata. If a field of a
struct is a reference type, Tlbimp.exe imports the type as an IntPtr and applies
the ComConversionLossAttribute. The attribute indicates that information was lost
during the import process.
Enumerations
Type Library Importer (Tlbimp.exe) imports unmanaged enumerations as managed Enum
types.
Constants
Constants will not be imported from type library in this release.
Typedefs
Type definitions (typedefs) within a type library are not imported. Instead,
parameters and fields are imported as the underlying types. For example, a
parameter of type BUTTON_COLOR is imported as type integer, since BUTTON_COLOR is
an alias for an integer.
Once imported, parameters and fields carry information that associates them with
their original type in the ComAliasNameAttribute. The conversion process applies
ComAliasNameAttribute to associate a field, parameter, or return value with the
name of the type library and the type within the library that was used as an
alias.
The following type library representation shows that the cl parameter is typed as
a BUTTON_COLOR, which is an alias for an integer.
Type library representation
library MyLib {
typedef [public] int BUTTON_COLOR;
interface ISee {
HResult SetColor([in] BUTTON_COLOR cl);
HResult GetColor([out, retval] BUTTON_COLOR *cl);
};
coclass See {
[default] interface ISee
};
};
==>
The converted types appear as follows:
public interface ISee {
void SetColor([ComAliasName("MyLib.BUTTON_COLOR")]] int cl);
[return: ComAliasName("MyLib.BUTTON_COLOR")] int GetColor();
};
public class See {
public void SetColor([ComAliasName("MyLib.BUTTON_COLOR")]] int cl);
[return: ComAliasName("MyLib.BUTTON_COLOR")] int GetColor();
};
Note that the actual type BUTTON_COLOR is not defined in the resulting metadata.
Instead, the parameters typed as BUTTON_COLOR in the type library are typed as the
underlying type, int, and are attributed with the ComAliasNameAttribute. This
conversion process also applies the attribute to arguments on class methods.
$4、Imported Member Conversion
（Describes how the import process converts methods, properties, and events.）
This topic describes how the import process converts the following members:
Methods
Properties
Events
Tlbimp.exe applies the DefaultMemberAttribute to any method or property with a
DispID of 0. Note that C# developers must treat these members as arrays. For
additional information, see your programming language documentation.
Methods
When COM interop imports a COM type, it produces a .NET Framework method signature
equivalent to the original COM method signature. During the conversion process, it
maps COM parameters, return values, and HRESULTs to those in a .NET Framework
method signature, as shown in the following illustration.
Method signature conversion
.gif)
You can examine method syntax with an object viewer or by using reflection, just as with any other .NET class. By default, when the COM object returns a failure HRESULT, the runtime throws a corresponding exception.