public void ConversionMismatch()
{
var cvt = new Dictionary <Type, PacketConverter>()
{
[typeof(TestRef)] = new TestBadConverter()
};
try
{
var buf = PacketConvert.Serialize(new TestRef(), cvt);
Assert.Fail();
}
catch (PacketException ex) when(ex.ErrorCode == PacketError.ConversionMismatch)
{
// ignore
}
}
public void Collection()
{
var arr = Enumerable.Range(0, 8).Select(r => new TestIndex {
Id = r, Name = r.ToString()
}).ToArray();
var buf = PacketConvert.Serialize(arr);
var rs = PacketConvert.Deserialize <PacketReader[]>(buf);
var rr = PacketConvert.Deserialize <PacketRawReader[]>(buf);
var ra = PacketConvert.Deserialize <TestIndex[]>(buf);
var rl = PacketConvert.Deserialize <List <TestIndex> >(buf);
var ri = PacketConvert.Deserialize <IList <TestIndex> >(buf);
var rc = PacketConvert.Deserialize <ICollection <TestIndex> >(buf);
ThrowIfNotSequenceEqual(arr, ra);
ThrowIfNotSequenceEqual(arr, rl);
ThrowIfNotSequenceEqual(arr, ri);
ThrowIfNotSequenceEqual(arr, rc);
return;
}
public void SerializeObjectDirectly()
{
var a = 1;
var b = "Sample text.";
var c = new[] { 1, 2, 3, 4, 5, 6, 7, 8 };
var ta = PacketConvert.Serialize(a);
var tb = PacketConvert.Serialize(b);
var tc = PacketConvert.Serialize(c);
var sa = PacketConvert.GetValue <int>(ta);
var sb = PacketConvert.GetValue(tb, typeof(string)) as string;
var sc = new PacketReader(tc);
Assert.AreEqual(a, sa);
Assert.AreEqual(b, sb);
Assert.AreEqual(b, Encoding.UTF8.GetString(tb));
ThrowIfNotSequenceEqual(c, sc.GetEnumerable <int>());
}
public void HashSet()
{
var a = new HashSet <byte>()
{
1, 128, 255
};
var b = new HashSet <string>()
{
"a", "beta", "candy", "dave"
};
var ta = PacketConvert.Serialize(a);
var tb = new PacketWriter().SetEnumerable("b", b).GetBytes();
var ra = PacketConvert.Deserialize <HashSet <byte> >(ta);
var rea = new PacketReader(tb);
var rb = rea["b"].GetHashSet <string>();
ThrowIfNotEqual(a, ra);
ThrowIfNotEqual(b, rb);
return;
}
public void EmptyCollection()
{
var obj = new
{
array = new int[0],
bytes = new byte[0],
sbytes = new sbyte[0],
empty = new IPAddress[0],
numbers = new List <double>(),
list = new List <string>()
};
var buf = PacketConvert.Serialize(obj);
var res = PacketConvert.Deserialize(buf, obj);
ThrowIfNotSequenceEqual(obj.array, res.array);
ThrowIfNotSequenceEqual(obj.list, res.list);
ThrowIfNotSequenceEqual(obj.numbers, res.numbers);
ThrowIfNotSequenceEqual(obj.empty, res.empty);
ThrowIfNotSequenceEqual(obj.bytes, res.bytes);
ThrowIfNotSequenceEqual(obj.sbytes, res.sbytes);
return;
}
public void DynamicObjectArray()
{
var target = Enumerable.Range(0, 16).Select(x => (dynamic) new PacketWriter()).ToArray();
for (var i = 0; i < target.Length; i++)
{
var writer = target[i];
writer.id = i;
writer.body.name = $"{i:d2}";
}
var buffer = PacketConvert.Serialize(target.Cast <PacketWriter>());
var result = PacketConvert.Deserialize(buffer, anonymous: new[] { new { id = 0, body = new { name = (string)null } } });
Assert.AreEqual(16, result.Length);
for (var i = 0; i < result.Length; i++)
{
var item = result[i];
Assert.IsNotNull(item);
Assert.AreEqual(i, item.id);
Assert.AreEqual($"{i:d2}", item.body.name);
}
}
public void DirectConvert()
{
var a = 1.1;
var b = "some";
var tax = PacketConvert.GetBytes(a);
var tay = PacketConvert.GetBytes(a, typeof(double));
var tbx = PacketConvert.GetBytes(b);
var tby = PacketConvert.GetBytes(b, typeof(string));
var rax = PacketConvert.GetValue <double>(tax);
var ray = PacketConvert.GetValue(tay, typeof(double));
var rbx = PacketConvert.GetValue <string>(tbx);
var rby = PacketConvert.GetValue(tby, typeof(string));
Assert.AreEqual(a, rax);
Assert.AreEqual(a, ray);
Assert.AreEqual(b, rbx);
Assert.AreEqual(b, rby);
var off = new Random().Next(8, 16);
var ba = new byte[128];
Buffer.BlockCopy(tax, 0, ba, off, tax.Length);
var bb = new byte[128];
Buffer.BlockCopy(tbx, 0, bb, off, tbx.Length);
var sax = PacketConvert.GetValue <double>(ba, off, tax.Length);
var say = PacketConvert.GetValue(ba, off, tax.Length, typeof(double));
var sbx = PacketConvert.GetValue <string>(bb, off, tbx.Length);
var sby = PacketConvert.GetValue(bb, off, tbx.Length, typeof(string));
Assert.AreEqual(a, sax);
Assert.AreEqual(a, say);
Assert.AreEqual(b, sbx);
Assert.AreEqual(b, sby);
}
public void Dictionary()
{
var a = new Dictionary <string, sbyte> {
["a"] = 1, ["beta"] = -1, ["other"] = 127
};
var b = new Dictionary <byte, string> {
[1] = "one", [128] = "many", [255] = "max", [0] = "zero"
};
var c = new Dictionary <string, IPAddress> {
["loopback"] = IPAddress.Loopback, ["ipv6 loopback"] = IPAddress.IPv6Loopback
};
var obj = new { a, b, c };
var ta = PacketConvert.Serialize(obj);
var va = PacketConvert.Deserialize(ta, new { a = default(Dictionary <string, sbyte>), b = default(IDictionary <byte, string>), c = default(IDictionary <string, IPAddress>) });
var wtr = new PacketWriter()
.SetDictionary("a", a)
.SetDictionary("b", b)
.SetDictionary("c", c);
var tb = wtr.GetBytes();
var rea = new PacketReader(tb);
var ra = rea["a"].GetDictionary <string, sbyte>();
var rb = rea["b"].GetDictionary <byte, string>();
var rc = rea["c"].GetDictionary <string, IPAddress>();
Assert.AreEqual(ta.Length, tb.Length);
ThrowIfNotEqual(a, ra);
ThrowIfNotEqual(b, rb);
ThrowIfNotEqual(c, rc);
ThrowIfNotEqual(a, va.a);
ThrowIfNotEqual(b, va.b);
ThrowIfNotEqual(c, va.c);
return;
}
public void DeserializeOffset()
{
var obj = new { id = 1.1, text = "what the" };
var ta = PacketConvert.Serialize(obj);
var buf = new byte[ta.Length + 128];
var off = new Random().Next(8, 32);
Buffer.BlockCopy(ta, 0, buf, off, ta.Length);
var ra = PacketConvert.Deserialize(ta, obj.GetType());
var rb = PacketConvert.Deserialize(buf, off, ta.Length, obj.GetType());
void AreEqual(object a, object b)
{
var x = a.Cast(obj);
var y = b.Cast(obj);
if (x.id == y.id && x.text == y.text)
{
return;
}
throw new ApplicationException();
}
AreEqual(obj, ra);
AreEqual(obj, rb);
var str = "world";
var tb = PacketConvert.GetBytes(str);
var tc = new byte[tb.Length + 128];
Buffer.BlockCopy(tb, 0, tc, off, tb.Length);
var rc = PacketConvert.Deserialize <string>(tc, off, tb.Length);
Assert.AreEqual(str, rc);
}
public void SerializeDictionaryDirectly()
{
var a = 1;
var b = "some";
var dic = new Dictionary <string, object>
{
["a"] = a,
["b"] = b,
["c"] = new Dictionary <string, object>()
{
["a"] = a,
["b"] = b,
}
};
var buf = PacketConvert.Serialize(dic);
var rea = new PacketReader(buf);
Assert.AreEqual(dic.Count, rea.Count);
Assert.AreEqual(dic.Count, rea.Keys.Count());
Assert.AreEqual(a, rea["a"].GetValue <int>());
Assert.AreEqual(b, rea["b"].GetValue <string>());
Assert.AreEqual(a, rea["c/a"].GetValue <int>());
Assert.AreEqual(b, rea["c/b"].GetValue <string>());
}
public void KeyValueCollection()
{
try
{
var collection = Enumerable.Range(0, 8).Select(r => new KeyValuePair <int, string>(r, r.ToString()));
var buffer = PacketConvert.Serialize(collection);
Assert.Fail();
}
catch (PacketException ex) when(ex.ErrorCode == PacketError.InvalidType)
{
// ignore
}
try
{
var kvp = new KeyValuePair <string, double>("one", 1.0);
var buffer = PacketConvert.Serialize(kvp);
Assert.Fail();
}
catch (PacketException ex) when(ex.ErrorCode == PacketError.InvalidType)
{
// ignore
}
}
private void SendPacket(Request request)
{
byte[] requestPkt = PacketConvert.RequestToByte(request);
Connect();
_socket.Send(requestPkt);
}
private async Task _Start()
{
var soc = default(Socket);
var iep = default(IPEndPoint);
for (int i = 0; i < _endpoints.Length; i++)
{
if (soc != null)
{
break;
}
soc = new Socket(SocketType.Stream, ProtocolType.Tcp);
iep = _endpoints[i];
try
{
await soc.ConnectAsyncEx(iep).TimeoutAfter("Share receiver timeout.");
}
catch (Exception err)
{
Log.Error(err);
soc.Dispose();
soc = null;
}
}
if (soc == null)
{
Status = ShareStatus.失败;
Dispose();
return;
}
var buf = PacketConvert.Serialize(new
{
path = "share." + (_batch ? "directory" : "file"),
data = _key,
source = LinkModule.Id,
target = Id,
});
try
{
soc.SetKeepAlive();
await soc.SendAsyncExt(buf);
Status = ShareStatus.运行;
await _Receive(soc, _cancel.Token);
Status = ShareStatus.成功;
PostModule.Notice(Id, _batch ? "share.dir" : "share.file", _origin);
}
catch (OperationCanceledException)
{
Status = ShareStatus.取消;
}
catch (Exception ex)
{
Log.Error(ex);
Status = ShareStatus.中断;
}
finally
{
soc.Dispose();
Dispose();
}
}
/// <summary>
/// Performance test
/// </summary>
internal static void DoWork()
{
var dic = new Dictionary <string, List <TimeSpan> >();
TraceWatch.InstanceDisposed = (tag, span) =>
{
if (dic.TryGetValue(tag, out var val))
{
val.Add(span);
}
else
{
dic.Add(tag, new List <TimeSpan>()
{
span
});
}
};
const int max = 1 << 20;
const int loop = 10;
var ano = new
{
num = 1024,
str = "string",
arr = new[] { 7, 11, 555, 1313 },
sub = new
{
sum = 2.2D,
lst = new List <string> {
"one", "two", "three"
},
}
};
var tmp = PacketConvert.Serialize(ano);
// release mode
for (int idx = 0; idx < loop; idx++)
{
using (new TraceWatch("BitConverter")) // 8.00 ms
{
for (int i = 0; i < max; i++)
{
var buf = BitConverter.GetBytes(i);
var res = BitConverter.ToInt32(buf, 0);
}
}
using (new TraceWatch("PacketWriter<>")) // 2228.99 ms, avg
{
for (int i = 0; i < max; i++)
{
var wtr = new PacketWriter().
SetValue(nameof(ano.num), ano.num).
SetValue(nameof(ano.str), ano.str).
SetEnumerable(nameof(ano.arr), ano.arr).
SetItem(nameof(ano.sub), new PacketWriter().
SetValue(nameof(ano.sub.sum), ano.sub.sum).
SetEnumerable(nameof(ano.sub.lst), ano.sub.lst));
var buf = wtr.GetBytes();
}
}
using (new TraceWatch("Serialize (anonymous)")) // 2453.45 ms, avg
{
for (int i = 0; i < max; i++)
{
var _ = PacketConvert.Serialize(ano);
}
}
using (new TraceWatch("Deserialize (anonymous)")) // 1960.96 ms, avg
{
for (int i = 0; i < max; i++)
{
var _ = PacketConvert.Deserialize(tmp, ano);
}
}
}
foreach (var i in dic)
{
var key = i.Key;
var val = i.Value;
if (val.Count > 6)
{
val.RemoveRange(0, 4);
}
var sum = val.Select(r => r.Ticks).Sum();
var cir = new TimeSpan(sum / val.Count);
var avg = new TimeSpan(1000 * sum / val.Count / max);
Console.WriteLine($"{key,-24} | " +
$"total: {new TimeSpan(sum).TotalMilliseconds,10:0.000} ms | " +
$"loop: {cir.TotalMilliseconds,10:0.000} ms | " +
$"avg: {avg.TotalMilliseconds,10:0.0000} ns");
}
}
public void InvalidType()
{
try
{
var list = new HashSet <object> {
1.2F, 3.4D, "5.6M"
};
var result = PacketConvert.Serialize(list);
Assert.Fail();
}
catch (PacketException ex) when(ex.ErrorCode == PacketError.InvalidElementType)
{
// ignore
}
try
{
var empty = new byte[0];
var reader = new PacketReader(empty);
var result = reader.Deserialize <Dictionary <object, string> >();
Assert.Fail();
}
catch (PacketException ex) when(ex.ErrorCode == PacketError.InvalidKeyType)
{
// ignore
}
try
{
var empty = new Dictionary <object, string>();
var writer = PacketWriter.Serialize(empty);
Assert.Fail();
}
catch (PacketException ex) when(ex.ErrorCode == PacketError.InvalidKeyType)
{
// ignore
}
var array = new[] { 0F, -1.1F, 2.2F };
var anonymous = new { solution = "Exchange", count = 4 };
var collection = new Dictionary <int, object>
{
[1] = 1,
[2] = 2L,
[4] = "four",
[8] = anonymous,
[16] = array,
};
var buffer = PacketConvert.Serialize(collection);
var dictionary = PacketConvert.Deserialize <Dictionary <int, object> >(buffer);
var r1 = ((PacketReader)dictionary[1]).GetValue <int>();
var r2 = ((PacketReader)dictionary[2]).GetValue <long>();
var r4 = ((PacketReader)dictionary[4]).GetValue <string>();
var ro = ((PacketReader)dictionary[8]).Deserialize(anonymous.GetType());
var ra = ((PacketReader)dictionary[16]).GetArray <float>();
Assert.AreEqual(collection[1], r1);
Assert.AreEqual(collection[2], r2);
Assert.AreEqual(collection[4], r4);
Assert.AreEqual(anonymous, ro);
ThrowIfNotSequenceEqual(array, ra);
}
