Información general sobre el cálculo de referencias

Artículo
10/07/2008

Actualización: noviembre 2007

.NET Compact Framework versión 2.0 proporciona compatibilidad ampliada con el cálculo de referencias a través de IDispatch y a través de la invocación de la plataforma y llamadas de vtable. Esta compatibilidad incluye lo siguiente:

Utilización del atributo MarshalAsAttribute.
Cálculo de referencias de tipos Variant admitidos en Windows Embedded CE.
Cálculo de referencias de tipos que llaman a interfaces COM a través de vtable.
Cálculo de referencias de estructuras con matrices y cadenas incrustadas.
Especificación del diseño de una estructura.

Puede calcular las referencias de los tipos siguientes por valor o por referencia:

BStr
IUnknown
IDispatch
SafeArray
DateTime (referencias calculadas como un OLE DATE)
Variant

Tenga en cuenta que .NET Compact Framework 2.0 admite los métodos AllocHGlobal y FreeHGlobal.

Registro de interoperabilidad

Puede crear archivos de registro de las firmas de función para ver cómo se calculan las referencias de una llamada de interoperabilidad. Para obtener información acerca de cómo se crean los archivos, vea Cómo: Crear archivos de registro. Para obtener información acerca de cómo se interpretan los archivos de registro, vea Información del archivo de registro.

Calcular las referencias de las diferencias con el entorno completo de .NET Framework

.NET Compact Framework no admite las siguientes características para el cálculo de referencias y la interoperabilidad que se proporcionan en el entorno completo de .NET Framework:

Cálculo de referencias personalizado.
Obtención de un delegado administrado a partir de un puntero a función nativo utilizando el método GetDelegateForFunctionPointer. Puede, sin embargo, crear un puntero a función nativo a partir de un delegado administrado.
Acceso a las clases .NET Compact Framework de los componentes nativos.
Pasar estructuras (VT_RECORD) a través de IDispatch.
Pasar tipos Int64 y UInt64 a través de IDispatch.

.NET Compact Framework se diferencia del entorno completo de .NET Framework en los comportamientos de cálculo de referencias siguientes:

.NET Compact Framework permite calcular referencias de las matrices de los valores SCODE, a diferencia del entorno completo de .NET Framework.
.NET Compact Framework calcula las referencias de las matrices de los punteros IUnknown e IDispatch de forma distinta que el entorno completo de .NET Framework.
.NET Compact Framework inicializa todos los subprocesos como apartamentos multiproceso y no admite otros modelos de subprocesos ni el establecimiento de un modelo de apartamento. Por consiguiente, .NET Compact Framework no admite la propiedad ApartmentState ni los métodos siguientes:

Calcular referencias con la instrucción Declare de Visual Basic

La instrucción Declare de Visual Basic es una alternativa al uso de declare para declarar referencias a procedimientos externos de un archivo DLL. Tenga en cuenta que no se admite la palabra clave Ansi en la instrucción Declare.

El cálculo de referencias con la instrucción Declare es idéntico al cálculo de referencias con la clase DllImportAttribute, excepto en los objetos ByVal String. En una instrucción Declare, las referencias de un parámetro ByVal String se calculan como un parámetro de salida. Dado que las cadenas son invariables, se exige que Common Language Runtime copie la cadena y devuelva una nueva referencia.

Diferencias entre el cálculo de diferencias de IDispatch y la invocación de la plataforma

La tabla siguiente muestra los tipos cuyas referencias se han calculado de manera diferente por los dos contadores de referencias.

Tipo	IDispatch	Invocación de la plataforma y vtable
String	BStr	wchar *
Object	Variant	NULL
Boolean	VARIANT_BOOL	byte
Array	SafeArray	Matrices al estilo de C

.NET Compact Framework calcula las referencias de una clase mediante la invocación de la plataforma sin StructLayoutAttribute como una estructura de diseño automático; el entorno completo de .NET Framework calcula las referencias como CCW (contenedor COM invocable).

Tenga en cuenta que .NET Compact Framework marca un objeto SafeArray con FADF_FIXEDSIZE y produce una excepción si cambia el tamaño en código nativo.

En situaciones donde Boolean se traduce en un tipo de byte nativo, no se pueden calcular referencias de Boolean como un tipo de valor devuelto; sólo se pueden calcular referencias de este tipo como un argumento.

Calcular referencias de los delegados

De forma predeterminada, las referencias de los delegados se calculan como punteros a función. También puede utilizar explícitamente el valor FunctionPtr de la enumeración UnmanagedType para crear una instancia de MarshalAsAttribute. Vea Calcular referencias de delegados como punteros de función para obtener ejemplos.

Especificar un juego de caracteres

Puede utilizar el campo CharSet de DllImportAttribute para especificar un juego de caracteres al calcular las referencias de las cadenas a través de la invocación de la plataforma.

.NET Compact Framework admite los dos valores siguientes:

Auto. Las referencias de las cadenas se calculan utilizando el juego de caracteres apropiado del sistema operativo, que es el juego de caracteres Unicode. Éste es el valor predeterminado.
Unicode. Las referencias de las cadenas se calculan mediante el juego de caracteres Unicode.

No se admite el valor de Ansi porque Windows Embedded CE sólo es Unicode. None es equivalente a Ansi y no se admite.

Dado que .NET Compact Framework no admite el campo ExactSpelling, Common Language Runtime busca automáticamente un punto de entrada conforme a los valores especificados por CharSet.

Fijación de objetos

Cuando el Common Language Runtime de .NET Compact Framework calcula referencias de un objeto, éste se ancla mientras dura la llamada a la invocación de la plataforma para asegurar que el recolector de elementos no utilizados no pueda liberar ni mover el objeto.

Uso de la memoria

Siga estas instrucciones para administrar la memoria con código no administrado en .NET Compact Framework:

Asigne la memoria siempre en el código administrado y pásela al código no administrado.
Si el código no administrado mantiene un puntero a un componente administrado, deberá fijar manualmente el objeto mediante la estructura GCHandle.

El Common Language Runtime de .NET Compact Framework inicializa conjuntamente los subprocesos durante el inicio y los desinicializa conjuntamente al cerrar. Los subprocesos reciben la marca " subprocesamiento libre".

Vea también

Share via