public SerializerBuilder(SerializerBuilder source)
{
_serializerFactory = () => source.Serializer;
_serializer = new Lazy<IMessageSerializer>(CreateSerializer);
_deserializer = new Lazy<IMessageDeserializer>(CreateDeserializer);
_deserializerFactories = new Dictionary<string, DeserializerFactory>(source._deserializerFactories, StringComparer.OrdinalIgnoreCase);
}
public void SetSerializer(SerializerFactory serializerFactory)
{
if (serializerFactory == null)
throw new ArgumentNullException(nameof(serializerFactory));
if (_serializer.IsValueCreated)
throw new ConfigurationException("The serializer has already been created, the serializer cannot be changed at this time.");
_serializerFactory = serializerFactory;
}
public SerializerBuilder()
{
_serializerFactory = () => new JsonMessageSerializer();
_serializer = new Lazy<IMessageSerializer>(CreateSerializer);
_deserializer = new Lazy<IMessageDeserializer>(CreateDeserializer);
_deserializerFactories = new Dictionary<string, DeserializerFactory>(StringComparer.OrdinalIgnoreCase);
AddDeserializer(JsonMessageSerializer.JsonContentType, () => new JsonMessageDeserializer(JsonMessageSerializer.Deserializer));
AddDeserializer(BsonMessageSerializer.BsonContentType, () => new BsonMessageDeserializer(BsonMessageSerializer.Deserializer));
AddDeserializer(XmlMessageSerializer.XmlContentType, () => new XmlMessageDeserializer(JsonMessageSerializer.Deserializer));
}
public override void WriteBytes(object obj, SerializerInputStream serializerInputStream)
{
serializerInputStream.Write(RpcSerializerUtil.Byte_Dictionary);
var startLength = serializerInputStream.Length;
serializerInputStream.Write(0);//当前流长度占位
var dic = (IDictionary)obj;
serializerInputStream.Write(_type.FullName);
serializerInputStream.Write(dic.Count);
var enumerator = dic.GetEnumerator();
while (enumerator.MoveNext())
{
SerializerFactory.Serializer(enumerator.Key, serializerInputStream);
SerializerFactory.Serializer(enumerator.Value, serializerInputStream);
}
serializerInputStream.UpdateCurrentLength(serializerInputStream.Length - startLength - 4, startLength);//填补流长度
}
internal async Task <int> SaveObjectAsync(object oi, SqoTypeInfo ti, ObjectInfo objInfo)
{
ObjectSerializer serializer = SerializerFactory.GetSerializer(this.path, GetFileByType(ti), useElevatedTrust);
serializer.NeedSaveComplexObjectAsync += new ComplexObjectEventHandler(serializer_NeedSaveComplexObjectAsync);
await CheckForConcurencyAsync(oi, objInfo, ti, serializer, false).ConfigureAwait(false);
await CheckConstraintsAsync(objInfo, ti).ConfigureAwait(false);
Dictionary <string, object> oldValuesOfIndexedFields = await this.indexManager.PrepareUpdateIndexesAsync(objInfo, ti).ConfigureAwait(false);
await serializer.SerializeObjectAsync(objInfo, this.rawSerializer).ConfigureAwait(false);
metaCache.SetOIDToObject(oi, objInfo.Oid, ti);
await this.indexManager.UpdateIndexesAsync(objInfo, ti, oldValuesOfIndexedFields).ConfigureAwait(false);
return(objInfo.Oid);
}
internal int SaveObject(object oi, SqoTypeInfo ti, ObjectInfo objInfo)
{
ObjectSerializer serializer = SerializerFactory.GetSerializer(this.path, GetFileByType(ti), useElevatedTrust);
serializer.NeedSaveComplexObject += new EventHandler <ComplexObjectEventArgs>(serializer_NeedSaveComplexObject);
CheckForConcurency(oi, objInfo, ti, serializer, false);
CheckConstraints(objInfo, ti);
Dictionary <string, object> oldValuesOfIndexedFields = this.indexManager.PrepareUpdateIndexes(objInfo, ti);
serializer.SerializeObject(objInfo, this.rawSerializer);
metaCache.SetOIDToObject(oi, objInfo.Oid, ti);
this.indexManager.UpdateIndexes(objInfo, ti, oldValuesOfIndexedFields);
return(objInfo.Oid);
}
internal async Task <bool> SaveValueAsync(int oid, string field, SqoTypeInfo ti, object value)
{
if (field == "OID")
{
throw new SiaqodbException("OID cannot be saved from client code!");
}
ObjectSerializer serializer = SerializerFactory.GetSerializer(this.path, GetFileByType(ti), useElevatedTrust);
serializer.NeedSaveComplexObjectAsync += new ComplexObjectEventHandler(serializer_NeedSaveComplexObjectAsync);
if (oid > 0 && oid <= ti.Header.numberOfRecords && !(await serializer.IsObjectDeletedAsync(oid, ti).ConfigureAwait(false)))
{
return(await serializer.SaveFieldValueAsync(oid, field, ti, value, this.rawSerializer).ConfigureAwait(false));
}
else
{
return(false);
}
}
internal bool SaveValue(int oid, string field, SqoTypeInfo ti, object value)
{
if (field == "OID")
{
throw new SiaqodbException("OID cannot be saved from client code!");
}
ObjectSerializer serializer = SerializerFactory.GetSerializer(this.path, GetFileByType(ti), useElevatedTrust);
serializer.NeedSaveComplexObject += new EventHandler <ComplexObjectEventArgs>(serializer_NeedSaveComplexObject);
if (oid > 0 && oid <= ti.Header.numberOfRecords && !serializer.IsObjectDeleted(oid, ti))
{
return(serializer.SaveFieldValue(oid, field, ti, value, this.rawSerializer));
}
else
{
return(false);
}
}
public void SerializeLevel()
{
#if NETFX_CORE
throw new System.NotImplementedException("Level prefab saving not implemented in Windows 8 yet.");
#else
using (StreamWriter streamWriter = new StreamWriter(filepath))
{
ISerializer <LevelPrefab> serializer = SerializerFactory.CreateSerializer <LevelPrefab>();
serializer.WriteObject(this, streamWriter.BaseStream);
}
#if DEBUG
using (StreamWriter streamWriter = new StreamWriter(@"..\..\..\" + filepath))
{
ISerializer <LevelPrefab> serializer = SerializerFactory.CreateSerializer <LevelPrefab>();
serializer.WriteObject(this, streamWriter.BaseStream);
}
#endif
#endif
}
public void SetUp()
{
m_serFactory = new SerializerFactory();
omg.org.IOP.CodecFactory codecFactory =
new Ch.Elca.Iiop.Interception.CodecFactoryImpl(m_serFactory);
m_codec =
codecFactory.create_codec(
new omg.org.IOP.Encoding(omg.org.IOP.ENCODING_CDR_ENCAPS.ConstVal,
1, 2));
m_iiopUrlUtil =
IiopUrlUtil.Create(m_codec, new object[] {
Services.CodeSetService.CreateDefaultCodesetComponent(m_codec)
});
m_serFactory.Initalize(new SerializerFactoryConfig(), m_iiopUrlUtil);
m_handler =
new GiopMessageHandler(
new ArgumentsSerializerFactory(m_serFactory),
GiopHeader.GetDefaultHeaderFlagsForEndian(Endian.BigEndian));
}
/// <summary>
/// 发送请求带返回
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="transfer"></param>
/// <returns></returns>
public T Send <T>(DBTransfer transfer)
{
byte[] buf = SerializerFactory <CommonSerializer> .Serializer(transfer);
RequestServer request = new RequestServer();
request.Address = SrvControl.Instance.GetCureent();
byte[] rec = request.Request(buf);
RequestResult result = SerializerFactory <CommonSerializer> .Deserialize <RequestResult>(rec);
if (result.Error != ErrorCode.Exception)
{
if (typeof(T) == typeof(DataTable) || typeof(T) == typeof(DataSet))
{
//当前序列化不能对DataTable
//服务端转换为XML
if (result.Result != null)
{
if (typeof(string) == result.Result.GetType())
{
DataSet ds = new DataSet();
var stream = new StringReader(result.Result.ToString());
//从stream装载到XmlTextReader
var reader = new XmlTextReader(stream);
ds.ReadXml(reader);
if (typeof(T) == typeof(DataSet))
{
result.Result = ds;
}
else
{
result.Result = ds.Tables[0];
}
}
}
}
return((T)result.Result);
}
else
{
throw new ServerException(result.ReslutMsg);
}
}
public async Task AsyncNoReturn(IInvocation invocation)
{
IHttpClientRequestContext context = RequestContextFactory.CreateContext(new CastleCoreInvocationCallContextAdapter(invocation),
new CastleCoreInvocationParametersContextAdapter(invocation));
//If it has no body we don't need to provide or produce serializers for it.
if (!context.BodyContext.HasBody)
{
await ProxyClient.Send(context).ConfigureAwait(false);
return;
}
//We need to look at the request to determine which serializer strategy should be used.
IRequestSerializationStrategy serializer = SerializerFactory.SerializerFor(context.BodyContext.ContentAttributeType);
//Because we don't need to get any returned information we can just send it
await ProxyClient.Send(context, serializer).ConfigureAwait(false);
}
public void SetUp()
{
SerializerFactory serFactory =
new SerializerFactory();
CodecFactory codecFactory =
new CodecFactoryImpl(serFactory);
m_codec =
codecFactory.create_codec(
new omg.org.IOP.Encoding(ENCODING_CDR_ENCAPS.ConstVal, 1, 2));
IiopUrlUtil iiopUrlUtil =
IiopUrlUtil.Create(m_codec, new object[] {
Services.CodeSetService.CreateDefaultCodesetComponent(m_codec)
});
serFactory.Initalize(new SerializerFactoryConfig(), iiopUrlUtil);
m_defaultCodeSetTaggedComponent =
Services.CodeSetService.CreateDefaultCodesetComponent(m_codec);
}
/// <summary>
/// 超时处理
/// </summary>
/// <param name="RequestID"></param>
/// <param name="address"></param>
private void TimeOutProcesser(long RequestID, long rspid, EndPoint address)
{
RequestResult result = new RequestResult();
result.Error = ErrorCode.TimeOut;
result.ErrorMsg = result.Error.ToDescriptionString();
result.ReslutMsg = "执行超时";
result.Result = null;
result.RequestID = RequestID;
result.ID = rspid;
byte[] r = SerializerFactory <CommonSerializer> .Serializer <RequestResult>(result);
AsyncUdpUserToken token = new AsyncUdpUserToken();
token.Data = r;
token.Length = r.Length;
token.Remote = address;
udp.SendPackage(token);
}
public void ComplexTypesSequence_SerializeAndDeserializeBack_OriginAndDeserializedAreEqual()
{
var origin = new object[]
{
"fortyTwo",
"",
new int[] { 1, 2, 3, 4 },
new User
{
Age = 18,
IsFemale = true,
Name = "Kate"
},
new MyStruct()
{
MyBool = true,
MyDate = DateTime.Now,
MyInt = 42,
MyLong = 42,
}
};
var sequenceTypes = origin.Select(o => o.GetType()).ToArray();
var serializer = SerializerFactory.CreateDefault().Create(sequenceTypes);
var deserializer = DeserializerFactory.CreateDefault().Create(sequenceTypes);
var stream = new MemoryStream();
serializer.Serialize(origin, stream);
stream.Position = 0;
var deserialized = (object[])deserializer.Deserialize(stream, (int)stream.Length);
Assert.Multiple(() =>
{
Assert.AreEqual(origin[0], deserialized[0]);
Assert.AreEqual(origin[1], deserialized[1]);
CollectionAssert.AreEqual((IEnumerable)origin[2], (IEnumerable)deserialized[2]);
Assert.IsTrue(((User)origin[3]).IsSameTo((User)deserialized[3]));
Assert.IsTrue(((MyStruct)origin[4]).IsSameTo((MyStruct)deserialized[4]));
Assert.AreEqual(origin.Length, deserialized.Length);
});
}
public void Action()
{
var test = new Test
{
P1 = null,
P2 = 2,
P3 = 3,
P4 = 4,
P5 = 5,
P6 = 6,
P7 = 7,
P8 = 8,
P9 = 9,
P10 = 10,
P11 = 'a',
P12 = false,
P13 = 1.1,
P14 = 2,
P15 = DateTime.Now,
P16 = TimeSpan.FromTicks(1025233),
P17 = "测试数据",
P18 = Encoding.UTF8.GetBytes("你好啊"),
P19 = new Aa
{
P1 = 19,
P2 = Sex.Woman,
P3 = new int[][] {
new int[] { }, new int[] { 1, 2, 4, 5 }
},
P4 = new Dictionary <int, string>
{
[1] = "1",
[2] = "2"
},
P5 = Enumerable.Range(0, 10),
P6 = Guid.NewGuid(),
P7 = ObjectId.GenerateNewId()
}
};
var bytes = SerializerFactory.Serializer(test);
var obj = SerializerFactory.Deserializer(bytes);
}
/// <summary>
/// 处理请求任务
/// </summary>
/// <param name="source"></param>
/// <param name="client"></param>
private void SubmitTask(SrvDataSource source, ClientRequest client)
{
Console.WriteLine("Submint:" + Thread.CurrentThread.ManagedThreadId);
var data = source.Message as byte[];
//获取传递的请求
DBTransfer model = SerializerFactory <CommonSerializer> .Deserialize <DBTransfer>(data);
if (model.TimeOut == 0)
{
//不超时
var result = DBAcessSrv.Singleton.Execete(Interlocked.Increment(ref rspID), model);
ResponseResult(source, result, model, client);
}
else
{
//超时请求
var result = ExecuteTimeOut(source, client, model);
ResponseResult(source, result, model, client);
}
}
private void SetObjectField(List <FieldInfo> fieldList, object result, byte[] data, int startOffset, int totalLength, out int nextStartOffset)
{
if (startOffset < totalLength)
{
var fieldName = ByteUtil.DecodeString(data, startOffset, out nextStartOffset);
startOffset = nextStartOffset;
var fieldValue = SerializerFactory.Deserializer(data, startOffset, out nextStartOffset);
var fieldInfo = fieldList.FirstOrDefault(m => m.Name == fieldName);
if (fieldInfo != null)
{
fieldInfo.SetValue(result, fieldValue);
}
startOffset = nextStartOffset;
SetObjectField(fieldList, result, data, startOffset, totalLength, out nextStartOffset);
}
else
{
nextStartOffset = startOffset;
}
}
public void ValidateSecureCredentialProviderSetter()
{
var credential = new Credentials
{
Password = "******"
};
var json = (string)credential.GetCustomSerializer(SerializerFormat.JSON);
dynamic deserialized = SerializerFactory.GetCustomSerializer <DynamicSerialization>(SerializerFormat.JSON).Deserialize(json);
var passwordEncrypted = (string)deserialized.Password;
var credentialResult = new Credentials
{
PasswordInternal = passwordEncrypted
};
Assert.Equal(credential.Password, credentialResult.Password);
}
public static XmlSerializer GetSerializer(Type type, string customKey, SerializerFactory factory)
{
string key = customKey + type.AssemblyQualifiedName;
if (Serializers.ContainsKey(key))
{
return(Serializers[key]);
}
XmlSerializer serializer = factory();
if (Serializers.ContainsKey(key))
{
return(Serializers[key]);
}
lock (_syncRoot)
{
Serializers.Add(key, serializer);
}
return(serializer);
}
public LevelPrefab GetLevelPrefab(string filepath)
{
try
{
LevelPrefab level;
using (Stream stream = TitleContainer.OpenStream(filepath))
{
ISerializer <LevelPrefab> serializer = SerializerFactory.CreateSerializer <LevelPrefab>();
level = serializer.ReadObject(stream);
}
return(level);
}
catch (FileNotFoundException)
{
return(new LevelPrefab {
filepath = filepath
});
}
}
/// <summary>
/// Serializes the cache index.
/// </summary>
/// <param name="obj">The cache index to serialize.</param>
public static void SerializeCacheIndex(Object obj)
{
if (obj == null)
{
return;
}
CacheIndex cacheIndex = obj as CacheIndex;
if (cacheIndex.Count() <= 0)
{
return;
}
lock (staticLock)
{
ISerializer <CacheIndex> iSerializer = SerializerFactory.Create <CacheIndex>(SerializationFormat.XML);
iSerializer.SerializeObjectToFile(cacheIndex, cacheIndex.SerializeFile);
}
}
public void ModelJsonDeserializationTest()
{
string value =
@"
{
""IsSuccess"": true,
""OperationType"": ""GetSellerAccountStatusResponse"",
""SellerID"": ""A006"",
""ResponseBody"": {
""Membership"": 0,
""FufillmentCenterList"": [
{
""WarehouseLocation"": ""USA"",
""WarehouseType"": 0,
""ShippingDestinationList"": [
""USA"",
""AUS"",
""HKG"",
""IND"",
""IDN"",
""PHL"",
""KOR"",
""CHL"",
""MAC"",
""CHN"",
""GBR"",
""SGP""
]
}
],
""SellerName"": ""Test_SandBox_MKTPLS"",
""Status"": ""Active""
}
}";
var serializer = SerializerFactory.GetSerializer(APIFormat.JSON);
var sellerStatus = serializer.Deserialize <ResponseModel <SellerStatusCheckResponseBody> >(value);
var body = sellerStatus.GetResponseBody();
Assert.IsType <SellerStatusCheckResponseBody>(body);
Assert.Equal("Test_SandBox_MKTPLS", body.SellerName);
}
private void Send()
{
Task.Factory.StartNew(() =>
{
DBTransfer transfer = null;
int num = 0;
int waitTime = 300;//5分钟
while (true)
{
if (queue.IsEmpty)
{
Thread.Sleep(1000);
num++;
if (num > waitTime)
{
break;
}
continue;
}
num = 0;
if (queue.TryDequeue(out transfer))
{
semaphore.Wait();
Task.Factory.StartNew(() =>
{
byte[] buf = SerializerFactory <CommonSerializer> .Serializer(transfer);
RequestServer request = new RequestServer();
request.Address = SrvControl.Instance.GetCureent();
byte[] rec = request.Request(buf);
RequestResult result = SerializerFactory <CommonSerializer> .Deserialize <RequestResult>(rec);
if (SrvExecuteResult != null)
{
SrvExecuteResult(result.RequestID, result.Error == ErrorCode.Sucess, result.ReslutMsg);
}
semaphore.Release();
});
}
}
Send();//递归更新线程
});
}
/// <summary>
/// 构造函数
/// </summary>
/// <param name="hostName"></param>
/// <param name="userName"></param>
/// <param name="port"></param>
/// <param name="password"></param>
/// <param name="maxQueueCount"></param>
/// <param name="serializerType"></param>
/// <param name="loger"></param>
/// <param name="writeWorkerTaskNumber"></param>
private RabbitMQClient(string hostName, string userName, string password, int?port, int maxQueueCount
, SerializerType serializerType, ILoger loger = null, short writeWorkerTaskNumber = 4)
{
factory = new ConnectionFactory();
factory.HostName = hostName;
if (!port.HasValue || port.Value < 0)
{
factory.Port = 5672;
}
else
{
factory.Port = port.Value;
}
factory.Password = password;
factory.UserName = userName;
serializer = SerializerFactory.Create(serializerType);
_queue = new System.Collections.Concurrent.BlockingCollection <StrongBox <QueueMessage> >();
//_queue = new System.Collections.Queue();
_maxQueueCount = maxQueueCount > 0 ? maxQueueCount : Options.DefaultMaxQueueCount;
//isQueueToWrite = false;
//resetEvent = new AutoResetEvent(false);
this.loger = loger;
//this.waitMillisecondsTimeout = 10000;
//queueWorkThread = new Thread(QueueToWrite);
//queueWorkThread.IsBackground = true;
//queueWorkThread.Start();
var scheduler = new ConcurrentExclusiveSchedulerPair(TaskScheduler.Default, writeWorkerTaskNumber).ExclusiveScheduler;
TaskFactory taskFactory = new TaskFactory(scheduler);
for (int i = 0; i < writeWorkerTaskNumber; i++)
{
taskFactory.StartNew(QueueToWrite, TaskCreationOptions.LongRunning);
//Task.Factory.StartNew(QueueToWrite);
}
}
public override string SerializeToString()
{
string value = string.Empty;
ISerializable serializer = SerializerFactory.Create(m_Period.StartTime);
if (serializer != null)
{
value += serializer.SerializeToString();
}
value += "/";
serializer = SerializerFactory.Create(m_Period.Duration);
if (serializer != null)
{
value += serializer.SerializeToString();
}
return(value);
}
/// <summary>
/// Serializes the cache index immediately.
/// </summary>
/// <param name="cacheIndex">The cache index to serialize.</param>
public static void SerializeCacheIndexImmediate(CacheIndex cacheIndex)
{
lock (staticLock)
{
try
{
cacheIndex.LastSerializationDate = DateTime.Now;
ISerializer <CacheIndex> iSerializer = SerializerFactory.Create <CacheIndex>(SerializationFormat.XML);
iSerializer.SerializeObjectToFile(cacheIndex, cacheIndex.SerializeFile);
}
catch (Exception e)
{
int count = -1;
if (cacheIndex != null)
{
count = cacheIndex.Count;
}
Device.Log.Error("Exception trying to serialize cache index immediately. Cache index count was: " + count, e);
}
}
}
public void SecondaryTriesRepeatedlyToConnect()
{
var serializerFactory = new SerializerFactory();
var serializer = serializerFactory.CreateSerializer();
var communicatorFactory = new CommunicatorFactory();
var primaryCommunicator = communicatorFactory.CreatePrimaryCommunicator(serializer);
var secondaryCommunicator = communicatorFactory.CreateSecondaryCommunicator(serializer);
secondaryCommunicator.Connect();
Task.Delay(Constants.ConnectionTimeout * 3).Wait();
Assert.False(secondaryCommunicator.IsConnected);
primaryCommunicator.Connect();
Task.Delay(Constants.ConnectionTimeout * 2).Wait();
Assert.True(secondaryCommunicator.IsConnected);
secondaryCommunicator.Disconnect();
primaryCommunicator.Disconnect();
}
public override void WriteBytes(object obj, SerializerInputStream serializerInputStream)
{
serializerInputStream.Write(RpcSerializerUtil.Byte_Enumerable);
var startLength = serializerInputStream.Length;
serializerInputStream.Write(0);//当前流长度占位
serializerInputStream.Write(_type.FullName);
var count = 0;
var enumerable = (IEnumerable)obj;
var enumerator = enumerable.GetEnumerator();
var currentLength = serializerInputStream.Length;
serializerInputStream.Write(0);//总个数占位
while (enumerator.MoveNext())
{
count++;
SerializerFactory.Serializer(enumerator.Current, serializerInputStream);
}
serializerInputStream.UpdateCurrentLength(count, currentLength); //填补数量
serializerInputStream.UpdateCurrentLength(serializerInputStream.Length - startLength - 4, startLength); //填补流长度
}
public static string InitializeObject(object value, SerializerEnum serializer)
{
if (value == null)
{
throw new ArgumentNullException(nameof(value));
}
if (SerializerFactory == null)
{
throw new InvalidOperationException();
}
if (ClassInfoBuilder == null)
{
throw new InvalidOperationException();
}
var classInfo = ClassInfoBuilder.BuildObjectTree(value);
var s = SerializerFactory.GetSerializer(serializer);
return(s.Serialize(classInfo));
}
public void Execute()
{
var m1 = new M1();
var m2_1 = new M2();
var m2_2 = new M2();
var m2_3 = new M2();
using (Stream stream = new MemoryStream())
{
var serializer = SerializerFactory.Create(typeof(IMyBusMessage), typeof(M1), typeof(M2));
serializer.Serialize(new object[] { m1, m2_1, m2_2, m2_3 }, stream);
stream.Position = 0;
var messageDeserialized = serializer.Deserialize(stream);
Assert.IsInstanceOf <M1>(messageDeserialized[0]);
Assert.IsInstanceOf <M2>(messageDeserialized[1]);
Assert.IsInstanceOf <M2>(messageDeserialized[2]);
Assert.IsInstanceOf <M2>(messageDeserialized[3]);
}
}
public void Should_throw_an_exception()
{
var m2_1 = new M2();
var m2_2 = new M2();
var m2_3 = new M2();
using (Stream stream = new MemoryStream())
{
var serializer = SerializerFactory.Create(typeof(IMyBusMessage), typeof(M1), typeof(M2));
//var exception = Assert.Throws<Exception>(() => serializer.Initialize(new[] { typeof(IMyBusMessage), typeof(M1), typeof(M2) }));
//Assert.AreEqual("Nested types are not supported by the XmlMessageSerializer.", exception.Message);
var m1 = new M1();
serializer.Serialize(new object[] { m1, m2_1, m2_2, m2_3 }, stream);
stream.Position = 0;
var messageDeserialized = serializer.Deserialize(stream);
Assert.IsInstanceOf <M1>(messageDeserialized[0]);
Assert.IsInstanceOf <M2>(messageDeserialized[1]);
Assert.IsInstanceOf <M2>(messageDeserialized[2]);
Assert.IsInstanceOf <M2>(messageDeserialized[3]);
}
}
public override object GetObject(byte[] inputBytes, int startOffset, out int nextStartOffset)
{
var objectByteData = ByteUtil.DecodeBytes(inputBytes, startOffset, out nextStartOffset);
if (objectByteData.Length > 0)
{
var tableName = ByteUtil.DecodeString(objectByteData, 0, out int tableNextStartOffset);
var tabeOffsetIndex = tableNextStartOffset;
var table = new DataTable(tableName);
var columnCount = ByteUtil.DecodeInt(objectByteData, tabeOffsetIndex, out tableNextStartOffset);
tabeOffsetIndex = tableNextStartOffset;
for (int i = 0; i < columnCount; i++)
{
var columnName = ByteUtil.DecodeString(objectByteData, tabeOffsetIndex, out tableNextStartOffset);
tabeOffsetIndex = tableNextStartOffset;
var columnTypeName = ByteUtil.DecodeString(objectByteData, tabeOffsetIndex, out tableNextStartOffset);
tabeOffsetIndex = tableNextStartOffset;
var type = SerializerUtil.GetType(columnTypeName);
table.Columns.Add(columnName, type);
}
var rowCount = ByteUtil.DecodeInt(objectByteData, tabeOffsetIndex, out tableNextStartOffset);
tabeOffsetIndex = tableNextStartOffset;
for (int i = 0; i < rowCount; i++)
{
DataRow row = table.NewRow();
for (int j = 0; j < columnCount; j++)
{
row[j] = SerializerFactory.Deserializer(objectByteData, tabeOffsetIndex, out tableNextStartOffset);
tabeOffsetIndex = tableNextStartOffset;
}
table.Rows.Add(row);
}
return(table);
}
else
{
return(null);
}
}
public void SetMessageSerializer(SerializerFactory serializerFactory)
{
_serializerBuilder.SetSerializer(serializerFactory);
}
