6 folii na stronÄ

OD KLASY C++ DO SERWERA COM: PROGRAMY PRZYKŁADOWE DO WYKŁADU PROGRAMOWANIE SKŁADNIKOWE W MODELU COM – OPRACOWANIE: JAROSŁAW FRANCIK 

// LISTING #1–PIERWSZE PODEJŚCIE 

// LISTING #2 – DRUGIE PODEJŚCIE 

#include 

#include 

// interfejs A 

interface IA 

{ 

virtual void __stdcall fa() = 0; 

}; 

// interfejs B 

interface IB 

{ 

virtual void __stdcall fb() = 0; 

}; 

// Składnik 

class CMyComp : public IA, public IB 

{ 

// Implementacja interfejsu A 

virtual void __stdcall fa(); 

// Implementacja interfejsu B 

virtual void __stdcall fb(); 

}; 

void CMyComp::fa() 

{ 

cout


/////////////////////////////// 

// Aplikacja kliencka 

#include "interface.h" 

void main() 

{ // inicjalizacja składnika 

IUnknown *pUnknown = CreateInstance(); 

IUnknown *CreateInstance() 

{ 

IUnknown *p = (IA*)new CMyComp; 

p->AddRef(); 

return p; 

} 

} 

// chcemy skorzystać z interfejsu IA 

IA *pIA = NULL; 

HRESULT hr = pUnknown->QueryInterface(IID_IA, (void**)&pIA); 

if (SUCCEEDED(hr)) 

{ pIA->fa(); 

pIA->Release(); 

} 

// chcemy skorzystać z interfejsu IB 

IB *pIB = NULL; 

hr = pUnknown->QueryInterface(IID_IB, (void**)&pIB); 


{ pIB->fb(); 

pIB->Release(); 

} 

pUnknown->Release(); // delete pUnknown; 

/////////////////////////////// 

// Moduł składnika 


#include 

// Klasa składnika 


{ // Implementacja interfejsu IUnknown 

virtual HRESULT _stdcall QueryInterface(REFIID iid, void **ppv); 

virtual ULONG _stdcall AddRef(); 

virtual ULONG _stdcall Release(); 


virtual void __stdcall fa() {cout


/////////////////////////////// 

// Aplikacja kliencka - korzystająca z serwera COM 

// LISTING #3 – TRZECIE PODEJŚCIE 

/////////////////////////////// 

// Plik nagłówkowy interface.h 

#include 


interface IA : public IUnknown 

{ 

virtual void __stdcall fa() = 0; 

}; 


interface IB : public IUnknown 

{ 

virtual void __stdcall fb() = 0; 

}; 

// deklaracje identyfikatorów IID 

extern const IID IID_IA; 

extern const IID IID_IB; 


void main() 

{ 

// inicjalizacja podsystemu COM 

CoInitialize(NULL); 

// inicjalizacja składnika 

IUnknown *pUnknown = NULL; 

HRESULT hr = CoCreateInstance(CLSID_Component, NULL, 

CLSCTX_INPROC_SERVER, IID_IUnknown, (void**)&pUnknown); 


{ // chcemy skorzystać z interfejsu IA 


hr = pUnknown->QueryInterface(IID_IA, (void**)&pIA); 


{ 

pIA->fa(); 


} 

/////////////////////////////// 

// Definicja identyfikatorów IID 

// {59F1DE0D-8843-4a57-82CE-D6DBA3D28D28} 

static const GUID CLSID_Component = 

{ 0x59f1de0d, 0x8843, 0x4a57, { 0x82, 0xce, 0xd6, 0xdb, 

0xa3, 0xd2, 0x8d, 0x28 } }; 

// {033E7EC7-50FA-404c-9C59-4CBA8892F054} 

static const GUID IID_IA = 

{ 0x33e7ec7, 0x50fa, 0x404c, { 0x9c, 0x59, 0x4c, 0xba, 0x88, 

0x92, 0xf0, 0x54 } }; 

// {FD854FCC-6AE2-4876-BB60-DC276E5DFC68} 

static const GUID IID_IB = 

{ 0xfd854fcc, 0x6ae2, 0x4876, { 0xbb, 0x60, 0xdc, 0x27, 

0x6e, 0x5d, 0xfc, 0x68 } }; 

} 

} 

// dalej jak w listingu #2 

pUnknown->Release(); 

/////////////////////////////// 

// Moduł składnika (serwer) 


#include 

#include "registry.h" 

// narzędzia do rejestru systemowego... 

/////////////////////////////////////////////////////////// 

// Zmienne globalne 

static HMODULE g_hModule = NULL; // uchwyt modułu DLL 

static long g_cComponents = 0 ; // Licznik aktywnych składników 

static long g_cServerLocks = 0 ; // Licznik dla LockServer 

// Dane do rejestru systemowego 

const char g_szProgID[] = "COMLecture.Approach3.1"; 

const char g_szFriendlyName[] = "Wykład z COM, podejście 3"; 

const char g_szVerIndProgID[] = "COMLecture.Approach3"; 

3


/////////////////////////////////////////////////////////// 

/////////////////////////////////////////////////////////// 


// Class Factory 


{ 

public: 

// Implementacja interfejsu IUnknown 





virtual void __stdcall fa() {cout


/////////////////////////////////////////////////////////// 

/////////////////////////////////////////////////////////// 

// Class Factory – interfejs IClassFactory 

// Funkcje eksportowane! 

HRESULT __stdcall CFactory::CreateInstance(IUnknown* pUnknownOuter, 

const IID& iid, void** ppv) 

{ 

if (pUnknownOuter != NULL) 

return CLASS_E_NOAGGREGATION; 

} 

// Utworzenie składnika 

CMyComp* pMyComp = new CMyComp; 

if (!pMyComp) 

return E_OUTOFMEMORY; 

// Utworzenie żądanego interfejsu 

HRESULT hr = pMyComp->QueryInterface(iid, ppv); 

pMyComp->Release(); 

return hr; 

HRESULT __stdcall CFactory::LockServer(BOOL bLock) 

{ 

if (bLock) 

InterlockedIncrement(&g_cServerLocks) ; 

else 

InterlockedDecrement(&g_cServerLocks) ; 

return S_OK ; 

} 

/////////////////////////////////////////////////////////// 

// 

// Inicjalizacja DLL 

BOOL APIENTRY DllMain(HMODULE hModule, DWORD ul_reason_for_call, 

LPVOID lpReserved) 

{ 

if (ul_reason_for_call == DLL_PROCESS_ATTACH) 

g_hModule = hModule; 

return TRUE ; 

} 

STDAPI DllCanUnloadNow() 

{ if ((g_cComponents == 0) && (g_cServerLocks == 0)) 

return S_OK; 

else 

return S_FALSE; 

} 

STDAPI DllGetClassObject(const CLSID& clsid, const IID& iid, void** ppv) 

{ 

// Czy możemy utworzyć taki składnik? 

if (clsid != CLSID_Component) 

return CLASS_E_CLASSNOTAVAILABLE ; 

} 

// Utwórz fabrykę klas 

CFactory* pFactory = new CFactory; 

if (pFactory == NULL) 


// Zwróć żądany interfejs 

HRESULT hr = pFactory->QueryInterface(iid, ppv); 

pFactory->Release(); 

return hr; 

STDAPI DllRegisterServer() 

{ return RegisterServer(g_hModule, CLSID_Component, 

g_szFriendlyName, g_szVerIndProgID, g_szProgID); 

} 

STDAPI DllUnregisterServer() 

{ return UnregisterServer(CLSID_Component, g_szVerIndProgID, 

g_szProgID); 

} 

/////////////////////////////// 

// Plik COMPONENT.DEF 

LIBRARY 

Component.dll 

DESCRIPTION 'Przykład do wykładu COM, (C) Jarosław Francik 2001' 

EXPORTS 

DllGetClassObject @2 PRIVATE 

DllCanUnloadNow @3 PRIVATE 

DllRegisterServer @4 PRIVATE 

DllUnregisterServer @5 PRIVATE 

5


/////////////////////////////// 

// Aplikacja kliencka - korzystająca z serwera COM 

// LISTING #4 – CZWARTE PODEJŚCIE (SERWER EXE) 

/////////////////////////////// 

// Specyfikacja mytypes.IDL 

import "unknwn.idl"; 

// Interface IA 

[ object, 

uuid(B5DB3493-9925-4633-B7DB-30DA5E75D347), 

helpstring("IA Interface"), 

pointer_default(unique) 

] 

interface IA : IUnknown 

{ HRESULT fa(); 

}; 

// Interface IB 

[ object, 

uuid(10AE43A2-2D3F-48a9-8ED3-D3F1F21CC898), 

helpstring("IB Interface"), 


] 

interface IB : IUnknown 

{ HRESULT fb(); 

}; 

// Biblioteka typów + clsid składników 

[ uuid(3221CCFF-68B2-442b-AFDC-FA9C767F1FC4), 

version(1.0), 

helpstring("Biblioteka typów Approach3a") 

] 

library MyTypeLib 

{ importlib("stdole32.tlb") ; 

[ 

uuid(E843265D-B374-4d56-A980-0EC5E9188B47), 

helpstring("Klasa komponentu Approach3a") 

] 

coclass Component 

{ 

[default] interface IA; 

interface IB; 

}; 

} ; 

#include "..\\mytypes.h" 

#include "..\\mytypes_i.c" 

void main() 

{ 




IUnknown *pUnknown = NULL; 

HRESULT hr = CoCreateInstance(CLSID_Component, NULL, 

CLSCTX_LOCAL_SERVER, IID_IUnknown, (void**)&pUnknown); 

/////////////////////////////// 

// Moduł proxy 

// zawiera wyłącznie pliki utworzone przez midl: 

// dlldata.c, abc_i.c, abc_p.c, 

// linkowane z rpcndr.lib, rpcns4.lib i rpcrt4.lib 

// Oto plik PROXY.DEF: 

LIBRARY 

proxy.dll 

DESCRIPTION 'Przykład do wykładu COM, (C) Jarosław Francik 2001' 

EXPORTS 

DllGetClassObject @1 PRIVATE 

DllCanUnloadNow @2 PRIVATE 

GetProxyDllInfo @2 PRIVATE 

DllRegisterServer @4 PRIVATE 

DllUnregisterServer @5 PRIVATE 

/////////////////////////////// 


#include "..\\mytypes.h" 

#include "..\\mytypes_i.c" 

#include 

#include 


// narzędzia do rejestru systemowego... 

/////////////////////////////////////////////////////////// 


// usunieto zmienną g_hModule 

// ponadto jak w podejściu Trzecim 

6


/////////////////////////////////////////////////////////// 

// 



{ 

public: 

// Implementacja interfejsu IUnknown jak w Podejściu Trzecim 


virtual HRESULT __stdcall fa() 

{ MessageBox(0, "Jestem fa", "Jestem fa", 0); return S_OK; } 

// Implementacja interfejsu B 

virtual HRESULT __stdcall fb() 

{ MessageBox(0, "Jestem fb", "Jestem fb", 0); return S_OK; } 

public: 

CMyComp() : m_nRef(1) { InterlockedIncrement(&g_cComponents); } 

~CMyComp() { InterlockedDecrement(&g_cComponents); 

if (g_cComponents == 0 && g_cServerLocks == 0) 

PostQuitMessage(0); } 

private: 

long m_nRef; 

}; 

// Implementacja klasy CMyComp – jak w Podejściu Trzecim 

/////////////////////////////////////////////////////////// 

// 


// Deklaracja i implementacja fabryki klas jak w Podejściu Trzecim; 

// jedyna różnica dotyczy poniższej funkcji: 


{ 

if (bLock) 

InterlockedIncrement(&g_cServerLocks); 

else 

InterlockedDecrement(&g_cServerLocks); 

} 


PostQuitMessage(0); 

return S_OK ; 

/////////////////////////////////////////////////////////// 

// 

// Część aplikacyjna + obsługa COM 

LRESULT CALLBACK WndProc(HWND, UINT, WPARAM, LPARAM); 

int APIENTRY WinMain(HINSTANCE hInstance, 

HINSTANCE hPrevInstance, 

LPSTR lpCmdLine, 

int nCmdShow) 

{ ///////////////////////////////////////////////////////////// 

// Inicjalizacja COM 

// flaga określająca tryb pracy 

bool bEmbedding = false; 

// Inicjalizacja COM 

HRESULT hr = CoInitialize(NULL) ; 

if (FAILED(hr)) 

return 0 ; 

// Odczyt linii wywołania 

char szTokens[] = "-/"; 

char* szToken = strtok(lpCmdLine, szTokens) ; 

while (szToken != NULL) 

{ 

if (_stricmp(szToken, "UnregServer") == 0) 

{ 

UnregisterServer(FALSE, CLSID_Component, 

g_szVerIndProgID, g_szProgID); 

CoUninitialize(); 

return 0; 

} 

else if (_stricmp(szToken, "RegServer") == 0) 

{ 

RegisterServer(FALSE, hInstance, CLSID_Component, 

g_szFriendlyName, g_szVerIndProgID, g_szProgID); 


return 0; 

} 

else if (_stricmp(szToken, "Embedding") == 0) 

{ 

bEmbedding = true; 

break ; 

} 

szToken = strtok(NULL, szTokens); 

} 

7


// Rejestracja fabryki klas 

DWORD dRegister; 

CFactory *pFactory = new CFactory; 

hr = ::CoRegisterClassObject(CLSID_Component, pFactory, 

CLSCTX_LOCAL_SERVER, REGCLS_MULTIPLEUSE, &dRegister); 


{ 

pFactory->Release() ; 

return FALSE ; 

} 

////////////////////////////////////////////////////////////// 

// Standardowa część aplikacji 

if (!bEmbedding) 

{ 

// Rejestracja klasy okna 

WNDCLASS wc; 

memset(&wc, 0, sizeof(wc)); 

wc.lpfnWndProc = (WNDPROC)WndProc; 

wc.hInstance = hInstance; 

wc.hCursor = LoadCursor(NULL, IDC_ARROW); 

wc.hbrBackground = (HBRUSH)GetStockObject(WHITE_BRUSH); 

wc.lpszClassName = "my_class1"; 

RegisterClass(&wc); 

// Utworzenie okna 

HWND hWnd; 

hWnd = CreateWindow("my_class1", "Tytuł", 

WS_OVERLAPPEDWINDOW, CW_USEDEFAULT, CW_USEDEFAULT, 

CW_USEDEFAULT, CW_USEDEFAULT, 

NULL, NULL, hInstance, NULL); 

if (!hWnd) 

return FALSE; 

ShowWindow(hWnd, nCmdShow); 

UpdateWindow(hWnd); 

} 

////////////////////////////////////////////////////////////// 

// Końcowa deinicjalizacja systemu COM! 

CoRevokeClassObject(dRegister); 


return msg.wParam; 

////////////////////////////////////////// 

// Funkcja okienkowa 

LRESULT CALLBACK WndProc(HWND hWnd, UINT message, 

WPARAM wParam, LPARAM lParam) 

{ 

switch (message) 

{ 

case WM_DESTROY: 

// nie pozwala zamknąć aplikacji, 

// dopóki klienci korzystają z serwera 


PostQuitMessage(0); 

break ; 

} 

case WM_CLOSE: 

// znosi blokadę na czas używania interfejsu użytkownika 

::InterlockedDecrement(&g_cServerLocks); 

return (DefWindowProc(hWnd, message, wParam, lParam)) ; 

default: 

return DefWindowProc(hWnd, message, wParam, lParam); 

} 

return 0; 

// Blokuje serwer na czas używania interfejsu użytkownika 

InterlockedIncrement(&g_cServerLocks); 

} 

// Pętla komunikatów 

MSG msg; 

while (GetMessage(&msg, NULL, 0, 0)) 

{ 

TranslateMessage(&msg); 

DispatchMessage(&msg); 

} 

8


/////////////////////////////// 


// LISTING #5 – PIĄTE PODEJŚCIE (DISPINTERFEJSY) 

/////////////////////////////// 

// Specyfikacja mytypes.IDL 


// Interface IA 

[ object, 


helpstring("IA Interface"), 

pointer_default(unique), 

dual, 

oleautomation 

] 

interface IA : IDispatch 

{ HRESULT fa(); 

}; 

// reszta bez zmian 

/////////////////////////////// 

// Aplikacja kliencka - korzystająca z interfejsu vtable 

// BEZ ŻADNYCH ZMIAN 

/////////////////////////////// 

// Moduł proxy – bez zmian 

// rozszerzenie klasy CMyComp 

// obejmuje implementację interfejsu IDispatch 


{ 

public: 

// Implementacja interfejsu IDispatch 

virtual HRESULT __stdcall GetTypeInfoCount( 

UINT __RPC_FAR *pctinfo); 

virtual HRESULT __stdcall GetTypeInfo( 

UINT iTInfo, LCID lcid, 

ITypeInfo __RPC_FAR *__RPC_FAR *ppTInfo); 

virtual HRESULT __stdcall GetIDsOfNames( 

REFIID riid, 

LPOLESTR __RPC_FAR *rgszNames, 

UINT cNames, 

LCID lcid, 

DISPID __RPC_FAR *rgDispId); 

virtual HRESULT __stdcall Invoke( 

DISPID dispIdMember, 

REFIID riid, 

LCID lcid, 

WORD wFlags, 

DISPPARAMS __RPC_FAR *pDispParams, 

VARIANT __RPC_FAR *pVarResult, 

EXCEPINFO __RPC_FAR *pExcepInfo, 

UINT __RPC_FAR *puArgErr); 

protected: 

ITypeInfo *m_pITypeInfo; 

HRESULT InitTypeInfo(); 

public: 

// rzeczy pomocne 

// uzupełnienie konstruktora: 

CMyComp() : m_nRef(1) 

{ InterlockedIncrement(&g_cComponents); 

InitTypeInfo(); } 

}; 

// RESZTA BEZ ZMIAN 

9


// Funkcja tworząca obiekt informacji o typach 

// Implementacja interfejsu IDispatch opiera się na 

// wykorzystaniu funkcjonalności obiektu informacji o typach 

HRESULT __stdcall CMyComp::GetTypeInfoCount(UINT __RPC_FAR *pctinfo) 

{ *pctinfo = 1; 

return S_OK; 

} 

HRESULT __stdcall CMyComp::GetTypeInfo(UINT iTInfo, LCID lcid, 

ITypeInfo __RPC_FAR *__RPC_FAR *ppTInfo) 

{ 

*ppTInfo = NULL; 

if (iTInfo != 0) 

return DISP_E_BADINDEX; 

m_pITypeInfo->AddRef(); 

*ppTInfo = m_pITypeInfo; 

return S_OK; 

} 

HRESULT __stdcall CMyComp::GetIDsOfNames(REFIID riid, 

LPOLESTR __RPC_FAR *rgszNames, 

UINT cNames, 

LCID lcid, 

DISPID __RPC_FAR *rgDispId) 

{ 

if (riid != IID_NULL) 

return DISP_E_UNKNOWNINTERFACE; 

HRESULT hr; 

hr = m_pITypeInfo->GetIDsOfNames(rgszNames, cNames, rgDispId); 

return hr; 

} 

HRESULT __stdcall CMyComp::Invoke( 

DISPID dispIdMember, 

REFIID riid, 

LCID lcid, 

WORD wFlags, 

DISPPARAMS __RPC_FAR *pDispParams, 

VARIANT __RPC_FAR *pVarResult, 

EXCEPINFO __RPC_FAR *pExcepInfo, 

UINT __RPC_FAR *puArgErr) 

{ 

if (riid != IID_NULL) 

return DISP_E_UNKNOWNINTERFACE; 

HRESULT hr = m_pITypeInfo->Invoke((IA*)this, dispIdMember, 

wFlags, pDispParams, pVarResult, pExcepInfo, puArgErr); 

return hr; 

} 

HRESULT CMyComp::InitTypeInfo() 

{ 

HRESULT hr; 

} 

// spróbuj załadować bibliotekę typów z rejestru systemowego 

ITypeLib *pTypeLib = NULL; 

hr = LoadRegTypeLib(LIBID_MyTypeLib, 1, 0, 0x00, &pTypeLib); 


{ 

// załaduj z pliku 

// ustal nazwę pliku exe i podziel ją na czynniki pierwsze 

char szModule[512] ; 

DWORD dwResult = 

::GetModuleFileName(g_hInstance, szModule, 512); 

char szDrive[_MAX_DRIVE]; 

char szDir[_MAX_DIR]; 

_splitpath(szModule, szDrive, szDir, NULL, NULL); 

// Określ nazwę pliku TLB 

char szTypeLibFullName[_MAX_PATH]; 

sprintf(szTypeLibFullName, "%s%s%s", szDrive, szDir, 

"mytypes.tlb"); 

// convert to wide char 

wchar_t wszTypeLibFullName[_MAX_PATH]; 

mbstowcs(wszTypeLibFullName, szTypeLibFullName, _MAX_PATH); 

hr = LoadTypeLib(wszTypeLibFullName, &pTypeLib); 


return hr; 

// na wszelki wypadek zarejestruj 

hr = RegisterTypeLib(pTypeLib, wszTypeLibFullName, NULL); 


return hr; 

} 

// pobierz TypeInfo dla IA 

m_pITypeInfo = NULL; 

hr = pTypeLib->GetTypeInfoOfGuid(IID_IA, &m_pITypeInfo); 

pTypeLib->Release(); 


return hr; 

return S_OK; 

// Podnadto uzupełniono CMyComp::QueryInterface tak, by zwracała 

// w razie potrzeby wskaźnik na IDispatch 

10

// Aternatywna Aplikacja kliencka 

// Aplikacja korzysta z dispinterfejsu 

#include 

#include 


//////////////////////////////////////// 

// Klient w Visual Basicu: 

Dim x As Object 

Set x = CreateObject(COMLecture.Approach5”) 

x.fa 

void main() 

{ 



wchar_t progid[] = L"COMLecture.Approach5"; 

CLSID clsid; 

CLSIDFromProgID(progid, &clsid); 

///////////////////////////////////////////// 

// Klient w MFC (po utworzeniu klasy “wrapper” 

IA ia; 

ia.CreateDispatch("COMLecture.Approach5"); 

ia.fa(); 

IDispatch *pIDispatch = NULL; 

HRESULT hr = CoCreateInstance(clsid, NULL, CLSCTX_LOCAL_SERVER, 

IID_IDispatch, (void**)&pIDispatch); 

assert(SUCCEEDED(hr)); 

DISPID dispid; 

OLECHAR *name = L"fa"; 

hr = pIDispatch->GetIDsOfNames(IID_NULL, &name, 1, 

GetUserDefaultLCID(), &dispid); 


VARIANTARG varg; 

VariantInit(&varg); 

varg.vt = VT_EMPTY; 

} 

DISPPARAMS param; 

param.cArgs = 0; 

param.rgvarg = &varg; 

param.cNamedArgs = 0; 

param.cArgs = NULL; 

hr = pIDispatch->Invoke(dispid, IID_NULL, GetUserDefaultLCID(), 

DISPATCH_METHOD, &param, NULL, NULL, NULL); 


11

Wstęp do programowania 

składnikowego 

Programowanie składnikowe 

Złota zasada: 

Interfejsem jest wszystko 

CZĘŚĆ 1: 

składniki i interfejsy 

Interfejsy lepiej oddają funkcjonalność 

obiektów niż dziedziczenie 

Jarosław Francik 

Założenia: 

1. Programowanie składnikowe to 

sposób programowania (filozofia) 

2. COM to tylko jedna ze specyfikacji 

wspierających programowanie składnikowe 

3. W ramach wykładu korzystamy ze zwykłego 

C++ by tworzyć oprogramowanie składnikowe 

4. W miarę potrzeb będziemy wprowadzać 

elementy COM 

Pierwsze podejście... 

Interfejs = klasa abstrakcyjna 

Składnik = klasa implementująca 

abstrakcyjny interfejs 

(dziedzicząca po klasie 

abstrakcyjnej) 

Wiele interfejsów = dziedz. wielobazowe 

#include 


class IA 

{ 

public: 

virtual void fa() = 0; 

}; 


class IB 

{ 

public: 

virtual void fb() = 0; 

}; 

// Składnik 


{ 


virtual void fa(); 

void CMyComp::fa() 

{ 

cout


Specyfikacja COM nie wymusza 

stosowania klas C++, 

jednak: 

binarny format tablicy funkcji wirtualnych 

C++ jest zgodny ze specyfikacją COM 


Wprowadzamy ułatwienia 

i wymogi COM: 

include 

interface (słowo kluczowe C++) 

__stdcall – konwencja wywołania 


[ listing #1 ] 

Słaby punkt: 

wykorzystujemy bezpośrednio wskaźnik 

na klasę komponentu 

w ten sposób zbyt mocno wiążemy 

klienta z implementacją składnika 

Rozwiązanie: 

stworzyć odrębną funkcję CreateInstance, 

której implementacja jest wewnętrznym 

szczegółem modułu składnika 

Lepsze podejście... 

Publicznie widzimy: 

interfejsy 

deklarację funkcji CreateInstance 

narzędzie do uzyskiwania wskazanych 

interfejsów 

? 

oczywiście też interfejs: 

IUnknown 

2



CZĘŚĆ 2: 

interfejs Iunknown 


Interfejs IUnknown 

interface IUnknown 

{ 

virtual HRESULT __stdcall QueryInterface 

(const IID &iid, void **ppc) = 0; 

virtual ULONG __stdcall AddRef() = 0; 

virtual ULONG __stdcall Release() = 0; 

}; 

Każdy interfejs COM dziedziczy po IUnknown 

IUnknown::QueryInterface 

Klient 

1. Klient wywołuje 

QueryInterface(IID) 

2. Obiekt zwraca 

wskaźnik na interfejs 

3. Klient może 

wywoływać metody 

Składnik 

COM 

HRESULT QueryInterface(const IID &iid, void **p); 


(użycie przez klienta) 


IUnknown *pComp = CreateInstance(); 

// chcemy skorzystać z interfejsu IA 


HRESULT hr = pComp->QueryInterface 

(IID_IA, (void**)&pIA); 


{ 

pIA->fa(); 

} 

identyfikator interfejsu – IID (GUID) 


(implementacja) 

HRESULT _stdcall CMyComp::QueryInterface(REFIID iid, 

void **ppv) 

{ 

if (iid == IID_IUnknown) 

*ppv = (IA*)this; 

else if (iid == IID_IA) 

*ppv = (IA*)this; 

else if (iid == IID_IB) 

*ppv = (IB*)this; 

else { ppv = NULL; return E_NOINTERFACE; } 

((IUnknown*)(*ppv))->AddRef(); 

return S_OK; 

} 

Funkcja CreateInstance 

IUnknown *CreateInstance() 

{ 

IUnknown *p = (IA*)new CMyComp; 

p->AddRef(); 

return p; 

} 

W bibliotece COM API dostępna jest funkcja 

CoCreateInstance o podobnym działaniu 

1

Drugie podejście 

T 

T 

Co widzi klient? 

T interfejsy 

T identyfikatory interfejsów (IID) 

T nagłówek funkcji CreateInstance 

(w COM korzystamy raczej 

z funkcji bibliotecznej CoCreateInstance) 

Co implementuje składnik? 

T klasa implementująca interfejs IUnknown 

oraz własne interfejsy 

T funkcja CreateInstance 


Nie używamy dziedziczenia 

wirtualnego! Jest ono 

niezgodne z formatem 

binarnym COM 

QueryInterface 

QueryInterface możemy stosować do 

dowolnego interfejsu, nie tylko do 

IUnknown – gdyż wszystkie interfejsy 

dziedziczą po IUnknown 


IUnknown *p = CreateInstance(); 


hr = p->QueryInterface(IID_IA, (void**)&pIA); 

if (!SUCCEEDED(hr)) return; 

// Interfejs IB otrzymujemy z IA 

IB *pIB = NULL; 

hr = pIA->QueryInterface(IID_IB, (void**)&pIB); 


// Interfejs IUnknown otrzymujemy z IB 

IUnknown * pUnknown = NULL; 

hr = pIB->QueryInterface(IID_IUnknown, 

(void**)&pUnknown); 



T 

T 

T 

T 

Za każdym razem otrzymuję ten sam interfejs 

IUnknown 

Zawsze mogę otrzymać interfejs, 

który już kiedyś uzyskałem 

Zawsze mogę uzyskać interfejs, 

który już mam 

Jeśli mogę otrzymać interfejs gdziekolwiek, 

to mogę go otrzymać wszędzie 

2


T definiuje obiekt 

T pozwala udostępniać różne wersje 

interfejsów dla tego samego obiektu 

T pomaga utrzymać kompatybilność 

wstecz przy wypuszczaniu nowej wersji 

produktu 

T ALE: wymaga to dotrzymania założeń 

przez projektanta nowej wersji!!! 

Zliczanie referencji: 

AddRef/Release 

T Klasa składnika zawiera licznik 

referencji 

T AddRef zwiększa licznik 

T Release zmniejsza licznik i w razie 

potrzeby usuwa składnik z pamięci 

T Utworzenie obiektu = AddRef 

T Porzucenie obiektu = Release 

Zliczanie referencji: 

AddRef/Release 

ULONG _stdcall CMyComp::AddRef() 

{ 

return InterlockedIncrement(&m_nRef); 

} 

ULONG _stdcall CMyComp::Release() 

{ 

if (InterlockedDecrement(&m_nRef) == 0) 

{ 

delete this; 

return 0; 

} 

return m_nRef; 

} 

AddRef/Release: 

trzy proste zasady 

T Wywołaj AddRef zanim zwrócisz wynik 

T 

jeśli zwracasz interfejs jako wartość funkcji. Dotyczy też 

QueryInterface i CreateInstance! 

T Wywołaj Release kiedy skończysz 

T 

gdy nie będziesz już dłużej wykorzystywał interfejsu 

T Wywołaj AddRef gdy robisz przypisanie 

T 

AddRef/Release: 

Optymalizacja 

Nie musisz stosować AddRef/Release w przypadku 

użycia wskaźnika o zagnieżdżonym zasięgu 

(w obrębie zasięgu innego wskaźnika) 

T 

T 

T 

T 

T 

T 

parametr wejściowy – nic (jest zagnieżdżony) 

parametr wyjściowy – AddRef 

parametr wejściowo-wyjściowy – być może AddRef + Release 

zmienna lokalna – nic (jest zagnieżdżona) 

zmienna globalna – AddRef + Release 

w przypadku wątpliwości – AddRef + Release 

Drugie podejście... 

T Słaby punkt: 

T funkcja CreateInstance zbyt mocno wiąże 

klienta z serwerem 

T Rozwiązanie: 

T skorzystamy z technologii COM... 

3



CZĘŚĆ 3: 

Funkcja CoCreateInstance, fabryki klas 

i serwery COM 


Podstawy technologii COM 

 

HRESULT 

standardowy typ wartości zwracanych przez 

funkcje 

 

 

 

S_OK S_FALSE 

E_UNEXPECTED E_NOTIMPL 

E_NOINTERFACE E_OUTOFMEMORY 

Bity: 

0-15 return code co się stało 

16-30 facility code id części systemu 

31 sukces czy porażka 

Makro SUCCEEDED 

Funkcja FormatMessage 



 

Rejestr Windows 

HKEY_CLASSES_ROOT 

CLSID 

{59F1DE0D-8843-4A57-82CE-D6DBA3D28D28}: Wykład COM, podejście 3 

T InProcServer32: c:\windows\system32\Component.dll 

T ProgID: COMLecture.Approach3.1 

T VersionIndependentProgID: COMLecture.Approach3 

COMLecture.Approach3.1: Wykład COM, podejście 3 

CLSID: {59F1DE0D-8843-4A57-82CE-D6DBA3D28D28} 

COMLecture.Approach3: Wykład COM, podejście 3 

CLSID: {59F1DE0D-8843-4A57-82CE-D6DBA3D28D28} 

CurVer: COMLecture.Approach3.1 

 

Rejestr Windows (c.d.) 

Przydatne funkcje: 

 

CLSIDFromProgID 

Rejestrowanie serwerów COM 

Serwer musi sam dostarczyć eksportowanych funkcji: 

DllRegisterServer 

DllUnregisterServer 

Przydatne narzędzia: 

RegOpenKeyEx, RegCreateKeyEx, RegSetValueEx, 

RegEnumKeyEx, RegDeleteKey, RegCloseKey 

Pliki Registry.h i Registry.cpp można znaleźć wraz z 

programem przykładowym approach3 

 


Przydatne funkcje: 

CoInitialize(NULL); // dla każdego procesu osobno! 

 

 

 

 

 

 

 

CoUninitialize 

StringFromCLSID 

StringFromIID 

CLSIDFromString 

IIDFromString 

CoTaskMemAlloc 

CoTaskMemFree 


CoCreateInstance ( 

const CLSID &clsid, 

IUnknown *pIUnknownOuter, 

DWORD dwClsContext, 

const IID &iid, 

void **ppv); 

1

Trzecie podejście - klient 

Zastępujemy dotychczasowy 

CreateInstance wywołaniem 

CoCreateInstance 

Powiązanie między klientem a serwerem 

już tylko poprzez CLSID! 

Trzecie podejście - klient 



HRESULT hr = CoCreateInstance( 

CLSID_MyComponent, 

NULL, 

CLSCTX_INPROC_SERVER, 

IID_IA, 

(void**)&pIA); 


{ pIA->fa(); 


} 

Fabryka klas 

IClassFactory – interfejs służący do tworzenia 

egzemplarzy klas (obiektów) 

interface IClassFactory 

{ HRESULT __stdcall CreateInstance 

(IUnknown *pUnknownOuter, 

const IID& iid, void **ppv); 

HRESULT __stdcall LockServer(BOOL b); 

} 

w wywołaniu CreateInstance brakuje CLSID 

Fabryka klas służy do tworzenia obiektów określonej klasy 

 

Fabryka klas 

Funkcja CoGetClassObject zwraca wskaźnik na 

fabrykę klas dla określonego CLSID 

HRESULT __stdcall CoGetClassObject( 

const CLSID &clsid, 

DWORD dwClsContext, 

COSERVERINFO *pServerInfo, 

const IID &iid, 

void **ppv); 

CoGetClassObject wywołuje DllGetClassObject: 

funkcję obowiązkowo eksportowaną przez serwery COM 

Fabryka klas 

Fabryka klas 

 

CoCreateInstance vc CoGetClassObject 

HRESULT __stdcall CoCreateInstance (...) 

{ *ppv = NULL; 

IClassFactory *pFactory = NULL; 

HRESULT hr = CoGetClassObject(clsid, ..., 

IID_IClassFactory, &pFactory); 


{ hr = pFactory->CreateInstance(..., iid, ppv); 

pFactory->Release; 

} 

return hr; 

} 

Klient 

CoCreateInstance 

COM API 

CoGet- 

ClassObject 

IA* 

DLL 

DllGetClassObject 

Class 

Factory 

new CFactory 

IClassFactory* 

IClassFactory::CreateInstance 

IClassFactory::Release 

pIA->fa 

Składnik 

new CMyComp 


2

Trzecie podejście - serwer 

 

 

 

Implementacja klasy składnika: 

prawie bez zmian 

Implementacja fabryki klas: 

 

 

 

implementacja IUnknown – standardowa 

implementacja IClassFactory::CreateInstance 

implementacja IClassFactory::LockServer 

Implementacja eksportowanych funkcji: 

 

 

 

DllCanUnloadNow – wymaga zliczania instancji 

DllGetClassObject 

DllRegisterServer / DllUnRegisterServer 


Trzecie podejście – co dalej? 

Serwer COM rejestrujemy za pomocą 

programu regsrv32 

Interfejsy mają stałe IID 

Aplikacje wcale nie muszą korzystać 

stale z tych samych CLSID 

3

TWORZENIE SKŁADNIKÓW 

WEWNĄTRZPROCESOWYCH 

Poniższy zwięzły opis przedstawia najważniejsze kroki niezbędne dla uzyskania klienta i serwera 

wewnątrzprocesowego COM. Ilustracją poniższej instrukcji są kody źródłowe approach3 i approach3a, a 

także inne materiały dostępne na stronie sun.iinf.polsl.gliwice.pl/~jfrancik/lectures/com.html. 

1. STWORZENIE SPECYFIKACJI IDL 

Plik IDL zawiera specyfikację tworzonych interfejsów i klas składników (a także biblioteki typów). 

Wynikiem kompilacji pliku abc.idl są między innymi pliki abc.h (deklaracje interfejsów w języku C/C++) 

oraz abc_i.c (definicje identyfikatorów iid i clsid). 

[Krok ten eliminuje potrzebę tworzenia pliku nagłówkowego interface.h 

oraz definiowania explicite identyfikatorów iid / clsid – por. listing approach 3] 

2. STWORZENIE APLIKACJI KLIENCKIEJ 

Aplikacja kliencka powinna obejmować obydwa pliki wynikowe kompilacji specyfikacji IDL wspomniane w 

poprzednim punkcie. Aplikacja inicjalizuje system COM (CoInitialize), zakłada nowy egzemplarz składnika 

za pomocą funkcji CoCreateInstance i otrzymuje wskaźnik na podany interfejs. Wskaźnik na dowolny, inny 

interfejs aplikacja może otrzymać wywołując funkcję QueryInterface już posiadanego interfejsu. Aplikacja 

jest zobowiązana wywoływać funkcje AddRef/Release – zgodnie z obowiązującymi zasadami (por. 

prezentacja approach2.pdf). 

3. STWORZENIE MODUŁU DLL SERWERA 

Na stworzenie modułu serwera składają się następujące czynności: 

1. Wprowadzenie do projektu plików wynikowych kompilacji specyfikacji IDL wyszczególnionych w p. 1. 

2. Założenie globalnych liczników: aktywnych składników oraz blokad serwera. 

3. Stworzenie klasy składnika. Wszystkie implementowane interfejsy powinny być wyszczególnione 

jako klasy bazowe. Należy zaimplementować wszystkie funkcje składowe tych interfejsów, a także 

funkcje składowe interfejsu IUnknown: QueryInterface, AddRef oraz Release. 

[Użycie specyfikacji IDL wymusza, by wszystkie funkcje składowe zwracały HRESULT. 

Listing Approach3 nie spełnia tego wymogu; stosowną poprawkę można znaleźć w listingu Approach3a] 

4. Stworzenie klasy implementującej interfejs IClassFactory (fabrykę klas). Należy zaimplementować 

zarówno funkcje składowe interfejsu IClassFactory (CreateInstance i LockServer), jak i 

wyszczególnione wcześniej funkcje składowe interfejsu IUnknown. 

5. Implementacja punktu wejściowego DLL (DllMain). W obrębie tej funkcji należy zachować uchwyt 

modułu DLL HMODULE. 

6. Implementacja obowiązkowych funkcji eksportowanych: 

- DllCanUnloadNow – na podstawie wspomnianych w p. 3-2 globalnych liczników ustala, czy 

serwer może być usunięty z pamięci. 

- DllGetClassObject – sprawdza podany clsid i tworzy odpowiadającą mu fabrykę klas. Zwraca 

wskaźnik do wskazanego w parametrze interfejsu fabryki klas. 

- DllRegisterServer – na podstawie zachowanego w funkcji DllMain uchwytu modułu DLL oraz 

dodatkowych, pomocniczych zmiennych globalnych, przeprowadza rejestrację serwera. 

Pomocne są tu pliki registry.h i registry.cpp (© Dale Rogerson) zawierające pomocne funkcje. 

- DllUnregisterServer – na podstawie dodatkowych, pomocniczych zmiennych globalnych, 

przeprowadza wyrejestrowanie serwera. Pomocne są tu pliki registry.h i registry.cpp (© Dale 

Rogerson) zawierające pomocne funkcje. 

7. Rejestracja modułu w systemie (za pomocą opcji Tools|Register Control w Visual Studio lub 

wywołując program regsvr32). 

opracowanie: Jarosław Francik

IDL EKSPRESOWE WPROWADZENIE 


PRZYKŁAD DEFINICJI INTERFEJSU: 

OBJAŚNIENIA: 


[ object, 


helpstring("przykładowy interfejs IA"), 


] 

interface IA : IUnknown 

{ HRESULT fun([in] int x, [out] int &r); 

}; 

Powyższa definicja odpowiada następującej klasie C++: 

interface IA : public IUnknown 

{ virtual void __stdcall fa() = 0; 

}; 

Specyfikacja klasy jest poprzedzona fragmentem znajdującym się w nawiasach kwadratowych. Są to rozszerzenia 

IDL w stosunku do C++: 

import 

wstawia plik w IDL (w tym przypadku: definicję klasy IUnknown) 

object 

wyróżnik obiektu COM (IDL ma zastosowania szersze niż tylko COM) 

uuid 

identyfikator GUID 

helpstring zwięzły opis w języku naturalnym, udostępniany na poziomie biblioteki typów 

pointer_default domyślny tryb marshalingu wskaźników; dostepne wartości to: 

ref wskaźniki są traktowane jak referencje: nie mogą zawierać NULL, nie mogą 

być zmieniane, w obrębie funkcji nie mogą być tworzone aliasy 

unique wskaźniki mogą zawierać NULL, mogą być zmieniane, ale w obrębie funkcji 

nie mogą być tworzone aliasy 

ptr wszystko powyższe jest dozwolone 

Specyfikacja funkcji składowych. Wszystkie funkcji w IDL muszą zwracać wartość HRESULT. Poszczególne 

parametry mogą zawierać dodatkowe określniki, stanowiące rozszerzenia IDL w stosunku do C++. Są 

one niezbędne dla zapewnienia prawidłowego marshalingu parametrów. 

Do zdefiniowania parametrów marshalingu są potrzebne: 

– adres przesyłanej zmiennej, 

– kierunek przesyłu argumentu, 

– rozmiar przesyłanego bloku. 

Pierwszy z powyższych parametrów jest znany podczas wykonania programu. 

Kierunek przesyłu argumentu określa się za pomocą następujących określników: 

in 

out 

in, out 

wyróżnik argumentu wejściowego funkcji 

wyróżnik argumentu wyjściowego (wyniku) funkcji (na ogół wskaźnika lub referencji) 

wyróżnik argumentu będącego jednocześnie wejściowym i wyjściowym 

Rozmiar przesyłanego bloku jest najczęściej jednoznacznie określany na podstawie typu przesyłanych danych. 

W kolejnych podpunktach zostaną przedstawione elementy języka IDL pozwalające na określenie rozmiaru przesyłanych 

danych w przypadkach, gdy nie może on być ustalony tylko na podstawie typu danych. 

Przesyłanie łańcuchów wymaga użycia określnika string. Należy pamiętać, że COM obsługuje wyłącznie 

łańcuchy Unicode (wchar_t zamiast char): 

HRESULT strfun([in, string] wchar_t *pIn, [out, string] wchar_t **pOut);

Przesyłanie tablic wymaga określenia rozmiaru tablicy za pomocą określnika size_is. Pozwala on na podanie 

rozmiaru posługując się innym parametrem, który powinien zawierać rozmiar tablicy: 

HRESULT arrfunIn([in] long nSize, [in, size_is(nSize)] long array[]); 

HRESULT arrfunOut([out, in] long *nSize, [out, size_is(nSize)] long array[]); 

należy zauważyć, że parametr użyty w size_in może być tylko wejściowy [in] lub wejściowo-wyjściowy [in, 

out]. Wynika z tego, że COM będzie zawsze wiedzieć, jak dużą tablicę udostępnił klient. Serwer może zapełnić 

tylko część tej tablicy, stosownie ustawiając parametr nSize. Z tego względu warto rozważyć następującą 

modyfikację funkcji arrfunOut, w której rozdzielono parametr wejściowy i wyjściowy: 

HRESULT arrfunOut2([in] nSizeIn, [out, size_is(nSizeIn)] long array[], 

[out] long *nSizeOut); 

Przekazywanie struktur jest łatwe, gdyż IDL pozwala na bezpośrednie definiowanie struktur: 

typedef struct Date 

{ int D; int M; int Y; 

} ; 

// .... 

HRESULT structfun([in] Date birthdate); 

Sprawa się komplikuje, gdy elementami struktury są wskaźniki na inne struktury, które również powinny 

być odwzorowane w ramach marshalingu. Kompilator IDL musi dokładnie wiedzieć, na co wskazuje wskaźnik 

– nie należy więc raczej stosować typu void*. Jeśli przekazywany jest wskaźnik na interfejs COM, dobrym 

pomysłem jest przekazanie – w osobnym parametrze – jego IID. Służy temu specjalny określnik iid_is: 

HRESULT intfun([in] const IID &iid, [out, iid_is(iid)] IUnknown **ppv); 

Oczywiście mniej więcej to samo można uzyskać przekazując typ interfejsu wprost, np.: 

HRESULT intfun_naive([out] IMyInterface **ppv); 

rozwiązanie takie zemści się jednak, gdy zamiast wskaźnika na IMyInterface zechcemy przesłać coś, co 

wskazuje na jakąś klasę wywiedzoną z IMyInterface. 

PRZYKŁAD DEFINICJI 

BIBLIOTEKI TYPÓW: 

OBJAŚNIENIA: 

library 

coclass 

[ uuid(3221CCFF-68B2-442b-AFDC-FA9C767F1FC4), 

version(1.0), 

helpstring("Przykładowa biblioteka typów") 

] 

library MyTypeLib 

{ importlib("stdole32.tlb") ; 

[ 

uuid(E843265D-B374-4d56-A980-0EC5E9188B47), 

helpstring("Klasa komponentu") 

] 

coclass Component 

{ 

[default] interface IA; 

interface IB; 

}; 

} ; 

definiuje bibliotekę typów o podanym GUID (LIBID). Biblioteka może zawierać jeden 

lub więcej komponentów – klas składników 

definiuje klasę składników o podanym GUID (CLSID). Klasa może udostępniać jeden lub 

więcej interfejsów. Jeden z nich może być domyślny, (istotne dla języków makr i VB). 

Opis powyższy ma charakter wstępny; w szczególności pominięto zagadnienia związane z definiowaniem 

dispinterfejsów (dipinterface, propget, propput, dual, oleautomation). Wyczerpujący opis języka IDL można 

znaleźć w MSDN; dobrym sposobem nauki IDL jest też analizowanie różnych dostępnych definicji klas.

TWORZENIE SKŁADNIKÓW 

ZEWNĄTRZPROCESOWYCH 

Poniższy zwięzły opis przedstawia najważniejsze kroki niezbędne dla uzyskania klienta i serwera zewnątrzprocesowego 

COM (serwer w pliku EXE). Tekst ten powinien być używany łącznie z instrukcją dot. 

tworzenia składników wewnątrzprocesowych (inproc). Ilustracją jest też kod źródłowy approach4, a także 

inne materiały dostępne na stronie sun.iinf.polsl.gliwice.pl/~jfrancik/lectures/com.html. 

1. STWORZENIE SPECYFIKACJI IDL 

Ten krok przebiega tak samo, jak w przypadku składników inproc. 

2. STWORZENIE APLIKACJI KLIENCKIEJ 

Jedyną różnicą pomiędzy aplikacją korzystającą ze składnika zewnątrzprocesowego (w stosunku do aplikacji 

używającej składnika inproc) jest wartość trzeciego parametru funkcji CoCreateinstance, która musi 

zawierać ustawiony bit CLSCTX_LOCAL_SERVER. 

3. STWORZENIE MODUŁU DLL PROXY 

Moduł proxy jest niezbędny przy komunikacji klienta z serwerem zewnątrzprocesowym, nie wymaga jednak 

specjalnego kodowania. Wystarczy w tym celu: 

- Stworzyć projekt DLL obejmujący następujące pliki źródłowe, automatycznie generowane podczas 

kompilacji specyfikacji IDL: dlldata.c, abc_i.c, abc_p.c (przy założeniu, że kompilowano plik abc.idl). 

- Włączyć linkowanie nastepujących bibliotek (poza standardowymi): rpcndr.lib, rpcns4.lib i rpcrt4.lib. 

- Dodać definicję symbolu REGISTER_PROXY_DLL 

- Dołączyć plik def (por. przykład approach4) 

- Skompilować i zlinkować projekt. 

- Zarejestrować otrzymany plik DLL (za pomocą opcji Tools|Register Control w Visual Studio lub 

wywołując program regsvr32). 

4. STWORZENIE MODUŁU EXE SERWERA 

Większa część kodu źródłowego serwerów zewnątrz- i wewnątrzprocesowych jest taka sama. W szczególności 

punkty 1 – 4 w części instrukcji dotyczącej tworzenia serwerów inproc można zastosować do serwerów 

zewnątrzprocesowych. Punkty 5 – 7 tej instrukcji nie odnoszą się do serwerów w plikach EXE, w szczególności 

nie ma tu funkcji eksportowanych. Oto specyficzne dla tego typu serwerów czynności dodatkowe: 

1. Stworzenie funkcji WinMain jak w przykładzie Approach4. Poniżej przedstawiono najważniejsze elementy: 

- Inicjalizacja systemu COM (CoInitialize). 

- Analiza linii wywołania: parametrów RegServer (rejestracja serwera), UnregServer (wyrejestrowanie 

serwera) i Embedding (praca tylko w trybie serwera, a nie aplikacji – zwykle powoduje wyłączenie 

wyświetlenia okna aplikacji). 

[Uwaga – wśród plików projektu Approach4 znajduja się pliki Registry.h i Registry.cpp 

z modyfikacjami niezbędnymi przy obsłudze składników zewnątrzprocesowych] 

- Utworzenie i rejestracja fabryk(i) klas (funkcja CoRegisterClassObject). 

- Wyświetlenie okna (zwykle z wyjątkiem trybu /Embedding) i petla komunikatów 

- Wyrejestrowanie fabryk(i) klas (CoRevokeClassObject) i deinicjalizacja COM (CoUninitialize) 

2. Implementacja zarządzania usuwaniem aplikacji z pamięci. Wymaga to: 

- przy dekrementacji globalnych liczników (g_cComponents i g_cServerLocks) – sprawdzenia, czy 

aplikacja nie powinna być usunięta z pamięci: 

- if (g_cComponents == 0 && g_cServerLocks == 0) PostQuitMessage(0); 

- Blokady usuwania aplikacji, gdy używany jest interfejs użytkownika (okno aplikacji): 

- InterlockedIncrement(&g_cServerLocks); – wywołane tuż po otwarciu okna 

- Zniesienia powyższej blokady w chwili zamknięcia okna aplikacji: 

- case WM_CLOSE: ::InterlockedDecrement(&g_cServerLocks); – w funkcji okienkowej 

- Dodatkowej kontroli podczas obsługi komunikatu WM_DESTROY: 

case WM_DESTROY: if (g_cComponents == 0 && g_cServerLocks == 0) PostQuitMessage(0); 

3. Zarejestrowanie serwera – poprzez wywołanie go z parametrem /RegServer. 


Interfejs IDispatch, 

dispinterfejsy 

i automatyzacja 


Interface Idispatch : IUnknown 

{ 

HRESULT GetTypeInfoCount([out] UINT __RPC_FAR *pctinfo); 

HRESULT GetTypeInfo( 

[in] UINT iTInfo, [in] LCID lcid, 

[out] ITypeInfo __RPC_FAR *__RPC_FAR *ppTInfo); 

HRESULT GetIDsOfNames( 

[in] REFIID riid, 

[in] LPOLESTR __RPC_FAR *rgszNames, 

[in] UINT cNames, 

[in] LCID lcid, 

[out, size_is(cNames)] DISPID __RPC_FAR *rgDispId); 

HRESULT Invoke( 

[in] DISPID dispIdMember, 

[in] REFIID riid, [in] LCID lcid, [in] WORD wFlags, 

[in] DISPPARAMS __RPC_FAR *pDispParams, 

[out] VARIANT __RPC_FAR *pVarResult, 

[out] EXCEPINFO __RPC_FAR *pExcepInfo, 

[out] UINT __RPC_FAR *puArgErr); 

}; 

interfejs IDispatch (IDL) 

Dispinterface 

Dispinterface 

Klient 

IDispatch 


Składnik COM 

Klient 

IDispatch 


Składnik COM 

AddRef 

Release 

GetTypeInfoCount 

dispinterface 

"fun1" 1 

"fun2" 2 

AddRef 

Release 


dispinterface 

"fun1" 1 

"fun2" 2 

GetTypeInfo 

GetIDsOfNames 

Invoke 

"fun3" 3 

1 fun1 

2 fun2 

GetTypeInfo 

GetIDsOfNames 

Invoke 

"fun3" 3 

pVTbl fun1 

fun2 

3 fun3 

fun3 

dual interface 

IDispatch 

Klient 


AddRef 

Release 


GetTypeInfo 

GetIDsOfNames 

Invoke 

fun1 

fun2 

fun3 

Składnik COM 

dispinterface 

"fun1" 1 

"fun2" 2 

"fun3" 3 

Parametry wywołania Invoke 

dispIdMember – dispid wywoływanej funkcji 

riid – zarezerwowany, ma być IID_NULL 

lcid – użyj GetUserDefaultLCID() 

wFlags – rodzaj funkcji: 

DISPATCH_METHOD, DISPATCH_PROPERTYGET, 

DISPATCH_PROPERTYPUT, DISPATCH_PROPERTYPUTREF 

pDispParams – tablica parametrów wywołania 

tagDISPPARAMS 

pVarResult – wynik funkcji (wskaźnik na 

wariant) 

pExcepInfo, puArgErr – sytuacje wyjątkowe 

1

DISPPARAMS i Warianty 

struct tagDISPPARAMS { VARIANTARG *rgvarg; /* .... */ }; 

struct tagVARIANT { /* .... */ 

VARTYPE vt; /* .... */ // stałe VT_* 

union { 

LONG lVal; 

// VT_I4 

BYTE bVal; 

// VT_UI1 

SHORT iVal; 

// VT_I2 

/* ... */ 

BSTR bStrVal; // VT_BYREF | VT_BSTR 

Ciekawe funkcje: 

SysAllocString 

VariantChangeType 

wchar_t progid[] = L"COMLecture.Approach5.1"; 

CLSID clsid; 

CLSIDFromProgID(progid, &clsid); 

IDispatch *pIDispatch = NULL; 

HRESULT hr = CoCreateInstance(clsid, NULL, CLSCTX_LOCAL_SERVER, 

IID_IDispatch, (void**)&pIDispatch); 

DISPID dispid; 

OLECHAR *name = L"fa"; 

hr = pIDispatch->GetIDsOfNames(IID_NULL, &name, 1, 

GetUserDefaultLCID(), &dispid); 

VARIANTARG varg; 

VariantInit(&varg); varg.vt = VT_EMPTY; 

DISPPARAMS param; 

param.cArgs = 0; param.rgvarg = &varg; 

param.cNamedArgs = 0; param.cArgs = NULL; 

hr = pIDispatch->Invoke(dispid, IID_NULL, GetUserDefaultLCID(), 

DISPATCH_METHOD, &param, NULL, NULL, NULL); 

Klient dla dispinterface 

Visual C++ i MFC: 

IA ia; 

ia.CreateDispatch("COMLecture.Approach5.1„) 

ia.fa(); 

Visual Basic: 

Dim x As Object 

CreateObject("COMLecture.Approach5.1„) 

x.fa 

Klienci dla dispinterface 

2

// Kalkulator (prosty) - wersja agregowalna 


// Interface ICalc 

[ 

object, 

uuid(892753ED-D14E-4d2f-B812-041E0C01F5F3), 

helpstring("Kalkulator (prosty), wersja agregowalna"), 


] 

interface ICalc : IUnknown 

{ 

HRESULT digit([in] int n); 

HRESULT comma(); 

HRESULT sign(); 

HRESULT op([in] int n); 

HRESULT eq(); 

HRESULT c(); 

HRESULT ce(); 

[propget, id(1), helpstring("wyświetlacz")] 

HRESULT display([out, retval] double *pVal); 

[propput, id(1), helpstring("wyświetlacz")] 

HRESULT display([in] double newVal); 

}; 


[ 

uuid(7FB7B169-2288-4713-98BD-4360E0147DD8), 

version(1.0), 

helpstring("Kalkulator (prosty), wersja agregowalna, bibl.typów") 

] 

library CalcAggrTypeLib 

{ 

importlib("stdole32.tlb") ; 

[ 

uuid(4D3B9D9B-8DCC-4443-BAC8-1DCAE9955270), 

helpstring("Kalkulator (prosty), wersja agregowalna") 

] 

coclass CalcSimple 

{ 

[default] interface ICalc; 

}; 

} ; 

// Serwer prostego kalkulatora - wersja agregowalna 

// Copyright (c) 2001 by Jarosław Francik 

#include "stdafx.h" 

#include "calc2.h" // plik automatycznie utworzony przez MIDL 

#include "calc2_i.c" // plik automatycznie utworzony przez MIDL 

#include 

#include "registry.h" // pomocnicze narzędzia do rejestru systemowego... 

/////////////////////////////////////////////////////////// 


static HMODULE g_hModule = NULL ; 

static long g_cComponents = 0 ; 

static long g_cServerLocks = 0 ; 

// uchwyt modułu DLL 

// Licznik aktywnych składników 

// Licznik dla LockServer 


const char g_szProgID[] = "Calc.SimpleAggr.2"; 

const char g_szFriendlyName[] = "Prosty kalkulator COM - wersja agregowalna"; 

const char g_szVerIndProgID[] = "Calc.SimpleAggr"; 

/////////////////////////////////////////////////////////// 

// Interfejs INondelegatingUnknown 

interface INondelegatingUnknown 

{ virtual HRESULT __stdcall 

NondelegatingQueryInterface(const IID&, void**) = 0 ; 

virtual ULONG __stdcall NondelegatingAddRef() = 0 ; 

virtual ULONG __stdcall NondelegatingRelease() = 0 ; 

} ; 

/////////////////////////////////////////////////////////// 


class CCalc : public ICalc, INondelegatingUnknown 

{public: 





// Implementacja interfejsu INondelegatingUnknown 

virtual HRESULT _stdcall NondelegatingQueryInterface(REFIID iid, void **ppv); 

virtual ULONG _stdcall NondelegatingAddRef(); 

virtual ULONG _stdcall NondelegatingRelease(); 

// Implementacja interfejsu ICalc 

virtual HRESULT __stdcall digit(int n); 

virtual HRESULT __stdcall comma(); 

virtual HRESULT __stdcall sign(); 

virtual HRESULT __stdcall op(int n); 

virtual HRESULT __stdcall eq(); 

virtual HRESULT __stdcall c(); 

virtual HRESULT __stdcall ce(); 

virtual HRESULT __stdcall get_display(double __RPC_FAR *pVal); 

virtual HRESULT __stdcall put_display(double newVal); 

// Implementacja wewnętrzna 

double m_display, m_reg; // wyświetlacz i drugi rejestr 

int m_op; // kod operacji; 0=nic, 1-4 = + - * / 

bool m_bAppendDisp; // tryb dodawania do wyświetlacza; 

public: 

CCalc(IUnknown *pUnknownOuter) : m_nRef(1), m_display(0.0), 

m_reg(0.0), m_op(0), m_bAppendDisp(false) 

{ InterlockedIncrement(&g_cComponents); 

if (pUnknownOuter) 

m_pUnknownOuter = pUnknownOuter; // zostaliśmy zagregowani! 

else 

m_pUnknownOuter = (IUnknown*)(INondelegatingUnknown*)this; 

} 

~CCalc() { InterlockedDecrement(&g_cComponents); } 

private: 

long m_nRef; 

IUnknown *m_pUnknownOuter; // obiekt do którego delegujemy odwołania 

};

// 

// Implementacja interfejsu ICalc 

HRESULT __stdcall CCalc::digit(int n) 

{ if (!m_bAppendDisp) 

m_display = n; 

else 

m_display = m_display * 10 + n; 

m_bAppendDisp = true; 

return S_OK; 

} 

HRESULT __stdcall CCalc::comma() 

{ return E_NOTIMPL; 

} 

HRESULT __stdcall CCalc::sign() 

{ m_display = -m_display; 

return S_OK; 

} 

HRESULT __stdcall CCalc::op(int n) 

{ eq(); 

m_op = n; 

return S_OK; 

} 

HRESULT __stdcall CCalc::eq() 

{ switch (m_op) 

{ 

case 1: m_display = m_reg + m_display; break; 

case 2: m_display = m_reg - m_display; break; 

case 3: m_display = m_reg * m_display; break; 

case 4: m_display = m_reg / m_display; break; 

} 

m_reg = m_display; 

m_bAppendDisp = false; 

return S_OK; 

} 

HRESULT __stdcall CCalc::c() 

{ m_reg = m_display = m_op = 0; 


return S_OK; 

} 

HRESULT __stdcall CCalc::ce() 

{ m_display = 0; 


return S_OK; 

} 

HRESULT __stdcall CCalc::get_display(double __RPC_FAR *pVal) 

{ 

*pVal = m_display; 

return S_OK; 

} 

HRESULT __stdcall CCalc::put_display(double newVal) 

{ 

m_display = newVal; 

return S_OK; 

} 

/////////////////////////////////////////////////////////// 

// 


HRESULT _stdcall CCalc::QueryInterface(REFIID iid, void **ppv) 

{ 

return m_pUnknownOuter->QueryInterface(iid, ppv); 

} 

ULONG _stdcall CCalc::AddRef() 

{ 

return m_pUnknownOuter->AddRef(); 

} 

ULONG _stdcall CCalc::Release() 

{ 

return m_pUnknownOuter->Release(); 

} 

/////////////////////////////////////////////////////////// 

// 


HRESULT _stdcall CCalc::NondelegatingQueryInterface(REFIID iid, void **ppv) 

{ 


*ppv = (INondelegatingUnknown*)this; 

else if (iid == IID_ICalc) 

*ppv = (ICalc*)this; 

else 

{ ppv = NULL; 

return E_NOINTERFACE; 

} 


return S_OK; 

} 

ULONG _stdcall CCalc::NondelegatingAddRef() 

{ 

return InterlockedIncrement(&m_nRef); 

} 

ULONG _stdcall CCalc::NondelegatingRelease() 

{ 

if (InterlockedDecrement(&m_nRef) == 0) 

{ 

delete this; 

return 0; 

} 

return m_nRef; 

} 

///////////////////////////////////////////////////////////

// 


class CFactory : public IClassFactory 

{ 

// standardowa deklaracja interfejsu IClassFactory 

} ; 

HRESULT __stdcall CFactory::QueryInterface(const IID& iid, void** ppv) 

// standardowa implementacja 

ULONG __stdcall CFactory::AddRef() 


ULONG __stdcall CFactory::Release() 




{ 

if (pUnknownOuter != NULL && iid != IID_IUnknown) 


} 


CCalc* pCalc = new CCalc(pUnknownOuter); 

if (!pCalc) 



HRESULT hr = pCalc->NondelegatingQueryInterface(iid, ppv); 

pCalc->NondelegatingRelease(); 

return hr; 



/////////////////////////////////////////////////////////// 

// 



//////////////////////////////////////////////////////////// 

// Kalkulator “naukowy” (z wykorzystaniem agregacji) 


// Interface ICalcScientific 

[ 

object, 

uuid(22E6B303-CEFE-4f65-9BED-8623AF83903E), 

helpstring("Kalkulator naukowy"), 


] 

interface ICalcScientific : IUnknown 

{ 

HRESULT sqroot(); 

}; 


[ 

uuid(F3B7AD02-3D70-46e5-9313-D479B95E4089), 

version(1.0), 

helpstring("Kalkulator naukowy, biblioteka typów") 

] 

library CalcSciTypeLib 

{ 


[ 

uuid(BA847794-18E2-42ce-B053-754828A6388E), 

helpstring("Kalkulator naukowy - komponent zagregowany") 

] 

coclass CalcScientific 

{ 

[default] interface ICalcScientific; 

// interface ICalc; 

}; 

} ; 

// Serwer kalkulatora naukowego (z pierwiastkowaniem) 

// Moduł agreguje składnik Calc2 - prosty kalkulator 



#include "calcsci.h" // plik automatycznie utworzony przez MIDL 

#include "calcsci_i.c" // plik automatycznie utworzony przez MIDL 

#include 

#include "registry.h" // pomocnicze narzędzia do rejestru systemowego... 

#include 

#include "..\\calc2\\calc2.h" 

#include "..\\calc2\\calc2_i.c" 

/////////////////////////////////////////////////////////// 

// 


// jak w poprzednim przykładzie...

// 


class CCalcScientific : public ICalcScientific 

{ 

public: 





// Implementacja interfejsu ICalcScientific 

virtual HRESULT __stdcall sqroot(); 

// Funkcja inicjalizująca obiekt wewnętrzny 

// (wywoływana przez fabrykę klas) 

HRESULT Init() 

{ 

return CoCreateInstance(CLSID_CalcSimple, (IUnknown*)this, 

CLSCTX_INPROC_SERVER, IID_IUnknown, (void**)&m_pUnknownInner); 

} 

public: 

IUnknown *m_pUnknownInner; 

CCalcScientific() : m_nRef(1) { InterlockedIncrement(&g_cComponents); } 

~CCalcScientific() { InterlockedDecrement(&g_cComponents); } 

private: 

long m_nRef; 

}; 

/////////////////////////////////////////////////////////// 

// 

// Implementacja interfejsu ICalcScientific 

HRESULT __stdcall CCalcScientific::sqroot() 

{ 

ICalc *pCalc = NULL; 

HRESULT hr = m_pUnknownInner->QueryInterface(IID_ICalc, (void**)&pCalc); 


{ 

double dDisp; 

pCalc->get_display(&dDisp); 

dDisp = sqrt(dDisp); 

pCalc->put_display(dDisp); 

return S_OK; 

} 

return hr; 

} 

/////////////////////////////////////////////////////////// 

// 


HRESULT _stdcall CCalcScientific::QueryInterface(REFIID iid, void **ppv) 

{ 


*ppv = (ICalcScientific*)this; 

else if (iid == IID_ICalcScientific) 

*ppv = (ICalcScientific*)this; 


return m_pUnknownInner->QueryInterface(iid, ppv); 

else 

{ ppv = NULL; 


} 


return S_OK; 

} 

ULONG _stdcall CCalcScientific::AddRef() 

ULONG _stdcall CCalcScientific::Release() 

// standardowe implementacje 

/////////////////////////////////////////////////////////// 

// 


// standardowa implementacja fabryki klas (jak w pierwszym przykładzie) 

// zmiany dotyczą tylko poniższego: 



{ 

if (pUnknownOuter != NULL) 



CCalcScientific* pCalcScientific = new CCalcScientific; 

if (!pCalcScientific) 


// Utworzenie wewnętrznego składnika 

HRESULT hr = pCalcScientific->Init(); 

if (!SUCCEEDED(hr)) 



hr = pCalcScientific->QueryInterface(iid, ppv); 

pCalcScientific->Release(); 

return hr; 

} 

/////////////////////////////////////////////////////////// 

// 


// standardowa implementacja

// Kalkulator (prosty) – wersja z punktami połączeń 


// Interface ICalc 

[ 

object, 

uuid(14169CFC-8CC3-45ec-8C46-D080C8DE6D39), 

helpstring("Kalkulator (prosty), wersja z punktami połączenia"), 


] 

interface ICalc : IUnknown 

{ 

HRESULT digit([in] int n); 

HRESULT comma(); 

HRESULT sign(); 

HRESULT op([in] int n); 

HRESULT eq(); 

HRESULT c(); 

HRESULT ce(); 

[propget, id(1), helpstring("wyświetlacz")] 

HRESULT display([out, retval] double *pVal); 

[propput, id(1), helpstring("wyświetlacz")] 

HRESULT display([in] double newVal); 

}; 

// Interfejs wychodzący 

[ 

object, 

uuid(A1284ED8-990E-4885-901A-26DA646245C8), 

helpstring("Kalkulator - Interfejs wychodzący"), 


] 

interface IOutgoingCalc : IUnknown 

{ 

HRESULT changed([in] double val); 

HRESULT errorB([in] BSTR msg); 

}; 


[ 

uuid(AF933814-60B5-4017-A695-413D21340D47), 

version(1.0), 

helpstring("Kalkulator (prosty), wersja z punktami połączenia, biblioteka 

typów") 

] 

library CalcAggrTypeLib 

{ 


[ 

uuid(0D49456B-4A4B-423c-9804-762059B7299A), 

helpstring("Kalkulator (prosty), wersja z punktami połączenia") 

] 

coclass CalcSimple 

{ 

[default] interface ICalc; 

[source] interface IOutgoingCalc; 

}; 

} ; 

// Serwer prostego kalkulatora - wersja z punktami połączenia 



#include "calcCP.h" 

#include "calcCP_i.c" 

#include 


#include 

// plik automatycznie utworzony przez MIDL 

// plik automatycznie utworzony przez MIDL 

// pomocnicze narzędzia do rejestru systemowego... 

// IConnectionPoint, IConnectionPointContainer 

/////////////////////////////////////////////////////////// 

// 


static HMODULE g_hModule = NULL ; 

static long g_cComponents = 0 ; 

static long g_cServerLocks = 0 ; 

// uchwyt modułu DLL 

// Licznik aktywnych składników 

// Licznik dla LockServer 


const char g_szProgID[] = "Calc.SimpleCP.2"; 

const char g_szFriendlyName[] = "Prosty kalkulator - wersja z CP”; 

const char g_szVerIndProgID[] = "Calc.SimpleCP"; 

// Wskaźnik do interfejsu ujścia 

IOutgoingCalc *g_pOutgoingCalc; 

/////////////////////////////////////////////////////////// 

// 

// Interfejs INondelegatingUnknown 

// jak w pierwszym przykładzie 

/////////////////////////////////////////////////////////// 

// 


class CCalc : public ICalc, INondelegatingUnknown, 

IConnectionPoint, IConnectionPointContainer 

{ 

public: 






virtual HRESULT _stdcall NondelegatingQueryInterface(REFIID iid, void **ppv); 

virtual ULONG _stdcall NondelegatingAddRef(); 

virtual ULONG _stdcall NondelegatingRelease();

}; 

// Implementacja interfejsu IConnectionPoint 

virtual HRESULT _stdcall GetConnectionInterface(IID __RPC_FAR *pIID); 

virtual HRESULT _stdcall GetConnectionPointContainer(IConnectionPointContainer 

__RPC_FAR *__RPC_FAR *ppCPC); 

virtual HRESULT _stdcall Advise(IUnknown __RPC_FAR *pUnkSink, 

DWORD __RPC_FAR *pdwCookie); 

virtual HRESULT _stdcall Unadvise(DWORD dwCookie); 

virtual HRESULT _stdcall EnumConnections(IEnumConnections 

__RPC_FAR *__RPC_FAR *ppEnum); 

// Implementacja interfejsu IConnectionPointContainer 

virtual HRESULT _stdcall EnumConnectionPoints(IEnumConnectionPoints 

__RPC_FAR *__RPC_FAR *ppEnum); 

virtual HRESULT _stdcall FindConnectionPoint(REFIID riid, 

IConnectionPoint __RPC_FAR *__RPC_FAR *ppCP); 

// dalej jak w pierwszym przykładzie 

.... 

/////////////////////////////////////////////////////////// 

// 

// Implementacja interfejsu Icalc 


/////////////////////////////////////////////////////////// 

// 



/////////////////////////////////////////////////////////// 

// 


HRESULT _stdcall CCalc::NondelegatingQueryInterface(REFIID iid, void **ppv) 

{ if (iid == IID_IUnknown) 

*ppv = (INondelegatingUnknown*)this; 


*ppv = (ICalc*)this; 

else if (iid == IID_IConnectionPoint) 

*ppv = (IConnectionPoint*)this; 

else if (iid == IID_IConnectionPointContainer) 

*ppv = (IConnectionPointContainer*)this; 

else 

{ ppv = NULL; 


} 


return S_OK; 

} 

ULONG _stdcall CCalc::NondelegatingAddRef() 


ULONG _stdcall CCalc::NondelegatingRelease() 


/////////////////////////////////////////////////////////// 

// 

// Implementacja interfejsu IConnectionPoint 

HRESULT _stdcall CCalc::GetConnectionInterface(IID __RPC_FAR *pIID) 


} 

HRESULT _stdcall CCalc::GetConnectionPointContainer(IConnectionPointContainer 

__RPC_FAR *__RPC_FAR *ppCPC) 


} 

HRESULT _stdcall CCalc::Advise(IUnknown __RPC_FAR *pUnkSink, DWORD __RPC_FAR 

*pdwCookie) 

{ 

// Wartość cookie jest nieistotna przy jednym połączeniu 

*pdwCookie = 1; 

} 

// oto wskaźnik do interfejsu ujścia 

return pUnkSink->QueryInterface(IID_IOutgoingCalc, 

(void**)&g_pOutgoingCalc); 

HRESULT _stdcall CCalc::Unadvise(DWORD dwCookie) 

{ 

g_pOutgoingCalc->Release(); 

g_pOutgoingCalc = NULL; 

return S_OK; 

} 

HRESULT _stdcall CCalc::EnumConnections(IEnumConnections __RPC_FAR 

*__RPC_FAR *ppEnum) 


} 

/////////////////////////////////////////////////////////// 

// 

// Implementacja interfejsu IConnectionPointContainer 

HRESULT _stdcall CCalc::EnumConnectionPoints(IEnumConnectionPoints __RPC_FAR 

*__RPC_FAR *ppEnum) 


} 

HRESULT _stdcall CCalc::FindConnectionPoint(REFIID riid, IConnectionPoint 

__RPC_FAR *__RPC_FAR *ppCP) 

{ 

if (riid == IID_IOutgoingCalc) 

return QueryInterface(IID_IConnectionPoint, (void**)ppCP); 


} 

/////////////////////////////////////////////////////////// 

// 

// Class Factory I funkcje eksportowane 

// standardowa implementacja fabryki klas (jak w pierwszym przykładzie)

Zawieranie i agregacja 

Zawieranie (Containment) 

• Powtórne użycie (reuse) 

• Dziedziczenie implementacji 

• Przesłanianie tożsamości obiektów 

Zawieranie = Containment 

Agregacja = Aggregation 

ICalcScientific 

ICalc 

CalcScientific 

ICalc 

CalcSimple 

IUnknown 

IUnknown 

Institute of Informatics, Silesian University of Technology, Gliwice, Poland 


Agregacja (Aggregation) 

Punkty połączeń 

IUnknown 

SERWER 

ICalcScientific 

CalcScientific 

INondelegatingUnknown 

IUnknown 

IConnectionPoint 

ICalc 

CalcSimple 

KLIENT 

ujście 

(sink) 






interface IConnectionPoint : IUnknown 

{ // Wymień dostępne punkty połączenia 

HRESULT GetConnectionInterface([out] IID __RPC_FAR *pIID); 

// Podaj pojemnik punktów połączenia 

HRESULT GetConnectionPointContainer( 

[out] IConnectionPointContainer *ppCPC); 

// Przyjmij wskaźnik do mojego ujścia 

HRESULT Advise( 

[in] IUnknown *pUnkSink, 

[out] DWORD *pdwCookie); 

// Nie wywołuj już mojego ujścia 

HRESULT Unadvise([in] DWORD dwCookie); 

// Wymień połączenia 

HRESULT EnumConnections([out] IEnumConnections *ppEnum); 

}; 



IConnectionPointContainer : public IUnknown 

{ 

// Wymień dostępne punkty połączenia 

HRESULT EnumConnectionPoints([out] IEnumConnectionPoints 

*ppEnum); 

}; 

// Znajdź wskazany punkt połączenia 

HRESULT FindConnectionPoint([in] REFIID riid, 

[out] IConnectionPoint *ppCP); 

1

Wielowątkowość w Windows 

Wielowątkowość w COM 

Marek Mittmann 

Grudzień 2002 

Wątek (ang.( 

thread) ) to sekwencja 

wykonywana przez proces, każdy 

proces ma do wykonania jeden lub 

więcej wątków 

Tam, gdzie wątki korzystają ze 

współdzielonych danych, konieczna 

jest synchronizacja 

Do synchronizacji wykorzystujemy: 

zdarzenia, sekcje krytyczne, semafory 

i wzajemne wykluczanie obiektów 

(mutex) 

Przedziały 

Typy przedziałów 

Przedział (ang.( 

apartment) ) to kolekcja 

obiektów wraz z ich kontekstami 

Każdy obiekt należy do dokładnie 

jednego przedziału 

Przedziały określają zestaw zasad dla 

danej grupy obiektów, wymaganych do 

poprawnej pracy w środowisku 

wielowątkowym 

 

 

 

Jednowątkowe (STA) 

Mają po jednym wątku, proces może mieć 

wiele STA 

Synchronizowane przy pomocy kolejki 

komunikatów 

Wielowątkowe (MTA) 

Mają wiele wątków, proces może mieć 

tylko jeden MTA 

Brak synchronizacji 

Neutralne (NA) 

Proces może mieć jeden NA 

Proces 

Proces 

Przedziały a wątki 

STA 

STA 

STA 

MTA 

MTA 

 

 

 

Przedziały jednowątkowe 

Każdy STA ma tylko jeden wątek, w 

pojedynczym procesie może istnieć 

wiele STA 

Wszystkie komponenty nie obsługujące 

modelu wielowątkowego działają w 

głównym STA 

Wątek deklaruje obsługę modelu STA 

przez wywołanie CoInitializeEx z drugim 

parametrm równym 

COINIT_APARTMENTTHREAD

Przedziały jednowątkowe c.d. 

Przedziały wielowątkowe 

 

 

 

Wywołania metod w STA są 

automatycznie synchronizowane i 

dysponowane przy użyciu kolejek 

komunikatów 

Każdy komponent zewnątrzprocesowy, 

który obsługuje model STA, musi 

zawierać pętlę komunikatów 

Komponent wykonywalny może 

blokować wywołania metod w STA za 

pomocą filtrów komunikatów (interfejs 

IMessageFilter) 

 

 

 

W pojedynczym procesie może istnieć 

tylko jeden MTA, który z kolei może 

zawierać wiele wątków 

Wywołania metod w MTA nie są 

automatycznie synchronizowane 

Wątek deklaruje obsługę modelu STA 

przez wywołanie CoInitializeEx z drugim 

parametrm = COINIT_MULTITHREAD 

 

 

 

 

Przedziały neutralne 

W pojedynczym procesie może istnieć 

tylko jeden NA 

Nie ma stałych wątków, obiekty z NA są 

zawsze wykonywane przez wątek 

wywołujący 

Brak wbudowanej synchronizacji 

Przedziały neutralne są obsługiwane 

tylko przez komponenty 

wewnątrzprocesowe 

 

Przedziały a komponenty 

wewnątrzprocesowe 

Komponenty wewnątrzprocesowe nie 

wywołują CoInitializeEx, , obsługiwany model 

wielowątkowości deklarują za pomocą wpisu 

w rejestrze (klucz CLSID\InprocServer32 

InprocServer32). 

Dopuszczalne wartości to: 

Apartment – STA 

Neutral – NA 

Free – MTA 

Both – obsługuje STA, NA i MTA 

brak – komponent jednowątkowy 

Przypisywanie do przedziałów 

Współdziałanie przedziałów 

Typ przedziału 

twórcy 

Model wielowątkowości komponentu 

Nieokreślony Apartment Free Both Neutral 

Proces 

Główny STA główny STA główny STA MTA główny STA NA 

Obiekt 

Pośrednik 

Obiekt 

Lekki 

pośrednik 

STA główny STA STA 

wywołującego 

MTA 

STA 


NA 

STA 

MTA 

MTA główny STA macierzysty STA MTA MTA NA 

Obiekt 

Lekki 

pośrednik 

Obiekt 

NA (wątek STA) główny STA STA 


MTA NA NA 

STA 

NA 

NA (wątek MTA) główny STA macierzysty STA MTA NA NA

Współdziałanie przedziałów 

Typ przedziału twórcy 

Główny STA 

Model wielowątkowości komponentu 

Nieokreślony Apartment Free Both Neutral 

bezpośredni 

dostęp 

bezpośredni 

dostęp 

dostęp 

przez 

pośrednika 

bezpośred 

ni dostęp 

dostęp przez lekkiego 

pośrednika 

Przekazywanie interfejsów 

pomiędzy przedziałami 

// STA1 

IMyInterface* pMyInterface; 

CoCreateInstance(CLSID_MyCOMClass, NULL, 

CLSCTX_LOCAL_SERVER, IID_IMyInterface, 

(void**)&pMyInterface); 

void MyThread(IStream* pScream) 

{ 

// Utwórz STA2 

CoInitializeEx(NULL, 

COINIT_APARTMENTTHREADED); 

STA 

MTA 

NA (wątek STA) 

dostęp przez 

pośrednika 

dostęp przez 

pośrednika 

dostęp przez 

pośrednika 

bezpośredni 

dostęp 

dostęp przez 

pośrednika 

dostęp przez 

lekkiego 

pośrednika 

dostęp 

przez 

pośrednika 

bezpośredni 

dostęp 

dostęp 

przez 

pośrednika 

bezpośred 

ni dostęp 

bezpośred 

ni dostęp 

bezpośred 

ni dostęp 


pośrednika 


pośrednika 

bezpośredni dostęp 

IStream* pStream; 

CoMarshalInterThreadInterfaceInStream( 

IID_IMyInterface, pMyInterface, 

&pStream); 

DWORD threadid; 

CreateThread(0, 0, 

(LPTHREAD_START_ROUTINE) MyThread, 

(void*)pStream, 0, &threadid); 

IMyInterface* pMyInterface; 

CoGetInterfaceAndReleaseStream( 

pStream, IID_IMyInterface, 

(void**) &pMyInterface); 

// ... 

pMyInterface->Release(); 

NA (wątek MTA) 

dostęp przez 

pośrednika 

dostęp przez 

pośrednika 

dostęp 

przez 

lekkiego 

pośrednika 

bezpośred 

ni dostęp 

bezpośredni dostęp 

// ... 

pMyInterface->Release(); 


} 

Podsumowanie 

Podsumowanie c.d. 

 

 

 

 

Każdy STA może mieć tylko jeden wątek 

Komponenty wykorzystujace wątki STA 

muszą pobierać i dysponować 

komunikaty okna 

Przekazywanie wskaźników interfejsów 

pomiedzy wątkami z różnych przedziałów 

powinno odbywać się za pośrednictwem 

szeregowania 

Każdy wątek korzystający z COM 

powinien wywołać CoInitializeEx 

 

 

 

 

Każdy obiekt jest związany tylko z 

jednym, ale przedział może zawierać 

wiele obiektów 

Główny STA jest tworzony przez wątek, 

który pierwszy wywoła CoInitializeEx z 

COINIT_APARTMENTTHREAD 

Proces może mieć wiele STA, ale tylko 

jeden MTA i jeden NA 

Dla obiektów wewnątrzprocesowych 

należy zdefiniować w rejestrze 

ThreadingModel

Kategorie komponentów 


w modelu COM 


maj 2002 



• Cel: usprawnienie wyszukiwania klas 

komponentów 

• Pozycje rejestru systemowego: 

– W HKEY_CLASSES_ROOT: 

• Component Categories – zestawienie kategorii (CATID) 

– dla poszczególnych klas: 

• Implemented Categories 

• Required categories 



• Domyślne klasy 

można je tworzyć nie znając CLSID, a tylko CATID! 

• Emulacja klas: 

klucz TreatAs 

funkcja CoTreatAsClass 

• Component Categories Manager 

interface ICatRegister 

interface ICatInformation 


1



w modelu COM 


maj 2002 

Trwałość (Persistency) 

PODSTAWOWE INTERFEJSY TRWAŁOŚCI: 

• IPersist 

• IPersistStream 

• IPersistStreamInit 

• IPersistStorage 

• IPersistFile 

• IPersistPropertyBag 

PODSTAWOWY INTERFEJS IPERSIST 

interface IPersist : IUnknown 

{ 

HRESULT GetClassID([out] CLSID *pClsId); 

}; 

OBSŁUGA STRUMIENI 

interface IPersistStreamInit : IPersist 

{ 

HRESULT IsDirty(); 

HRESULT Load([in, unique] IStream *pStr); 

HRESULT Save([in, unique] IStream *pStr, 

[in] BOOL fClearDirty); 

HRESULT GetSizeMax([out] 

ULARGE_INTEGER *pSize); 

HRESULT InitNew(); 

}; 

ZAPIS TRWAŁEGO OBIEKTU 

// pobieramy clsid klasy 

CLSID clsid; 

hr = pPersistent->GetClassID(&clsid); 

// zapisujemy clsid (standardowa funkcja) 

hr = WriteClassStm(pStream, clsid) 

// zapisujemy dane obiektu 

hr = pPersistent->Save(pStream, TRUE); 

interface ISequentialStream : IUnknown 

{ 

HRESULT Read([out, size_is(cb), 

length_is(*pRead)] void *p, 

[in] ULONG cb, 

[out] ULONG *pRead); 

HRESULT Write( 

[out, size_is(cb)] void *p, 

[in] ULONG cb, 

[out] ULONG *pWritten); 

}; 

ODCZYT TRWAŁEGO OBIEKTU 

// pobieramy CLSID 

CLSID clsid; 

hr = ReadClassStm(pStream, &clsid); 

// tworzymy nowe wystąpienie obiektu 

IPersistStream *pPersistent; 

hr = CoCreateInstance(clsid, NULL, 

CLSCTX_INPROC_SERVER, IID_IPersistStream, 

(void**)pPersistent); 

PRACA Z ZESTAWAMI WŁAŚCIWOŚCI 

// Wciągamy dane obiektu 

pPersistent->Load(pStream); 

SPRYTNE FUNKCJE STANDARDOWE 

hr = OleSaveToStream(pPersistent, pStream); 

hr = OleLoadFromStream(pPersistent, pStream); 

interface IPersistPropertyBag : IPersist 

{ 

HRESULT IsDirty(); 

HRESULT Load([in] IPropertyBag *pPropBag, 

[in] IErrorLog *pErrorLog); 

HRESULT Save([in] IPropertyBag *pPropBag, 

[in] BOOL fClearDirty, 

[in[ BOOL bSaveAllProps); 

HRESULT GetSizeMax([out] 

ULARGE_INTEGER *pSize); 

HRESULT InitNew(); 

}; 

interface IPropertyBag : IUnknown 

{ 

HRESULT Read([in] LPCOLESTR pPropName, 

[in, out] VARIANT *pVar, 

[in] IErrorLog *pErrorLog); 

}; 

HRESULT Write([in] LPCOLESTR pPropName, 

[in] VARIANT *pVar); 


Do czego służą monikery? 


w modelu COM 


czerwiec 2002 


Monikery 

• Zastosowanie – dwa w jednym: 

– inteligentne nazwy obiektów 

– inicjalizowanie obiektów 

• Co ma jedno do drugiego? 

class CPoint 

{ 

CPoint (int x, int y); 

void Draw(); 

}; 

CPoint *p = 

new CPoint(10, 10); 


interface IPoint 

{ 

HRESULT Draw(); 

}; 

IPoint *p = NULL; 

CoCreateInstance(clsid,... 

IID_IPoint, (void**)&p); 

CoCreateInstance nie jest odpowiednikiem 

konstruktora: nie ma parametrów wywołania 

Monikery – istota działania 

Monikery standardowe 

nazwa obiektu 

MONIKER 

point:10,10 

arkusz.xls 

arkusz.xls!Sheet1!R1C1:R10C6 

216C83D7-4621-4ffd-A87D-61DD9C3D2A66 

plikowy 

elementowy 

klasowy 

złożony 

URL 

CreateFileMoniker 

CreateItemMoniker 

CreateClassMoniker 

CreateURLMoniker 

ścieżka i nazwa pliku 

obiekt zawarty w innym 

obiekcie 

„opakowanie” CLSID: 

obiekt klasy 

CreateGenericComposite superpozycja kilku 

monikerów 

URL 

instancja obiektu 


wskaźnikowy CreatePointerMoniker 

OBJREF 

antymoniker 

CreateObjrefMoniker 

CreateAntiMoniker 


identyfikuje obiekt 

w stanie aktywnym 

uszeregowany wskaźnik do 

interfejsu IUnknown 

odwrotność monikera 

Interfejs IMoniker 

Stosowanie nazw symbolicznych 

• Dziedziczy po IPersistStream 

• Ciekawsze funkcje składowe: 

GetDisplayName 

zwraca nazwę symboliczną 

ParseDisplayName 

przekształca nazwę symboliczną w moniker 

BindToObject 

dowiązuje obiekt nazywany przez moniker 

Reduce 

redukuje moniker do najprostszej postaci 

ComposeWith 

łączy monikery tworząc moniker złożony 


• Metoda IMoniker::ParseDisplayName 

• Funkcja MkParseDisplayName 

– dla podanego łańcucha tworzy moniker 

– przyjmuje dwa typy nazw: 

• ścieżka do pliku, np: 

c:\moje dokumenty\arkusz.xls 

• standardowa nazwa obiektu: 

ProgID:Nazwa-obiektu 

gdzie: 

ProgID – zarejestrowany prog id monikera 

Nazwa-obiektu – nazwa rozpoznawalna dla monikera 

•przykład dla monikera klasowego: 

clsid:216C83D7-4621-4ffd-A87D-61DD9C3D2A66 


1

Dowiązywanie obiektów 

Czas na kod… 

• Metoda IMoniker::BindToObject 

• Funkcja BindMoniker (nieco prostsza w użyciu) 

// tworzy kontekst wiązania 

IBindCtx *pBindCtx; 

hr = CreateBindCtx(0, &pBindCtx); 

monikerów raczej nie tworzymy 

przez CoCreateInstance! 

• Co robi IMoniker:: BindToObject? 

– tworzy instancję odpowiedniego obiektu 

– inicjalizuje ją 

• Jak IMoniker::BindToObject inicjalizuje obiekty? 

–zależy od typu monikera 

– moniker plikowy: wciąga z pliku; tworzony obiekt 

musi implementować IPersistFile 

– moniker klasowy: wywołuje CoGetClassObject 


// utworzenie monikera 

ULONG chEaten; 

IMoniker *pMoniker = NULL; 

hr = MkParseDisplayName(pBindCtx, pszNazwa, 

&chEaten, &pMoniker); 

// dowiązuje obiekt 

ICoś *p 

pMoniker->BindToObject(pBindCtx, 0, IID_ICoś,(void**)&p); 

pMoniker->Release(); 

pBindCtx->Release(); 


// monikery nie żyją długo… 

// konteksty wiązania też nie 

Kod: uproszczenia 

Monikery złożone 

• Dowiązanie obiektu bez jawnego kontekstu: 

zamiast: 

IBindCtx *pBindCtx; 

CreateBindCtx(0, &pBindCtx); 

pMoniker->BindToObject(pBindCtx, 0, IID_ICoś, (void**)&p); 

pBindCtx->Release(); 

wystarczy: 

BindMoniker(pMoniker, 0, IID_ICoś, (void**)&p); 

moniker plikowy 

moniker 

elementowy 

moniker 

elementowy 

c:\program files\arkusz.xls Sheet1 R1C1:R10C6 

moniker złożony 

c:\program files\arkusz.xls!Sheet1! R1C1:R10C6 

• Funkcja CoGetObject 

robi wszystko: udostępnia obiekt na podstawie nazwy 

HRESULT CoGetObject(LPCWSTR pszDisplayName, 

BIND_OPTS *pBindOptions, IID &riid, void **ppv); 



Przykład: OLE Linking 

• Dokument złożony (kontener) zawiera utrwalone 

dane monikera plikowego dokumentu 

włączonego (linked) 

• Korzystając z interfejsu IPersistStream 

(który implementują wszystkie monikery) 

można z dokumentu utrwalonego odtworzyć 

obiekt monikera plikowego 

• Moniker plikowy identyfikuje swą nazwę (plik) 

i dowiązuje zapisany w nim dokument włączony 

• Dokument włączony, aby współpracować z 

monikerem plikowym, implementuje IPersistFile 

Podsumowanie 

• Monikery tworzymy za pomocą specjalnych 

funkcji (CreateXXXMoniker) lub podając nazwę 

symboliczną (MkParseDisplayName) 

• Monikery implementują IPersistStream, zatem 

możemy je przechowywać w strumieniach i 

magazynach 

• Utworzony lub odtworzony moniker dowiązuje 

nazywany przez siebie obiekt (i inicjalizuje go) 

• Po dowiązaniu obiektu moniker zazwyczaj jest 

usuwany 



2

OLE: Pojęcia podstawowe 


w modelu COM 


czerwiec 2002 

OLE: Object Linking 

and Embedding 

• OLE – technologia polegająca na tworzeniu 

złożonych dokumentów 

• Przez pewien czas OLE było zbiorczą nazwą 

technologii znanej obecnie jako COM 

• Dokument złożony (compound document) 

• Łączenie (linking) – dokument włączony 

znajduje się w oddzielnym pliku 

• Osadzanie (embedding) – dokument osadzony 

jest przechowywany w obrębie dokumentu 

złożonego (w magazynie IStorage) 



OLE: Pojęcia podstawowe 

• Kontener (container) – aplikacja obsługująca 

dokumenty złożone; klient 

• Serwer OLE –serwer udostępniający dokumenty 

osadzane lub łączone 

• Miniserwer OLE – serwer wewnątrzprocesowy, 

nie występuje jako osobna aplikacja 

(oferuje wyłącznie dokumenty osadzane) 

• Pełny serwer OLE (full server) – serwer 

zewnątzprocesowy 

Osadzanie (embedding) 

• Struktura obiektu magazynowego (IStorage) 

podsumowanie 

dokumentu 

root storage 

dokument 

MS MS Word 

arkusz 

kalkulacyjny 

pula pula obiektów 

magazyn obiektów osadzonych 

cache 

prezentacji 

CLSID 

Excel’a 



kontener OLE 

obiekt 

kliencki 

(client site) 



strona kontenera (klienta) 

IOleClientSite 

IAdviceSink 

IOleClientSite –udostępnia 

serwerowi sterowanie 

kontenerem 

SaveObject –zapisuje 

obiekt 

ShowObject –wymusza 

wyświetlenie obiektu 

RequestNewObjectLayout 

IAdviceSink –ujście 

różnego rodzaju notyfikacji 

OnDataChange 

OnViewChange 

OnRename 

OnSave 

OnClose 

IOleObject 

IRunnableObject 

IDataObject 

IPersistStorage 

IOleCache2 

IOleCacheControl 

IViewObject2 


strona serwera 

serwer OLE 

data 

cache 

obiekt 

zawartości 

(content 

object) 


1





IOleObject 


IDataObject 


IOleCache2 


IViewObject2 

serwer in-proc 

data 

cache 

ujście 

IOleObject 

IDataObject 


IAdviseSink 

serwer lokalny 

IOleObject 


IDataObject 


IOleCache2 


IViewObject2 

• Obiekt danych: IDataObject 

– podstawa tzw. Uniform Data Transfer: 

dane przesyłane z miejsca w miejsce w 

standardowy sposób 

– podstawa mechanizmów OLE Clipboard 

i Drag and Drop 

–Ważniejsze funkcje: 

• GetData, SetData – transfer danych 

• QueryGetData – „znasz taki format danych?” 

• EnumFormatEtc – wymienia formaty danych 

• DAdvice, DUnadvice – mechanizm podobny 

do punktów połączeń; nota bene: 

współpracuje z interfejsem IAdviceSink 







IOleObject 


IDataObject 


IOleCache2 


IViewObject2 

• Trwałość obiektu: IPersistStorage 

–obsługa zapisywania – wykorzystywana 

przez kontener po to, by zapisać 

osadzony dokument w obrębie 

dokumentu złożonego 

• Kontener dostarcza magazyn danych 

IStorage 

system dostarcza standardową 

implementację IStorage poprzez funkcję: 

StgCreateStorageEx 

IOleObject 


IDataObject 


IOleCache2 


IViewObject2 

• Interfejsy obsługujące cache: 

IOleCache2, IOleCacheControl 

obsługa obiektu „cache prezentacji” 

niezbędna do komunikacji z serwerem 

lokalnym 







IOleObject 


IDataObject 


IOleCache2 


IViewObject2 

• Reprezentacja wizualna obiektu: 

IViewObject2 

– automatycznie przejmowana przez cache 

–Najważniejsze funkcje: 

• Draw 

• GetColorSet 

• GetExtent 

IOleObject 


IDataObject 


IOleCache2 


IViewObject2 

• Obiekt OLE (IOleObject) i czasowniki 

– jeden z najistotniejszych interfejsów, 

pozwalających na bezpośrednią 

komunikację z obiektem OLE 

– nigdy nie jest implementowany 

przez obiekt cache 

–Najważniejsze funkcje: 

• SetClientSite 

• DoVerb – wywołanie tzw. czasownika, np. w 

celu edycji osadzonego dokumentu 

• EnumVerbs 

• GetExtent/SetExtent 



2


Aktywacja w miejscu (in-place activation) 

• Dodatkowe interfejsy 

Łączenie (linking) 

• Struktura obiektu magazynowego (IStorage) 

• po stronie kontenera: 

IOleInPlaceSite: rozszerzenie IOleClientSite 

IOleInPlaceFrame: negocjacja wspólnego menu/toolbara 

IOleInPlaceUIWindow: dalsze szczsegółowe negocjacje 

• po stronie serwera: 

IOleInPlaceObject: 

IOleInPlaceActiveObject: 

podsumowanie 

dokumentu 

root storage 

dokument 

MS MS Word 

pula pula obiektów 

magazyn obiektów włączonych 

cache 

prezentacji 

moniker 

arkusza 

kalkulacyjnego 



Łączenie (linking) 

• Po stronie kontenera (klienta): 

–Obsługa łączenia przebiega po stronie kontenera 

w ramach tych samych interfejsów, co w przypadku 

osadzania. 

– Wykorzystuje się moniker, który jest zapisywany 

w dokumencie złożonym (magazynie) podobnie, 

jak osadzony dokument 

• Specjalne interfejsy: 

– IOleLink –związany z obsługą monikera 

– IPersistFile – wymagany przez monikery plikowe 


3

Trochę historii… 


w modelu COM 


czerwiec 2002 

Kontrolki ActiveX 

• VBX – Visual Basic Extensions… 

• OLE Controls 

– rozbudowana specyfikacja wymuszająca 

implementację wielu różnych interfejsów 

• ActiveX Controls 

– nowa potrzeba: przesyłanie kontrolek przez Internet 

–nowa, rozluźniona specyfikacja – „lekkie kontrolki” 

ActiveX stał się flagowym okrętem Microsoftu 

nowe zamieszanie językowe: ActiveX = COM? 



Definicja ActiveX 

• Tylko dwa wymogi: 

– implementacja interfejsu IUnknown 

–zdolność do samorejestrowania się 

• Na podstawie tej definicji większość 

serwerów COM to ActiveX 

Definicja ActiveX 

• Dodatkowy wymóg: 

– rozszerzenie funkcjonalności kontrolki ActiveX 

w określonych, standardowych obszarach wymaga 

bezwzględnego przestrzegania obowiązujących norm 

– nie musisz tego implementować, ale jeśli już chcesz, 

to musisz to zrobić ściśle wg naszych wytycznych 

• około 20 standardowych interfejsów, i liczba ta 

ciągle rośnie 



Anatomia ActiveX 


Kontener 

• cztery obszary 

funkcjonalności: 

– GUI 

– metody 

– zdarzenia 

– właściwości 

IOleInPlaceFrame 

IOleInPlaceUIWindow 

IOleInPlaceSite 


IAdviseSink 

IOleControlSite 

IDispatch 

IPropertyNotifySink 

IDispatch (events) 


IOleInPlaceActiveObject 

IOleInPlaceObject 

IOleObject 


IDataObject 

IViewObject2 

IOleCache2 


IPersistStreamInit 

ISpecifyPropertyPages 

IConnectionPointContainer 


IProvideClassInfo2 

IDispatch 

IOleControl 

Kontrolka 

ActiveX 

Kontener 





IAdviseSink 


IDispatch 



• GUI: 

– zgrubsza ta sama 

funkcjonalność, co w 

przypaku In-Place OLE 

(w wydaniu inprocess) 

– liczne kontrolki nie 

korzystają z cache 


IOleInPlace- 

ActiveObject 


IOleObject 


IDataObject 

IViewObject2 

IOleCache2 







IDispatch 

IOleControl 

Kontrolka 

ActiveX 

1



Kontener 





IAdviseSink 


IDispatch 



• metody: 

– realizowane w postaci 

dispatch interfejsu 




IOleObject 


IDataObject 

IViewObject2 

IOleCache2 







IDispatch 

IOleControl 

Kontrolka 

ActiveX 

Kontener 





IAdviseSink 


IDispatch 





IOleObject 


IDataObject 

IViewObject2 

IOleCache2 




IConnectionPointContaine 

• zdarzenia: 

– po stronie kontrolki: 

punkty kontrolne 

(connection points), 

informacja o typach 

IConnectionPoint r 

– po stronie kontenera: IProvideClassInfo2 

dynamicznie tworzony 

IDispatch 

Institute of dispatch Informatics, Silesian interfejs University of Technology, Gliwice, Poland IOleControl 

Kontrolka 

ActiveX 



Kontener 

• właściwości: 

– trwałość właściwości 

– obsługa w dispatch 

interface 

– property pages 





IAdviseSink 


IDispatch 






IOleObject 


IDataObject 

IViewObject2 

IOleCache2 







IDispatch 

IOleControl 

Kontrolka 

ActiveX 

Kontener 





IAdviseSink 


IDispatch 





IOleObject 


IDataObject 

IViewObject2 

IOleCache2 

• interfejsy specyficzne: 


– niewielkie interfejsy 


ibejmujące 


funkcjonalność 



nieobjętą przez 


pozostałe interfejsy 

IDispatch 

Institute of Informatics, Silesian University of Technology, Gliwice, PolandIOleControl 

Kontrolka 

ActiveX 

Podsumowanie 

• Kontrolki ActiveX w większości opierają się na 

innych, znanych technologiach (OLE, 

connection points, dispatch interfaces) 

• Pełna funkcjonalność obejmuje na tyle dużą 

liczbę interfejsów, że w praktyce nigdy nie 

implementuje się ActiveX bez specjalizowanych 

narzędzi 

• Ostatnie zdanie dotyczy w pewnym sensie całej 

technologii COM 


2

IPtr - Smart Interface Pointer 

// Use: IPtr spIX ; 

// Do not use with IUnknown; IPtr 

// will not compile. Instead, use IUnknownPtr. 

template class IPtr 

{ 

public: 

// Constructors 

IPtr() 

{ 

m_pI = NULL ; 

} 

IPtr(T* lp) 

{ 

m_pI = lp ; 

if ( m_pI != NULL) 

{ 

m_pI->AddRef() ; 

} 

} 

IPtr(IUnknown* pI) 

{ 

m_pI = NULL ; 

if (pI != NULL) 

{ 

pI->QueryInterface(*piid, (void **)&m_pI) ; 

} 

} 

// Destructor 

~IPtr() 

{ 

Release() ; 

} 

// Reset 

void Release() 

{ 

if (m_pI != NULL) 

{ 

T* pOld = m_pI ; 

m_pI = NULL ; 

pOld->Release() ; 

} 

} 

// Conversion 

operator T*() { return m_pI ;} 

// Pointer operations 

T& operator*() { assert(m_pI != NULL) ; return *m_pI ;} 

T** operator&() { assert(m_pI == NULL) ; return &m_pI ;} 

T* operator->() { assert(m_pI != NULL) ; return m_pI ;} 

// Assignment from the same interface 

T* operator=(T* pI) 

{ 

if (m_pI != pI) 

{ 

IUnknown* pOld = m_pI ; 

m_pI = pI ; 

if (m_pI != NULL) 

{ 

m_pI->AddRef() ; 

} 

if (pOld != NULL) 

{ 


} 

} 

return m_pI ; 

} 

// Assignment from another interface 

T* operator=(IUnknown* pI) 

{ 

IUnknown* pOld = m_pI ; 

m_pI == NULL ; 

} 

// Save current value. 

// Assign new value. 

// Release the old interf 

// Save current value. 

// Query for correct interface. 

if (pI != NULL) 

{ 

HRESULT hr = pI->QueryInterface(*piid, 

void**)&m_pI) ; 

assert(SUCCEEDED(hr) && (m_pI != NULL)) ; 

} 

if (pOld != NULL) 

{ 

} 

return m_pI ; 


// Release old pointer. 

// Boolean functions 

BOOL operator!() { return (m_pI == NULL) ? TRUE : FALSE ;} 

operator BOOL() const { return (m_pI != NULL) ? TRUE : FALSE ; } 

// GUID 

const IID& iid() { return *piid ;} 

private: 

// Pointer variable 

T* m_pI ; 

} ; 


ATL: ACTIVE TEMPLATE LIBRARY 

KRÓTKI WSTĘP DO PROGRAMOWANIA 

JAROSŁAW FRANCIK 

Biblioteka ATL, rozprowadzana wraz z pakietem Visual Studio/C++, jest przeznaczona do tworzenia modułów COM. 

W porównaniu z MFC oferuje nie tylko większe możliwości w tym zakresie, ale przede wszystkim gwarantuje znacznie 

mniejsze rozmiary skompilowanych modułów – co jest niezwykle istotne, szczególnie w przypadku tworzenia kontrolek 

ActiveX przeznaczonych do instalowania przez Internet. 

Podobnie, jak w przypadku MFC, dogłębne poznanie biblioteki ATL wymaga długiego przygotowania. Jednak proste, 

ale funkcjonalne moduły można tworzyć znając jedynie najważniejsze elementy tej biblioteki. 

Tworzone w oparciu o ATL klasy komponentów zapewniają obsługę standardowych interfejsów COM. Najprostszy z 

nich, zwany prostym obiektem (simple object) obsługuje interfejsy IUnknown i IClassFactory, tak więc programista nie 

musi (na ogół) dbać o ich implementację. 

TWORZENIE MODUŁÓW SERWERA COM 

Utworzenie modułu serwera COM wymaga wybrania opcji File|New i wskazania ATL COM Wizard jako typu projektu. 

W kolejnym oknie ustala się m.in. typ serwera (wewnątrzprocesowy – DLL lub zewnątrzproceoswy – EXE). Po zatwierdzeniu 

otrzymujemy szkieletowy moduł DLL lub EXE, wraz z typowymi elementami implementacji (np. w przypadku 

DLL funkcjami DllGetClassObject, DllCanUnloadNow, DllRegisterServer i DllUnregisterServer). Moduł ten 

nie zawiera początkowo żadnych klas. Poniżej przedstawiono sposób implementacji dwóch prostych klas COM. 

TWORZENIE PROSTYCH KOMPONENTÓW – LICZNIK ZWYKŁY 

Klasy komponentów tworzy się za pomocą narzędzia dostępnego w menu poprzez Insert|New ATL Object. Następnie, 

korzystając z narzędzia Class View można wprowadzać metody i właściwości. 

Poniżej przedstawiono szczegółowy przepis na stworzenie prostej klasy komponentów implementujących licznik zliczający 

w górę: 

1. Utwórz nowy projekt (File|New) wybierając pozycję ATL COM AppWizard. Przyjmij domyślne ustawienia 

kreatora (powstanie moduł DLL). 

2. Wprowadź nowy obiekt (właściwie: klasę): wybierz opcję Insert|New ATL Object. 

3. Gdy na ekranie pojawi się okno ATL Object Wizard, wybierz pozycję Objects i kliknij ikonę Simple Object, a 

następnie naciśnij przycisk Next. 

4. Wpisz w pole tekstowe Short Name nazwę tworzonego komponentu. Kliknij OK. 

W tym momencie mamy już utworzoną klasę komponentu. Oznacza to miedzy innymi, że zaimplementowany 

jest już interfejs IUnknown, IFactoryClass oraz IDispatch (utworzona klasa ma interfejs podwójny (dual) – o 

czym zadecydowało jedno z ustawień w kreatorze). 

5. W obszarze ClassView wybierz utworzony dopiero co interfejs i wybierz w menu kontekstowym Add Method. 

6. W oknie dialogowym utwórz metodę Inc – bezparametrową. Powtórz operację dla metody Reset. 

7. Ponownie korzystając z ClassView utwórz właściwość Value. Określ dla niej typ long i wyłącz zaznaczenie 

pola Put Function (w ten sposób utworzymy właściwość tylko do odczytu). 

8. W obszarze ClassView wybierz klasę implementującą interfejs i wybierz opcję Add Member Variable. Dodaj 

zmienną składową long m_val. 

9. Dodaj inicjalizację zmiennej w konstruktorze: m_val = 0; 

10. W pliku implementacyjnym uzupełnij implementację metod (należy dodać tylko wyróżnione linijki, pozostała 

część kodu jest wygenerowana automatycznie.): 

STDMETHODIMP CCounter::Inc() 

{ 

m_val++; 

return S_OK; 

} 

STDMETHODIMP CCounter::Reset() 

{ 

m_val = 0; 

return S_OK; 

} 

STDMETHODIMP 

CCounter::get_Value(long *pVal) 

{ 

*pVal = m_val; 

return S_OK; 

} 

W tym momencie klasa jest już gotowa do użycia. Można ją przetestować na przykład za pomocą niewielkiego programu 

w Visual Basicu.

TWORZENIE KOMPONENTÓW GENERUJĄCYCH ZDARZENIA – LICZNIK WSTECZ 

Zdarzenia są generowane za pośrednictwem interfejsu punktu połączenia IConnectionPoint. Poniżej przedstawiono 

klasę liczników zliczających w dół, wysyłających sygnał po osiągnięciu zera: 

1. Utwórz projekt podobnie, jak w przypadku poprzedniej klasy. Możesz też utworzyć nową klasę w ramach tego 

samego modułu i projektu. 

2. Utwórz klasę liczników wstecz bazując na szablonie Simple Object. Uwaga: w kreatorze obiektów COM 

przejdź do zakładki Attributes i wskaż opcję Support Connection Points. Możesz też zaznaczyć opcję Support 

ISupportErrorInfo. 

3. Utwórz metodę Dec oraz właściwość Value (tym razem do odczytu i zapisu). 

4. Tak, jak poprzednio, utwórz zmienną m_val, w której przechowywana będzie wartość atrybutu Value. Zainicjalizuj 

ją w konstruktorze. 

5. Stwórz implementację funkcji składowych: 

STDMETHODIMP CCounter::Dec() 

{ 

m_val--; 

return S_OK; 

} 

STDMETHODIMP 

CCounter::get_Value(long *pVal) 

{ 

*pVal = m_val; 

return S_OK; 

} 

STDMETHODIMP CCounter::put_Value(long 

newVal) 

{ 

m_val = newVal; 

return S_OK; 

} 

Utworzona klasa przypomina podstawową klasę liczników. Obecnie dodamy obsługę IConnectionPoint. 

6. Odnajdź w ClassView pozycję odpowiadającą interfejsowi połączeń, np. _ICounterEvents. 

7. Za pomocą menu kontekstowego i opcji (uwaga!) AddMethod dodaj zdarzenie Zero. Return type ustaw na void. 

8. Skompiluj projekt. Następny punkt będzie realizowany w oparciu o utworzoną podczas tej kompilacji 

bibliotekę typów * . 

9. Uruchom implementację punktu połączeń: w tym celu w ClassView zaznacz nazwę klasy liczników i wybierz 

opcję Implement Connection Point. Zaznacz wyświetloną w okienku nazwę interfejsu. Ten krok należy powtórzyć 

za każdym razem, gdy doda się nowe zdarzenie. 

W tym momencie zostanie stworzona implementacja dla klasy połączenia (zob. plik *CP.H). W klasie tej dostępna 

jest metoda Fire_Zero wyzwalająca zdarzenie. Uwaga – zdarzenia należy interpretować jako wywołania 

interfejsu, który zaimplementowany jest po stronie klienta. 

10. Zmień stosownie funkcję Dec: 


{ 

m_val--; 

if (!m_val) Fire_Zero(); 

return S_OK; 

} 

11. Jeżeli w p. 2 włączono opcję Support ISupportErrorInfo, możesz uruchomić mechanizm diagnostyki błędów, 

wprowadzając nastepującą linijkę kodu na początku metody Dec: 


{ if (m_val

6 folii na stronÄ

You also want an ePaper? Increase the reach of your titles

Delete template?

Save as template?

6 folii na stronÄ