Optimización de la persistencia y la inicialización

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

Este enfoque tiene la ventaja de que se puede usar una sola DoPropExchange implementación para la inicialización, para la persistencia en formato binario y para la persistencia en el formato denominado "conjunto de propiedades" utilizado 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 eficiencia. 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 de 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 notrivial (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, puede proporcionar una implementación más directa para la persistencia binaria. Por ejemplo, considere esta DoPropExchange función:

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 Serialize de la siguiente manera:

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 dwVersion variable local se puede usar para detectar la versión del estado persistente del control que se carga o se guarda. Puede 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), puede 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...
}

Tenga 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 daría lugar a que solo se modifique un byte de m_boolProp , dejando los bytes restantes sin inicializar.

Para el mismo control, puede 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 usa el contenedor.

Consulte también

Controles ActiveX de MFC: Optimización