protected override void PackToCore(MsgPack.Packer packer, Delegate objectTree) { if (objectTree is CallbackDelegate) { var funcRef = objectTree.Method.DeclaringType?.GetFields(BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.Public | BindingFlags.Static).FirstOrDefault(a => a.FieldType == typeof(RemoteFunctionReference)); if (funcRef == null) { throw new ArgumentException("The CallbackDelegate does not contain a RemoteFunctionReference capture."); } RemoteFunctionReference fr = (RemoteFunctionReference)funcRef.GetValue(objectTree.Target); packer.PackExtendedTypeValue(10, fr.Duplicate()); } else { var funcRefDetails = FunctionReference.Create(objectTree); string refType = InternalManager.CanonicalizeRef(funcRefDetails.Identifier); packer.PackExtendedTypeValue(10, Encoding.UTF8.GetBytes(refType)); } }
public void PackToMessage( Packer pk, PackingOptions options ) { pk.PackArrayHeader( 5 ); pk.PackString( uri ); pk.PackString( title ); pk.Pack( width ); pk.Pack( height ); pk.Pack( size ); }
public void PackToMessage(Packer packer, PackingOptions options) { packer.PackMapHeader(2); packer.Pack("__type"); packer.Pack("MetaField"); packer.Pack("fieldId"); packer.Pack(FieldId); }
public void PackToMessage(Packer packer, PackingOptions options) { packer.PackMapHeader(3); packer.PackString("graphName"); packer.Pack(this.graphName); packer.PackString("graphObjName"); packer.Pack(this.graphObjName); packer.PackString("killSession"); packer.Pack(this.killSession); }
protected override void PackToCore(MsgPack.Packer packer, IO.Ably.Message objectTree) { var nonNullFields = new bool[] { objectTree.ClientId.IsNotEmpty(), objectTree.ConnectionId.IsNotEmpty(), objectTree.Data != null, objectTree.Encoding.IsNotEmpty(), objectTree.Id.IsNotEmpty(), objectTree.Name.IsNotEmpty(), objectTree.Timestamp != null, }.Count(x => x); packer.PackMapHeader(nonNullFields); if (objectTree.ClientId.IsNotEmpty()) { this._serializer0.PackTo(packer, "clientId"); this._serializer0.PackTo(packer, objectTree.ClientId); } if (objectTree.ConnectionId.IsNotEmpty()) { this._serializer0.PackTo(packer, "connectionId"); this._serializer0.PackTo(packer, objectTree.ConnectionId); } if (objectTree.Data != null) { this._serializer0.PackTo(packer, "data"); this._serializer1.PackTo(packer, objectTree.Data); } if (objectTree.Encoding.IsNotEmpty()) { this._serializer0.PackTo(packer, "encoding"); this._serializer0.PackTo(packer, objectTree.Encoding); } if (objectTree.Id.IsNotEmpty()) { this._serializer0.PackTo(packer, "id"); this._serializer0.PackTo(packer, objectTree.Id); } if (objectTree.Name.IsNotEmpty()) { this._serializer0.PackTo(packer, "name"); this._serializer0.PackTo(packer, objectTree.Name); } if (objectTree.Timestamp != null) { this._serializer0.PackTo(packer, "timestamp"); this._serializer2.PackTo(packer, objectTree.Timestamp); } }
public static bool MsgPackLuaTable(ref LuaTable luatable, ref Packer pker) { if (luatable == null) { pker = null; return false; } else { pker.PackMapHeader(luatable.Count); } foreach (var item in luatable) { //object key = item.Key; bool kFlag = luatable.IsKeyString(item.Key); if (kFlag) { pker.PackRawHeader(item.Key.Length); pker.PackRawBody(System.Text.Encoding.UTF8.GetBytes(item.Key)); } else { pker.Pack(double.Parse(item.Key.ToString())); } var valueType = item.Value.GetType(); if (valueType == typeof(String)) { pker.PackRawHeader(item.Value.ToString().Length); pker.PackRawBody(System.Text.Encoding.UTF8.GetBytes(item.Value.ToString())); } else if (valueType == typeof(LuaTable)) { LuaTable luaTbl = item.Value as LuaTable; MsgPackLuaTable(ref luaTbl, ref pker); } else if (valueType == typeof(bool)) { pker.Pack(bool.Parse(item.Value.ToString())); } else { pker.Pack(double.Parse(item.Value.ToString())); } } return true; }
public void PackToMessage( Packer packer, PackingOptions options ) { // Pack fields are here: // First, record total fields size. packer.PackArrayHeader( 2 ); packer.Pack( this.Id ); packer.PackString( this.Name ); // ...Instead, you can pack as map as follows: // packer.PackMapHeader( 2 ); // packer.Pack( "Id" ); // packer.Pack( this.Id ); // packer.Pack( "Name" ); // packer.Pack( this.Name ); }
protected override void PackToCore(MsgPack.Packer packer, Delegate objectTree) { if (objectTree is CallbackDelegate) { throw new InvalidOperationException("Resending callback delegates is currently not supported."); } var funcRefDetails = FunctionReference.Create(objectTree); var resourceNameBytes = Encoding.UTF8.GetBytes(funcRefDetails.Resource); var delegateData = new byte[8 + resourceNameBytes.Length]; Array.Copy(BitConverter.GetBytes(funcRefDetails.Identifier).Reverse().ToArray(), 0, delegateData, 0, 4); Array.Copy(BitConverter.GetBytes(funcRefDetails.Instance).Reverse().ToArray(), 0, delegateData, 4, 4); Array.Copy(resourceNameBytes, 0, delegateData, 8, resourceNameBytes.Length); packer.PackExtendedTypeValue(1, delegateData); }
public void PackToMessage(Packer packer, PackingOptions options) { packer.PackMapHeader(this.inSession ? 4 : 6) .PackString("channel") .Pack(Channel.MsgPack) .PackString("inSession") .Pack(this.inSession) .PackString("isolate") .Pack(this.isolate) .PackString("transaction") .Pack(this.transaction); if (!this.inSession) { packer.PackString("graphName") .PackString(this.graphName) .PackString("graphObjName") .PackString(this.graphObjName); } }
/// <summary> /// Use msgpack to compress the data /// </summary> /// <param name="packer"> /// The msgpack packer /// </param> /// <param name="options"> /// msgpack packing options /// </param> public void PackToMessage(Packer packer, PackingOptions options) { packer.PackArrayHeader(this.Values.Count); foreach (object obj in this.Values) { if (obj.GetType() == typeof(string)) { string temp = (string)obj; packer.PackString(temp, Encoding.GetEncoding("UTF-8")); } else if (obj.GetType() == typeof(Single)) { float temp = (Single)obj; packer.Pack<float>(temp); } else if (obj.GetType() == typeof(int)) { int temp = (Int32)obj; packer.Pack(temp); } } }
/// <summary> /// Use msgpack to compress the data /// </summary> /// <param name="packer"> /// The msgpack packer /// </param> /// <param name="options"> /// msgpack packing options /// </param> public void PackToMessage(Packer packer, PackingOptions options) { packer.PackArrayHeader(this.Values.Count); foreach (MessagePackObject obj in this.Values) { if (obj.IsTypeOf(typeof(string)) == true) { string temp = obj.AsStringUtf8(); packer.PackString(temp); } else if (obj.IsTypeOf(typeof(Single)) == true) { float temp = obj.AsSingle(); packer.Pack<float>(temp); } else if (obj.IsTypeOf(typeof(int)) == true) { int temp = obj.AsInt32(); packer.Pack(temp); } } }
protected abstract byte[] GetResult(Packer packer);
public void PackToMessage(Packer packer, PackingOptions options) { // 0xC3 packer.Pack(true); }
public void TestDeepNestedArray() { using (var stream = new MemoryStream()) { var packer = Packer.Create(stream); packer.Pack( new[] { new MessagePackObject( new[] { new MessagePackObject( new [] { new MessagePackObject("1-1-1"), new MessagePackObject("1-1-2"), new MessagePackObject("1-1-3") } ), new MessagePackObject( new [] { new MessagePackObject("1-2-1"), new MessagePackObject("1-2-2"), new MessagePackObject("1-2-3") } ), new MessagePackObject( new [] { new MessagePackObject("1-3-1"), new MessagePackObject("1-3-2"), new MessagePackObject("1-3-3") } ), } ), new MessagePackObject( new[] { new MessagePackObject( new [] { new MessagePackObject("2-1-1"), new MessagePackObject("2-1-2"), new MessagePackObject("2-1-3") } ), new MessagePackObject( new [] { new MessagePackObject("2-2-1"), new MessagePackObject("2-2-2"), new MessagePackObject("2-2-3") } ), new MessagePackObject( new [] { new MessagePackObject("2-3-1"), new MessagePackObject("2-3-2"), new MessagePackObject("2-3-3") } ), } ), new MessagePackObject( new[] { new MessagePackObject( new [] { new MessagePackObject("3-1-1"), new MessagePackObject("3-1-2"), new MessagePackObject("3-1-3") } ), new MessagePackObject( new [] { new MessagePackObject("3-2-1"), new MessagePackObject("3-2-2"), new MessagePackObject("3-2-3") } ), new MessagePackObject( new [] { new MessagePackObject("3-3-1"), new MessagePackObject("3-3-2"), new MessagePackObject("3-3-3") } ), } ), } ); stream.Position = 0; var unpacker = Unpacker.Create(stream); Assert.That(unpacker.Read()); using (Unpacker subtreeReader1 = unpacker.ReadSubtree()) { Assert.That(subtreeReader1.IsArrayHeader); Assert.That(subtreeReader1.ItemsCount, Is.EqualTo(3)); for (int i = 1; subtreeReader1.Read(); i++) { using (Unpacker subtreeReader2 = subtreeReader1.ReadSubtree()) { Assert.That(subtreeReader2.IsArrayHeader); Assert.That(subtreeReader2.ItemsCount, Is.EqualTo(3)); for (int j = 1; subtreeReader2.Read(); j++) { using (Unpacker subtreeReader3 = subtreeReader2.ReadSubtree()) { Assert.That(subtreeReader3.IsArrayHeader); Assert.That(subtreeReader3.ItemsCount, Is.EqualTo(3)); for (int k = 1; subtreeReader3.Read(); k++) { Assert.That(subtreeReader3.LastReadData.AsString(), Is.EqualTo(i + "-" + j + "-" + k)); } } } } } } } }
/// <summary> /// Packs the candidate to a MessagePack objects /// This method should not be called directly, use serialize instead. /// </summary> /// <param name="packer">The packer</param> /// <param name="options">The packer options</param> public void PackToMessage(Packer packer, PackingOptions options) { // pack the header for the amount of items in the map packer.PackMapHeader(MapCount); packer.Pack("DCS"); packer.Pack(Dcs); packer.Pack("DAC"); packer.Pack(Dac); packer.Pack("DAD"); packer.Pack(Dad); packer.Pack("DBD"); packer.Pack(Dbd.ToString(DateFormat, CultureInfo.InvariantCulture)); packer.Pack("DBB"); packer.Pack(Dbb.ToString(DateFormat, CultureInfo.InvariantCulture)); packer.Pack("DBC"); packer.Pack((int) Dbc); packer.Pack("DAY"); packer.Pack(Day.AnsiFormat()); packer.Pack("DAU"); packer.Pack(Dau.AnsiFormat); packer.Pack("DAG"); packer.Pack(Dag); packer.Pack("DAI"); packer.Pack(Dai); packer.Pack("DAJ"); packer.Pack(Daj); packer.Pack("DAK"); packer.Pack(Dak.AnsiFormat); packer.Pack("DCG"); packer.Pack(Dcg); // pack image packer.Pack("ZAA"); var imageConverter = new ImageConverter(); packer.Pack((byte[]) imageConverter.ConvertTo(Image, typeof (byte[]))); // pack fingerprint packer.Pack("ZAB"); if (Fingerprint.Image != null) { var afis = new AfisEngine(); var p = new Person(Fingerprint); afis.Extract(p); } if (Fingerprint.AsIsoTemplate != null) packer.Pack(Fingerprint.AsIsoTemplate); }
/// <summary> /// Packs specified collection with the default context. /// </summary> /// <typeparam name="T">The type of items of the collection.</typeparam> /// <param name="source">The <see cref="Packer"/>.</param> /// <param name="collection">The collection to be serialized.</param> /// <returns><paramref name="source"/>.</returns> /// <exception cref="ArgumentNullException"> /// <paramref name="source"/> is <c>null</c>. /// </exception> /// <exception cref="System.Runtime.Serialization.SerializationException"> /// Cannot serialize <paramref name="collection"/>. /// </exception> public static Packer PackArray <T>(this Packer source, IEnumerable <T> collection) { PackCollectionCore(source, collection, SerializationContext.Default); return(source); }
protected override Packer CreatePacker(MemoryStream stream) { Assert.That(stream.Position, Is.EqualTo(0)); return(Packer.Create(new byte[64 * 1024])); }
/// <summary> /// Serializes the target object /// </summary> /// <param name="packer"></param> /// <param name="objectTree"></param> protected override void PackToCore(MsgPack.Packer packer, T objectTree) { _pack(packer, objectTree); }
public void TestArray() { var emptyList = new List <int>(); { var output = new MemoryStream(); Packer.Create(output).PackCollection(emptyList); Assert.AreEqual(0, Unpacking.UnpackArrayLength(new MemoryStream(output.ToArray()))); Assert.AreEqual(0, Unpacking.UnpackArrayLength(output.ToArray()).Value); } var random = new Random(); for (int i = 0; i < 100; i++) { var l = new List <int>(); int len = ( int )random.Next() % 1000 + 1; for (int j = 0; j < len; j++) { l.Add(j); } var output = new MemoryStream(); Packer.Create(output).PackCollection(l); Stream streamInput = new MemoryStream(output.ToArray()); Assert.AreEqual(len, Unpacking.UnpackArrayLength(streamInput)); for (int j = 0; j < len; j++) { Assert.AreEqual(l[j], Unpacking.UnpackInt32(streamInput)); } byte[] byteArrayInput = output.ToArray(); var arrayLength = Unpacking.UnpackArrayLength(byteArrayInput); Assert.AreEqual(len, arrayLength.Value); int offset = arrayLength.ReadCount; for (int j = 0; j < len; j++) { var uar = Unpacking.UnpackInt32(byteArrayInput, offset); Assert.AreNotEqual(0, uar.ReadCount); Assert.AreEqual(l[j], uar.Value); offset += uar.ReadCount; } } for (int i = 0; i < 100; i++) { var l = new List <String>(); int len = ( int )random.Next() % 1000 + 1; for (int j = 0; j < len; j++) { l.Add(j.ToString()); } var output = new MemoryStream(); Packer.Create(output).PackCollection(l); Stream streamInput = new MemoryStream(output.ToArray()); Assert.AreEqual(len, Unpacking.UnpackArrayLength(streamInput)); for (int j = 0; j < len; j++) { Assert.AreEqual(l[j], Unpacking.UnpackString(streamInput)); } byte[] byteArrayInput = output.ToArray(); var arrayLength = Unpacking.UnpackArrayLength(byteArrayInput); Assert.AreEqual(len, arrayLength.Value); int offset = arrayLength.ReadCount; for (int j = 0; j < len; j++) { var usr = Unpacking.UnpackString(byteArrayInput, offset); Assert.AreEqual(l[j], usr.Value); offset += usr.ReadCount; } } }
/// <summary> /// Packs specified dictionary with the specified context. /// </summary> /// <typeparam name="TKey">The type of keys of the dictionary.</typeparam> /// <typeparam name="TValue">The type of values of the dictionary.</typeparam> /// <param name="source">The <see cref="Packer"/>.</param> /// <param name="dictionary">The dictionary to be serialized.</param> /// <param name="context">The <see cref="SerializationContext"/> holds shared serializers.</param> /// <returns><paramref name="source"/>.</returns> /// <exception cref="ArgumentNullException"> /// <paramref name="source"/> is <c>null</c>. /// Or <paramref name="context"/> is <c>null</c>. /// </exception> /// <exception cref="System.Runtime.Serialization.SerializationException"> /// Cannot serialize <paramref name="dictionary"/>. /// </exception> public static Packer PackDictionary <TKey, TValue>(this Packer source, IDictionary <TKey, TValue> dictionary, SerializationContext context) { PackDictionaryCore(source, dictionary, context); return(source); }
private static void PackCollectionCore <T>(Packer source, IEnumerable <T> collection, SerializationContext context) { PackCollectionCore(source, collection, context.GetSerializer <T>()); }
/// <summary> /// Packs specified collection with the specified context. /// </summary> /// <typeparam name="T">The type of items of the collection.</typeparam> /// <param name="source">The <see cref="Packer"/>.</param> /// <param name="collection">The collection to be serialized.</param> /// <param name="context">The <see cref="SerializationContext"/> holds shared serializers.</param> /// <returns><paramref name="source"/>.</returns> /// <exception cref="ArgumentNullException"> /// <paramref name="source"/> is <c>null</c>. /// Or <paramref name="context"/> is <c>null</c>. /// </exception> /// <exception cref="System.Runtime.Serialization.SerializationException"> /// Cannot serialize <paramref name="collection"/>. /// </exception> public static Packer PackCollection <T>(this Packer source, IEnumerable <T> collection, SerializationContext context) { PackCollectionCore(source, collection, context); return(source); }
protected override Packer CreatePacker(MemoryStream stream, PackerCompatibilityOptions compatibilityOptions) { Assert.That(stream.Position, Is.EqualTo(0)); return(Packer.Create(new byte[64 * 1024], true, compatibilityOptions)); }
public void PackToMessage(Packer packer, PackingOptions options) { packer.Pack((byte)RequestType); PackToMessageCore(packer); }
public void PackToMessage( Packer packer, PackingOptions options ) { // 0xC3 packer.Pack( true ); }
private static ByteArrayPacker CreatePacker(byte[] buffer, int startOffset, Func <byte[], int, byte[]> allocator) { return(Packer.Create(buffer, startOffset, allocator, PackerCompatibilityOptions.None)); }
public void TestHeteroArray() { var heteroList = new List <MessagePackObject>() { true, false, MessagePackObject.Nil, 0, "", 123456, -123456, new String('a', 40000), new String('a', 80000), new MessagePackObject( new MessagePackObjectDictionary() { { "1", "foo" }, { 2, MessagePackObject.Nil }, { 3333333, -1 } } ), new MessagePackObject(new MessagePackObject[] { 1, 2, 3 }) }; var output = new MemoryStream(); Packer.Create(output).PackCollection(heteroList); MessagePackObject obj = UnpackOne(output); bool isSuccess = false; try { var list = obj.AsList(); Assert.AreEqual(heteroList[0], list[0]); Assert.AreEqual(heteroList[1], list[1]); Assert.AreEqual(heteroList[2], list[2]); Assert.AreEqual(heteroList[3], list[3]); Assert.AreEqual(heteroList[4], list[4]); Assert.AreEqual(heteroList[5], list[5]); Assert.AreEqual(heteroList[6], list[6]); Assert.AreEqual(heteroList[7], list[7]); Assert.AreEqual(heteroList[8], list[8]); Assert.AreEqual( heteroList[9].AsDictionary()["1"], list[9].AsDictionary()["1"] ); Assert.IsTrue(list[9].AsDictionary()[2].IsNil); Assert.AreEqual( heteroList[9].AsDictionary()[3333333], list[9].AsDictionary()[3333333] ); Assert.AreEqual(heteroList[10].AsList()[0], list[10].AsList()[0]); Assert.AreEqual(heteroList[10].AsList()[1], list[10].AsList()[1]); Assert.AreEqual(heteroList[10].AsList()[2], list[10].AsList()[2]); isSuccess = true; } finally { if (!isSuccess) { Console.WriteLine(Dump(obj)); } } }
private static ByteArrayPacker CreatePacker(byte[] buffer, int startOffset, bool allowsBufferExtension) { return(Packer.Create(buffer, startOffset, allowsBufferExtension, PackerCompatibilityOptions.None)); }
public void PackToMessage(Packer packer, PackingOptions options) { packer.Pack(count); packer.PackString(data); }
protected override byte[] GetResult(Packer packer) { return((( ByteArrayPacker )packer).GetResultBytes().ToArray()); }
public void TestMap() { var emptyMap = new Dictionary <int, int>(); { var output = new MemoryStream(); Packer.Create(output).PackDictionary(emptyMap); Assert.AreEqual(0, Unpacking.UnpackDictionaryCount(new MemoryStream(output.ToArray()))); Assert.AreEqual(0, Unpacking.UnpackDictionaryCount(output.ToArray()).Value); } var random = new Random(); for (int i = 0; i < 100; i++) { var m = new Dictionary <int, int>(); int len = ( int )random.Next() % 1000 + 1; for (int j = 0; j < len; j++) { m[j] = j; } var output = new MemoryStream(); Packer.Create(output).PackDictionary(m); Stream streamInput = new MemoryStream(output.ToArray()); Assert.AreEqual(len, Unpacking.UnpackDictionaryCount(streamInput)); for (int j = 0; j < len; j++) { int value; Assert.IsTrue(m.TryGetValue(Unpacking.UnpackInt32(streamInput), out value)); Assert.AreEqual(value, Unpacking.UnpackInt32(streamInput)); } byte[] byteArrayInput = output.ToArray(); var arrayLength = Unpacking.UnpackDictionaryCount(byteArrayInput); Assert.AreEqual(len, arrayLength.Value); int offset = arrayLength.ReadCount; for (int j = 0; j < len; j++) { var keyUar = Unpacking.UnpackInt32(byteArrayInput, offset); Assert.AreNotEqual(0, keyUar.ReadCount); int value; Assert.IsTrue(m.TryGetValue(keyUar.Value, out value)); var valueUar = Unpacking.UnpackInt32(byteArrayInput, offset + keyUar.ReadCount); Assert.AreEqual(value, valueUar.Value); offset += keyUar.ReadCount + valueUar.ReadCount; } } for (int i = 0; i < 100; i++) { var m = new Dictionary <string, int>(); int len = ( int )random.Next() % 1000 + 1; for (int j = 0; j < len; j++) { m[j.ToString()] = j; } var output = new MemoryStream(); Packer.Create(output).PackDictionary(m); Stream streamInput = new MemoryStream(output.ToArray()); Assert.AreEqual(len, Unpacking.UnpackDictionaryCount(streamInput)); for (int j = 0; j < len; j++) { int value; Assert.IsTrue(m.TryGetValue(Unpacking.UnpackString(streamInput), out value)); Assert.AreEqual(value, Unpacking.UnpackInt32(streamInput)); } byte[] byteArrayInput = output.ToArray(); var arrayLength = Unpacking.UnpackDictionaryCount(byteArrayInput); Assert.AreEqual(len, arrayLength.Value); int offset = arrayLength.ReadCount; for (int j = 0; j < len; j++) { var usr = Unpacking.UnpackString(byteArrayInput, offset); Assert.AreNotEqual(0, usr.ReadCount); int value; Assert.IsTrue(m.TryGetValue(usr.Value, out value)); var uar = Unpacking.UnpackInt32(byteArrayInput, offset + usr.ReadCount); Assert.AreEqual(value, uar.Value); offset += usr.ReadCount + uar.ReadCount; } } }
protected abstract void PackToMessageCore(Packer packer);
protected override Packer CreatePacker(MemoryStream stream) { return(Packer.Create(stream)); }
protected override Packer CreatePacker(MemoryStream stream, PackerCompatibilityOptions compatibilityOptions) { return(Packer.Create(stream, compatibilityOptions)); }
protected override void PackToMessageCore(Packer packer) { packer.PackArrayHeader(1); packer.Pack(_str); }
protected override byte[] GetResult(Packer packer) { return((( MemoryStream )(( MessagePackStreamPacker )packer).Destination).ToArray()); }
/// <summary> /// </summary> /// <param name="packer"> /// </param> /// <param name="options"> /// </param> public void PackToMessage(Packer packer, PackingOptions options) { // Serialize type name of the data object packer.Pack(this.typeName); // Serialize the data object itself as a byte array packer.Pack(this.dataObject.GetData()); }
void Pack(Packer packer, object o) { if (o == null) { packer.PackNull(); return; } if (o is int) packer.Pack ((int)o); else if (o is uint) packer.Pack ((uint)o); else if (o is float) packer.Pack ((float)o); else if (o is double) packer.Pack ((double)o); else if (o is long) packer.Pack ((long)o); else if (o is ulong) packer.Pack ((ulong)o); else if (o is bool) packer.Pack ((bool)o); else if (o is byte) packer.Pack ((byte)o); else if (o is sbyte) packer.Pack ((sbyte)o); else if (o is short) packer.Pack ((short)o); else if (o is ushort) packer.Pack ((ushort)o); else if (o is string) packer.PackString((string)o, Encoding.ASCII); else if (o is Dictionary<string, object>) { packer.PackMapHeader((o as Dictionary<string, object>).Count); foreach (var pair in (o as Dictionary<string, object>)) { Pack(packer, pair.Key); Pack(packer, pair.Value); } } else if (o is string[]) { packer.PackArrayHeader((o as string[]).Length); foreach (var obj in (o as string[])) packer.Pack(obj as string); } else throw new Exception("Cant handle type: " + o.GetType().Name);; }