Cómo utilizar la serialización compacta
¿Por qué serialización compacta?
Es un proceso de producción de una forma compacta de objeto serializado para mejorar el rendimiento, lo que resulta en viajes de red más rápidos. Como lo ilustra el nombre, el archivo serializado compacto es compacto en forma de datos y procesos. La idea detrás de la serialización compacta es que a cada 'tipo conocido' (un tipo conocido es un tipo que está registrado con el marco) se le asigna un identificador de tipo único de 2 bytes por parte del marco, lo que permite que el deserializador identifique de manera única los 'tipos conocidos' .
Por ejemplo, suponga que el marco asigna un identificador 0 a System.Int32. Luego, el serializador escribe el identificador de 2 bytes seguido de 4 bytes de valor de objeto en la secuencia. El deserializador lee el identificador, determina el tipo de objeto y luego crea y completa el objeto con su valor. Por otro lado, la serialización nativa escribe la información de tipo completa con los datos del objeto. NCache supera de manera sofisticada estos problemas de esterilización nativa de las siguientes maneras:
- Aquí el objeto serializado no contiene información de tipo completo ni ensamblajes. Solo contiene un valor de objeto y un identificador único de 2 bytes. Este identificador único de 2 bytes se usa como referencia para identificar de forma única los detalles del tipo mientras se deserializa un objeto. De esta manera el tamaño del objeto se reduce
- La serialización compacta también evita la reflexión, lo que también reduce la sobrecarga
- Las dos características anteriores reducen las operaciones de E/S
- A medida que el tamaño del objeto disminuye, la red se activa automáticamente más rápido y, finalmente, el costo disminuye
- El tamaño de objeto pequeño y el tráfico de red rápido aumentan el rendimiento de la aplicación
Para usar la serialización compacta, debe definir un constructor público predeterminado (sin parámetros) en un tipo serializable compacto y registrar ese tipo con NCache Gerente. NCache ahora admite tipos genéricos personalizados. Todos los tipos genéricos con cualquier cantidad de argumentos se pueden serializar a través de la serialización compacta. Si un cliente no desea agregar tipos genéricos y sus parámetros a través de la interfaz de usuario, tiene la opción de agregarlos a través de la clase IGenericTypes.
¿Cómo utilizar la serialización compacta?
Para usar tipos compactos serializables con NCache Configurar caché con NCache Manager y luego registre sus tipos serializables compactos con NCache.
Paso 1: Registro de tipos serializables compactos:
Puede registrar los tipos uno por uno a través de 'Agregar tipos' botón. Realice los siguientes pasos para registrar sus tipos con caché configurado:
- Detenga el caché si se está ejecutando.
- Haga clic en el 'Serialización compacta' pestaña que abrirá la siguiente pantalla.
- Haga Clic en 'Agregar tipos' botón. UN 'Seleccionar Clases Compactas' aparecerá el cuadro de diálogo
- Busque el archivo de ensamblaje que contiene los tipos compactos haciendo clic en el 'Navegar' botón como se muestra en la figura.
- Seleccione las clases que desea registrar con el caché de la lista de clases cargadas.
- Prensa 'Agregar clase' para agregar las clases en la lista de clases seleccionadas.
- Haga Clic en 'OK' del botón.
- Los tipos recién agregados comenzarán a aparecer en el cuadro de lista debajo del 'Serialización compacta' Pestaña que contiene información sobre el tipo de compacto y la plataforma.
- 'Eliminar' El botón eliminará el tipo seleccionado de la lista de tipos registrados.
- Esto muestra todos los tipos agregados. Ahora se pueden agregar argumentos con tipos genéricos seleccionando un tipo específico y luego haciendo clic en 'Agregar ' del botón.
Paso 2: Registro de tipos compactos genéricos a través del controlador de tipos genéricos
Esta es la otra forma de registrar tipos compactos genéricos a través del "Manejador de tipos genéricos". Con el controlador de tipos genéricos, el usuario puede agregar todos los tipos genéricos a la vez mediante la implementación de nuestra interfaz. Esto ahorra tiempo y esfuerzo. Aquí hay un código de muestra para esto.
public class CustomGenericType <T,K,V> { }
public class SetGenerics: IGenericTypeProvider
{
Type[] types = new Type[6];
#region IGenericTypeProvider Members
Type[] IGenericTypeProvider.GetGenericTypes()
{
types[0]=typeof(Dictionary<string, Customer>);
types[1]=typeof(List<int>);
types[2]=typeof(CustomGenericType<Employee, Product, Customer>);
types[3]=typeof(CustomGenericType<Employee, Product, int>);
types[4]=typeof(CustomGenericType<Employee, string, byte>);
types[5]=typeof(CustomGenericType<string, Customer, bool>);
return types;
}
#endregion
}Para registrar tipos siga estos pasos.
- Haga Clic en 'Manejador de tipo genérico' botón. UN 'Seleccionar Clases Compactas' cuadro de diálogo aparecerá.
- Busque el archivo de ensamblaje que implementa esta interfaz y contiene tipos compactos haciendo clic en el 'Navegar' botón como se muestra en la figura.
- Haga Clic en 'OK' botón. Todos los tipos agregados se enumerarán como se muestra a continuación.
