1

COM / DCOM / COM+COM / DCOM / COM+

Cosimo StufanoCosimo Stufano

EvoluciEvolucióón n de COM / DCOM / COM+de COM / DCOM / COM+

l COM (Component Object Model) es el resultado de la evolución y convergencia de dos tecnologías:Ø La comunicación inter-procesos en

los ambientes Windows de Microsoft.Ø El desarrollo de un mecanismo para

la invocación de procedimientos remotos (RPC: Remote Procedure Calls) por parte de la OSF como parte de un ambiente de computación distribuida (DCE).

2

EvoluciEvolucióón n de COM+de COM+

DDEDDE19871987

ClipboardClipboard19871987

ComputaciComputacióón n distribuidadistribuida

1980s1980s

OLE 1OLE 119921992

Open Open Softare Softare FoundationFoundationDistribited Distribited Computing Computing EnviromentEnviroment

Remote Procedure CallsRemote Procedure Calls(OSF DCE RPC)(OSF DCE RPC)

19921992COMCOM19951995

DCOMDCOM19961996

COM+COM+19991999

¿¿COM, DCOM o COM+?COM, DCOM o COM+?

ll COM COM permite interaccipermite interaccióón entre n entre componentes componentes COM COM que residen que residen en un en un computadorcomputador

ll DCOM (Distributed COM) DCOM (Distributed COM) agrega agrega la la posibilidad posibilidad de de que estos objetos este que estos objetos este distribuidos distribuidos en la reden la red

ll COM+ COM+ agrega agrega al al modelo modelo de de objetos una objetos una variedad variedad de de servicios para servicios para el el desarrollo desarrollo de de aplicaciones empresarialesaplicaciones empresariales

3

¿¿ Que es Que es COM?COM?l COM es una especificación.l COM es una porción de código que

forma parte de varios sistemas operativos.

l COM es una filosofía para el desarrollo de aplicaciones.

l COM es un estándar binario para la construcción de componentes.

¿¿Que esQue es unun componentecomponente COM?COM?

ll Es un Es un contenedor binariocontenedor binarioll Contiene Contiene el el ccóódigo digo dede unauna o o mas clases mas clases dede

objetosobjetosll Cada clase puede tener una Cada clase puede tener una o o mas mas

interfacesinterfacesll COM COM expone expone o o publica estas publica estas interfaces interfaces para para

que puedan que puedan ser ser usadas por otras usadas por otras aplicacionesaplicaciones..

ll Una aplicaciUna aplicacióón puede usar componentes n puede usar componentes COM. COM. independientementeindependientemente del del lenguajelenguaje enenque fueron escritosque fueron escritos..

4

¿¿Que es Que es un un componente componente COM?COM?

ComponenteComponente

ClienteCliente

Class Class FactoryFactory

IClassFactoryIClassFactory

IUnknownIUnknown

RegistroRegistro

EnvoltorioEnvoltorio

ObjetoObjeto

InterfacesInterfacesll Las Las aplicacionesaplicaciones accesan accesan el el

contenido contenido de de los componentes los componentes COM COM mediante sus mediante sus interfacesinterfaces

ll Las interfaces Las interfaces describen los describen los mméétodos disponibles todos disponibles y y sus sus parparáámetrosmetros

ll Las interfaces se Las interfaces se identifican identifican mediante nmediante núúmeros unicos meros unicos de 128 de 128 bits bits llamadosllamados GUID o UUID.GUID o UUID.

5

GUIDsGUIDs, , UUIDsUUIDs, , IIDsIIDs, etc. , etc. ll Los Los identificadores identificadores de interfaces se de interfaces se

escribenescriben de la formade la forma{B45E9146-3349-4F77-9151-2BF646CB9CAF}

ll Dos interfaces Dos interfaces bien conocidas bien conocidas son:son:ØØ IUnknownIUnknown

{00000000-0000-0000-C000-000000000046}ØØ IClassFactoryIClassFactory

{00000001-0000-0000-C000-000000000046}l Estas interfaces se discutiran en detalle

más adelante

ProgramaPrograma

Tipos Tipos de de componentes componentes COMCOM

ll In ProcessIn Processll LocalesLocalesll RemotosRemotos

ProgramaPrograma

ComponenteComponente

ProgramaPrograma

InvocaciInvocacióónn

InvocaciInvocacióónn ComponenteComponente

6

Infraestructura Infraestructura COMCOMll El El sistema operativo debe proveer sistema operativo debe proveer

funciones para clientes funciones para clientes y y servidoresservidores..ØØ Para Para clientesclientes: : ActivaciActivacióón n de de objetosobjetosØØ Para Para servidoresservidores: : Facilidades para publicar Facilidades para publicar

