private static void CreatePackArrayProceduresCore(Type targetType, SerializerEmitter emitter, CollectionTraits traits)
{
var il = emitter.GetPackToMethodILGenerator();
var localHolder = new LocalVariableHolder(il);
try
{
// Array
if (targetType.IsArray)
{
/*
* // array
* packer.PackArrayHeader( length );
* for( int i = 0; i < length; i++ )
* {
* this._serializer.PackTo( packer, collection[ i ] );
* }
*/
var length = localHolder.PackingCollectionCount;
il.EmitAnyLdarg(2);
il.EmitLdlen();
il.EmitAnyStloc(length);
il.EmitAnyLdarg(1);
il.EmitAnyLdloc(length);
il.EmitAnyCall(Metadata._Packer.PackArrayHeader);
il.EmitPop();
Emittion.EmitFor(
il,
length,
(il0, i) =>
Emittion.EmitSerializeValue(
emitter,
il0,
1,
traits.ElementType,
null,
NilImplication.MemberDefault,
il1 =>
{
il1.EmitAnyLdarg(2);
il1.EmitAnyLdloc(i);
il1.EmitLdelem(traits.ElementType);
},
localHolder
)
);
}
else if (traits.CountProperty == null)
{
/*
* array = collection.ToArray();
* packer.PackArrayHeader( length );
* for( int i = 0; i < length; i++ )
* {
* this._serializer.PackTo( packer, array[ i ] );
* }
*/
var array = localHolder.GetSerializingCollection(traits.ElementType.MakeArrayType());
EmitLoadTarget(targetType, il, 2);
il.EmitAnyCall(Metadata._Enumerable.ToArray1Method.MakeGenericMethod(traits.ElementType));
il.EmitAnyStloc(array);
var length = localHolder.PackingCollectionCount;
il.EmitAnyLdloc(array);
il.EmitLdlen();
il.EmitAnyStloc(length);
il.EmitAnyLdarg(1);
il.EmitAnyLdloc(length);
il.EmitAnyCall(Metadata._Packer.PackArrayHeader);
il.EmitPop();
Emittion.EmitFor(
il,
length,
(il0, i) =>
Emittion.EmitSerializeValue(
emitter,
il0,
1,
traits.ElementType,
null,
NilImplication.MemberDefault,
il1 =>
{
il1.EmitAnyLdloc(array);
il1.EmitAnyLdloc(i);
il1.EmitLdelem(traits.ElementType);
},
localHolder
)
);
}
else
{
/*
* // Enumerable
* packer.PackArrayHeader( collection.Count );
* foreach( var item in list )
* {
* this._serializer.PackTo( packer, array[ i ] );
* }
*/
var collection = localHolder.GetSerializingCollection(targetType);
// This instruction always ldarg, not to be ldarga
il.EmitAnyLdarg(2);
il.EmitAnyStloc(collection);
var count = localHolder.PackingCollectionCount;
EmitLoadTarget(targetType, il, 2);
il.EmitGetProperty(traits.CountProperty);
il.EmitAnyStloc(count);
il.EmitAnyLdarg(1);
il.EmitAnyLdloc(count);
il.EmitAnyCall(Metadata._Packer.PackArrayHeader);
il.EmitPop();
Emittion.EmitForEach(
il,
traits,
collection,
(il0, getCurrentEmitter) =>
Emittion.EmitSerializeValue(
emitter,
il0,
1,
traits.ElementType,
null,
NilImplication.MemberDefault,
_ => getCurrentEmitter(),
localHolder
)
);
}
il.EmitRet();
}
finally
{
il.FlushTrace();
}
}
private static void CreateMapPack(Type targetType, SerializerEmitter emiter, CollectionTraits traits)
{
var il = emiter.GetPackToMethodILGenerator();
var localHolder = new LocalVariableHolder(il);
try
{
/*
* int count = ((ICollection<KeyValuePair<string, DateTime>>)dictionary).Count;
* packer.PackMapHeader(count);
* foreach (KeyValuePair<string, DateTime> current in dictionary)
* {
* this._serializer0.PackTo(packer, current.Key);
* this._serializer1.PackTo(packer, current.Value);
* }
*/
var collection = localHolder.GetSerializingCollection(targetType);
var item = localHolder.GetSerializingCollectionItem(traits.ElementType);
var keyProperty = traits.ElementType.GetProperty("Key");
var valueProperty = traits.ElementType.GetProperty("Value");
// This instruction is always ldarg, not to be ldarga.
il.EmitAnyLdarg(2);
il.EmitAnyStloc(collection);
var count = localHolder.PackingCollectionCount;
EmitLoadTarget(targetType, il, collection);
il.EmitGetProperty(traits.CountProperty);
il.EmitAnyStloc(count);
il.EmitAnyLdarg(1);
il.EmitAnyLdloc(count);
il.EmitAnyCall(Metadata._Packer.PackMapHeader);
il.EmitPop();
Emittion.EmitForEach(
il,
traits,
collection,
(il0, getCurrentEmitter) =>
{
if (traits.ElementType.IsGenericType)
{
Contract.Assert(traits.ElementType.GetGenericTypeDefinition() == typeof(KeyValuePair <,>));
getCurrentEmitter();
il0.EmitAnyStloc(item);
Emittion.EmitSerializeValue(
emiter,
il0,
1,
traits.ElementType.GetGenericArguments()[0],
null,
NilImplication.MemberDefault,
il1 =>
{
il1.EmitAnyLdloca(item);
il1.EmitGetProperty(keyProperty);
},
localHolder
);
Emittion.EmitSerializeValue(
emiter,
il0,
1,
traits.ElementType.GetGenericArguments()[1],
null,
NilImplication.MemberDefault,
il1 =>
{
il1.EmitAnyLdloca(item);
il1.EmitGetProperty(valueProperty);
},
localHolder
);
}
else
{
Contract.Assert(traits.ElementType == typeof(DictionaryEntry));
getCurrentEmitter();
il0.EmitAnyStloc(item);
Emittion.EmitSerializeValue(
emiter,
il0,
1,
typeof(MessagePackObject),
null,
NilImplication.MemberDefault,
il1 =>
{
il0.EmitAnyLdloca(item);
il0.EmitGetProperty(Metadata._DictionaryEntry.Key);
il0.EmitUnbox_Any(typeof(MessagePackObject));
},
localHolder
);
Emittion.EmitSerializeValue(
emiter,
il0,
1,
typeof(MessagePackObject),
null,
NilImplication.MemberDefault,
il1 =>
{
il0.EmitAnyLdloca(item);
il0.EmitGetProperty(Metadata._DictionaryEntry.Value);
il0.EmitUnbox_Any(typeof(MessagePackObject));
},
localHolder
);
}
}
);
il.EmitRet();
}
finally
{
il.FlushTrace();
}
}
private static void CreateMapPack( Type targetType, SerializerEmitter emiter, CollectionTraits traits )
{
var il = emiter.GetPackToMethodILGenerator();
var localHolder = new LocalVariableHolder( il );
try
{
/*
* int count = ((ICollection<KeyValuePair<string, DateTime>>)dictionary).Count;
* packer.PackMapHeader(count);
* foreach (KeyValuePair<string, DateTime> current in dictionary)
* {
* this._serializer0.PackTo(packer, current.Key);
* this._serializer1.PackTo(packer, current.Value);
* }
*/
var collection = localHolder.GetSerializingCollection( targetType );
var item = localHolder.GetSerializingCollectionItem( traits.ElementType );
var keyProperty = traits.ElementType.GetProperty( "Key" );
var valueProperty = traits.ElementType.GetProperty( "Value" );
// This instruction is always ldarg, not to be ldarga.
il.EmitAnyLdarg( 2 );
il.EmitAnyStloc( collection );
var count = localHolder.PackingCollectionCount;
EmitLoadTarget( targetType, il, collection );
il.EmitGetProperty( traits.CountProperty );
il.EmitAnyStloc( count );
il.EmitAnyLdarg( 1 );
il.EmitAnyLdloc( count );
il.EmitAnyCall( Metadata._Packer.PackMapHeader );
il.EmitPop();
Emittion.EmitForEach(
il,
traits,
collection,
( il0, getCurrentEmitter ) =>
{
if ( traits.ElementType.IsGenericType )
{
Contract.Assert( traits.ElementType.GetGenericTypeDefinition() == typeof( KeyValuePair<,> ) );
getCurrentEmitter();
il0.EmitAnyStloc( item );
Emittion.EmitSerializeValue(
emiter,
il0,
1,
traits.ElementType.GetGenericArguments()[ 0 ],
null,
NilImplication.MemberDefault,
il1 =>
{
il1.EmitAnyLdloca( item );
il1.EmitGetProperty( keyProperty );
},
localHolder
);
Emittion.EmitSerializeValue(
emiter,
il0,
1,
traits.ElementType.GetGenericArguments()[ 1 ],
null,
NilImplication.MemberDefault,
il1 =>
{
il1.EmitAnyLdloca( item );
il1.EmitGetProperty( valueProperty );
},
localHolder
);
}
else
{
Contract.Assert( traits.ElementType == typeof( DictionaryEntry ) );
getCurrentEmitter();
il0.EmitAnyStloc( item );
Emittion.EmitSerializeValue(
emiter,
il0,
1,
typeof( MessagePackObject ),
null,
NilImplication.MemberDefault,
il1 =>
{
il0.EmitAnyLdloca( item );
il0.EmitGetProperty( Metadata._DictionaryEntry.Key );
il0.EmitUnbox_Any( typeof( MessagePackObject ) );
},
localHolder
);
Emittion.EmitSerializeValue(
emiter,
il0,
1,
typeof( MessagePackObject ),
null,
NilImplication.MemberDefault,
il1 =>
{
il0.EmitAnyLdloca( item );
il0.EmitGetProperty( Metadata._DictionaryEntry.Value );
il0.EmitUnbox_Any( typeof( MessagePackObject ) );
},
localHolder
);
}
}
);
il.EmitRet();
}
finally
{
il.FlushTrace();
}
}
private static void CreatePackArrayProceduresCore( Type targetType, SerializerEmitter emitter, CollectionTraits traits )
{
var il = emitter.GetPackToMethodILGenerator();
var localHolder = new LocalVariableHolder( il );
try
{
// Array
if ( targetType.IsArray )
{
/*
* // array
* packer.PackArrayHeader( length );
* for( int i = 0; i < length; i++ )
* {
* this._serializer.PackTo( packer, collection[ i ] );
* }
*/
var length = localHolder.PackingCollectionCount;
il.EmitAnyLdarg( 2 );
il.EmitLdlen();
il.EmitAnyStloc( length );
il.EmitAnyLdarg( 1 );
il.EmitAnyLdloc( length );
il.EmitAnyCall( Metadata._Packer.PackArrayHeader );
il.EmitPop();
Emittion.EmitFor(
il,
length,
( il0, i ) =>
Emittion.EmitSerializeValue(
emitter,
il0,
1,
traits.ElementType,
null,
NilImplication.MemberDefault,
il1 =>
{
il1.EmitAnyLdarg( 2 );
il1.EmitAnyLdloc( i );
il1.EmitLdelem( traits.ElementType );
},
localHolder
)
);
}
else if ( traits.CountProperty == null )
{
/*
* array = collection.ToArray();
* packer.PackArrayHeader( length );
* for( int i = 0; i < length; i++ )
* {
* this._serializer.PackTo( packer, array[ i ] );
* }
*/
var array = localHolder.GetSerializingCollection( traits.ElementType.MakeArrayType() );
EmitLoadTarget( targetType, il, 2 );
il.EmitAnyCall( Metadata._Enumerable.ToArray1Method.MakeGenericMethod( traits.ElementType ) );
il.EmitAnyStloc( array );
var length = localHolder.PackingCollectionCount;
il.EmitAnyLdloc( array );
il.EmitLdlen();
il.EmitAnyStloc( length );
il.EmitAnyLdarg( 1 );
il.EmitAnyLdloc( length );
il.EmitAnyCall( Metadata._Packer.PackArrayHeader );
il.EmitPop();
Emittion.EmitFor(
il,
length,
( il0, i ) =>
Emittion.EmitSerializeValue(
emitter,
il0,
1,
traits.ElementType,
null,
NilImplication.MemberDefault,
il1 =>
{
il1.EmitAnyLdloc( array );
il1.EmitAnyLdloc( i );
il1.EmitLdelem( traits.ElementType );
},
localHolder
)
);
}
else
{
/*
* // Enumerable
* packer.PackArrayHeader( collection.Count );
* foreach( var item in list )
* {
* this._serializer.PackTo( packer, array[ i ] );
* }
*/
var collection = localHolder.GetSerializingCollection( targetType );
// This instruction always ldarg, not to be ldarga
il.EmitAnyLdarg( 2 );
il.EmitAnyStloc( collection );
var count = localHolder.PackingCollectionCount;
EmitLoadTarget( targetType, il, 2 );
il.EmitGetProperty( traits.CountProperty );
il.EmitAnyStloc( count );
il.EmitAnyLdarg( 1 );
il.EmitAnyLdloc( count );
il.EmitAnyCall( Metadata._Packer.PackArrayHeader );
il.EmitPop();
Emittion.EmitForEach(
il,
traits,
collection,
( il0, getCurrentEmitter ) =>
Emittion.EmitSerializeValue(
emitter,
il0,
1,
traits.ElementType,
null,
NilImplication.MemberDefault,
_ => getCurrentEmitter(),
localHolder
)
);
}
il.EmitRet();
}
finally
{
il.FlushTrace();
}
}
private static void CreateMapPack(Type targetType, SerializerEmitter emiter, CollectionTraits traits)
{
TracingILGenerator packToMethodILGenerator = emiter.GetPackToMethodILGenerator();
LocalVariableHolder localHolder = new LocalVariableHolder(packToMethodILGenerator);
try
{
< > c__DisplayClass20 class3;
LocalBuilder serializingCollection = localHolder.GetSerializingCollection(targetType);
LocalBuilder item = localHolder.GetSerializingCollectionItem(traits.ElementType);
PropertyInfo keyProperty = traits.ElementType.GetProperty("Key");
PropertyInfo valueProperty = traits.ElementType.GetProperty("Value");
packToMethodILGenerator.EmitAnyLdarg(2);
packToMethodILGenerator.EmitAnyStloc(serializingCollection);
LocalBuilder packingCollectionCount = localHolder.PackingCollectionCount;
EmitLoadTarget(targetType, packToMethodILGenerator, serializingCollection);
packToMethodILGenerator.EmitGetProperty(traits.CountProperty);
packToMethodILGenerator.EmitAnyStloc(packingCollectionCount);
packToMethodILGenerator.EmitAnyLdarg(1);
packToMethodILGenerator.EmitAnyLdloc(packingCollectionCount);
packToMethodILGenerator.EmitAnyCall(_Packer.PackMapHeader);
packToMethodILGenerator.EmitPop();
Emittion.EmitForEach(packToMethodILGenerator, traits, serializingCollection, delegate(TracingILGenerator il0, Action getCurrentEmitter) {
Action <TracingILGenerator> loadValueEmitter = null;
Action <TracingILGenerator> action2 = null;
Action <TracingILGenerator> action3 = null;
Action <TracingILGenerator> action4 = null;
< > c__DisplayClass20 class1 = class3;
if (traits.ElementType.IsGenericType)
{
Contract.Assert(traits.ElementType.GetGenericTypeDefinition() == typeof(KeyValuePair <,>));
getCurrentEmitter();
il0.EmitAnyStloc(item);
if (loadValueEmitter == null)
{
loadValueEmitter = delegate(TracingILGenerator il1) {
il1.EmitAnyLdloca(item);
il1.EmitGetProperty(keyProperty);
};
}
Emittion.EmitSerializeValue(emiter, il0, 1, traits.ElementType.GetGenericArguments()[0], null, NilImplication.MemberDefault, loadValueEmitter, localHolder);
if (action2 == null)
{
action2 = delegate(TracingILGenerator il1) {
il1.EmitAnyLdloca(item);
il1.EmitGetProperty(valueProperty);
};
}
Emittion.EmitSerializeValue(emiter, il0, 1, traits.ElementType.GetGenericArguments()[1], null, NilImplication.MemberDefault, action2, localHolder);
}
else
{
Contract.Assert(traits.ElementType == typeof(DictionaryEntry));
getCurrentEmitter();
il0.EmitAnyStloc(item);
if (action3 == null)
{
action3 = delegate(TracingILGenerator il1) {
il0.EmitAnyLdloca(item);
il0.EmitGetProperty(_DictionaryEntry.Key);
il0.EmitUnbox_Any(typeof(MessagePackObject));
};
}
Emittion.EmitSerializeValue(emiter, il0, 1, typeof(MessagePackObject), null, NilImplication.MemberDefault, action3, localHolder);
if (action4 == null)
{
action4 = delegate(TracingILGenerator il1) {
il0.EmitAnyLdloca(item);
il0.EmitGetProperty(_DictionaryEntry.Value);
il0.EmitUnbox_Any(typeof(MessagePackObject));
};
}
Emittion.EmitSerializeValue(emiter, il0, 1, typeof(MessagePackObject), null, NilImplication.MemberDefault, action4, localHolder);
}
});
