1

COM / DCOM / ActiveX / COM+

1 Introduccin

DCOM (Distributed Component Object Model) es el resultado de la evolucin y
convergencia de dos tecnologas: la comunicacin inter-procesos en los ambientes Windows de
Microsoft y los esfuerzos del la OSF (Open Software Foundation) para desarrollar un ambiente
de computacin distribuido (DCE, Distributed Computing Environment), en particular un
protocolo para la invocacin de procesos remotos (RPC, Remote Procedure Calls). La Figura 1
muestra la evolucin de DCOM
Los primeros computadores personales tenan capacidades limitadas y empleaban
sistemas operativos simples que solo podan ejecutar un proceso (programa) a la vez. Con el
desarrollo de procesadores ms poderosos y de sistemas operativos ms sofisticados se hizo
posible la ejecucin de varios procesos de forma (aparentemente) simultnea incorporando
tcnicas de tiempo compartido. Debido a la modalidad de uso de los computadores personales
(interaccin directa hombre-mquina) pronto se sinti la necesidad de contar con mecanismos de
intercambio de informacin entre procesos.

Los primeros intentos de ofrecer comunicacin entre procesos en los ambientes Windows
1 Evolucin de COM
DDE DDE
1987 1987
Clipboard Clipboard
1987 1987
Computacin Computacin
distribuida distribuida
1980s 1980s
OLE 1 OLE 1
1992 1992
Open Software Foundation Open Software Foundation
Distributed Computing Environment Distributed Computing Environment
Remote Procedure Calls Remote Procedure Calls
(OSF DCE RPC) (OSF DCE RPC)
1992 1992
COM COM
1995 1995
DCOM DCOM
1996 1996
COM+ COM+
1999 1999



2
fueron el DDE (Dynamic Data Exchange) y el Clipboard. El DDE era un mecanismo de
intercambio de mensajes que result complejo para los programadores y muy pocas aplicaciones
lo usaron exitosamente. El Clipboard, por otra parte, permiti a los usuarios de una forma simple
la creacin de documentos compuestos, es decir, con diferentes tipos de contenidos generados
por diversos procesos.

La principal limitacin del Clipboard es que los documentos creados son estticos: si
cualquiera de los elementos de un documento compuesto cambia, se deber modificar el
documento compuesto manualmente. Para atacar este problema, Microsoft introdujo en 1992 la
tecnologa OLE (Object Linking and Embedding). OLE introduce los conceptos de objeto y
componente, acordes con los paradigmas modernos de programacin.

COM surge para satisfacer la necesidad de Microsoft de modularizar las complejas
aplicaciones modernas, incluyendo sistemas operativos tales como Windows 9x/ME/NT/2000.
COM permite la creacin de componentes reutilizables que pueden ser desarrollados de manera
independiente los unos de los otros. Con esto se logra dividir sistemas complejos en subsistemas
que pueden ser asignados a diferentes grupos de programadores. Un componente COM puede
contener uno o mas objetos.

Por otra parte la OSF se estableci en los aos 1980s como un consorcio de empresas del
ramo de tecnologas de informacin con la misin de definir estndares independientes en el
rea. DCE es de los estndares propuestos por la OSF cuyo objetivo es la de proveer un ambiente
para el desarrollo de sistemas distribuidos. Uno de los componentes de DCE es una
especificacin para la comunicacin entre computadores. Esta especificacin, conocida como
RPC, permite que aplicaciones en computadores diferentes se comuniquen.

La integracin de COM y RPC di origen a DCOM. Este ltimo permite crear
aplicaciones cuyos componentes no necesariamente residen en un computador sino que pueden
estar distribuidos en varios computadores conectados en red.

Los componentes ActiveX se basan en COM/DCOM y sustituyen/incluyen a OLE. La
funcionalidad de ActiveX se implementa mediante un conjunto especfico de interfaces
definidas sobre diversos objetos y secuencias de operacin especficas, tanto en clientes como en
servidores.

2 Qu es COM?

Esta pregunta puede responderse de cualquiera de las siguientes maneras:

COM es una especificacin.
COM es una porcin de cdigo que forma parte de varios sistemas operativos.
COM es una filosofa para el desarrollo de aplicaciones.
COM es un estndar binario para la construccin de componentes.



