Optimizar la persistencia y la inicialización

De forma predeterminada, la función miembro DoPropExchange controla la persistencia y la inicialización en un control. En un control típico, esta función contiene llamadas a varias funciones de PX_ (PX_Color, PX_Font, etc.), una para cada propiedad.

Este enfoque tiene la ventaja de que se puede usar una única implementación DoPropExchange para la inicialización, para la persistencia en formato binario y para la persistencia en el formato denominado «contenedor de propiedades» usado por algunos contenedores. Esta función proporciona toda la información sobre las propiedades y sus valores predeterminados en un lugar conveniente.

Sin embargo, esta generalidad se produce a costa de la eficacia. Las funciones de PX_ obtienen su flexibilidad a través de implementaciones multicapa que son intrínsecamente menos eficientes que los enfoques más directos, pero menos flexibles. Además, si un control pasa un valor predeterminado a una función PX_, ese valor predeterminado debe proporcionarse cada vez, incluso en situaciones en las que el valor predeterminado no se pueda usar necesariamente. Si la generación del valor predeterminado es una tarea no trivial (por ejemplo, cuando el valor se obtiene de una propiedad ambiente), se realiza un trabajo innecesario adicional en los casos en los que no se usa el valor predeterminado.

Puedes mejorar el rendimiento de persistencia binaria del control reemplazando la función del Serialize de tu control. La implementación predeterminada de esta función miembro realiza una llamada a tu DoPropExchange función. Al invalidarla, puedes proporcionar una implementación más directa para la persistencia binaria. Por ejemplo, considera esta función DoPropExchange:

void CMyAxOptCtrl::DoPropExchange(CPropExchange* pPX)
{
   ExchangeVersion(pPX, MAKELONG(_wVerMinor, _wVerMajor));
   COleControl::DoPropExchange(pPX);

   PX_Bool(pPX, _T("BoolProp"), m_BoolProp, TRUE);
   PX_Short(pPX, _T("ShortProp"), m_ShortProp, 0);
   PX_Color(pPX, _T("ColorProp"), m_ColorProp, RGB(0xFF, 0x00, 0x00));
   PX_String(pPX, _T("StringProp"), m_StringProp, _T(""));
}

Para mejorar el rendimiento de la persistencia binaria de este control, puede invalidar la función de la siguiente manera Serialize:

void CMyAxOptCtrl::Serialize(CArchive& ar)
{
   SerializeVersion(ar, MAKELONG(_wVerMinor, _wVerMajor));
   SerializeExtent(ar);
   SerializeStockProps(ar);

   if (ar.IsLoading())
   {
      ar >> m_BoolProp;
      ar >> m_ShortProp;
      ar >> m_ColorProp;
      ar >> m_StringProp;
   }
   else
   {
      ar << m_BoolProp;
      ar << m_ShortProp;
      ar << m_ColorProp;
      ar << m_StringProp;
   }
}

La variable local dwVersion se puede usar para detectar la versión del estado persistente del control que se carga o se guarda. Puedes usar esta variable en lugar de llamar a CPropExchange::GetVersion.

Para ahorrar un poco de espacio en el formato persistente para una propiedad BOOL (y para mantenerla compatible con el formato generado por PX_Bool), puedes almacenar la propiedad como byTE, como se indica a continuación:

if (ar.IsLoading())
{
   BYTE bTmp;
   ar >> bTmp;
   m_BoolProp = (BOOL)bTmp;
   // other properties...
}
else
{
   ar << (BYTE)m_BoolProp;
   // other properties...
}

Ten en cuenta que, en el caso de carga, se usa una variable temporal y, a continuación, se asigna su valor, en lugar de convertir m_boolProp en una referencia BYTE. La técnica de conversión provocaría que solo se modifique un byte de m_boolProp, dejando los bytes restantes sin inicializar.

Para el mismo control, puedes optimizar la inicialización del control reemplazando COleControl::OnResetState de la siguiente manera:

void CMyAxOptCtrl::OnResetState()
{
   ResetVersion(MAKELONG(_wVerMinor, _wVerMajor));
   ResetStockProps();

   m_BoolProp = TRUE;
   m_ShortProp = 0;
   m_ColorProp = RGB(0xFF, 0x00, 0x00);
   m_StringProp.Empty();
}

Aunque Serialize y OnResetState se han invalidado, la función DoPropExchange debe mantenerse intacta porque todavía se usa para la persistencia en el formato de contenedor de propiedades. Es importante mantener las tres funciones para asegurarse de que el control administra sus propiedades de forma coherente, independientemente del mecanismo de persistencia que use el contenedor.

Consulte también

Controles ActiveX MFC: Optimización