ADOEvts.exe is a sample that demonstrates how to capture events from
Microsoft Active Data Objects (ADO). The ADO events in this sample were
added with ADO version 2.0.
The following file is available for download from the Microsoft Download Center:
ADOEVTS.EXE
(http://download.microsoft.com/download/vc60pro/info/1/win98/en-us/adoevts.exe)
For additional information about how to download Microsoft Support files, click the following article number to view the article in the Microsoft Knowledge Base:
119591Â
(http://kbalertz.com/Feedback.aspx?kbNumber=119591/EN-US/
)
How to Obtain Microsoft Support Files from Online Services
Microsoft scanned this file for viruses. Microsoft used the most current virus-detection software that was available on the date that the file was posted. The file is stored on security-enhanced servers that help to prevent any unauthorized changes to the file.
To build the sample, run ADOEvts.exe, open the ADOEvts.cpp file in the
Visual C++ environment, and build. When you receive a message asking if
you would like to create a default project workspace click Yes. The #import
of MSADO15.dll might have to be redirected if you do not have a "Program
Files" directory on your C: drive.
You need to make a DataSource called "AccessTest" on the system that is
pointing to the Test.mdb file provided with this sample.
After you run the console application, the events are shown in the Visual
C++ Output window.
Follow these steps to capture ADO events in Visual C++:
- Create classes derived from RecordsetEventsVt and ConnectionEventsVt.
These classes define the sink object for the events.
- Implement the IUnknown and RecordsetEventsVt/ConnectionEventsVt methods
for each of the classes.
- In your application, create an instance of the event class and connect
the object to the appropriate ADO connection point.
The following sample demonstrates how to implement the steps above.
Creating the Event Classes
The first step to handling ADO events is to create the sink classes that
will handle the events. To do this, you must create a Visual C++ class
derived from either RecordsetEventsVt or ConnectionEventsVt, depending upon
the events you want to capture. The RecordsetEventsVt and
ConnectionEventsVt interfaces are defined in ADOInt.h, which comes with the
Microsoft Data Access SDK or Visual Studio version 6.0.
The sample shows both of the classes in ADOConnEvts.h and ADORSEvts.h. They
are called CADOConnectionEvents and CADORecordsetEvents respectively.
Following is the connection event class:
********
#include <adoint.h>
class CADOConnectionEvents : public ConnectionEventsVt
{
public :
ULONG m_ulRefCount;
CADOConnectionEvents():m_ulRefCount(1){}
STDMETHOD(QueryInterface)(REFIID iid, LPVOID * ppvObject)
{
if (IsEqualIID(__uuidof(IUnknown), iid) ||
IsEqualIID(__uuidof(ConnectionEventsVt), iid))
{
*ppvObject = this;
return S_OK;
}
else
return E_NOINTERFACE;
}
STDMETHOD_(ULONG, AddRef)()
{
return m_ulRefCount++;
}
STDMETHOD_(ULONG, Release)()
{
if (--m_ulRefCount == 0)
{
delete this;
return 0;
}
else
return m_ulRefCount;
}
STDMETHOD(InfoMessage)(
ADOError * pError,
EventStatusEnum * adStatus,
_ADOConnection * pConnection)
{
*adStatus = adStatusUnwantedEvent;
return S_OK;
}
STDMETHOD(BeginTransComplete)(
LONG TransactionLevel,
ADOError * pError,
EventStatusEnum * adStatus,
_ADOConnection * pConnection)
{
*adStatus = adStatusUnwantedEvent;
return S_OK;
}
STDMETHOD(CommitTransComplete)(
ADOError * pError,
EventStatusEnum * adStatus,
_ADOConnection * pConnection)
{
*adStatus = adStatusUnwantedEvent;
return S_OK;
}
STDMETHOD(RollbackTransComplete)(
ADOError * pError,
EventStatusEnum * adStatus,
_ADOConnection * pConnection)
{
*adStatus = adStatusUnwantedEvent;
return S_OK;
}
STDMETHOD(WillExecute)(
BSTR * Source,
CursorTypeEnum * CursorType,
LockTypeEnum * LockType,
long * Options,
EventStatusEnum * adStatus,
_ADOCommand * pCommand,
_ADORecordset * pRecordset,
_ADOConnection * pConnection)
{
*adStatus = adStatusUnwantedEvent;
return S_OK;
}
STDMETHOD(ExecuteComplete)(
LONG RecordsAffected,
ADOError * pError,
EventStatusEnum * adStatus,
_ADOCommand * pCommand,
_ADORecordset * pRecordset,
_ADOConnection * pConnection)
{
*adStatus = adStatusUnwantedEvent;
return S_OK;
}
STDMETHOD(WillConnect)(
BSTR * ConnectionString,
BSTR * UserID,
BSTR * Password,
long * Options,
EventStatusEnum * adStatus,
_ADOConnection *pConnection)
{
*adStatus = adStatusUnwantedEvent;
return S_OK;
}
STDMETHOD(ConnectComplete)(
ADOError * pError,
EventStatusEnum * adStatus,
_ADOConnection * pConnection)
{
*adStatus = adStatusUnwantedEvent;
return S_OK;
}
STDMETHOD(Disconnect)(
EventStatusEnum * adStatus,
_ADOConnection * pConnection)
{
*adStatus = adStatusUnwantedEvent;
return S_OK;
}
};
********
Notice that you must implement Iunknown. Also, notice that all of the
methods return adStatusUnwantedEvent. This tells ADO to not call the event
handler again. This gives you a generic class that you can derive from and
then only override the events that you want to handle. All other events are
only be called once because of the adStatusUnwantedEvent return value. You
can see in ADOEvents.cpp that there are 2 classes derived from these
classes: CCnEvents and CRSEvents. These are the classes that you will use
to create the event objects. Their methods contain an OutputDebugString
message for each event so you can view the events in the output window of
the debugger.
Connecting an Event Object to ADO
The ADOEvts.cpp file demonstrates how to connect an event object to an ADO
connection or recordset. Four functions are defined:
SetConnectionEvents(),
SetRSEvents(),
ClearRSEvents(), and
ClearConnectionEvents(). Following is
and example of how the functions are used in the
main() function:
*****
int main(int argc, char* argv[])
{
CoInitialize(NULL);
ADODB::_ConnectionPtr spConn(__uuidof(ADODB::Connection));
ADODB::_RecordsetPtr spRS(__uuidof(ADODB::Recordset));
SetConnectionEvents(spConn);
spConn->Open(L"DSN=AccessTest", L"", L"", -1L);
SetRSEvents(spRS);
spRS->Open(L"Select * from Table1", spConn.GetInterfacePtr(),
ADODB::adOpenKeyset, ADODB::adLockOptimistic, -1);
spRS->MoveFirst();
spRS->MoveNext();
spRS->Close();
spConn->Close();
ClearRSEvents(spRS);
ClearConnectionEvents(spConn);
return 0;
}
*****
In the code above you can see that an interface pointer to the connection
and recordset objects is passed to SetConnectionEvents and SetRSEvents
respectively. These functions create a connection event or recordset event
object and connect it to the ADO object.
Following is the code for SetConnectionEvents():
*****
DWORD gdwCnEvents;
HRESULT SetConnectionEvents(ADODB::_ConnectionPtr & spConn)
{
IConnectionPointContainer *pCPC = NULL;
IConnectionPoint *pCP = NULL;
HRESULT hr;
hr = spConn->QueryInterface(IID_IConnectionPointContainer,
(LPVOID *) &pCPC);
if (FAILED(hr))
return hr;
hr = pCPC->FindConnectionPoint(__uuidof(ConnectionEvents), &pCP);
pCPC->Release();
if (FAILED(hr))
return hr;
hr = pCP->Advise(new CCnEvents, &gdwCnEvents);
pCP->Release();
return hr;
}
*****
: UUIDs come from "ConnectionEvents" and "RecordsetEvents". The
connection points QueryInterface() the event object you pass to the
Advise() call for ConnectionEventsVt or RecordsetEventsVt.
Also, further notice that the pointer, "new CCnEvents", is passed directly
to the Advise call. The event object is freed when its Release() method is
called in the connection point Unadvise() call in ClearConnectionEvents().