TN054: Chamar o DAO diretamente ao Using Classes MFC DAO
.gif "Observação") Observação: |
|---|
sistema autônomo do Visual C++. NET, o ambiente do Visual C++ e sistema autônomo assistentes não suportam mais DAO (Embora sistema autônomo classes DAO estão incluídas e você ainda poderá usá-las).A Microsoft recomenda que você use Modelos de BD OLE DB or ODBC e do MFC para novos projetos.Você só deve usar o DAO em manutenção de aplicativos existentes. |
Ao usar as classes de banco de dados MFC DAO, pode haver situações em que é necessário usar o DAO diretamente.Geralmente, isso não será o caso, mas o MFC tenha fornecido alguns mecanismos de auxiliares para facilitar a fazer chamadas DAO diretas simples ao combinar o uso de classes MFC com chamadas diretas do DAO.Tornando direto DAO chamadas aos métodos de um objeto gerenciado MFC DAO devem exigir apenas algumas linhas de código.Se você precisar criar e usar objetos DAO não gerenciado pelo MFC, você terá que fazer um pouco mais de trabalho, na verdade, chamada Versão no objeto.Esta nota técnica explica quando convém telefonar DAO diretamente, que auxiliares MFC podem fazer para ajudá-lo e como usar as interfaces do DAO OLE.Por fim, esta nota fornece algumas funções de exemplo mostra como chamar o DAO diretamente para recursos de segurança do DAO.
Ao fazer chamadas diretas DAO
As situações mais comuns para tornar a direcionar chamadas DAO ocorrem quando coleções precisam ser atualizados ou quando você estiver implementando recursos não delimitados por MFC.O recurso mais significativo não exposto pelo MFC é segurança.Se você quiser implementar recursos de segurança, você precisará usar os objetos DAO usuários e agrupar (s) diretamente.Além de segurança, há somente alguns outros DAO recursos não suportados pelo MFC.Esses incluem recursos de replicação de clonagem e o banco de dados do conjunto de registros, bem sistema autônomo algumas adições atrasadas ao DAO.
Uma breve visão geral de implementação do MFC e
Quebra automática do MFC do DAO torna usando DAO mais fácil, manipulando muitos detalhes para que não precisem se preocupar com as pequenas coisas que.Isso inclui a inicialização do OLE, a criação e o gerenciamento dos objetos DAO (especialmente os objetos de coleção), erro de verificação e fornecendo uma interface simples com rigidez de tipos (nenhum VARIANTE or BSTR argumentos). Pode fazer chamadas diretas do DAO e ainda usufruir esses recursos.Tudo o que seu código deve fazer é telefonar Versão para todos os objetos criados pelo DAO telefonar s direto e não modificar qualquer um dos ponteiros de interface MFC pode depender internamente.Por exemplo, não modifique o m_pDAORecordset membro de um em aberto CDaoRecordset a menos que entenda de objeto todos os ramificações internas.No entanto, você pode usar o m_pDAORecordset interface telefonar DAO diretamente para obter a coleção Fields.Nesse caso, a m_pDAORecordset membro não deve ser modificado.Você precisará simplesmente chamar Versão no objeto de coleção Fields quando tiver terminado com o objeto.
Descrição dos auxiliares para tornar o DAO chama mais fácil
Auxiliares fornecidos para fazer chamada DAO mais fácil são os mesmos auxiliares que serão usados internamente em classes MFC DAO banco de dados.Esses auxiliares são usados para verificar os códigos de retorno ao fazer uma telefonar direta do DAO, registrar registrar registrar em log de saída de depurar, a verificação de erros esperados e gerar exceções apropriadas se necessário.Há duas funções auxiliares subjacente e quatro macros que são mapeados para um desses dois auxiliares.A explicação melhor seria simplesmente ler o código.See DAO_CHECK, DAO_CHECK_ERROR, DAO_CHECK_MEM, and DAO_TRACE na AFXDAO.H para ver as macros e consulte AfxDaoCheck and AfxDaoTrace DAOCORE.CPP.
Usando as interfaces do DAO OLE
Interfaces OLE para cada objeto na hierarquia de objetos DAO são definidas no arquivo de cabeçalho DBDAOINT.H, que é encontrada no diretório \programa Files\Microsoft Visual Studio .NET 2003\VC7\include.Essas interfaces fornecem métodos que permitem manipular toda a hierarquia DAO.
Para muitos dos métodos nas interfaces do DAO, você precisará manipular um BSTR objeto (uma seqüência de prefixo de comprimento de caracteres usado na automação OLE). The BSTR objeto geralmente é encapsulado dentro do VARIANTE tipo de dados.O MFC classe COleVariant si herda o VARIANTE tipo de dados.Dependendo se você compilação seu projeto para ANSI ou Unicode, as interfaces do DAO retornará ANSI ou Unicode BSTRs. Duas macros, V_BSTR and V_BSTRT, são úteis para garantir que a interface do DAO obtém o BSTR do tipo esperado.
V_BSTR will extrair the bstrVal membro umCOleVariant. Essa macro normalmente é usada quando você precisa passar o Sumário de um COleVariant para um método de uma interface do DAO. O fragmento de código a seguir mostra a declarações e o uso real para dois métodos da interface do DAO DAOUser que aproveitam o V_BSTR macro:
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 ) ));
Observe que o VT_BSTRT o argumento especificado na COleVariant construtor acima garante que há um ANSI BSTR no COleVariant Se você criar uma versão ANSI do seu aplicativo e um Unicode BSTR Para obter uma versão Unicode de seu aplicativo. Este é o que espera DAO.
A Outros macro, V_BSTRTextrai um ANSI ou Unicode ,bstrVal membro COleVariant Dependendo do tipo de compilação (ANSI ou Unicode). O código a seguir demonstra como extrair o BSTR o valor de um COleVariant em um CString:
COleVariant varName( _T( "MyName" ), VT_BSTRT );
CString str = V_BSTRT( &varName );
The V_BSTRT macro, juntamente com outros truques para violar em em aberto outros tipos armazenados dentro de COleVariant, é demonstrado no exemplo DAOVIEW incluído no CD do Visual C++. Especificamente, essa conversão é executada no CCrack::strVARIANT método.Esse método, sempre que possível, converte o valor de um COleVariant em uma instância da CString.
Exemplo simples de uma telefonar direta para o DAO
Situações podem ocorrer quando é necessário atualizar os objetos subjacentes de coleção do DAO.Normalmente, isso não deve ser necessário, mas é um procedimento simples se for necessário.Um exemplo de quando uma coleção talvez precise ser atualizado é quando estiver operando em um ambiente multiusuário com vários usuários criando novos tabledefs.Nesse caso sua coleção tabledefs pode se tornar obsoleta.Para atualizar a coleção, basta telefonar o Atualizar método do objeto de coleção e verificação de erros:
DAO_CHECK( pMyDaoDatabase->
m_pDAOTableDefs->Refresh( ) );
Observe que no momento todas as interfaces de objeto de coleção DAO são detalhes de implementação não documentado das classes de banco de dados MFC DAO.
Usando DAO diretamente para funções de segurança do DAO
As classes de banco de dados MFC DAO não encapsular recursos de segurança do DAO.Você deve telefonar métodos das interfaces do DAO para usar alguns recursos de segurança do DAO.A função a seguir define o banco de dados do sistema e altera a senha do usuário.Essa função chama três Outros funções, que são definidas posteriormente.
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 );
.
.
.
}
Os próximos quatro exemplos demonstram como:
Defina o banco de dados do sistema DAO (mdw arquivo).
conjunto o usuário padrão e a senha.
alterar senha de um usuário.
Altere a senha de um arquivo .mdb.
configuração sistema banco de dados
Abaixo está uma função de exemplo para conjunto o banco de dados do sistema que será usado por um aplicativo.Esta função deve ser chamada antes que sejam feitas chamadas de DAO.
// 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 ) );
}
Definição de usuário padrão e senha
Para conjunto o usuário de padrão e senha para um banco de dados do sistema, use a função a seguir:
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 ) );
}
Alterando a senha de usuário
Para alterar a senha do usuário, use a função a seguir:
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( );
}
Alterando a senha de um arquivo .mdb
Para alterar a senha de um arquivo .mdb, use a função a seguir:
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();
}