3
La especificacin de COM es un documento que puede obtenerse de
http://www.microsoft.com/com/. Este documento describe todos los aspectos que un
programador debe conocer para desarrollar aplicaciones COM.

Por otra parte, el sistema operativo debe proveer un nmero de facilidades para que las
aplicaciones COM puedan ejecutarse. En la actualidad solo algunas versiones de Windows
proveen este soporte en modo nativo.

Otra forma de describir COM es como una filosofa para el diseo y desarrollo de
aplicaciones. En la medida en que las aplicaciones se hacen mas grandes y complejas, el
desarrollo de programas monolticos se vuelve imprctica. El desarrollo de aplicaciones se
facilita si stas se modularizan dividindolas en componentes que pueden ser desarrollados de
manera independiente y que adems pueden reutilizarse en el futuro.

Por ltimo, COM es un estndar binario porque los componentes pueden ser utilizados
sin necesidad de tener acceso al cdigo fuente: solo se requiere acceso al componente en forma
binaria. Esto permite que componentes elaborados por diversos proveedores puedan conectarse e
interactuar en forma significativa.

3 Interfaces COM

COM define una metodologa completamente estandarizada para la creacin de
componentes y para el control de la comunicacin entre estos componentes y sus clientes. A
Componente
Cliente
Class
Factory
IClassFactory
IUnknown
Registro
Envoltorio
Objeto



4
diferencia de los ambientes de programacin convencionales, estos mecanismos son
independientes de las aplicaciones que usan los componentes y de los lenguajes de programacin
usados para crear los objetos.

Un componente COM expone los servicios que ofrecen los objetos que contiene mediante
una o ms interfaces. Estas interfaces estn constituidas de colecciones de llamadas de funcin
especificndose, en cada caso, el tipo y la cantidad de parmetros esperados. La figura 2 ilustra
un componente COM. Algunos de los elementos mostrados en la figura se describirn en las
secciones siguientes.

Una vez que un componente COM ha sido creado, sus interfaces no pueden cambiarse.
Esto garantiza que todas las aplicaciones que usan este componente podrn seguir hacindolo en
el futuro. Si se requiere modificar o incrementar la funcionalidad de un componente, se debe
agregar una nueva interface, preservando intactas las ya existentes.

Las interfaces se identifican en el sistema mediante nmeros nicos de 128 bits
conocidos, dependiendo del contexto, como GUID (Global Unique IDentifier), UUID (Universal
Unique IDentifier), IID (Interface Identifier) o CLSID (CLaSs IDEntifier). Los GUID se
escriben usando notacin hexadecimal y tienen una apariencia similar a la mostrada:

{B45E9146-3349-4F77-9151-2BF646CB9CAF}

Para garantizar la unicidad de estos nmeros se recomienda usar el programa guidgen.exe el cual
puede obtenerse de Microsoft. Todos los objetos COM deben implementar por lo menos una
interface IUnknown, cuyo GUID es:

{00000000-0000-0000-C000-000000000046}

as mismo, en cada componente COM, debe haber una Class Factory que implementa una
interface IClassFactory (adems de su propio IUnknown) identificada por:

{00000001-0000-0000-C000-000000000046}

que permite crear instancias de l objetos del componente.




4 Tipos de componentes

Los componentes COM se pueden agrupar bsicamente en tres categoras.

2 Componente COM


5
In-Process
Locales
Remotos

Los componentes In-Process se cargan en el mismo espacio de procesos que la aplicacin
cliente. Estos componentes se implementan como libreras dinmicas (DLL) por lo cual se
minimiza el tiempo requerido para la invocacin de los mtodos. Por otra parte, como el
componente comparte el espacio de direcciones de la aplicacin, una falla en el componente
puede causar daos en la aplicacin. Los componentes In-Process no son programas ejecutables,
por lo tanto solo pueden usarse en el contexto de un programa que los invoca. Los controles
ActiveX son componentes In-Process.

Los componentes locales se ejecutan en un proceso separado en el mismo computador
mientras que los componentes remotos se ejecutan en otro computador. La aplicacin cliente no
necesita saber donde reside el componente. Cuando el componente es remoto, DCOM crea un
proxy que intercepta la referencias a la interface del objeto y luego usa RPC para ejecutar la
instancia real del objeto.

5 Infraestructura de COM

