System.Reflection.Emitを使用したコンパクトキャッシュシリアライザー

キャッシュのない最新のサービスでは、どこにもありません。永続データベース内のデータへのアクセスは長くて費用のかかるビジネスなので、最も頻繁に使用されるデータに中間ストレージを追加すると、速度が大幅に向上します。 情報は、ライン、リスト、セッション状態など、さまざまな方法でさまざまな形式でキャッシュに保持できます。 この記事では、ネストされたクラスと循環参照を持たない「フラット」オブジェクトをキャッシュに保存する方法の1つについて説明します。

フラットオブジェクトのカスタムシリアル化

Microsoft AzureのRedis Cacheなどのキャッシュは、少なくともStackExchange.Redisクライアントライブラリの一部として、組み込みのオブジェクトシリアル化を提供しません。 キャッシュは、特定のキーの下に任意のバイトシーケンスを保存できるメソッドを提供します。ユーザーは、保存されたオブジェクトからバイトを取得する方法を選択できます。 可能なオプションの1つは標準の.Net BinaryFormatterですが、それだけではなく、キャッシュに多くのオブジェクトを格納するサービスに適切なシリアル化方法を選択すると、パフォーマンスにプラスの影響があります。

この記事で説明するシリアル化のアプローチは、次のシステムの前提に基づいています。

• キャッシュの容量は制限されており、永続的なストレージよりもコストがかかります。 Microsoft Azureでは、利用可能な制限が大きいキャッシュは多額の支払いが予想されます。
• シリアル化された表現の大量のバイトは、書き込み/読み取りのコストだけでなく、ネットワークを介したデータの転送のためにも、キャッシュの相互作用時間に悪影響を及ぼします。
• シリアライズ可能なオブジェクトの構成は時間的に安定しており、サービスとキャッシュの所有者の完全な制御下にあります。 外部からのシリアル化されたデータを使用する場合があるため、フィールドの予期しない外観、削除、または並べ替えは発生しません。
• キャッシュは最適化ツールであり、オブジェクトの一時的なストレージです。 デシリアライゼーションに矛盾または問題がある場合、キャッシュから古いオブジェクトを削除して新しいオブジェクトと置き換えることは大きな問題ではありません。

このような背景に対して、BinaryFormatterを含むすべての通常のシリアライザーによって保存されたフィールド、クラス、およびアセンブリに関するメタデータのシリアル化された表現から除外するため、かなりのバイトを節約することは魅力的なアイデアのようです。 最後に、所有者がフィールドの構成についてすべてを知っている場合、たとえば、単に特定の順序で行をフォーマットして、構成に明らかにない文字でそれらを分離することを防ぐのは何ですか？

"7c9e6679-7425-40de-944b-e07fc1f90ae7|48972|Alice in Wonderland" 

このアプローチにはある程度の精度が必要ですが、有害とは言えません。
さらに進んだ場合、セパレータなしで、文字列にフォーマットせずに行うことができます：任意のタイプはメモリ内でバイトのシーケンスとして表され、プロパティのタイプを知っている場合、必要な長さのバイトの配列を読み書きし、/から変換することができます目的のタイプの値。 文字列や配列など、長さが固定されていない型の場合、シリアル化された値の前に含まれるバイト数/要素数を指定できます。 カスタムクラスまたは構造のタイプを持つプロパティを使用すると、特に循環リンクを追跡する必要がある場合、状況はより複雑になります。この単純なケースでは、それらはまだ考慮されていません。 （ただし、これは、これが原則的に実現不可能であることを意味するものではありません）。

キャッシュに多数のフィールドを持つ多数のオブジェクトを格納する場合、記述された原則に従ってシリアル化のためのコードを書くのは退屈で、エラーがたくさんあります。 オブジェクト全体を保存する必要がある場合、そのような操作はSystem.Reflection名前空間を使用して簡単に自動化できます。

 public override void Serialize(TObject theObject, Stream stream) { foreach (var property in _properties) { var val = property.GetValue(theObject); if (property.PropertyType == typeof(byte)) { stream.WriteByte((byte)val); } else if (property.PropertyType == typeof(bool)) { var bytes = BitConverter.GetBytes((bool)val); stream.Write(bytes, 0, bytes.Length); } else if (property.PropertyType == typeof(int)) { var bytes = BitConverter.GetBytes((int)val); stream.Write(bytes, 0, bytes.Length); } else if (property.PropertyType == typeof(Guid)) { var bytes = ((Guid)val).ToByteArray(); stream.Write(bytes, 0, bytes.Length); } ... } } public override TObject Deserialize(Stream stream) { var theObject = Activator.CreateInstance<TObject>(); foreach (var property in _properties) { object val; if (property.PropertyType == typeof(byte)) { val = stream.ReadByte(); } var bytesCount = TypesInfo.GetBytesCount(type); var valueBytes = new byte[bytesCount]; stream.Read(valueBytes, 0, valueBytes.Length); if (property.PropertyType == typeof(bool)) { val = BitConverter.ToBoolean(valueBytes, 0); } else if (property.PropertyType == typeof(int)) { val = BitConverter.ToInt32(valueBytes, 0); } else if (property.PropertyType == typeof(Guid)) { val = new Guid(valueBytes); } ... property.SetValue(theObject, val); } } 

