Cuando se utilizan las clases de base de datos DAO de MFC, puede haber situaciones donde es necesario utilizar DAO directamente. Normalmente esto no será el caso, pero MFC ha proporcionado algunos mecanismos auxiliares para facilitar haciendo las llamadas directas DAO simples al combinar el uso de las clases MFC con llamadas directas de DAO. Hacer DAO directa llamadas a los métodos de un objeto DAO MFC administrado deben exigir sólo unas pocas líneas de código. Si necesita crear y utilizar objetos DAO no gestionados por MFC, tendrá que trabajar un poco más llamando realmente versión del objeto. Esta nota técnica explica cuando desee llamar directamente a DAO, lo pueden hacer los ayudantes MFC para ayudarle y cómo utilizar las interfaces OLE de DAO. Por último, esta nota proporciona algunas funciones de ejemplo que muestra cómo llamar a DAO directamente para las características de seguridad DAO.
Las situaciones más comunes para realizar directamente llamadas DAO se producen cuando colecciones necesitan actualizarse o cuando están implementando funciones no envueltos por MFC. La característica más importante no expuesta por MFC es seguridad. Si desea implementar características de seguridad, necesita utilizar directamente los objetos DAO usuarios y grupos. Además de seguridad, hay sólo unas pocas otras características DAO no compatibles con MFC. Estos incluyen funcionalidades de replicación de clonación y base de datos de registros, así como algunas adiciones finales para DAO.
Envoltura de MFC de hace DAO mediante DAO más fácil manejar muchos de los detalles por lo que no tiene que preocuparse por las pequeñas cosas. Esto incluye la inicialización de OLE, la creación y administración de los objetos DAO (especialmente los objetos de colección), error de comprobación y proporcionando una interfaz más simple, inflexible (ninguna variante o BSTR argumentos). Puede realizar llamadas directas de DAO y beneficiarse de estas características. Todo el código debe hacer es llamar liberación para los objetos creados por llamadas directas de DAO y no modificar cualquiera de los punteros de interfaz que MFC puede depender internamente. Por ejemplo, no modifique al miembro m_pDAORecordset de un objeto CDaoRecordset abierto a menos que entienda todas las ramificaciones internas. Sin embargo, podría utilizar la interfaz m_pDAORecordset para llamar DAO directamente para obtener la colección de campos. En este caso no se modificaría el miembro m_pDAORecordset . Simplemente tienes que llamar liberación sobre el objeto de la colección de campos cuando termine con el objeto.
Los ayudantes a hacer llamar DAO más fácil son los mismos ayudantes que se utilizan internamente en las clases de base de datos DAO de MFC. Estos ayudantes se utilizan para comprobar los códigos de retorno al realizar una llamada directa de DAO, registro de salida de depuración, comprobación de errores esperados y lanzando excepciones adecuadas si es necesario. Hay dos funciones auxiliares subyacente y cuatro macros que se asignan a uno de estos dos ayudantes. La mejor explicación sería simplemente leer el código. Véase DAO_CHECK, DAO_CHECK_ERROR, DAO_CHECK_MEMy DAO_TRACE en AFXDAO.H para ver las macros y ver AfxDaoCheck y AfxDaoTrace en DAOCORE.CPP.
Las interfaces OLE para cada objeto en la jerarquía de objetos DAO se definen en el archivo de encabezado DBDAOINT.H, que se encuentra en el directorio \Program Files\DevStudio\VC\include. Estas interfaces proporcionan métodos que permiten manipular toda la jerarquía DAO.
Para muchos de los métodos de las interfaces DAO, necesita manipular un objeto BSTR (un prefijo de longitud cadena utilizada en la automatización OLE). El objeto BSTR normalmente se encapsula dentro del tipo de datos VARIANT . La clase MFC COleVariant propio hereda el tipo de datos VARIANT . Dependiendo de si se genera el proyecto para ANSI o Unicode, las interfaces DAO devolverá s BSTRANSI o Unicode. Dos macros, V_BSTR y V_BSTRT, son útiles para asegurar que la interfaz DAO obtiene el BSTR del tipo esperado.
V_BSTR extrae al miembro bstrVal de un COleVariant. Esta macro se utiliza normalmente cuando se necesita pasar el contenido de un COleVariant a un método de interfaz DAO. El siguiente fragmento de código muestra las declaraciones y el uso real de dos métodos de la interfaz de DAOUser de DAO que se aprovechan de la macro V_BSTR:
COleVariant varOldName;
COleVariant varNewName (_T("NewUser"), VT_BSTRT);
/ / Código para asignar pUser a un valor válido omitido
DAOUser * pUser = NULL;
/ / Estas declaraciones de método fueron tomadas de DBDAOINT.H
/ / STDMETHOD(get_Name) (THIS_ lejano de BSTR * pbstr) pura;
/ / STDMETHOD(put_Name) (BSTR THIS_ bstr) pura;
DAO_CHECK (pUser-gt; get_Name (V_BSTR (& varOldName)));
DAO_CHECK (pUser - > put_Name (V_BSTR (& varNewName)))
Tenga en cuenta que el argumento VT_BSTRT especificado en el constructor de COleVariant anterior asegura que allí será un BSTR de ANSI en el COleVariant si crea una versión ANSI de la aplicación y un BSTR Uunicode para la versión Unicode de su aplicación. Esto es lo que espera el DAO.
La macro, V_BSTRT, extraerá a un ANSI o Unicode bstrVal miembro de COleVariant dependiendo del tipo de compilación (ANSI o Unicode). El código siguiente muestra cómo extraer el valor BSTR un COleVariant en un CString:
COleV&ariant varName (_T ("minombre"), VT_BSTRT);
CString str = V_BSTRT (amp; varName)
La macro V_BSTRT , junto con otros trucos para abrir otro tipos almacenados dentro de COleVariant, se demuestra en el ejemplo DAOVIEW incluido en el CD del Visual C++. Específicamente, esta traducción se realiza en el método CCrack::strVARIANT . Este método, siempre que sea posible, traduce el valor de un COleVariant una instancia de CString.
Pueden surgir situaciones cuando sea necesario actualizar los objetos de colección DAO subyacentes. Normalmente esto no debería ser necesario, pero es un procedimiento sencillo si es necesario. Un ejemplo de cuando una colección que deba actualizarse es cuando operan en un entorno multiusuario con varios usuarios crear nuevas definiciones de tabla. En este caso su colección tabledefs podría convertirse en obsoleto. Para actualizar la colección, simplemente debe llamar al método Refresh de objeto de la colección particular y comprobar si hay errores:
DAO_CHECK (pMyDaoDatabase-gt;
m_pDAOTableDefs - > Refresh ())
Tenga en cuenta que actualmente todas las interfaces de objeto de colección de DAO son detalles de implementación indocumentados de las clases de base de datos DAO de MFC.
Las clases de base de datos DAO MFC no incluir características de seguridad DAO. Debe llamar a métodos de las interfaces DAO para utilizar algunas características de seguridad DAO. La siguiente función establece la base de datos del sistema y, a continuación, cambia la contraseña del usuario. Esta función llama a tres otras funciones, que posteriormente se definen.
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 );
.
.
.
}
Los cuatro ejemplos demuestran cómo:
Configuración de la base de datos del sistema
A continuación es una función de ejemplo para establecer la base de datos de sistema que será utilizado por una aplicación. Esta función se debe llamar antes de ninguna otra llamada DAO.
/ / Establecer la base de datos del sistema que la / / utilizará el motor de base de datos DAO
void SetSystemDB (CString amp; strSystemMDB)
{
COleVariant varSystemDB (strSystemMDB, VT_BSTRT);
/ / Inicializar DAO de MFC
(De AfxDaoInit);
DAODBEngine * pDBEngine = AfxDaoGetEngine (de);
ASSERT (pDBEngine! = NULL);
/ / Call put_SystemDB método para establecer la / / sistema de base de datos de motor DAO
DAO_CHECK (pDBEngine - > put_SystemDB (varSystemDB.bstrVal));
}
Establecer el valor predeterminado usuario y contraseña
Para establecer el valor predeterminado usuario y contraseña para una base de datos del sistema, utilice la siguiente función:
void SetDefaultUser (CString amp; strUserName, CString & strPassword)
{
COleVariant varUserName (strUserName, VT_BSTRT);
COleVariant varPassword (strPassword, VT_BSTRT);
DAODBEngine * pDBEngine = AfxDaoGetEngine (de);
ASSERT (pDBEngine! = NULL);
/ / Establecer el usuario predeterminado:
DAO_CHECK (pDBEngine - > put_DefaultUser (varUserName.bstrVal));
/ / Establecer contraseña predeterminada:
DAO_CHECK (pDBEngine - > put_DefaultPassword (varPassword.bstrVal));
}
Cambiar la contraseña del usuario
Para cambiar la contraseña del usuario, utilice la siguiente función:
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( );
}
Cambiar la contraseña de un.Archivo MDB
Para cambiar la contraseña de un.MDB archivos, utilizar la siguiente función:
void SetDBPassword (LPCTSTR pDB, LPCTSTR pszOldPassword, LPCTSTR pszNewPassword)
{
nbsp; CDaoDatabase db;
CString strConnect (_T ("; pwd ="));
/ / la base de datos debe abrirse como exclusivo
/ / establecer una contraseña
DB.Abrir (pDB, TRUE, FALSE, strConnect + pszOldPassword);
COleVariant NewPassword (pszNewPassword, VT_BSTRT),
OldPassword (pszOldPassword, VT_BSTRT);
DAO_CHECK (db.m_pDAODatabase - > NewPassword (V_BSTR (& contraseñaAntigua),
V_BSTR (& NewPassword)));
DB.Close();
}
&Notas técnicas por número |nbsp; Notas técnicas por categoría