Salar.Bois is the most compact, extermly fast binary serializer for .Net Standard, .NET Code and .NET Framework.

• No compression is done, the high compact ratio is the result of Bois format.
• No configuration.
• No change to your classes.
• Compression is provided as a seperate package.

• Because payload size matters. Bois serializer generates the smallest payload size.
• Because speed matters. Both serialization and deserialization are extremely fast.
• Easy to use, Serialize<T> and Deserialize<T> are all you need.
• No configuration required. No separate schema required.

PM> Install-Package Salar.Bois

LZ4 Compression wrapper package

PM> Install-Package Salar.Bois.LZ4

Minimum frameworks supported are .Net Core 2.0, .Net Standard 2.1 and .Net Framework 4.5

It is easy to use , just add the package to your project and voila, you can now use it.

All you need to do is to call Serialize method.

BoisSerializer.Initialize<Person>();
var boisSerializer = new BoisSerializer();

using (var mem = new MemoryStream())
{
	boisSerializer.Serialize(personInstance, mem);

	return mem.ToArray();
}

Note: Calling BoisSerializer.Initialize is not required at all, but if the performance of application is important to you, it is better to do it at the begining of your application.

Here is the complete example:

public class Project
{
	public int ID { get; set; }
	public string Name { get; set; }
	public string Description { get; set; }
	public string ProjectUrl { get; set; }
	public Version Version { get; set; }
}

class Program
{
	static void Main()
	{
		// Initialize is optional, but recommended for better performance
		BoisSerializer.Initialize<Project>();

		var projectInstance = new Project()
		{
			ID = 1,
			Name = "Salar.Bois",
			ProjectUrl = "https://github.com/salarcode/Bois",
			Version = new Version(3, 0, 0, 0),
			Description = "Salar.Bois is a compact, fast and powerful binary serializer for .NET Framework."
		};

		var boisSerializer = new BoisSerializer();

		using (var file = new FileStream("output.data", FileMode.Create))
		{
			boisSerializer.Serialize(projectInstance, file);
		}

		// All done.

		// ...
		// if you want to have more compression using LZ4 wrapper

		var boisLz4Serializer = new BoisLz4Serializer();

		using (var file = new FileStream("output-compressed.data", FileMode.Create))
		{
			boisLz4Serializer.Pickle(projectInstance, file);
		}

	}
}

var boisSerializer = new BoisSerializer();
return boisSerializer.Deserialize<Project>(dataStream);

// and the compressed data
var boisLz4Serializer = new BoisLz4Serializer();
return boisLz4Serializer.Unpickle<Project>(dataStream);

Nothing special is really required. Just these small easy rules.

• Having parameter-less public constructor.
• Collections/Lists should be generic and implement one of ICollection<>, IList<> or IDictionary<>

The BoisLz4Serializer class is in a separate package called Salar.Bois.LZ4. It is provided for anyone looking for more compact serialization. To use it just create a new instance of BoisLz4Serializer and to serialize and compress the objects call Pickle and to deserialize and uncompress call Unpickle. Please note that BoisLz4Serializer -for now- is implemented as a wrapper around LZ4.

If you are interested to know how Salar.Bois has gain this amazing compact format check out its Bois format wiki page.

Bois Format Schema.

The benchmarks sourcecode is available. Every elapsed time is calculated for 5000 iteration (v3.0).

Please note that in these tests no configuration required for Bois versus attributes required for Avro, Zero, MsPack and ProtoZBuff. Also Zero required the properties to be virtual.

-Serialization against: ArrayTypes with small data

-Serialization against: ArrayTypes with big data

-Serialization against: PrimitiveTypes with small data

-Serialization against: ComplexCollections with small data

-Serialization against: ComplexCollections with big data

-Serialization against: ComplexContainer Collections

-Serialization against: SpecializedCollections