sus sus interfacesinterfacesll Servicios Servicios de de localizacilocalizacióón n de de componetescomponetes: :

el el registroregistroll Servicios Servicios RPC RPC transparentestransparentesll Mecanismos para Mecanismos para control de control de aplicaciones aplicaciones

y y asignaciasignacióón n dede memoriamemoria

DefiniciDefinicióónn de Interfaces (IDL)de Interfaces (IDL)

ll Se Se requiere requiere un un mecanismo para definir mecanismo para definir interfaces interfaces independientes independientes del del lenguajelenguaje de de programacionprogramacion..

ll Para Para esto esto se se utiliza utiliza un IDL (un IDL (Interface Interface Definition LanguageDefinition Language))

ll IDL no IDL no es parte es parte de COMde COMll Se Se compila compila com MIDLcom MIDL

import import ““unknown.unknown.idlidl””;;[ object,[ object, uuiduuid(1000001(1000001--00000000--00000000--00000000--000000000001) ]000000000001) ]interfaceinterface ISumISum :: IUnknown IUnknown {{

HRESULT Sum ([in]HRESULT Sum ([in] intint x, [in]x, [in] intint y, [out,y, [out, retvalretval]] intint* * retvalretval););};};

7

Funciones Funciones COMCOMl Todas las funciones de COM comienzan

con el prefijo Co.l Estas funciones son parte del sistema

operativo.l Las principales funciones son:

Ø CoInitialize(NULL);Ø CoCreateInstance(clsid, pUnkOuter,

grfContext, iid, ppvObj);Ø CoUninitialize();

La interface La interface IUnknownIUnknownll Todo componente Todo componente COM COM debe debe

implementar implementar al al menos esta menos esta intefaceinteface..

ll Esta Esta interface interface debe contener estos debe contener estos tres metodostres metodos::ØØ QueryInterface QueryInterface (IID,(IID,ppvppv););ØØ AddRef AddRef ();();ØØ Release ();Release ();

8

QueryInterface QueryInterface ((iidiid,, ppvppv););ll Permite interrogar Permite interrogar a un a un componete componete

para determinar si implementa para determinar si implementa cierta cierta interface.interface.

ll Debe cumplir las siguientes reglasDebe cumplir las siguientes reglasØØ ConsistenciaConsistenciaØØ Ser Ser estestááticaticaØØ Ser Ser reflexivareflexivaØØ Ser Ser simsiméétricatricaØØ Ser Ser transitivatransitiva

La interface La interface IClassFactoryIClassFactoryll Para Para activar activar un un componentecomponente, COM , COM

debe conocer como crearlodebe conocer como crearlo. Para . Para esto esto el el componente debe contener componente debe contener un un objeto objeto ffáábrica que implemente brica que implemente IClassFactoryIClassFactory

ll IClassFactory IClassFactory contiene contiene dos dos mméétodostodos::ØØ CreateInstance CreateInstance ((pUnkOuterpUnkOuter, , riidriid, , ppvppv););ØØ LockServer LockServer ((fLockfLock););

9

Un Un componentecomponente COMCOM

ComponenteComponente

Class Class FactoryFactory

IClassFactoryIClassFactory

IUnknownIUnknown

RegistroRegistro

EnvoltorioEnvoltorio

ObjetoObjeto

IUnknownIUnknown

Un Un ejemploejemploll El El ejemplo esta ejemplo esta en C++en C++ll ConstaConsta de:de:

ØØ UnUn cliente que usa cliente que usa el el servidorservidorØØ Un Un componente servidorcomponente servidor In ProcessIn Process

que implementaque implementa lala operacioperacióón suman sumaØØ El El servidor consta servidor consta de:de:ØØ Una clase MySum Una clase MySum ØØ Una clase CfactoryUna clase CfactoryØØ Dos Dos funciones funciones DLLDLLØØ Un Un archivo para registrarloarchivo para registrarlo

10

El El cliente cliente (1)(1)/ client./ client.cppcpp#include <#include <iostreamiostream.h>.h>#include "component.h" // Generated by MIDL#include "component.h" // Generated by MIDL

// {10000002// {10000002--00000000--00000000--00000000--000000000001}000000000001}const CLSID CLSID_const CLSID CLSID_MySumMySum = = {0x10000002,0x0000,0x0000,{0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x{0x10000002,0x0000,0x0000,{0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x01}};01}};

