Convert.cs source code in C# .NET

Source code for the .NET framework in C#

                        

Code:

/ DotNET / DotNET / 8.0 / untmp / whidbey / REDBITS / ndp / clr / src / BCL / System / Convert.cs / 1 / Convert.cs

                            // ==++== 
//
//   Copyright (c) Microsoft Corporation.  All rights reserved.
//
// ==--== 
/*============================================================
** 
** Class:   Convert 
**
** 
** Purpose: Home for static conversion methods.
**
**
===========================================================*/ 
namespace System {
    using System; 
    using System.Globalization; 
    using System.Threading;
    using System.Reflection; 
    using System.Runtime.CompilerServices;

    // Returns the type code of this object. An implementation of this method
    // must not return TypeCode.Empty (which represents a null reference) or 
    // TypeCode.Object (which represents an object that doesn't implement the
    // IConvertible interface). An implementation of this method should return 
    // TypeCode.DBNull if the value of this object is a database null. For 
    // example, a nullable integer type should return TypeCode.DBNull if the
    // value of the object is the database null. Otherwise, an implementation 
    // of this method should return the TypeCode that best describes the
    // internal representation of the object.
    // The Value class provides conversion and querying methods for values. The
    // Value class contains static members only, and it is not possible to create 
    // instances of the class.
    // 
    // The statically typed conversion methods provided by the Value class are all 
    // of the form:
    // 
    //    public static XXX ToXXX(YYY value)
    //
    // where XXX is the target type and YYY is the source type. The matrix below
    // shows the set of supported conversions. The set of conversions is symmetric 
    // such that for every ToXXX(YYY) there is also a ToYYY(XXX).
    // 
    // From:  To: Bol Chr SBy Byt I16 U16 I32 U32 I64 U64 Sgl Dbl Dec Dat Str 
    // ---------------------------------------------------------------------
    // Boolean     x       x   x   x   x   x   x   x   x   x   x   x       x 
    // Char            x   x   x   x   x   x   x   x   x                   x
    // SByte       x   x   x   x   x   x   x   x   x   x   x   x   x       x
    // Byte        x   x   x   x   x   x   x   x   x   x   x   x   x       x
    // Int16       x   x   x   x   x   x   x   x   x   x   x   x   x       x 
    // UInt16      x   x   x   x   x   x   x   x   x   x   x   x   x       x
    // Int32       x   x   x   x   x   x   x   x   x   x   x   x   x       x 
    // UInt32      x   x   x   x   x   x   x   x   x   x   x   x   x       x 
    // Int64       x   x   x   x   x   x   x   x   x   x   x   x   x       x
    // UInt64      x   x   x   x   x   x   x   x   x   x   x   x   x       x 
    // Single      x       x   x   x   x   x   x   x   x   x   x   x       x
    // Double      x       x   x   x   x   x   x   x   x   x   x   x       x
    // Decimal     x       x   x   x   x   x   x   x   x   x   x   x       x
    // DateTime                                                        x   x 
    // String      x   x   x   x   x   x   x   x   x   x   x   x   x   x   x
    // --------------------------------------------------------------------- 
    // 
    // For dynamic conversions, the Value class provides a set of methods of the
    // form: 
    //
    //    public static XXX ToXXX(object value)
    //
    // where XXX is the target type (Boolean, Char, SByte, Byte, Int16, UInt16, 
    // Int32, UInt32, Int64, UInt64, Single, Double, Decimal, DateTime,
    // or String). The implementations of these methods all take the form: 
    // 
    //    public static XXX toXXX(object value) {
    //        return value == null? XXX.Default: ((IConvertible)value).ToXXX(); 
    //    }
    //
    // The code first checks if the given value is a null reference (which is the
    // same as Value.Empty), in which case it returns the default value for type 
    // XXX. Otherwise, a cast to IConvertible is performed, and the appropriate ToXXX()
    // method is invoked on the object. An InvalidCastException is thrown if the 
    // cast to IConvertible fails, and that exception is simply allowed to propagate out 
    // of the conversion method.
 
    // Constant representing the database null value. This value is used in
    // database applications to indicate the absense of a known value. Note
    // that Value.DBNull is NOT the same as a null object reference, which is
    // represented by Value.Empty. 
    //
    // The Equals() method of DBNull always returns false, even when the 
    // argument is itself DBNull. 
    //
    // When passed Value.DBNull, the Value.GetTypeCode() method returns 
    // TypeCode.DBNull.
    //
    // When passed Value.DBNull, the Value.ToXXX() methods all throw an
    // InvalidCastException. 

    public static class Convert { 
 
        //A typeof operation is fairly expensive (does a system call), so we'll cache these here
        //statically.  These are exactly lined up with the TypeCode, eg. ConvertType[TypeCode.Int16] 
        //will give you the type of an Int16.
        internal static readonly Type[] ConvertTypes = {
            typeof(System.Empty),
            typeof(Object), 
            typeof(System.DBNull),
            typeof(Boolean), 
            typeof(Char), 
            typeof(SByte),
            typeof(Byte), 
            typeof(Int16),
            typeof(UInt16),
            typeof(Int32),
            typeof(UInt32), 
            typeof(Int64),
            typeof(UInt64), 
            typeof(Single), 
            typeof(Double),
            typeof(Decimal), 
            typeof(DateTime),
            typeof(Object), //TypeCode is discontinuous so we need a placeholder.
            typeof(String)
        }; 

        internal static readonly char[] base64Table = {'A','B','C','D','E','F','G','H','I','J','K','L','M','N','O', 
                                                       'P','Q','R','S','T','U','V','W','X','Y','Z','a','b','c','d', 
                                                       'e','f','g','h','i','j','k','l','m','n','o','p','q','r','s',
                                                       't','u','v','w','x','y','z','0','1','2','3','4','5','6','7', 
                                                       '8','9','+','/','=' };
#if _DEBUG
        static Convert() {
            BCLDebug.Assert(ConvertTypes!=null, "[Convert.cctor]ConvertTypes!=null"); 
            BCLDebug.Assert(ConvertTypes.Length == ((int)TypeCode.String + 1), "[Convert.cctor]ConvertTypes.Length == ((int)TypeCode.String + 1)");
            BCLDebug.Assert(ConvertTypes[(int)TypeCode.Empty]==typeof(System.Empty), 
                            "[Convert.cctor]ConvertTypes[(int)TypeCode.Empty]==typeof(System.Empty)"); 
            BCLDebug.Assert(ConvertTypes[(int)TypeCode.String]==typeof(String),
                            "[Convert.cctor]ConvertTypes[(int)TypeCode.String]==typeof(System.String)"); 
            BCLDebug.Assert(ConvertTypes[(int)TypeCode.Int32]==typeof(int),
                            "[Convert.cctor]ConvertTypes[(int)TypeCode.Int32]==typeof(int)");

        } 
#endif
 
        public static readonly Object DBNull = System.DBNull.Value; 

        // Returns the type code for the given object. If the argument is null, 
        // the result is TypeCode.Empty. If the argument is not a value (i.e. if
        // the object does not implement IConvertible), the result is TypeCode.Object.
        // Otherwise, the result is the type code of the object, as determined by
        // the object's implementation of IConvertible. 
        public static TypeCode GetTypeCode(object value) {
            if (value == null) return TypeCode.Empty; 
            IConvertible temp = value as IConvertible; 
            if (temp != null)
            { 
                return temp.GetTypeCode();
            }
            return TypeCode.Object;
        } 

        // Returns true if the given object is a database null. This operation 
        // corresponds to "value.GetTypeCode() == TypeCode.DBNull". 
        public static bool IsDBNull(object value) {
            if (value == System.DBNull.Value) return true; 
            IConvertible convertible = value as IConvertible;
            return convertible != null? convertible.GetTypeCode() == TypeCode.DBNull: false;
        }
 
        // Converts the given object to the given type. In general, this method is
        // equivalent to calling the Value.ToXXX(value) method for the given 
        // typeCode and boxing the result. 
        //
        // The method first checks if the given object implements IConvertible. If not, 
        // the only permitted conversion is from a null to TypeCode.Empty, the
        // result of which is null.
        //
        // If the object does implement IConvertible, a check is made to see if the 
        // object already has the given type code, in which case the object is
        // simply returned. Otherwise, the appropriate ToXXX() is invoked on the 
        // object's implementation of IConvertible. 
        public static Object ChangeType(Object value, TypeCode typeCode) {
            return ChangeType(value, typeCode, Thread.CurrentThread.CurrentCulture); 
        }

