Escolar Documentos
Profissional Documentos
Cultura Documentos
Cosimo Stufano
1
Evolución de COM+
Computació
Computación
DDE Clipboard
1987 1987 distribuida
1980s
DCOM COM+
1996 1999
2
¿ Que es 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.
l Es un contenedor binario
l Contiene el código de una o mas clases de
objetos
l Cada clase puede tener una o mas
interfaces
l COM expone o publica estas interfaces para
que puedan ser usadas por otras
aplicaciones.
aplicaciones.
l Una aplicació
aplicación puede usar componentes
COM. independientemente del lenguaje en
que fueron escritos.
escritos.
3
¿Que es un componente COM?
IUnknown
IClassFactory
Class
Factory
Cliente
Objeto Registro
Envoltorio
Componente
Interfaces
l Las aplicaciones accesan el
contenido de los componentes
COM mediante sus interfaces
l Las interfaces describen los
métodos disponibles y sus
pará
parámetros
l Las interfaces se identifican
mediante núnúmeros unicos de 128
bits llamados GUID o UUID.
4
GUIDs, UUIDs, IIDs, etc.
l Los identificadores de interfaces se
escriben de la forma
{B45E9146-3349-4F77-9151-2BF646CB9CAF}
l Dos interfaces bien conocidas son:
Ø IUnknown
{00000000-0000-0000-C000-000000000046}
Ø IClassFactory
{00000001-0000-0000-C000-000000000046}
l Estas interfaces se discutiran en detalle
más adelante
Invocació
Invocación
Invocació
Invocación Componente
Componente
5
Infraestructura COM
l El sistema operativo debe proveer
funciones para clientes y servidores.
servidores.
Ø Para clientes:
clientes: Activació
Activación de objetos
Ø Para servidores:
servidores: Facilidades para publicar
sus interfaces
l Servicios de localizació
localización de componetes:
componetes:
el registro
l Servicios RPC transparentes
l Mecanismos para control de aplicaciones
y asignació
asignación de memoria
import “unknown.idl
unknown.idl”
”;
[ object, uuid(1000001
uuid(1000001-
-0000-
0000- 0000-
0000-0000-
0000-000000000001) ]
interface ISum : IUnknown
{
HRESULT Sum ([in] int x, [in] int y, [out, retval]
retval] int*
int* retval);
retval);
};
6
Funciones COM
l 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 IUnknown
l Todo componente COM debe
implementar al menos esta
inteface.
inteface.
l Esta interface debe contener estos
tres metodos:
metodos:
Ø QueryInterface (IID,ppv
(IID,ppv);
);
Ø AddRef ();
Ø Release ();
7
QueryInterface (iid, ppv);
l Permite interrogar a un componete
para determinar si implementa
cierta interface.
l Debe cumplir las siguientes reglas
Ø Consistencia
Ø Ser está
estática
Ø Ser reflexiva
Ø Ser simé
simétrica
Ø Ser transitiva
La interface IClassFactory
l Para activar un componente,
componente, COM
debe conocer como crearlo.
crearlo. Para esto
el componente debe contener un objeto
fábrica que implemente IClassFactory
l IClassFactory contiene dos métodos:
todos:
Ø CreateInstance (pUnkOuter,
pUnkOuter, riid,
riid, ppv);
ppv);
Ø LockServer (fLock);
fLock);
8
Un componente COM
IUnknown
IClassFactory
Class
Factory
IUnknown
Objeto Registro
Envoltorio
Componente
Un ejemplo
l El ejemplo esta en C++
l Consta de:
Ø Un cliente que usa el servidor
Ø Un componente servidor In Process
que implementa la operació
operación suma
Ø El servidor consta de:
Ø Una clase MySum
Ø Una clase Cfactory
Ø Dos funciones DLL
Ø Un archivo para registrarlo
9
El cliente (1)
/ client.cpp
client.cpp
#include <iostream
<iostream.h>
.h>
#include "component.h" // Generated by MIDL
// {10000002-
{10000002-0000-
0000-0000-
0000-0000-
0000-000000000001}
const CLSID CLSID_MySum
CLSID_MySum =
{0x10000002,0x0000,0x0000,{0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x01}};
{0x10000002,0x0000,0x0000,{0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x01}};
void main()
{
cout << "Client: Calling CoInitialize()"
CoInitialize()" << endl;
endl;
HRESULT hr = CoInitialize(NULL);
CoInitialize(NULL);
if(FAILED(hr))
cout << "CoInitialize
"CoInitialize failed" << endl;
endl;
IUnknown*
IUnknown* pUnknown;
pUnknown;
ISum*
ISum* pSum;
pSum;
El cliente (2)
cout << "Client: Calling QueryInterface()
QueryInterface() for ISum on " <<
pUnknown << endl;
endl;
hr = pUnknown-
pUnknown->QueryInterface(IID_
QueryInterface(IID_ISum
ISum,
, (void**)&pSum
(void**)&pSum);
);
if(FAILED(hr))
cout << "IID_ISum
"IID_ISum not supported" << endl;
endl;
hr = pUnknown-
pUnknown->Release();
cout << "Client: Calling pUnknown-
pUnknown->Release() reference count = "
<< hr << endl;
endl;
int sum;
hr = pSum-
pSum->Sum(2, 3, &sum);
if(SUCCEEDED(hr))
cout << "Client: Calling Sum(2, 3) = " << sum << endl;
endl;
hr = pSum-
pSum->Release();
cout << "Client: Calling pSum-
pSum->Release() reference count = " <<
hr << endl;
endl;
10
Funciones DLL
l El componente debe implementar dos
funciones DLL:
Ø DllGetClassObject (REFCLSID clsid, REFIID riid, void** ppv);
Ø DllCanUnloadNow();
Funciones DLL
; component.def
LIBRARY component.dll
component.dll
DESCRIPTION 'COM component example'
EXPORTS
DllGetClassObject @2 PRIVATE
DllCanUnloadNow @3 PRIVATE
11
El componente - clase 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;
// ISum
HRESULT __stdcall Sum(int x, int y, int* retval);
private:
ULONG m_cRef;
};
12
MySum – Interface ISUM
Clase CFactory
class CFactory : public IClassFactory
{
public:
// 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() { }
private:
ULONG m_cRef;
};
13
CFactory – Interface IUnknown
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;
}
if(pMySum == NULL)
return E_OUTOFMEMORY;
14
Componente – Funciones DLL
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;
}
if(clsid != CLSID_MySum)
return CLASS_E_CLASSNOTAVAILABLE;
[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"
15
ActiveX
l Definiciones
Ø 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.
Documentos
Activació
Activación en sito
(Edició
Edición visual) Controles
Linking
Embedding
Drag-
Drag-and Drop
OLE
Macros
Transferencia de datos uniforme COM
16
Mecanismos de re-utilización COM
l Como las interfaces en los componetes
COM son inmutables.
inmutables.
l Si se desea incorporar la funcionalidad
de un Componente COM se debe usar
inclusió
inclusión o agregació
agregación
Agregador Contenedor
Objeto Objeto
COM+
l Integra COM con servicios para el
desarrollo de aplicaciones empresariales.
empresariales.
l En cierto modo COM+ es la fusió
fusión de
COM, MTS (Microsoft Transaction Server)
y otros componentes.
componentes.
l Ademas de métodos,
todos, los componentes
tiene ahora un contexto y atributos.
atributos.
l COM+ examina el contexto y determina si
deben ejecutarse acciones antes o
despues de invocar al objeto.
objeto.
17
Componentes COM+
IUnknown
Contexto
Atributos
Cliente
Servidor
Beneficios de COM+
l Simplificació
Simplificación en el desarrollo de
aplicació
aplicaciónes:
nes: se reduce al mínimo la
infraestructura de programació
programación.
l Modelo simple y escalable:
escalable: los servidores
hacen casi todo el trabajo
l Arquitectura simple y extensible: se
agrega funcionalidad enriqueciendo el
contexto no creando nuevas API
18
Interceptores
l Para procesar el contexto,
contexto, COM+
intercepta las invocaciones a los objetos
para realizara pre-
pre- y post-
post- procesamiento.
procesamiento.
Thread
Cliente procesador Servidor
del contexto
Cliente Servidor
Transacció
Transacción
DTC Data
Funcionalidad de COM+
l Desarrollo de servidores
l Servicios transaccionales
l Seguridad
l Administración
l Colas de componentes (procesamiento
diferido)
l Manejo de eventos
l Balance de carga
19