OLE Automation

From Wikipedia, the free encyclopedia

In Microsoft Windows applications programming, OLE Automation (later renamed by Microsoft to just Automation[1][2], although the old term remained with widespread use), is the formal interprocess communication mechanism based on Component Object Model (COM).[3] It provides an infrastructure whereby applications called automation controllers can access and manipulate (i.e. set properties of or call methods on) shared automation objects that are exported by other applications. It supersedes Dynamic Data Exchange, an older mechanism for applications to control one another.[4] As with DDE, in OLE Automation the automation controller is the "client" and the application exporting the automation objects is the "server".

Contents

[edit] Usage

Automation was designed with the ease of scripting in mind, so controllers often provide languages such Visual Basic for Applications to end users, allowing them to control automation objects via scripts. Automation objects can be written in conventional languages such as C++[5], but the C++ syntax for COM (and therefore Automation) is complex and not very programmer-friendly. In contrast, languages such as Visual Basic and Borland Delphi provide a convenient syntax for Automation which hides the complexity of the underlying implementation.

[edit] Interfaces

An Automation object is simply a COM object implementing the IDispatch interface (for details on interfaces and calling conventions, see Component Object Model). This interface exposes four methods, the most important of which is Invoke. This method allows calling methods of a class by name, with an arbitrary number of parameters. Neither the name of the method nor the number (and exact types) of parameters need to be known at compile time, as it is the case for COM objects not supporting Automation; moreover, in scripting languages there is no "compile time" at all. This technique is called late binding.

Most existing COM components are Automation-compliant and furthermore allow both late binding and traditional, compile-time early binding. This is achieved by implementing so-called dual interfaces, which are interfaces derived from IDispatch. Generally, both late and early binding expose the same functionality for Automation clients; languages such as Visual Basic and Delphi, as well as some C++ libraries, which provide a higher level of abstraction for COM, make sure that all Automation components created in these languages correctly duplicate their interfaces with late and early binding.

Generally, implementing early binding is more troublesome. Late binding is slower, but more reliable, as it does not require binary compatibility between versions of the same component. For late binding, a client only needs to know the name (or CLSID) of the desired object and the names and parameters of methods it actually uses, while for early binding, the client needs to know the complete definition and identifier (IID) for every interface requested, as well as the exact position of each method in the interface vtable. This, is however, more a problem of COM in general rather than Automation, as early binding relies on traditional COM calling conventions.

Automation servers may be implemented as single-use or multi-use.[6] For the former, each client connects to an individual instance of the server, with an individual instance of its class factory. For the latter, many clients connect to a single server, sharing that server's class factory across all clients.

The servers for the automation objects may be either out-of-process executables or in-process DLLs.[7]

[edit] Type libraries

This article or section may require cleanup to meet Wikipedia's quality standards.
Please help improve this article or replace this tag with a more specific message. This article has been tagged since August 2006. (help, talk)

In order to automate an application, the developer of an automation controller must know the object model that is employed by that application.[8] This requires that the developer of the application publicly document its object model. Development of automation controllers without knowledge of the target application's object model is "difficult to impossible".[9]

Because of these complications, Automation components are usually provided with type libraries, which contain metadata about classes, interfaces and other features exposed by an object library. Interfaces are described in Interface Description Language. Type libraries can be viewed using various tools, such as the Microsoft OLE/COM Object Viewer (oleview.exe, part of the Microsoft Platform SDK) or the Object Browser in Visual Basic (up to version 6) and Visual Studio .NET.

Also, type libraries are used to generate proxy/stub code for interoperating between COM and other platforms, such as Microsoft .NET and Java. For instance, the .NET Framework SDK includes tools that can generate a proxy .NET DLL to access Automation objects using both early binding (with information about interfaces extracted from a type library) and late binding (via IDispatch, mapped to the .NET Reflection API), with the built-in .NET-to-COM bridge called COM Interop[10]. While Java lacks built-in COM support, toolsets like JACOB [11] and jSegue [12] can generate proxy source code (consisting of two parts, a set of Java classes and a C++ source for a Java Native Interface DLL) from type libraries. Predictably, such solutions only work on Windows.

Microsoft has publicly documented the object model of all of the applications in Microsoft Office[13], and some other software developers have also documented the object models of their applications. Object models are presented to automation controllers as type libraries, wih their i

[edit] Language support

Automation (unlike the rest of COM) is available for a variety of languages, including, but not limited to:

[edit] Examples

The following Visual Basic 6 (or VBA) code launches Microsoft Excel, creates a new document, selects some cells, types "Hello World!" in cell A1, and then shows the application window. It operates using late binding, but early binding can be enabled simply by changing the object type from Object (an alias for IDispatch) to Excel.Application, provided that the Excel type library is referenced in the project.

Dim excelApp as Object
Set excelApp = CreateObject("Excel.Application")
excelApp.Workbooks.Add
excelApp.Range("A1:C6").Select
excelApp.ActiveCell.Formula = "Hello World!"
excelApp.Visible = True

Here is a sample code for C++, which just makes the window visible, using the pure COM API for late binding without other libraries or wrappers:

HRESULT hres;
CLSID clsid;
CLSIDFromProgID(L"Excel.Application", &clsid);
IDispatch *excelApp;