オブジェクトのプロパティの構成とその変更

MSDN は 、アルファベット順または宣言順でType.GetProperties（）メソッドによるプロパティの戻り値を保証しないという事実にもかかわらず、返される配列が同じオブジェクト型の同じバージョンでの呼び出しと異なると信じる理由はありません。 信頼性を高めるために、このメソッドを1回呼び出して、結果のプロパティの配列をプライベートフィールドに保存し、シリアル化操作と逆シリアル化操作の両方でさらに使用できます。 キャッシュは通常、長時間ノンストップで実行されるシステムで使用され、一度シリアライズ可能タイプのプロパティの初期化リストを使用してシリアライザーが作成されると、長時間存在します。 これが不十分だと思われる場合は、サービスの再起動時に再初期化してこのリストをディスクに追加保存することも可能ですが、これは不必要な予防策のようです。

それでも、プロパティの構成、名前、タイプ、または相対的な場所を変更すると、古いバージョンを正しくデシリアライズできなくなります。 ただし、説明されているアイデアは永続的なデータベースではなくキャッシュにデータを格納することを目的としているため、矛盾に対処する最も簡単な方法は、古いバイト表現を無効にし、新しくシリアル化されたオブジェクトに置き換えることです。 より複雑なアプローチも可能です。たとえば、別のAppDomainを使用して、古いバージョンのタイプをロードし、オブジェクトをデシリアライズし、新しいオブジェクトのプロパティを入力し、同じキーでシリアル化して保存します。 ただし、この記事では、これを達成する試みは行われていません。

いずれの場合でも、オブジェクトのタイプの変更を追跡するには、シリアル化プロセスにバージョン管理のオプションを含める必要があります。 たとえば、オブジェクト自体のバイトの前に、オブジェクトが宣言されているアセンブリバージョンを記述できます。

 public virtual string GetTypeVersion() { return typeof(TObject).Assembly.GetName().Version.ToString(); } 

 var reflectionSerializer = new ReflectionCompactSerializer<Entity>(); typeVersion = reflectionSerializer.GetTypeVersion(); reflectionSerializer.WriteVersion(stream, typeVersion); reflectionSerializer.Serialize(originalEntity, stream); var version = reflectionSerializer.ReadObjectVersion(stream); deserializedEntity = reflectionSerializer.Deserialize(stream); 

メモリに結果を保存してGetProperties（）メソッドが1回だけ呼び出される多くの異なるオブジェクトをシリアル化する場合、オブジェクトのタイプと取得したプロパティリストを何らかの方法で比較する必要があります。 これを行うには、ディクショナリのType→PropertyInfo []を使用するか、Genericsを使用してシリアル化可能な各タイプに特化したシリアライザーを選択します。 2番目のアプローチは主観的により便利に見えます。

 public class ReflectionCompactSerializer<TObject> : CompactSerializerBase<TObject> where TObject: class, new () { private readonly PropertyInfo[] _properties = typeof(TObject).GetProperties(BindingFlags.Instance | BindingFlags.Public); ... } 

より生産的なアプローチ

このタスクのコンテキストでReflectionを使用するときに発生する次の問題は、パフォーマンスです。リフレクションは高速メカニズムとは見なされませんでした。 Sasha Goldshtein、Dima Zurbalev、Ido Flatowなどの.Netアプリケーションの最適化に関する書籍では、 「Pro .Net Performance：Optimize Your C＃Applications」およびBen Watson 「Writing High-Performance .NET Code」の 1つとして、コードを生成するために、たとえば名前空間System.Reflection.Emitを使用して、リフレクションとカスタムシリアライザーの作成が提案されています。 このアプローチのアイデアは、プロパティの結果リストからコードをすぐに作成することです。つまり、各プロパティの値を交互に受け取り、バイトストリームに書き込み、読み取り、変換、値の設定などを行う一連の命令です。