Para poder crear y usar COM se requiere que el sistema operativo provea la
infraestructura necesaria. En Windows esta reside en un DLL conocida como COM library, que
incluye lo siguiente:

Funciones fundamentales para creacin de clientes y servidores COM.
$ para clientes: activacin de objetos
$ para servidores: facilidades para hacer disponibles sus interfaces.
Servicios de localizacin de componentes, implementado mediante el registro.
Servicios RPC transparentes
Un mecanismo estndar para control de aplicaciones y asignacin de memoria.

Ademas de los servicios bsicos mencionados hasta ahora, COM tambin construye una
infraestructura de otros tres componentes del sistema operativo:

Almacenamiento persistente.
Monikers.
Transferencias de datos uniforme.

El almacenamiento persistente permite crear un sistema de archivos estructurado dentro
de un archivo que reside en el disco duro permitiendo que los objetos almacenen su estado, el
cual puede ser restaurado posteriormente.

Los monikers permiten asignar un nombre a una instancia especfica de una clase (un
objeto especfico) de forma tal que una aplicacin puede reconectarse a exactamente ese objeto


6
con el mismo estado (en vez de un objeto cualquiera de esa clase).

La transferencia de datos uniforme proporciona interfaces estndares para el intercambio
de datos entre un cliente y un objeto.

6 El lenguaje para definicin de interfaces (IDL)

Uno de los aspectos ms importantes de COM es la de ser independiente de los lenguajes
de programacin. Para lograr esto se requiere de un mecanismo neutro para describir los mtodos
que un componente ofrece en sus interfaces y la cantidad y tipo de parmetros que cada mtodo
requiere. La descripcin de las interfaces de un componente COM se hace en IDL (Interface
Definition Language). Abajo se muestra un ejemplo de una interface escrita en versin de
Microsoft del IDL propuesto por OSF. Esta definicin debe procesarse con un compilador MIDL
a fin de obtener los archivos necesarios para generar aplicaciones y componentes COM. Debe
notarse que IDL no es parte de COM, solo es una herramienta usada para ayudar a los
programadores a definir intefaces.


import unknown.idl;

[ object, uuid(1000001-0000-0000-0000-000000000001) ]
interface ISum : IUnknown
{
HRESULT Sum ([in] int x, [in] int y, [out, retval] int* retval);
};


7 Funciones COM

El subsistema COM contenido en el sistema operativo, proporciona un API (Application
Programming Interface) para que los programadores interacten con el. Las funciones de esta
API comienzan con las letras Co. Las ms importantes son:

CoInitialize(NULL)
CoCreateInstance(clsid, pUnkOuter, grfContext, iid, ppvObj) y
CoUninitialize()

CoIninialize inicializa al subsistema COM y debe ser invocada antes de cualquier otro servicio
COM. CoUninitialize, en cambio, debe invocarse al terminar la aplicacin para cerrar la librera
COM, liberar los recursos y cerrar todas las conexiones RPC. La funcin CoCreateInstance se
utiliza para crear objetos de las clases deseadas. Los parmetros de esta ltima se describen a
continuacin:

Parmetro Tipo Descripcin


7
clsid REFCLSID UUID de la clase de la cual se desea el objeto
pUnkOuter IUnknown* El IUnknown del controlador, si existe. (Agregacin)
grfContext DWORD Contexto (InProcess, local, etc.)
iid REFID Interface de inicializacin deseada.
ppvObj void** Donde se retorna la interface deseada

Todas estas funciones retornan una condicin de tipo HRESULT que indican si la
llamada tuvo xito o si se produjo algn error.

8 La interface I Unknown

La interface IUnknown implementa los tres mtodos indicados a continuacin:

QueryInterface ( iid, ppv )
AddRef () y
Release ()

QueryInterface permite determinar si un objeto soporta la interface. iid, en cuyo caso retorna un
apuntador a la misma en ppv. AddRef y Release se usa para llevar la cuenta del nmero de
referencias a un objeto. Cuando el numero de referencias llega a cero, el objeto es destruido y se
libera la memoria que ocupaba. Estas funciones retornan una condicin de tipo HRESULT para
permitir el manejo de errores.

La funcin QueryInterface debe cumplir con las siguientes reglas:

