/// <summary>
        /// 转换当前 16 进制字符串为字节数组。
        /// </summary>
        /// <param name="hexStr">由 16 进制字符构成的字符串。</param>
        /// <returns>转换后的字节数组。</returns>
        /// <exception cref="ArgumentNullException">当 <paramref name="hexStr"/> 为空引用(<c>null</c>)时抛出。</exception>
        /// <exception cref="ArgumentEmptyException">当 <pramref name="hexStr"/> 为空字符串(<see cref="String.Empty"/>)时抛出。</exception>
        /// <exception cref="InvalidCastException">当源字符串内容不符合十六进制字符规则时抛出。请参考 <see cref="IsHexString(string)"/> 方法。</exception>
        public static byte[] ToBytes(this string hexStr)
        {
            #region Parameter's Check

            ParamCheck.NotEmptyOrNull(hexStr, nameof(hexStr));

            #endregion

            // 检查字符串是否由 16 进制字符构成。
            if (!hexStr.IsHexString())
            {
                throw new InvalidCastException(Properties.Resource.HexStringInvalid);
            }

            int    byteCount = hexStr.Length / 2;   // 求得转换后的字节数组元素总数。
            byte[] bytes     = new byte[byteCount]; // 存储转换后的字节数组。

            for (int i = 0; i < hexStr.Length; i++)
            {
                string hex = hexStr.Substring(i++, 2); // 取得二个字符,并使用字符计算加一。

                bytes[i / 2] = byte.Parse(hex, NumberStyles.AllowHexSpecifier, CultureInfo.InvariantCulture);
            }

            return(bytes);
        }
        /// <summary>
        /// <para>返回一个布尔值,指示 <paramref name="type"/> 是否实现了 <paramref name="ifType"/> 代表的接口。</para>
        /// </summary>
        /// <param name="type">将要检查的类型。</param>
        /// <param name="ifType">预期的接口类型。</param>
        /// <returns>如果 <paramref name="type"/> 实现了 <paramref name="ifType"/> 代表的接口时返回真(<c>true</c>),否则返回假(<c>false</c>)。</returns>
        /// <remarks>注,如果 <paramref name="ifType"/> 不是一个接口类型,那么将返回一个假(<c>false</c>)。</remarks>
        /// <exception cref="ArgumentNullException">当 <paramref name="type"/> 或 <paramref name="ifType"/> 为空引用(<c>null</c>)时引发。</exception>
        public static bool IsImplFrom(this Type type, Type ifType)
        {
            #region Parameter Check

            ParamCheck.NotNull(type, nameof(type));
            ParamCheck.NotNull(ifType, nameof(ifType));

            #endregion

            var typeInfo   = type.GetTypeInfo();
            var ifTypeInfo = ifType.GetTypeInfo();

            // 如果预期类型不是一个接口,
            if (!ifTypeInfo.IsInterface)
            {
                return(false);
            }

            // 如果被测类型是泛型,
            if (typeInfo.IsGenericType)
            {
                return(typeInfo.GetGenericTypeDefinition() == ifType || ifTypeInfo.IsAssignableFrom(typeInfo));
            }

            // 被测类型是一般类型,
            return(ifTypeInfo.IsAssignableFrom(typeInfo) || typeInfo.GetInterfaces().Any(ifif =>
            {
                var ififInfo = ifif.GetTypeInfo();

                // 如果是泛型则比较泛型定义,否则比较类型。
                return ififInfo.IsGenericType
                           ? ififInfo.GetGenericTypeDefinition() == ifType
                           : ifif == ifType;
            }));
        }
        /// <summary>
        /// <para>检查当前字符串是否是由 16 进制字符构成的。</para>
        /// <para>
        /// 检查内容包含:
        /// <list type="number">
        /// <item>1. 检查字符串的总字符个数是 2 的整数倍。</item>
        /// <item>2. 检查字符串中的构成字符为 0-9,A-F, a-f</item>
        /// </list>
        /// </para>
        /// </summary>
        /// <param name="str">将被检查的字符串。</param>
        /// <returns>如果符合返回 <c>ture</c>;否则返回 <c>false</c>。</returns>
        /// <exception cref="ArgumentNullException">当 <paramref name="str"/> 为空引用(<c>null</c>)时抛出。</exception>
        /// <exception cref="ArgumentEmptyException">当 <paramref name="str"/> 为空字符串(<see cref="String.Empty"/>)时抛出。</exception>
        /// <remarks>
        /// 本方法仅在字符串内容上保证是符合 16 进制的规则;但不保证转换成的 byte[] 一定符合业务要求。
        /// </remarks>
        public static bool IsHexString(this string str)
        {
            #region Parameter's Check

            ParamCheck.NotEmptyOrNull(str, nameof(str));

            #endregion

            // 如果不是 2 的整数倍。
            if (str.Length % 2 > 0)
            {
                return(false);
            }

            // 循环检查构成的字符。
            foreach (char c in str)
            {
                if (c >= 'a' && c <= 'f')
                {
                    continue;
                }
                if (c >= 'A' && c <= 'F')
                {
                    continue;
                }
                if (c >= '0' && c <= '9')
                {
                    continue;
                }

                return(false);
            }

            return(true);
        }
 /// <summary>
 /// 检查 <paramref name="value"/>,如果为空引用(<c>null</c>)则抛出 <see cref="ArgumentNullException"/>。
 /// </summary>
 /// <typeparam name="T">指定 <paramref name="value"/> 的类型。</typeparam>
 /// <param name="value">被检查值。</param>
 /// <param name="name">被检查值在方法定义中的名称。</param>
 /// <exception cref="ArgumentNullException">如果被检查值为空引用(<c>null</c>)则抛出。</exception>
 public static void NotNull <T>(T value, string name) where T : class
 {
     if (ReferenceEquals(value, null))
     {
         ParamCheck.NotEmptyOrNull(name, nameof(name));
         throw new ArgumentNullException(name);
     }
 }
 /// <summary>
 /// <para>检查 <paramref name="value"/> 是否为空全局唯一标识符(<see cref="Guid.Empty"/>)。</para>
 /// </summary>
 /// <param name="value">将要被检查的参数值。</param>
 /// <param name="name">被检查参数值的名称。</param>
 /// <exception cref="ArgumentNullException">当 <paramref name="name"/> 为空引用(<c>null</c>)时引发。</exception>
 /// <exception cref="ArgumentEmptyException">当 <paramref name="value"/> 为空全局唯一标识符(<see cref="Guid.Empty"/>) 或 <paramref name="name"/> 为空字符串(<see cref="String.Empty"/>)时引发。</exception>
 public static void NotEmpty(Guid value, string name)
 {
     if (Guid.Equals(value, Guid.Empty))
     {
         ParamCheck.NotEmptyOrNull(name, nameof(name));
         throw new ArgumentEmptyException(name);
     }
 }
        /// <summary>
        /// <para>返回一个布尔值,指示 <paramref name="type"/> 是否是从 <paramref name="baseType"/> 类型派生(或实现)的。</para>
        /// <para>如果 <paramref name="type"/> 继承于 <paramref name="baseType"/> 则返回真(<c>true</c>)。</para>
        /// <para>如果 <paramref name="type"/> 实现了 <paramref name="baseType"/>(当是一个接口类型时)则返回真(<c>true</c>)</para>
        /// </summary>
        /// <param name="type">将要检查的类型。</param>
        /// <param name="baseType">预期的基类或接口。</param>
        /// <returns>如果 <paramref name="type"/> 是从 <paramref name="baseType"/> 派生或实现了 <paramref name="baseType"/>(当是一个接口类型时)时返回真(<c>true</c>);否则返回假(<c>false</c>)。</returns>
        /// <exception cref="ArgumentNullException">当 <paramref name="type"/> 或 <paramref name="baseType"/> 为空引用(<c>null</c>)时引发。</exception>
        public static bool IsDerivedFrom(this Type type, Type baseType)
        {
            #region Parameter Check

            ParamCheck.NotNull(type, nameof(type));
            ParamCheck.NotNull(baseType, nameof(baseType));

            #endregion

            TypeInfo baseTypeInfo = baseType.GetTypeInfo();

            // 如果预期类型是一个接口,
            if (baseTypeInfo.IsInterface)
            {
                return(type.IsImplFrom(baseType));
            }

            TypeInfo typeInfo = type.GetTypeInfo();

            // 如果预期类型不是泛型声明,
            if (!baseTypeInfo.IsGenericTypeDefinition)
            {
                return(baseTypeInfo.IsAssignableFrom(type));
            }
            else
            { // 否则,
                // 如果被测类型是泛型,
                if (typeInfo.IsGenericType)
                {
                    return(baseTypeInfo.IsAssignableFrom(typeInfo.GetGenericTypeDefinition()));
                }
                else // 否则
                {
                    bool result = baseTypeInfo.IsAssignableFrom(typeInfo);
                    if (result)
                    {
                        return(true);
                    }

                    // 查询基类,
                    var typeOfBase = typeInfo.BaseType;
                    while (typeOfBase != typeof(object))
                    {
                        result = typeOfBase.IsDerivedFrom(baseType);
                        if (result)
                        {
                            break;
                        }

                        typeOfBase = typeOfBase.GetTypeInfo().BaseType;
                    }

                    return(result);
                }
            }
        }
        /// <summary>
        /// 循环对 <paramref name="source"/> 内的每个元素执行 <paramref name="func"/> 定义的操作,并返回包含处理后元素的 <see cref="IEnumerable{T}"/>。
        /// </summary>
        /// <typeparam name="T"><paramref name="source"/> 中元素的类型。</typeparam>
        /// <param name="source">包含将要处理元素的 <see cref="IEnumerable{T}"/>。</param>
        /// <param name="func">将要应用于元素的方法。</param>
        /// <returns>包含处理后元素的 <see cref="IEnumerable{T}"/>。</returns>
        /// <exception cref="NullReferenceException">当 <paramref name="source"/> 为空引用(<c>null</c>)时引发。</exception>
        public static IEnumerable <T> ForEach <T>(this IEnumerable <T> source, Func <T, T> func)
        {
            #region Param Check

            ParamCheck.NotNull(source, nameof(source));

            #endregion

            return(source.Select(item => func.Invoke(item)).ToList());
        }
        /// <summary>
        /// 循环对 <paramref name="source"/> 内的每个元素执行 <paramref name="action"/> 定义的操作。
        /// </summary>
        /// <typeparam name="T"><paramref name="source"/> 中元素的类型。</typeparam>
        /// <param name="source">包含将要处理元素的 <see cref="IEnumerable{T}"/>。</param>
        /// <param name="action">将要应用于元素的方法。</param>
        /// <exception cref="NullReferenceException">当 <paramref name="source"/> 为空引用(<c>null</c>)时引发。</exception>
        public static void ForEach <T>(this IEnumerable <T> source, Action <T> action)
        {
            #region Param Check

            ParamCheck.NotNull(source, nameof(source));

            #endregion

            foreach (T item in source)
            {
                action.Invoke(item);
            }
        }
        /// <summary>
        /// 转换当前字节数组为 16 进制字符构成的字符串。
        /// </summary>
        /// <param name="bin">待转换的字节数组。</param>
        /// <returns>转换后的字符串。</returns>
        /// <exception cref="ArgumentNullException">当 <paramref name="bin"/> 为空引用(<c>null</c>)时抛出。</exception>
        /// <exception cref="ArgumentEmptyException">当 <paramref name="bin"/> 为空集合时抛出。</exception>
        public static string ToHexString(this byte[] bin)
        {
            #region Parameter's Check

            ParamCheck.NotEmptyOrNull(bin, nameof(bin));

            #endregion

            StringBuilder hexStr = new StringBuilder();

            foreach (byte b in bin)
            {
                hexStr.Append(b.ToString("X2", CultureInfo.InvariantCulture));
            }

            return(hexStr.ToString());
        }
        /// <summary>
        /// 检查 <paramref name="value"/>,如果没有任何元素存在则抛出 <see cref="ArgumentEmptyException"/>。
        /// </summary>
        /// <param name="value">被检查集合值。</param>
        /// <param name="name">被检查值在方法定义中的名称。</param>
        public static void NotEmptyOrNull(ICollection value, string name)
        {
            ArgumentException e = null;

            if (ReferenceEquals(value, null))
            {
                e = new ArgumentNullException(name);
            }
            else if (value.Count == 0)
            {
                e = new ArgumentEmptyException(name);
            }

            if (e != null)
            {
                ParamCheck.NotEmptyOrNull(name, nameof(name));
                throw e;
            }
        }