// Start Excel as a COM server in a separate process
hres = CoCreateInstance(&clsid, 0, CLSCTX_LOCAL_SERVER, IID_IDispatch, (void **)&excelApp);

if(FAILED(hres))
{
    // error handling
}

DISPID dispidVisible;
OLECHAR *propertyName = "Visible";
hres = excelApp->GetIDsOfNames(IID_NULL, &propertyName, 1, LOCALE_SYSTEM_DEFAULT, &dispidVisible);

if(FAILED(hres))
{
    // error handling
}

unsigned returnArg;
VARIANT varTrue;
DISPPARAMS params = { &varTrue, 1, 0, 0 };

// set the variant to a boolean true
varTrue.vt = VT_BOOL;
varTrue.boolVal = 0xFFFF;

// make the window visible: excelApp.Visible = True
hres = excelApp->Invoke(dispidVisible, IID_NULL, LOCALE_SYSTEM_DEFAULT, DISPATCH_PROPERTYPUT, params, 0, 0, &returnArg);

if(FAILED(hres))
{
    // error handling
}

// ... use the object

// free the object
excelApp->Release();

Here is an example C++ code (doing the same as the Visual Basic code) using MFC-provided wrappers for Excel 97, which hide the complexity of COM:

#include "excel8.h"

// ...

OleVariant covTrue((short)TRUE), covFalse((short)FALSE), covOptional((long)DISP_E_PARAMNOTFOUND, VT_ERROR);

_Application excelApp;

if(!excelApp.CreateDispatch("Excel.Application"))
{
    // error handling
}

excelApp.GetWorkbooks().Add(covOptional);
excelApp.GetRange(COleVariant("A1"),COleVariant("C6")).Select();
excelApp.GetActiveCell().SetFormula("Hello World!");
excelApp.SetVisible(TRUE);

Finally, here is an example for PHP:

<?php

$excelApp = new COM("Excel.Application") or die("Cannot create an Excel object");
$excelApp->Workbooks->Add();
$excelApp->Range("A1:C6")->Select();
$excelApp->ActiveCell->Formula = "Hello World!";
$excelApp->Visible = 1;

?>

It should be noted that in C# (and VB.NET with strict type checking) late binding is always explicit, producing code almost as complex as the pure C++ example. In contrast, early binding in .NET provides possibility for cleaner-looking code, like the other three examples (although the given examples implicitly involve late binding while .NET does not).

[edit] Name confusion

It should be noted that Automation objects do not necessarily use Microsoft OLE, which stands for Object Linking and Embedding — currently only a subset of COM — although some of Automation objects (which are a special type of COM objects[1]) can be used in OLE and/or ActiveX environments. The confusion has its roots in Microsoft's earlier (rather vague) definition of OLE, which was previously more or less a synonym of COM — to the point that the acronym "OLE" frequently appears in legacy COM code, like parts of the MFC library.

[edit] References

  1. ^ a b Microsoft Corporation. Automation (MFC). MSDN.
  2. ^ Kruglinski, David J., Wingo, Scott; Shepherd, George (1998). “Chapter 25: Automation”, Programming Microsoft Visual C++ 6.0, 5th edition, Redmond, WA: Microsoft Press. ISBN 1-57231-857-0.
  3. ^ Richard Potter (1999-04-18). OLE Automation. Interprocess Communication for End-User Programming.
  4. ^ Gordon McComb (1997). Using OLE Automation to Control WordPerfect. — McComb decribes how to use OLE Automation instead of DDE to control WordPerfect
  5. ^ a b Chris Oakley. OLE Automation for C++ programmers.
  6. ^ OLE automation routines in BASIC and C++. DB2: Application Development Guide: Programming Server Applications. IBM.
  7. ^ a b Jan Dubois (Summer 1998). "Win32::OLE". The Perl Journal 3 (2).
  8. ^ a b Yehuda Shiran and Tomer Shiran. OLE Automation in JavaScript. WebReference. — despite the title, the article discusses JScript rather than JavaScript
  9. ^ Bruce Armstrong (2006-01-16). "OLE — Extending the Capabilities of PowerBuilder (Part 2)". PowerBuilder Developers' Journal 12 (11).
  10. ^ a b Appleman, Dan (2001). “Chapter 15: COM Interop and Accessing the Win32 API”, Moving to VB.NET: Strategies, Concepts, and Code. Apress. ISBN 1-893115-97-6.
  11. ^ The JACOB Project (2004-10-17).
  12. ^ jSegue (2005-12-14]]).
  13. ^ How to find and use Office object model documentation. KnowledgeBase. Microsoft Corporation.
  14. ^ OLE Automation using Delphi. About.com.
  15. ^ The PHP Group (2006-07-25). PHP: COM and .Net (Windows).

[edit] Further reading

[edit] OLE Automation in general

  • Microsoft Corporation (December 1993). OLE 2 Programmer's Reference: Creating Programmable Applications with OLE Automation v. 2. Microsoft Press. ISBN 1-55615-629-4.
  • Kraig Brockschmidt (1995). Inside OLE. Microsoft Press.
  • Microsoft Corporation (1996). OLE Automation Programmer's Reference. Microsoft Press. ISBN 1-55615-851-3.

[edit] Object models for specific applications

[edit] See also

Retrieved from "http://en.wikipedia.org../../../o/l/e/OLE_Automation_965d.html"
In other languages