Sucesivas invocaciones a QueryInterface solicitando la misma interface deben
retornar apuntadores idnticos.
Si la primera invocacin a QueryInterface solicitando una interface es exitosa, las
subsiguientes tambin deben serlo. Si la primera invocacin falla, las siguientes
tambin fallan.
QueryInterface debe ser reflexiva..
QueryInterface debe ser simtrica.
QueryInterface debe ser transitiva.

10 La interface I ClassFactory

Cuando un cliente llama la funcin CoCreateInstace, COM debe crear un objeto con la
interface deseada en la memoria del computador y devolver un apuntador con su ubicacin. Para
lograr esto, debe determinar donde se encuentra el componente COM que contiene la
implementacin de la interface deseada y como crear dicho objeto. La ubicacin del objeto se
obtiene del registro, mientras que el mecanismo para crear el objeto debe obtenerse del


8
componente COM mismo; esto ltimo se resuelve mediante IClassFactory. Los objetos
fabricadores implementan IClassFactory para crear otros objetos COM.

La definicin de IclassFactory contiene dos mtodos :

CreateInstance ([in, unique] Iunknown* pUnkOuter,
[in] REFIID riid,
[out, iid_is(riid)] void** ppvObject); y
LockServer ([in] BOOL fLock);

ambos mtodos retornan una condicin de tipo HRESULT. Los parmetros se describen en la
siguiente tabla:

Parmetro Tipo Descripcin
pUnkOuter IUnknown* El IUnknown del controlador, si existe. (Agregacin)
riid REFIID UUID de la interface de la cual se desea el objeto
ppvObject void** Donde se retorna el apuntador al objeto deseado
fLock BOOL TRUE si se desea que el objeto fbrica permanezca en memoria.


11 Un ejemplo de aplicacin COM

En esta seccin se mostrar un ejemplo de una aplicacin COM que contiene un
componente InProcess. Se usar C++ para implementar el ejemplo.


11.1 El cliente

Abajo se muestra el programa cliente. ste usa el componente COM cuya interface se
defini en la seccin 6. Aunque este programa verifica las condiciones de error luego de cada
llamada, cuando ocurre un error slo se muestra un mensaje y se permite que el programa
contine su ejecucin . Esto es una mala prctica y solo se justifica en este caso debido a que un
buen manejo de errores complicara el el programa y dificultara la comprensin de los conceptos
COM ilustrados.


// client.cpp
#include <iostream.h>
#include "component.h" // Generated by MIDL
// {10000002-0000-0000-0000-000000000001}
const CLSID CLSID_MySum =
{0x10000002,0x0000,0x0000,{0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x01}};


9

void main()
{
cout << "Client: Calling CoInitialize()" << endl;
HRESULT hr = CoInitialize(NULL);
if(FAILED(hr))
cout << "CoInitialize failed" << endl;

IUnknown* pUnknown;
ISum* pSum;

cout << "Client: Calling CoCreateInstance()" << endl;
hr = CoCreateInstance(CLSID_MySum, NULL, CLSCTX_INPROC_SERVER,
IID_IUnknown, (void**)&pUnknown);
if(FAILED(hr))
cout << "CoCreateInstance failed" << endl;

cout << "Client: Calling QueryInterface() for ISum on " << pUnknown <<
endl;
hr = pUnknown->QueryInterface(IID_ISum, (void**)&pSum);
if(FAILED(hr))
cout << "IID_ISum not supported" << endl;

hr = pUnknown->Release();
cout << "Client: Calling pUnknown->Release() reference count = "
<< hr << endl;

int sum;
hr = pSum->Sum(2, 3, &sum);
if(SUCCEEDED(hr))
cout << "Client: Calling Sum(2, 3) = " << sum << endl;

hr = pSum->Release();
cout << "Client: Calling pSum->Release() reference count = " <<
hr << endl;

cout << "Client: Calling CoUninitialize()" << endl;
CoUninitialize();
}


11.2 Funciones DLL

Dado que el componente es InProcess, ste estar contenido en un DLL. Adems de lo
mencionado hasta ahora, este DLL debe exportar dos funciones:

DllGetClassObject (REFCLSID clsid, REFIID riid, void** ppv); y
DllCanUnloadNow();

La funcin DllGetClassObject permite obtener un apuntador a la interface riid de la clase clsid y
en general se utiliza para obtener el apuntador inicial a IClassFactory. La funcin


10
DllCanUnloadNow es utilizada por COM para determinar si la DLL puede descargarse de
memoria.