        public static Object ChangeType(Object value, TypeCode typeCode, IFormatProvider provider) {
            if (value == null && (typeCode == TypeCode.Empty || typeCode == TypeCode.String || typeCode == TypeCode.Object)) { 
                return null;
            } 
 
            IConvertible v = value as IConvertible;
            if (v == null) { 
                throw new InvalidCastException(Environment.GetResourceString("InvalidCast_IConvertible"));
            }

            // This line is invalid for things like Enums that return a TypeCode 
            // of Int32, but the object can't actually be cast to an Int32.
            //            if (v.GetTypeCode() == typeCode) return value; 
            switch (typeCode) { 
            case TypeCode.Boolean:
                return v.ToBoolean(provider); 
            case TypeCode.Char:
                return v.ToChar(provider);
            case TypeCode.SByte:
                return v.ToSByte(provider); 
            case TypeCode.Byte:
                return v.ToByte(provider); 
            case TypeCode.Int16: 
                return v.ToInt16(provider);
            case TypeCode.UInt16: 
                return v.ToUInt16(provider);
            case TypeCode.Int32:
                return v.ToInt32(provider);
            case TypeCode.UInt32: 
                return v.ToUInt32(provider);
            case TypeCode.Int64: 
                return v.ToInt64(provider); 
            case TypeCode.UInt64:
                return v.ToUInt64(provider); 
            case TypeCode.Single:
                return v.ToSingle(provider);
            case TypeCode.Double:
                return v.ToDouble(provider); 
            case TypeCode.Decimal:
                return v.ToDecimal(provider); 
            case TypeCode.DateTime: 
                return v.ToDateTime(provider);
            case TypeCode.String: 
                return v.ToString(provider);
            case TypeCode.Object:
                return value;
            case TypeCode.DBNull: 
                throw new InvalidCastException(Environment.GetResourceString("InvalidCast_DBNull"));
            case TypeCode.Empty: 
                throw new InvalidCastException(Environment.GetResourceString("InvalidCast_Empty")); 
            default:
                throw new ArgumentException(Environment.GetResourceString("Arg_UnknownTypeCode")); 
            }
        }

        internal static Object DefaultToType(IConvertible value, Type targetType, IFormatProvider provider) { 
            BCLDebug.Assert(value!=null, "[Convert.DefaultToType]value!=null");
 
            if (targetType==null) { 
                throw new ArgumentNullException("targetType");
            } 

            if (value.GetType()==targetType) {
                return value;
            } 

            if (targetType==ConvertTypes[(int)TypeCode.Boolean]) 
                return value.ToBoolean(provider); 
            if (targetType==ConvertTypes[(int)TypeCode.Char])
                return value.ToChar(provider); 
            if (targetType==ConvertTypes[(int)TypeCode.SByte])
                return value.ToSByte(provider);
            if (targetType==ConvertTypes[(int)TypeCode.Byte])
                return value.ToByte(provider); 
            if (targetType==ConvertTypes[(int)TypeCode.Int16])
                return value.ToInt16(provider); 
            if (targetType==ConvertTypes[(int)TypeCode.UInt16]) 
                return value.ToUInt16(provider);
            if (targetType==ConvertTypes[(int)TypeCode.Int32]) 
                return value.ToInt32(provider);
            if (targetType==ConvertTypes[(int)TypeCode.UInt32])
                return value.ToUInt32(provider);
            if (targetType==ConvertTypes[(int)TypeCode.Int64]) 
                return value.ToInt64(provider);
            if (targetType==ConvertTypes[(int)TypeCode.UInt64]) 
                return value.ToUInt64(provider); 
            if (targetType==ConvertTypes[(int)TypeCode.Single])
                return value.ToSingle(provider); 
            if (targetType==ConvertTypes[(int)TypeCode.Double])
                return value.ToDouble(provider);
            if (targetType==ConvertTypes[(int)TypeCode.Decimal])
                return value.ToDecimal(provider); 
            if (targetType==ConvertTypes[(int)TypeCode.DateTime])
                return value.ToDateTime(provider); 
            if (targetType==ConvertTypes[(int)TypeCode.String]) { 
                return value.ToString(provider);
            } 
            if (targetType==ConvertTypes[(int)TypeCode.Object])
                return (Object)value;
            if (targetType==ConvertTypes[(int)TypeCode.DBNull])
                throw new InvalidCastException(Environment.GetResourceString("InvalidCast_DBNull")); 
            if (targetType==ConvertTypes[(int)TypeCode.Empty])
                throw new InvalidCastException(Environment.GetResourceString("InvalidCast_Empty")); 
            throw new InvalidCastException(String.Format(CultureInfo.CurrentCulture, Environment.GetResourceString("InvalidCast_FromTo"), value.GetType().FullName, targetType.FullName)); 
        }
 
        public static Object ChangeType(Object value, Type conversionType) {
            return ChangeType(value, conversionType, Thread.CurrentThread.CurrentCulture);
        }
 
        public static Object ChangeType(Object value, Type conversionType, IFormatProvider provider) {
            if( conversionType == null) { 
                throw new ArgumentNullException("conversionType"); 
            }
 
            if( value == null ) {
                if(conversionType.IsValueType) {
                    throw new InvalidCastException(Environment.GetResourceString("InvalidCast_CannotCastNullToValueType"));
                } 
                return null;
            } 
 
            IConvertible ic = value as IConvertible;
            if (ic == null) { 
                if ( value.GetType() == conversionType) {
                    return value;
                }
                throw new InvalidCastException(Environment.GetResourceString("InvalidCast_IConvertible")); 
            }
            if (conversionType==ConvertTypes[(int)TypeCode.Boolean]) 
                return ic.ToBoolean(provider); 
            if (conversionType==ConvertTypes[(int)TypeCode.Char])
                return ic.ToChar(provider); 
            if (conversionType==ConvertTypes[(int)TypeCode.SByte])
                return ic.ToSByte(provider);
            if (conversionType==ConvertTypes[(int)TypeCode.Byte])
                return ic.ToByte(provider); 
            if (conversionType==ConvertTypes[(int)TypeCode.Int16])
                return ic.ToInt16(provider); 
            if (conversionType==ConvertTypes[(int)TypeCode.UInt16]) 
                return ic.ToUInt16(provider);
            if (conversionType==ConvertTypes[(int)TypeCode.Int32]) 
                return ic.ToInt32(provider);
            if (conversionType==ConvertTypes[(int)TypeCode.UInt32])
                return ic.ToUInt32(provider);
            if (conversionType==ConvertTypes[(int)TypeCode.Int64]) 
                return ic.ToInt64(provider);
            if (conversionType==ConvertTypes[(int)TypeCode.UInt64]) 
                return ic.ToUInt64(provider); 
            if (conversionType==ConvertTypes[(int)TypeCode.Single])
                return ic.ToSingle(provider); 
            if (conversionType==ConvertTypes[(int)TypeCode.Double])
                return ic.ToDouble(provider);
            if (conversionType==ConvertTypes[(int)TypeCode.Decimal])
                return ic.ToDecimal(provider); 
            if (conversionType==ConvertTypes[(int)TypeCode.DateTime])
                return ic.ToDateTime(provider); 
            if (conversionType==ConvertTypes[(int)TypeCode.String]) { 
                return ic.ToString(provider);
            } 
            if (conversionType==ConvertTypes[(int)TypeCode.Object])
                return (Object)value;
            return ic.ToType(conversionType, provider);
        } 

        // Conversions to Boolean 
        public static bool ToBoolean(Object value) { 
            return value == null? false: ((IConvertible)value).ToBoolean(null);
        } 

        public static bool ToBoolean(Object value, IFormatProvider provider) {
            return value == null? false: ((IConvertible)value).ToBoolean(provider);
        } 

 
        public static bool ToBoolean(bool value) { 
            return value;
        } 

        [CLSCompliant(false)]
        public static bool ToBoolean(sbyte value) {
            return value != 0; 
        }
 
        // To be consistent with IConvertible in the base data types else we get different semantics 
        // with widening operations. Without this operator this widen succeeds,with this API the widening throws.
        public static bool ToBoolean(char value) { 
            return ((IConvertible)value).ToBoolean(null);
        }

        public static bool ToBoolean(byte value) { 
            return value != 0;
        } 
 

        public static bool ToBoolean(short value) { 
            return value != 0;
        }

        [CLSCompliant(false)] 
        public static bool ToBoolean(ushort value) {
            return value != 0; 
        } 

        public static bool ToBoolean(int value) { 
            return value != 0;
        }

        [CLSCompliant(false)] 
        public static bool ToBoolean(uint value) {
            return value != 0; 
        } 

        public static bool ToBoolean(long value) { 
            return value != 0;
        }

        [CLSCompliant(false)] 
        public static bool ToBoolean(ulong value) {
            return value != 0; 
        } 

        public static bool ToBoolean(String value) { 
            if (value == null)
                return false;
            return Boolean.Parse(value);
        } 

        public static bool ToBoolean(String value, IFormatProvider provider) { 
            if (value == null) 
                return false;
            return Boolean.Parse(value); 
        }

        public static bool ToBoolean(float value)
        { 
            return value != 0;
        } 
 
        public static bool ToBoolean(double value)
        { 
            return value != 0;
        }

        public static bool ToBoolean(decimal value) 
        {
            return value != 0; 
        } 

        public static bool ToBoolean(DateTime value) 
        {
            return ((IConvertible)value).ToBoolean(null);
        }
 
        // Disallowed conversions to Boolean
        // public static bool ToBoolean(TimeSpan value) 
 
        // Conversions to Char
 

        public static char ToChar(object value) {
            return value == null? (char)0: ((IConvertible)value).ToChar(null);
        } 

        public static char ToChar(object value, IFormatProvider provider) { 
            return value == null? (char)0: ((IConvertible)value).ToChar(provider); 
        }
 
        public static char ToChar(bool value) {
            return ((IConvertible)value).ToChar(null);
        }
 
