Requirements should be mr.cool: Using Late Bound COM Objects

Using Late Bound COM Objects
ABSTRACT
In this article, Beth Breidenbach describes you to late bind to COM objects in. NET. Interoperability with COM objects has been well–integrated into the. NET Runtime. But Judging by the postings in the. NET newsgroups There appears to is some lingering about how to bind to COM O Bjects at runtime. This article would discuss the different methods available for invoking COM objects at runtime. After a brief review of late binding (and why it should sometimes to be avoided), we'll be walk through three different tion scenarios and explore the appropriate C # syntax to use. We have a brief look at the relative performance of the ' each method '.
ARTICLE
This article would describe how to late bind to COM objects in. NET. Interoperability with COM objects has been well-integrated into the. NET Runtime. Indeed, early binding is quite straightforward and has already been covered quite-in-Kaushal Sanghavi ' s articles on C OM (+) Interoperability (reference list at the "this" article). Judging by the postings in the. NET newsgroups, however, there appears to is some lingering about how to bind to COM objects at runtime. This article would discuss the different methods available for invoking COM objects at runtime. After a brief review of late binding (and why it should sometimes is avoided) we'll walk through three different invocat Ion scenarios and explore the appropriate C # syntax to use. We and a brief look at the relative performance of the "each" method.
Prerequisites
Our discussion assumes your understand the basic concepts of COM interoperability in. NET. If you are are just getting up to speed on the topic, the list of references is at the end of this article. In particular, you should understand what a Runtime Callable Wrapperis generated.
Introductory Concepts
Late Binding Defined
Binding associates a method with a pointer to the method ' s memory location. In early binding, the object ' s client was bound to the vtable locations of the object ' methods at the time of compilation. Late binding, in contrast, identifies a method ' s location at runtime via human-readable names. To enable late binding, the target object must implement the IDispatch interface. The IDispatch::GetIDsOfNames and Idispach::invoke methods allow object interrogation and method is invocation at runtime. The OLEView application (bundled with Visual Studio 6) can was used to determine whether the IDispatch interface is support Ed by your target component. Notice The IDispatch inherited interface for this component:

Assuming this object has a ProgID of "Testobject.testclass" and are located on a server named "Ourserver," the typical Code for late binding would look like this:
Dim Omyobject as Object
Set Omyobject = CreateObject ("Testobject.testclass", "Ourserver")
MsgBox Omyobject.echo1 ("Echo This Back to me")
In the example above, the variable is declared as a generic object. The CreateObject call uses the "ProgID to locate" DLL on the specified server. Note this the server parameter is isn't required if the target DLL is located on the local box.
Why use Late Binding
As you probably know, Microsoft recommends early binding whenever. IT provides the best performance because your application binds directly to the address of the required functions. As Microsoft ' s knowledge Base article #Q245115 (http://support.microsoft.com/default.aspx?scid=kb; en-us;q245115) states when talking about early binding, "in terms of overall execution, it's at speed least as fast As late binding. " So why worry about how to late bind at all?
There are scenarios for which late binding is justified. You are not know the exact binary interface until runtime. The object may exist in multiple versions and have improperly adapted interfaces the between. You are developing Web applications on a shared host and is unable to get an RCW created for the "COM object you want to Invoke. Or, the object may have been compiled in VB with improper version compatibility settings, resulting in constantly changing GUIDs even when the version hasn ' t changed. In this scenarios, a defensive programmer needs to remove he or her code a bit from the object ' binary signature. The tradeoff is one of flexibility versus performance and should are weighed carefully.