/// <summary>使用指定的字节数组初始化 CombGuid 结构的新实例。</summary>
/// <param name="value">包含初始化 CombGuid 的值的 16 元素字节数组。</param>
/// <param name="sequentialType">指示字节数组中标识顺序的 6 位字节的位置</param>
/// <param name="isOwner">指示使用指定的字节数组初始化 CombGuid 结构的新实例是否拥有此字节数组。</param>
public CombGuid(Byte[] value, CombGuidSequentialSegmentType sequentialType, Boolean isOwner = false)
{
if (value == null || value.Length != _SizeOfGuid)
{
throw new ArgumentException("value 的长度不是 16 个字节。");
}
if (sequentialType == CombGuidSequentialSegmentType.Guid)
{
if (isOwner)
{
m_value = value;
}
else
{
m_value = new Byte[_SizeOfGuid];
value.CopyTo(m_value, 0);
}
}
else
{
m_value = new Byte[_SizeOfGuid];
for (Int32 i = 0; i < _SizeOfGuid; i++)
{
m_value[_GuidComparisonOrders[i]] = value[i];
}
}
}
/// <summary>使用指定字符串所表示的值初始化 CombGuid 结构的新实例。</summary>
/// <param name="comb">包含下面任一格式的 CombGuid 的字符串（“d”表示忽略大小写的十六进制数字）：
/// <para>32 个连续的数字 dddddddddddddddddddddddddddddddd </para>
/// <para>- 或 CombGuid 格式字符串 - </para>
/// <para>12 和 4、4、4、8 位数字的分组，各组之间有连线符，dddddddddddd-dddd-dddd-dddd-dddddddd</para>
/// <para>- 或 Guid 格式字符串 - </para>
/// <para>8、4、4、4 和 12 位数字的分组，各组之间有连线符，dddddddd-dddd-dddd-dddd-dddddddddddd</para>
/// </param>
/// <param name="sequentialType">指示字符串中标识顺序的 12 位字符串的位置</param>
public CombGuid(String comb, CombGuidSequentialSegmentType sequentialType)
{
if (comb.IsNullOrWhiteSpace())
{
throw new ArgumentNullException("comb");
}
Int32 a; Int16 b, c; Byte[] d;
if (new GuidParser(comb, sequentialType).TryParse(out a, out b, out c, out d))
{
m_value = new Byte[_SizeOfGuid];
Init(a, b, c, d);
}
else
{
if (_NullString.EqualIgnoreCase(comb))
{
m_value = null;
}
else
{
throw CreateFormatException(comb);
}
}
}
internal GuidParser(String src, CombGuidSequentialSegmentType sequentialType)
{
_src = src.Trim();
_cur = 0;
_length = _src.Length;
_sequentialType = sequentialType;
}
/// <summary>将 CombGuid 的字符串表示形式转换为等效的 CombGuid 结构。</summary>
/// <param name="s">包含下面任一格式的 CombGuid 的字符串（“d”表示忽略大小写的十六进制数字）：
/// <para>32 个连续的数字 dddddddddddddddddddddddddddddddd </para>
/// <para>- 或 CombGuid 格式字符串 - </para>
/// <para>12 和 4、4、4、8 位数字的分组，各组之间有连线符，dddddddddddd-dddd-dddd-dddd-dddddddd</para>
/// <para>- 或 Guid 格式字符串 - </para>
/// <para>8、4、4、4 和 12 位数字的分组，各组之间有连线符，dddddddd-dddd-dddd-dddd-dddddddddddd</para>
/// </param>
/// <param name="sequentialType">指示字符串中标识顺序的 12 位字符串的位置</param>
/// <returns></returns>
public static CombGuid Parse(String s, CombGuidSequentialSegmentType sequentialType)
{
if (_NullString.EqualIgnoreCase(s))
{
return(CombGuid.Null);
}
else
{
return(new CombGuid(s, sequentialType));
}
}
/// <summary>将 CombGuid 的字符串表示形式转换为等效的 CombGuid 结构。</summary>
/// <param name="comb">包含下面任一格式的 CombGuid 的字符串（“d”表示忽略大小写的十六进制数字）：
/// <para>32 个连续的数字 dddddddddddddddddddddddddddddddd </para>
/// <para>- 或 CombGuid 格式字符串 - </para>
/// <para>12 和 4、4、4、8 位数字的分组，各组之间有连线符，dddddddddddd-dddd-dddd-dddd-dddddddd</para>
/// <para>- 或 Guid 格式字符串 - </para>
/// <para>8、4、4、4 和 12 位数字的分组，各组之间有连线符，dddddddd-dddd-dddd-dddd-dddddddddddd</para>
/// </param>
/// <param name="sequentialType">指示字符串中标识顺序的 12 位字符串的位置</param>
/// <param name="result">将包含已分析的值的结构。 如果此方法返回 true，result 包含有效的 CombGuid。 如果此方法返回 false，result 等于 CombGuid.Null。</param>
/// <returns></returns>
public static Boolean TryParse(String comb, CombGuidSequentialSegmentType sequentialType, out CombGuid result)
{
if (comb.IsNullOrWhiteSpace())
{
throw new ArgumentNullException("comb");
}
if (new GuidParser(comb, sequentialType).TryParse(out var a, out var b, out var c, out var d))
{
result = new CombGuid(a, b, c, d);
return(true);
}
result = Null;
return(false);
}
/// <summary>将 CombGuid 的字符串表示形式转换为等效的 CombGuid 结构。</summary>
/// <param name="comb">包含下面任一格式的 CombGuid 的字符串（“d”表示忽略大小写的十六进制数字）：
/// <para>32 个连续的数字 dddddddddddddddddddddddddddddddd </para>
/// <para>- 或 CombGuid 格式字符串 - </para>
/// <para>12 和 4、4、4、8 位数字的分组，各组之间有连线符，dddddddddddd-dddd-dddd-dddd-dddddddd</para>
/// <para>- 或 Guid 格式字符串 - </para>
/// <para>8、4、4、4 和 12 位数字的分组，各组之间有连线符，dddddddd-dddd-dddd-dddd-dddddddddddd</para>
/// </param>
/// <param name="sequentialType">指示字符串中标识顺序的 12 位字符串的位置</param>
/// <param name="result">将包含已分析的值的结构。 如果此方法返回 true，result 包含有效的 CombGuid。 如果此方法返回 false，result 等于 CombGuid.Null。</param>
/// <returns></returns>
public static bool TryParse(string comb, CombGuidSequentialSegmentType sequentialType, out YusCombGuid result)
{
if (comb.YusNullOrWhiteSpace())
{
throw new ArgumentNullException("comb");
}
if (new GuidParser(comb, sequentialType).TryParse(out int a, out short b, out short c, out byte[] d))
{
result = new YusCombGuid(a, b, c, d);
return(true);
}
result = Null;
return(false);
}
public Byte[] GetByteArray(CombGuidSequentialSegmentType sequentialType)
{
//if (IsNull) { throw new HmExceptionBase("此 CombGuid 结构字节数组为空！"); }
if (IsNull)
{
return(Empty.m_value);
}
if (sequentialType == CombGuidSequentialSegmentType.Guid)
{
return(m_value);
}
else
{
return(ToByteArray(CombGuidSequentialSegmentType.Comb));
}
}
/// <summary>根据所提供的格式方式，返回此 CombGuid 实例值的字符数组，如果此 CombGuid 结构值为空，抛出异常。</summary>
/// <param name="sequentialType">指示生成的字符数组中标识顺序的 6 位字节的位置。</param>
/// <returns>此 CombGuid 的字符数组，包含一系列指定格式的小写十六进制位字符</returns>
public Char[] GetHexChars(CombGuidSequentialSegmentType sequentialType)
{
//if (IsNull) { throw new HmExceptionBase("此 CombGuid 结构字节数组为空！"); }
if (IsNull)
{
return(Empty.GetHexChars(sequentialType));
}
var offset = 0;
var guidChars = new Char[32];
if (sequentialType == CombGuidSequentialSegmentType.Guid)
{
offset = HexsToChars(guidChars, offset, m_value[0], m_value[1]);
offset = HexsToChars(guidChars, offset, m_value[2], m_value[3]);
offset = HexsToChars(guidChars, offset, m_value[4], m_value[5]);
offset = HexsToChars(guidChars, offset, m_value[6], m_value[7]);
offset = HexsToChars(guidChars, offset, m_value[8], m_value[9]);
offset = HexsToChars(guidChars, offset, m_value[10], m_value[11]);
offset = HexsToChars(guidChars, offset, m_value[12], m_value[13]);
offset = HexsToChars(guidChars, offset, m_value[14], m_value[15]);
}
else
{
offset = HexsToChars(guidChars, offset, m_value[10], m_value[11]);
offset = HexsToChars(guidChars, offset, m_value[12], m_value[13]);
offset = HexsToChars(guidChars, offset, m_value[14], m_value[15]);
offset = HexsToChars(guidChars, offset, m_value[8], m_value[9]);
offset = HexsToChars(guidChars, offset, m_value[6], m_value[7]);
offset = HexsToChars(guidChars, offset, m_value[4], m_value[5]);
offset = HexsToChars(guidChars, offset, m_value[0], m_value[1]);
offset = HexsToChars(guidChars, offset, m_value[2], m_value[3]);
}
return(guidChars);
}
/// <summary>将 CombGuid 的字符串表示形式转换为等效的 CombGuid 结构。</summary>
/// <param name="value">Guid结构、CombGuid结构、16 元素字节数组 或 包含下面任一格式的 CombGuid 的字符串（“d”表示忽略大小写的十六进制数字）：
/// <para>32 个连续的数字 dddddddddddddddddddddddddddddddd </para>
/// <para>- 或 CombGuid 格式字符串 - </para>
/// <para>12 和 4、4、4、8 位数字的分组，各组之间有连线符，dddddddddddd-dddd-dddd-dddd-dddddddd</para>
/// <para>- 或 Guid 格式字符串 - </para>
/// <para>8、4、4、4 和 12 位数字的分组，各组之间有连线符，dddddddd-dddd-dddd-dddd-dddddddddddd</para>
/// </param>
/// <param name="sequentialType"></param>
/// <param name="result">将包含已分析的值的结构。 如果此方法返回 true，result 包含有效的 CombGuid。 如果此方法返回 false，result 等于 CombGuid.Null。</param>
/// <remarks>如果传入的 value 为字节数组时，解析生成的 CombGuid 结构实例将拥有此字节数组。</remarks>
/// <returns></returns>
public static Boolean TryParse(Object value, CombGuidSequentialSegmentType sequentialType, out CombGuid result)
{
if (value == null)
{
result = Null;
return(false);
}
var type = value.GetType();
if (type == typeof(CombGuid))
{
result = (CombGuid)value;
return(true);
}
else if (type == typeof(Guid))
{
result = (Guid)value;
return(true);
}
else if (type == typeof(String))
{
return(TryParse(value as String, sequentialType, out result));
}
else if (type == typeof(Byte[]))
{
var bs = value as Byte[];
if (bs != null && bs.Length == _SizeOfGuid)
{
result = new CombGuid(bs, sequentialType, true);
return(true);
}
}
result = Null;
return(false);
}
/// <summary>将此 CombGuid 结构转换为字节数组，如果此 CombGuid 结构值为空，抛出异常。</summary>
/// <param name="sequentialType">指示生成的字节数组中标识顺序的 6 位字节的位置</param>
/// <returns>16 元素字节数组。</returns>
public Byte[] ToByteArray(CombGuidSequentialSegmentType sequentialType)
{
//if (IsNull) { throw new HmExceptionBase("此 CombGuid 结构字节数组为空！"); }
if (IsNull)
{
return(Empty.ToByteArray(sequentialType));
}
var ret = new Byte[_SizeOfGuid];
if (sequentialType == CombGuidSequentialSegmentType.Guid)
{
m_value.CopyTo(ret, 0);
}
else
{
for (Int32 i = 0; i < _SizeOfGuid; i++)
{
ret[i] = m_value[_GuidComparisonOrders[i]];
}
}
return(ret);
}
/// <summary>将 CombGuid 的字符串表示形式转换为等效的 CombGuid 结构。</summary>
/// <param name="value">Guid结构、CombGuid结构、16 元素字节数组 或 包含下面任一格式的 CombGuid 的字符串（“d”表示忽略大小写的十六进制数字）：
/// <para>32 个连续的数字 dddddddddddddddddddddddddddddddd </para>
/// <para>- 或 CombGuid 格式字符串 - </para>
/// <para>12 和 4、4、4、8 位数字的分组，各组之间有连线符，dddddddddddd-dddd-dddd-dddd-dddddddd</para>
/// <para>- 或 Guid 格式字符串 - </para>
/// <para>8、4、4、4 和 12 位数字的分组，各组之间有连线符，dddddddd-dddd-dddd-dddd-dddddddddddd</para>
/// </param>
/// <param name="sequentialType">格式枚举</param>
/// <param name="result">将包含已分析的值的结构。 如果此方法返回 true，result 包含有效的 CombGuid。 如果此方法返回 false，result 等于 CombGuid.Null。</param>
/// <remarks>如果传入的 value 为字节数组时，解析生成的 CombGuid 结构实例将拥有此字节数组。</remarks>
/// <returns></returns>
public static bool TryParse(object value, CombGuidSequentialSegmentType sequentialType, out YusCombGuid result)
{
if (value == null)
{
result = Null;
return(false);
}
var type = value.GetType();
if (type == typeof(YusCombGuid))
{
result = (YusCombGuid)value;
return(true);
}
else if (type == typeof(Guid))
{
result = (Guid)value;
return(true);
}
else if (type == typeof(string))
{
return(TryParse(value as string, sequentialType, out result));
}
else if (type == typeof(byte[]))
{
if (value is byte[] bs && bs.Length == _SizeOfGuid)
{
result = new YusCombGuid(bs, sequentialType, true);
return(true);
}
}
result = Null;
return(false);
}
/// <summary>使用指定字符串所表示的值初始化 CombGuid 结构的新实例。</summary>
/// <param name="comb">包含下面任一格式的 CombGuid 的字符串（“d”表示忽略大小写的十六进制数字）：
/// <para>32 个连续的数字 dddddddddddddddddddddddddddddddd </para>
/// <para>- 或 CombGuid 格式字符串 - </para>
/// <para>12 和 4、4、4、8 位数字的分组，各组之间有连线符，dddddddddddd-dddd-dddd-dddd-dddddddd</para>
/// <para>- 或 Guid 格式字符串 - </para>
/// <para>8、4、4、4 和 12 位数字的分组，各组之间有连线符，dddddddd-dddd-dddd-dddd-dddddddddddd</para>
/// </param>
/// <param name="sequentialType">指示字符串中标识顺序的 12 位字符串的位置</param>
public YusCombGuid(string comb, CombGuidSequentialSegmentType sequentialType)
{
if (comb.YusNullOrWhiteSpace())
{
throw new ArgumentNullException("comb");
}
if (new GuidParser(comb, sequentialType).TryParse(out int a, out short b, out short c, out byte[] d))
{
m_value = new byte[_SizeOfGuid];
Init(a, b, c, d);
}
else
{
if (_NullString.YusEqualIgnoreCase(comb))
{
m_value = null;
}
else
{
throw CreateFormatException(comb);
}
}
}
/// <summary>根据所提供的格式方式，把此 CombGuid 编码为十六进制字符串，如果此 CombGuid 结构值为空，抛出异常。</summary>
/// <param name="sequentialType">指示生成的字符数组中标识顺序的 6 位字节的位置。</param>
/// <returns></returns>
public String ToHex(CombGuidSequentialSegmentType sequentialType)
{
return(new String(GetHexChars(sequentialType)));
}