        public static char ToChar(char value) {
            return value; 
        } 

        [CLSCompliant(false)] 
        public static char ToChar(sbyte value) {
            if (value < 0) throw new OverflowException(Environment.GetResourceString("Overflow_Char"));
            return (char)value;
        } 

        public static char ToChar(byte value) { 
            return (char)value; 
        }
 
        public static char ToChar(short value) {
            if (value < 0) throw new OverflowException(Environment.GetResourceString("Overflow_Char"));
            return (char)value;
        } 

        [CLSCompliant(false)] 
        public static char ToChar(ushort value) { 
            return (char)value;
        } 

        public static char ToChar(int value) {
            if (value < 0 || value > Char.MaxValue) throw new OverflowException(Environment.GetResourceString("Overflow_Char"));
            return (char)value; 
        }
 
        [CLSCompliant(false)] 
        public static char ToChar(uint value) {
            if (value > Char.MaxValue) throw new OverflowException(Environment.GetResourceString("Overflow_Char")); 
            return (char)value;
        }

        public static char ToChar(long value) { 
            if (value < 0 || value > Char.MaxValue) throw new OverflowException(Environment.GetResourceString("Overflow_Char"));
            return (char)value; 
        } 

        [CLSCompliant(false)] 
        public static char ToChar(ulong value) {
            if (value > Char.MaxValue) throw new OverflowException(Environment.GetResourceString("Overflow_Char"));
            return (char)value;
        } 

        // 
        // @VariantSwitch 
        // Remove FormatExceptions;
        // 
        public static char ToChar(String value) {
            return ToChar(value, null);
        }
 
        public static char ToChar(String value, IFormatProvider provider) {
            if (value == null) 
                throw new ArgumentNullException("value"); 

            if (value.Length != 1) 
                throw new FormatException(Environment.GetResourceString(ResId.Format_NeedSingleChar));

            return value[0];
        } 

        // To be consistent with IConvertible in the base data types else we get different semantics 
        // with widening operations. Without this operator this widen succeeds,with this API the widening throws. 
        public static char ToChar(float value)
        { 
            return ((IConvertible)value).ToChar(null);
        }

        // To be consistent with IConvertible in the base data types else we get different semantics 
        // with widening operations. Without this operator this widen succeeds,with this API the widening throws.
        public static char ToChar(double value) 
        { 
            return ((IConvertible)value).ToChar(null);
        } 

        // To be consistent with IConvertible in the base data types else we get different semantics
        // with widening operations. Without this operator this widen succeeds,with this API the widening throws.
        public static char ToChar(decimal value) 
        {
            return ((IConvertible)value).ToChar(null); 
        } 

        public static char ToChar(DateTime value) 
        {
            return ((IConvertible)value).ToChar(null);
        }
 

        // Disallowed conversions to Char 
        // public static char ToChar(TimeSpan value) 

        // Conversions to SByte 

        [CLSCompliant(false)]
        public static sbyte ToSByte(object value) {
            return value == null? (sbyte)0: ((IConvertible)value).ToSByte(null); 
        }
 
        [CLSCompliant(false)] 
        public static sbyte ToSByte(object value, IFormatProvider provider) {
            return value == null? (sbyte)0: ((IConvertible)value).ToSByte(provider); 
        }

        [CLSCompliant(false)]
        public static sbyte ToSByte(bool value) { 
            return value? (sbyte)Boolean.True: (sbyte)Boolean.False;
        } 
 
        [CLSCompliant(false)]
        public static sbyte ToSByte(sbyte value) { 
            return value;
        }

        [CLSCompliant(false)] 
        public static sbyte ToSByte(char value) {
            if (value > SByte.MaxValue) throw new OverflowException(Environment.GetResourceString("Overflow_SByte")); 
            return (sbyte)value; 
        }
 
        [CLSCompliant(false)]
        public static sbyte ToSByte(byte value) {
            if (value > SByte.MaxValue) throw new OverflowException(Environment.GetResourceString("Overflow_SByte"));
            return (sbyte)value; 
        }
 
        [CLSCompliant(false)] 
        public static sbyte ToSByte(short value) {
            if (value < SByte.MinValue || value > SByte.MaxValue) throw new OverflowException(Environment.GetResourceString("Overflow_SByte")); 
            return (sbyte)value;
        }

        [CLSCompliant(false)] 
        public static sbyte ToSByte(ushort value) {
            if (value > SByte.MaxValue) throw new OverflowException(Environment.GetResourceString("Overflow_SByte")); 
            return (sbyte)value; 
        }
 
        [CLSCompliant(false)]
        public static sbyte ToSByte(int value) {
            if (value < SByte.MinValue || value > SByte.MaxValue) throw new OverflowException(Environment.GetResourceString("Overflow_SByte"));
            return (sbyte)value; 
        }
 
        [CLSCompliant(false)] 
        public static sbyte ToSByte(uint value) {
            if (value > SByte.MaxValue) throw new OverflowException(Environment.GetResourceString("Overflow_SByte")); 
            return (sbyte)value;
        }

        [CLSCompliant(false)] 
        public static sbyte ToSByte(long value) {
            if (value < SByte.MinValue || value > SByte.MaxValue) throw new OverflowException(Environment.GetResourceString("Overflow_SByte")); 
            return (sbyte)value; 
        }
 
        [CLSCompliant(false)]
        public static sbyte ToSByte(ulong value) {
            if (value > (ulong)SByte.MaxValue) throw new OverflowException(Environment.GetResourceString("Overflow_SByte"));
            return (sbyte)value; 
        }
 
        [CLSCompliant(false)] 
        public static sbyte ToSByte(float value) {
            return ToSByte((double)value); 
        }

        [CLSCompliant(false)]
        public static sbyte ToSByte(double value) { 
            return ToSByte(ToInt32(value));
        } 
 
        [CLSCompliant(false)]
        public static sbyte ToSByte(decimal value) { 
            return Decimal.ToSByte(Decimal.Round(value, 0));
        }

        [CLSCompliant(false)] 
        public static sbyte ToSByte(String value) {
            if (value == null) 
                return 0; 
            return SByte.Parse(value, CultureInfo.CurrentCulture);
        } 

        [CLSCompliant(false)]
        public static sbyte ToSByte(String value, IFormatProvider provider) {
            return SByte.Parse(value, NumberStyles.Integer, provider); 
        }
 
        [CLSCompliant(false)] 
        public static sbyte ToSByte(DateTime value)
        { 
            return ((IConvertible)value).ToSByte(null);
        }

        // Disallowed conversions to SByte 
        // public static sbyte ToSByte(TimeSpan value)
 
        // Conversions to Byte 

        public static byte ToByte(object value) { 
            return value == null? (byte)0: ((IConvertible)value).ToByte(null);
        }

        public static byte ToByte(object value, IFormatProvider provider) { 
            return value == null? (byte)0: ((IConvertible)value).ToByte(provider);
        } 
 
        public static byte ToByte(bool value) {
            return value? (byte)Boolean.True: (byte)Boolean.False; 
        }

        public static byte ToByte(byte value) {
            return value; 
        }
 
        public static byte ToByte(char value) { 
            if (value > Byte.MaxValue) throw new OverflowException(Environment.GetResourceString("Overflow_Byte"));
            return (byte)value; 
        }

        [CLSCompliant(false)]
        public static byte ToByte(sbyte value) { 
            if (value < Byte.MinValue) throw new OverflowException(Environment.GetResourceString("Overflow_Byte"));
            return (byte)value; 
        } 

        public static byte ToByte(short value) { 
            if (value < Byte.MinValue || value > Byte.MaxValue) throw new OverflowException(Environment.GetResourceString("Overflow_Byte"));
            return (byte)value;
        }
 
        [CLSCompliant(false)]
        public static byte ToByte(ushort value) { 
            if (value > Byte.MaxValue) throw new OverflowException(Environment.GetResourceString("Overflow_Byte")); 
            return (byte)value;
        } 

        public static byte ToByte(int value) {
            if (value < Byte.MinValue || value > Byte.MaxValue) throw new OverflowException(Environment.GetResourceString("Overflow_Byte"));
            return (byte)value; 
        }
 
        [CLSCompliant(false)] 
        public static byte ToByte(uint value) {
            if (value > Byte.MaxValue) throw new OverflowException(Environment.GetResourceString("Overflow_Byte")); 
            return (byte)value;
        }

        public static byte ToByte(long value) { 
            if (value < Byte.MinValue || value > Byte.MaxValue) throw new OverflowException(Environment.GetResourceString("Overflow_Byte"));
            return (byte)value; 
        } 

        [CLSCompliant(false)] 
        public static byte ToByte(ulong value) {
            if (value > Byte.MaxValue) throw new OverflowException(Environment.GetResourceString("Overflow_Byte"));
            return (byte)value;
        } 

        public static byte ToByte(float value) { 
            return ToByte((double)value); 
        }
 
        public static byte ToByte(double value) {
            return ToByte(ToInt32(value));
        }
 
        public static byte ToByte(decimal value) {
            return Decimal.ToByte(Decimal.Round(value, 0)); 
        } 

