TN054: Chiamando DAO direttamente utilizzando le classi DAO MFC
[!NOTA]
A partire da Visual C++ .NET, l'ambiente e le procedure guidate di Visual C++ non supportano più DAO, anche se le classi DAO sono incluse e possono essere comunque utilizzate.Si consiglia di utilizzare Modelli OLE DB o ODBC e MFC per i nuovi progetti.di utilizzare DAO solo per la gestione delle applicazioni già esistenti.
Quando si utilizzano le classi di database DAO MFC, potrebbero verificarsi situazioni in cui è necessario utilizzare direttamente le API DAO.In genere, questo non verrà il caso, ma MFC forniti alcuni meccanismi di supporto per semplificare la lettura delle chiamate dirette di DAO semplici quando si combinano l'utilizzo di classi MFC con chiamate dirette di DAO.La esecuzione di chiamate dirette di DAO ai metodi di un oggetto MFC gestito di DAO deve richiedere poche righe di codice.Se è necessario creare e utilizzare gli oggetti di DAO che non sono gestiti da MFC, sarà necessario eseguire un poco più lavoro effettivamente chiamando Versione l'oggetto.Questa nota tecnica viene illustrato quando è necessario chiamare direttamente le API DAO, quali gli helper MFC possono essere utili e come utilizzare le interfacce DAO OLE.Infine, questa nota fornisce alcune funzioni di esempio che illustrano come chiamare direttamente le API DAO per le funzionalità di sicurezza di DAO.
Quando eseguire chiamate dirette di DAO
Le situazioni più comuni per eseguire chiamate dirette di DAO si verificano quando le raccolte devono essere aggiornate o quando si distribuiscono le funzionalità non esegue il wrapping da MFC.La funzionalità più significativa non esposta da MFC è sicurezza.Se si desidera implementare funzioni di sicurezza, sarà necessario utilizzare gli utenti di DAO e gruppo oggetti direttamente.Oltre alla sicurezza, sono disponibili solo alcune altre funzionalità di DAO supportate da MFC.Questi comprendono funzionalità di replica di duplicazione e il database di recordset nonché alcune modifiche recenti a DAO.
Una breve panoramica dell'implementazione di MFC e DAO
Il wrapping di DAO di MFC semplifica l'utilizzo di DAO più facile gestire molti dettagli in modo da non dover per piccole operazioni.Ciò include l'inizializzazione di OLE, la creazione e la gestione degli oggetti di DAO (soprattutto gli oggetti Collection), il controllo degli errori e di creazione di un'interfaccia fortemente tipizzata e più semplice (nessun variant o argomenti di BSTR ).È possibile effettuare chiamate dirette di DAO e di sfruttare.Tutto il codice deve effettuare consiste nel chiamare Versione per tutti gli oggetti creati dalle chiamate dirette di DAO e non modificarne uno dei puntatori a interfaccia a MFC può basarsi su internamente.Ad esempio, non modificare il membro m_pDAORecordset di un oggetto aperto di CDaoRecordset a meno di comprendere tutte le ramificazioni interne.È possibile, tuttavia, utilizzare l'interfaccia m_pDAORecordset per chiamare direttamente le API DAO per ottenere la raccolta dei campi.In questo caso il membro m_pDAORecordset non viene modificato.È necessario chiamare semplicemente Versione l'oggetto Collection dei campi al termine dell'oggetto.
Descrizione di helper per rendere le chiamate di DAO più semplici
Gli helper forniti per eseguire la chiamata a DAO più facile sono uguali helper utilizzati internamente classi di database DAO MFC.Questi helper utilizzati per controllare i codici restituiti quando effettua una chiamata diretta di DAO, registrando l'output di debug, controllo degli errori previsti e generazione di eccezioni appropriate se necessario.Esistono due funzioni di supporto sottostanti e quattro macro che eseguono il mapping a uno di questi due helper.La migliore spiegazione verrebbe di leggere semplicemente il codice.Vedere DAO_CHECK, DAO_CHECK_ERROR, DAO_CHECK_MEMe DAO_TRACE in AFXDAO.H per visualizzare le macro e AfxDaoCheck vedere e AfxDaoTrace in DAOCORE.CPP.
L'utilizzo delle interfacce DAO OLE
Le interfacce OLE per ogni oggetto nella gerarchia di oggetti di DAO sono definite nel file di intestazione DBDAOINT.H, che si trova in \ programmi \ Microsoft Visual Studio .NET 2003. \ VC7 \ directory di inclusione.Queste interfacce forniscono metodi che consentono di modificare l'intera gerarchia di DAO.
Per molti dei metodi nelle interfacce DAO, sarà necessario modificare un oggetto di BSTR (una stringa con prefisso di lunghezza utilizzata in automazione OLE).L'oggetto di BSTR in genere è incapsulato nel tipo di dati variant.La classe COleVariant stesso MFC eredita dal tipo di dati variant.A seconda se si compila il progetto per ANSI o Unicode, le interfacce DAO restituiranno ANSI o Unicode BSTRS.Due macro, V_BSTR e V_BSTRT, sono utili per verificare che l'interfaccia di DAO ottiene BSTR del tipo previsto.
V_BSTR estrarrà il membro bstrVal di COleVariant.Questa macro in genere utilizzata quando è necessario passare il contenuto di COleVariant a un metodo di interfaccia di DAO.Nel frammento di codice mostra le dichiarazioni che il l'utilizzo di due metodi di interfaccia di DAO DAOUser che utilizzano la macro V_BSTR :
COleVariant varOldName;
COleVariant varNewName( _T("NewUser"), VT_BSTRT );
// Code to assign pUser to a valid value omitted
DAOUser *pUser = NULL;
// These method declarations were taken from DBDAOINT.H
// STDMETHOD(get_Name) (THIS_ BSTR FAR* pbstr) PURE;
// STDMETHOD(put_Name) (THIS_ BSTR bstr) PURE;
DAO_CHECK( pUser->get_Name( &V_BSTR ( &varOldName ) ));
DAO_CHECK( pUser->put_Name( V_BSTR ( &varNewName ) ));
Si noti che l'argomento di VT_BSTRT specificato nel costruttore di COleVariant sopra garantisce che sia presente un ANSI BSTR in COleVariant se si compila una versione ANSI dell'applicazione e Unicode BSTR di versione Unicode dell'applicazione.Questa operazione DAO prevede.
Altre macro, V_BSTRT, estrarrà un formato ANSI o il membro Unicode bstrVal di COleVariant a seconda del tipo di compilazione (ANSI o Unicode.Il codice seguente viene illustrato come estrarre il valore di BSTR da COleVariant in CString:
COleVariant varName( _T( "MyName" ), VT_BSTRT );
CString str = V_BSTRT( &varName );
La macro V_BSTRT, con altre tecniche per aprire altri tipi archiviati in COleVariant, come illustrato nell'esempio di DAOVIEW.In particolare, questa conversione viene eseguita nel metodo CCrack::strVARIANT.Questo metodo, laddove possibile converte il valore di COleVariant in un'istanza di CString.
Esempio semplice di una chiamata diretta a DAO
Le situazioni può verificarsi quando è necessario aggiornare gli oggetti Collection sottostanti di DAO.In genere, questo non deve essere necessario, ma è una procedura semplice se necessario.Un esempio di quando una raccolta debba essere aggiornato quando si lavora in un ambiente multiutente con più utenti che creano nuovi TableDef.In questo caso la forza di raccolta TableDef diventata non aggiornata.Per aggiornare la raccolta, è sufficiente chiamare il metodo Refresh dell'oggetto Collection e del controllo specifici per gli errori:
DAO_CHECK( pMyDaoDatabase->
m_pDAOTableDefs->Refresh( ) );
Si noti che attualmente tutte le interfacce dell'oggetto Collection di DAO sono dettagli di implementazione non documentati delle classi di database DAO MFC.
Utilizzo di DAO direttamente per le funzionalità di sicurezza di DAO
Le classi di database DAO MFC non eseguono il wrapping delle funzioni di sicurezza di DAO.È necessario chiamare metodi delle interfacce DAO per utilizzare alcune funzionalità di sicurezza di DAO.La seguente funzione imposta il database di sistema e quindi modificare la password dell'utente.Questa funzione chiama altre tre funzioni, che successivamente vengono definite.
void ChangeUserPassword( )
{
// Specify path to the Microsoft Access
// system database
CString strSystemDB =
_T( "c:\\Program Files\\MSOffice\\access\\System.mdw" );
// Set system database before MFC initilizes DAO
// NOTE: An MFC module uses only one instance
// of a DAO database engine object. If you have
// called a DAO object in your application prior
// to calling the function below, you must call
// AfxDaoTerm to destroy the existing database
// engine object. Otherwise, the database engine
// object already in use will be reused, and setting
// a system datbase will have no effect.
//
// If you have used a DAO object prior to calling
// this function it is important that DAO be
// terminated with AfxDaoTerm since an MFC
// module only gets one copy of the database engine
// and that engine will be reused if it hasn't been
// terminated. In other words, if you do not call
// AfxDaoTerm and there is currently a database
// initialized, setting the system database will
// have no affect.
SetSystemDB( strSystemDB );
// User name and password manually added
// by using Microsoft Access
CString strUserName = _T( "NewUser" );
CString strOldPassword = _T( "Password" );
CString strNewPassword = _T( "NewPassword" );
// Set default user so that MFC will be able
// to log in by default using the user name and
// password from the system database
SetDefaultUser( strUserName, strOldPassword );
// Change the password. You should be able to
// call this function from anywhere in your
// MFC application
ChangePassword( strUserName, strOldPassword,
strNewPassword );
.
.
.
}
I quattro esempi seguenti viene illustrato come:
Impostare il database DAO di sistema (file di .MDW).
Impostazione dell'utente e la password predefiniti.
Modificare la password di un utente.
Modificare la password di un file MDB.
.gif "1s0dx3s7.collapse_all(it-it,VS.110).gif")
Impostare il database di sistema
In è una funzione di esempio per impostare il database di sistema che verrà utilizzato da un'applicazione.Questa funzione deve essere chiamato prima che tutte le altre chiamate di DAO sono effettuate.
// Set the system database that the
// DAO database engine will use
void SetSystemDB( CString & strSystemMDB )
{
COleVariant varSystemDB( strSystemMDB, VT_BSTRT );
// Initialize DAO for MFC
AfxDaoInit( );
DAODBEngine* pDBEngine = AfxDaoGetEngine( );
ASSERT( pDBEngine != NULL );
// Call put_SystemDB method to set the
// system database for DAO engine
DAO_CHECK( pDBEngine->put_SystemDB( varSystemDB.bstrVal ) );
}
L'impostazione dell'utente e la password predefiniti
Per impostare l'utente e la password predefiniti per un database di sistema, utilizzare la funzione seguente:
void SetDefaultUser(CString & strUserName, CString & strPassword)
{
COleVariant varUserName( strUserName, VT_BSTRT );
COleVariant varPassword( strPassword, VT_BSTRT );
DAODBEngine* pDBEngine = AfxDaoGetEngine( );
ASSERT( pDBEngine != NULL );
// Set default user:
DAO_CHECK( pDBEngine->put_DefaultUser( varUserName.bstrVal ) );
// Set default password:
DAO_CHECK( pDBEngine->put_DefaultPassword( varPassword.bstrVal ) );
}
Modificare la password di un utente
Per modificare la password di un utente, utilizzare la funzione seguente:
void ChangePassword( CString &strUserName,
CString &strOldPassword,
CString &strNewPassword )
{
// Create (open) a workspace
CDaoWorkspace wsp;
CString strWspName = _T( "Temp Workspace" );
wsp.Create( strWspName, strUserName,
strOldPassword );
wsp.Append( );
// Determine how many objects there are
// in the Users collection
short nUserCount;
short nCurrentUser;
DAOUser *pUser = NULL;
DAOUsers *pUsers = NULL;
// Side-effect is implicit OLE AddRef( )
// on DAOUser object:
DAO_CHECK( wsp.m_pDAOWorkspace->get_Users( &pUsers ) );
// Side-effect is implicit OLE AddRef( )
// on DAOUsers object
DAO_CHECK( pUsers->get_Count( &nUserCount ) );
// Traverse through the list of users
// and change password for the userid
// used to create/open the workspace
for( nCurrentUser = 0; nCurrentUser < nUserCount;
nCurrentUser++ )
{
COleVariant varIndex( nCurrentUser, VT_I2 );
COleVariant varName;
// Retrieve information for user nCurrentUser
DAO_CHECK( pUsers->get_Item( varIndex, &pUser ) );
// Retrieve name for user nCurrentUser
DAO_CHECK( pUser->get_Name( &V_BSTR( &varName ) ) );
CString strTemp = V_BSTRT( &varName );
// If there is a match, change the password
if( strTemp == strUserName )
{
COleVariant varOldPwd( strOldPassword,
VT_BSTRT );
COleVariant varNewPwd( strNewPassword,
VT_BSTRT );
DAO_CHECK( pUser->NewPassword( V_BSTR( &varOldPwd ),
V_BSTR( &varNewPwd ) ) );
TRACE( "\t Password is changed\n" );
}
}
// Clean up: decrement the usage count
// on the OLE objects
pUser->Release( );
pUsers->Release( );
wsp.Close( );
}
Modificare la password di un file MDB
Per modificare la password di un file MDB, utilizzare la funzione seguente:
void SetDBPassword( LPCTSTR pDB, LPCTSTR pszOldPassword, LPCTSTR pszNewPassword )
{
CDaoDatabase db;
CString strConnect( _T( ";pwd=" ) );
// the database must be opened as exclusive
// to set a password
db.Open( pDB, TRUE, FALSE,
strConnect + pszOldPassword );
COleVariant NewPassword( pszNewPassword, VT_BSTRT ),
OldPassword( pszOldPassword, VT_BSTRT );
DAO_CHECK( db.m_pDAODatabase->NewPassword( V_BSTR( &OldPassword ),
V_BSTR( &NewPassword ) ) );
db.Close();
}