System.Enum.ToObject C# (CSharp) Метод

        public static Object ToObject(Type enumType, Object value)
        {
            if (value == null)
                throw new ArgumentNullException("value");

            // Delegate rest of error checking to the other functions
            TypeCode typeCode = Convert.GetTypeCode(value);

            switch (typeCode)
            {
                case TypeCode.Int32 :
                    return ToObject(enumType, (int)value);

                case TypeCode.SByte :
                    return ToObject(enumType, (sbyte)value);

                case TypeCode.Int16 :
                    return ToObject(enumType, (short)value);

                case TypeCode.Int64 :
                    return ToObject(enumType, (long)value);

                case TypeCode.UInt32 :
                    return ToObject(enumType, (uint)value);

                case TypeCode.Byte :
                    return ToObject(enumType, (byte)value);

                case TypeCode.UInt16 :
                    return ToObject(enumType, (ushort)value);

                case TypeCode.UInt64 :
                    return ToObject(enumType, (ulong)value);

                default :
                    // All unsigned types will be directly cast
                    throw new ArgumentException(Environment.GetResourceString("Arg_MustBeEnumBaseTypeOrEnum"), "value");
            }
        }

        ///// <summary>
        ///// 变更类型
        ///// </summary>
        ///// <param name="value">值</param>
        ///// <param name="type">类型</param>
        //public static object ChangeType(string value, Type type)
        //{
        //    object obj = null;
        //    var nullableType = Nullable.GetUnderlyingType(type);
        //    try
        //    {
        //        if (nullableType != null)
        //        {
        //            if (value == null)
        //                obj = null;
        //            else
        //                obj = OtherChangeType(value, type);
        //        }
        //        else if (typeof(Enum).IsAssignableFrom(type))
        //        {
        //            obj = Enum.Parse(type, value);
        //        }
        //        else
        //        {
        //            obj = Convert.ChangeType(value, type);
        //        }
        //        return obj;
        //    }
        //    catch
        //    {
        //        return default;
        //    }
        //}

        /// <summary>
        /// 变更类型
        /// </summary>
        /// <param name="value">值</param>
        /// <param name="type">类型</param>
        /// <param name="cell">单元格</param>
        public static object ChangeType(object value, Type type, ICell cell)
        {
            try
            {
                if (value == null && type.IsGenericType)
                {
                    return(Activator.CreateInstance(type));
                }
                if (value == null || string.IsNullOrWhiteSpace(value.ToString()))
                {
                    return(null);
                }
                if (type == value.GetType())
                {
                    return(value);
                }
                if (type.IsEnum)
                {
                    if (value is string)
                    {
                        return(Enum.Parse(type, value as string));
                    }
                    else
                    {
                        return(Enum.ToObject(type, value));
                    }
                }
                if (!type.IsInterface && type.IsGenericType)
                {
                    Type   innerType  = type.GetGenericArguments()[0];
                    object innerValue = ChangeType(value, innerType, cell);
                    return(Activator.CreateInstance(type, new object[] { innerValue }));
                }
                if (value is string && type == typeof(Guid))
                {
                    return(new Guid(value as string));
                }
                if (value is string && type == typeof(Version))
                {
                    return(new Version(value as string));
                }
                if (!(value is IConvertible))
                {
                    return(value);
                }
                return(Convert.ChangeType(value, type));
            }
            catch (Exception ex)
            {
                throw new OfficeDataConvertException($"值转换失败。输入值为: {value}, 目标类型为: {type.FullName}", ex)
                      {
                          PrimitiveType = value.GetType(),
                          TargetType    = type,
                          Value         = value,
                          RowIndex      = cell.RowIndex + 1,
                          ColumnIndex   = cell.ColumnIndex + 1,
                          Name          = cell.Name,
                      };
            }
        }