void main()void main(){{

coutcout << "Client: Calling<< "Client: Calling CoInitializeCoInitialize()" <<()" << endlendl;;HRESULT hr =HRESULT hr = CoInitializeCoInitialize(NULL);(NULL);if(FAILED(hr))if(FAILED(hr))

coutcout << "<< "CoInitializeCoInitialize failed" <<failed" << endlendl;;

IUnknownIUnknown** pUnknownpUnknown;;ISumISum** pSumpSum;;

coutcout << "Client: Calling<< "Client: Calling CoCreateInstanceCoCreateInstance()" <<()" << endlendl;;hr =hr = CoCreateInstanceCoCreateInstance(CLSID_(CLSID_MySumMySum, NULL, , NULL,

CLSCTX_INPROC_SERVER, IID_CLSCTX_INPROC_SERVER, IID_IUnknownIUnknown, (void**)&, (void**)&pUnknownpUnknown););if(FAILED(hr))if(FAILED(hr))

coutcout << "<< "CoCreateInstanceCoCreateInstance failed" <<failed" << endlendl;;

El El clientecliente (2)(2)coutcout << "Client: Calling<< "Client: Calling QueryInterfaceQueryInterface() for() for ISumISum on " <<on " <<

pUnknownpUnknown <<<< endlendl;;hr =hr = pUnknownpUnknown-->>QueryInterfaceQueryInterface(IID_(IID_ISumISum, (void**)&, (void**)&pSumpSum););if(FAILED(hr))if(FAILED(hr))

coutcout << "IID_<< "IID_ISumISum not supported" <<not supported" << endlendl;;

hr =hr = pUnknownpUnknown-->Release();>Release();coutcout << "Client: Calling<< "Client: Calling pUnknownpUnknown-->Release() reference count = ">Release() reference count = "

<< hr <<<< hr << endlendl;;

intint sum;sum;hr =hr = pSumpSum-->Sum(2, 3, &sum);>Sum(2, 3, &sum);if(SUCCEEDED(hr))if(SUCCEEDED(hr))

coutcout << "Client: Calling Sum(2, 3) = " << sum <<<< "Client: Calling Sum(2, 3) = " << sum << endlendl;;

hr =hr = pSumpSum-->Release();>Release();coutcout << "Client: Calling<< "Client: Calling pSumpSum-->Release() reference count = " << >Release() reference count = " <<

hr <<hr << endlendl;;

coutcout << "Client: Calling<< "Client: Calling CoUninitializeCoUninitialize()" <<()" << endlendl;;CoUninitializeCoUninitialize();();

}}

11

Funciones Funciones DLLDLLll El El componente debe implementar componente debe implementar dos dos

funciones funciones DLL:DLL:Ø DllGetClassObject (REFCLSID clsid, REFIID riid, void** ppv);Ø DllCanUnloadNow();

l La primera permite obtener un apuntador a IClassFactory

l La segunda permite a COM determinar si puede o no descargar el DLL de memoria

Funciones Funciones DLLDLL

ll Las Las funciones funciones DLL DLL deben declararse deben declararse en en un un archivo archivo DEF DEF como siguecomo sigue::

; component.def; component.defLIBRARY component.LIBRARY component.dlldllDESCRIPTION 'COM component example'DESCRIPTION 'COM component example'EXPORTSEXPORTS

DllGetClassObjectDllGetClassObject @2@2 PRIVATEPRIVATEDllCanUnloadNowDllCanUnloadNow @3@3 PRIVATEPRIVATE

12

El El componente componente -- clase MySumclase MySum// 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;

class CMySum : public ISum{public:

// IUnknownULONG __stdcall AddRef();ULONG __stdcall Release();HRESULT __stdcall QueryInterface(REFIID iid, void** ppv);

// ISumHRESULT __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;

};

MySumMySum –– Interface Interface IUnknownIUnknownULONG 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;

}

13

MySum MySum –– Interface ISUMInterface ISUM

HRESULT CMySum::Sum(int x, int y, int* retval){

cout << "Component: CMySum::Sum() " << x << " + " << y << " = " << x + y << endl;

*retval = x + y;return S_OK;

}

Clase CFactoryClase CFactoryclass CFactory : public IClassFactory{public:

// IUnknownULONG __stdcall AddRef();ULONG __stdcall Release();HRESULT __stdcall QueryInterface(REFIID iid, void** ppv);

// IClassFactoryHRESULT __stdcall CreateInstance(IUnknown *pUnknownOuter,

REFIID iid, void** ppv);HRESULT __stdcall LockServer(BOOL bLock);

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

private:ULONG m_cRef;

};

14

CFactoryCFactory –– Interface Interface IUnknownIUnknownULONG 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;}

Cfactory Cfactory –– Interface Interface IClassFactoryIClassFactoryHRESULT 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_IUNKNOWNHRESULT hr = pMySum->QueryInterface(iid, ppv);pMySum->Release();return hr;

}

HRESULT CFactory::LockServer(BOOL bLock){

if(bLock)g_cServerLocks++;

elseg_cServerLocks--;

return S_OK;}