System.Reflection.Emit名前空間のILGeneratorクラスには、DynamicMethodクラスを使用して実行時にコンパイルできるMSIL中間言語命令を作成できる多数のメソッドが含まれています。 一般的には、次のようになります。

 public static EmitSerializer<TObject> Generate<TObject>() where TObject : class, new() { var propertiesWriter = new DynamicMethod( "WriteProperties", null, new Type[] { typeof(Stream), typeof(TObject) }, typeof(EmitSerializer<TObject>)); var writerIlGenerator = propertiesWriter.GetILGenerator(); var writerEmitter = new CodeEmitter(writerIlGenerator); var propertiesReader = new DynamicMethod( "ReadProperties", null, new Type[] { typeof(Stream), typeof(TObject) }, typeof(EmitSerializer<TObject>)); var readerIlGenerator = propertiesReader.GetILGenerator(); var readerEmitter = new CodeEmitter(readerIlGenerator); var properties = typeof(TObject) .GetProperties(BindingFlags.Instance | BindingFlags.Public); foreach(var property in properties) { if (property.PropertyType == typeof(byte)) { writerEmitter.EmitWriteBytePropertyCode(property); readerEmitter.EmitReadBytePropertyCode(property); } else if (property.PropertyType == typeof(Guid)) { writerEmitter.EmitWriteGuidPropertyCode(property); readerEmitter.EmitReadGuidPropertyCode(property); } … } var writePropertiesDelegate = (Action<Stream,TObject>)propertiesWriter .CreateDelegate(typeof(Action<Stream, TObject>)); var readPropertiesDelegate = (Action<Stream, TObject>)propertiesReader .CreateDelegate(typeof(Action<Stream, TObject>)); return new EmitSerializer<TObject>( writePropertiesDelegate, readPropertiesDelegate); } } 

もちろん、「共通の機能」を超えて、最も難しくて興味深い部分は、EmitWriteNNNPropertyCode / EmitReadNNNPropertyCodeメソッドの実装です。

MSILは「高レベルのアセンブラ」であり、ILGenerator.Emit（OpCode）メソッドを呼び出して、特に間接的な方法で書き込むことはできず、コードの読み取りが難しい場合があります。

上記の本のいずれかで与えられたトリックはここで役立ちます：ILコード全体を最初から書く必要はありません。 C＃で「ワーク」を作成し、それを使用してアセンブリを作成し、ILでそれを逆アセンブルし、結果のリファレンス実装を見て、ニーズに応じて一般化することは非常に可能です。

Windowsが.NetアセンブリからILコードを取得できる逆アセンブラーが多数あります：ildasm、dotPeek、ILSpyなど。しかし、MicrosoftのOSで起動されたこのプロジェクトはすでにLinuxで書かれていました（良いです。 NET Coreは可能です）、逆アセンブラの選択はそれほど大きくありません。 ただし、このオペレーティングシステムでは、特にmonodisのツールを使用できます。 次のコマンドでmonodisを使用して、dllアセンブリからILのテキストファイルとソースコードを取得できます。

 monodis <  > --output=<   > 

最も単純な型の一般的なシリアル化

生成されたシリアライザーによって実行されるすべてのアクションは、元のリフレクションシリアライザーの操作に似ており、一見すると思われるよりも、Emitを介して簡単に繰り返すことができます。 たとえば、int型のプロパティの値を受け取り、そのバイトをストリームに書き込む「ワークピース」は次のようになります。

 private static void WritePrimitiveTypeProperty(Stream stream, Entity entity) { var index = entity.Index; var valueBytes = BitConverter.GetBytes(index); stream.Write(valueBytes, 0, valueBytes.Length); } 

