private static void TestMissingFieldCore(SerializationMethod method, EmitterFlavor flavor)
{
var context = new SerializationContext()
{
SerializationMethod = method, EmitterFlavor = flavor
};
var serializer = MessagePackSerializer.Create <VersioningTestTarget>(context);
using (var stream = new MemoryStream())
{
if (method == SerializationMethod.Array)
{
stream.Write(new byte[] { 0x91, 0x1 });
}
else
{
var packer = Packer.Create(stream, false);
packer.PackMapHeader(1);
packer.Pack("Field1");
packer.Pack(1);
}
stream.Position = 0;
var result = serializer.Unpack(stream);
Assert.That(result.Field1, Is.EqualTo(1));
Assert.That(result.Field2, Is.EqualTo(0));
Assert.That(result.Field3, Is.Null);
}
}
private static void TestFieldSwappedCore(EmitterFlavor flavor)
{
var context = new SerializationContext()
{
SerializationMethod = SerializationMethod.Map, EmitterFlavor = flavor
};
var serializer = MessagePackSerializer.Create <VersioningTestTarget>(context);
using (var stream = new MemoryStream())
{
var packer = Packer.Create(stream, false);
packer.PackMapHeader(4);
packer.Pack("Field1");
packer.Pack(1);
packer.Pack("Field2");
packer.Pack(-1);
packer.Pack("Extra");
packer.Pack(2); // Issue6
stream.Position = 0;
var result = serializer.Unpack(stream);
Assert.That(result.Field1, Is.EqualTo(1));
Assert.That(result.Field2, Is.EqualTo(-1));
Assert.That(result.Field3, Is.Null);
}
}
public static SerializerEmitter CreateTupleSerializerCore(Type tupleType, EmitterFlavor emitterFlavor)
{
Contract.Requires(tupleType != null);
Contract.Ensures(Contract.Result <SerializerEmitter>() != null);
var emitter = SerializationMethodGeneratorManager.Get().CreateEmitter(tupleType, emitterFlavor);
var itemTypes = TupleItems.GetTupleItemTypes(tupleType);
CreateTuplePack(
emitter,
tupleType,
itemTypes,
(il, collection) =>
{
il.EmitAnyLdarg(2);
il.EmitAnyStloc(collection);
}
);
CreateTupleUnpack(
emitter,
itemTypes
);
return(emitter);
}
/// <summary>
/// Creates new <see cref="EnumSerializerEmitter"/> which corresponds to the specified <see cref="EmitterFlavor"/>.
/// </summary>
/// <param name="targetType">The type of the serialization target.</param>
/// <param name="emitterFlavor"><see cref="EmitterFlavor"/>.</param>
/// <returns>New <see cref="EnumSerializerEmitter"/> which corresponds to the specified <see cref="EmitterFlavor"/>.</returns>
public EnumSerializerEmitter CreateEnumEmitter(Type targetType, EmitterFlavor emitterFlavor)
{
Contract.Requires(targetType != null);
Contract.Ensures(Contract.Result <EnumSerializerEmitter>() != null);
return(this.CreateEnumEmitterCore(targetType, emitterFlavor));
}
private static void TestFieldInvalidTypeCore(SerializationMethod method, EmitterFlavor flavor)
{
var serializer = CreateSerializer <VersioningTestTarget>(flavor);
using (var stream = new MemoryStream())
{
if (method == SerializationMethod.Array)
{
stream.Write(new byte[] { 0x93, 0x1, 0xFF, 0x1 });
}
else
{
var packer = Packer.Create(stream, false);
packer.PackMapHeader(3);
packer.PackString("Field1");
packer.Pack(1);
packer.PackString("Field2");
packer.Pack(-1);
packer.PackString("Field3");
packer.Pack(1);
}
stream.Position = 0;
var result = serializer.Unpack(stream);
Assert.That(result.Field1, Is.EqualTo(1));
Assert.That(result.Field2, Is.EqualTo(-1));
Assert.That(result.Field3, Is.EqualTo("a"));
}
}
private static void TestExtraFieldCore <T>(SerializationMethod method, EmitterFlavor flavor)
{
var serializer = CreateSerializer <T>(flavor);
using (var stream = new MemoryStream())
{
if (method == SerializationMethod.Array)
{
stream.Write(new byte[] { 0x94, 0x1, 0xFF, 0xA1, ( byte )'a', 0xC0 });
}
else
{
var packer = Packer.Create(stream, false);
packer.PackMapHeader(5);
packer.Pack("Field1");
packer.Pack(1);
packer.Pack("Extra");
packer.PackNull();
packer.Pack("Field2");
packer.Pack(-1);
packer.Pack("Field3");
packer.Pack("a");
packer.Pack("Extra");
packer.PackNull();
}
stream.Position = 0;
serializer.Unpack(stream);
}
}
private static void TestExtraFieldCore <T>(SerializationMethod method, EmitterFlavor flavor)
{
var context = new SerializationContext()
{
SerializationMethod = method, EmitterFlavor = flavor
};
var serializer = MessagePackSerializer.Create <T>(context);
using (var stream = new MemoryStream())
{
if (method == SerializationMethod.Array)
{
stream.Write(new byte[] { 0x94, 0x1, 0xFF, 0xA1, ( byte )'a', 0xC0 });
}
else
{
var packer = Packer.Create(stream, false);
packer.PackMapHeader(4);
packer.Pack("Field1");
packer.Pack(1);
packer.Pack("Field2");
packer.Pack(-1);
packer.Pack("Field3");
packer.Pack("a");
packer.Pack("Extra");
packer.PackNull();
}
stream.Position = 0;
var result = serializer.Unpack(stream);
/*
* if ( result is IMessagePackExtensibleObject )
* {
* var extensionData = ( ( IMessagePackExtensibleObject )result ).ExtensionData;
* Assert.That( extensionData.IsNil, Is.False );
*
* if ( method == SerializationMethod.Array )
* {
* Assert.That( extensionData.AsList().Count, Is.EqualTo( 4 ) );
* Assert.That( extensionData.AsList()[ 0 ] == 1 );
* Assert.That( extensionData.AsList()[ 1 ] == -1 );
* Assert.That( extensionData.AsList()[ 2 ] == "a" );
* Assert.That( extensionData.AsList()[ 3 ].IsNil );
* }
* else
* {
* Assert.That( extensionData.AsDictionary().Count, Is.EqualTo( 4 ) );
* Assert.That( extensionData.AsDictionary()[ "Field1" ] == 1 );
* Assert.That( extensionData.AsDictionary()[ "Field2" ] == -1 );
* Assert.That( extensionData.AsDictionary()[ "Field3" ] == "a" );
* Assert.That( extensionData.AsDictionary()[ "Extra" ].IsNil );
* }
* }
*/
}
}
/// <summary>
/// Creates new <see cref="SerializerEmitter"/> which corresponds to the specified <see cref="EmitterFlavor"/>.
/// </summary>
/// <param name="targetType">The type of the serialization target.</param>
/// <param name="emitterFlavor"><see cref="EmitterFlavor"/>.</param>
/// <returns>New <see cref="SerializerEmitter"/> which corresponds to the specified <see cref="EmitterFlavor"/>.</returns>
public SerializerEmitter CreateEmitter( Type targetType, EmitterFlavor emitterFlavor )
{
Contract.Requires( targetType != null );
Contract.Requires( emitterFlavor == EmitterFlavor.FieldBased || emitterFlavor == EmitterFlavor.ContextBased );
Contract.Ensures( Contract.Result<SerializerEmitter>() != null );
return this.CreateEmitterCore( targetType , emitterFlavor);
}
/// <summary>
/// Creates new <see cref="SerializerEmitter"/> which corresponds to the specified <see cref="EmitterFlavor"/>.
/// </summary>
/// <param name="targetType">The type of the serialization target.</param>
/// <param name="baseClass">Type of the base class of the serializer.</param>
/// <param name="emitterFlavor"><see cref="EmitterFlavor"/>.</param>
/// <returns>New <see cref="SerializerEmitter"/> which corresponds to the specified <see cref="EmitterFlavor"/>.</returns>
public SerializerEmitter CreateEmitter(Type targetType, Type baseClass, EmitterFlavor emitterFlavor)
{
Contract.Requires(targetType != null);
Contract.Requires(baseClass != null);
Contract.Ensures(Contract.Result <SerializerEmitter>() != null);
return(this.CreateEmitterCore(targetType, baseClass, emitterFlavor));
}
/// <summary>
/// Creates new <see cref="SerializerEmitter"/> which corresponds to the specified <see cref="EmitterFlavor"/>.
/// </summary>
/// <param name="targetType">The type of the serialization target.</param>
/// <param name="emitterFlavor"><see cref="EmitterFlavor"/>.</param>
/// <returns>New <see cref="SerializerEmitter"/> which corresponds to the specified <see cref="EmitterFlavor"/>.</returns>
public SerializerEmitter CreateEmitter(Type targetType, EmitterFlavor emitterFlavor)
{
Contract.Requires(targetType != null);
Contract.Requires(emitterFlavor == EmitterFlavor.FieldBased || emitterFlavor == EmitterFlavor.ContextBased);
Contract.Ensures(Contract.Result <SerializerEmitter>() != null);
return(this.CreateEmitterCore(targetType, emitterFlavor));
}
public static SerializerEmitter CreateArraySerializerCore(Type targetType, EmitterFlavor emitterFlavor)
{
Contract.Requires(targetType != null);
SerializerEmitter emitter = SerializationMethodGeneratorManager.Get().CreateEmitter(targetType, emitterFlavor);
CollectionTraits collectionTraits = targetType.GetCollectionTraits();
CreatePackArrayProceduresCore(targetType, emitter, collectionTraits);
CreateUnpackArrayProceduresCore(targetType, emitter, collectionTraits);
return(emitter);
}
public static SerializerEmitter CreateArraySerializerCore( Type targetType, EmitterFlavor emitterFlavor )
{
Contract.Requires( targetType != null );
Contract.Ensures( Contract.Result<SerializerEmitter>() != null );
var emitter = SerializationMethodGeneratorManager.Get().CreateEmitter( targetType, emitterFlavor );
var traits = targetType.GetCollectionTraits();
CreatePackArrayProceduresCore( targetType, emitter, traits );
CreateUnpackArrayProceduresCore( targetType, emitter, traits );
return emitter;
}
private static void TestCore(EmitterFlavor emittingFlavor, SerializationMethod serializationMethod, Func <SerializationContext, SerializerBuilder <DirectoryItem> > builderProvider)
{
var root = new DirectoryItem()
{
Name = "/"
};
root.Directories =
new[]
{
new DirectoryItem()
{
Name = "tmp/"
},
new DirectoryItem()
{
Name = "var/",
Directories = new DirectoryItem[0],
Files = new [] { new FileItem()
{
Name = "system.log"
} }
}
};
root.Files = new FileItem[0];
var serializer = new AutoMessagePackSerializer <DirectoryItem>(new SerializationContext()
{
EmitterFlavor = emittingFlavor, SerializationMethod = serializationMethod, GeneratorOption = SerializationMethodGeneratorOption.CanDump
}, builderProvider);
using (var memoryStream = new MemoryStream())
{
serializer.Pack(memoryStream, root);
memoryStream.Position = 0;
var result = serializer.Unpack(memoryStream);
Assert.That(result.Name, Is.EqualTo("/"));
Assert.That(result.Files, Is.Not.Null.And.Empty);
Assert.That(result.Directories, Is.Not.Null.And.Length.EqualTo(2));
Assert.That(result.Directories[0], Is.Not.Null);
Assert.That(result.Directories[0].Name, Is.EqualTo("tmp/"));
Assert.That(result.Directories[0].Files, Is.Null);
Assert.That(result.Directories[0].Directories, Is.Null);
Assert.That(result.Directories[1], Is.Not.Null);
Assert.That(result.Directories[1].Name, Is.EqualTo("var/"));
Assert.That(result.Directories[1].Files, Is.Not.Null.And.Length.EqualTo(1));
Assert.That(result.Directories[1].Files[0], Is.Not.Null);
Assert.That(result.Directories[1].Files[0].Name, Is.EqualTo("system.log"));
Assert.That(result.Directories[1].Directories, Is.Not.Null.And.Empty);
}
}
private static MessagePackSerializer <T> CreateSerializer <T>(EmitterFlavor flavor)
{
#if NETFX_35 || NETFX_CORE || SILVERLIGHT
var context = new SerializationContext();
#else
var context = PreGeneratedSerializerActivator.CreateContext(SerializationMethod.Array, SerializationContext.Default.CompatibilityOptions.PackerCompatibilityOptions);
#endif
#if !XAMIOS && !UNITY_IPHONE
context.SerializerOptions.EmitterFlavor = flavor;
return(MessagePackSerializer.CreateInternal <T>(context, PolymorphismSchema.Default));
#else
return(context.GetSerializer <T>());
#endif // !XAMIOS && !UNITY_IPHONE
}
private static MessagePackSerializer <T> CreateSerializer <T>(EmitterFlavor flavor)
{
var context =
#if AOT
flavor != EmitterFlavor.ReflectionBased
? PreGeneratedSerializerActivator.CreateContext(SerializationMethod.Array, SerializationContext.Default.CompatibilityOptions.PackerCompatibilityOptions) :
#endif // AOT
new SerializationContext();
#if !AOT
context.SerializerOptions.EmitterFlavor = flavor;
return(MessagePackSerializer.CreateInternal <T>(context, PolymorphismSchema.Default));
#else
return(context.GetSerializer <T>());
#endif // !AOT
}
internal NullableMessagePackSerializer(SerializationContext context, EmitterFlavor emitterFlavor)
{
if (context == null)
{
throw new ArgumentNullException("context");
}
if (NullableMessagePackSerializer <T> ._nullableTImplicitOperator == null)
{
throw new InvalidOperationException(string.Format(CultureInfo.CurrentCulture, "'{0}' is not nullable type.", new object[] { typeof(T) }));
}
SerializerEmitter emitter = SerializationMethodGeneratorManager.Get().CreateEmitter(typeof(T), emitterFlavor);
NullableMessagePackSerializer <T> .CreatePacking(emitter);
NullableMessagePackSerializer <T> .CreateUnpacking(emitter);
this._underlying = emitter.CreateInstance <T>(context);
}
/// <summary>
/// Creates new <see cref="SerializerEmitter"/> which corresponds to the specified <see cref="EmitterFlavor"/>.
/// </summary>
/// <param name="targetType">The type of the serialization target.</param>
/// <param name="emitterFlavor"><see cref="EmitterFlavor"/>.</param>
/// <returns>
/// New <see cref="SerializerEmitter"/> which corresponds to the specified <see cref="EmitterFlavor"/>.
/// </returns>
protected override SerializerEmitter CreateEmitterCore(Type targetType, EmitterFlavor emitterFlavor)
{
#if !WINDOWS_PHONE
switch (emitterFlavor)
{
case EmitterFlavor.FieldBased:
{
return(new FieldBasedSerializerEmitter(this._module, this._isExternalAssemblyBuilder ? default(int?) : Interlocked.Increment(ref this._typeSequence), targetType, this._isDebuggable));
}
default:
{
return(new ContextBasedSerializerEmitter(targetType));
}
}
#else
return(new ContextBasedSerializerEmitter(targetType));
#endif
}
private static void TestExtraFieldCore(SerializationMethod method, EmitterFlavor flavor, PackerCompatibilityOptions compat)
{
var serializer = CreateSerializer <VersioningTestTarget>(flavor);
using (var stream = new MemoryStream())
{
if (method == SerializationMethod.Array)
{
stream.Write(new byte[] { 0x94, 0x1, 0xFF, 0xA1, ( byte )'a', 0xA1, 0xC0 });
}
else
{
const string String10 = "1234567890"; // packed as MinimumFixedRaw or Bin8
const string String40 = "1234567890123456789012345678901234567890"; // packed as Bin8 or Str8
var packer = Packer.Create(stream, compat, false);
packer.PackMapHeader(7);
packer.PackString("Field1");
packer.Pack(1);
packer.PackString("Extra1");
packer.PackString(String40);
packer.PackString("Extra2");
packer.PackBinary(System.Text.Encoding.UTF8.GetBytes(String40));
packer.PackString("Field2");
packer.Pack(-1);
packer.PackString("Extra3");
packer.PackString(String10);
packer.PackString("Field3");
packer.PackString("a");
packer.PackString("Extra4");
packer.PackArrayHeader(1);
packer.PackNull();
}
stream.Position = 0;
var result = serializer.Unpack(stream);
Assert.That(result.Field1, Is.EqualTo(1));
Assert.That(result.Field2, Is.EqualTo(-1));
Assert.That(result.Field3, Is.EqualTo("a"));
}
}
public static SerializerEmitter CreateMapSerializerCore(Type targetType, EmitterFlavor emitterFlavor)
{
Contract.Requires(targetType != null);
Contract.Ensures(Contract.Result <SerializerEmitter>() != null);
var emitter = SerializationMethodGeneratorManager.Get().CreateEmitter(targetType, emitterFlavor);
var traits = targetType.GetCollectionTraits();
CreateMapPack(
targetType,
emitter,
traits
);
CreateMapUnpack(
targetType,
emitter,
traits
);
return(emitter);
}
private static void TestCore(EmitterFlavor emittingFlavor, SerializationMethod serializationMethod, ISerializerBuilder <DirectoryItem> generator)
{
var root = new DirectoryItem()
{
Name = "/"
};
root.Directories =
new[]
{
new DirectoryItem()
{
Name = "tmp/"
},
new DirectoryItem()
{
Name = "var/",
Directories = new DirectoryItem[0],
Files = new [] { new FileItem()
{
Name = "system.log"
} }
}
};
root.Files = new FileItem[0];
var serializer =
new AutoMessagePackSerializer <DirectoryItem>(
new SerializationContext
{
EmitterFlavor = emittingFlavor,
SerializationMethod = serializationMethod,
#if SILVERLIGHT
GeneratorOption = SerializationMethodGeneratorOption.Fast
#else
GeneratorOption = SerializationMethodGeneratorOption.CanDump
#endif
},
private static void TestCore( EmitterFlavor emittingFlavor, Func<SerializationContext, SerializerBuilder<DirectoryItem>> builderProvider )
{
var root = new DirectoryItem() { Name = "/" };
root.Directories =
new[]
{
new DirectoryItem() { Name = "tmp/" },
new DirectoryItem()
{
Name = "var/",
Directories = new DirectoryItem[ 0 ],
Files = new []{ new FileItem(){ Name = "system.log" } }
}
};
root.Files = new FileItem[ 0 ];
var serializer = new AutoMessagePackSerializer<DirectoryItem>( new SerializationContext() { EmitterFlavor = emittingFlavor, GeneratorOption = SerializationMethodGeneratorOption.CanDump }, builderProvider );
using ( var memoryStream = new MemoryStream() )
{
serializer.Pack( memoryStream, root );
memoryStream.Position = 0;
var result = serializer.Unpack( memoryStream );
Assert.That( result.Name, Is.EqualTo( "/" ) );
Assert.That( result.Files, Is.Not.Null.And.Empty );
Assert.That( result.Directories, Is.Not.Null.And.Length.EqualTo( 2 ) );
Assert.That( result.Directories[ 0 ], Is.Not.Null );
Assert.That( result.Directories[ 0 ].Name, Is.EqualTo( "tmp/" ) );
Assert.That( result.Directories[ 0 ].Files, Is.Null );
Assert.That( result.Directories[ 0 ].Directories, Is.Null );
Assert.That( result.Directories[ 1 ], Is.Not.Null );
Assert.That( result.Directories[ 1 ].Name, Is.EqualTo( "var/" ) );
Assert.That( result.Directories[ 1 ].Files, Is.Not.Null.And.Length.EqualTo( 1 ) );
Assert.That( result.Directories[ 1 ].Files[ 0 ], Is.Not.Null );
Assert.That( result.Directories[ 1 ].Files[ 0 ].Name, Is.EqualTo( "system.log" ) );
Assert.That( result.Directories[ 1 ].Directories, Is.Not.Null.And.Empty );
}
}
private static void TestFieldSwappedCore(EmitterFlavor flavor)
{
var serializer = CreateSerializer <VersioningTestTarget>(flavor);
using (var stream = new MemoryStream())
{
var packer = Packer.Create(stream, false);
packer.PackMapHeader(3);
packer.PackString("Field1");
packer.Pack(1);
packer.PackString("Field2");
packer.Pack(-1);
packer.PackString("Extra");
packer.Pack(2); // Issue6
stream.Position = 0;
var result = serializer.Unpack(stream);
Assert.That(result.Field1, Is.EqualTo(1));
Assert.That(result.Field2, Is.EqualTo(-1));
Assert.That(result.Field3, Is.Null);
}
}
private static void TestExtraFieldRoundTripCore <T>(SerializationMethod method, EmitterFlavor flavor)
{
var context = new SerializationContext()
{
SerializationMethod = method, EmitterFlavor = flavor
};
var serializer = MessagePackSerializer.Create <T>(context);
using (var stream = new MemoryStream())
{
if (method == SerializationMethod.Array)
{
stream.Write(new byte[] { 0x94, 0x1, 0xFF, 0xA1, ( byte )'a', 0xC0 });
}
else
{
var packer = Packer.Create(stream, false);
packer.PackMapHeader(4);
packer.Pack("Field1");
packer.Pack(1);
packer.Pack("Field2");
packer.Pack(-1);
packer.Pack("Field3");
packer.Pack("a");
packer.Pack("Extra");
packer.PackNull();
}
byte[] bytes = stream.ToArray();
stream.Position = 0;
var result = serializer.Unpack(stream);
stream.SetLength(0);
serializer.Pack(stream, result);
Assert.That(stream.ToArray(), Is.EqualTo(bytes));
}
}
/// <summary> /// Creates new <see cref="SerializerEmitter"/> which corresponds to the specified <see cref="EmitterFlavor"/>. /// </summary> /// <param name="specification">The specification of the serializer.</param> /// <param name="baseClass">Type of the base class of the serializer.</param> /// <param name="emitterFlavor"><see cref="EmitterFlavor"/>.</param> /// <returns>New <see cref="SerializerEmitter"/> which corresponds to the specified <see cref="EmitterFlavor"/>.</returns> protected abstract SerializerEmitter CreateEmitterCore(SerializerSpecification specification, Type baseClass, EmitterFlavor emitterFlavor);
/// <summary>
/// Creates new <see cref="EnumSerializerEmitter" /> which corresponds to the specified <see cref="EmitterFlavor" />.
/// </summary>
/// <param name="context">The <see cref="SerializationContext" />.</param>
/// <param name="specification">The specification of the serializer.</param>
/// <param name="emitterFlavor"><see cref="EmitterFlavor" />.</param>
/// <returns>
/// New <see cref="SerializerEmitter" /> which corresponds to the specified <see cref="EmitterFlavor" />.
/// </returns>
protected override EnumSerializerEmitter CreateEnumEmitterCore( SerializationContext context, SerializerSpecification specification, EmitterFlavor emitterFlavor )
{
#if !WINDOWS_PHONE
switch ( emitterFlavor )
{
case EmitterFlavor.FieldBased:
{
return new FieldBasedEnumSerializerEmitter( context, this._module, specification, this._isDebuggable );
}
default:
{
return new ContextBasedEnumSerializerEmitter( specification );
}
}
#else
return new ContextBasedEnumSerializerEmitter( targetType );
#endif
}
/// <summary> /// Creates new <see cref="EnumSerializerEmitter"/> which corresponds to the specified <see cref="EmitterFlavor"/>. /// </summary> /// <param name="targetType">The type of the serialization target.</param> /// <param name="emitterFlavor"><see cref="EmitterFlavor"/>.</param> /// <returns>New <see cref="SerializerEmitter"/> which corresponds to the specified <see cref="EmitterFlavor"/>.</returns> protected abstract EnumSerializerEmitter CreateEnumEmitterCore(Type targetType, EmitterFlavor emitterFlavor);
/// <summary>
/// Creates new <see cref="EnumSerializerEmitter"/> which corresponds to the specified <see cref="EmitterFlavor"/>.
/// </summary>
/// <param name="context">The <see cref="SerializationContext"/>.</param>
/// <param name="specification">The specification of the serializer.</param>
/// <param name="emitterFlavor"><see cref="EmitterFlavor"/>.</param>
/// <returns>New <see cref="EnumSerializerEmitter"/> which corresponds to the specified <see cref="EmitterFlavor"/>.</returns>
public EnumSerializerEmitter CreateEnumEmitter( SerializationContext context, SerializerSpecification specification, EmitterFlavor emitterFlavor )
{
Contract.Requires( context != null );
Contract.Requires( specification != null );
Contract.Ensures( Contract.Result<EnumSerializerEmitter>() != null );
return this.CreateEnumEmitterCore( context, specification, emitterFlavor );
}
private static TestResult[] Test(
EmitterFlavor flavor,
SerializationMethod method,
EnumSerializationMethod enumMethod )
{
var stopWatch = new Stopwatch();
using ( var buffer = new MemoryStream() )
{
// JIT
TestCreateSerializer(
stopWatch,
new SerializationContext
{
EmitterFlavor = flavor,
SerializationMethod = method,
EnumSerializationMethod = enumMethod
}
);
TestSerialize(
stopWatch,
buffer,
new SerializationContext
{
EmitterFlavor = flavor,
SerializationMethod = method,
EnumSerializationMethod = enumMethod
}
);
buffer.Position = 0;
TestDeserialize(
stopWatch,
buffer,
new SerializationContext
{
EmitterFlavor = flavor,
SerializationMethod = method,
EnumSerializationMethod = enumMethod
}
);
var samples = new long[ flavor == EmitterFlavor.CodeDomBased ? 10 : Iteration ];
// 1st-time only
for ( int i = 0; i < samples.Length; i++ )
{
TestCreateSerializer(
stopWatch,
new SerializationContext
{
EmitterFlavor = flavor,
SerializationMethod = method,
EnumSerializationMethod = enumMethod
}
);
samples[ i ] = stopWatch.Elapsed.Ticks;
}
var creationResult = Calculate( samples );
samples = new long[ Iteration ];
// Exept-1st time
var context =
new SerializationContext
{
EmitterFlavor = flavor,
SerializationMethod = method,
EnumSerializationMethod = enumMethod
};
var samples2 = new long[ samples.Length ];
// Dry-run
buffer.SetLength( 0 );
TestSerialize( stopWatch, buffer, context );
buffer.Position = 0;
TestDeserialize( stopWatch, buffer, context );
for ( int i = 0; i < samples.Length; i++ )
{
buffer.SetLength( 0 );
TestSerialize( stopWatch, buffer, context );
samples[ i ] = stopWatch.Elapsed.Ticks;
buffer.Position = 0;
TestDeserialize( stopWatch, buffer, context );
samples2[ i ] = stopWatch.Elapsed.Ticks;
}
var serializationResult = Calculate( samples );
var deserializationResult = Calculate( samples2 );
return new TestResult[] { creationResult, serializationResult, deserializationResult };
}
}
/// <summary>
/// Creates new <see cref="SerializerEmitter"/> which corresponds to the specified <see cref="EmitterFlavor"/>.
/// </summary>
/// <param name="targetType">The type of the serialization target.</param>
/// <param name="baseClass">Type of the base class of the serializer.</param>
/// <param name="emitterFlavor"><see cref="EmitterFlavor"/>.</param>
/// <returns>New <see cref="SerializerEmitter"/> which corresponds to the specified <see cref="EmitterFlavor"/>.</returns>
public SerializerEmitter CreateEmitter( Type targetType, Type baseClass, EmitterFlavor emitterFlavor )
{
Contract.Requires( targetType != null );
Contract.Requires( baseClass != null );
Contract.Ensures( Contract.Result<SerializerEmitter>() != null );
return this.CreateEmitterCore( targetType, baseClass, emitterFlavor );
}
/// <summary> /// Creates new <see cref="SerializerEmitter"/> which corresponds to the specified <see cref="EmitterFlavor"/>. /// </summary> /// <param name="targetType">The type of the serialization target.</param> /// <param name="baseClass">Type of the base class of the serializer.</param> /// <param name="emitterFlavor"><see cref="EmitterFlavor"/>.</param> /// <returns>New <see cref="SerializerEmitter"/> which corresponds to the specified <see cref="EmitterFlavor"/>.</returns> protected abstract SerializerEmitter CreateEmitterCore( Type targetType, Type baseClass, EmitterFlavor emitterFlavor );
public static SerializerEmitter CreateTupleSerializerCore( Type tupleType, EmitterFlavor emitterFlavor )
{
Contract.Requires( tupleType != null );
Contract.Ensures( Contract.Result<SerializerEmitter>() != null );
var emitter = SerializationMethodGeneratorManager.Get().CreateEmitter( tupleType, emitterFlavor );
var itemTypes = TupleItems.GetTupleItemTypes( tupleType );
CreateTuplePack(
emitter,
tupleType,
itemTypes,
( il, collection ) =>
{
il.EmitAnyLdarg( 2 );
il.EmitAnyStloc( collection );
}
);
CreateTupleUnpack(
emitter,
itemTypes
);
return emitter;
}
/// <summary>
/// Initializes a new instance of the <see cref="EmittingSerializerBuilder<TObject>"/> class.
/// </summary>
/// <param name="context">The <see cref="SerializationContext"/>.</param>
protected EmittingSerializerBuilder(SerializationContext context)
: base(context)
{
this._emitterFlavor = context.EmitterFlavor;
this._generatorManager = SerializationMethodGeneratorManager.Get(context.GeneratorOption);
}
public static SerializerEmitter CreateArraySerializerCore(SerializationContext context, Type targetType, EmitterFlavor emitterFlavor)
{
Contract.Requires(targetType != null);
Contract.Ensures(Contract.Result <SerializerEmitter>() != null);
var emitter = SerializationMethodGeneratorManager.Get().CreateEmitter(targetType, emitterFlavor);
var traits = targetType.GetCollectionTraits();
CreatePackArrayProceduresCore(targetType, emitter, traits);
CreateUnpackArrayProceduresCore(context, targetType, emitter, traits);
return(emitter);
}
/// <summary> /// Creates new <see cref="SerializerEmitter"/> which corresponds to the specified <see cref="EmitterFlavor"/>. /// </summary> /// <param name="targetType">The type of the serialization target.</param> /// <param name="baseClass">Type of the base class of the serializer.</param> /// <param name="emitterFlavor"><see cref="EmitterFlavor"/>.</param> /// <returns>New <see cref="SerializerEmitter"/> which corresponds to the specified <see cref="EmitterFlavor"/>.</returns> protected abstract SerializerEmitter CreateEmitterCore(Type targetType, Type baseClass, EmitterFlavor emitterFlavor);
/// <summary>
/// Creates new <see cref="EnumSerializerEmitter"/> which corresponds to the specified <see cref="EmitterFlavor"/>.
/// </summary>
/// <param name="context">The <see cref="SerializationContext"/>.</param>
/// <param name="specification">The specification of the serializer.</param>
/// <param name="emitterFlavor"><see cref="EmitterFlavor"/>.</param>
/// <returns>New <see cref="EnumSerializerEmitter"/> which corresponds to the specified <see cref="EmitterFlavor"/>.</returns>
public EnumSerializerEmitter CreateEnumEmitter(SerializationContext context, SerializerSpecification specification, EmitterFlavor emitterFlavor)
{
Contract.Requires(context != null);
Contract.Requires(specification != null);
Contract.Ensures(Contract.Result <EnumSerializerEmitter>() != null);
return(this.CreateEnumEmitterCore(context, specification, emitterFlavor));
}
private static void TestCore( EmitterFlavor emittingFlavor, SerializationMethod serializationMethod, ISerializerBuilder generator )
{
var root = new DirectoryItem() { Name = "/" };
root.Directories =
new[]
{
new DirectoryItem() { Name = "tmp/" },
new DirectoryItem()
{
Name = "var/",
Directories = new DirectoryItem[ 0 ],
Files = new []{ new FileItem(){ Name = "system.log" } }
}
};
root.Files = new FileItem[ 0 ];
var context =
new SerializationContext
{
SerializationMethod = serializationMethod,
SerializerOptions =
{
GeneratorOption = SerializationMethodGeneratorOption.CanDump,
EmitterFlavor = emittingFlavor
}
};
var serializer =
( MessagePackSerializer<DirectoryItem> ) generator.BuildSerializerInstance(
context,
typeof( DirectoryItem ),
PolymorphismSchema.Default
);
using ( var memoryStream = new MemoryStream() )
{
serializer.Pack( memoryStream, root );
memoryStream.Position = 0;
var result = serializer.Unpack( memoryStream );
Assert.That( result.Name, Is.EqualTo( "/" ) );
Assert.That( result.Files, Is.Not.Null.And.Empty );
Assert.That( result.Directories, Is.Not.Null.And.Length.EqualTo( 2 ) );
Assert.That( result.Directories[ 0 ], Is.Not.Null );
Assert.That( result.Directories[ 0 ].Name, Is.EqualTo( "tmp/" ) );
Assert.That( result.Directories[ 0 ].Files, Is.Null );
Assert.That( result.Directories[ 0 ].Directories, Is.Null );
Assert.That( result.Directories[ 1 ], Is.Not.Null );
Assert.That( result.Directories[ 1 ].Name, Is.EqualTo( "var/" ) );
Assert.That( result.Directories[ 1 ].Files, Is.Not.Null.And.Length.EqualTo( 1 ) );
Assert.That( result.Directories[ 1 ].Files[ 0 ], Is.Not.Null );
Assert.That( result.Directories[ 1 ].Files[ 0 ].Name, Is.EqualTo( "system.log" ) );
Assert.That( result.Directories[ 1 ].Directories, Is.Not.Null.And.Empty );
}
}
/// <summary>
/// Creates new <see cref="EnumSerializerEmitter"/> which corresponds to the specified <see cref="EmitterFlavor"/>.
/// </summary>
/// <param name="targetType">The type of the serialization target.</param>
/// <param name="emitterFlavor"><see cref="EmitterFlavor"/>.</param>
/// <returns>New <see cref="EnumSerializerEmitter"/> which corresponds to the specified <see cref="EmitterFlavor"/>.</returns>
public EnumSerializerEmitter CreateEnumEmitter( Type targetType, EmitterFlavor emitterFlavor )
{
Contract.Requires( targetType != null );
Contract.Ensures( Contract.Result<EnumSerializerEmitter>() != null );
return this.CreateEnumEmitterCore( targetType, emitterFlavor );
}
/// <summary> /// Creates new <see cref="EnumSerializerEmitter"/> which corresponds to the specified <see cref="EmitterFlavor"/>. /// </summary> /// <param name="context">The <see cref="SerializationContext"/>.</param> /// <param name="specification">The specification of the serializer.</param> /// <param name="emitterFlavor"><see cref="EmitterFlavor"/>.</param> /// <returns>New <see cref="SerializerEmitter"/> which corresponds to the specified <see cref="EmitterFlavor"/>.</returns> protected abstract EnumSerializerEmitter CreateEnumEmitterCore( SerializationContext context, SerializerSpecification specification, EmitterFlavor emitterFlavor );
/// <summary> /// Creates new <see cref="EnumSerializerEmitter"/> which corresponds to the specified <see cref="EmitterFlavor"/>. /// </summary> /// <param name="targetType">The type of the serialization target.</param> /// <param name="emitterFlavor"><see cref="EmitterFlavor"/>.</param> /// <returns>New <see cref="SerializerEmitter"/> which corresponds to the specified <see cref="EmitterFlavor"/>.</returns> protected abstract EnumSerializerEmitter CreateEnumEmitterCore( Type targetType, EmitterFlavor emitterFlavor );
protected override EnumSerializerEmitter CreateEnumEmitterCore( Type targetType, EmitterFlavor emitterFlavor )
{
#if !WINDOWS_PHONE
switch ( emitterFlavor )
{
case EmitterFlavor.FieldBased:
{
return new FieldBasedEnumSerializerEmitter( this._module, this._isExternalAssemblyBuilder ? default( int? ) : Interlocked.Increment( ref this._typeSequence ), targetType, this._isDebuggable );
}
default:
{
return new ContextBasedEnumSerializerEmitter( targetType );
}
}
#else
return new ContextBasedEnumSerializerEmitter( targetType );
#endif
}
protected sealed override SerializerEmitter CreateEmitterCore(Type targetType, EmitterFlavor emitterFlavor)
{
switch (emitterFlavor)
{
case EmitterFlavor.FieldBased:
return(new FieldBasedSerializerEmitter(this._module, this._isExternalAssemblyBuilder ? null : new int?(Interlocked.Increment(ref this._typeSequence)), targetType, this._isDebuggable));
}
return(new ContextBasedSerializerEmitter(targetType));
}
private static void TestCore(EmitterFlavor emittingFlavor, SerializationMethod serializationMethod, ISerializerBuilder generator)
{
var root = new DirectoryItem()
{
Name = "/"
};
root.Directories =
new[]
{
new DirectoryItem()
{
Name = "tmp/"
},
new DirectoryItem()
{
Name = "var/",
Directories = new DirectoryItem[0],
Files = new [] { new FileItem()
{
Name = "system.log"
} }
}
};
root.Files = new FileItem[0];
var context =
new SerializationContext
{
SerializationMethod = serializationMethod,
SerializerOptions =
{
#if !NETSTANDARD1_3
GeneratorOption = SerializationMethodGeneratorOption.CanDump,
#endif // !NETSTANDARD1_3
EmitterFlavor = emittingFlavor
}
};
var serializer =
(MessagePackSerializer <DirectoryItem>)generator.BuildSerializerInstance(
context,
typeof(DirectoryItem),
PolymorphismSchema.Default
);
using (var memoryStream = new MemoryStream())
{
serializer.Pack(memoryStream, root);
memoryStream.Position = 0;
var result = serializer.Unpack(memoryStream);
Assert.That(result.Name, Is.EqualTo("/"));
Assert.That(result.Files, Is.Not.Null.And.Empty);
Assert.That(result.Directories, Is.Not.Null.And.Length.EqualTo(2));
Assert.That(result.Directories[0], Is.Not.Null);
Assert.That(result.Directories[0].Name, Is.EqualTo("tmp/"));
Assert.That(result.Directories[0].Files, Is.Null);
Assert.That(result.Directories[0].Directories, Is.Null);
Assert.That(result.Directories[1], Is.Not.Null);
Assert.That(result.Directories[1].Name, Is.EqualTo("var/"));
Assert.That(result.Directories[1].Files, Is.Not.Null.And.Length.EqualTo(1));
Assert.That(result.Directories[1].Files[0], Is.Not.Null);
Assert.That(result.Directories[1].Files[0].Name, Is.EqualTo("system.log"));
Assert.That(result.Directories[1].Directories, Is.Not.Null.And.Empty);
}
}
/// <summary> /// Creates new <see cref="EnumSerializerEmitter"/> which corresponds to the specified <see cref="EmitterFlavor"/>. /// </summary> /// <param name="context">The <see cref="SerializationContext"/>.</param> /// <param name="targetType">The type of the serialization target.</param> /// <param name="emitterFlavor"><see cref="EmitterFlavor"/>.</param> /// <returns>New <see cref="SerializerEmitter"/> which corresponds to the specified <see cref="EmitterFlavor"/>.</returns> protected abstract EnumSerializerEmitter CreateEnumEmitterCore( SerializationContext context, Type targetType, EmitterFlavor emitterFlavor );
/// <summary> /// Creates new <see cref="SerializerEmitter"/> which corresponds to the specified <see cref="EmitterFlavor"/>. /// </summary> /// <param name="specification">The specification of the serializer.</param> /// <param name="baseClass">Type of the base class of the serializer.</param> /// <param name="emitterFlavor"><see cref="EmitterFlavor"/>.</param> /// <returns>New <see cref="SerializerEmitter"/> which corresponds to the specified <see cref="EmitterFlavor"/>.</returns> protected abstract SerializerEmitter CreateEmitterCore( SerializerSpecification specification, Type baseClass, EmitterFlavor emitterFlavor );
public static SerializerEmitter CreateMapSerializerCore( SerializationContext context, Type targetType, EmitterFlavor emitterFlavor )
{
Contract.Requires( targetType != null );
Contract.Ensures( Contract.Result<SerializerEmitter>() != null );
var emitter = SerializationMethodGeneratorManager.Get().CreateEmitter( targetType, emitterFlavor );
var traits = targetType.GetCollectionTraits();
CreateMapPack(
targetType,
emitter,
traits
);
CreateMapUnpack(
context,
targetType,
emitter,
traits
);
return emitter;
}
/// <summary>
/// Creates new <see cref="SerializerEmitter"/> which corresponds to the specified <see cref="EmitterFlavor"/>.
/// </summary>
/// <param name="specification">The specification of the serializer.</param>
/// <param name="baseClass">Type of the base class of the serializer.</param>
/// <param name="emitterFlavor"><see cref="EmitterFlavor"/>.</param>
/// <returns>New <see cref="SerializerEmitter"/> which corresponds to the specified <see cref="EmitterFlavor"/>.</returns>
public SerializerEmitter CreateEmitter( SerializerSpecification specification, Type baseClass, EmitterFlavor emitterFlavor )
{
Contract.Requires( specification != null );
Contract.Requires( baseClass != null );
Contract.Ensures( Contract.Result<SerializerEmitter>() != null );
return this.CreateEmitterCore( specification, baseClass, emitterFlavor );
}
/// <summary>
/// Creates new <see cref="SerializerEmitter"/> which corresponds to the specified <see cref="EmitterFlavor"/>.
/// </summary>
/// <param name="targetType">The type of the serialization target.</param>
/// <param name="emitterFlavor"><see cref="EmitterFlavor"/>.</param>
/// <returns>
/// New <see cref="SerializerEmitter"/> which corresponds to the specified <see cref="EmitterFlavor"/>.
/// </returns>
protected sealed override SerializerEmitter CreateEmitterCore( Type targetType, EmitterFlavor emitterFlavor )
{
#if !WINDOWS_PHONE
switch ( emitterFlavor )
{
case EmitterFlavor.FieldBased:
{
return new FieldBasedSerializerEmitter( this._module, Interlocked.Increment( ref this._typeSequence ), targetType, this._isDebuggable );
}
case EmitterFlavor.ContextBased:
default:
{
return new ContextBasedSerializerEmitter( targetType );
}
}
#else
return new ContextBasedSerializerEmitter( targetType );
#endif
}
/// <summary> /// Creates new <see cref="EnumSerializerEmitter"/> which corresponds to the specified <see cref="EmitterFlavor"/>. /// </summary> /// <param name="context">The <see cref="SerializationContext"/>.</param> /// <param name="specification">The specification of the serializer.</param> /// <param name="emitterFlavor"><see cref="EmitterFlavor"/>.</param> /// <returns>New <see cref="SerializerEmitter"/> which corresponds to the specified <see cref="EmitterFlavor"/>.</returns> protected abstract EnumSerializerEmitter CreateEnumEmitterCore(SerializationContext context, SerializerSpecification specification, EmitterFlavor emitterFlavor);
/// <summary>
/// Creates new <see cref="SerializerEmitter"/> which corresponds to the specified <see cref="EmitterFlavor"/>.
/// </summary>
/// <param name="specification">The specification of the serializer.</param>
/// <param name="baseClass">Type of the base class of the serializer.</param>
/// <param name="emitterFlavor"><see cref="EmitterFlavor"/>.</param>
/// <returns>New <see cref="SerializerEmitter"/> which corresponds to the specified <see cref="EmitterFlavor"/>.</returns>
public SerializerEmitter CreateEmitter(SerializerSpecification specification, Type baseClass, EmitterFlavor emitterFlavor)
{
Contract.Requires(specification != null);
Contract.Requires(baseClass != null);
Contract.Ensures(Contract.Result <SerializerEmitter>() != null);
return(this.CreateEmitterCore(specification, baseClass, emitterFlavor));
}
