protected override void Serialize (ByteSerializer bs)
{
foreach (VibrationStep step in Steps)
{
bs.Serialize (step.Duration);
bs.Serialize (step.Strength);
}
}
protected override void Serialize(ByteSerializer bs)
{
foreach (VibrationStep step in Steps)
{
bs.Serialize(step.Duration);
bs.Serialize(step.Strength);
}
}
public Bytes Serialize()
{
ByteSerializer bs = new ByteSerializer();
bs.Serialize(Event);
bs.Serialize(TapDirection);
bs.Serialize(TapCount);
return(bs.GetBuffer());
}
public Bytes Serialize ()
{
ByteSerializer bs = new ByteSerializer ();
bs.Serialize (Event);
bs.Serialize (TapDirection);
bs.Serialize (TapCount);
return bs.GetBuffer ();
}
public Bytes Serialize ()
{
ByteSerializer bs = new ByteSerializer ();
bs.Serialize (Command);
bs.Serialize (PayloadSize);
this.Serialize (bs);
return bs.GetBuffer ();
}
public Bytes Serialize()
{
ByteSerializer bs = new ByteSerializer();
bs.Serialize(Command);
bs.Serialize(PayloadSize);
this.Serialize(bs);
return(bs.GetBuffer());
}
public Bytes Serialize()
{
ByteSerializer bs = new ByteSerializer();
// ORDER IS MANDATORY
bs.Serialize(Major);
bs.Serialize(Minor);
bs.Serialize(Patch);
bs.Serialize(HardwareRevision);
return(bs.GetBuffer());
}
public Bytes Serialize ()
{
ByteSerializer bs = new ByteSerializer ();
// ORDER IS MANDATORY
bs.Serialize (Major);
bs.Serialize (Minor);
bs.Serialize (Patch);
bs.Serialize (HardwareRevision);
return bs.GetBuffer ();
}
public void StringArrayOfArrayThing()
{
var serializer = new ByteSerializer();
var model1 = new string[][] { new string[] { "a", "b", "c" }, new string[] { "d", "e", "f" } };
var bytes = serializer.Serialize(model1);
var model2 = serializer.Deserialize <string[][]>(bytes);
}
private void OnSaveLevel(LevelFile level)
{
level = level.Clone();
byte[] bytes = ByteSerializer.Serialize(level);
string path = level.isOfficial ? officialLevelsDir_FullPath : customLevelsDir;
path = Path.Combine(path, level.fileName) + (level.isOfficial ? ".txt" : ".lvl");
File.WriteAllBytes(path, bytes);
if (level.isOfficial)
{
RegisterLevel(officialLevels, level);
}
else
{
RegisterLevel(customLevels, level);
}
EventManager.Raise(new LevelSavedEvent(level));
#if UNITY_EDITOR
UnityEditor.AssetDatabase.Refresh();
#endif
}
public Bytes Serialize()
{
ByteSerializer bs = new ByteSerializer();
bs.Serialize(EmgData);
return(bs.GetBuffer());
}
public Bytes Serialize ()
{
ByteSerializer bs = new ByteSerializer ();
bs.Serialize (EmgData);
return bs.GetBuffer ();
}
public void EmptyObjectsAndNulls()
{
var serializer = new ByteSerializer();
var model1 = new NoPropertiesModel();
var bytes1 = serializer.Serialize(model1);
var model2 = serializer.Deserialize <NoPropertiesModel>(bytes1);
Assert.IsNotNull(model2);
var model3 = new NoPropertiesModel[] {
new NoPropertiesModel(),
new NoPropertiesModel()
};
var bytes3 = serializer.Serialize(model3);
var model4 = serializer.Deserialize <NoPropertiesModel[]>(bytes3);
Assert.AreEqual(2, model4.Length);
Assert.IsNotNull(model4[0]);
Assert.IsNotNull(model4[1]);
var model5 = new NoPropertiesModel[] {
null,
null
};
var bytes5 = serializer.Serialize(model5);
var model6 = serializer.Deserialize <NoPropertiesModel[]>(bytes5);
Assert.AreEqual(2, model6.Length);
Assert.IsNull(model6[0]);
Assert.IsNull(model6[1]);
var bytes7 = serializer.Serialize(null);
var model7 = serializer.Deserialize <NoPropertiesModel>(bytes7);
Assert.IsNull(model7);
var bytes8 = serializer.Serialize(null);
var model8 = serializer.Deserialize <NoPropertiesModel[]>(bytes8);
Assert.IsNull(model8);
var model9 = new NoPropertiesModel[0];
var bytes9 = serializer.Serialize(model9);
var model10 = serializer.Deserialize <IEnumerable <NoPropertiesModel> >(bytes9);
Assert.AreEqual(model9.GetType(), model10?.GetType());
var model11 = new ArrayChainModel[] {
new ArrayChainModel()
{
ID = Guid.NewGuid(),
Children = null
}
};
var bytes11 = serializer.Serialize(model11);
var model12 = serializer.Deserialize <ArrayChainModel[]>(bytes11);
Assert.AreEqual(model11[0].Children, model12[0].Children);
}
public void SerializeAndDeserializeToTheSameObject(byte originalValue)
{
Serializer <byte> serializer = new ByteSerializer();
byte[] serializedValue = serializer.Serialize(originalValue);
byte deserializedValue = serializer.Deserialize(serializedValue);
Assert.Equal(originalValue, deserializedValue);
}
public void ByLargeSerializerIndex()
{
var serializer = new ByteSerializer(false, false, false, ByteSerializerIndexSize.UInt16);
var model1 = Factory.GetSerializerLongIndexModel();
var bytes = serializer.Serialize(model1);
var model2 = serializer.Deserialize <TestSerializerLongIndexModel>(bytes);
Factory.AssertAreEqual(model1, model2);
}
public void Types()
{
var serializer = new ByteSerializer();
var model1 = Factory.GetAllTypesModel();
var bytes = serializer.Serialize(model1);
var model2 = serializer.Deserialize <AllTypesModel>(bytes);
Factory.AssertAreEqual(model1, model2);
}
public void ByIgnoreSerailizerIndex()
{
var serializer = new ByteSerializer(false, false, true);
var model1 = Factory.GetSerializerIndexModel();
var bytes = serializer.Serialize(model1);
var model2 = serializer.Deserialize <TestSerializerIndexModel2>(bytes);
Factory.AssertAreNotEqual(model1, model2);
}
public void ExceptionObject()
{
var serializer = new ByteSerializer();
var model1 = new Exception("bad things happened");
var bytes = serializer.Serialize(model1);
var model2 = serializer.Deserialize <Exception>(bytes);
Assert.AreEqual(model1.Message, model2.Message);
}
public void BySerializerIndex()
{
var serializer = new ByteSerializer();
var model1 = Factory.GetSerializerIndexModel();
var bytes = serializer.Serialize(model1);
var model2 = serializer.Deserialize <TestSerializerIndexModel2>(bytes);
Factory.AssertAreEqual(model1, model2);
}
public void ByPropertyName()
{
var serializer = new ByteSerializer(true);
var model1 = Factory.GetAllTypesModel();
var bytes = serializer.Serialize(model1);
var model2 = serializer.Deserialize <AllTypesReversedModel>(bytes);
Factory.AssertAreEqual(model1, model2);
}
public void Boxing()
{
var serializer = new ByteSerializer(false, true);
var model1 = Factory.GetBoxingModel();
var bytes = serializer.Serialize(model1);
var model2 = serializer.Deserialize <TestBoxingModel>(bytes);
Factory.AssertAreEqual(model1, model2);
}
public void Arrays()
{
var serializer = new ByteSerializer();
var model1 = Factory.GetArrayModel();
var bytes = serializer.Serialize(model1);
var model2 = serializer.Deserialize <BasicModel[]>(bytes);
Factory.AssertAreEqual(model1, model2);
}
static void Main()
{
var file = @"c:\temp\test.bin";
IEnumerable <Yours> t = new Yours[3];
File.WriteAllBytes(file, ByteSerializer.Serialize(t));
using (var stream = File.OpenRead(file))
{
Console.WriteLine("file size: " + stream.Length);
}
}
public void StreamDeserializeArray()
{
var serializer = new ByteSerializer();
var model1 = Factory.GetArrayModel();
var bytes = serializer.Serialize(model1);
using (var ms = new MemoryStream(bytes))
{
var model2 = serializer.DeserializeAsync <BasicModel[]>(ms).GetAwaiter().GetResult();
Factory.AssertAreEqual(model1, model2);
}
}
public void StreamDeserializeByPropertyName()
{
var serializer = new ByteSerializer(true);
var model1 = Factory.GetAllTypesModel();
var bytes = serializer.Serialize(model1);
using (var ms = new MemoryStream(bytes))
{
var model2 = serializer.DeserializeAsync <AllTypesReversedModel>(ms).GetAwaiter().GetResult();
Factory.AssertAreEqual(model1, model2);
}
}
public void CookieObject()
{
var serializer = new ByteSerializer();
var model1 = new Cookie("tester", "stuff", null, null);
var bytes = serializer.Serialize(model1);
var model2 = serializer.Deserialize <Cookie>(bytes);
Assert.AreEqual(model1.Name, model2.Name);
Assert.AreEqual(model1.Value, model2.Value);
Assert.AreEqual(model1.Path, model2.Path);
Assert.AreEqual(model1.Domain, model2.Domain);
}
public void Serialize()
{
var address = new Address();
var action = new ChargeActionPoint
{
avatarAddress = address
};
var serialized = (Dictionary)action.PlainValue;
Assert.IsTrue(serialized.ContainsKey((IKey)(Text)"avatarAddress"));
Assert.AreEqual(address, serialized["avatarAddress"].ToAddress());
Assert.DoesNotThrow(() => ByteSerializer.Serialize(action));
}
public static byte[] ToBytes(object value)
{
if (value == null)
{
return(new byte[0]);
}
var serializer = new Serializer();
var serializedObject = serializer.SerializeClass(value, value.GetType());
var bytes = ByteSerializer.Serialize(serializedObject);
return(bytes);
}
public Bytes Serialize()
{
ByteSerializer bs = new ByteSerializer();
// ORDER IS MANDATORY
bs.Serialize(SerialNumber);
bs.Serialize(UnlockPose);
bs.Serialize(ActiveClassifierType);
bs.Serialize(ActiveClassifierIndex);
bs.Serialize(HasCustomClassifier);
bs.Serialize(StreamIndicating);
bs.Serialize(Sku);
bs.Serialize(Reserved);
return(bs.GetBuffer());
}
public Bytes Serialize ()
{
ByteSerializer bs = new ByteSerializer ();
// ORDER IS MANDATORY
bs.Serialize (SerialNumber);
bs.Serialize (UnlockPose);
bs.Serialize (ActiveClassifierType);
bs.Serialize (ActiveClassifierIndex);
bs.Serialize (HasCustomClassifier);
bs.Serialize (StreamIndicating);
bs.Serialize (Sku);
bs.Serialize (Reserved);
return bs.GetBuffer ();
}
public void Interface()
{
var serializer = new ByteSerializer();
ITestInterface model1 = new TestInterfaceImplemented()
{
Property1 = 5,
Property2 = 6,
Property3 = 7
};
var bytes = serializer.Serialize(model1);
var model2 = serializer.Deserialize <ITestInterface>(bytes);
Assert.AreEqual(5, model2.Property1);
Assert.AreEqual(6, model2.Property2);
}
public void WriteClientCharacteristicConfiguration(Bytes uuid, BleCCCValue value)
{
BlePeripheralCharacteristic characteristic = this.PeripheralMap.FindCharacteristicByUUID(uuid);
if (!characteristic.HasCCC)
{
throw new ArgumentException($"Client characteristic {uuid} doesn't have a configuration attribute!");
}
ByteSerializer bs = new ByteSerializer();
bs.Serialize(value);
ushort attrHandle = characteristic.HandleCCC;
this.WriteAttribute(attrHandle, bs.GetBuffer());
}
public Bytes Serialize ()
{
ByteSerializer bs = new ByteSerializer ();
// ORDER IS MANDATORY
bs.Serialize (OrientationW);
bs.Serialize (OrientationX);
bs.Serialize (OrientationY);
bs.Serialize (OrientationZ);
bs.Serialize (Accelerometer);
bs.Serialize (Gyroscope);
return bs.GetBuffer ();
}
public Bytes Serialize()
{
ByteSerializer bs = new ByteSerializer();
// ORDER IS MANDATORY
bs.Serialize(OrientationW);
bs.Serialize(OrientationX);
bs.Serialize(OrientationY);
bs.Serialize(OrientationZ);
bs.Serialize(Accelerometer);
bs.Serialize(Gyroscope);
return(bs.GetBuffer());
}
public void WithSerializer()
{
var key = SymmetricEncryptor.GenerateKey(SymmetricAlgorithmType.AESwithShift);
var serializer = new ByteSerializer();
var model1 = Factory.GetAllTypesModel();
using (var ms = new MemoryStream())
using (var cryptoStreamWriter = SymmetricEncryptor.Encrypt(SymmetricAlgorithmType.AESwithShift, key, ms, true, false))
using (var cryptoStreamReader = SymmetricEncryptor.Decrypt(SymmetricAlgorithmType.AESwithShift, key, ms, false, false))
{
var expected = serializer.Serialize(model1);
serializer.SerializeAsync(cryptoStreamWriter, model1).GetAwaiter().GetResult();
cryptoStreamWriter.FlushFinalBlock();
ms.Position = 0;
var bytes = ms.ToArray();
var model2 = serializer.DeserializeAsync <AllTypesModel>(cryptoStreamReader).GetAwaiter().GetResult();
Factory.AssertAreEqual(model1, model2);
}
}
/// <summary>
/// 插入缓存
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="key"></param>
/// <param name="data"></param>
/// <param name="cacheTime">秒钟</param>
public void Insert <T>(string key, T data, int cacheTime)
{
if (_Database == null)
{
return;
}
try
{
var timeSpan = TimeSpan.FromSeconds(cacheTime);
byte[] bytes = ByteSerializer.Serialize(data);
if (bytes != null)
{
_Database.StringSet(key, bytes, timeSpan);
}
}
catch (Exception ex)
{
//new ECFException(ex, "Cache-Redis");
}
}
/// <summary>
/// 插入缓存
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="key"></param>
/// <param name="data"></param>
public void Insert <T>(string key, T data)
{
if (_Database == null)
{
return;
}
try
{
byte[] bytes = ByteSerializer.Serialize(data);
if (bytes != null)
{
_Database.StringSet(key, bytes);
}
_Database.KeyExpire(key, new TimeSpan(0, 0, TimeOut));
}
catch (Exception ex)
{
//new ECFException(ex, "Cache-Redis");
}
}
protected override void Serialize (ByteSerializer bs)
{
bs.Serialize (EmgMode);
bs.Serialize (ImuMode);
bs.Serialize (ClassifierMode);
}
protected override void Serialize (ByteSerializer bs)
{
bs.Serialize (SleepMode);
}
protected override void Serialize (ByteSerializer bs)
{
bs.Serialize (UserAction);
}
public void WriteClientCharacteristicConfiguration (Bytes uuid, BleCCCValue value)
{
BlePeripheralCharacteristic characteristic = this.PeripheralMap.FindCharacteristicByUUID (uuid);
if (!characteristic.HasCCC)
{
throw new ArgumentException ($"Client characteristic {uuid} doesn't have a configuration attribute!");
}
ByteSerializer bs = new ByteSerializer ();
bs.Serialize (value);
ushort attrHandle = characteristic.HandleCCC;
this.WriteAttribute (attrHandle, bs.GetBuffer ());
}
protected override void Serialize (ByteSerializer bs)
{
bs.Serialize (Vibrate);
}
protected override void Serialize (ByteSerializer bs)
{
bs.Serialize (Unlock);
}
