The Labs \ Source Viewer \ SSCLI \ System \ Base64FormattingOptions

  1. // ==++==
  2. //
  3. //
  4. // Copyright (c) 2006 Microsoft Corporation. All rights reserved.
  5. //
  6. // The use and distribution terms for this software are contained in the file
  7. // named license.txt, which can be found in the root of this distribution.
  8. // By using this software in any fashion, you are agreeing to be bound by the
  9. // terms of this license.
  10. //
  11. // You must not remove this notice, or any other, from this software.
  12. //
  13. //
  14. // ==--==
  15. /*============================================================
  16. **
  17. ** Class:  Convert
  18. **
  19. **
  20. ** Purpose: Home for static conversion methods.
  21. **
  22. **
  23. ===========================================================*/
  24. namespace System
  25. {
  26.     using System;
  27.     using System.Globalization;
  28.     using System.Threading;
  29.     using System.Reflection;
  30.     using System.Runtime.CompilerServices;
  31.    
  32.     // Returns the type code of this object. An implementation of this method
  33.     // must not return TypeCode.Empty (which represents a null reference) or
  34.     // TypeCode.Object (which represents an object that doesn't implement the
  35.     // IConvertible interface). An implementation of this method should return
  36.     // TypeCode.DBNull if the value of this object is a database null. For
  37.     // example, a nullable integer type should return TypeCode.DBNull if the
  38.     // value of the object is the database null. Otherwise, an implementation
  39.     // of this method should return the TypeCode that best describes the
  40.     // internal representation of the object.
  41.     // The Value class provides conversion and querying methods for values. The
  42.     // Value class contains static members only, and it is not possible to create
  43.     // instances of the class.
  44.     //
  45.     // The statically typed conversion methods provided by the Value class are all
  46.     // of the form:
  47.     //
  48.     // public static XXX ToXXX(YYY value)
  49.     //
  50.     // where XXX is the target type and YYY is the source type. The matrix below
  51.     // shows the set of supported conversions. The set of conversions is symmetric
  52.     // such that for every ToXXX(YYY) there is also a ToYYY(XXX).
  53.     //
  54.     // From: To: Bol Chr SBy Byt I16 U16 I32 U32 I64 U64 Sgl Dbl Dec Dat Str
  55.     // ----------------------------------------------------------------------
  56.     // Boolean x x x x x x x x x x x x x
  57.     // Char x x x x x x x x x x
  58.     // SByte x x x x x x x x x x x x x x
  59.     // Byte x x x x x x x x x x x x x x
  60.     // Int16 x x x x x x x x x x x x x x
  61.     // UInt16 x x x x x x x x x x x x x x
  62.     // Int32 x x x x x x x x x x x x x x
  63.     // UInt32 x x x x x x x x x x x x x x
  64.     // Int64 x x x x x x x x x x x x x x
  65.     // UInt64 x x x x x x x x x x x x x x
  66.     // Single x x x x x x x x x x x x x
  67.     // Double x x x x x x x x x x x x x
  68.     // Decimal x x x x x x x x x x x x x
  69.     // DateTime x x
  70.     // String x x x x x x x x x x x x x x x
  71.     // ----------------------------------------------------------------------
  72.     //
  73.     // For dynamic conversions, the Value class provides a set of methods of the
  74.     // form:
  75.     //
  76.     // public static XXX ToXXX(object value)
  77.     //
  78.     // where XXX is the target type (Boolean, Char, SByte, Byte, Int16, UInt16,
  79.     // Int32, UInt32, Int64, UInt64, Single, Double, Decimal, DateTime,
  80.     // or String). The implementations of these methods all take the form:
  81.     //
  82.     // public static XXX toXXX(object value) {
  83.     // return value == null? XXX.Default: ((IConvertible)value).ToXXX();
  84.     // }
  85.     //
  86.     // The code first checks if the given value is a null reference (which is the
  87.     // same as Value.Empty), in which case it returns the default value for type
  88.     // XXX. Otherwise, a cast to IConvertible is performed, and the appropriate ToXXX()
  89.     // method is invoked on the object. An InvalidCastException is thrown if the
  90.     // cast to IConvertible fails, and that exception is simply allowed to propagate out
  91.     // of the conversion method.
  92.    
  93.     // Constant representing the database null value. This value is used in
  94.     // database applications to indicate the absense of a known value. Note
  95.     // that Value.DBNull is NOT the same as a null object reference, which is
  96.     // represented by Value.Empty.
  97.     //
  98.     // The Equals() method of DBNull always returns false, even when the
  99.     // argument is itself DBNull.
  100.     //
  101.     // When passed Value.DBNull, the Value.GetTypeCode() method returns
  102.     // TypeCode.DBNull.
  103.     //
  104.     // When passed Value.DBNull, the Value.ToXXX() methods all throw an
  105.     // InvalidCastException.
  106.    
  107.     public static class Convert
  108.     {
  109.        
  110.         //A typeof operation is fairly expensive (does a system call), so we'll cache these here
  111.         //statically. These are exactly lined up with the TypeCode, eg. ConvertType[TypeCode.Int16]
  112.         //will give you the type of an Int16.
  113.         static internal readonly Type[] ConvertTypes = {typeof(System.Empty), typeof(object), typeof(System.DBNull), typeof(bool), typeof(char), typeof(sbyte), typeof(byte), typeof(Int16), typeof(UInt16), typeof(Int32),
  114.             //TypeCode is discontinuous so we need a placeholder.
  115.         typeof(UInt32), typeof(Int64), typeof(UInt64), typeof(float), typeof(double), typeof(decimal), typeof(DateTime), typeof(object), typeof(string)};
  116.        
  117.         static internal readonly char[] base64Table = {'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J',
  118.         'K', 'L', 'M', 'N', 'O', 'P', 'Q', 'R', 'S', 'T',
  119.         'U', 'V', 'W', 'X', 'Y', 'Z', 'a', 'b', 'c', 'd',
  120.         'e', 'f', 'g', 'h', 'i', 'j', 'k', 'l', 'm', 'n',
  121.         'o', 'p', 'q', 'r', 's', 't', 'u', 'v', 'w', 'x',
  122.         'y', 'z', '0', '1', '2', '3', '4', '5', '6', '7',
  123.         '8', '9', '+', '/', '='};
  124.         #if _DEBUG
  125.         static Convert()
  126.         {
  127.             BCLDebug.Assert(ConvertTypes != null, "[Convert.cctor]ConvertTypes!=null");
  128.             BCLDebug.Assert(ConvertTypes.Length == ((int)TypeCode.String + 1), "[Convert.cctor]ConvertTypes.Length == ((int)TypeCode.String + 1)");
  129.             BCLDebug.Assert(ConvertTypes[(int)TypeCode.Empty] == typeof(System.Empty), "[Convert.cctor]ConvertTypes[(int)TypeCode.Empty]==typeof(System.Empty)");
  130.             BCLDebug.Assert(ConvertTypes[(int)TypeCode.String] == typeof(string), "[Convert.cctor]ConvertTypes[(int)TypeCode.String]==typeof(System.String)");
  131.             BCLDebug.Assert(ConvertTypes[(int)TypeCode.Int32] == typeof(int), "[Convert.cctor]ConvertTypes[(int)TypeCode.Int32]==typeof(int)");
  132.            
  133.         }
  134.         #endif
  135.        
  136.         public static readonly object DBNull = System.DBNull.Value;
  137.        
  138.         // Returns the type code for the given object. If the argument is null,
  139.         // the result is TypeCode.Empty. If the argument is not a value (i.e. if
  140.         // the object does not implement IConvertible), the result is TypeCode.Object.
  141.         // Otherwise, the result is the type code of the object, as determined by
  142.         // the object's implementation of IConvertible.
  143.         public static TypeCode GetTypeCode(object value)
  144.         {
  145.             if (value == null)
  146.                 return TypeCode.Empty;
  147.             IConvertible temp = value as IConvertible;
  148.             if (temp != null) {
  149.                 return temp.GetTypeCode();
  150.             }
  151.             return TypeCode.Object;
  152.         }
  153.        
  154.         // Returns true if the given object is a database null. This operation
  155.         // corresponds to "value.GetTypeCode() == TypeCode.DBNull".
  156.         public static bool IsDBNull(object value)
  157.         {
  158.             if (value == System.DBNull.Value)
  159.                 return true;
  160.             IConvertible convertible = value as IConvertible;
  161.             return convertible != null ? convertible.GetTypeCode() == TypeCode.DBNull : false;
  162.         }
  163.        
  164.         // Converts the given object to the given type. In general, this method is
  165.         // equivalent to calling the Value.ToXXX(value) method for the given
  166.         // typeCode and boxing the result.
  167.         //
  168.         // The method first checks if the given object implements IConvertible. If not,
  169.         // the only permitted conversion is from a null to TypeCode.Empty, the
  170.         // result of which is null.
  171.         //
  172.         // If the object does implement IConvertible, a check is made to see if the
  173.         // object already has the given type code, in which case the object is
  174.         // simply returned. Otherwise, the appropriate ToXXX() is invoked on the
  175.         // object's implementation of IConvertible.
  176.         public static object ChangeType(object value, TypeCode typeCode)
  177.         {
  178.             return ChangeType(value, typeCode, Thread.CurrentThread.CurrentCulture);
  179.         }
  180.        
  181.         public static object ChangeType(object value, TypeCode typeCode, IFormatProvider provider)
  182.         {
  183.             if (value == null && (typeCode == TypeCode.Empty || typeCode == TypeCode.String || typeCode == TypeCode.Object)) {
  184.                 return null;
  185.             }
  186.            
  187.             IConvertible v = value as IConvertible;
  188.             if (v == null) {
  189.                 throw new InvalidCastException(Environment.GetResourceString("InvalidCast_IConvertible"));
  190.             }
  191.            
  192.             // This line is invalid for things like Enums that return a TypeCode
  193.             // of Int32, but the object can't actually be cast to an Int32.
  194.             // if (v.GetTypeCode() == typeCode) return value;
  195.             switch (typeCode) {
  196.                 case TypeCode.Boolean:
  197.                     return v.ToBoolean(provider);
  198.                 case TypeCode.Char:
  199.                     return v.ToChar(provider);
  200.                 case TypeCode.SByte:
  201.                     return v.ToSByte(provider);
  202.                 case TypeCode.Byte:
  203.                     return v.ToByte(provider);
  204.                 case TypeCode.Int16:
  205.                     return v.ToInt16(provider);
  206.                 case TypeCode.UInt16:
  207.                     return v.ToUInt16(provider);
  208.                 case TypeCode.Int32:
  209.                     return v.ToInt32(provider);
  210.                 case TypeCode.UInt32:
  211.                     return v.ToUInt32(provider);
  212.                 case TypeCode.Int64:
  213.                     return v.ToInt64(provider);
  214.                 case TypeCode.UInt64:
  215.                     return v.ToUInt64(provider);
  216.                 case TypeCode.Single:
  217.                     return v.ToSingle(provider);
  218.                 case TypeCode.Double:
  219.                     return v.ToDouble(provider);
  220.                 case TypeCode.Decimal:
  221.                     return v.ToDecimal(provider);
  222.                 case TypeCode.DateTime:
  223.                     return v.ToDateTime(provider);
  224.                 case TypeCode.String:
  225.                     return v.ToString(provider);
  226.                 case TypeCode.Object:
  227.                     return value;
  228.                 case TypeCode.DBNull:
  229.                     throw new InvalidCastException(Environment.GetResourceString("InvalidCast_DBNull"));
  230.                     break;
  231.                 case TypeCode.Empty:
  232.                     throw new InvalidCastException(Environment.GetResourceString("InvalidCast_Empty"));
  233.                     break;
  234.                 default:
  235.                     throw new ArgumentException(Environment.GetResourceString("Arg_UnknownTypeCode"));
  236.                     break;
  237.             }
  238.         }
  239.        
  240.         static internal object DefaultToType(IConvertible value, Type targetType, IFormatProvider provider)
  241.         {
  242.             BCLDebug.Assert(value != null, "[Convert.DefaultToType]value!=null");
  243.            
  244.             if (targetType == null) {
  245.                 throw new ArgumentNullException("targetType");
  246.             }
  247.            
  248.             if (value.GetType() == targetType) {
  249.                 return value;
  250.             }
  251.            
  252.             if (targetType == ConvertTypes[(int)TypeCode.Boolean])
  253.                 return value.ToBoolean(provider);
  254.             if (targetType == ConvertTypes[(int)TypeCode.Char])
  255.                 return value.ToChar(provider);
  256.             if (targetType == ConvertTypes[(int)TypeCode.SByte])
  257.                 return value.ToSByte(provider);
  258.             if (targetType == ConvertTypes[(int)TypeCode.Byte])
  259.                 return value.ToByte(provider);
  260.             if (targetType == ConvertTypes[(int)TypeCode.Int16])
  261.                 return value.ToInt16(provider);
  262.             if (targetType == ConvertTypes[(int)TypeCode.UInt16])
  263.                 return value.ToUInt16(provider);
  264.             if (targetType == ConvertTypes[(int)TypeCode.Int32])
  265.                 return value.ToInt32(provider);
  266.             if (targetType == ConvertTypes[(int)TypeCode.UInt32])
  267.                 return value.ToUInt32(provider);
  268.             if (targetType == ConvertTypes[(int)TypeCode.Int64])
  269.                 return value.ToInt64(provider);
  270.             if (targetType == ConvertTypes[(int)TypeCode.UInt64])
  271.                 return value.ToUInt64(provider);
  272.             if (targetType == ConvertTypes[(int)TypeCode.Single])
  273.                 return value.ToSingle(provider);
  274.             if (targetType == ConvertTypes[(int)TypeCode.Double])
  275.                 return value.ToDouble(provider);
  276.             if (targetType == ConvertTypes[(int)TypeCode.Decimal])
  277.                 return value.ToDecimal(provider);
  278.             if (targetType == ConvertTypes[(int)TypeCode.DateTime])
  279.                 return value.ToDateTime(provider);
  280.             if (targetType == ConvertTypes[(int)TypeCode.String]) {
  281.                 return value.ToString(provider);
  282.             }
  283.             if (targetType == ConvertTypes[(int)TypeCode.Object])
  284.                 return (object)value;
  285.             if (targetType == ConvertTypes[(int)TypeCode.DBNull])
  286.                 throw new InvalidCastException(Environment.GetResourceString("InvalidCast_DBNull"));
  287.             if (targetType == ConvertTypes[(int)TypeCode.Empty])
  288.                 throw new InvalidCastException(Environment.GetResourceString("InvalidCast_Empty"));
  289.             throw new InvalidCastException(String.Format(CultureInfo.CurrentCulture, Environment.GetResourceString("InvalidCast_FromTo"), value.GetType().FullName, targetType.FullName));
  290.         }
  291.        
  292.         public static object ChangeType(object value, Type conversionType)
  293.         {
  294.             return ChangeType(value, conversionType, Thread.CurrentThread.CurrentCulture);
  295.         }
  296.        
  297.         public static object ChangeType(object value, Type conversionType, IFormatProvider provider)
  298.         {
  299.             if (conversionType == null) {
  300.                 throw new ArgumentNullException("conversionType");
  301.             }
  302.            
  303.             if (value == null) {
  304.                 if (conversionType.IsValueType) {
  305.                     throw new InvalidCastException(Environment.GetResourceString("InvalidCast_CannotCastNullToValueType"));
  306.                 }
  307.                 return null;
  308.             }
  309.            
  310.             IConvertible ic = value as IConvertible;
  311.             if (ic == null) {
  312.                 if (value.GetType() == conversionType) {
  313.                     return value;
  314.                 }
  315.                 throw new InvalidCastException(Environment.GetResourceString("InvalidCast_IConvertible"));
  316.             }
  317.             if (conversionType == ConvertTypes[(int)TypeCode.Boolean])
  318.                 return ic.ToBoolean(provider);
  319.             if (conversionType == ConvertTypes[(int)TypeCode.Char])
  320.                 return ic.ToChar(provider);
  321.             if (conversionType == ConvertTypes[(int)TypeCode.SByte])
  322.                 return ic.ToSByte(provider);
  323.             if (conversionType == ConvertTypes[(int)TypeCode.Byte])
  324.                 return ic.ToByte(provider);
  325.             if (conversionType == ConvertTypes[(int)TypeCode.Int16])
  326.                 return ic.ToInt16(provider);
  327.             if (conversionType == ConvertTypes[(int)TypeCode.UInt16])
  328.                 return ic.ToUInt16(provider);
  329.             if (conversionType == ConvertTypes[(int)TypeCode.Int32])
  330.                 return ic.ToInt32(provider);
  331.             if (conversionType == ConvertTypes[(int)TypeCode.UInt32])
  332.                 return ic.ToUInt32(provider);
  333.             if (conversionType == ConvertTypes[(int)TypeCode.Int64])
  334.                 return ic.ToInt64(provider);
  335.             if (conversionType == ConvertTypes[(int)TypeCode.UInt64])
  336.                 return ic.ToUInt64(provider);
  337.             if (conversionType == ConvertTypes[(int)TypeCode.Single])
  338.                 return ic.ToSingle(provider);
  339.             if (conversionType == ConvertTypes[(int)TypeCode.Double])
  340.                 return ic.ToDouble(provider);
  341.             if (conversionType == ConvertTypes[(int)TypeCode.Decimal])
  342.                 return ic.ToDecimal(provider);
  343.             if (conversionType == ConvertTypes[(int)TypeCode.DateTime])
  344.                 return ic.ToDateTime(provider);
  345.             if (conversionType == ConvertTypes[(int)TypeCode.String]) {
  346.                 return ic.ToString(provider);
  347.             }
  348.             if (conversionType == ConvertTypes[(int)TypeCode.Object])
  349.                 return (object)value;
  350.             return ic.ToType(conversionType, provider);
  351.         }
  352.        
  353.         // Conversions to Boolean
  354.         public static bool ToBoolean(object value)
  355.         {
  356.             return value == null ? false : ((IConvertible)value).ToBoolean(null);
  357.         }
  358.        
  359.         public static bool ToBoolean(object value, IFormatProvider provider)
  360.         {
  361.             return value == null ? false : ((IConvertible)value).ToBoolean(provider);
  362.         }
  363.        
  364.        
  365.         public static bool ToBoolean(bool value)
  366.         {
  367.             return value;
  368.         }
  369.        
  370.         [CLSCompliant(false)]
  371.         public static bool ToBoolean(sbyte value)
  372.         {
  373.             return value != 0;
  374.         }
  375.        
  376.         // To be consistent with IConvertible in the base data types else we get different semantics
  377.         // with widening operations. Without this operator this widen succeeds,with this API the widening throws.
  378.         public static bool ToBoolean(char value)
  379.         {
  380.             return ((IConvertible)value).ToBoolean(null);
  381.         }
  382.        
  383.         public static bool ToBoolean(byte value)
  384.         {
  385.             return value != 0;
  386.         }
  387.        
  388.        
  389.         public static bool ToBoolean(short value)
  390.         {
  391.             return value != 0;
  392.         }
  393.        
  394.         [CLSCompliant(false)]
  395.         public static bool ToBoolean(ushort value)
  396.         {
  397.             return value != 0;
  398.         }
  399.        
  400.         public static bool ToBoolean(int value)
  401.         {
  402.             return value != 0;
  403.         }
  404.        
  405.         [CLSCompliant(false)]
  406.         public static bool ToBoolean(uint value)
  407.         {
  408.             return value != 0;
  409.         }
  410.        
  411.         public static bool ToBoolean(long value)
  412.         {
  413.             return value != 0;
  414.         }
  415.        
  416.         [CLSCompliant(false)]
  417.         public static bool ToBoolean(ulong value)
  418.         {
  419.             return value != 0;
  420.         }
  421.        
  422.         public static bool ToBoolean(string value)
  423.         {
  424.             if (value == null)
  425.                 return false;
  426.             return Boolean.Parse(value);
  427.         }
  428.        
  429.         public static bool ToBoolean(string value, IFormatProvider provider)
  430.         {
  431.             if (value == null)
  432.                 return false;
  433.             return Boolean.Parse(value);
  434.         }
  435.        
  436.         public static bool ToBoolean(float value)
  437.         {
  438.             return value != 0;
  439.         }
  440.        
  441.         public static bool ToBoolean(double value)
  442.         {
  443.             return value != 0;
  444.         }
  445.        
  446.         public static bool ToBoolean(decimal value)
  447.         {
  448.             return value != 0;
  449.         }
  450.        
  451.         public static bool ToBoolean(DateTime value)
  452.         {
  453.             return ((IConvertible)value).ToBoolean(null);
  454.         }
  455.        
  456.         // Disallowed conversions to Boolean
  457.         // public static bool ToBoolean(TimeSpan value)
  458.        
  459.         // Conversions to Char
  460.        
  461.        
  462.         public static char ToChar(object value)
  463.         {
  464.             return value == null ? (char)0 : ((IConvertible)value).ToChar(null);
  465.         }
  466.        
  467.         public static char ToChar(object value, IFormatProvider provider)
  468.         {
  469.             return value == null ? (char)0 : ((IConvertible)value).ToChar(provider);
  470.         }
  471.        
  472.         public static char ToChar(bool value)
  473.         {
  474.             return ((IConvertible)value).ToChar(null);
  475.         }
  476.        
  477.         public static char ToChar(char value)
  478.         {
  479.             return value;
  480.         }
  481.        
  482.         [CLSCompliant(false)]
  483.         public static char ToChar(sbyte value)
  484.         {
  485.             if (value < 0)
  486.                 throw new OverflowException(Environment.GetResourceString("Overflow_Char"));
  487.             return (char)value;
  488.         }
  489.        
  490.         public static char ToChar(byte value)
  491.         {
  492.             return (char)value;
  493.         }
  494.        
  495.         public static char ToChar(short value)
  496.         {
  497.             if (value < 0)
  498.                 throw new OverflowException(Environment.GetResourceString("Overflow_Char"));
  499.             return (char)value;
  500.         }
  501.        
  502.         [CLSCompliant(false)]
  503.         public static char ToChar(ushort value)
  504.         {
  505.             return (char)value;
  506.         }
  507.        
  508.         public static char ToChar(int value)
  509.         {
  510.             if (value < 0 || value > Char.MaxValue)
  511.                 throw new OverflowException(Environment.GetResourceString("Overflow_Char"));
  512.             return (char)value;
  513.         }
  514.        
  515.         [CLSCompliant(false)]
  516.         public static char ToChar(uint value)
  517.         {
  518.             if (value > Char.MaxValue)
  519.                 throw new OverflowException(Environment.GetResourceString("Overflow_Char"));
  520.             return (char)value;
  521.         }
  522.        
  523.         public static char ToChar(long value)
  524.         {
  525.             if (value < 0 || value > Char.MaxValue)
  526.                 throw new OverflowException(Environment.GetResourceString("Overflow_Char"));
  527.             return (char)value;
  528.         }
  529.        
  530.         [CLSCompliant(false)]
  531.         public static char ToChar(ulong value)
  532.         {
  533.             if (value > Char.MaxValue)
  534.                 throw new OverflowException(Environment.GetResourceString("Overflow_Char"));
  535.             return (char)value;
  536.         }
  537.        
  538.         //
  539.         // @VariantSwitch
  540.         // Remove FormatExceptions;
  541.         //
  542.         public static char ToChar(string value)
  543.         {
  544.             return ToChar(value, null);
  545.         }
  546.        
  547.         public static char ToChar(string value, IFormatProvider provider)
  548.         {
  549.             if (value == null)
  550.                 throw new ArgumentNullException("value");
  551.            
  552.             if (value.Length != 1)
  553.                 throw new FormatException(Environment.GetResourceString(ResId.Format_NeedSingleChar));
  554.            
  555.             return value[0];
  556.         }
  557.        
  558.         // To be consistent with IConvertible in the base data types else we get different semantics
  559.         // with widening operations. Without this operator this widen succeeds,with this API the widening throws.
  560.         public static char ToChar(float value)
  561.         {
  562.             return ((IConvertible)value).ToChar(null);
  563.         }
  564.        
  565.         // To be consistent with IConvertible in the base data types else we get different semantics
  566.         // with widening operations. Without this operator this widen succeeds,with this API the widening throws.
  567.         public static char ToChar(double value)
  568.         {
  569.             return ((IConvertible)value).ToChar(null);
  570.         }
  571.        
  572.         // To be consistent with IConvertible in the base data types else we get different semantics
  573.         // with widening operations. Without this operator this widen succeeds,with this API the widening throws.
  574.         public static char ToChar(decimal value)
  575.         {
  576.             return ((IConvertible)value).ToChar(null);
  577.         }
  578.        
  579.         public static char ToChar(DateTime value)
  580.         {
  581.             return ((IConvertible)value).ToChar(null);
  582.         }
  583.        
  584.        
  585.         // Disallowed conversions to Char
  586.         // public static char ToChar(TimeSpan value)
  587.        
  588.         // Conversions to SByte
  589.        
  590.         [CLSCompliant(false)]
  591.         public static sbyte ToSByte(object value)
  592.         {
  593.             return value == null ? (sbyte)0 : ((IConvertible)value).ToSByte(null);
  594.         }
  595.        
  596.         [CLSCompliant(false)]
  597.         public static sbyte ToSByte(object value, IFormatProvider provider)
  598.         {
  599.             return value == null ? (sbyte)0 : ((IConvertible)value).ToSByte(provider);
  600.         }
  601.        
  602.         [CLSCompliant(false)]
  603.         public static sbyte ToSByte(bool value)
  604.         {
  605.             return value ? (sbyte)Boolean.True : (sbyte)Boolean.False;
  606.         }
  607.        
  608.         [CLSCompliant(false)]
  609.         public static sbyte ToSByte(sbyte value)
  610.         {
  611.             return value;
  612.         }
  613.        
  614.         [CLSCompliant(false)]
  615.         public static sbyte ToSByte(char value)
  616.         {
  617.             if (value > SByte.MaxValue)
  618.                 throw new OverflowException(Environment.GetResourceString("Overflow_SByte"));
  619.             return (sbyte)value;
  620.         }
  621.        
  622.         [CLSCompliant(false)]
  623.         public static sbyte ToSByte(byte value)
  624.         {
  625.             if (value > SByte.MaxValue)
  626.                 throw new OverflowException(Environment.GetResourceString("Overflow_SByte"));
  627.             return (sbyte)value;
  628.         }
  629.        
  630.         [CLSCompliant(false)]
  631.         public static sbyte ToSByte(short value)
  632.         {
  633.             if (value < SByte.MinValue || value > SByte.MaxValue)
  634.                 throw new OverflowException(Environment.GetResourceString("Overflow_SByte"));
  635.             return (sbyte)value;
  636.         }
  637.        
  638.         [CLSCompliant(false)]
  639.         public static sbyte ToSByte(ushort value)
  640.         {
  641.             if (value > SByte.MaxValue)
  642.                 throw new OverflowException(Environment.GetResourceString("Overflow_SByte"));
  643.             return (sbyte)value;
  644.         }
  645.        
  646.         [CLSCompliant(false)]
  647.         public static sbyte ToSByte(int value)
  648.         {
  649.             if (value < SByte.MinValue || value > SByte.MaxValue)
  650.                 throw new OverflowException(Environment.GetResourceString("Overflow_SByte"));
  651.             return (sbyte)value;
  652.         }
  653.        
  654.         [CLSCompliant(false)]
  655.         public static sbyte ToSByte(uint value)
  656.         {
  657.             if (value > SByte.MaxValue)
  658.                 throw new OverflowException(Environment.GetResourceString("Overflow_SByte"));
  659.             return (sbyte)value;
  660.         }
  661.        
  662.         [CLSCompliant(false)]
  663.         public static sbyte ToSByte(long value)
  664.         {
  665.             if (value < SByte.MinValue || value > SByte.MaxValue)
  666.                 throw new OverflowException(Environment.GetResourceString("Overflow_SByte"));
  667.             return (sbyte)value;
  668.         }
  669.        
  670.         [CLSCompliant(false)]
  671.         public static sbyte ToSByte(ulong value)
  672.         {
  673.             if (value > (ulong)SByte.MaxValue)
  674.                 throw new OverflowException(Environment.GetResourceString("Overflow_SByte"));
  675.             return (sbyte)value;
  676.         }
  677.        
  678.         [CLSCompliant(false)]
  679.         public static sbyte ToSByte(float value)
  680.         {
  681.             return ToSByte((double)value);
  682.         }
  683.        
  684.         [CLSCompliant(false)]
  685.         public static sbyte ToSByte(double value)
  686.         {
  687.             return ToSByte(ToInt32(value));
  688.         }
  689.        
  690.         [CLSCompliant(false)]
  691.         public static sbyte ToSByte(decimal value)
  692.         {
  693.             return Decimal.ToSByte(Decimal.Round(value, 0));
  694.         }
  695.        
  696.         [CLSCompliant(false)]
  697.         public static sbyte ToSByte(string value)
  698.         {
  699.             if (value == null)
  700.                 return 0;
  701.             return SByte.Parse(value, CultureInfo.CurrentCulture);
  702.         }
  703.        
  704.         [CLSCompliant(false)]
  705.         public static sbyte ToSByte(string value, IFormatProvider provider)
  706.         {
  707.             return SByte.Parse(value, NumberStyles.Integer, provider);
  708.         }
  709.        
  710.         [CLSCompliant(false)]
  711.         public static sbyte ToSByte(DateTime value)
  712.         {
  713.             return ((IConvertible)value).ToSByte(null);
  714.         }
  715.        
  716.         // Disallowed conversions to SByte
  717.         // public static sbyte ToSByte(TimeSpan value)
  718.        
  719.         // Conversions to Byte
  720.        
  721.         public static byte ToByte(object value)
  722.         {
  723.             return value == null ? (byte)0 : ((IConvertible)value).ToByte(null);
  724.         }
  725.        
  726.         public static byte ToByte(object value, IFormatProvider provider)
  727.         {
  728.             return value == null ? (byte)0 : ((IConvertible)value).ToByte(provider);
  729.         }
  730.        
  731.         public static byte ToByte(bool value)
  732.         {
  733.             return value ? (byte)Boolean.True : (byte)Boolean.False;
  734.         }
  735.        
  736.         public static byte ToByte(byte value)
  737.         {
  738.             return value;
  739.         }
  740.        
  741.         public static byte ToByte(char value)
  742.         {
  743.             if (value > Byte.MaxValue)
  744.                 throw new OverflowException(Environment.GetResourceString("Overflow_Byte"));
  745.             return (byte)value;
  746.         }
  747.        
  748.         [CLSCompliant(false)]
  749.         public static byte ToByte(sbyte value)
  750.         {
  751.             if (value < Byte.MinValue)
  752.                 throw new OverflowException(Environment.GetResourceString("Overflow_Byte"));
  753.             return (byte)value;
  754.         }
  755.        
  756.         public static byte ToByte(short value)
  757.         {
  758.             if (value < Byte.MinValue || value > Byte.MaxValue)
  759.                 throw new OverflowException(Environment.GetResourceString("Overflow_Byte"));
  760.             return (byte)value;
  761.         }
  762.        
  763.         [CLSCompliant(false)]
  764.         public static byte ToByte(ushort value)
  765.         {
  766.             if (value > Byte.MaxValue)
  767.                 throw new OverflowException(Environment.GetResourceString("Overflow_Byte"));
  768.             return (byte)value;
  769.         }
  770.        
  771.         public static byte ToByte(int value)
  772.         {
  773.             if (value < Byte.MinValue || value > Byte.MaxValue)
  774.                 throw new OverflowException(Environment.GetResourceString("Overflow_Byte"));
  775.             return (byte)value;
  776.         }
  777.        
  778.         [CLSCompliant(false)]
  779.         public static byte ToByte(uint value)
  780.         {
  781.             if (value > Byte.MaxValue)
  782.                 throw new OverflowException(Environment.GetResourceString("Overflow_Byte"));
  783.             return (byte)value;
  784.         }
  785.        
  786.         public static byte ToByte(long value)
  787.         {
  788.             if (value < Byte.MinValue || value > Byte.MaxValue)
  789.                 throw new OverflowException(Environment.GetResourceString("Overflow_Byte"));
  790.             return (byte)value;
  791.         }
  792.        
  793.         [CLSCompliant(false)]
  794.         public static byte ToByte(ulong value)
  795.         {
  796.             if (value > Byte.MaxValue)
  797.                 throw new OverflowException(Environment.GetResourceString("Overflow_Byte"));
  798.             return (byte)value;
  799.         }
  800.        
  801.         public static byte ToByte(float value)
  802.         {
  803.             return ToByte((double)value);
  804.         }
  805.        
  806.         public static byte ToByte(double value)
  807.         {
  808.             return ToByte(ToInt32(value));
  809.         }
  810.        
  811.         public static byte ToByte(decimal value)
  812.         {
  813.             return Decimal.ToByte(Decimal.Round(value, 0));
  814.         }
  815.        
  816.         public static byte ToByte(string value)
  817.         {
  818.             if (value == null)
  819.                 return 0;
  820.             return Byte.Parse(value, CultureInfo.CurrentCulture);
  821.         }
  822.        
  823.         public static byte ToByte(string value, IFormatProvider provider)
  824.         {
  825.             if (value == null)
  826.                 return 0;
  827.             return Byte.Parse(value, NumberStyles.Integer, provider);
  828.         }
  829.        
  830.         public static byte ToByte(DateTime value)
  831.         {
  832.             return ((IConvertible)value).ToByte(null);
  833.         }
  834.        
  835.        
  836.         // Disallowed conversions to Byte
  837.         // public static byte ToByte(TimeSpan value)
  838.        
  839.         // Conversions to Int16
  840.        
  841.         public static short ToInt16(object value)
  842.         {
  843.             return value == null ? (short)0 : ((IConvertible)value).ToInt16(null);
  844.         }
  845.        
  846.         public static short ToInt16(object value, IFormatProvider provider)
  847.         {
  848.             return value == null ? (short)0 : ((IConvertible)value).ToInt16(provider);
  849.         }
  850.        
  851.         public static short ToInt16(bool value)
  852.         {
  853.             return value ? (short)Boolean.True : (short)Boolean.False;
  854.         }
  855.        
  856.         public static short ToInt16(char value)
  857.         {
  858.             if (value > Int16.MaxValue)
  859.                 throw new OverflowException(Environment.GetResourceString("Overflow_Int16"));
  860.             return (short)value;
  861.         }
  862.        
  863.         [CLSCompliant(false)]
  864.         public static short ToInt16(sbyte value)
  865.         {
  866.             return value;
  867.         }
  868.        
  869.         public static short ToInt16(byte value)
  870.         {
  871.             return value;
  872.         }
  873.        
  874.         [CLSCompliant(false)]
  875.         public static short ToInt16(ushort value)
  876.         {
  877.             if (value > Int16.MaxValue)
  878.                 throw new OverflowException(Environment.GetResourceString("Overflow_Int16"));
  879.             return (short)value;
  880.         }
  881.        
  882.         public static short ToInt16(int value)
  883.         {
  884.             if (value < Int16.MinValue || value > Int16.MaxValue)
  885.                 throw new OverflowException(Environment.GetResourceString("Overflow_Int16"));
  886.             return (short)value;
  887.         }
  888.        
  889.         [CLSCompliant(false)]
  890.         public static short ToInt16(uint value)
  891.         {
  892.             if (value > Int16.MaxValue)
  893.                 throw new OverflowException(Environment.GetResourceString("Overflow_Int16"));
  894.             return (short)value;
  895.         }
  896.        
  897.         public static short ToInt16(short value)
  898.         {
  899.             return value;
  900.         }
  901.        
  902.         public static short ToInt16(long value)
  903.         {
  904.             if (value < Int16.MinValue || value > Int16.MaxValue)
  905.                 throw new OverflowException(Environment.GetResourceString("Overflow_Int16"));
  906.             return (short)value;
  907.         }
  908.        
  909.         [CLSCompliant(false)]
  910.         public static short ToInt16(ulong value)
  911.         {
  912.             if (value > (ulong)Int16.MaxValue)
  913.                 throw new OverflowException(Environment.GetResourceString("Overflow_Int16"));
  914.             return (short)value;
  915.         }
  916.        
  917.         public static short ToInt16(float value)
  918.         {
  919.             return ToInt16((double)value);
  920.         }
  921.        
  922.         public static short ToInt16(double value)
  923.         {
  924.             return ToInt16(ToInt32(value));
  925.         }
  926.        
  927.         public static short ToInt16(decimal value)
  928.         {
  929.             return Decimal.ToInt16(Decimal.Round(value, 0));
  930.         }
  931.        
  932.         public static short ToInt16(string value)
  933.         {
  934.             if (value == null)
  935.                 return 0;
  936.             return Int16.Parse(value, CultureInfo.CurrentCulture);
  937.         }
  938.        
  939.         public static short ToInt16(string value, IFormatProvider provider)
  940.         {
  941.             if (value == null)
  942.                 return 0;
  943.             return Int16.Parse(value, NumberStyles.Integer, provider);
  944.         }
  945.        
  946.         public static short ToInt16(DateTime value)
  947.         {
  948.             return ((IConvertible)value).ToInt16(null);
  949.         }
  950.        
  951.        
  952.         // Disallowed conversions to Int16
  953.         // public static short ToInt16(TimeSpan value)
  954.        
  955.         // Conversions to UInt16
  956.        
  957.         [CLSCompliant(false)]
  958.         public static ushort ToUInt16(object value)
  959.         {
  960.             return value == null ? (ushort)0 : ((IConvertible)value).ToUInt16(null);
  961.         }
  962.        
  963.         [CLSCompliant(false)]
  964.         public static ushort ToUInt16(object value, IFormatProvider provider)
  965.         {
  966.             return value == null ? (ushort)0 : ((IConvertible)value).ToUInt16(provider);
  967.         }
  968.        
  969.        
  970.         [CLSCompliant(false)]
  971.         public static ushort ToUInt16(bool value)
  972.         {
  973.             return value ? (ushort)Boolean.True : (ushort)Boolean.False;
  974.         }
  975.        
  976.         [CLSCompliant(false)]
  977.         public static ushort ToUInt16(char value)
  978.         {
  979.             return value;
  980.         }
  981.        
  982.         [CLSCompliant(false)]
  983.         public static ushort ToUInt16(sbyte value)
  984.         {
  985.             if (value < 0)
  986.                 throw new OverflowException(Environment.GetResourceString("Overflow_UInt16"));
  987.             return (ushort)value;
  988.         }
  989.        
  990.         [CLSCompliant(false)]
  991.         public static ushort ToUInt16(byte value)
  992.         {
  993.             return value;
  994.         }
  995.        
  996.         [CLSCompliant(false)]
  997.         public static ushort ToUInt16(short value)
  998.         {
  999.             if (value < 0)
  1000.                 throw new OverflowException(Environment.GetResourceString("Overflow_UInt16"));
  1001.             return (ushort)value;
  1002.         }
  1003.        
  1004.         [CLSCompliant(false)]
  1005.         public static ushort ToUInt16(int value)
  1006.         {
  1007.             if (value < 0 || value > UInt16.MaxValue)
  1008.                 throw new OverflowException(Environment.GetResourceString("Overflow_UInt16"));
  1009.             return (ushort)value;
  1010.         }
  1011.        
  1012.         [CLSCompliant(false)]
  1013.         public static ushort ToUInt16(ushort value)
  1014.         {
  1015.             return value;
  1016.         }
  1017.        
  1018.         [CLSCompliant(false)]
  1019.         public static ushort ToUInt16(uint value)
  1020.         {
  1021.             if (value > UInt16.MaxValue)
  1022.                 throw new OverflowException(Environment.GetResourceString("Overflow_UInt16"));
  1023.             return (ushort)value;
  1024.         }
  1025.        
  1026.        
  1027.         [CLSCompliant(false)]
  1028.         public static ushort ToUInt16(long value)
  1029.         {
  1030.             if (value < 0 || value > UInt16.MaxValue)
  1031.                 throw new OverflowException(Environment.GetResourceString("Overflow_UInt16"));
  1032.             return (ushort)value;
  1033.         }
  1034.        
  1035.         [CLSCompliant(false)]
  1036.         public static ushort ToUInt16(ulong value)
  1037.         {
  1038.             if (value > UInt16.MaxValue)
  1039.                 throw new OverflowException(Environment.GetResourceString("Overflow_UInt16"));
  1040.             return (ushort)value;
  1041.         }
  1042.        
  1043.         [CLSCompliant(false)]
  1044.         public static ushort ToUInt16(float value)
  1045.         {
  1046.             return ToUInt16((double)value);
  1047.         }
  1048.        
  1049.         [CLSCompliant(false)]
  1050.         public static ushort ToUInt16(double value)
  1051.         {
  1052.             return ToUInt16(ToInt32(value));
  1053.         }
  1054.        
  1055.         [CLSCompliant(false)]
  1056.         public static ushort ToUInt16(decimal value)
  1057.         {
  1058.             return Decimal.ToUInt16(Decimal.Round(value, 0));
  1059.         }
  1060.        
  1061.         [CLSCompliant(false)]
  1062.         public static ushort ToUInt16(string value)
  1063.         {
  1064.             if (value == null)
  1065.                 return 0;
  1066.             return UInt16.Parse(value, CultureInfo.CurrentCulture);
  1067.         }
  1068.        
  1069.         [CLSCompliant(false)]
  1070.         public static ushort ToUInt16(string value, IFormatProvider provider)
  1071.         {
  1072.             if (value == null)
  1073.                 return 0;
  1074.             return UInt16.Parse(value, NumberStyles.Integer, provider);
  1075.         }
  1076.        
  1077.         [CLSCompliant(false)]
  1078.         public static ushort ToUInt16(DateTime value)
  1079.         {
  1080.             return ((IConvertible)value).ToUInt16(null);
  1081.         }
  1082.        
  1083.         // Disallowed conversions to UInt16
  1084.         // public static ushort ToUInt16(TimeSpan value)
  1085.        
  1086.         // Conversions to Int32
  1087.        
  1088.         public static int ToInt32(object value)
  1089.         {
  1090.             return value == null ? 0 : ((IConvertible)value).ToInt32(null);
  1091.         }
  1092.        
  1093.         public static int ToInt32(object value, IFormatProvider provider)
  1094.         {
  1095.             return value == null ? 0 : ((IConvertible)value).ToInt32(provider);
  1096.         }
  1097.        
  1098.        
  1099.         public static int ToInt32(bool value)
  1100.         {
  1101.             return value ? Boolean.True : Boolean.False;
  1102.         }
  1103.        
  1104.         public static int ToInt32(char value)
  1105.         {
  1106.             return value;
  1107.         }
  1108.        
  1109.         [CLSCompliant(false)]
  1110.         public static int ToInt32(sbyte value)
  1111.         {
  1112.             return value;
  1113.         }
  1114.        
  1115.         public static int ToInt32(byte value)
  1116.         {
  1117.             return value;
  1118.         }
  1119.        
  1120.         public static int ToInt32(short value)
  1121.         {
  1122.             return value;
  1123.         }
  1124.        
  1125.         [CLSCompliant(false)]
  1126.         public static int ToInt32(ushort value)
  1127.         {
  1128.             return value;
  1129.         }
  1130.        
  1131.         [CLSCompliant(false)]
  1132.         public static int ToInt32(uint value)
  1133.         {
  1134.             if (value > Int32.MaxValue)
  1135.                 throw new OverflowException(Environment.GetResourceString("Overflow_Int32"));
  1136.             return (int)value;
  1137.         }
  1138.        
  1139.         public static int ToInt32(int value)
  1140.         {
  1141.             return value;
  1142.         }
  1143.        
  1144.         public static int ToInt32(long value)
  1145.         {
  1146.             if (value < Int32.MinValue || value > Int32.MaxValue)
  1147.                 throw new OverflowException(Environment.GetResourceString("Overflow_Int32"));
  1148.             return (int)value;
  1149.         }
  1150.        
  1151.         [CLSCompliant(false)]
  1152.         public static int ToInt32(ulong value)
  1153.         {
  1154.             if (value > Int32.MaxValue)
  1155.                 throw new OverflowException(Environment.GetResourceString("Overflow_Int32"));
  1156.             return (int)value;
  1157.         }
  1158.        
  1159.         public static int ToInt32(float value)
  1160.         {
  1161.             return ToInt32((double)value);
  1162.         }
  1163.        
  1164.         public static int ToInt32(double value)
  1165.         {
  1166.             if (value >= 0) {
  1167.                 if (value < 2147483647.5) {
  1168.                     int result = (int)value;
  1169.                     double dif = value - result;
  1170.                     if (dif > 0.5 || dif == 0.5 && (result & 1) != 0)
  1171.                         result++;
  1172.                     return result;
  1173.                 }
  1174.             }
  1175.             else {
  1176.                 if (value >= -2147483648.5) {
  1177.                     int result = (int)value;
  1178.                     double dif = value - result;
  1179.                     if (dif < -0.5 || dif == -0.5 && (result & 1) != 0)
  1180.                         result--;
  1181.                     return result;
  1182.                 }
  1183.             }
  1184.             throw new OverflowException(Environment.GetResourceString("Overflow_Int32"));
  1185.         }
  1186.        
  1187.         public static int ToInt32(decimal value)
  1188.         {
  1189.             return Decimal.FCallToInt32(value);
  1190.         }
  1191.        
  1192.         public static int ToInt32(string value)
  1193.         {
  1194.             if (value == null)
  1195.                 return 0;
  1196.             return Int32.Parse(value, CultureInfo.CurrentCulture);
  1197.         }
  1198.        
  1199.         public static int ToInt32(string value, IFormatProvider provider)
  1200.         {
  1201.             if (value == null)
  1202.                 return 0;
  1203.             return Int32.Parse(value, NumberStyles.Integer, provider);
  1204.         }
  1205.        
  1206.         public static int ToInt32(DateTime value)
  1207.         {
  1208.             return ((IConvertible)value).ToInt32(null);
  1209.         }
  1210.        
  1211.        
  1212.         // Disallowed conversions to Int32
  1213.         // public static int ToInt32(TimeSpan value)
  1214.        
  1215.         // Conversions to UInt32
  1216.        
  1217.         [CLSCompliant(false)]
  1218.         public static uint ToUInt32(object value)
  1219.         {
  1220.             return value == null ? 0 : ((IConvertible)value).ToUInt32(null);
  1221.         }
  1222.        
  1223.         [CLSCompliant(false)]
  1224.         public static uint ToUInt32(object value, IFormatProvider provider)
  1225.         {
  1226.             return value == null ? 0 : ((IConvertible)value).ToUInt32(provider);
  1227.         }
  1228.        
  1229.        
  1230.         [CLSCompliant(false)]
  1231.         public static uint ToUInt32(bool value)
  1232.         {
  1233.             return value ? (uint)Boolean.True : (uint)Boolean.False;
  1234.         }
  1235.        
  1236.         [CLSCompliant(false)]
  1237.         public static uint ToUInt32(char value)
  1238.         {
  1239.             return value;
  1240.         }
  1241.        
  1242.         [CLSCompliant(false)]
  1243.         public static uint ToUInt32(sbyte value)
  1244.         {
  1245.             if (value < 0)
  1246.                 throw new OverflowException(Environment.GetResourceString("Overflow_UInt32"));
  1247.             return (uint)value;
  1248.         }
  1249.        
  1250.         [CLSCompliant(false)]
  1251.         public static uint ToUInt32(byte value)
  1252.         {
  1253.             return value;
  1254.         }
  1255.        
  1256.         [CLSCompliant(false)]
  1257.         public static uint ToUInt32(short value)
  1258.         {
  1259.             if (value < 0)
  1260.                 throw new OverflowException(Environment.GetResourceString("Overflow_UInt32"));
  1261.             return (uint)value;
  1262.         }
  1263.        
  1264.         [CLSCompliant(false)]
  1265.         public static uint ToUInt32(ushort value)
  1266.         {
  1267.             return value;
  1268.         }
  1269.        
  1270.         [CLSCompliant(false)]
  1271.         public static uint ToUInt32(int value)
  1272.         {
  1273.             if (value < 0)
  1274.                 throw new OverflowException(Environment.GetResourceString("Overflow_UInt32"));
  1275.             return (uint)value;
  1276.         }
  1277.        
  1278.         [CLSCompliant(false)]
  1279.         public static uint ToUInt32(uint value)
  1280.         {
  1281.             return value;
  1282.         }
  1283.        
  1284.         [CLSCompliant(false)]
  1285.         public static uint ToUInt32(long value)
  1286.         {
  1287.             if (value < 0 || value > UInt32.MaxValue)
  1288.                 throw new OverflowException(Environment.GetResourceString("Overflow_UInt32"));
  1289.             return (uint)value;
  1290.         }
  1291.        
  1292.         [CLSCompliant(false)]
  1293.         public static uint ToUInt32(ulong value)
  1294.         {
  1295.             if (value > UInt32.MaxValue)
  1296.                 throw new OverflowException(Environment.GetResourceString("Overflow_UInt32"));
  1297.             return (uint)value;
  1298.         }
  1299.        
  1300.         [CLSCompliant(false)]
  1301.         public static uint ToUInt32(float value)
  1302.         {
  1303.             return ToUInt32((double)value);
  1304.         }
  1305.        
  1306.         [CLSCompliant(false)]
  1307.         public static uint ToUInt32(double value)
  1308.         {
  1309.             if (value >= -0.5 && value < 4294967295.5) {
  1310.                 uint result = (uint)value;
  1311.                 double dif = value - result;
  1312.                 if (dif > 0.5 || dif == 0.5 && (result & 1) != 0)
  1313.                     result++;
  1314.                 return result;
  1315.             }
  1316.             throw new OverflowException(Environment.GetResourceString("Overflow_UInt32"));
  1317.         }
  1318.        
  1319.         [CLSCompliant(false)]
  1320.         public static uint ToUInt32(decimal value)
  1321.         {
  1322.             return Decimal.ToUInt32(Decimal.Round(value, 0));
  1323.         }
  1324.        
  1325.         [CLSCompliant(false)]
  1326.         public static uint ToUInt32(string value)
  1327.         {
  1328.             if (value == null)
  1329.                 return 0;
  1330.             return UInt32.Parse(value, CultureInfo.CurrentCulture);
  1331.         }
  1332.        
  1333.         [CLSCompliant(false)]
  1334.         public static uint ToUInt32(string value, IFormatProvider provider)
  1335.         {
  1336.             if (value == null)
  1337.                 return 0;
  1338.             return UInt32.Parse(value, NumberStyles.Integer, provider);
  1339.         }
  1340.        
  1341.         [CLSCompliant(false)]
  1342.         public static uint ToUInt32(DateTime value)
  1343.         {
  1344.             return ((IConvertible)value).ToUInt32(null);
  1345.         }
  1346.        
  1347.         // Disallowed conversions to UInt32
  1348.         // public static uint ToUInt32(TimeSpan value)
  1349.        
  1350.         // Conversions to Int64
  1351.        
  1352.         public static long ToInt64(object value)
  1353.         {
  1354.             return value == null ? 0 : ((IConvertible)value).ToInt64(null);
  1355.         }
  1356.        
  1357.         public static long ToInt64(object value, IFormatProvider provider)
  1358.         {
  1359.             return value == null ? 0 : ((IConvertible)value).ToInt64(provider);
  1360.         }
  1361.        
  1362.        
  1363.         public static long ToInt64(bool value)
  1364.         {
  1365.             return value ? Boolean.True : Boolean.False;
  1366.         }
  1367.        
  1368.         public static long ToInt64(char value)
  1369.         {
  1370.             return value;
  1371.         }
  1372.        
  1373.         [CLSCompliant(false)]
  1374.         public static long ToInt64(sbyte value)
  1375.         {
  1376.             return value;
  1377.         }
  1378.        
  1379.         public static long ToInt64(byte value)
  1380.         {
  1381.             return value;
  1382.         }
  1383.        
  1384.         public static long ToInt64(short value)
  1385.         {
  1386.             return value;
  1387.         }
  1388.        
  1389.         [CLSCompliant(false)]
  1390.         public static long ToInt64(ushort value)
  1391.         {
  1392.             return value;
  1393.         }
  1394.        
  1395.         public static long ToInt64(int value)
  1396.         {
  1397.             return value;
  1398.         }
  1399.        
  1400.         [CLSCompliant(false)]
  1401.         public static long ToInt64(uint value)
  1402.         {
  1403.             return value;
  1404.         }
  1405.        
  1406.         [CLSCompliant(false)]
  1407.         public static long ToInt64(ulong value)
  1408.         {
  1409.             if (value > Int64.MaxValue)
  1410.                 throw new OverflowException(Environment.GetResourceString("Overflow_Int64"));
  1411.             return (long)value;
  1412.         }
  1413.        
  1414.         public static long ToInt64(long value)
  1415.         {
  1416.             return value;
  1417.         }
  1418.        
  1419.        
  1420.         public static long ToInt64(float value)
  1421.         {
  1422.             return ToInt64((double)value);
  1423.         }
  1424.        
  1425.         public static long ToInt64(double value)
  1426.         {
  1427.             return checked((long)Math.Round(value));
  1428.         }
  1429.        
  1430.         public static long ToInt64(decimal value)
  1431.         {
  1432.             return Decimal.ToInt64(Decimal.Round(value, 0));
  1433.         }
  1434.        
  1435.         public static long ToInt64(string value)
  1436.         {
  1437.             if (value == null)
  1438.                 return 0;
  1439.             return Int64.Parse(value, CultureInfo.CurrentCulture);
  1440.         }
  1441.        
  1442.         public static long ToInt64(string value, IFormatProvider provider)
  1443.         {
  1444.             if (value == null)
  1445.                 return 0;
  1446.             return Int64.Parse(value, NumberStyles.Integer, provider);
  1447.         }
  1448.        
  1449.         public static long ToInt64(DateTime value)
  1450.         {
  1451.             return ((IConvertible)value).ToInt64(null);
  1452.         }
  1453.        
  1454.         // Disallowed conversions to Int64
  1455.         // public static long ToInt64(TimeSpan value)
  1456.        
  1457.         // Conversions to UInt64
  1458.        
  1459.         [CLSCompliant(false)]
  1460.         public static ulong ToUInt64(object value)
  1461.         {
  1462.             return value == null ? 0 : ((IConvertible)value).ToUInt64(null);
  1463.         }
  1464.        
  1465.         [CLSCompliant(false)]
  1466.         public static ulong ToUInt64(object value, IFormatProvider provider)
  1467.         {
  1468.             return value == null ? 0 : ((IConvertible)value).ToUInt64(provider);
  1469.         }
  1470.        
  1471.         [CLSCompliant(false)]
  1472.         public static ulong ToUInt64(bool value)
  1473.         {
  1474.             return value ? (ulong)Boolean.True : (ulong)Boolean.False;
  1475.         }
  1476.        
  1477.         [CLSCompliant(false)]
  1478.         public static ulong ToUInt64(char value)
  1479.         {
  1480.             return value;
  1481.         }
  1482.        
  1483.        
  1484.         [CLSCompliant(false)]
  1485.         public static ulong ToUInt64(sbyte value)
  1486.         {
  1487.             if (value < 0)
  1488.                 throw new OverflowException(Environment.GetResourceString("Overflow_UInt64"));
  1489.             return (ulong)value;
  1490.         }
  1491.        
  1492.         [CLSCompliant(false)]
  1493.         public static ulong ToUInt64(byte value)
  1494.         {
  1495.             return value;
  1496.         }
  1497.        
  1498.         [CLSCompliant(false)]
  1499.         public static ulong ToUInt64(short value)
  1500.         {
  1501.             if (value < 0)
  1502.                 throw new OverflowException(Environment.GetResourceString("Overflow_UInt64"));
  1503.             return (ulong)value;
  1504.         }
  1505.        
  1506.         [CLSCompliant(false)]
  1507.         public static ulong ToUInt64(ushort value)
  1508.         {
  1509.             return value;
  1510.         }
  1511.        
  1512.         [CLSCompliant(false)]
  1513.         public static ulong ToUInt64(int value)
  1514.         {
  1515.             if (value < 0)
  1516.                 throw new OverflowException(Environment.GetResourceString("Overflow_UInt64"));
  1517.             return (ulong)value;
  1518.         }
  1519.        
  1520.         [CLSCompliant(false)]
  1521.         public static ulong ToUInt64(uint value)
  1522.         {
  1523.             return value;
  1524.         }
  1525.        
  1526.         [CLSCompliant(false)]
  1527.         public static ulong ToUInt64(long value)
  1528.         {
  1529.             if (value < 0)
  1530.                 throw new OverflowException(Environment.GetResourceString("Overflow_UInt64"));
  1531.             return (ulong)value;
  1532.         }
  1533.        
  1534.         [CLSCompliant(false)]
  1535.         public static ulong ToUInt64(UInt64 value)
  1536.         {
  1537.             return value;
  1538.         }
  1539.        
  1540.         [CLSCompliant(false)]
  1541.         public static ulong ToUInt64(float value)
  1542.         {
  1543.             return ToUInt64((double)value);
  1544.         }
  1545.        
  1546.         [CLSCompliant(false)]
  1547.         public static ulong ToUInt64(double value)
  1548.         {
  1549.             return checked((ulong)Math.Round(value));
  1550.         }
  1551.        
  1552.         [CLSCompliant(false)]
  1553.         public static ulong ToUInt64(decimal value)
  1554.         {
  1555.             return Decimal.ToUInt64(Decimal.Round(value, 0));
  1556.         }
  1557.        
  1558.         [CLSCompliant(false)]
  1559.         public static ulong ToUInt64(string value)
  1560.         {
  1561.             if (value == null)
  1562.                 return 0;
  1563.             return UInt64.Parse(value, CultureInfo.CurrentCulture);
  1564.         }
  1565.        
  1566.         [CLSCompliant(false)]
  1567.         public static ulong ToUInt64(string value, IFormatProvider provider)
  1568.         {
  1569.             if (value == null)
  1570.                 return 0;
  1571.             return UInt64.Parse(value, NumberStyles.Integer, provider);
  1572.         }
  1573.        
  1574.         [CLSCompliant(false)]
  1575.         public static ulong ToUInt64(DateTime value)
  1576.         {
  1577.             return ((IConvertible)value).ToUInt64(null);
  1578.         }
  1579.        
  1580.         // Disallowed conversions to UInt64
  1581.         // public static ulong ToUInt64(TimeSpan value)
  1582.        
  1583.         // Conversions to Single
  1584.        
  1585.         public static float ToSingle(object value)
  1586.         {
  1587.             return value == null ? 0 : ((IConvertible)value).ToSingle(null);
  1588.         }
  1589.        
  1590.         public static float ToSingle(object value, IFormatProvider provider)
  1591.         {
  1592.             return value == null ? 0 : ((IConvertible)value).ToSingle(provider);
  1593.         }
  1594.        
  1595.         [CLSCompliant(false)]
  1596.         public static float ToSingle(sbyte value)
  1597.         {
  1598.             return value;
  1599.         }
  1600.        
  1601.         public static float ToSingle(byte value)
  1602.         {
  1603.             return value;
  1604.         }
  1605.        
  1606.         public static float ToSingle(char value)
  1607.         {
  1608.             return ((IConvertible)value).ToSingle(null);
  1609.         }
  1610.        
  1611.         public static float ToSingle(short value)
  1612.         {
  1613.             return value;
  1614.         }
  1615.        
  1616.         [CLSCompliant(false)]
  1617.         public static float ToSingle(ushort value)
  1618.         {
  1619.             return value;
  1620.         }
  1621.        
  1622.         public static float ToSingle(int value)
  1623.         {
  1624.             return value;
  1625.         }
  1626.        
  1627.         [CLSCompliant(false)]
  1628.         public static float ToSingle(uint value)
  1629.         {
  1630.             return value;
  1631.         }
  1632.        
  1633.         public static float ToSingle(long value)
  1634.         {
  1635.             return value;
  1636.         }
  1637.        
  1638.         [CLSCompliant(false)]
  1639.         public static float ToSingle(ulong value)
  1640.         {
  1641.             return value;
  1642.         }
  1643.        
  1644.         public static float ToSingle(float value)
  1645.         {
  1646.             return value;
  1647.         }
  1648.        
  1649.         public static float ToSingle(double value)
  1650.         {
  1651.             return (float)value;
  1652.         }
  1653.        
  1654.         public static float ToSingle(decimal value)
  1655.         {
  1656.             return (float)value;
  1657.         }
  1658.        
  1659.         public static float ToSingle(string value)
  1660.         {
  1661.             if (value == null)
  1662.                 return 0;
  1663.             return Single.Parse(value, CultureInfo.CurrentCulture);
  1664.         }
  1665.        
  1666.         public static float ToSingle(string value, IFormatProvider provider)
  1667.         {
  1668.             if (value == null)
  1669.                 return 0;
  1670.             return Single.Parse(value, NumberStyles.Float | NumberStyles.AllowThousands, provider);
  1671.         }
  1672.        
  1673.        
  1674.         public static float ToSingle(bool value)
  1675.         {
  1676.             return value ? Boolean.True : Boolean.False;
  1677.         }
  1678.        
  1679.         public static float ToSingle(DateTime value)
  1680.         {
  1681.             return ((IConvertible)value).ToSingle(null);
  1682.         }
  1683.        
  1684.         // Disallowed conversions to Single
  1685.         // public static float ToSingle(TimeSpan value)
  1686.        
  1687.         // Conversions to Double
  1688.        
  1689.         public static double ToDouble(object value)
  1690.         {
  1691.             return value == null ? 0 : ((IConvertible)value).ToDouble(null);
  1692.         }
  1693.        
  1694.         public static double ToDouble(object value, IFormatProvider provider)
  1695.         {
  1696.             return value == null ? 0 : ((IConvertible)value).ToDouble(provider);
  1697.         }
  1698.        
  1699.        
  1700.         [CLSCompliant(false)]
  1701.         public static double ToDouble(sbyte value)
  1702.         {
  1703.             return value;
  1704.         }
  1705.        
  1706.         public static double ToDouble(byte value)
  1707.         {
  1708.             return value;
  1709.         }
  1710.        
  1711.         public static double ToDouble(short value)
  1712.         {
  1713.             return value;
  1714.         }
  1715.        
  1716.         public static double ToDouble(char value)
  1717.         {
  1718.             return ((IConvertible)value).ToDouble(null);
  1719.         }
  1720.        
  1721.         [CLSCompliant(false)]
  1722.         public static double ToDouble(ushort value)
  1723.         {
  1724.             return value;
  1725.         }
  1726.        
  1727.         public static double ToDouble(int value)
  1728.         {
  1729.             return value;
  1730.         }
  1731.        
  1732.         [CLSCompliant(false)]
  1733.         public static double ToDouble(uint value)
  1734.         {
  1735.             return value;
  1736.         }
  1737.        
  1738.         public static double ToDouble(long value)
  1739.         {
  1740.             return value;
  1741.         }
  1742.        
  1743.         [CLSCompliant(false)]
  1744.         public static double ToDouble(ulong value)
  1745.         {
  1746.             return value;
  1747.         }
  1748.        
  1749.         public static double ToDouble(float value)
  1750.         {
  1751.             return value;
  1752.         }
  1753.        
  1754.         public static double ToDouble(double value)
  1755.         {
  1756.             return value;
  1757.         }
  1758.        
  1759.         public static double ToDouble(decimal value)
  1760.         {
  1761.             return (double)value;
  1762.         }
  1763.        
  1764.         public static double ToDouble(string value)
  1765.         {
  1766.             if (value == null)
  1767.                 return 0;
  1768.             return Double.Parse(value, CultureInfo.CurrentCulture);
  1769.         }
  1770.        
  1771.         public static double ToDouble(string value, IFormatProvider provider)
  1772.         {
  1773.             if (value == null)
  1774.                 return 0;
  1775.             return Double.Parse(value, NumberStyles.Float | NumberStyles.AllowThousands, provider);
  1776.         }
  1777.        
  1778.         public static double ToDouble(bool value)
  1779.         {
  1780.             return value ? Boolean.True : Boolean.False;
  1781.         }
  1782.        
  1783.         public static double ToDouble(DateTime value)
  1784.         {
  1785.             return ((IConvertible)value).ToDouble(null);
  1786.         }
  1787.        
  1788.         // Disallowed conversions to Double
  1789.         // public static double ToDouble(TimeSpan value)
  1790.        
  1791.         // Conversions to Decimal
  1792.        
  1793.         public static decimal ToDecimal(object value)
  1794.         {
  1795.             return value == null ? 0 : ((IConvertible)value).ToDecimal(null);
  1796.         }
  1797.        
  1798.         public static decimal ToDecimal(object value, IFormatProvider provider)
  1799.         {
  1800.             return value == null ? 0 : ((IConvertible)value).ToDecimal(provider);
  1801.         }
  1802.        
  1803.         [CLSCompliant(false)]
  1804.         public static decimal ToDecimal(sbyte value)
  1805.         {
  1806.             return value;
  1807.         }
  1808.        
  1809.         public static decimal ToDecimal(byte value)
  1810.         {
  1811.             return value;
  1812.         }
  1813.        
  1814.         public static decimal ToDecimal(char value)
  1815.         {
  1816.             return ((IConvertible)value).ToDecimal(null);
  1817.         }
  1818.        
  1819.         public static decimal ToDecimal(short value)
  1820.         {
  1821.             return value;
  1822.         }
  1823.        
  1824.         [CLSCompliant(false)]
  1825.         public static decimal ToDecimal(ushort value)
  1826.         {
  1827.             return value;
  1828.         }
  1829.        
  1830.         public static decimal ToDecimal(int value)
  1831.         {
  1832.             return value;
  1833.         }
  1834.        
  1835.         [CLSCompliant(false)]
  1836.         public static decimal ToDecimal(uint value)
  1837.         {
  1838.             return value;
  1839.         }
  1840.        
  1841.         public static decimal ToDecimal(long value)
  1842.         {
  1843.             return value;
  1844.         }
  1845.        
  1846.         [CLSCompliant(false)]
  1847.         public static decimal ToDecimal(ulong value)
  1848.         {
  1849.             return value;
  1850.         }
  1851.        
  1852.         public static decimal ToDecimal(float value)
  1853.         {
  1854.             return (decimal)value;
  1855.         }
  1856.        
  1857.         public static decimal ToDecimal(double value)
  1858.         {
  1859.             return (decimal)value;
  1860.         }
  1861.        
  1862.         public static decimal ToDecimal(string value)
  1863.         {
  1864.             if (value == null)
  1865.                 return 0m;
  1866.             return Decimal.Parse(value, CultureInfo.CurrentCulture);
  1867.         }
  1868.        
  1869.         public static decimal ToDecimal(string value, IFormatProvider provider)
  1870.         {
  1871.             if (value == null)
  1872.                 return 0m;
  1873.             return Decimal.Parse(value, NumberStyles.Number, provider);
  1874.         }
  1875.        
  1876.         public static decimal ToDecimal(decimal value)
  1877.         {
  1878.             return value;
  1879.         }
  1880.        
  1881.         public static decimal ToDecimal(bool value)
  1882.         {
  1883.             return value ? Boolean.True : Boolean.False;
  1884.         }
  1885.        
  1886.         public static decimal ToDecimal(DateTime value)
  1887.         {
  1888.             return ((IConvertible)value).ToDecimal(null);
  1889.         }
  1890.        
  1891.         // Disallowed conversions to Decimal
  1892.         // public static decimal ToDecimal(TimeSpan value)
  1893.        
  1894.         // Conversions to DateTime
  1895.        
  1896.         public static DateTime ToDateTime(DateTime value)
  1897.         {
  1898.             return value;
  1899.         }
  1900.        
  1901.         public static DateTime ToDateTime(object value)
  1902.         {
  1903.             return value == null ? DateTime.MinValue : ((IConvertible)value).ToDateTime(null);
  1904.         }
  1905.        
  1906.         public static DateTime ToDateTime(object value, IFormatProvider provider)
  1907.         {
  1908.             return value == null ? DateTime.MinValue : ((IConvertible)value).ToDateTime(provider);
  1909.         }
  1910.        
  1911.         public static DateTime ToDateTime(string value)
  1912.         {
  1913.             if (value == null)
  1914.                 return new DateTime(0);
  1915.             return DateTime.Parse(value, CultureInfo.CurrentCulture);
  1916.         }
  1917.        
  1918.         public static DateTime ToDateTime(string value, IFormatProvider provider)
  1919.         {
  1920.             if (value == null)
  1921.                 return new DateTime(0);
  1922.             return DateTime.Parse(value, provider);
  1923.         }
  1924.        
  1925.         [CLSCompliant(false)]
  1926.         public static DateTime ToDateTime(sbyte value)
  1927.         {
  1928.             return ((IConvertible)value).ToDateTime(null);
  1929.         }
  1930.        
  1931.         public static DateTime ToDateTime(byte value)
  1932.         {
  1933.             return ((IConvertible)value).ToDateTime(null);
  1934.         }
  1935.        
  1936.         public static DateTime ToDateTime(short value)
  1937.         {
  1938.             return ((IConvertible)value).ToDateTime(null);
  1939.         }
  1940.        
  1941.         [CLSCompliant(false)]
  1942.         public static DateTime ToDateTime(ushort value)
  1943.         {
  1944.             return ((IConvertible)value).ToDateTime(null);
  1945.         }
  1946.        
  1947.         public static DateTime ToDateTime(int value)
  1948.         {
  1949.             return ((IConvertible)value).ToDateTime(null);
  1950.         }
  1951.        
  1952.         [CLSCompliant(false)]
  1953.         public static DateTime ToDateTime(uint value)
  1954.         {
  1955.             return ((IConvertible)value).ToDateTime(null);
  1956.         }
  1957.        
  1958.         public static DateTime ToDateTime(long value)
  1959.         {
  1960.             return ((IConvertible)value).ToDateTime(null);
  1961.         }
  1962.        
  1963.         [CLSCompliant(false)]
  1964.         public static DateTime ToDateTime(ulong value)
  1965.         {
  1966.             return ((IConvertible)value).ToDateTime(null);
  1967.         }
  1968.        
  1969.         public static DateTime ToDateTime(bool value)
  1970.         {
  1971.             return ((IConvertible)value).ToDateTime(null);
  1972.         }
  1973.        
  1974.         public static DateTime ToDateTime(char value)
  1975.         {
  1976.             return ((IConvertible)value).ToDateTime(null);
  1977.         }
  1978.        
  1979.         public static DateTime ToDateTime(float value)
  1980.         {
  1981.             return ((IConvertible)value).ToDateTime(null);
  1982.         }
  1983.        
  1984.         public static DateTime ToDateTime(double value)
  1985.         {
  1986.             return ((IConvertible)value).ToDateTime(null);
  1987.         }
  1988.        
  1989.         public static DateTime ToDateTime(decimal value)
  1990.         {
  1991.             return ((IConvertible)value).ToDateTime(null);
  1992.         }
  1993.        
  1994.         // Disallowed conversions to DateTime
  1995.         // public static DateTime ToDateTime(TimeSpan value)
  1996.        
  1997.         // Conversions to String
  1998.        
  1999.         public static string ToString(object value)
  2000.         {
  2001.             return ToString(value, null);
  2002.         }
  2003.        
  2004.         public static string ToString(object value, IFormatProvider provider)
  2005.         {
  2006.             IConvertible ic = value as IConvertible;
  2007.             if (ic != null)
  2008.                 return ic.ToString(provider);
  2009.             IFormattable formattable = value as IFormattable;
  2010.             if (formattable != null)
  2011.                 return formattable.ToString(null, provider);
  2012.             return value == null ? String.Empty : value.ToString();
  2013.         }
  2014.        
  2015.         public static string ToString(bool value)
  2016.         {
  2017.             return value.ToString();
  2018.         }
  2019.        
  2020.         public static string ToString(bool value, IFormatProvider provider)
  2021.         {
  2022.             return value.ToString(provider);
  2023.         }
  2024.        
  2025.         public static string ToString(char value)
  2026.         {
  2027.             return Char.ToString(value);
  2028.         }
  2029.        
  2030.         public static string ToString(char value, IFormatProvider provider)
  2031.         {
  2032.             return value.ToString(provider);
  2033.         }
  2034.        
  2035.         [CLSCompliant(false)]
  2036.         public static string ToString(sbyte value)
  2037.         {
  2038.             return value.ToString(CultureInfo.CurrentCulture);
  2039.         }
  2040.        
  2041.         [CLSCompliant(false)]
  2042.         public static string ToString(sbyte value, IFormatProvider provider)
  2043.         {
  2044.             return value.ToString(provider);
  2045.         }
  2046.        
  2047.         public static string ToString(byte value)
  2048.         {
  2049.             return value.ToString(CultureInfo.CurrentCulture);
  2050.         }
  2051.        
  2052.         public static string ToString(byte value, IFormatProvider provider)
  2053.         {
  2054.             return value.ToString(provider);
  2055.         }
  2056.        
  2057.         public static string ToString(short value)
  2058.         {
  2059.             return value.ToString(CultureInfo.CurrentCulture);
  2060.         }
  2061.        
  2062.         public static string ToString(short value, IFormatProvider provider)
  2063.         {
  2064.             return value.ToString(provider);
  2065.         }
  2066.        
  2067.         [CLSCompliant(false)]
  2068.         public static string ToString(ushort value)
  2069.         {
  2070.             return value.ToString(CultureInfo.CurrentCulture);
  2071.         }
  2072.        
  2073.         [CLSCompliant(false)]
  2074.         public static string ToString(ushort value, IFormatProvider provider)
  2075.         {
  2076.             return value.ToString(provider);
  2077.         }
  2078.        
  2079.         public static string ToString(int value)
  2080.         {
  2081.             return value.ToString(CultureInfo.CurrentCulture);
  2082.         }
  2083.        
  2084.         public static string ToString(int value, IFormatProvider provider)
  2085.         {
  2086.             return value.ToString(provider);
  2087.         }
  2088.        
  2089.         [CLSCompliant(false)]
  2090.         public static string ToString(uint value)
  2091.         {
  2092.             return value.ToString(CultureInfo.CurrentCulture);
  2093.         }
  2094.        
  2095.         [CLSCompliant(false)]
  2096.         public static string ToString(uint value, IFormatProvider provider)
  2097.         {
  2098.             return value.ToString(provider);
  2099.         }
  2100.        
  2101.         public static string ToString(long value)
  2102.         {
  2103.             return value.ToString(CultureInfo.CurrentCulture);
  2104.         }
  2105.        
  2106.         public static string ToString(long value, IFormatProvider provider)
  2107.         {
  2108.             return value.ToString(provider);
  2109.         }
  2110.        
  2111.         [CLSCompliant(false)]
  2112.         public static string ToString(ulong value)
  2113.         {
  2114.             return value.ToString(CultureInfo.CurrentCulture);
  2115.         }
  2116.        
  2117.         [CLSCompliant(false)]
  2118.         public static string ToString(ulong value, IFormatProvider provider)
  2119.         {
  2120.             return value.ToString(provider);
  2121.         }
  2122.        
  2123.         public static string ToString(float value)
  2124.         {
  2125.             return value.ToString(CultureInfo.CurrentCulture);
  2126.         }
  2127.        
  2128.         public static string ToString(float value, IFormatProvider provider)
  2129.         {
  2130.             return value.ToString(provider);
  2131.         }
  2132.        
  2133.         public static string ToString(double value)
  2134.         {
  2135.             return value.ToString(CultureInfo.CurrentCulture);
  2136.         }
  2137.        
  2138.         public static string ToString(double value, IFormatProvider provider)
  2139.         {
  2140.             return value.ToString(provider);
  2141.         }
  2142.        
  2143.         public static string ToString(decimal value)
  2144.         {
  2145.             return value.ToString(CultureInfo.CurrentCulture);
  2146.         }
  2147.        
  2148.         public static string ToString(decimal value, IFormatProvider provider)
  2149.         {
  2150.             return value.ToString(provider);
  2151.         }
  2152.        
  2153.         public static string ToString(DateTime value)
  2154.         {
  2155.             return value.ToString();
  2156.         }
  2157.        
  2158.         public static string ToString(DateTime value, IFormatProvider provider)
  2159.         {
  2160.             return value.ToString(provider);
  2161.         }
  2162.        
  2163.         public static string ToString(string value)
  2164.         {
  2165.             return value;
  2166.         }
  2167.        
  2168.         public static string ToString(string value, IFormatProvider provider)
  2169.         {
  2170.             return value;
  2171.             // avoid the null check
  2172.         }
  2173.        
  2174.        
  2175.         //
  2176.         // Conversions which understand Base XXX numbers.
  2177.         //
  2178.         // Parses value in base base. base can only
  2179.         // be 2, 8, 10, or 16. If base is 16, the number may be preceded
  2180.         // by 0x; any other leading or trailing characters cause an error.
  2181.         //
  2182.         public static byte ToByte(string value, int fromBase)
  2183.         {
  2184.             if (fromBase != 2 && fromBase != 8 && fromBase != 10 && fromBase != 16) {
  2185.                 throw new ArgumentException(Environment.GetResourceString("Arg_InvalidBase"));
  2186.             }
  2187.             int r = ParseNumbers.StringToInt(value, fromBase, ParseNumbers.IsTight | ParseNumbers.TreatAsUnsigned);
  2188.             if (r < Byte.MinValue || r > Byte.MaxValue)
  2189.                 throw new OverflowException(Environment.GetResourceString("Overflow_Byte"));
  2190.             return (byte)r;
  2191.         }
  2192.        
  2193.         // Parses value in base fromBase. fromBase can only
  2194.         // be 2, 8, 10, or 16. If fromBase is 16, the number may be preceded
  2195.         // by 0x; any other leading or trailing characters cause an error.
  2196.         //
  2197.         [CLSCompliant(false)]
  2198.         public static sbyte ToSByte(string value, int fromBase)
  2199.         {
  2200.             if (fromBase != 2 && fromBase != 8 && fromBase != 10 && fromBase != 16) {
  2201.                 throw new ArgumentException(Environment.GetResourceString("Arg_InvalidBase"));
  2202.             }
  2203.             int r = ParseNumbers.StringToInt(value, fromBase, ParseNumbers.IsTight | ParseNumbers.TreatAsI1);
  2204.             if (fromBase != 10 && r <= Byte.MaxValue)
  2205.                 return (sbyte)r;
  2206.            
  2207.             if (r < SByte.MinValue || r > SByte.MaxValue)
  2208.                 throw new OverflowException(Environment.GetResourceString("Overflow_SByte"));
  2209.             return (sbyte)r;
  2210.         }
  2211.        
  2212.         // Parses value in base fromBase. fromBase can only
  2213.         // be 2, 8, 10, or 16. If fromBase is 16, the number may be preceded
  2214.         // by 0x; any other leading or trailing characters cause an error.
  2215.         //
  2216.         public static short ToInt16(string value, int fromBase)
  2217.         {
  2218.             if (fromBase != 2 && fromBase != 8 && fromBase != 10 && fromBase != 16) {
  2219.                 throw new ArgumentException(Environment.GetResourceString("Arg_InvalidBase"));
  2220.             }
  2221.             int r = ParseNumbers.StringToInt(value, fromBase, ParseNumbers.IsTight | ParseNumbers.TreatAsI2);
  2222.             if (fromBase != 10 && r <= UInt16.MaxValue)
  2223.                 return (short)r;
  2224.            
  2225.             if (r < Int16.MinValue || r > Int16.MaxValue)
  2226.                 throw new OverflowException(Environment.GetResourceString("Overflow_Int16"));
  2227.             return (short)r;
  2228.         }
  2229.        
  2230.         // Parses value in base fromBase. fromBase can only
  2231.         // be 2, 8, 10, or 16. If fromBase is 16, the number may be preceded
  2232.         // by 0x; any other leading or trailing characters cause an error.
  2233.         //
  2234.         [CLSCompliant(false)]
  2235.         public static ushort ToUInt16(string value, int fromBase)
  2236.         {
  2237.             if (fromBase != 2 && fromBase != 8 && fromBase != 10 && fromBase != 16) {
  2238.                 throw new ArgumentException(Environment.GetResourceString("Arg_InvalidBase"));
  2239.             }
  2240.             int r = ParseNumbers.StringToInt(value, fromBase, ParseNumbers.IsTight | ParseNumbers.TreatAsUnsigned);
  2241.             if (r < UInt16.MinValue || r > UInt16.MaxValue)
  2242.                 throw new OverflowException(Environment.GetResourceString("Overflow_UInt16"));
  2243.             return (ushort)r;
  2244.         }
  2245.        
  2246.         // Parses value in base fromBase. fromBase can only
  2247.         // be 2, 8, 10, or 16. If fromBase is 16, the number may be preceded
  2248.         // by 0x; any other leading or trailing characters cause an error.
  2249.         //
  2250.         public static int ToInt32(string value, int fromBase)
  2251.         {
  2252.             if (fromBase != 2 && fromBase != 8 && fromBase != 10 && fromBase != 16) {
  2253.                 throw new ArgumentException(Environment.GetResourceString("Arg_InvalidBase"));
  2254.             }
  2255.             return ParseNumbers.StringToInt(value, fromBase, ParseNumbers.IsTight);
  2256.         }
  2257.        
  2258.         // Parses value in base fromBase. fromBase can only
  2259.         // be 2, 8, 10, or 16. If fromBase is 16, the number may be preceded
  2260.         // by 0x; any other leading or trailing characters cause an error.
  2261.         //
  2262.         [CLSCompliant(false)]
  2263.         public static uint ToUInt32(string value, int fromBase)
  2264.         {
  2265.             if (fromBase != 2 && fromBase != 8 && fromBase != 10 && fromBase != 16) {
  2266.                 throw new ArgumentException(Environment.GetResourceString("Arg_InvalidBase"));
  2267.             }
  2268.             return (uint)ParseNumbers.StringToInt(value, fromBase, ParseNumbers.TreatAsUnsigned | ParseNumbers.IsTight);
  2269.         }
  2270.        
  2271.         // Parses value in base fromBase. fromBase can only
  2272.         // be 2, 8, 10, or 16. If fromBase is 16, the number may be preceded
  2273.         // by 0x; any other leading or trailing characters cause an error.
  2274.         //
  2275.         public static long ToInt64(string value, int fromBase)
  2276.         {
  2277.             if (fromBase != 2 && fromBase != 8 && fromBase != 10 && fromBase != 16) {
  2278.                 throw new ArgumentException(Environment.GetResourceString("Arg_InvalidBase"));
  2279.             }
  2280.             return ParseNumbers.StringToLong(value, fromBase, ParseNumbers.IsTight);
  2281.         }
  2282.        
  2283.         // Parses value in base fromBase. fromBase can only
  2284.         // be 2, 8, 10, or 16. If fromBase is 16, the number may be preceded
  2285.         // by 0x; any other leading or trailing characters cause an error.
  2286.         //
  2287.         [CLSCompliant(false)]
  2288.         public static ulong ToUInt64(string value, int fromBase)
  2289.         {
  2290.             if (fromBase != 2 && fromBase != 8 && fromBase != 10 && fromBase != 16) {
  2291.                 throw new ArgumentException(Environment.GetResourceString("Arg_InvalidBase"));
  2292.             }
  2293.             return (ulong)ParseNumbers.StringToLong(value, fromBase, ParseNumbers.TreatAsUnsigned | ParseNumbers.IsTight);
  2294.         }
  2295.        
  2296.         // Convert the byte value to a string in base fromBase
  2297.         public static string ToString(byte value, int toBase)
  2298.         {
  2299.             if (toBase != 2 && toBase != 8 && toBase != 10 && toBase != 16) {
  2300.                 throw new ArgumentException(Environment.GetResourceString("Arg_InvalidBase"));
  2301.             }
  2302.             return ParseNumbers.IntToString((int)value, toBase, -1, ' ', ParseNumbers.PrintAsI1);
  2303.         }
  2304.        
  2305.         // Convert the Int16 value to a string in base fromBase
  2306.         public static string ToString(short value, int toBase)
  2307.         {
  2308.             if (toBase != 2 && toBase != 8 && toBase != 10 && toBase != 16) {
  2309.                 throw new ArgumentException(Environment.GetResourceString("Arg_InvalidBase"));
  2310.             }
  2311.             return ParseNumbers.IntToString((int)value, toBase, -1, ' ', ParseNumbers.PrintAsI2);
  2312.         }
  2313.        
  2314.         // Convert the Int32 value to a string in base toBase
  2315.         public static string ToString(int value, int toBase)
  2316.         {
  2317.             if (toBase != 2 && toBase != 8 && toBase != 10 && toBase != 16) {
  2318.                 throw new ArgumentException(Environment.GetResourceString("Arg_InvalidBase"));
  2319.             }
  2320.             return ParseNumbers.IntToString(value, toBase, -1, ' ', 0);
  2321.         }
  2322.        
  2323.         // Convert the Int64 value to a string in base toBase
  2324.         public static string ToString(long value, int toBase)
  2325.         {
  2326.             if (toBase != 2 && toBase != 8 && toBase != 10 && toBase != 16) {
  2327.                 throw new ArgumentException(Environment.GetResourceString("Arg_InvalidBase"));
  2328.             }
  2329.             return ParseNumbers.LongToString(value, toBase, -1, ' ', 0);
  2330.         }
  2331.        
  2332.         public static string ToBase64String(byte[] inArray)
  2333.         {
  2334.             if (inArray == null) {
  2335.                 throw new ArgumentNullException("inArray");
  2336.             }
  2337.             return ToBase64String(inArray, 0, inArray.Length, Base64FormattingOptions.None);
  2338.         }
  2339.        
  2340.         [System.Runtime.InteropServices.ComVisible(false)]
  2341.         public static string ToBase64String(byte[] inArray, Base64FormattingOptions options)
  2342.         {
  2343.             if (inArray == null) {
  2344.                 throw new ArgumentNullException("inArray");
  2345.             }
  2346.             return ToBase64String(inArray, 0, inArray.Length, options);
  2347.         }
  2348.        
  2349.         public static string ToBase64String(byte[] inArray, int offset, int length)
  2350.         {
  2351.             return ToBase64String(inArray, offset, length, Base64FormattingOptions.None);
  2352.         }
  2353.        
  2354.         [System.Runtime.InteropServices.ComVisible(false)]
  2355.         unsafe public static string ToBase64String(byte[] inArray, int offset, int length, Base64FormattingOptions options)
  2356.         {
  2357.             int inArrayLength;
  2358.             int stringLength;
  2359.            
  2360.             //Do data verfication
  2361.             if (inArray == null)
  2362.                 throw new ArgumentNullException("inArray");
  2363.             if (length < 0)
  2364.                 throw new ArgumentOutOfRangeException("length", Environment.GetResourceString("ArgumentOutOfRange_Index"));
  2365.             if (offset < 0)
  2366.                 throw new ArgumentOutOfRangeException("offset", Environment.GetResourceString("ArgumentOutOfRange_GenericPositive"));
  2367.             inArrayLength = inArray.Length;
  2368.             if (offset > (inArrayLength - length))
  2369.                 throw new ArgumentOutOfRangeException("offset", Environment.GetResourceString("ArgumentOutOfRange_OffsetLength"));
  2370.            
  2371.             if (options < Base64FormattingOptions.None || options > Base64FormattingOptions.InsertLineBreaks) {
  2372.                 throw new ArgumentException(Environment.GetResourceString("Arg_EnumIllegalVal", (int)options));
  2373.             }
  2374.            
  2375.             if (inArrayLength == 0)
  2376.                 return String.Empty;
  2377.            
  2378.             bool insertLineBreaks = (options == Base64FormattingOptions.InsertLineBreaks);
  2379.             //Create the new string. This is the maximally required length.
  2380.             stringLength = CalculateOutputLength(length, insertLineBreaks);
  2381.            
  2382.             string returnString = String.GetStringForStringBuilder(String.Empty, stringLength);
  2383.             fixed (char* outChars = returnString) {
  2384.                 fixed (byte* inData = inArray) {
  2385.                     int j = ConvertToBase64Array(outChars, inData, offset, length, insertLineBreaks);
  2386.                     returnString.SetLength(j);
  2387.                     return returnString;
  2388.                 }
  2389.             }
  2390.         }
  2391.        
  2392.         public static int ToBase64CharArray(byte[] inArray, int offsetIn, int length, char[] outArray, int offsetOut)
  2393.         {
  2394.             return ToBase64CharArray(inArray, offsetIn, length, outArray, offsetOut, Base64FormattingOptions.None);
  2395.         }
  2396.        
  2397.         [System.Runtime.InteropServices.ComVisible(false)]
  2398.         unsafe public static int ToBase64CharArray(byte[] inArray, int offsetIn, int length, char[] outArray, int offsetOut, Base64FormattingOptions options)
  2399.         {
  2400.            
  2401.             int retVal;
  2402.            
  2403.             int inArrayLength;
  2404.             int outArrayLength;
  2405.             int numElementsToCopy;
  2406.            
  2407.             //Do data verfication
  2408.             if (inArray == null)
  2409.                 throw new ArgumentNullException("inArray");
  2410.             if (outArray == null)
  2411.                 throw new ArgumentNullException("outArray");
  2412.             if (length < 0)
  2413.                 throw new ArgumentOutOfRangeException("length", Environment.GetResourceString("ArgumentOutOfRange_Index"));
  2414.             if (offsetIn < 0)
  2415.                 throw new ArgumentOutOfRangeException("offsetIn", Environment.GetResourceString("ArgumentOutOfRange_GenericPositive"));
  2416.             if (offsetOut < 0)
  2417.                 throw new ArgumentOutOfRangeException("offsetOut", Environment.GetResourceString("ArgumentOutOfRange_GenericPositive"));
  2418.            
  2419.             if (options < Base64FormattingOptions.None || options > Base64FormattingOptions.InsertLineBreaks) {
  2420.                 throw new ArgumentException(Environment.GetResourceString("Arg_EnumIllegalVal", (int)options));
  2421.             }
  2422.            
  2423.             inArrayLength = inArray.Length;
  2424.            
  2425.             if (offsetIn > (int)(inArrayLength - length))
  2426.                 throw new ArgumentOutOfRangeException("offsetIn", Environment.GetResourceString("ArgumentOutOfRange_OffsetLength"));
  2427.            
  2428.             if (inArrayLength == 0)
  2429.                 return 0;
  2430.            
  2431.             bool insertLineBreaks = (options == Base64FormattingOptions.InsertLineBreaks);
  2432.             //This is the maximally required length that must be available in the char array
  2433.             outArrayLength = outArray.Length;
  2434.            
  2435.             // Length of the char buffer required
  2436.             numElementsToCopy = CalculateOutputLength(length, insertLineBreaks);
  2437.            
  2438.             if (offsetOut > (int)(outArrayLength - numElementsToCopy))
  2439.                 throw new ArgumentOutOfRangeException("offsetOut", Environment.GetResourceString("ArgumentOutOfRange_OffsetOut"));
  2440.            
  2441.             fixed (char* outChars = &outArray[offsetOut]) {
  2442.                 fixed (byte* inData = inArray) {
  2443.                     retVal = ConvertToBase64Array(outChars, inData, offsetIn, length, insertLineBreaks);
  2444.                 }
  2445.             }
  2446.            
  2447.             return retVal;
  2448.         }
  2449.        
  2450.         unsafe private static int ConvertToBase64Array(char* outChars, byte* inData, int offset, int length, bool insertLineBreaks)
  2451.         {
  2452.             int lengthmod3 = length % 3;
  2453.             int calcLength = offset + (length - lengthmod3);
  2454.             int j = 0;
  2455.             int charcount = 0;
  2456.             //Convert three bytes at a time to base64 notation. This will consume 4 chars.
  2457.             int i;
  2458.            
  2459.             // get a pointer to the base64Table to avoid unnecessary range checking
  2460.             fixed (char* base64 = base64Table) {
  2461.                 for (i = offset; i < calcLength; i += 3) {
  2462.                     if (insertLineBreaks) {
  2463.                         if (charcount == 76) {
  2464.                             outChars[j++] = '\r';
  2465.                             outChars[j++] = '\n';
  2466.                             charcount = 0;
  2467.                         }
  2468.                         charcount += 4;
  2469.                     }
  2470.                     outChars[j] = base64[(inData[i] & 252) >> 2];
  2471.                     outChars[j + 1] = base64[((inData[i] & 3) << 4) | ((inData[i + 1] & 240) >> 4)];
  2472.                     outChars[j + 2] = base64[((inData[i + 1] & 15) << 2) | ((inData[i + 2] & 192) >> 6)];
  2473.                     outChars[j + 3] = base64[(inData[i + 2] & 63)];
  2474.                     j += 4;
  2475.                 }
  2476.                
  2477.                 //Where we left off before
  2478.                 i = calcLength;
  2479.                
  2480.                 if (insertLineBreaks && (lengthmod3 != 0) && (charcount == 76)) {
  2481.                     outChars[j++] = '\r';
  2482.                     outChars[j++] = '\n';
  2483.                 }
  2484.                
  2485.                 switch (lengthmod3) {
  2486.                     case 2:
  2487.                         //One character padding needed
  2488.                         outChars[j] = base64[(inData[i] & 252) >> 2];
  2489.                         outChars[j + 1] = base64[((inData[i] & 3) << 4) | ((inData[i + 1] & 240) >> 4)];
  2490.                         outChars[j + 2] = base64[(inData[i + 1] & 15) << 2];
  2491.                         outChars[j + 3] = base64[64];
  2492.                         //Pad
  2493.                         j += 4;
  2494.                         break;
  2495.                     case 1:
  2496.                         // Two character padding needed
  2497.                         outChars[j] = base64[(inData[i] & 252) >> 2];
  2498.                         outChars[j + 1] = base64[(inData[i] & 3) << 4];
  2499.                         outChars[j + 2] = base64[64];
  2500.                         //Pad
  2501.                         outChars[j + 3] = base64[64];
  2502.                         //Pad
  2503.                         j += 4;
  2504.                         break;
  2505.                 }
  2506.             }
  2507.            
  2508.             return j;
  2509.         }
  2510.        
  2511.         private static int CalculateOutputLength(int inputLength, bool insertLineBreaks)
  2512.         {
  2513.             int outlen = (int)(inputLength / 3 * 4);
  2514.             // the base length - we want integer division here.
  2515.             outlen += ((inputLength % 3) != 0) ? 4 : 0;
  2516.             // at most 4 more chars for the remainder
  2517.             if (outlen == 0)
  2518.                 return outlen;
  2519.            
  2520.             if (insertLineBreaks) {
  2521.                 int newLines = outlen / 76;
  2522.                 if ((outlen % 76) == 0) {
  2523.                     --newLines;
  2524.                 }
  2525.                 outlen += newLines * 2;
  2526.                 // the number of line break chars we'll add, "\r\n"
  2527.             }
  2528.             return outlen;
  2529.         }
  2530.        
  2531.         [MethodImplAttribute(MethodImplOptions.InternalCall)]
  2532.         public static extern byte[] FromBase64String(string s);
  2533.        
  2534.         [MethodImplAttribute(MethodImplOptions.InternalCall)]
  2535.         public static extern byte[] FromBase64CharArray(char[] inArray, int offset, int length);
  2536.        
  2537.     }
  2538.    
  2539.     [Flags()]
  2540.     public enum Base64FormattingOptions
  2541.     {
  2542.         None = 0,
  2543.         InsertLineBreaks = 1
  2544.     }
  2545. }

Developer Fusion