INSTITUTO TECNOLGICO SUPERIOR DE CIUDAD

SERDN

COM/DCOM/RMI
PORFIRIO MEDINA DE LA ROSA
MATRICULA 13CS0296

DOCENTE: MTRO. ISSAC ALDAVE ROJAS

INGENIERA INFORMTICA

SEXTO SEMESTRE

COM/DCOM

Microsoft Distributed COM (DCOM) extiende COM (Component Object Model)

para soportar comunicacin entre objetos en ordenadores distintos, en una LAN,
WAN, o incluso en Internet. Con DCOM una aplicacin puede ser distribuida en
lugares que dan ms sentido al cliente y a la aplicacin.
DCOM(Distributed Component Object Model) es el resultado de la evolucin
y la convergencia de dos tecnologas: la comunicacin inter-procesos en los
ambientes Windows de Microsoft y los esfuerzos de 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).

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 ms 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 ori gen a DCOM. Este
ltimo permite crear aplicaciones cuyos componentes no necesariamente
residen en un computador sino que pueden estar distribuidos en vari os
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.
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 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.

Tipos de componentes
Los componentes COM se pueden agrupar bsicamente en tres categoras.
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 dnde reside el componente.

Cuando el componente es remoto, DCOM crea un proxy que intercepta las

referencias a la interface del objeto y luego usa RPC para ejecutar la instancia
real del objeto.
DCOM es una extensin de COM, y ste define como los componentes y sus
clientes interactan entre s. Esta interaccin es definida de tal manera que el
cliente y el componente pueden conectar sin la necesidad de un sistema
intermedio. El cliente llama a los mtodos del componente sin tener que
preocuparse de niveles ms complejos.
En los actuales sistemas operativos, los procesos estn separados unos de otros.
Un cliente que necesita comunicarse con un componente en otro proceso no
puede llamarlo directamente, y tendr que utilizar alguna forma de
comunicacin entre procesos que proporcione el sistema operativo. COM
proporciona este tipo de comunicacin de una forma transparente: intercepta las
llamadas del cliente y las reenva al componente que est en otro proceso.
Cuando el cliente y el componente residen en distintas mquinas, DCOM
simplemente reemplaza la comunicacin entre procesos locales por un protocolo
de red. Ni el cliente ni el componente se enteran de que la unin que los conecta
es ahora un poco ms grande.
Las libreras de COM proporcionan servicios orientados a objetos a los clientes y
componentes, y utilizan RPC y un proveedor de seguridad para generar paquetes
de red estndar que entienda el protocolo estndar de DCOM.

Ejemplo

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-0000000000000001} const CLSID CLSID_MySum =
{0x10000002,0x0000,0x0000,{0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x01}};
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();

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 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

El componente
Para construir el componente se debe crear un proyecto que contenga
component.def, component.cpp y el archivo componente .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
{ pu
blic
:
// 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--; }
priv
ate:

ULONG m_cRef;
};
ULONG CMySum::AddRef()
{

endl;
}

cout << "Component: CMySum::AddRef() m_cRef = " << m_cRef + 1 <<

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
{ pu
blic
:
// IUnknown
ULONG __stdcall AddRef();
ULONG __stdcall Release();
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() { }
priv
ate:
};

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;
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.

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-0000000000000001}\InprocServer32]
@="C:\\Program
Files\\DevStudio\\MyProjects\\Component\\Debug\\Component.dll"

Tabla comparativa de COM/DCOM

COM
Los
componentes
que
interactan ms a menudo
deberan estar localizados ms
cerca.

Algunos componentes solo

pueden ser ejecutados en
mquinas
especficas
o
lugares especficos.
Los
componentes
ms
pequeos
aumentan
la
flexibilidad, pero aumentan el
trfico de red.
Los
componentes
grandes
reducen el trfico de red, pero
tambin reducen la flexibilidad.
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.

DCOM
DCOM proporciona esta
transparencia: DCOM puede
utilizar cualquier protocolo de
transporte, como TCP/IP, UDP,
IPX/SPX y NetBIOS. DCOM
proporciona un marco de seguridad
a todos estos protocolos.

Hay
muchos
libros,
herramientas y desarrolladores.

Existe una buena integracin

con Visual BASIC y JAVA.

Microsoft depende
funcionamiento.

Hay muy poco soporte en

plataformas no-Windows. Si
bien algunos vendedores de
Unix consigan incorporar DCOM
en sus prximos relase, el
sistema
no
es
lo
suficientemente estable para
ganar la aceptacin en el
mundo UNIX.

Es
difcil
mantener
una
consistencia en el registro.

No existe una limpieza "pasifica"

por lo que una referencia a un
servicio se puede mantener en

de

su

memoria, pese a que se haya

terminado.

Tabla comparativa COM/RMI

COM
COM es una especificacin.

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.

Es REALMENTE fcil de usar si

ya se conoce JAVA.

Portable a travs de plataformas

con soporte JAVA.

Bajo costo al convertir sistema

existente.

Soporta paso de objetos por

referencia y/o valor.

A veces, no es tan intuitivo.

No
soportado
lenguajes.

Disminuye el rendimiento con el

crecimiento del sistema.

COM es una porcin de cdigo

COM provee dos mecanismos

para permitir la re-utilizacin de
componentes:
Inclusin y agregacin.
Las funciones del COM.
Desarrollo de servidores.
Servicios transaccionales
Seguridad.
Administracin.
Colas de componentes.
Balance de carga.

RMI
RMI es un paquete de JAVA que
permite manejar objetos (y sus
respectivos
mtodos)
de
manera remota, para utilizar los
recursos de un servidor de
manera transparente para el
usuario local.

por

otros