        public static byte ToByte(String value) { 
            if (value == null)
                return 0;
            return Byte.Parse(value, CultureInfo.CurrentCulture);
        } 

        public static byte ToByte(String value, IFormatProvider provider) { 
            if (value == null) 
                return 0;
            return Byte.Parse(value, NumberStyles.Integer, provider); 
        }

        public static byte ToByte(DateTime value)
        { 
            return ((IConvertible)value).ToByte(null);
        } 
 

        // Disallowed conversions to Byte 
        // public static byte ToByte(TimeSpan value)

        // Conversions to Int16
 
        public static short ToInt16(object value) {
            return value == null? (short)0: ((IConvertible)value).ToInt16(null); 
        } 

        public static short ToInt16(object value, IFormatProvider provider) { 
            return value == null? (short)0: ((IConvertible)value).ToInt16(provider);
        }

        public static short ToInt16(bool value) { 
            return value? (short)Boolean.True: (short)Boolean.False;
        } 
 
        public static short ToInt16(char value) {
            if (value > Int16.MaxValue) throw new OverflowException(Environment.GetResourceString("Overflow_Int16")); 
            return (short)value;
        }

        [CLSCompliant(false)] 
        public static short ToInt16(sbyte value) {
            return value; 
        } 

        public static short ToInt16(byte value) { 
            return value;
        }

        [CLSCompliant(false)] 
        public static short ToInt16(ushort value) {
            if (value > Int16.MaxValue) throw new OverflowException(Environment.GetResourceString("Overflow_Int16")); 
            return (short)value; 
        }
 
        public static short ToInt16(int value) {
            if (value < Int16.MinValue || value > Int16.MaxValue) throw new OverflowException(Environment.GetResourceString("Overflow_Int16"));
            return (short)value;
        } 

        [CLSCompliant(false)] 
        public static short ToInt16(uint value) { 
            if (value > Int16.MaxValue) throw new OverflowException(Environment.GetResourceString("Overflow_Int16"));
            return (short)value; 
        }

        public static short ToInt16(short value) {
            return value; 
        }
 
        public static short ToInt16(long value) { 
            if (value < Int16.MinValue || value > Int16.MaxValue) throw new OverflowException(Environment.GetResourceString("Overflow_Int16"));
            return (short)value; 
        }

        [CLSCompliant(false)]
        public static short ToInt16(ulong value) { 
            if (value > (ulong)Int16.MaxValue) throw new OverflowException(Environment.GetResourceString("Overflow_Int16"));
            return (short)value; 
        } 

        public static short ToInt16(float value) { 
            return ToInt16((double)value);
        }

        public static short ToInt16(double value) { 
            return ToInt16(ToInt32(value));
        } 
 
        public static short ToInt16(decimal value) {
            return Decimal.ToInt16(Decimal.Round(value, 0)); 
        }

        public static short ToInt16(String value) {
            if (value == null) 
                return 0;
            return Int16.Parse(value, CultureInfo.CurrentCulture); 
        } 

        public static short ToInt16(String value, IFormatProvider provider) { 
            if (value == null)
                return 0;
            return Int16.Parse(value, NumberStyles.Integer, provider);
        } 

        public static short ToInt16(DateTime value) 
        { 
            return ((IConvertible)value).ToInt16(null);
        } 


        // Disallowed conversions to Int16
        // public static short ToInt16(TimeSpan value) 

        // Conversions to UInt16 
 
        [CLSCompliant(false)]
        public static ushort ToUInt16(object value) { 
            return value == null? (ushort)0: ((IConvertible)value).ToUInt16(null);
        }

        [CLSCompliant(false)] 
        public static ushort ToUInt16(object value, IFormatProvider provider) {
            return value == null? (ushort)0: ((IConvertible)value).ToUInt16(provider); 
        } 

 
        [CLSCompliant(false)]
        public static ushort ToUInt16(bool value) {
            return value? (ushort)Boolean.True: (ushort)Boolean.False;
        } 

        [CLSCompliant(false)] 
        public static ushort ToUInt16(char value) { 
            return value;
        } 

        [CLSCompliant(false)]
        public static ushort ToUInt16(sbyte value) {
            if (value < 0) throw new OverflowException(Environment.GetResourceString("Overflow_UInt16")); 
            return (ushort)value;
        } 
 
        [CLSCompliant(false)]
        public static ushort ToUInt16(byte value) { 
            return value;
        }

        [CLSCompliant(false)] 
        public static ushort ToUInt16(short value) {
            if (value < 0) throw new OverflowException(Environment.GetResourceString("Overflow_UInt16")); 
            return (ushort)value; 
        }
 
        [CLSCompliant(false)]
        public static ushort ToUInt16(int value) {
            if (value < 0 || value > UInt16.MaxValue) throw new OverflowException(Environment.GetResourceString("Overflow_UInt16"));
            return (ushort)value; 
        }
 
        [CLSCompliant(false)] 
        public static ushort ToUInt16(ushort value) {
            return value; 
        }

        [CLSCompliant(false)]
        public static ushort ToUInt16(uint value) { 
            if (value > UInt16.MaxValue) throw new OverflowException(Environment.GetResourceString("Overflow_UInt16"));
            return (ushort)value; 
        } 

 
        [CLSCompliant(false)]
        public static ushort ToUInt16(long value) {
            if (value < 0 || value > UInt16.MaxValue) throw new OverflowException(Environment.GetResourceString("Overflow_UInt16"));
            return (ushort)value; 
        }
 
        [CLSCompliant(false)] 
        public static ushort ToUInt16(ulong value) {
            if (value > UInt16.MaxValue) throw new OverflowException(Environment.GetResourceString("Overflow_UInt16")); 
            return (ushort)value;
        }

        [CLSCompliant(false)] 
        public static ushort ToUInt16(float value) {
            return ToUInt16((double)value); 
        } 

        [CLSCompliant(false)] 
        public static ushort ToUInt16(double value) {
            return ToUInt16(ToInt32(value));
        }
 
        [CLSCompliant(false)]
        public static ushort ToUInt16(decimal value) { 
            return Decimal.ToUInt16(Decimal.Round(value, 0)); 
        }
 
        [CLSCompliant(false)]
        public static ushort ToUInt16(String value) {
            if (value == null)
                return 0; 
            return UInt16.Parse(value, CultureInfo.CurrentCulture);
        } 
 
        [CLSCompliant(false)]
        public static ushort ToUInt16(String value, IFormatProvider provider) { 
            if (value == null)
                return 0;
            return UInt16.Parse(value, NumberStyles.Integer, provider);
        } 

        [CLSCompliant(false)] 
        public static ushort ToUInt16(DateTime value) 
        {
            return ((IConvertible)value).ToUInt16(null); 
        }

        // Disallowed conversions to UInt16
        // public static ushort ToUInt16(TimeSpan value) 

        // Conversions to Int32 
 
        public static int ToInt32(object value) {
            return value == null? 0: ((IConvertible)value).ToInt32(null); 
        }

        public static int ToInt32(object value, IFormatProvider provider) {
            return value == null? 0: ((IConvertible)value).ToInt32(provider); 
        }
 
 
        public static int ToInt32(bool value) {
            return value? Boolean.True: Boolean.False; 
        }

        public static int ToInt32(char value) {
            return value; 
        }
 
        [CLSCompliant(false)] 
        public static int ToInt32(sbyte value) {
            return value; 
        }

        public static int ToInt32(byte value) {
            return value; 
        }
 
        public static int ToInt32(short value) { 
            return value;
        } 

        [CLSCompliant(false)]
        public static int ToInt32(ushort value) {
            return value; 
        }
 
        [CLSCompliant(false)] 
        public static int ToInt32(uint value) {
            if (value > Int32.MaxValue) throw new OverflowException(Environment.GetResourceString("Overflow_Int32")); 
            return (int)value;
        }

        public static int ToInt32(int value) { 
            return value;
        } 
 
        public static int ToInt32(long value) {
            if (value < Int32.MinValue || value > Int32.MaxValue) throw new OverflowException(Environment.GetResourceString("Overflow_Int32")); 
            return (int)value;
        }

        [CLSCompliant(false)] 
        public static int ToInt32(ulong value) {
            if (value > Int32.MaxValue) throw new OverflowException(Environment.GetResourceString("Overflow_Int32")); 
            return (int)value; 
        }
 
        public static int ToInt32(float value) {
            return ToInt32((double)value);
        }
 
        public static int ToInt32(double value) {
            if (value >= 0) { 
                if (value < 2147483647.5) { 
                    int result = (int)value;
                    double dif = value - result; 
                    if (dif > 0.5 || dif == 0.5 && (result & 1) != 0) result++;
                    return result;
                }
            } 
            else {
                if (value >= -2147483648.5) { 
                    int result = (int)value; 
                    double dif = value - result;
                    if (dif < -0.5 || dif == -0.5 && (result & 1) != 0) result--; 
                    return result;
                }
            }
            throw new OverflowException(Environment.GetResourceString("Overflow_Int32")); 
        }
 
        public static int ToInt32(decimal value) { 
            return Decimal.FCallToInt32(value);
        } 

        public static int ToInt32(String value) {
            if (value == null)
                return 0; 
            return Int32.Parse(value, CultureInfo.CurrentCulture);
        } 
 