Estas funciones deben exportarse en un archivo de definicin de mdulo (DEF) como se
muestra a continuacin:

; component.def
LIBRARY component.dll
DESCRIPTION 'COM component example'
EXPORTS
DllGetClassObject @2 PRIVATE
DllCanUnloadNow @3 PRIVATE

11.3 El componente

Para construir el componente se debe crear un proyecto que contenga component.def,
component.cpp y el archivo component_i.c generado por MIDL.. El cdigo del componente se
muestra abajo:

// component.cpp
#include <iostream.h> // For cout
#include "component.h" // Generated by MIDL

// {10000002-0000-0000-0000-000000000001}
const CLSID CLSID_MySum =
{0x10000002,0x0000,0x0000,{0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x01}};

long g_cComponents = 0;
long g_cServerLocks = 0;
HANDLE g_hEvent; // For a later exercise with local components

class CMySum : public ISum
{
public:
// IUnknown
ULONG __stdcall AddRef();
ULONG __stdcall Release();
HRESULT __stdcall QueryInterface(REFIID iid, void** ppv);

// ISum
HRESULT __stdcall Sum(int x, int y, int* retval);

CMySum() : m_cRef(1) { g_cComponents++; }
~CMySum() { cout << "Component: CMySum::~CMySum()" << endl,
g_cComponents--; }

private:
ULONG m_cRef;
};


11

ULONG CMySum::AddRef()
{
cout << "Component: CMySum::AddRef() m_cRef = " << m_cRef + 1 << endl;
return ++m_cRef;
}

ULONG CMySum::Release()
{
cout << "Component: CMySum::Release() m_cRef = " << m_cRef - 1 << endl;
if(--m_cRef != 0)
return m_cRef;
delete this;
return 0;
}

HRESULT CMySum::QueryInterface(REFIID iid, void** ppv)
{
if(iid == IID_IUnknown)
{
cout << "Component: CMySum::QueryInterface() for IUnknown
returning " << this << endl;
*ppv = (IUnknown*)this;
}
else if(iid == IID_ISum)
{
cout << "Component: CMySum::QueryInterface() for ISum returning "
<< this << endl;
*ppv = (ISum*)this;
}
else
{
*ppv = NULL;
return E_NOINTERFACE;
}
AddRef();
return S_OK;
}

HRESULT CMySum::Sum(int x, int y, int* retval)
{
cout << "Component: CMySum::Sum() " << x << " + " << y << " = " << x +
y << endl;
*retval = x + y;
return S_OK;
}

class CFactory : public IClassFactory
{
public:
// IUnknown
ULONG __stdcall AddRef();
ULONG __stdcall Release();


12
HRESULT __stdcall QueryInterface(REFIID iid, void** ppv);

// IClassFactory
HRESULT __stdcall CreateInstance(IUnknown *pUnknownOuter, REFIID iid,
void** ppv);
HRESULT __stdcall LockServer(BOOL bLock);

CFactory() : m_cRef(1) { }
~CFactory() { }

private:
ULONG m_cRef;
};

ULONG CFactory::AddRef()
{
cout << "Component: CFactory::AddRef() m_cRef = " << m_cRef + 1 <<
endl;
return ++m_cRef;
}

ULONG CFactory::Release()
{
cout << "Component: CFactory::Release() m_cRef = " << m_cRef - 1 <<
endl;
if(--m_cRef != 0)
return m_cRef;
delete this;
return 0;
}

HRESULT CFactory::QueryInterface(REFIID iid, void** ppv)
{
if((iid == IID_IUnknown) || (iid == IID_IClassFactory))
{
cout << "Component: CFactory::QueryInteface() for IUnknown or
IClassFactory " << this << endl;
*ppv = (IClassFactory *)this;
}
else
{
*ppv = NULL;
return E_NOINTERFACE;
}
AddRef();
return S_OK;
}

HRESULT CFactory::CreateInstance(IUnknown *pUnknownOuter, REFIID iid, void**
ppv)
{
if(pUnknownOuter != NULL)
return CLASS_E_NOAGGREGATION;


13

CMySum *pMySum = new CMySum;
cout << "Component: CFactory::CreateInstance() " << pMySum << endl;

if(pMySum == NULL)
return E_OUTOFMEMORY;

// QueryInterface probably for IID_IUNKNOWN
HRESULT hr = pMySum->QueryInterface(iid, ppv);
pMySum->Release();
return hr;
}

