AltSerializer - An Alternate Binary Serializer

• Download source files - 27.6 Kb
• Download test project - 40.2 Kb

Introduction

The AltSerializer is a replacement for the binary serializer built in to .NET. I built it to be quick and easy to use, and hopefully, it works exactly like one would expect it to. I've started using it quite a bit now, and I hope that others find it useful, too.

Features

• Faster, and much smaller than the default binary formatter.
• Optionally serializes property/field names along with the data, easing versioning and development.
• Supports nullable types.
• Caches serialized objects so they are never serialized twice; circular references are serialized correctly.
• IAltSerializable interface for custom serialization implementations.
• If an object implements ISerializable, the serializer will use that interface.
• With the CompiledSerializer attribute, the serializer can dynamically compile methods to serialize/deserialize your class.
• Works with Mono.

Description

The AltSerializer will decompose any object it is given, and serialize all (including protected/private) properties/fields in the object. By default, the serializer uses only the properties of an object; but by setting a flag, it will enumerate the fields instead. I tend to stick with properties, because they are most often the editable portion of objects that I use with other components (for example, PropertyGrid). Any read-only or write-only properties are ignored, as well as any fields marked as NonSerialized. The only limitation on the object is that the object must have a parameter-less default constructor.

The AltSerializer also knows about most system types, and can effectively encode them without storing much metadata. Most of these types are also not cached (integers, shorts, booleans, bytes, etc.) because they are too small to effectively cache. Any type that the serializer does not know about is stored by their assembly qualified names - this means whoever is doing the deserialization must also know about the types encoded in the stream. The types are only stored once; then they are cached away to avoid unnecessary bloat.

I ran some benchmarks against the binary formatter, for reference. To be fair, the binary formatter is not very good at serializing small objects. There are some cases where the binary formatter outperforms AltSerializer; obviously, I'm working on fixing that. Each test measures the time it took to perform 100,000 serializations/deserializations of the type in the Test column. The size difference is the difference between the binary formatter output and the AltSerializer output. The time difference is the difference between the binary serializer time and the AltSerializer time.

Getting Started

Using the Serializer

The library comes with some static methods for serialization that you can get started with right away:

byte [] bytes = Serializer.Serialize("Hello, World!");
object myObject = Serializer.Deserialize(bytes);

These two methods work for just about anything you want to throw at the serializer, and are probably all you will need to use. To specify properties that the serializer should ignore, tag them with a DoNotSerialize attribute.

The AltSerializer creates metadata information about objects it encounters as it encounters them, so there will probably be a slight delay (whatever delay that is associated with reflecting the object) the first time you attempt to serialize or deserialize with it.

AltSerializer Settings

You can change the settings of the serializer by changing the value of the Serializer.DefaultSerializeFlags variable. (If you instantiate your own serializer, it has its own properties for settings.) The following settings are available in any combination:

• SerializePropertyNames - Encodes properties/fields that were serialized along with the data. (More on this below.)
• SerialzationCache - Enables the serialization class. There's little reason not to have this one on.
• SerializeProperties - Serializes the properties of an object instead of the fields.

When the SerializePropertyNames flag is set, the serializer records the fields or properties it serialized along with the data. When the object is deserialized, if any of the properties/fields are missing, then they are discarded. Likewise, any fields that are new are ignored. This works great for maintaining backwards compatibility without much effort. I use this all the time during development, especially when my objects are still evolving and I'm adding new properties all the time.

One other important setting is the Serializer.DefaultEncoding property, which is used when serializing strings. For example, if you don't need strings as Unicode, you could change this setting to Encoding.ASCII.

Advanced Features

Specifying Type Information

By default, the library encodes type information about an object before it serializes it, so that it knows how to deserialize the object without any prior knowledge. However, it can be useful to cut down on the size of the serialized object by specifying the type of object you're serializing. Obviously, you will have to specify the type again as you're deserializing:

byte[] bytes = Serializer.Serialize(myObject, typeof(MyObjectType));
object newObject = Serializer.Deserialize(bytes, typeof(MyObjectType));

This won't make much of a difference on system types, but it will prevent the serializer from writing out the type name (which it will) for types that it doesn't know about.

Manipulating the Cache

Objects can also be permanently added to the cache. When the serializer encounters these objects, it only writes a reference to it, and the object itself is never serialized. This assumes, of course, that the deserializer used to deserialize the objects is initialized with cache objects in the same order that the serializer was! This isn't an issue if you use the same instance of the AltSerializer class, or if you use the static methods; but it may be an issue if you have two different processes that utilize the AltSerializer. This is especially useful for letting the serializer know about all the types you may want to serialize. The full type information is never stored in the serialized stream, and the data becomes almost purely raw data.

Serializer.CacheObject(typeof(MyObjectType));
byte[] bytes = Serializer.Serialize(obj);
object myObject = Serializer.Deserialize(bytes);

IAltSerializable Interface

If your object implements IAltSerializable, you can specify a custom serialization and deserialization routine. This gives your object access to most of the Write and Read methods in the serializer, which you can use to efficiently serialize the properties you need. Make sure your object always serializes and deserializes properly, because the serializer will probably throw an exception if you don't read back all of the data that you wrote.

public class MyClass : IAltSerializable
{
    private int _value;
    public int Value
    {
        get { return _value; }
        set { _value = value; }
    }

    #region IAltSerializable Members

    public void Serialize(AltSerializer serializer)
    {
        serializer.Write(Value);
    }

    public void Deserialize(AltSerializer deserializer)
    {
        Value = deserializer.ReadInt32();
    }

    #endregion
}

Dynamically Compiled Serializers

Finally, there is a CompiledSerializer attribute you can place in front of your class. If the serializer sees this, it will dynamically emit code to serialize and deserialize your object. Using a compiled serializer/deserializer is quite a bit faster than doing it via reflection; however, there are some limitations. Only compiled properties are able to be serialized (for now). There are still a few optimizations that could be made, I just haven't afforded the time to make them - so far the speed of the serializer has not been an issue.

Testing

I built a project based on NUnit to unit test as many cases that I could think of. It's not the neatest code by any means, but I think it gets the job done. Of course, if you find any cases that break the serializer, please let me know!