        public static int ToInt32(String value, IFormatProvider provider) {
            if (value == null) 
                return 0;
            return Int32.Parse(value, NumberStyles.Integer, provider);
        }
 
        public static int ToInt32(DateTime value)
        { 
            return ((IConvertible)value).ToInt32(null); 
        }
 

        // Disallowed conversions to Int32
        // public static int ToInt32(TimeSpan value)
 
        // Conversions to UInt32
 
        [CLSCompliant(false)] 
        public static uint ToUInt32(object value) {
            return value == null? 0: ((IConvertible)value).ToUInt32(null); 
        }

        [CLSCompliant(false)]
        public static uint ToUInt32(object value, IFormatProvider provider) { 
            return value == null? 0: ((IConvertible)value).ToUInt32(provider);
        } 
 

        [CLSCompliant(false)] 
        public static uint ToUInt32(bool value) {
            return value? (uint)Boolean.True: (uint)Boolean.False;
        }
 
        [CLSCompliant(false)]
        public static uint ToUInt32(char value) { 
            return value; 
        }
 
        [CLSCompliant(false)]
        public static uint ToUInt32(sbyte value) {
            if (value < 0) throw new OverflowException(Environment.GetResourceString("Overflow_UInt32"));
            return (uint)value; 
        }
 
        [CLSCompliant(false)] 
        public static uint ToUInt32(byte value) {
            return value; 
        }

        [CLSCompliant(false)]
        public static uint ToUInt32(short value) { 
            if (value < 0) throw new OverflowException(Environment.GetResourceString("Overflow_UInt32"));
            return (uint)value; 
        } 

        [CLSCompliant(false)] 
        public static uint ToUInt32(ushort value) {
            return value;
        }
 
        [CLSCompliant(false)]
        public static uint ToUInt32(int value) { 
            if (value < 0) throw new OverflowException(Environment.GetResourceString("Overflow_UInt32")); 
            return (uint)value;
        } 

        [CLSCompliant(false)]
        public static uint ToUInt32(uint value) {
            return value; 
        }
 
        [CLSCompliant(false)] 
        public static uint ToUInt32(long value) {
            if (value < 0 || value > UInt32.MaxValue) throw new OverflowException(Environment.GetResourceString("Overflow_UInt32")); 
            return (uint)value;
        }

        [CLSCompliant(false)] 
        public static uint ToUInt32(ulong value) {
            if (value > UInt32.MaxValue) throw new OverflowException(Environment.GetResourceString("Overflow_UInt32")); 
            return (uint)value; 
        }
 
        [CLSCompliant(false)]
        public static uint ToUInt32(float value) {
            return ToUInt32((double)value);
        } 

        [CLSCompliant(false)] 
        public static uint ToUInt32(double value) { 
            if (value >= -0.5 && value < 4294967295.5) {
                uint result = (uint)value; 
                double dif = value - result;
                if (dif > 0.5 || dif == 0.5 && (result & 1) != 0) result++;
                return result;
            } 
            throw new OverflowException(Environment.GetResourceString("Overflow_UInt32"));
        } 
 
        [CLSCompliant(false)]
        public static uint ToUInt32(decimal value) { 
            return Decimal.ToUInt32(Decimal.Round(value, 0));
        }

        [CLSCompliant(false)] 
        public static uint ToUInt32(String value) {
            if (value == null) 
                return 0; 
            return UInt32.Parse(value, CultureInfo.CurrentCulture);
        } 

        [CLSCompliant(false)]
        public static uint ToUInt32(String value, IFormatProvider provider) {
            if (value == null) 
                return 0;
            return UInt32.Parse(value, NumberStyles.Integer, provider); 
        } 

        [CLSCompliant(false)] 
        public static uint ToUInt32(DateTime value)
        {
            return ((IConvertible)value).ToUInt32(null);
        } 

        // Disallowed conversions to UInt32 
        // public static uint ToUInt32(TimeSpan value) 

        // Conversions to Int64 

        public static long ToInt64(object value) {
            return value == null? 0: ((IConvertible)value).ToInt64(null);
        } 

        public static long ToInt64(object value, IFormatProvider provider) { 
            return value == null? 0: ((IConvertible)value).ToInt64(provider); 
        }
 

        public static long ToInt64(bool value) {
            return value? Boolean.True: Boolean.False;
        } 

        public static long ToInt64(char value) { 
            return value; 
        }
 
        [CLSCompliant(false)]
        public static long ToInt64(sbyte value) {
            return value;
        } 

        public static long ToInt64(byte value) { 
            return value; 
        }
 
        public static long ToInt64(short value) {
            return value;
        }
 
        [CLSCompliant(false)]
        public static long ToInt64(ushort value) { 
            return value; 
        }
 
        public static long ToInt64(int value) {
            return value;
        }
 
        [CLSCompliant(false)]
        public static long ToInt64(uint value) { 
            return value; 
        }
 
        [CLSCompliant(false)]
        public static long ToInt64(ulong value) {
            if (value > Int64.MaxValue) throw new OverflowException(Environment.GetResourceString("Overflow_Int64"));
            return (long)value; 
        }
 
        public static long ToInt64(long value) { 
            return value;
        } 


        public static long ToInt64(float value) {
            return ToInt64((double)value); 
        }
 
        public static long ToInt64(double value) { 
            return checked((long)Math.Round(value));
        } 

        public static long ToInt64(decimal value) {
            return Decimal.ToInt64(Decimal.Round(value, 0));
        } 

        public static long ToInt64(string value) { 
            if (value == null) 
                return 0;
            return Int64.Parse(value, CultureInfo.CurrentCulture); 
        }

        public static long ToInt64(String value, IFormatProvider provider) {
            if (value == null) 
                return 0;
            return Int64.Parse(value, NumberStyles.Integer, provider); 
        } 

        public static long ToInt64(DateTime value) 
        {
            return ((IConvertible)value).ToInt64(null);
        }
 
        // Disallowed conversions to Int64
        // public static long ToInt64(TimeSpan value) 
 
        // Conversions to UInt64
 
        [CLSCompliant(false)]
        public static ulong ToUInt64(object value) {
            return value == null? 0: ((IConvertible)value).ToUInt64(null);
        } 

        [CLSCompliant(false)] 
        public static ulong ToUInt64(object value, IFormatProvider provider) { 
            return value == null? 0: ((IConvertible)value).ToUInt64(provider);
        } 

        [CLSCompliant(false)]
        public static ulong ToUInt64(bool value) {
            return value? (ulong)Boolean.True: (ulong)Boolean.False; 
        }
 
        [CLSCompliant(false)] 
        public static ulong ToUInt64(char value) {
            return value; 
        }


        [CLSCompliant(false)] 
        public static ulong ToUInt64(sbyte value) {
            if (value < 0) throw new OverflowException(Environment.GetResourceString("Overflow_UInt64")); 
            return (ulong)value; 
        }
 
        [CLSCompliant(false)]
        public static ulong ToUInt64(byte value) {
            return value;
        } 

        [CLSCompliant(false)] 
        public static ulong ToUInt64(short value) { 
            if (value < 0) throw new OverflowException(Environment.GetResourceString("Overflow_UInt64"));
            return (ulong)value; 
        }

        [CLSCompliant(false)]
        public static ulong ToUInt64(ushort value) { 
            return value;
        } 
 
        [CLSCompliant(false)]
        public static ulong ToUInt64(int value) { 
            if (value < 0) throw new OverflowException(Environment.GetResourceString("Overflow_UInt64"));
            return (ulong)value;
        }
 
        [CLSCompliant(false)]
        public static ulong ToUInt64(uint value) { 
            return value; 
        }
 
        [CLSCompliant(false)]
        public static ulong ToUInt64(long value) {
            if (value < 0) throw new OverflowException(Environment.GetResourceString("Overflow_UInt64"));
            return (ulong)value; 
        }
 
        [CLSCompliant(false)] 
        public static ulong ToUInt64(UInt64 value) {
            return value; 
        }

        [CLSCompliant(false)]
        public static ulong ToUInt64(float value) { 
            return ToUInt64((double)value);
        } 
 
        [CLSCompliant(false)]
        public static ulong ToUInt64(double value) { 
            return checked((ulong)Math.Round(value));
        }

        [CLSCompliant(false)] 
        public static ulong ToUInt64(decimal value) {
            return Decimal.ToUInt64(Decimal.Round(value, 0)); 
        } 

        [CLSCompliant(false)] 
        public static ulong ToUInt64(String value) {
            if (value == null)
                return 0;
            return UInt64.Parse(value, CultureInfo.CurrentCulture); 
        }
 
        [CLSCompliant(false)] 
        public static ulong ToUInt64(String value, IFormatProvider provider) {
            if (value == null) 
                return 0;
            return UInt64.Parse(value, NumberStyles.Integer, provider);
        }
 
        [CLSCompliant(false)]
        public static ulong ToUInt64(DateTime value) 
        { 
            return ((IConvertible)value).ToUInt64(null);
        } 

        // Disallowed conversions to UInt64
        // public static ulong ToUInt64(TimeSpan value)
 
        // Conversions to Single
 
        public static float ToSingle(object value) { 
            return value == null? 0: ((IConvertible)value).ToSingle(null);
        } 

