mirror of
https://github.com/esiur/esiur-dotnet.git
synced 2025-05-06 11:32:59 +00:00
1070 lines
31 KiB
C#
1070 lines
31 KiB
C#
using System;
|
|
using System.Collections.Generic;
|
|
using System.Linq;
|
|
using System.Text;
|
|
using Esiur.Net.IIP;
|
|
|
|
using System.Runtime.InteropServices;
|
|
using System.Diagnostics;
|
|
using System.Net;
|
|
using System.Net.NetworkInformation;
|
|
using System.Reflection;
|
|
using Esiur.Data;
|
|
using Esiur.Engine;
|
|
using Esiur.Resource;
|
|
|
|
namespace Esiur.Data
|
|
{
|
|
public static class DC // Data Converter
|
|
{
|
|
public static object CastConvert(object value, Type destinationType)
|
|
{
|
|
if (value == null)
|
|
return null;
|
|
|
|
var sourceType = value.GetType();
|
|
|
|
if (destinationType == sourceType)
|
|
{
|
|
return value;
|
|
}
|
|
else
|
|
{
|
|
if (sourceType.IsArray)
|
|
{
|
|
if (destinationType.IsArray)
|
|
destinationType = destinationType.GetElementType();
|
|
|
|
var v = value as Array;
|
|
|
|
var rt = Array.CreateInstance(destinationType, v.Length);
|
|
|
|
for (var i = 0; i < rt.Length; i++)
|
|
{
|
|
try
|
|
{
|
|
#if NETSTANDARD1_5
|
|
if (destinationType.GetTypeInfo().IsInstanceOfType(v.GetValue(i)))
|
|
#else
|
|
if (destinationType.IsInstanceOfType(v.GetValue(i)))
|
|
#endif
|
|
rt.SetValue(v.GetValue(i), i);
|
|
else
|
|
rt.SetValue(Convert.ChangeType(v.GetValue(i), destinationType), i);
|
|
}
|
|
catch
|
|
{
|
|
rt.SetValue(null, i);
|
|
}
|
|
}
|
|
|
|
return rt;
|
|
}
|
|
else
|
|
{
|
|
try
|
|
{
|
|
#if NETSTANDARD1_5
|
|
if (destinationType.GetTypeInfo().IsInstanceOfType(value))
|
|
#else
|
|
if (destinationType.IsInstanceOfType(value))
|
|
#endif
|
|
return value;
|
|
else
|
|
return Convert.ChangeType(value, destinationType);
|
|
}
|
|
catch
|
|
{
|
|
return null;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
/*
|
|
private static byte[] ReverseArray(byte[] data, uint offset, uint count)
|
|
{
|
|
if (offset + count > data.Length)
|
|
{
|
|
Console.WriteLine("ReverseArray: Bad offset " + data.Length + " " + offset + " " + count);
|
|
|
|
StackTrace st = new StackTrace();
|
|
Console.WriteLine(st.ToString());
|
|
|
|
return null;
|
|
}
|
|
|
|
byte[] rt = new byte[count];
|
|
|
|
uint b = count;
|
|
|
|
for (var i = offset; i < (offset + count); i++)
|
|
rt[--b] = data[i];
|
|
|
|
return rt;
|
|
}
|
|
*/
|
|
|
|
/*
|
|
public static T[] ArrayFromBytes<T>(byte[] data, uint offset, uint length)
|
|
{
|
|
|
|
if (typeof(T) == typeof(string))
|
|
{
|
|
List<string> ar = new List<string>();
|
|
|
|
uint i = 0;
|
|
|
|
while (i < length)
|
|
{
|
|
var cl = GetUInt32(data, 0);
|
|
i += 4;
|
|
ar.Add(Encoding.UTF8.GetString(data, (int)(offset + i), (int)cl));
|
|
i += cl;
|
|
}
|
|
|
|
return (T[])(object)ar.ToArray();
|
|
|
|
}
|
|
else
|
|
{
|
|
uint blockSize = (uint)Marshal.SizeOf(typeof(T));
|
|
|
|
T[] ar = new T[length / blockSize];
|
|
|
|
for (uint i = 0; i < ar.Length; i += blockSize)
|
|
ar[i] = FromBytes<T>(data, offset + i);
|
|
|
|
return ar;
|
|
}
|
|
}
|
|
*/
|
|
|
|
public static sbyte GetInt8(this byte[] data, uint offset)
|
|
{
|
|
return (sbyte)data[offset];
|
|
}
|
|
|
|
public static sbyte[] GetInt8Array(this byte[] data, uint offset, uint length)
|
|
{
|
|
var rt = new sbyte[length];
|
|
Buffer.BlockCopy(rt, (int)offset, rt, 0, (int)length);
|
|
return rt;
|
|
}
|
|
|
|
public static byte GetUInt8(this byte[] data, uint offset)
|
|
{
|
|
return data[offset];
|
|
}
|
|
|
|
public static byte[] GetUInt8Array(this byte[] data, uint offset, uint length)
|
|
{
|
|
var rt = new byte[length];
|
|
Buffer.BlockCopy(rt, (int)offset, rt, 0, (int)length);
|
|
return rt;
|
|
}
|
|
|
|
public static Int16 GetInt16(this byte[] data, uint offset)
|
|
{
|
|
return (Int16)((data[offset] << 8) | data[offset + 1]);
|
|
}
|
|
|
|
public static Int16[] GetInt16Array(this byte[] data, uint offset, uint length)
|
|
{
|
|
var rt = new Int16[length/2];
|
|
for (var i = 0; i < length; i += 2)
|
|
rt[i] = GetInt16(data, (uint)(offset + i));
|
|
|
|
return rt;
|
|
}
|
|
|
|
public static UInt16 GetUInt16(this byte[] data, uint offset)
|
|
{
|
|
return (UInt16)((data[offset] << 8) | data[offset + 1]);
|
|
}
|
|
|
|
public static UInt16[] GetUInt16Array(this byte[] data, uint offset, uint length)
|
|
{
|
|
var rt = new UInt16[length / 2];
|
|
for (var i = 0; i < length; i += 2)
|
|
rt[i] = GetUInt16(data, (uint)(offset + i));
|
|
return rt;
|
|
}
|
|
|
|
public static Int32 GetInt32(this byte[] data, uint offset)
|
|
{
|
|
return (Int32)((data[offset] << 24) | (data[offset + 1] << 16) | (data[offset + 2] << 8) | data[offset + 3]);
|
|
}
|
|
|
|
public static Int32[] GetInt32Array(this byte[] data, uint offset, uint length)
|
|
{
|
|
var rt = new Int32[length / 4];
|
|
for (var i = 0; i < length; i += 4)
|
|
rt[i] = GetInt32(data, (uint)(offset + i));
|
|
|
|
return rt;
|
|
}
|
|
|
|
public static UInt32 GetUInt32(this byte[] data, uint offset)
|
|
{
|
|
return (UInt32)((data[offset] << 24) | (data[offset + 1] << 16) | (data[offset + 2] << 8) | data[offset + 3]);
|
|
}
|
|
|
|
public static UInt32[] GetUInt32Array(this byte[] data, uint offset, uint length)
|
|
{
|
|
var rt = new UInt32[length / 4];
|
|
for (var i = 0; i < length; i += 4)
|
|
rt[i] = GetUInt32(data, (uint)(offset + i));
|
|
|
|
return rt;
|
|
}
|
|
|
|
|
|
public static unsafe UInt64 GetUInt64(this byte[] data, uint offset)
|
|
{
|
|
UInt64 rt = 0;
|
|
byte* p = (byte*)&rt;
|
|
|
|
*(p + 7) = data[0];
|
|
*(p + 6) = data[1];
|
|
*(p + 5) = data[2];
|
|
*(p + 4) = data[3];
|
|
*(p + 3) = data[4];
|
|
*(p + 2) = data[5];
|
|
*(p + 1) = data[6];
|
|
*(p) = data[7];
|
|
|
|
return rt;
|
|
|
|
}
|
|
|
|
public static Int64[] GetInt64Array(this byte[] data, uint offset, uint length)
|
|
{
|
|
var rt = new Int64[length / 8];
|
|
for (var i = 0; i < length; i += 8)
|
|
rt[i] = GetInt64(data, (uint)(offset + i));
|
|
|
|
return rt;
|
|
}
|
|
|
|
public static unsafe Int64 GetInt64(this byte[] data, uint offset)
|
|
{
|
|
Int64 rt = 0;
|
|
byte* p = (byte*)&rt;
|
|
|
|
*(p + 7) = data[0];
|
|
*(p + 6) = data[1];
|
|
*(p + 5) = data[2];
|
|
*(p + 4) = data[3];
|
|
*(p + 3) = data[4];
|
|
*(p + 2) = data[5];
|
|
*(p + 1) = data[6];
|
|
*(p) = data[7];
|
|
|
|
return rt;
|
|
|
|
/* Or
|
|
return (Int64)(
|
|
(data[offset] << 56)
|
|
| (data[offset + 1] << 48)
|
|
| (data[offset + 2] << 40)
|
|
| (data[offset + 3] << 32)
|
|
| (data[offset + 4] << 24)
|
|
| (data[offset + 5] << 16)
|
|
| (data[offset + 6] << 8)
|
|
| (data[offset + 7])
|
|
);
|
|
*/
|
|
}
|
|
|
|
public static UInt64[] GetUInt64Array(this byte[] data, uint offset, uint length)
|
|
{
|
|
var rt = new UInt64[length / 8];
|
|
for (var i = 0; i < length; i += 8)
|
|
rt[i] = GetUInt64(data, (uint)(offset + i));
|
|
|
|
return rt;
|
|
}
|
|
|
|
public static unsafe float GetFloat32(this byte[] data, uint offset)
|
|
{
|
|
float rt = 0;
|
|
byte* p = (byte*)&rt;
|
|
*p = data[offset + 3];
|
|
*(p + 1) = data[offset + 2];
|
|
*(p + 2) = data[offset + 1];
|
|
*(p + 3) = data[offset];
|
|
return rt;
|
|
}
|
|
|
|
public static float[] GetFloat32Array(this byte[] data, uint offset, uint length)
|
|
{
|
|
var rt = new float[length / 4];
|
|
for (var i = 0; i < length; i += 4)
|
|
rt[i] = GetFloat32(data, (uint)(offset + i));
|
|
|
|
return rt;
|
|
}
|
|
|
|
public static unsafe double GetFloat64(this byte[] data, uint offset)
|
|
{
|
|
double rt = 0;
|
|
byte* p = (byte*)&rt;
|
|
|
|
*(p + 7) = data[0];
|
|
*(p + 6) = data[1];
|
|
*(p + 5) = data[2];
|
|
*(p + 4) = data[3];
|
|
*(p + 3) = data[4];
|
|
*(p + 2) = data[5];
|
|
*(p + 1) = data[6];
|
|
*(p) = data[7];
|
|
|
|
return rt;
|
|
}
|
|
|
|
public static double[] GetFloat64Array(this byte[] data, uint offset, uint length)
|
|
{
|
|
var rt = new double[length / 8];
|
|
for (var i = 0; i < length; i += 8)
|
|
rt[i] = GetFloat64(data, (uint)(offset + i));
|
|
|
|
return rt;
|
|
}
|
|
|
|
public static bool GetBoolean(this byte[] data, uint offset)
|
|
{
|
|
return data[offset] > 0;
|
|
}
|
|
|
|
public static bool[] GetBooleanArray(this byte[] data, uint offset, uint length)
|
|
{
|
|
var rt = new bool[length];
|
|
for (var i = 0; i < length; i++)
|
|
rt[i] = data[offset + i] > 0;
|
|
return rt;
|
|
}
|
|
|
|
public static char GetChar(this byte[] data, uint offset)
|
|
{
|
|
return Convert.ToChar(((data[offset] << 8) | data[offset + 1]));
|
|
}
|
|
|
|
public static char[] GetCharArray(this byte[] data, uint offset, uint length)
|
|
{
|
|
var rt = new char[length/2];
|
|
for (var i = 0; i < length; i+=2)
|
|
rt[i] = GetChar(data, (uint)(offset + i));
|
|
return rt;
|
|
}
|
|
|
|
public static string GetString(this byte[] data, uint offset, uint length)
|
|
{
|
|
return Encoding.UTF8.GetString(data, (int)offset, (int)length);
|
|
}
|
|
|
|
public static string[] GetStringArray(this byte[] data, uint offset, uint length)
|
|
{
|
|
List<string> ar = new List<string>();
|
|
|
|
uint i = 0;
|
|
|
|
while (i < length)
|
|
{
|
|
var cl = GetUInt32(data, offset + i);
|
|
i += 4;
|
|
ar.Add(Encoding.UTF8.GetString(data, (int)(offset + i), (int)cl));
|
|
i += cl;
|
|
}
|
|
|
|
return ar.ToArray();
|
|
}
|
|
|
|
public static Guid GetGuid(this byte[] data, uint offset)
|
|
{
|
|
return new Guid(DC.Clip(data, offset, 16));
|
|
}
|
|
|
|
public static Guid[] GetGuidArray(this byte[] data, uint offset, uint length)
|
|
{
|
|
var rt = new Guid[length / 16];
|
|
for (var i = 0; i < length; i += 16)
|
|
rt[i] = GetGuid(data, (uint)(offset + i));
|
|
return rt;
|
|
}
|
|
|
|
public static DateTime GetDateTime(this byte[] data, uint offset)
|
|
{
|
|
var ticks = GetInt64(data, offset);
|
|
return new DateTime(ticks, DateTimeKind.Utc);
|
|
}
|
|
|
|
public static DateTime[] GetDateTimeArray(this byte[] data, uint offset, uint length)
|
|
{
|
|
var rt = new DateTime[length / 8];
|
|
for (var i = 0; i < length; i += 8)
|
|
rt[i] = GetDateTime(data, (uint)(offset + i));
|
|
return rt;
|
|
}
|
|
|
|
/*
|
|
public static PhysicalAddress GetPhysicalAddress(this byte[] data, uint offset)
|
|
{
|
|
return new PhysicalAddress(Clip(data, offset, 6));
|
|
}
|
|
|
|
public static PhysicalAddress[] GetPhysicalAddressArray(this byte[] data, uint offset, uint length)
|
|
{
|
|
var rt = new PhysicalAddress[length / 6];
|
|
for (var i = 0; i < length; i += 6)
|
|
rt[i] = GetPhysicalAddress(data, (uint)(offset + i));
|
|
return rt;
|
|
}
|
|
*/
|
|
public static IPAddress GetIPv4Address(this byte[] data, uint offset)
|
|
{
|
|
return new IPAddress((long)GetUInt32(data, offset));
|
|
}
|
|
|
|
public static IPAddress[] GetIPv4AddressArray(this byte[] data, uint offset, uint length)
|
|
{
|
|
var rt = new IPAddress[length / 4];
|
|
for (var i = 0; i < length; i += 4)
|
|
rt[i] = GetIPv4Address(data, (uint)(offset + i));
|
|
return rt;
|
|
}
|
|
|
|
public static IPAddress GetIPv6Address(this byte[] data, uint offset)
|
|
{
|
|
return new IPAddress(Clip(data, offset, 16));
|
|
}
|
|
|
|
public static IPAddress[] GetIPv6AddressArray(this byte[] data, uint offset, uint length)
|
|
{
|
|
var rt = new IPAddress[length / 16];
|
|
for (var i = 0; i < length; i += 16)
|
|
rt[i] = GetIPv6Address(data, (uint)(offset + i));
|
|
return rt;
|
|
}
|
|
|
|
/*
|
|
public static T FromBytes<T>(byte[] data, uint offset, uint length = 0)
|
|
{
|
|
if (typeof(T) == typeof(bool))
|
|
{
|
|
return (T)(object)(data[offset] == 1);
|
|
}
|
|
else if (typeof(T) == typeof(byte))
|
|
{
|
|
return (T)(object)data[offset];
|
|
}
|
|
else if (typeof(T) == typeof(char))
|
|
{
|
|
return (T)(object)BitConverter.ToChar(ReverseArray(data, offset, 2), 0);
|
|
}
|
|
else if (typeof(T) == typeof(short))
|
|
{
|
|
return (T)(object)BitConverter.ToInt16(ReverseArray(data, offset, 2), 0);
|
|
}
|
|
else if (typeof(T) == typeof(ushort))
|
|
{
|
|
return (T)(object)BitConverter.ToUInt16(ReverseArray(data, offset, 2), 0);
|
|
}
|
|
else if (typeof(T) == typeof(int))
|
|
{
|
|
return (T)(object)BitConverter.ToInt32(ReverseArray(data, offset, 4), 0);
|
|
}
|
|
else if (typeof(T) == typeof(uint))
|
|
{
|
|
return (T)(object)BitConverter.ToUInt32(ReverseArray(data, offset, 4), 0);
|
|
}
|
|
else if (typeof(T) == typeof(long))
|
|
{
|
|
return (T)(object)BitConverter.ToInt64(ReverseArray(data, offset, 8), 0);
|
|
}
|
|
else if (typeof(T) == typeof(ulong))
|
|
{
|
|
return (T)(object)BitConverter.ToUInt64(ReverseArray(data, offset, 8), 0);
|
|
}
|
|
else if (typeof(T) == typeof(float))
|
|
{
|
|
return (T)(object)BitConverter.ToSingle(ReverseArray(data, offset, 4), 0);
|
|
}
|
|
else if (typeof(T) == typeof(double))
|
|
{
|
|
return (T)(object)BitConverter.ToDouble(ReverseArray(data, offset, 8), 0);
|
|
}
|
|
else if (typeof(T) == typeof(string))
|
|
{
|
|
return (T)(object)Encoding.UTF8.GetString(data, (int)offset, (int)length);
|
|
}
|
|
else if (typeof(T) == typeof(Guid))
|
|
{
|
|
return (T)(object)new Guid(DC.Clip(data, offset, 16));
|
|
}
|
|
else if (typeof(T) == typeof(IPAddress))
|
|
{
|
|
if (length == 0)
|
|
return (T)(object)(new IPAddress((long)GetUInt32(data, offset)));
|
|
else
|
|
return (T)(object)(new IPAddress(Clip(data, offset, length)));
|
|
}
|
|
else if (typeof(T) == typeof(PhysicalAddress))
|
|
{
|
|
return (T)(object)new PhysicalAddress(Clip(data, offset, 6));
|
|
}
|
|
else if (typeof(T) == typeof(DateTime))
|
|
{
|
|
long ticks = BitConverter.ToInt64(ReverseArray(data, offset, 8), 0);
|
|
return (T)(object)new DateTime(ticks, DateTimeKind.Utc);
|
|
}
|
|
else
|
|
{
|
|
return default(T);
|
|
}
|
|
}
|
|
*/
|
|
|
|
public static byte[] ToBytes(sbyte value)
|
|
{
|
|
return new byte[1] { (byte)value };
|
|
}
|
|
|
|
public static byte[] ToBytes(byte value)
|
|
{
|
|
return new byte[1] { value };
|
|
}
|
|
|
|
public static byte[] ToBytes(IPAddress ip)
|
|
{
|
|
return ip.GetAddressBytes();
|
|
}
|
|
|
|
public static byte[] ToBytes(PhysicalAddress mac)
|
|
{
|
|
return mac.GetAddressBytes();
|
|
}
|
|
|
|
public static byte[] ToBytes(bool value)
|
|
{
|
|
return new byte[1] { value ? (byte)1 : (byte)0 };
|
|
}
|
|
|
|
public static byte ToByte(bool value)
|
|
{
|
|
return value ? (byte)1 : (byte)0;
|
|
}
|
|
|
|
public static byte[] ToBytes(byte[] value)
|
|
{
|
|
return value;
|
|
}
|
|
|
|
//public static byte[] ToBytes(Codec value)
|
|
//{
|
|
// return value.ToStructuredValue();
|
|
//}
|
|
|
|
public static byte[] ToBytes(bool[] value)
|
|
{
|
|
|
|
byte[] ba = new byte[value.Length];
|
|
|
|
for (int i = 0; i < ba.Length; i++)
|
|
ba[i] = DC.ToByte(value[i]);
|
|
|
|
return ba;
|
|
}
|
|
|
|
|
|
/*
|
|
public static byte[] ToBytes(IResource value)
|
|
{
|
|
|
|
if (value is DistributedResource)
|
|
return DC.ToBytes((value as DistributedResource).Id);
|
|
else
|
|
{
|
|
List<byte> rt = new List<byte>();
|
|
// Add GUID
|
|
rt.AddRange(value.Instance.Template.ClassId.ToByteArray());
|
|
// Add Instance ID
|
|
rt.AddRange(DC.ToBytes(value.Instance.Id));
|
|
|
|
return rt.ToArray();
|
|
}
|
|
}
|
|
*/
|
|
|
|
/*
|
|
public static byte[] ToBytes(Structure value)
|
|
{
|
|
return value.Compose();
|
|
}*/
|
|
|
|
public static byte[] ToBytes(char value)
|
|
{
|
|
byte[] ret = BitConverter.GetBytes(value);
|
|
Array.Reverse(ret);
|
|
return ret;
|
|
}
|
|
|
|
public static byte[] ToBytes(Guid value)
|
|
{
|
|
return value.ToByteArray();
|
|
}
|
|
|
|
public static byte[] ToBytes(char[] value)
|
|
{
|
|
List<byte> rt = new List<byte>();
|
|
|
|
for (int i = 0; i < value.Length; i++)
|
|
rt.AddRange(ToBytes(value[i]));
|
|
|
|
return rt.ToArray();
|
|
}
|
|
|
|
public static byte[] ToBytes(short[] value)
|
|
{
|
|
List<byte> rt = new List<byte>();
|
|
|
|
for (int i = 0; i < value.Length; i++)
|
|
rt.AddRange(ToBytes(value[i]));
|
|
|
|
return rt.ToArray();
|
|
}
|
|
|
|
|
|
|
|
public static byte[] ToBytes(ushort[] value)
|
|
{
|
|
List<byte> rt = new List<byte>();
|
|
|
|
for (int i = 0; i < value.Length; i++)
|
|
rt.AddRange(ToBytes(value[i]));
|
|
|
|
return rt.ToArray();
|
|
}
|
|
|
|
public static void Append(ref byte[] dst, byte[] src)
|
|
{
|
|
Append(ref dst, src, (uint)0, (uint)src.Length);
|
|
}
|
|
|
|
public static void Append(ref byte[] dst, byte[] src, uint srcOffset, uint length)
|
|
{
|
|
var dstOffset = dst.Length;
|
|
Array.Resize<byte>(ref dst, dstOffset + (int)length);
|
|
Buffer.BlockCopy(src, (int)srcOffset, dst, dstOffset, (int)length);
|
|
}
|
|
|
|
public static byte[] Combine(byte[] src1, uint src1Offset, uint src1Length, byte[] src2, uint src2Offset, uint src2Length)
|
|
{
|
|
var rt = new byte[src1Length + src2Length];
|
|
Buffer.BlockCopy(src1, (int)src1Offset, rt, 0, (int)src1Length);
|
|
Buffer.BlockCopy(src2, (int)src2Offset, rt, (int)src1Length, (int)src2Length);
|
|
return rt;
|
|
}
|
|
|
|
public static byte[] Merge(params byte[][] arrays)
|
|
{
|
|
var s = arrays.Sum(x => x.Length);
|
|
var r = new byte[s];
|
|
var offset = 0;
|
|
foreach (var array in arrays)
|
|
{
|
|
Buffer.BlockCopy(array, 0, r, offset, array.Length);
|
|
offset += array.Length;
|
|
}
|
|
|
|
return r;
|
|
}
|
|
|
|
public static byte[] Clip(this byte[] data, uint offset, uint length)
|
|
{
|
|
if (data.Length < offset + length)
|
|
return null;
|
|
|
|
if (length == data.Length && offset == 0)
|
|
return data;
|
|
|
|
var b = new byte[length];
|
|
Buffer.BlockCopy(data, (int)offset, b, 0, (int)length);
|
|
return b;
|
|
}
|
|
|
|
public static byte[] ToBytes(int[] value)
|
|
{
|
|
List<byte> rt = new List<byte>();
|
|
|
|
for (int i = 0; i < value.Length; i++)
|
|
rt.AddRange(ToBytes(value[i]));
|
|
|
|
return rt.ToArray();
|
|
}
|
|
|
|
public static byte[] ToBytes(uint[] value)
|
|
{
|
|
List<byte> rt = new List<byte>();
|
|
|
|
for (int i = 0; i < value.Length; i++)
|
|
rt.AddRange(ToBytes(value[i]));
|
|
|
|
return rt.ToArray();
|
|
}
|
|
|
|
public static byte[] ToBytes(long[] value)
|
|
{
|
|
List<byte> rt = new List<byte>();
|
|
|
|
for (int i = 0; i < value.Length; i++)
|
|
rt.AddRange(ToBytes(value[i]));
|
|
|
|
return rt.ToArray();
|
|
}
|
|
|
|
public static byte[] ToBytes(ulong[] value)
|
|
{
|
|
List<byte> rt = new List<byte>();
|
|
|
|
for (int i = 0; i < value.Length; i++)
|
|
rt.AddRange(ToBytes(value[i]));
|
|
|
|
return rt.ToArray();
|
|
}
|
|
|
|
public static byte[] ToBytes(float[] value)
|
|
{
|
|
List<byte> rt = new List<byte>();
|
|
|
|
for (int i = 0; i < value.Length; i++)
|
|
rt.AddRange(ToBytes(value[i]));
|
|
|
|
return rt.ToArray();
|
|
}
|
|
|
|
public static byte[] ToBytes(double[] value)
|
|
{
|
|
List<byte> rt = new List<byte>();
|
|
|
|
for (int i = 0; i < value.Length; i++)
|
|
rt.AddRange(ToBytes(value[i]));
|
|
|
|
return rt.ToArray();
|
|
}
|
|
|
|
|
|
public static byte[] ToBytes(decimal[] value)
|
|
{
|
|
List<byte> rt = new List<byte>();
|
|
|
|
for (int i = 0; i < value.Length; i++)
|
|
rt.AddRange(ToBytes(value[i]));
|
|
|
|
return rt.ToArray();
|
|
}
|
|
|
|
|
|
public static byte[] ToBytes(DateTime[] value)
|
|
{
|
|
List<byte> rt = new List<byte>();
|
|
|
|
for (int i = 0; i < value.Length; i++)
|
|
rt.AddRange(ToBytes(value[i]));
|
|
|
|
return rt.ToArray();
|
|
}
|
|
|
|
|
|
public static byte[] ToBytes(string[] value)
|
|
{
|
|
List<byte> rt = new List<byte>();
|
|
|
|
for (int i = 0; i < value.Length; i++)
|
|
{
|
|
byte[] ba = ToBytes(value[i]);
|
|
// add string length
|
|
rt.AddRange(ToBytes(ba.Length));
|
|
// add encoded string
|
|
rt.AddRange(ba);
|
|
}
|
|
|
|
return rt.ToArray();
|
|
}
|
|
|
|
public static byte[] ToBytes(int value)
|
|
{
|
|
byte[] ret = BitConverter.GetBytes(value);
|
|
|
|
Array.Reverse(ret);
|
|
|
|
return ret;
|
|
}
|
|
|
|
public static byte[] ToBytes(short value)
|
|
{
|
|
byte[] ret = BitConverter.GetBytes(value);
|
|
|
|
Array.Reverse(ret);
|
|
|
|
return ret;
|
|
}
|
|
|
|
public static byte[] ToBytes(float value)
|
|
{
|
|
byte[] ret = BitConverter.GetBytes(value);
|
|
|
|
Array.Reverse(ret);
|
|
|
|
return ret;
|
|
}
|
|
|
|
/*
|
|
public static byte[] ToBytes(Structure[] values)
|
|
{
|
|
if (values == null || values.Length == 0)
|
|
return new byte[0];
|
|
|
|
var rt = new BinaryList();
|
|
var previous = values[0];
|
|
|
|
// include first one
|
|
if (previous == null)
|
|
rt.Append((byte)Structure.ComparisonResult.Null);
|
|
else
|
|
rt.Append((byte)Structure.ComparisonResult.DifferentStructure, previous.Compose(true,true,true));
|
|
|
|
for (var i = 1; i < values.Length; i++)
|
|
{
|
|
var current = values[i];
|
|
var results = Structure.Compare(previous, current);
|
|
|
|
rt.Append((byte)results);
|
|
|
|
if (results == Structure.ComparisonResult.DifferentStructure)
|
|
rt.Append(current.Compose(true, true, true));
|
|
else if (results == Structure.ComparisonResult.SameStructureDifferentValueTypes)
|
|
rt.Append(current.Compose(false));
|
|
else if (results == Structure.ComparisonResult.SameStructureDifferentValues)
|
|
rt.Append(current.Compose(false, false));
|
|
}
|
|
|
|
return rt.ToArray();
|
|
}
|
|
|
|
|
|
public static byte[] ToBytes(IIPObject[] values)
|
|
{
|
|
if (values == null || values.Length == 0)
|
|
return new byte[0];
|
|
|
|
var rt = new BinaryList();
|
|
var previous = values[0];
|
|
|
|
// include first one
|
|
if (previous == null)
|
|
rt.Append((byte)IIPObject.ComparisonResult.Null);
|
|
else
|
|
rt.Append((byte)IIPObject.ComparisonResult.DifferentObject, previous.GUID.ToByteArray(), previous.InstanceID);
|
|
|
|
for (var i = 1; i < values.Length; i++)
|
|
{
|
|
var current = values[i];
|
|
var results = IIPObject.Compare(previous, current);
|
|
|
|
rt.Append((byte)results);
|
|
|
|
if (results == IIPObject.ComparisonResult.DifferentObject)
|
|
rt.Append(current.GUID.ToByteArray(), current.InstanceID);
|
|
else if (results == IIPObject.ComparisonResult.SameTypeDifferentInstance)
|
|
rt.Append(current.InstanceID);
|
|
}
|
|
|
|
return rt.ToArray();
|
|
}
|
|
*/
|
|
public static byte[] ToBytes(string value)
|
|
{
|
|
return Encoding.UTF8.GetBytes(value);
|
|
}
|
|
|
|
public static byte[] ToBytes(double value)
|
|
{
|
|
byte[] ret = BitConverter.GetBytes(value);
|
|
|
|
Array.Reverse(ret);
|
|
|
|
return ret;
|
|
}
|
|
|
|
public static byte[] ToBytes(long value)
|
|
{
|
|
byte[] ret = BitConverter.GetBytes(value);
|
|
|
|
Array.Reverse(ret);
|
|
|
|
return ret;
|
|
}
|
|
|
|
public static byte[] ToBytes(DateTime value)
|
|
{
|
|
byte[] ret = BitConverter.GetBytes(value.ToUniversalTime().Ticks);
|
|
Array.Reverse(ret);
|
|
return ret;
|
|
}
|
|
|
|
|
|
public static byte[] ToBytes(ulong value)
|
|
{
|
|
byte[] ret = BitConverter.GetBytes(value);
|
|
|
|
Array.Reverse(ret);
|
|
|
|
return ret;
|
|
}
|
|
|
|
public static byte[] ToBytes(uint value)
|
|
{
|
|
|
|
byte[] ret = BitConverter.GetBytes(value);
|
|
|
|
Array.Reverse(ret);
|
|
|
|
return ret;
|
|
}
|
|
|
|
public static byte[] ToBytes(ushort value)
|
|
{
|
|
byte[] ret = BitConverter.GetBytes(value);
|
|
|
|
Array.Reverse(ret);
|
|
|
|
return ret;
|
|
}
|
|
|
|
public static byte[] ToBytes(decimal value)
|
|
{
|
|
byte[] ret = new byte[0];// BitConverter.GetBytes(value);
|
|
|
|
Array.Reverse(ret);
|
|
|
|
return ret;
|
|
}
|
|
|
|
public static string ToHex(byte[] ba)
|
|
{
|
|
if (ba == null)
|
|
return "NULL";
|
|
return ToHex(ba, 0, (uint)ba.Length);
|
|
}
|
|
|
|
public static string ToHex(byte[] ba, uint offset, uint length, string separator = " ")
|
|
{
|
|
StringBuilder hex = new StringBuilder((int)length * 2);
|
|
|
|
for (var i = offset; i < offset + length; i++)
|
|
{
|
|
hex.AppendFormat("{0:x2}", ba[i]);
|
|
if (separator != null)
|
|
hex.Append(separator);
|
|
}
|
|
|
|
return hex.ToString();
|
|
}
|
|
|
|
public static byte[] FromHex(string hexString, string separator = " ")
|
|
{
|
|
var rt = new List<byte>();
|
|
|
|
if (separator == null)
|
|
{
|
|
for (var i = 0; i < hexString.Length; i += 2)
|
|
rt.Add(Convert.ToByte(hexString.Substring(i, 2), 16));
|
|
}
|
|
else
|
|
{
|
|
var hexes = hexString.Split(new string[] { separator }, StringSplitOptions.RemoveEmptyEntries);
|
|
foreach (var h in hexes)
|
|
rt.Add(Convert.ToByte(h, 16));
|
|
}
|
|
|
|
return rt.ToArray();
|
|
}
|
|
|
|
public static string FlagsEnumToString<T>(ulong value)
|
|
{
|
|
|
|
string rt = typeof(T).Name + ":";
|
|
|
|
for (int i = 0; i < 64; i++)
|
|
{
|
|
ulong bit = (ulong)(Convert.ToUInt64(Math.Pow(2, i)) & value);
|
|
if (bit != 0)
|
|
{
|
|
rt += " " + Enum.GetName(typeof(T), bit);
|
|
}
|
|
}
|
|
|
|
return rt;
|
|
}
|
|
|
|
public static string ToISODateTime(this DateTime date)
|
|
{
|
|
return date.ToString("yyyy-MM-dd HH:mm:ss");
|
|
}
|
|
|
|
|
|
public static bool TryParse<T>(object Input, out T Results)
|
|
{
|
|
try
|
|
{
|
|
#if NETSTANDARD1_5
|
|
var tryParse = typeof(T).GetTypeInfo().GetDeclaredMethod("TryParse");
|
|
if ((bool)tryParse.Invoke(null, new object[] { Input, null }))
|
|
{
|
|
var parse = typeof(T).GetTypeInfo().GetDeclaredMethod("Parse");
|
|
|
|
Results = (T)parse.Invoke(null, new object[] { Input });
|
|
return true;
|
|
}
|
|
#else
|
|
if ((bool)typeof(T).InvokeMember("TryParse", BindingFlags.Public | BindingFlags.Static | BindingFlags.InvokeMethod, null, null, new object[] { Input, null }))
|
|
{
|
|
Results = (T)typeof(T).InvokeMember("Parse", BindingFlags.Public | BindingFlags.Static | BindingFlags.InvokeMethod, null, null, new object[] { Input });
|
|
return true;
|
|
}
|
|
|
|
#endif
|
|
else
|
|
{
|
|
Results = default(T);
|
|
return false;
|
|
}
|
|
}
|
|
catch //Exception ex)
|
|
{
|
|
Results = default(T);
|
|
return false;
|
|
}
|
|
}
|
|
|
|
|
|
public static uint ToUnixTime(this DateTime date)
|
|
{
|
|
return (uint)(date - new DateTime(1970, 1, 1)).TotalSeconds;
|
|
}
|
|
|
|
public static DateTime FromUnixTime(uint seconds)
|
|
{
|
|
return new DateTime(1970, 1, 1, 0, 0, 0, DateTimeKind.Utc).AddSeconds((double)seconds);
|
|
}
|
|
|
|
public static DateTime FromUnixTime(ulong milliseconds)
|
|
{
|
|
return new DateTime(1970, 1, 1, 0, 0, 0, DateTimeKind.Utc).AddMilliseconds((double)milliseconds);
|
|
}
|
|
}
|
|
|
|
|
|
}
|