HRESULT CFactory::LockServer(BOOL bLock)
{
if(bLock)
g_cServerLocks++;
else
g_cServerLocks--;
return S_OK;
}

HRESULT __stdcall DllCanUnloadNow()
{
cout << "Component: DllCanUnloadNow() " << (g_cServerLocks == 0 &&
g_cComponents == 0 ? "Yes" : "No") << endl;
if(g_cServerLocks == 0 && g_cComponents == 0)
return S_OK;
else
return S_FALSE;
}

HRESULT __stdcall DllGetClassObject(REFCLSID clsid, REFIID iid, void** ppv)
{
cout << "Component: DllGetClassObject" << endl;

if(clsid != CLSID_MySum)
return CLASS_E_CLASSNOTAVAILABLE;

CFactory* pFactory = new CFactory;
if(pFactory == NULL)
return E_OUTOFMEMORY;

// QueryInterface probably for IClassFactory
HRESULT hr = pFactory->QueryInterface(iid, ppv);
pFactory->Release();
return hr;
}

Ntese que componet.cpp contiene dos clases. La clase CMySum que implementa las
clases IUnknown e ISum, mientras que la clase CFactory implementa Iunknown e IclassFactory.



14
11.4 Registro del componente

Antes de que el componente pueda ser utilizado, ste debe ser registrado a fin de que el
cliente pueda encontrarlo. Para esta operacin puede emplearse un archivo de registro como el
siguiente:

REGEDIT4

[HKEY_CLASSES_ROOT\CLSID\{10000002-0000-0000-0000-000000000001}]
@="Inside DCOM Sample"

[HKEY_CLASSES_ROOT\CLSID\{10000002-0000-0000-0000-
000000000001}\InprocServer32]
@="C:\\Program Files\\DevStudio\\MyProjects\\Component\\Debug\\Component.dll"

Tambin se puede incluir en el componente la capacidad para registrarse a s mismo. Este
enfoque, sin embargo, no se discutir aqu.


12 ActiveX

ActiveX ha sido definido de varias formas:

Un trmino de mercadeo de Microsoft.
Un trmino de Microsoft para identificar sus tecnologas que pueden aplicarse al
Internet.
Un componente COM que implementa IUnknown y tiene capacidad para auto-
registrarse.
El nuevo nombre de los controles OLE.

El hecho de que las ltimas dos definiciones son contradictorias (los controles OLE son
objetos COM que se comunican con su entorno mediante un conjunto de interfaces bien
definidas) hace pensar que probablemente la primera definicin sea la mas correcta, sobre todo si
se toma en cuenta que la gente de mercadeo ha acogido ampliamente la idea (inicialmente
propuesta por Humpty Dumpty) de que las palabras significan cualquier cosa que se desee que
signifiquen.


15

Tomando la definicin ms amplia de AvtiveX, se puede representar la relacin entre
COM, OLE y ActiveX como se muestra en la figura 3

La funcionalidad de ActiveX incluye tres reas:

Automatizacin,
Documentos ActiveX, y
Objetos (controles) ActiveX.

La automatizacin ActiveX permite una capacidad de programacin a nivel de Macro que
pueda abarcar varias aplicaciones.

Los documentos ActiveX proveen la habilidad de alojar informacin de otras
aplicaciones en un documento central, promoviendo una interface de usuario centrada en
documentos.

Por ltimo los controles ActiveX (antes controles OLE) definen un conjunto de interfaces
que deben ser implementadas para que un objeto pueda calificar como un ActiveX, as como las
interfaces necesarias para crear un contenedor de controles ActiveX. Los controles ActiveX se
3 OLE, COM y ActiveX
ActiveX ActiveX
COM COM
OLE OLE
Activacin Activacin en en sito sito
( (Edicin Edicin visual) visual)
Linking Linking
Embedding Embedding
Documentos Documentos
Controles Controles
Macros Macros
Automatizacin Automatizacin Monikers Monikers
Transferencia Transferencia de de datos uniforme datos uniforme
Almacenamiento persistente Almacenamiento persistente
El El Modelo Modelo de de Objetos Componentes Objetos Componentes (COM) (COM)
Drag Drag- -and Drop and Drop


16
implementan como componentes COM InProcess.