        public static float ToSingle(object value, IFormatProvider provider) {
            return value == null? 0: ((IConvertible)value).ToSingle(provider);
        } 

        [CLSCompliant(false)] 
        public static float ToSingle(sbyte value) { 
            return value;
        } 

        public static float ToSingle(byte value) {
            return value;
        } 

        public static float ToSingle(char value) { 
            return ((IConvertible)value).ToSingle(null); 
        }
 
        public static float ToSingle(short value) {
            return value;
        }
 
        [CLSCompliant(false)]
        public static float ToSingle(ushort value) { 
            return value; 
        }
 
        public static float ToSingle(int value) {
            return value;
        }
 
        [CLSCompliant(false)]
        public static float ToSingle(uint value) { 
            return value; 
        }
 
        public static float ToSingle(long value) {
            return value;
        }
 
        [CLSCompliant(false)]
        public static float ToSingle(ulong value) { 
            return value; 
        }
 
        public static float ToSingle(float value) {
            return value;
        }
 
        public static float ToSingle(double value) {
            return (float)value; 
        } 

        public static float ToSingle(decimal value) { 
            return (float)value;
        }

        public static float ToSingle(String value) { 
            if (value == null)
                return 0; 
            return Single.Parse(value, CultureInfo.CurrentCulture); 
        }
 
        public static float ToSingle(String value, IFormatProvider provider) {
            if (value == null)
                return 0;
            return Single.Parse(value, NumberStyles.Float | NumberStyles.AllowThousands, provider); 
        }
 
 
        public static float ToSingle(bool value)
        { 
            return value? Boolean.True: Boolean.False;
        }

        public static float ToSingle(DateTime value) 
        {
            return ((IConvertible)value).ToSingle(null); 
        } 

        // Disallowed conversions to Single 
        // public static float ToSingle(TimeSpan value)

        // Conversions to Double
 
        public static double ToDouble(object value) {
            return value == null? 0: ((IConvertible)value).ToDouble(null); 
        } 

        public static double ToDouble(object value, IFormatProvider provider) { 
            return value == null? 0: ((IConvertible)value).ToDouble(provider);
        }

 
        [CLSCompliant(false)]
        public static double ToDouble(sbyte value) { 
            return value; 
        }
 
        public static double ToDouble(byte value) {
            return value;
        }
 
        public static double ToDouble(short value) {
            return value; 
        } 

        public static double ToDouble(char value) { 
            return ((IConvertible)value).ToDouble(null);
        }

        [CLSCompliant(false)] 
        public static double ToDouble(ushort value) {
            return value; 
        } 

        public static double ToDouble(int value) { 
            return value;
        }

        [CLSCompliant(false)] 
        public static double ToDouble(uint value) {
            return value; 
        } 

        public static double ToDouble(long value) { 
            return value;
        }

        [CLSCompliant(false)] 
        public static double ToDouble(ulong value) {
            return value; 
        } 

        public static double ToDouble(float value) { 
            return value;
        }

        public static double ToDouble(double value) { 
            return value;
        } 
 
        public static double ToDouble(decimal value) {
            return (double)value; 
        }

        public static double ToDouble(String value) {
            if (value == null) 
                return 0;
            return Double.Parse(value, CultureInfo.CurrentCulture); 
        } 

        public static double ToDouble(String value, IFormatProvider provider) { 
            if (value == null)
                return 0;
            return Double.Parse(value, NumberStyles.Float | NumberStyles.AllowThousands, provider);
        } 

        public static double ToDouble(bool value) { 
            return value? Boolean.True: Boolean.False; 
        }
 
        public static double ToDouble(DateTime value)
        {
            return ((IConvertible)value).ToDouble(null);
        } 

        // Disallowed conversions to Double 
        // public static double ToDouble(TimeSpan value) 

        // Conversions to Decimal 

        public static decimal ToDecimal(object value) {
            return value == null? 0: ((IConvertible)value).ToDecimal(null);
        } 

        public static decimal ToDecimal(object value, IFormatProvider provider) { 
            return value == null? 0: ((IConvertible)value).ToDecimal(provider); 
        }
 
        [CLSCompliant(false)]
        public static decimal ToDecimal(sbyte value) {
            return value;
        } 

        public static decimal ToDecimal(byte value) { 
            return value; 
        }
 
        public static decimal ToDecimal(char value) {
            return ((IConvertible)value).ToDecimal(null);
        }
 
        public static decimal ToDecimal(short value) {
            return value; 
        } 

        [CLSCompliant(false)] 
        public static decimal ToDecimal(ushort value) {
            return value;
        }
 
        public static decimal ToDecimal(int value) {
            return value; 
        } 

        [CLSCompliant(false)] 
        public static decimal ToDecimal(uint value) {
            return value;
        }
 
        public static decimal ToDecimal(long value) {
            return value; 
        } 

        [CLSCompliant(false)] 
        public static decimal ToDecimal(ulong value) {
            return value;
        }
 
        public static decimal ToDecimal(float value) {
            return (decimal)value; 
        } 

        public static decimal ToDecimal(double value) { 
            return (decimal)value;
        }

        public static decimal ToDecimal(String value) { 
            if (value == null)
                return 0m; 
            return Decimal.Parse(value, CultureInfo.CurrentCulture); 
        }
 
        public static Decimal ToDecimal(String value, IFormatProvider provider) {
            if (value == null)
                return 0m;
            return Decimal.Parse(value, NumberStyles.Number, provider); 
        }
 
        public static decimal ToDecimal(decimal value) { 
            return value;
        } 

        public static decimal ToDecimal(bool value) {
            return value? Boolean.True: Boolean.False;
        } 

        public static decimal ToDecimal(DateTime value) 
        { 
            return ((IConvertible)value).ToDecimal(null);
        } 

        // Disallowed conversions to Decimal
        // public static decimal ToDecimal(TimeSpan value)
 
        // Conversions to DateTime
 
        public static DateTime ToDateTime(DateTime value) { 
            return value;
        } 

        public static DateTime ToDateTime(object value) {
            return value == null? DateTime.MinValue: ((IConvertible)value).ToDateTime(null);
        } 

        public static DateTime ToDateTime(object value, IFormatProvider provider) { 
            return value == null? DateTime.MinValue: ((IConvertible)value).ToDateTime(provider); 
        }
 
        public static DateTime ToDateTime(String value) {
            if (value == null)
                return new DateTime(0);
            return DateTime.Parse(value, CultureInfo.CurrentCulture); 
        }
 
        public static DateTime ToDateTime(String value, IFormatProvider provider) { 
            if (value == null)
                return new DateTime(0); 
            return DateTime.Parse(value, provider);
        }

         [CLSCompliant(false)] 
        public static DateTime ToDateTime(sbyte value) {
            return ((IConvertible)value).ToDateTime(null); 
        } 

        public static DateTime ToDateTime(byte value) { 
            return ((IConvertible)value).ToDateTime(null);
        }

        public static DateTime ToDateTime(short value) { 
            return ((IConvertible)value).ToDateTime(null);
        } 
 
        [CLSCompliant(false)]
        public static DateTime ToDateTime(ushort value) { 
            return ((IConvertible)value).ToDateTime(null);
        }

        public static DateTime ToDateTime(int value) { 
            return ((IConvertible)value).ToDateTime(null);
        } 
 
        [CLSCompliant(false)]
        public static DateTime ToDateTime(uint value) { 
            return ((IConvertible)value).ToDateTime(null);
        }

        public static DateTime ToDateTime(long value) { 
            return ((IConvertible)value).ToDateTime(null);
        } 
 
        [CLSCompliant(false)]
        public static DateTime ToDateTime(ulong value) { 
            return ((IConvertible)value).ToDateTime(null);
        }

        public static DateTime ToDateTime(bool value) { 
            return ((IConvertible)value).ToDateTime(null);
        } 
 
        public static DateTime ToDateTime(char value) {
            return ((IConvertible)value).ToDateTime(null); 
        }

        public static DateTime ToDateTime(float value) {
            return ((IConvertible)value).ToDateTime(null); 
        }
 
        public static DateTime ToDateTime(double value) { 
            return ((IConvertible)value).ToDateTime(null);
        } 

        public static DateTime ToDateTime(decimal value) {
            return ((IConvertible)value).ToDateTime(null);
        } 

        // Disallowed conversions to DateTime 
        // public static DateTime ToDateTime(TimeSpan value) 

        // Conversions to String 

        public static string ToString(Object value) {
            return ToString(value,null);
        } 

        public static string ToString(Object value, IFormatProvider provider) { 
            IConvertible ic = value as IConvertible; 
            if (ic != null)
                return ic.ToString(provider); 
            IFormattable formattable = value as IFormattable;
            if (formattable != null)
                return formattable.ToString(null, provider);
            return value == null? String.Empty: value.ToString(); 
        }
 
        public static string ToString(bool value) { 
            return value.ToString();
        } 

        public static string ToString(bool value, IFormatProvider provider) {
            return value.ToString(provider);
        } 

        public static string ToString(char value) { 
            return Char.ToString(value); 
        }
 
        public static string ToString(char value, IFormatProvider provider) {
            return value.ToString(provider);
        }
 
