static Cache()
{
Type = typeof(T);
UnderlyingType = Enum.GetUnderlyingType(Type);
Values = (Enum.GetValues(Type) as T[]).AsReadOnly();
Names = Enum.GetNames(Type).Select(string.Intern).ToReadOnlyArray();
Members = Names.Select(x => new Member <T>(x)).ToReadOnlyArray();
MinValue = Values.DefaultIfEmpty().Min();
MaxValue = Values.DefaultIfEmpty().Max();
IsEmpty = Values.Count == 0;
IsFlags = Attribute.IsDefined(Type, typeof(FlagsAttribute));
var distinctedMember = Members.OrderBy(x => x.Value).Distinct(new Member <T> .ValueComparer()).ToArray();
MemberByName = Members.ToFrozenStringKeyDictionary(x => x.Name);
UnderlyingOperation
= Type.GetTypeCode(Type) switch
{
TypeCode.SByte => SByteOperation <T> .Create(MinValue, MaxValue, distinctedMember),
TypeCode.Byte => ByteOperation <T> .Create(MinValue, MaxValue, distinctedMember),
TypeCode.Int16 => Int16Operation <T> .Create(MinValue, MaxValue, distinctedMember),
TypeCode.UInt16 => UInt16Operation <T> .Create(MinValue, MaxValue, distinctedMember),
TypeCode.Int32 => Int32Operation <T> .Create(MinValue, MaxValue, distinctedMember),
TypeCode.UInt32 => UInt32Operation <T> .Create(MinValue, MaxValue, distinctedMember),
TypeCode.Int64 => Int64Operation <T> .Create(MinValue, MaxValue, distinctedMember),
TypeCode.UInt64 => UInt64Operation <T> .Create(MinValue, MaxValue, distinctedMember),
_ => throw new InvalidOperationException(),
};
}
static void Cache <T>()
where T : struct, Enum
{
var type = typeof(T);
var underlyingType = Enum.GetUnderlyingType(type);
var values = ((T[])Enum.GetValues(type)).AsReadOnly();
var names = Enum.GetNames(type).ToReadOnlyArray();
var members = names.Select(x => new Member <T>(x)).ToReadOnlyArray();
var minValue = values.DefaultIfEmpty().Min();
var maxValue = values.DefaultIfEmpty().Max();
var isEmpty = values.Count == 0;
var isFlags = Attribute.IsDefined(type, typeof(FlagsAttribute));
var distinctedMembers = members.Distinct(new Member <T> .ValueComparer()).ToArray();
var memberByValue = distinctedMembers.ToFrozenDictionary(x => x.Value);
var memberByName = members.ToFrozenStringKeyDictionary(x => x.Name);
var underlyingOperation
= Type.GetTypeCode(type) switch
{
TypeCode.SByte => SByteOperation <T> .Create(minValue, maxValue, distinctedMembers),
TypeCode.Byte => ByteOperation <T> .Create(minValue, maxValue, distinctedMembers),
TypeCode.Int16 => Int16Operation <T> .Create(minValue, maxValue, distinctedMembers),
TypeCode.UInt16 => UInt16Operation <T> .Create(minValue, maxValue, distinctedMembers),
TypeCode.Int32 => Int32Operation <T> .Create(minValue, maxValue, distinctedMembers),
TypeCode.UInt32 => UInt32Operation <T> .Create(minValue, maxValue, distinctedMembers),
TypeCode.Int64 => Int64Operation <T> .Create(minValue, maxValue, distinctedMembers),
TypeCode.UInt64 => UInt64Operation <T> .Create(minValue, maxValue, distinctedMembers),
_ => throw new InvalidOperationException(),
};
}
/// <summary>
///获取行信息
/// </summary>
/// <param name="str">行字符串</param>
/// <param name="count">通道数量</param>
/// <returns>false--转换成功 true--失败</returns>
public bool ByteToRow(byte[] data, int analogCount, int digitalCount)
{
try
{
//TODO:每次调用重复计算，影响效率
int digital = GetUshortCount(digitalCount);
int len = 4 + 4 + analogCount * 2 + digital * 2;
if (data.Length < len)
{
throw new ArgumentException("ByteToRow，字节数组长度小于要求值");
}
analogChannelData = new UInt16[analogCount];
digitalChannelData = new UInt16[digital];
int index = 0;
sampleNum = ByteOperation.CombinationByte(data[index++], data[index++], data[index++], data[index++]);
timeStamp = ByteOperation.CombinationByte(data[index++], data[index++], data[index++], data[index++]);
for (int j = 0; j < analogCount; j++)
{
analogChannelData[j] = ByteOperation.CombinationByte(data[index++], data[index++]);
}
for (int j = 0; j < digital; j++)
{
digitalChannelData [j] = ByteOperation.CombinationByte(data[index++], data[index++]);
}
return(true);
}
catch (Exception ex)
{
throw ex;
}
}
/// <summary>
/// 生成 二进制字节数组
/// </summary>
/// <returns>生成字符串</returns>
public byte[] RowToByteArray()
{
try
{
int len = 4 + 4 + analogChannelData.Length * 2 + digitalChannelData.Length * 2;
byte[] data = new byte[len];
int index = 0;
data[index++] = ByteOperation.GetBit7_0(sampleNum);
data[index++] = ByteOperation.GetBit15_8(sampleNum);
data[index++] = ByteOperation.GetBit23_16(sampleNum);
data[index++] = ByteOperation.GetBit31_24(sampleNum);
data[index++] = ByteOperation.GetBit7_0(timeStamp);
data[index++] = ByteOperation.GetBit15_8(timeStamp);
data[index++] = ByteOperation.GetBit23_16(timeStamp);
data[index++] = ByteOperation.GetBit31_24(timeStamp);
foreach (var m in analogChannelData)
{
data[index++] = ByteOperation.GetBit7_0(m);
data[index++] = ByteOperation.GetBit15_8(m);
}
foreach (var m in digitalChannelData)
{
data[index++] = ByteOperation.GetBit7_0(m);
data[index++] = ByteOperation.GetBit15_8(m);
}
return(data);
}
catch (Exception ex)
{
throw ex;
}
}
/// <summary>
/// Returns an indication whether a constant with a specified value exists in a specified enumeration.
/// </summary>
/// <param name="value"></param>
/// <typeparam name="T">Enum type</typeparam>
/// <returns></returns>
public static bool IsDefined <T>(byte value)
where T : struct, Enum
{
if (Cache_UnderlyingOperation <T> .UnderlyingType == typeof(byte))
{
return(ByteOperation <T> .IsDefined(ref value));
}
throw new ArgumentException(IsDefinedTypeMismatchMessage);
}
/// <summary>
/// 获取状态位
/// </summary>
/// <param name="bitArray">位数组</param>
/// <param name="posit">位置</param>
/// <returns>位状态</returns>
int GetDigitalBit(UInt16[] bitArray, UInt16 posit)
{
int index = posit / 16;
int offset = posit % 16;
bool state = ByteOperation.GetBit(bitArray[index], offset);
if (state)
{
return(1);
}
else
{
return(0);
}
}
private void ParseFlags(byte[] flagBytes)
{
this.TagAlterPreservation = ByteOperation.GetBit(flagBytes[0], 6);
this.FileAlterPreservation = ByteOperation.GetBit(flagBytes[0], 5);
this.ReadOnly = ByteOperation.GetBit(flagBytes[0], 4);
this.GroupingIdentity = ByteOperation.GetBit(flagBytes[1], 6);
this.Compression = ByteOperation.GetBit(flagBytes[1], 3);
this.Encryption = ByteOperation.GetBit(flagBytes[1], 2);
this.Unsynchronisation = ByteOperation.GetBit(flagBytes[1], 1);
this.DataLengthIndicator = ByteOperation.GetBit(flagBytes[1], 0);
if (((flagBytes[0] & 0x8F) != 0) || ((flagBytes[1] & 0xB0) != 0))
{
throw new Exceptions.NotUsableFlagException("Invalid flag field in FrameFlagSet. Undefined flags are set", "", DateTime.Now);
}
}
public BinaryContent(ASCIIContent assiiContent)
{
AnalogCount = assiiContent.AnalogCount;
DigitalCount = assiiContent.DigitalCount;
sampleNum = (UInt32)assiiContent.SampleIndex;
timeStamp = (UInt32)assiiContent.SampleTimeStamp;
analogChannelData = new ushort[AnalogCount];
for (int i = 0; i < AnalogCount; i++)
{
analogChannelData[i] = (ushort)assiiContent.AnalogChannelData[i];
}
// Array.Copy(assiiContent.AnalogChannelData, analogChannelData, AnalogCount);
//int digital = GetUshortCount(DigitalCount);
//digitalChannelData = new ushort[digital];
digitalChannelData = ByteOperation.BitAssemblyUsort16(assiiContent.DigitalChannelData);
}
public void TestGetBit()
{
bool expTrue = true;
bool expFalse = false;
byte byte01 = 0x01;
byte byteCA = 0xCA;
Assert.AreEqual(expTrue, ByteOperation.GetBit(byte01, 0));
Assert.AreEqual(expFalse, ByteOperation.GetBit(byte01, 1));
Assert.AreEqual(false, ByteOperation.GetBit(byteCA, 0));
Assert.AreEqual(true, ByteOperation.GetBit(byteCA, 1));
Assert.AreEqual(false, ByteOperation.GetBit(byteCA, 2));
Assert.AreEqual(true, ByteOperation.GetBit(byteCA, 3));
Assert.AreEqual(false, ByteOperation.GetBit(byteCA, 4));
Assert.AreEqual(false, ByteOperation.GetBit(byteCA, 5));
Assert.AreEqual(true, ByteOperation.GetBit(byteCA, 6));
Assert.AreEqual(true, ByteOperation.GetBit(byteCA, 7));
}
static Cache_UnderlyingOperation()
{
var type = Cache_Type <T> .Type;
var min = Cache_MinMaxValues <T> .MinValue;
var max = Cache_MinMaxValues <T> .MaxValue;
var distincted = Cache_Members <T> .Members.OrderBy(x => x.Value).Distinct(new Member <T> .ValueComparer()).ToArray();
UnderlyingType = Cache_Type <T> .UnderlyingType;
UnderlyingOperation
= Type.GetTypeCode(type) switch
{
TypeCode.SByte => SByteOperation <T> .Create(min, max, distincted),
TypeCode.Byte => ByteOperation <T> .Create(min, max, distincted),
TypeCode.Int16 => Int16Operation <T> .Create(min, max, distincted),
TypeCode.UInt16 => UInt16Operation <T> .Create(min, max, distincted),
TypeCode.Int32 => Int32Operation <T> .Create(min, max, distincted),
TypeCode.UInt32 => UInt32Operation <T> .Create(min, max, distincted),
TypeCode.Int64 => Int64Operation <T> .Create(min, max, distincted),
TypeCode.UInt64 => UInt64Operation <T> .Create(min, max, distincted),
_ => throw new InvalidOperationException(),
};
}
static CacheUnderlyingOperation()
{
Type type = CacheType <T> .Type;
T min = CacheMinMaxValues <T> .MinValue;
T max = CacheMinMaxValues <T> .MaxValue;
EnumMember <T>[] distincted = CacheMembers <T> .Members.OrderBy(x => x.Value).Distinct(new EnumMember <T> .ValueComparer()).ToArray();
UnderlyingType = CacheType <T> .UnderlyingType;
// ReSharper disable once SwitchExpressionHandlesSomeKnownEnumValuesWithExceptionInDefault
UnderlyingOperation = Type.GetTypeCode(type) switch
{
TypeCode.SByte => SByteOperation <T> .Create(min, max, distincted),
TypeCode.Byte => ByteOperation <T> .Create(min, max, distincted),
TypeCode.Int16 => Int16Operation <T> .Create(min, max, distincted),
TypeCode.UInt16 => UInt16Operation <T> .Create(min, max, distincted),
TypeCode.Int32 => Int32Operation <T> .Create(min, max, distincted),
TypeCode.UInt32 => UInt32Operation <T> .Create(min, max, distincted),
TypeCode.Int64 => Int64Operation <T> .Create(min, max, distincted),
TypeCode.UInt64 => UInt64Operation <T> .Create(min, max, distincted),
_ => throw new InvalidOperationException()
};
}
}