15

Componente Componente –– FuncionesFunciones DLLDLLHRESULT __stdcall DllCanUnloadNow(){

cout << "Component: DllCanUnloadNow() " << (g_cServerLocks == 0 && g_cComponents == 0 ? "Yes" : "No") << endl;

if(g_cServerLocks == 0 && g_cComponents == 0)return S_OK;

elsereturn 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 IClassFactoryHRESULT hr = pFactory->QueryInterface(iid, ppv);pFactory->Release();return hr;

}

RegistroRegistro deldel componentecomponentell Para registrar el Para registrar el componente componente se se

tienen tienen dos dos alternativasalternativas::ØØ Usar Usar un un archivo archivo ..reg como reg como el el mostrado mostrado

abajoabajoØØ Agregar Agregar al al componente componente la la habilidad habilidad de de

registrarseregistrarse..REGEDIT4

[HKEY_CLASSES_ROOT\CLSID\{10000002-0000-0000-0000-000000000001}]@=“Ejemplo de COM"

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

16

ActiveXActiveXll DefinicionesDefiniciones

Ø Un término de mercadeo de Microsoft.Ø Un término de Microsoft para identificar

sus tecnologías que pueden aplicarse al Internet.

Ø Un componente COM que implementa IUnknown y tiene capacidad para auto-registrarse.

Ø El nuevo nombre de los controles OLE.

COM, OLE y ActiveXCOM, OLE y ActiveXActiveXActiveX

COMCOM

OLEOLE

ActivaciActivacióón n en en sitosito((EdiciEdicióón n visual)visual)

LinkingLinkingEmbeddingEmbedding

DocumentosDocumentos

ControlesControles

MacrosMacros

MonikersMonikers

Transferencia Transferencia de de datos uniformedatos uniforme

Almacenamiento persistenteAlmacenamiento persistente

El El Modelo Modelo de de Objetos Componentes Objetos Componentes (COM)(COM)

DragDrag--and Dropand Drop

AutomatizaciAutomatizacióónn

17

Mecanismos Mecanismos de rede re--utilizaciutilizacióón n COMCOMll Como Como las las interfaces en interfaces en los componetes los componetes

COM son COM son inmutablesinmutables..ll SiSi se se desea incorporar desea incorporar la la funcionalidad funcionalidad

de un de un Componente Componente COM se COM se debe usardebe usarinclusiinclusióónn o o agregaciagregacióónn

ObjetoObjeto

ContenedorContenedor

ObjetoObjeto

AgregadorAgregador

COM+COM+ll Integra COM con Integra COM con servicios para servicios para el el

desarrollo desarrollo de de aplicaciones empresarialesaplicaciones empresariales..ll En En cierto modo cierto modo COM+ COM+ es es la la fusifusióón n de de

COM, MTS (Microsoft Transaction Server) COM, MTS (Microsoft Transaction Server) y y otros componentesotros componentes..

ll Ademas Ademas de de mméétodostodos, , los componentes los componentes tiene ahora tiene ahora un un contexto contexto y y atributosatributos..

ll COM+ COM+ examina examina el el contexto contexto y y determina si determina si deben ejecutarse acciones deben ejecutarse acciones antes o antes o despues despues de de invocar invocar al al objetoobjeto..

18

Componentes Componentes COM+COM+

ServidorServidor

ClienteCliente

ContextoContexto

AtributosAtributos

IUnknownIUnknown

Beneficios Beneficios de COM+de COM+ll SimplificaciSimplificacióón n en el en el desarrollo desarrollo de de

aplicaciaplicacióónesnes: se reduce al : se reduce al mmíínimo nimo la la infraestructura infraestructura de de programaciprogramacióónn..

ll ModeloModelo simple y simple y escalableescalable: : los servidores los servidores hacen casi todo hacen casi todo el el trabajotrabajo

ll Arquitectura Arquitectura simple y extensible: se simple y extensible: se agrega funcionalidad enriqueciendoagrega funcionalidad enriqueciendo elelcontextocontexto nono creando nuevascreando nuevas APIAPI

19

InterceptoresInterceptoresll Para Para procesar procesar el el contextocontexto, COM+ , COM+

intercepta las invocaciones intercepta las invocaciones a a los objetos los objetos para realizara para realizara prepre-- y posty post-- procesamientoprocesamiento..

ClienteCliente ServidorServidorThread Thread

procesadorprocesadordel del contextocontexto

DTC DataData

TransacciTransaccióónnClienteCliente ServidorServidor

Funcionalidad Funcionalidad de COM+de COM+l Desarrollo de servidoresl Servicios transaccionalesl Seguridadl Administraciónl Colas de componentes (procesamiento

diferido)l Manejo de eventosl Balance de carga