        [CLSCompliant(false)]
        public static string ToString(sbyte value) { 
            return value.ToString(CultureInfo.CurrentCulture); 
        }
 
        [CLSCompliant(false)]
        public static string ToString(sbyte value, IFormatProvider provider) {
            return value.ToString(provider);
        } 

        public static string ToString(byte value) { 
            return value.ToString(CultureInfo.CurrentCulture); 
        }
 
        public static string ToString(byte value, IFormatProvider provider) {
            return value.ToString(provider);
        }
 
        public static string ToString(short value) {
            return value.ToString(CultureInfo.CurrentCulture); 
        } 

        public static string ToString(short value, IFormatProvider provider) { 
            return value.ToString(provider);
        }

        [CLSCompliant(false)] 
        public static string ToString(ushort value) {
            return value.ToString(CultureInfo.CurrentCulture); 
        } 

        [CLSCompliant(false)] 
        public static string ToString(ushort value, IFormatProvider provider) {
            return value.ToString(provider);
        }
 
        public static string ToString(int value) {
            return value.ToString(CultureInfo.CurrentCulture); 
        } 

        public static string ToString(int value, IFormatProvider provider) { 
            return value.ToString(provider);
        }

        [CLSCompliant(false)] 
        public static string ToString(uint value) {
            return value.ToString(CultureInfo.CurrentCulture); 
        } 

        [CLSCompliant(false)] 
        public static string ToString(uint value, IFormatProvider provider) {
            return value.ToString(provider);
        }
 
        public static string ToString(long value) {
            return value.ToString(CultureInfo.CurrentCulture); 
        } 

        public static string ToString(long value, IFormatProvider provider) { 
            return value.ToString(provider);
        }

        [CLSCompliant(false)] 
        public static string ToString(ulong value) {
            return value.ToString(CultureInfo.CurrentCulture); 
        } 

        [CLSCompliant(false)] 
        public static string ToString(ulong value, IFormatProvider provider) {
            return value.ToString(provider);
        }
 
        public static string ToString(float value) {
            return value.ToString(CultureInfo.CurrentCulture); 
        } 

        public static string ToString(float value, IFormatProvider provider) { 
            return value.ToString(provider);
        }

        public static string ToString(double value) { 
            return value.ToString(CultureInfo.CurrentCulture);
        } 
 
        public static string ToString(double value, IFormatProvider provider) {
            return value.ToString(provider); 
        }

        public static string ToString(decimal value) {
            return value.ToString(CultureInfo.CurrentCulture); 
        }
 
        public static string ToString(Decimal value, IFormatProvider provider) { 
            return value.ToString(provider);
        } 

        public static string ToString(DateTime value) {
            return value.ToString();
        } 

        public static string ToString(DateTime value, IFormatProvider provider) { 
            return value.ToString(provider); 
        }
 
        public static String ToString(String value) {
            return value;
        }
 
        public static String ToString(String value,IFormatProvider provider) {
            return value; // avoid the null check 
        } 

 
        //
        // Conversions which understand Base XXX numbers.
        //
        // Parses value in base base.  base can only 
        // be 2, 8, 10, or 16.  If base is 16, the number may be preceded
        // by 0x; any other leading or trailing characters cause an error. 
        // 
        public static byte ToByte (String value, int fromBase) {
            if (fromBase!=2 && fromBase!=8 && fromBase!=10 && fromBase!=16) { 
                throw new ArgumentException(Environment.GetResourceString("Arg_InvalidBase"));
            }
            int r = ParseNumbers.StringToInt(value,fromBase,ParseNumbers.IsTight | ParseNumbers.TreatAsUnsigned);
            if (r < Byte.MinValue || r > Byte.MaxValue) 
                throw new OverflowException(Environment.GetResourceString("Overflow_Byte"));
            return (byte) r; 
        } 

        // Parses value in base fromBase.  fromBase can only 
        // be 2, 8, 10, or 16.  If fromBase is 16, the number may be preceded
        // by 0x; any other leading or trailing characters cause an error.
        //
        [CLSCompliant(false)] 
        public static sbyte ToSByte (String value, int fromBase) {
            if (fromBase!=2 && fromBase!=8 && fromBase!=10 && fromBase!=16) { 
                throw new ArgumentException(Environment.GetResourceString("Arg_InvalidBase")); 
            }
            int r = ParseNumbers.StringToInt(value,fromBase,ParseNumbers.IsTight | ParseNumbers.TreatAsI1); 
            if (fromBase != 10 && r <= Byte.MaxValue)
                return (sbyte)r;

            if (r < SByte.MinValue || r > SByte.MaxValue) 
                throw new OverflowException(Environment.GetResourceString("Overflow_SByte"));
            return (sbyte) r; 
        } 

        // Parses value in base fromBase.  fromBase can only 
        // be 2, 8, 10, or 16.  If fromBase is 16, the number may be preceded
        // by 0x; any other leading or trailing characters cause an error.
        //
        public static short ToInt16 (String value, int fromBase) { 
            if (fromBase!=2 && fromBase!=8 && fromBase!=10 && fromBase!=16) {
                throw new ArgumentException(Environment.GetResourceString("Arg_InvalidBase")); 
            } 
            int r = ParseNumbers.StringToInt(value,fromBase,ParseNumbers.IsTight | ParseNumbers.TreatAsI2);
            if (fromBase != 10 && r <= UInt16.MaxValue) 
                return (short)r;

            if (r < Int16.MinValue || r > Int16.MaxValue)
                throw new OverflowException(Environment.GetResourceString("Overflow_Int16")); 
            return (short) r;
        } 
 
        // Parses value in base fromBase.  fromBase can only
        // be 2, 8, 10, or 16.  If fromBase is 16, the number may be preceded 
        // by 0x; any other leading or trailing characters cause an error.
        //
        [CLSCompliant(false)]
            public static ushort ToUInt16 (String value, int fromBase) { 
            if (fromBase!=2 && fromBase!=8 && fromBase!=10 && fromBase!=16) {
                throw new ArgumentException(Environment.GetResourceString("Arg_InvalidBase")); 
            } 
            int r = ParseNumbers.StringToInt(value,fromBase,ParseNumbers.IsTight | ParseNumbers.TreatAsUnsigned);
            if (r < UInt16.MinValue || r > UInt16.MaxValue) 
                throw new OverflowException(Environment.GetResourceString("Overflow_UInt16"));
            return (ushort) r;
        }
 
        // Parses value in base fromBase.  fromBase can only
        // be 2, 8, 10, or 16.  If fromBase is 16, the number may be preceded 
        // by 0x; any other leading or trailing characters cause an error. 
        //
        public static int ToInt32 (String value, int fromBase) { 
            if (fromBase!=2 && fromBase!=8 && fromBase!=10 && fromBase!=16) {
                throw new ArgumentException(Environment.GetResourceString("Arg_InvalidBase"));
            }
            return ParseNumbers.StringToInt(value,fromBase,ParseNumbers.IsTight); 
        }
 
        // Parses value in base fromBase.  fromBase can only 
        // be 2, 8, 10, or 16.  If fromBase is 16, the number may be preceded
        // by 0x; any other leading or trailing characters cause an error. 
        //
        [CLSCompliant(false)]
            public static uint ToUInt32 (String value, int fromBase) {
            if (fromBase!=2 && fromBase!=8 && fromBase!=10 && fromBase!=16) { 
                throw new ArgumentException(Environment.GetResourceString("Arg_InvalidBase"));
            } 
            return (uint) ParseNumbers.StringToInt(value,fromBase, ParseNumbers.TreatAsUnsigned | ParseNumbers.IsTight); 
        }
 
        // Parses value in base fromBase.  fromBase can only
        // be 2, 8, 10, or 16.  If fromBase is 16, the number may be preceded
        // by 0x; any other leading or trailing characters cause an error.
        // 
        public static long ToInt64 (String value, int fromBase) {
            if (fromBase!=2 && fromBase!=8 && fromBase!=10 && fromBase!=16) { 
                throw new ArgumentException(Environment.GetResourceString("Arg_InvalidBase")); 
            }
            return ParseNumbers.StringToLong(value,fromBase,ParseNumbers.IsTight); 
        }

        // Parses value in base fromBase.  fromBase can only
        // be 2, 8, 10, or 16.  If fromBase is 16, the number may be preceded 
        // by 0x; any other leading or trailing characters cause an error.
        // 
        [CLSCompliant(false)] 
        public static ulong ToUInt64 (String value, int fromBase) {
            if (fromBase!=2 && fromBase!=8 && fromBase!=10 && fromBase!=16) { 
                throw new ArgumentException(Environment.GetResourceString("Arg_InvalidBase"));
            }
            return (ulong) ParseNumbers.StringToLong(value,fromBase, ParseNumbers.TreatAsUnsigned | ParseNumbers.IsTight);
        } 

        // Convert the byte value to a string in base fromBase 
        public static String ToString (byte value, int toBase) { 
            if (toBase!=2 && toBase!=8 && toBase!=10 && toBase!=16) {
                throw new ArgumentException(Environment.GetResourceString("Arg_InvalidBase")); 
            }
            return ParseNumbers.IntToString((int)value, toBase, -1, ' ', ParseNumbers.PrintAsI1);
        }
 
