How to Use Compact Serialization

Why Compact Serialization?

It's a process of producing a compact form of serialized object for performance improvement which results in faster network trips. As name illustrates, compact serialized file is compact in form of data and process. The idea behind compact serialization is that every 'known type' (a known type is a type that is registered with the framework) is assigned a unique 2-bytes type handle by the framework, which lets the deserializer uniquely identify the 'known types'.

For example, suppose the framework assign a handle 0 to System.Int32. Then the serializer writes the 2-byte handle followed by 4 bytes of object value to the stream. Deserializer reads the handle, figures out the object type, and then creates and populates the object with its value. On other hand the native serialization writes the complete type information with object data. NCache sophisticatedly over comes these issues of native sterilization in the following ways:

  • Here serialized object does not contain complete type information and assemblies. It only contains an object value and a unique 2-byte handle. This unique 2-byte handle is used as a reference to uniquely identify the type details while deserializing an object. In this way the size of the object reduces
  • Compact serialization also avoids the reflection which also reduces the overhead
  • The above two features reduces the IO operations
  • As the object size decreases, it automatically faster the network trips and eventually the cost decrease
  • Small object size and fast network traffic increases the application performance

For using Compact Serialization, you need to define a default public constructor (parameter less) in a compact serializable type and register that type with NCache Manager. NCache now supports Custom Generic Types. All generic types with any number of arguments can be serialized through compact serialization. If a client doesn't want to add generic types and its parameters though UI, then he has the option to add them through IGenericTypes class.

How to Use Compact Serialization?

To use Compact Serializable types with NCache Configure Cache with NCache Manager and then register your compact serializable types with NCache.

Step 1: Registering Compact Serializable Types:

You can register types one by one through 'Add Types' button. Perform the following steps to register your types with configured cache:

  • Stop the cache if it is running.
  • Click on the 'Compact Serialization' tab which will open up the following screen.
Registering Compact Serializable Types
  • Click 'Add Types' button. A 'Select Compact Classes' dialog will appear.
  • Browse for the assembly file that contains the compact types by clicking the 'Browse' button as shown in the figure.
  • Select the classes you want to register with the cache from the loaded classes list.
  • Press 'Add Class' button to add the classes in the selected classes list.
  • Click 'Ok' button.
Compact Classes in Serialization
  • Newly added types will start appearing in the list box under the 'Compact Serialization' tab having Compact Type and Platform information.
  • 'Remove' button will delete the selected type from the registered types list.
How to Use Compact Serialization
  • This shows all the added types. Now arguments can be added with generic types by selecting specific type and then clicking on 'Add <T>' button.

Step 2: Registering Generic Compact Types Through Generic Type Handler

This is the other way for registering generic compact types through "Generic Type Handler". With Generic Type Handler user can add all the Generic types at once by implementing our interface. This saves time and effort. Here is a sample code for this.

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[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;

For registering types follow these steps.

  • Click 'Generic Type Handler' button. A 'Select Compact Classes' dialog box will appear.
  • Browse for the assembly file that implements this interface and contains compact types by clicking the 'Browse' button as shown in the figure.
Registering Generic Compact Types
  • Click 'OK' button. All the added types will be listed as shown below.
 Compact Serialization Framework

What to Do Next?

© Copyright Alachisoft 2002 - . All rights reserved. NCache is a registered trademark of Diyatech Corp.