13 Mecanismos de re-utilizacin COM

COM provee dos mecanismos para permitir la re-utilizacin de componentes:

Inclusin y
Agregacin

Estos mecanismos se ilustran en la figura 4. Para que un componente incluya a otro, el
primero debe convertirse en cliente del segundo e incluir las interfaces del componente incluido.
Al implementar estas interfaces el componente contenedor simplemente delega la ejecucin al
componente incluido. El mecanismo de agregacin permite que el componente contenedor haga
visibles las interfaces del componente contenido. Esto requiere que el componente contenido
tenga dos interfaces IUnknown, una cuando se usa sin agregacin y otra que se re-dirige al
IUnknown del componente contenedor.

14 COM+

COM+ se distribuye a partir de 1.999 con la introduccin de Windows 2000. COM+
integra el modelo de objetos de COM con algunos servicios que son necesarios para la creacin
de aplicaciones empresariales, de una forma tal que los programadores puedan concentrarse en la
lgica del negocio y no tengan que gastar tiempo y esfuerzos en desarrollar infraestructura ni
otros servicios comunes. Com+ trata de lograr esto de forma tal que sea fcil de usar,
implementar y mantener. En cierto modo COM+ es la convergencia de COM, MTS (Microsoft
Trasaction Server) y otros.

Para permitir que los componentes COM+ participen en servicios, se agregan dos
elementos adicionales a los componentes COM: un contexto y un conjunto de atributos. Esto
4 Re-utilizacin en COM
Objeto Objeto
Contenedor Contenedor
Objeto Objeto
Agregador Agregador



17
permite determinar las caractersticas de ejecucin del objeto: si es transaccional, si se va usar
balance de carga, si se va a usar una cola de componentes, etc. Cuando se invoca un objeto,
COM+ intercepta la llamada para examinar el contexto y ejecuta cualquier accin necesaria antes
de invocar al objeto. Al terminar el objeto su trabajo, el interceptor examina nuevamente el
contexto para determinar si se requiere alguna otra accin antes de retornar el control a la
aplicacin. La figura 5 ilustra la estructura de un componente COM+ y su interaccin con un
cliente.

Ente los beneficios de COM+ el primero es la simplificacin mediante reduccin. Se
proveen nuevos servicios mediante un modelo basado en atributos en vez de un API tradicional.
COM+ tambin intenta reducir al mnimo la infraestructura de programacin de forma que los
clientes no tengan que preocuparse de cosas tales como aspectos transaccionales, entre otros.

En segundo lugar se esta tratando de imponer un modelo simple y escalable. Los clientes
crean objetos, los usan y los liberan inmediatamente. Tambin se intenta que los clientes no
tengan mucho que hacer, que los servidores se hagan cargo del trabajo.

Por ltimo, COM+ es una arquitectura simple y extensible. Los interceptores examinan el
contexto y hacen lo que sea necesario. Para agregar nuevos servicios solo debe ingresarse la
informacin necesaria al contexto.

La funcionalidad de COM+ se puede describir en siete categorias bsicas:

Desarrollo de servidores
Servicios transaccionales
Seguridad
Administracin
Colas de componentes (procesamiento diferido)
Manejo de eventos
Balance de carga


18

5 Componentes COM+
Servidor Servidor
Cliente Cliente Cliente Cliente
Contexto Contexto Contexto Contexto
Atributos Atributos
IUnknown IUnknown



19


1 ............................................................................................................................... Introduccin 1

2 ........................................................................................................................... Qu es COM? 2

3 .......................................................................................................................... Interfaces COM 3

4 ................................................................................................................ Tipos de componentes 5

5 .............................................................................................................. Infraestructura de COM 5

6 ........................................................................... El lenguaje para definicin de interfaces (IDL) 6

7 ......................................................................................................................... Funciones COM 6

8 ............................................................................................................... La interface IUnknown 7

10 ....................................................................................................... La interface IClassFactory 7

11 ................................................................................................Un ejemplo de aplicacin COM 8
11.1.................................................................................................................... El cliente 8
11.2...........................................................................................................Funciones DLL 9
11.3............................................................................................................El componente 10
11.4............................................................................................ Registro del componente 13

12 .................................................................................................................................... ActiveX 14

13 ..........................................................................................Mecanismos de re-utilizacin COM 15

14 ...................................................................................................................................... COM+ 16