        // Convert the Int16 value to a string in base fromBase
        public static String ToString (short value, int toBase) { 
            if (toBase!=2 && toBase!=8 && toBase!=10 && toBase!=16) { 
                throw new ArgumentException(Environment.GetResourceString("Arg_InvalidBase"));
            } 
            return ParseNumbers.IntToString((int)value, toBase, -1, ' ', ParseNumbers.PrintAsI2);
        }

        // Convert the Int32 value to a string in base toBase 
        public static String ToString (int value, int toBase) {
            if (toBase!=2 && toBase!=8 && toBase!=10 && toBase!=16) { 
                throw new ArgumentException(Environment.GetResourceString("Arg_InvalidBase")); 
            }
            return ParseNumbers.IntToString(value, toBase, -1, ' ', 0); 
        }

        // Convert the Int64 value to a string in base toBase
        public static String ToString (long value, int toBase) { 
            if (toBase!=2 && toBase!=8 && toBase!=10 && toBase!=16) {
                throw new ArgumentException(Environment.GetResourceString("Arg_InvalidBase")); 
            } 
            return ParseNumbers.LongToString(value, toBase, -1, ' ', 0);
        } 

        public static String ToBase64String(byte[] inArray) {
            if (inArray==null) {
                throw new ArgumentNullException("inArray"); 
            }
            return ToBase64String(inArray, 0, inArray.Length, Base64FormattingOptions.None); 
        } 

        [System.Runtime.InteropServices.ComVisible(false)] 
        public static String ToBase64String(byte[] inArray, Base64FormattingOptions options) {
            if (inArray==null) {
                throw new ArgumentNullException("inArray");
            } 
            return ToBase64String(inArray, 0, inArray.Length, options);
        } 
 
        public static String ToBase64String(byte[] inArray, int offset, int length) {
            return ToBase64String(inArray, offset, length, Base64FormattingOptions.None); 
        }

        [System.Runtime.InteropServices.ComVisible(false)]
        public static unsafe String ToBase64String(byte[] inArray, int offset, int length, Base64FormattingOptions options) { 
            int     inArrayLength;
            int     stringLength; 
 
            //Do data verfication
            if (inArray==null) 
                throw new ArgumentNullException("inArray");
            if (length<0)
                throw new ArgumentOutOfRangeException("length", Environment.GetResourceString("ArgumentOutOfRange_Index"));
            if (offset<0) 
                throw new ArgumentOutOfRangeException("offset", Environment.GetResourceString("ArgumentOutOfRange_GenericPositive"));
            inArrayLength = inArray.Length; 
            if (offset > (inArrayLength - length)) 
                throw new ArgumentOutOfRangeException("offset", Environment.GetResourceString("ArgumentOutOfRange_OffsetLength"));
 
            if( options < Base64FormattingOptions.None || options > Base64FormattingOptions.InsertLineBreaks) {
                throw new ArgumentException(Environment.GetResourceString("Arg_EnumIllegalVal", (int)options));
            }
 
            if (inArrayLength == 0)
                return String.Empty; 
 
            bool insertLineBreaks = (options == Base64FormattingOptions.InsertLineBreaks);
            //Create the new string.  This is the maximally required length. 
            stringLength = CalculateOutputLength(length, insertLineBreaks);

            string returnString = String.GetStringForStringBuilder(String.Empty, stringLength);
            fixed (char* outChars = returnString){ 
                fixed (byte* inData = inArray) {
                    int j = ConvertToBase64Array(outChars,inData,offset,length, insertLineBreaks); 
                    returnString.SetLength(j); 
                    return returnString;
                } 
            }
        }

        public static int ToBase64CharArray(byte[] inArray, int offsetIn, int length, char[] outArray, int offsetOut) { 
            return ToBase64CharArray (inArray, offsetIn, length, outArray, offsetOut, Base64FormattingOptions.None);
        } 
 
        [System.Runtime.InteropServices.ComVisible(false)]
        public static unsafe int ToBase64CharArray(byte[] inArray, int offsetIn, int length, char[] outArray, int offsetOut, Base64FormattingOptions options) { 

            int retVal;

            int inArrayLength; 
            int outArrayLength;
            int numElementsToCopy; 
 
            //Do data verfication
            if (inArray==null) 
                throw new ArgumentNullException("inArray");
            if (outArray==null)
                throw new ArgumentNullException("outArray");
            if (length<0) 
                throw new ArgumentOutOfRangeException("length", Environment.GetResourceString("ArgumentOutOfRange_Index"));
            if (offsetIn<0) 
                throw new ArgumentOutOfRangeException("offsetIn", Environment.GetResourceString("ArgumentOutOfRange_GenericPositive")); 
            if (offsetOut<0)
                throw new ArgumentOutOfRangeException("offsetOut", Environment.GetResourceString("ArgumentOutOfRange_GenericPositive")); 

            if( options < Base64FormattingOptions.None || options > Base64FormattingOptions.InsertLineBreaks) {
                throw new ArgumentException(Environment.GetResourceString("Arg_EnumIllegalVal", (int)options));
            } 

            inArrayLength = inArray.Length; 
 
            if (offsetIn > (int)(inArrayLength - length))
                throw new ArgumentOutOfRangeException("offsetIn", Environment.GetResourceString("ArgumentOutOfRange_OffsetLength")); 

            if (inArrayLength == 0)
                return 0;
 
            bool insertLineBreaks = (options == Base64FormattingOptions.InsertLineBreaks);
            //This is the maximally required length that must be available in the char array 
            outArrayLength = outArray.Length; 

            // Length of the char buffer required 
            numElementsToCopy = CalculateOutputLength(length, insertLineBreaks);

            if (offsetOut > (int)(outArrayLength -  numElementsToCopy))
                throw new ArgumentOutOfRangeException("offsetOut", Environment.GetResourceString("ArgumentOutOfRange_OffsetOut")); 

            fixed (char* outChars = &outArray[offsetOut]) { 
                fixed (byte* inData = inArray) { 
                   retVal = ConvertToBase64Array(outChars,inData,offsetIn,length, insertLineBreaks);
                } 
            }

            return retVal;
        } 

        private static unsafe int ConvertToBase64Array(char* outChars, byte* inData, int offset, int length, bool insertLineBreaks) { 
            int lengthmod3 = length%3; 
            int calcLength = offset + (length - lengthmod3);
            int j=0; 
            int charcount = 0;
            //Convert three bytes at a time to base64 notation.  This will consume 4 chars.
            int i;
 
            // get a pointer to the base64Table to avoid unnecessary range checking
            fixed(char* base64 = base64Table) { 
                for (i=offset; i>2];
                    outChars[j+1] = base64[((inData[i]&0x03)<<4) | ((inData[i+1]&0xf0)>>4)]; 
                    outChars[j+2] = base64[((inData[i+1]&0x0f)<<2) | ((inData[i+2]&0xc0)>>6)];
                    outChars[j+3] = base64[(inData[i+2]&0x3f)];
                    j += 4;
                } 

                //Where we left off before 
                i =  calcLength; 

                if (insertLineBreaks && (lengthmod3 !=0) && (charcount == 76)) { 
                    outChars[j++] = '\r';
                    outChars[j++] = '\n';
                }
 
                switch(lengthmod3)
                { 
                case 2: //One character padding needed 
                    outChars[j] = base64[(inData[i]&0xfc)>>2];
                    outChars[j+1] = base64[((inData[i]&0x03)<<4)|((inData[i+1]&0xf0)>>4)]; 
                    outChars[j+2] = base64[(inData[i+1]&0x0f)<<2];
                    outChars[j+3] = base64[64]; //Pad
                    j+=4;
                    break; 
                case 1: // Two character padding needed
                    outChars[j] = base64[(inData[i]&0xfc)>>2]; 
                    outChars[j+1] = base64[(inData[i]&0x03)<<4]; 
                    outChars[j+2] = base64[64]; //Pad
                    outChars[j+3] = base64[64]; //Pad 
                    j+=4;
                    break;
                }
            } 

            return j; 
        } 

        private static int CalculateOutputLength(int inputLength, bool insertLineBreaks) { 
            int outlen = (int)( inputLength / 3 * 4);           // the base length - we want integer division here.
            outlen += ((inputLength % 3) != 0) ? 4 : 0;         // at most 4 more chars for the remainder

            if (outlen ==0 ) 
                return outlen;
 
            if (insertLineBreaks) { 
                int newLines = outlen / 76;
                if( (outlen % 76) == 0) { 
                    --newLines;
                }
                outlen += newLines * 2;              // the number of line break chars we'll add, "\r\n"
            } 
            return outlen;
        } 
 
        [MethodImplAttribute(MethodImplOptions.InternalCall)]
        public static extern byte[] FromBase64String(String s); 

        [MethodImplAttribute(MethodImplOptions.InternalCall)]
        public static extern byte[] FromBase64CharArray(char[] inArray, int offset, int length);
 
    }
 
    [Flags] 
    public enum Base64FormattingOptions {
        None = 0, 
        InsertLineBreaks = 1
    }
}
                        

Link Menu

Network programming in C#, Network Programming in VB.NET, Network Programming in .NET
This book is available now!
Buy at Amazon US or
Buy at Amazon UK