アセンブリおよび逆コンパイル後、対応するILコードには次の指示が含まれます。

 .method private static hidebysig default void WritePrimitiveTypeProperty (class [mscorlib]System.IO.Stream 'stream', class SourcesForIL.Entity entity) cil managed { // Method begins at RVA 0x241c // Code size 28 (0x1c) .maxstack 4 .locals init ( int32 V_0, unsigned int8[] V_1) IL_0000: nop IL_0001: ldarg.1 IL_0002: callvirt instance int32 class SourcesForIL.Entity::get_Index() IL_0007: stloc.0 IL_0008: ldloc.0 IL_0009: call unsigned int8[] class [mscorlib]System.BitConverter::GetBytes(int32) IL_000e: stloc.1 IL_000f: ldarg.0 IL_0010: ldloc.1 IL_0011: ldc.i4.0 IL_0012: ldloc.1 IL_0013: ldlen IL_0014: conv.i4 IL_0015: callvirt instance void class [mscorlib]System.IO.Stream::Write(unsigned int8[], int32, int32) IL_001a: nop IL_001b: ret } 

また、名前空間Reflection.Emitを使用してそれを繰り返すコードは、ILGeneratorメソッドの次のシーケンスを呼び出します。

 var byteArray = _ilGenerator.DeclareLocal(typeof(byte[])); // load object under serialization onto the evaluation stack _ilGenerator.Emit(OpCodes.Ldarg_1); // get property value _ilGenerator.EmitCall(OpCodes.Callvirt, property.GetMethod, null); // get value's representation in bytes _ilGenerator.EmitCall(OpCodes.Call, BitConverterMethodsInfo.ChooseGetBytesOverloadByType(valueType), null); // save the bytes array from the stack in local variable _ilGenerator.Emit(OpCodes.Stloc, byteArray); // load stream parameter onto the evaluation stack _ilGenerator.Emit(OpCodes.Ldarg_0); // load bytesCount array _ilGenerator.Emit(OpCodes.Ldloc_S, bytesArray); // load offset parameter == 0 onto the stack _ilGenerator.Emit(OpCodes.Ldc_I4_0); // load bytesCount array _ilGenerator.Emit(OpCodes.Ldloc_S, bytesArray); // calculate the array length _ilGenerator.Emit(OpCodes.Ldlen); // convert it to Int32 _ilGenerator.Emit(OpCodes.Conv_I4); // write array to stream _ilGenerator.EmitCall(OpCodes.Callvirt, StreamMethodsInfo.Write, null); 

プロパティの値の取得は、property.GetMethodを使用してすべてのタイプで同じであることに注意してください。 同様に、この値のバイト配列への変換は簡単に一般化できます。MethodInfo型の適切な引数を使用するだけです。 したがって、同じジェネレーター関数は、渡されたバイトの配列を取得する方法に応じて、異なるタイプのプロパティをシリアル化するコードを作成できます。
System.BitConverterクラスには、いくつかの組み込み型のいくつかのオーバーロードされたGetBytesメソッドが含まれています。これらすべての型に対して、BitConverterMethodsInfo.ChooseGetBytesOverloadByType（valueType）で必要なMethodInfoオプションを選択することで、シリアル化操作を同じ方法で実行できます。

Reflectionを使用して、対応するメソッドのMedodInfoオブジェクトを再度取得する必要があります。これらのメソッドにすばやくアクセスするには、静的辞書に保存するのが理にかなっています。

 public static MethodInfo ChooseGetBytesOverloadByType(Type type) { if (_getBytesMethods.ContainsKey(type)) { return _getBytesMethods[type]; } var method = typeof(BitConverter).GetMethod("GetBytes", new Type[] { type }); if (method == null) { throw new InvalidOperationException("No overload for parameter of type " + type.Name); } _getBytesMethods[type] = method; return method; } 

上記のコードを使用すると、bool、short、int、long、ushort、uint、ulong、double、float、charなどのいくつかのシステムタイプのコードを生成できます。

10進数、GUID、およびバイトのシリアル化

10進数型はプリミティブ型のリストから選択されますが、System.BitConverterにバイトの配列を取得するための組み込みメソッドはありません。 したがって、変換メソッドは個別に実装する必要があります。

 public static byte[] GetDecimalBytes(decimal value) { var bits = decimal.GetBits((decimal)value); var bytes = new List<byte>(); foreach (var bitsPart in bits) { bytes.AddRange(BitConverter.GetBytes(bitsPart)); } return bytes.ToArray(); } public static decimal BytesToDecimal(byte[] bytes, int startIndex) { var valueBytes = bytes.Skip(startIndex).ToArray(); if (valueBytes.Length != 16) throw new Exception("A decimal must be created from exactly 16 bytes"); var bits = new Int32[4]; for (var bitsPart = 0; bitsPart <= 15; bitsPart += 4) { bits[bitsPart/4] = BitConverter.ToInt32(valueBytes, bitsPart); } return new decimal(bits); } 

Guidタイプの場合、BitConverter.GetBytesメソッドのオーバーロードもありませんが、そのバイト表現の取得は簡単です-Guid.ToByteArrayメソッドを使用します。 GUIDには、バイト配列から値を復元するコンストラクターがあります。

 private static void WriteGuidProperty(Stream stream, Entity entity) { var id = entity.Id; var valueBytes = id.ToByteArray(); stream.Write(valueBytes, 0, valueBytes.Length); } private static void ReadGuidProperty(Stream stream, Entity entity) { var valueBytes = new byte[16]; stream.Read(valueBytes, 0, valueBytes.Length); entity.Id = new Guid(valueBytes); } 

バイトを使用すると、非常に簡単になります。Streamクラスには、1バイトを読み書きするための特別なメソッドがあります。

日付と時刻のシリアル化

DateTime型とDateTimeOffset型では、時間値だけでなく、それぞれKindフィールドとOffsetフィールドによっても決定されるため、事態はもう少し複雑です。 これらのフィールドは、時間自体と一緒に読み書きする必要があります。 たとえば、DateTimeOffset変数の値を格納するILコードの生成は次のようになります。

 private void EmitWriteDateTimeOffsetVariable(LocalBuilder dateTimeOffset) { var offset = _ilGenerator.DeclareLocal(typeof(TimeSpan)); var dateTimeTicks = _ilGenerator.DeclareLocal(typeof(long)); var dateTimeTicksByteArray = _ilGenerator.DeclareLocal(typeof(byte[])); var offsetTicksByteArray = _ilGenerator.DeclareLocal(typeof(byte[])); // load the variable address to the stack _ilGenerator.Emit(OpCodes.Ldloca_S, dateTimeOffset); // call method to get Offset property _ilGenerator.EmitCall(OpCodes.Call, DateTimeOffsetMembersInfo.OffsetProperty, null); // save it to local variable _ilGenerator.Emit(OpCodes.Stloc, offset); // load the variable address to the stack _ilGenerator.Emit(OpCodes.Ldloca_S, offset); // call method to get offset Ticks property _ilGenerator.EmitCall(OpCodes.Call, TimeSpanMembersInfo.TicksProperty, null); // convert it to byte array _ilGenerator.EmitCall(OpCodes.Call, GetInt64BytesMethodInfo, null); // save it to local variable _ilGenerator.Emit(OpCodes.Stloc, offsetTicksByteArray); EmitWriteBytesArrayToStream(offsetTicksByteArray); // load the dateTimeOffset variable address to the stack _ilGenerator.Emit(OpCodes.Ldloca_S, dateTimeOffset); // call method to get Ticks property _ilGenerator.EmitCall(OpCodes.Call, DateTimeOffsetMembersInfo.TicksProperty, null); // save it to local variable _ilGenerator.Emit(OpCodes.Stloc, dateTimeTicks); // load the variable address to the stack _ilGenerator.Emit(OpCodes.Ldloc, dateTimeTicks); // convert it to byte array _ilGenerator.EmitCall(OpCodes.Call, GetInt64BytesMethodInfo, null); // save it to local variable _ilGenerator.Emit(OpCodes.Stloc, dateTimeTicksByteArray); EmitWriteBytesArrayToStream(dateTimeTicksByteArray); } 

バイト単位での型の長さの決定

上記のすべての型の逆シリアル化は対称的ですが、対応するバイト配列を読み取るには、その長さを知る必要があります。 実行時に、プロパティタイプはTypeクラスの値として使用可能であり、sizeof操作を適用できません。 Marshal.SizeOfメソッドが役に立ちますが、これはすべてのタイプに適用できるわけではなく、カスタム保存の実装によって書き込まれたバイト数を返しません。 ただし、それらの場合は、単純に明示的にサイズを返すことができます。

 public static int GetBytesCount(Type propertyType) { if (propertyType == typeof(DateTime)) { return sizeof(long) + 1; } else if (propertyType == typeof(DateTimeOffset)) { return sizeof(long) + sizeof(long); } else if (propertyType == typeof(bool)) { return sizeof(bool); } else if(propertyType == typeof(char)) { return sizeof(char); } else if (propertyType == typeof(decimal)) { return 16; } else { return Marshal.SizeOf(propertyType); } } 

シリアル化Nullable <T>

Nullable <>をシリアル化する場合、最初にプロパティにnullが含まれるかどうかを判断するフラグを書き込み、値が空でない場合にのみ、既に実装されているメソッドを使用して値自体を書き込みます。

 public void EmitWriteNullablePropertyCode(PropertyInfo property) { var nullableValue = _ilGenerator.DeclareLocal(property.PropertyType); var isNull = _ilGenerator.DeclareLocal(typeof(bool)); var isNullByte = _ilGenerator.DeclareLocal(typeof(byte)); var underlyingType = property.PropertyType.GetGenericArguments().Single(); var value = _ilGenerator.DeclareLocal(underlyingType); var valueBytes = _ilGenerator.DeclareLocal(typeof(byte[])); var nullableInfo = NullableInfo.GetNullableInfo(underlyingType); var nullFlagBranch = _ilGenerator.DefineLabel(); var byteFlagLabel = _ilGenerator.DefineLabel(); var noValueLabel = _ilGenerator.DefineLabel(); EmitLoadPropertyValueToStack(property); // save nullable value to local variable _ilGenerator.Emit(OpCodes.Stloc, nullableValue); // load address of the variable to stack _ilGenerator.Emit(OpCodes.Ldloca_S, nullableValue); // get HasValue property _ilGenerator.EmitCall(OpCodes.Call, nullableInfo.HasValueProperty, null); // load value '0' to stack _ilGenerator.Emit(OpCodes.Ldc_I4_0); // compare _ilGenerator.Emit(OpCodes.Ceq); // save to local boolean variable _ilGenerator.Emit(OpCodes.Stloc, isNull); // load to stack _ilGenerator.Emit(OpCodes.Ldloc, isNull); // jump to isNull branch, if needed _ilGenerator.Emit(OpCodes.Brtrue_S, nullFlagBranch); // load value '0' to stack _ilGenerator.Emit(OpCodes.Ldc_I4_0); // jump to byteFlagLabel _ilGenerator.Emit(OpCodes.Br_S, byteFlagLabel); _ilGenerator.MarkLabel(nullFlagBranch); // load value '1' to stack _ilGenerator.Emit(OpCodes.Ldc_I4_1); _ilGenerator.MarkLabel(byteFlagLabel); // convert to byte _ilGenerator.Emit(OpCodes.Conv_U1); // save to local variable _ilGenerator.Emit(OpCodes.Stloc, isNullByte); // load stream parameter to stack _ilGenerator.Emit(OpCodes.Ldarg_0); // load byte flag to the stack _ilGenerator.Emit(OpCodes.Ldloc, isNullByte); // write it to the stream _ilGenerator.EmitCall(OpCodes.Callvirt, StreamMethodsInfo.WriteByte, null); // load isNull flag to stack _ilGenerator.Emit(OpCodes.Ldloc, isNull); // load value '0' _ilGenerator.Emit(OpCodes.Ldc_I4_0); // compare _ilGenerator.Emit(OpCodes.Ceq); // jump to tne end, if no value presented _ilGenerator.Emit(OpCodes.Brfalse_S, noValueLabel); // load the address of the nullable to the stack _ilGenerator.Emit(OpCodes.Ldloca_S, nullableValue); // get actual value _ilGenerator.EmitCall(OpCodes.Call, nullableInfo.ValueProperty, null); EmitWriteValueFromStackToStream(underlyingType); _ilGenerator.MarkLabel(noValueLabel); } 

文字列処理

文字列型の値のサイズは固定されておらず、格納されているバイト数は事前にわかりません。 ただし、特定の文字列の長さは、それを構成するバイトを書き込む前にストリームに保存できます。 逆シリアル化する場合、まず文字列の長さを持つintを含むバイトの配列を読み取り、この長さの値を取得してから、対応するバイト数を読み取ることができます。 NULL文字列の場合、値「-1」を書き込むと、長さ0の空の文字列と区別できます。

Encoding.GetBytes / Encoding.GetStringメソッドを使用すると、文字列をバイト配列に変換したり、バイト配列から簡単に変換したりできます。 変更については、レコードではなく、ストリームから文字列を読み取る方法があります。

 private void EmitReadStringFromStreamToStack() { var bytesCoutArray = _ilGenerator.DeclareLocal(typeof(byte[])); var stringBytesCount = _ilGenerator.DeclareLocal(typeof(int)); var stringBytesArray = _ilGenerator.DeclareLocal(typeof(byte[])); var isNull = _ilGenerator.DeclareLocal(typeof(bool)); var isNotNullBranch = _ilGenerator.DefineLabel(); var endOfReadLabel = _ilGenerator.DefineLabel(); var propertyBytesCount = TypesInfo.GetBytesCount(typeof(int)); // push the amout of bytes to read onto the stack _ilGenerator.Emit(OpCodes.Ldc_I4, propertyBytesCount); // allocate array to store bytes _ilGenerator.Emit(OpCodes.Newarr, typeof(byte)); // stores the allocated array in the local variable _ilGenerator.Emit(OpCodes.Stloc, bytesCoutArray); // push the stream parameter _ilGenerator.Emit(OpCodes.Ldarg_0); // push the byte count array _ilGenerator.Emit(OpCodes.Ldloc, bytesCoutArray); // push '0' as the offset parameter _ilGenerator.Emit(OpCodes.Ldc_I4_0); // push the byte array again - to calculate its length _ilGenerator.Emit(OpCodes.Ldloc, bytesCoutArray); // get the length _ilGenerator.Emit(OpCodes.Ldlen); // convert the result to Int32 _ilGenerator.Emit(OpCodes.Conv_I4); // call the stream.Read method _ilGenerator.EmitCall(OpCodes.Callvirt, StreamMethodsInfo.Read, null); // pop amount of bytes read _ilGenerator.Emit(OpCodes.Pop); // push the bytes count array _ilGenerator.Emit(OpCodes.Ldloc, bytesCoutArray); // push '0' as the start index parameter _ilGenerator.Emit(OpCodes.Ldc_I4_0); // convert the bytes to Int32 _ilGenerator.EmitCall(OpCodes.Call, BytesToInt32MethodInfo, null); // save bytes count to local variable _ilGenerator.Emit(OpCodes.Stloc, stringBytesCount); // load it to the stack _ilGenerator.Emit(OpCodes.Ldloc, stringBytesCount); // put value '-1' to the stack _ilGenerator.Emit(OpCodes.Ldc_I4_M1); // compare bytes count and -1 _ilGenerator.Emit(OpCodes.Ceq); // save to boolean variable _ilGenerator.Emit(OpCodes.Stloc, isNull); // load to stack _ilGenerator.Emit(OpCodes.Ldloc, isNull); // if false, jump to isNotNullBranch _ilGenerator.Emit(OpCodes.Brfalse_S, isNotNullBranch); // push 'null' value _ilGenerator.Emit(OpCodes.Ldnull); // jump to the end of read fragment _ilGenerator.Emit(OpCodes.Br_S, endOfReadLabel); // not null string value branch _ilGenerator.MarkLabel(isNotNullBranch); // load bytes count to the stack _ilGenerator.Emit(OpCodes.Ldloc, stringBytesCount); // allocate array to store bytes _ilGenerator.Emit(OpCodes.Newarr, typeof(byte)); // save it to local variable _ilGenerator.Emit(OpCodes.Stloc, stringBytesArray); // push the stream parameter _ilGenerator.Emit(OpCodes.Ldarg_0); // load string bytes array to stack _ilGenerator.Emit(OpCodes.Ldloc, stringBytesArray); // push '0' as the start index parameter _ilGenerator.Emit(OpCodes.Ldc_I4_0); // load string bytes array to stack to get array length _ilGenerator.Emit(OpCodes.Ldloc, stringBytesArray); // get the length _ilGenerator.Emit(OpCodes.Ldlen); // convert the result to Int32 _ilGenerator.Emit(OpCodes.Conv_I4); // call the stream.Read method _ilGenerator.EmitCall(OpCodes.Callvirt, StreamMethodsInfo.Read, null); // pop amount of bytes read _ilGenerator.Emit(OpCodes.Pop); // load Encoding to stack _ilGenerator.EmitCall(OpCodes.Call, EncodingMembersInfo.EncodingGetter, null); // load string bytes _ilGenerator.Emit(OpCodes.Ldloc, stringBytesArray); // call Encoding.GetString() method _ilGenerator.EmitCall(OpCodes.Callvirt, EncodingMembersInfo.GetStringMethod, null); _ilGenerator.MarkLabel(endOfReadLabel); } 

配列とコレクションを操作する

配列のシリアル化には、文字列の操作に似たアプローチを使用できます。まず、その長さを書き込み（読み取り）、次に適切な反復回数のループで、上記で実装した単一の値を処理する方法の1つ1つで各要素を書き込みます（読み取り）。

 public void EmitReadArrayPropertyCode(PropertyInfo property) { var elementType = property.PropertyType.GetElementType(); var elementBytesArray = _ilGenerator.DeclareLocal(typeof(byte[])); var lengthBytes = _ilGenerator.DeclareLocal(typeof(byte[])); var arrayLength = _ilGenerator.DeclareLocal(typeof(int)); var array = _ilGenerator.DeclareLocal(property.PropertyType); var element = _ilGenerator.DeclareLocal(elementType); var index = _ilGenerator.DeclareLocal(typeof(int)); var isNullArrayLabel = _ilGenerator.DefineLabel(); var setPropertyLabel = _ilGenerator.DefineLabel(); var loopConditionLabel = _ilGenerator.DefineLabel(); var loopIterationLabel = _ilGenerator.DefineLabel(); // push deserialized object to stack _ilGenerator.Emit(OpCodes.Ldarg_1); EmitAllocateBytesArrayForType(typeof(int), lengthBytes); EmitReadByteArrayFromStream(lengthBytes); EmitConvertBytesArrayToPrimitiveValueOnStack(lengthBytes, typeof(int)); // save it to local variable _ilGenerator.Emit(OpCodes.Stloc, arrayLength); EmitJumpIfNoElements(arrayLength, isNullArrayLabel); // push array length to stack _ilGenerator.Emit(OpCodes.Ldloc, arrayLength); // create new array _ilGenerator.Emit(OpCodes.Newarr, elementType); // save it to the local variable _ilGenerator.Emit(OpCodes.Stloc, array); EmitZeroIndex(index); if (elementType != typeof(string)) { EmitAllocateBytesArrayForType(elementType, elementBytesArray); } // jump to the loop condition check _ilGenerator.Emit(OpCodes.Br_S, loopConditionLabel); _ilGenerator.MarkLabel(loopIterationLabel); if (elementType == typeof(string)) { EmitReadStringFromStreamToStack(); } else { EmitReadValueFromStreamToStack(elementType, elementBytesArray); } // save to local variable _ilGenerator.Emit(OpCodes.Stloc, element); // load array instance to stack _ilGenerator.Emit(OpCodes.Ldloc, array); // load element index _ilGenerator.Emit(OpCodes.Ldloc_S, index); // load the element to stack _ilGenerator.Emit(OpCodes.Ldloc_S, element); // set element to the array _ilGenerator.Emit(OpCodes.Stelem, elementType); EmitIndexIncrement(index); _ilGenerator.MarkLabel(loopConditionLabel); EmitIndexIsLessCheck(index, arrayLength); // jump to the iteration if true _ilGenerator.Emit(OpCodes.Brtrue_S, loopIterationLabel); // push filled array to stack _ilGenerator.Emit(OpCodes.Ldloc, array); // jump to SetProperty label _ilGenerator.Emit(OpCodes.Br_S, setPropertyLabel); _ilGenerator.MarkLabel(isNullArrayLabel); _ilGenerator.Emit(OpCodes.Ldnull); _ilGenerator.MarkLabel(setPropertyLabel); // call object's property setter _ilGenerator.EmitCall(OpCodes.Callvirt, property.SetMethod, null); } 

配列に加えて、プロジェクトは汎用コレクションも実装します。リスト<>リストでテストが実行されましたが、コードは、次の条件を満たす場合にコレクションプロパティが処理されるように設計されています。

• パラメーターなしのパブリックコンストラクターがあります。
• ICollection <T>インターフェイスを実装します。
• Tは、前述の単純型です。

コレクションのシリアル化とシリアル化解除は、配列と同様の方法で実装され、ICollection <>インターフェイスの実装により、また受信したEnumerator-aのMoveNextおよびCurrentの呼び出しにより利用可能なAdd、Count、GetEnumeratorメソッドおよびプロパティの使用に合わせて調整されます。

テスト、比較、結論

この調査は、結果のシリアライザーを標準オプションと比較しないと完了しません。賞金を評価するために、前述のBinaryFormatterとNewtonsoft JsonSerializerが最も一般的なライブラリ実装の1つとして選ばれました。 Xmlシリアル化は、明らかに「冗長」であるため、考慮されませんでした。この比較は、シリアル化/逆シリアル化時の平均1000回の試行と、シリアル化された表現のサイズ（バイト単位）に基づいています。実験のオブジェクトには、上記のすべてのタイプのプロパティが含まれており、この実装でサポートされていないプロパティは含まれていません。

 var originalEntity = new Entity { Name = "Name", ShortName = string.Empty, Description = null, Label = 'L', Age = 32, Index = -7, IsVisible = true, Price = 225.87M, Rating = 4.8, Weigth = 130, ShortIndex = short.MaxValue, LongIndex = long.MinValue, UnsignedIndex = uint.MaxValue, ShortUnsignedIndex = 25, LongUnsignedIndex = 11, Id = Guid.NewGuid(), CreatedAt = DateTime.Now, CreatedAtUtc = DateTime.UtcNow, LastAccessed = DateTime.MinValue, ChangedAt = DateTimeOffset.Now, ChangedAtUtc = DateTimeOffset.UtcNow, References = null, Weeks = new List<short>() { 3, 12, 24, 48, 53, 61 }, PricesHistory = new decimal[] { 225.8M, 226M, 227.87M, 224.87M }, BitMap = new bool[] { true, true, false, true, false, false, true, true }, ChildrenIds = new Guid [] { Guid.NewGuid(), Guid.NewGuid(), Guid.NewGuid() }, Schedule = new DateTime [] { DateTime.Now.AddDays(-1), DateTime.Now.AddMonths(2), DateTime.Now.AddYears(10) }, Moments = new DateTimeOffset [] { DateTimeOffset.UtcNow.AddDays(-5), DateTimeOffset.Now.AddDays(10) }, Tags = new List<string> { "The quick brown fox jumps over the lazy dog", "Reflection.Emit", string.Empty, "0" }, AlternativeId = Guid.NewGuid() }; 

「純粋な」リフレクションシリアライザーでさえ、より一般的で複雑なタスクに重点を置いているため、このようなオブジェクトでは標準オプションよりも優れた結果を示していることに注意してください。EmitSerializerの結果はさらに優れていました（生成されたコードを1回コンパイルするのにかかった時間を除く）。測定中に得られた値：

 Serializer | Average elapsed, ms | Size, bytes ------------------------------------------------------------------------------- EmitSerializer | 9.9522 | 477 ------------------------------------------------------------------------------- ReflectionSerializer | 22.9454 | 477 ------------------------------------------------------------------------------- BinaryFormatter | 246.4836 | 1959 ------------------------------------------------------------------------------- Newtonsoft JsonSerializer | 87.1893 | 1156 EmitSerializer compiled in: 104.5019 ms 

ソースコード

ソリューションのソースコードはGithubにあります。

ただし、実装はそのままで提供され、誤りや信頼性の保証はありません。作者は、現時点では、このアイデアが生まれた枠組みの中でプロジェクトを去り、「戦闘条件」でテストを実施する機会がありませんでした。

コードは.NET Core 2.0で作成され、Linux Ubuntu 16.04 LTS OSでコンパイルおよびテストされました。