mcs/class/corlib/System/Convert.cs

   1 //\r
   2 // System.Convert.cs\r
   3 //\r
   4 // Author:\r
   5 //   Derek Holden (dholden@draper.com)\r
   6 //   Duncan Mak (duncan@ximian.com)\r
   7 //\r
   8 // (C) Ximian, Inc.  http://www.ximian.com\r
   9 //\r
  10 //\r
  11 // System.Convert class. This was written word for word off the \r
  12 // Library specification for System.Convert in the ECMA TC39 TG2 \r
  13 // and TG3 working documents. The first page of which has a table\r
  14 // for all legal conversion scenerios.\r
  15 //\r
  16 // This header and the one above it can be formatted however, just trying\r
  17 // to keep it consistent w/ the existing mcs headers.\r
  18 //\r
  19 // This Convert class could be written another way, with each type \r
  20 // implementing IConvertible and defining their own conversion functions,\r
  21 // and this class just calling the type's implementation. Or, they can \r
  22 // be defined here and the implementing type can use these functions when \r
  23 // defining their IConvertible interface. Byte's ToBoolean() calls \r
  24 // Convert.ToBoolean(byte), or Convert.ToBoolean(byte) calls \r
  25 // byte.ToBoolean(). The first case is what is done here.\r
  26 //\r
  27 // See http://lists.ximian.com/archives/public/mono-list/2001-July/000525.html\r
  28 //\r
  29 // There are also conversion functions that are not defined in\r
  30 // the ECMA draft, such as there is no bool ToBoolean(DateTime value), \r
  31 // and placing that somewhere won't compile w/ this Convert since the\r
  32 // function doesn't exist. However calling that when using Microsoft's\r
  33 // System.Convert doesn't produce any compiler errors, it just throws\r
  34 // an InvalidCastException at runtime.\r
  35 //\r
  36 // Whenever a decimal, double, or single is converted to an integer\r
  37 // based type, it is even rounded. This uses Math.Round which only \r
  38 // has Round(decimal) and Round(double), so in the Convert from \r
  39 // single cases the value is passed to Math as a double. This \r
  40 // may not be completely necessary.\r
  41 //\r
  42 // The .NET Framework SDK lists DBNull as a member of this class\r
  43 // as 'public static readonly object DBNull;'. \r
  44 //\r
  45 // It should also be decided if all the cast return values should be\r
  46 // returned as unchecked or not.\r
  47 //\r
  48 // All the XML function comments were auto generated which is why they\r
  49 // sound someone redundant.\r
  50 //\r
  51 // TYPE | BOOL BYTE CHAR DT DEC DBL I16 I32 I64 SBYT SNGL STR UI16 UI32 UI64\r
  52 // -----+--------------------------------------------------------------------\r
  53 // BOOL |   X    X           X   X   X   X   X    X    X   X    X    X    X\r
  54 // BYTE |   X    X    X      X   X   X   X   X    X    X   X    X    X    X\r
  55 // CHAR |        X    X              X   X   X    X        X    X    X    X\r
  56 // DT   |                 X                                X\r
  57 // DEC  |   X    X           X   X   X   X   X    X    X   X    X    X    X\r
  58 // DBL  |   X    X           X   X   X   X   X    X    X   X    X    X    X\r
  59 // I16  |   X    X    X      X   X   X   X   X    X    X   X    X    X    X\r
  60 // I32  |   X    X    X      X   X   X   X   X    X    X   X    X    X    X\r
  61 // I64  |   X    X    X      X   X   X   X   X    X    X   X    X    X    X\r
  62 // SBYT |   X    X    X      X   X   X   X   X    X    X   X    X    X    X\r
  63 // SNGL |   X    X           X   X   X   X   X    X    X   X    X    X    X\r
  64 // STR  |   X    X    X   X  X   X   X   X   X    X    X   X    X    X    X\r
  65 // UI16 |   X    X    X      X   X   X   X   X    X    X   X    X    X    X\r
  66 // UI32 |   X    X    X      X   X   X   X   X    X    X   X    X    X    X\r
  67 // UI64 |   X    X    X      X   X   X   X   X    X    X   X    X    X    X\r
  68 //\r
  69
  70 //
  71 // Copyright (C) 2004 Novell, Inc (http://www.novell.com)
  72 //
  73 // Permission is hereby granted, free of charge, to any person obtaining
  74 // a copy of this software and associated documentation files (the
  75 // "Software"), to deal in the Software without restriction, including
  76 // without limitation the rights to use, copy, modify, merge, publish,
  77 // distribute, sublicense, and/or sell copies of the Software, and to
  78 // permit persons to whom the Software is furnished to do so, subject to
  79 // the following conditions:
  80 //
  81 // The above copyright notice and this permission notice shall be
  82 // included in all copies or substantial portions of the Software.
  83 //
  84 // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
  85 // EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
  86 // MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
  87 // NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
  88 // LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
  89 // OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
  90 // WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
  91 //
  92 \r
  93 using System.Globalization;\r
  94 using System.IO;
  95 using System.Security.Cryptography;\r
  96 using System.Text;\r
  97 \r
  98 namespace System {\r
  99   \r
 100 //      [CLSCompliant(false)]\r
 101         public sealed class Convert {\r
 102 \r
 103                 // Fields\r
 104                 public static readonly object DBNull = System.DBNull.Value;\r
 105                 static ToBase64Transform toBase64Transform = new ToBase64Transform();\r
 106         \r
 107                 private Convert ()\r
 108                 {\r
 109                 }\r
 110 \r
 111                 // ========== BASE 64 Conversions ========== //\r
 112                 // the BASE64 convert methods are using the Base64 converting methods\r
 113                 // from System.Security.Cryptography.ToBase64Transform and\r
 114                 // System.Security.Cryptography.FromBase64Transform\r
 115                 //\r
 116                 // should be changed to a stand-alone class Base64Encoder & Base64Decoder\r
 117                 \r
 118                 public static byte[] FromBase64CharArray (char[] inArray, int offset, int length)\r
 119                 {\r
 120                         if (inArray == null)\r
 121                                 throw new ArgumentNullException ("inArray");\r
 122                         if (offset < 0)\r
 123                                 throw new ArgumentOutOfRangeException ("offset < 0");\r
 124                         if (length < 0)\r
 125                                 throw new ArgumentOutOfRangeException ("length < 0");\r
 126                         // avoid integer overflow\r
 127                         if (offset > inArray.Length - length)\r
 128                                 throw new ArgumentOutOfRangeException ("offset + length > array.Length");\r
 129                         // do not check length here (multiple of 4) because the\r
 130                         // string can contain ignored characters\r
 131 \r
 132                         return FromBase64 (inArray, offset, length);\r
 133                 }\r
 134                 \r
 135                 public static byte[] FromBase64String (string s)\r
 136                 {\r
 137                         if (s == null)\r
 138                                 throw new ArgumentNullException ("s");\r
 139                         // do not check length here (multiple of 4) because the\r
 140                         // string can contain ignored characters\r
 141 \r
 142                         char[] chars = s.ToCharArray ();\r
 143                         return FromBase64 (chars, 0, chars.Length);\r
 144                 }\r
 145                 \r
 146                 private static byte[] FromBase64 (char[] chars, int index, int count) \r
 147                 {\r
 148                         byte[] data = new byte [count];\r
 149                         int n = 0;\r
 150                         for (int i=0; i < count; i++) {\r
 151                                 char c = chars [i];\r
 152                                 // drop ignored characters\r
 153                                 if (c == '\t' || c == '\r' || c == '\n' || c == ' ')\r
 154                                         continue;\r
 155                                 // wide chars (16 bits)\r
 156                                 if ((int)c > Byte.MaxValue)\r
 157                                         continue;\r
 158                                 data [n++] = (byte) c;\r
 159                         }\r
 160                         // now the length must be a multiple of 4 bytes (same as % 4)\r
 161                         if ((n & 3) != 0)\r
 162                                 throw new FormatException ("invalid base64 length");\r
 163                         // and we do not need to ignore whitespace this time (which is a little faster)\r
 164                         FromBase64Transform t = new FromBase64Transform (FromBase64TransformMode.DoNotIgnoreWhiteSpaces);\r
 165                         return t.TransformFinalBlock (data, 0, n);\r
 166                 }\r
 167 \r
 168                 public static TypeCode GetTypeCode (object value)\r
 169                 {\r
 170                         if (value == null)\r
 171                                 return TypeCode.Empty;\r
 172                         else \r
 173                                 return Type.GetTypeCode (value.GetType ());\r
 174                 }\r
 175 \r
 176                 public static bool IsDBNull (object value)\r
 177                 {\r
 178                         if (value is DBNull)\r
 179                                 return true;\r
 180                         else\r
 181                                 return false;\r
 182                 }\r
 183                 \r
 184                 public static int ToBase64CharArray (byte[] inArray, int offsetIn, int length, \r
 185                                                     char[] outArray, int offsetOut)\r
 186                 {\r
 187                         if (inArray == null)\r
 188                                 throw new ArgumentNullException ("inArray");\r
 189                         if (outArray == null)\r
 190                                 throw new ArgumentNullException ("outArray");\r
 191                         if (offsetIn < 0 || length < 0 || offsetOut < 0)\r
 192                                 throw new ArgumentOutOfRangeException ("offsetIn, length, offsetOut < 0");\r
 193                         // avoid integer overflow\r
 194                         if (offsetIn > inArray.Length - length)\r
 195                                 throw new ArgumentOutOfRangeException ("offsetIn + length > array.Length");\r
 196 \r
 197                         // note: normally ToBase64Transform doesn't support multiple block processing\r
 198                         byte[] outArr = toBase64Transform.InternalTransformFinalBlock (inArray, offsetIn, length);\r
 199                         \r
 200                         char[] cOutArr = new ASCIIEncoding ().GetChars (outArr);\r
 201                         \r
 202                         // avoid integer overflow\r
 203                         if (offsetOut > outArray.Length - cOutArr.Length)\r
 204                                 throw new ArgumentOutOfRangeException ("offsetOut + cOutArr.Length > outArray.Length");\r
 205                         \r
 206                         Array.Copy (cOutArr, 0, outArray, offsetOut, cOutArr.Length);\r
 207                         \r
 208                         return cOutArr.Length;\r
 209                 }\r
 210                 \r
 211                 public static string ToBase64String (byte[] inArray)\r
 212                 {\r
 213                         if (inArray == null)\r
 214                                 throw new ArgumentNullException ("inArray");\r
 215 \r
 216                         return ToBase64String (inArray, 0, inArray.Length);\r
 217                 }\r
 218                 \r
 219                 public static string ToBase64String (byte[] inArray, int offset, int length)\r
 220                 {\r
 221                         if (inArray == null)\r
 222                                 throw new ArgumentNullException ("inArray");\r
 223                         if (offset < 0 || length < 0)\r
 224                                 throw new ArgumentOutOfRangeException ("offset < 0 || length < 0");\r
 225                         // avoid integer overflow\r
 226                         if (offset > inArray.Length - length)\r
 227                                 throw new ArgumentOutOfRangeException ("offset + length > array.Length");\r
 228                         \r
 229                         // note: normally ToBase64Transform doesn't support multiple block processing\r
 230                         byte[] outArr = toBase64Transform.InternalTransformFinalBlock (inArray, offset, length);\r
 231                         \r
 232                         return (new ASCIIEncoding ().GetString (outArr));\r
 233                 }\r
 234
 235 #if NET_2_0
 236                 public static string ToBase64String (byte[] inArray, Base64FormattingOptions options)
 237                 {
 238                         if (inArray == null)
 239                                 throw new ArgumentNullException ("inArray");
 240                         return ToBase64String (inArray, 0, inArray.Length, options);
 241                 }
 242
 243                 public static string ToBase64String (byte[] inArray, bool insertLineBreaks)
 244                 {
 245                         Base64FormattingOptions options = insertLineBreaks ? Base64FormattingOptions.InsertLineBreaks : Base64FormattingOptions.None;
 246                         return ToBase64String (inArray, options);
 247                 }
 248
 249                 public static string ToBase64String (byte[] inArray, int offset, int length, Base64FormattingOptions options)
 250                 {
 251                         if (inArray == null)
 252                                 throw new ArgumentNullException ("inArray");
 253                         if (offset < 0 || length < 0)
 254                                 throw new ArgumentOutOfRangeException ("offset < 0 || length < 0");
 255                         // avoid integer overflow
 256                         if (offset > inArray.Length - length)
 257                                 throw new ArgumentOutOfRangeException ("offset + length > array.Length");
 258
 259                         Encoding encoding = new ASCIIEncoding ();
 260                         StringBuilder sb = new StringBuilder ();
 261                         BinaryReader reader = new BinaryReader (new MemoryStream (inArray, offset, length));
 262                         byte[] b = null;
 263
 264                         do {
 265                                 // 54 bytes of input makes for 72 bytes of output.
 266                                 b = reader.ReadBytes (54);
 267                                 if (b.Length > 0)
 268                                         sb.AppendLine (encoding.GetString (toBase64Transform.InternalTransformFinalBlock (b, 0, b.Length)));
 269                         } while (b.Length > 0);
 270
 271                         return sb.ToString ();
 272                 }
 273
 274                 public static string ToBase64String (byte[] inArray, int offset, int length, bool insertLineBreaks)
 275                 {
 276                         Base64FormattingOptions options = insertLineBreaks ? Base64FormattingOptions.InsertLineBreaks : Base64FormattingOptions.None;
 277                         return ToBase64String (inArray, offset, length, options);
 278                 }
 279 #endif
 280
 281
 282                 \r
 283                 // ========== Boolean Conversions ========== //\r
 284         \r
 285                 public static bool ToBoolean (bool value) \r
 286                 { \r
 287                         return value; \r
 288                 }\r
 289 \r
 290                 public static bool ToBoolean (byte value) \r
 291                 { \r
 292                         return (value != 0); \r
 293                 }\r
 294  \r
 295                 public static bool ToBoolean (char value)\r
 296                 {\r
 297                         throw new InvalidCastException (Locale.GetText ("Can't convert char to bool"));\r
 298                 }\r
 299                 \r
 300                 public static bool ToBoolean (DateTime value)\r
 301                 {\r
 302                         throw new InvalidCastException (Locale.GetText ("Can't convert date to bool"));\r
 303                 }\r
 304                 \r
 305                 public static bool ToBoolean (decimal value) \r
 306                 { \r
 307                         return (value != 0M); \r
 308                 }\r
 309 \r
 310                 public static bool ToBoolean (double value) \r
 311                 { \r
 312                         return (value != 0); \r
 313                 }\r
 314 \r
 315                 public static bool ToBoolean (float value) \r
 316                 { \r
 317                         return (value != 0f); \r
 318                 }\r
 319 \r
 320                 public static bool ToBoolean (int value) \r
 321                 { \r
 322                         return (value != 0); \r
 323                 }\r
 324 \r
 325                 public static bool ToBoolean (long value) \r
 326                 { \r
 327                         return (value != 0); \r
 328                 }\r
 329 \r
 330                 [CLSCompliant (false)]\r
 331                 public static bool ToBoolean (sbyte value) \r
 332                 { \r
 333                         return (value != 0); \r
 334                 }\r
 335         \r
 336                 public static bool ToBoolean (short value) \r
 337                 { \r
 338                         return (value != 0); \r
 339                 }\r
 340 \r
 341                 public static bool ToBoolean (string value) \r
 342                 {\r
 343                         if (value == null)\r
 344                                 return false; // LAMESPEC: Spec says throw ArgumentNullException\r
 345                         return Boolean.Parse (value);\r
 346                 }\r
 347 \r
 348                 public static bool ToBoolean (string value, IFormatProvider provider)\r
 349                 {\r
 350                         if (value == null)\r
 351                                 return false; // LAMESPEC: Spec says throw ArgumentNullException\r
 352                         return Boolean.Parse (value); // provider is ignored.\r
 353                 }\r
 354 \r
 355                 [CLSCompliant (false)]\r
 356                 public static bool ToBoolean (uint value) \r
 357                 { \r
 358                         return (value != 0);\r
 359                 }\r
 360 \r
 361                 [CLSCompliant (false)]\r
 362                 public static bool ToBoolean (ulong value) \r
 363                 { \r
 364                         return (value != 0); \r
 365                 }\r
 366 \r
 367                 [CLSCompliant (false)]\r
 368                 public static bool ToBoolean (ushort value) \r
 369                 { \r
 370                         //if (value == null)\r
 371                         //      return false;\r
 372                         return (value != 0); \r
 373                 }\r
 374 \r
 375                 public static bool ToBoolean (object value)\r
 376                 {\r
 377                         if (value == null)\r
 378                                 return false;\r
 379                         return ToBoolean (value, null);\r
 380                 }\r
 381 \r
 382                 public static bool ToBoolean (object value, IFormatProvider provider)\r
 383                 {\r
 384                         if (value == null)\r
 385                                 return false;\r
 386                         return ((IConvertible) value).ToBoolean (provider);\r
 387                 }\r
 388 \r
 389                 // ========== Byte Conversions ========== //\r
 390         \r
 391                 public static byte ToByte (bool value) \r
 392                 { \r
 393                         return (byte)(value ? 1 : 0); \r
 394                 }\r
 395         \r
 396                 public static byte ToByte (byte value) \r
 397                 { \r
 398                         return value; \r
 399                 }\r
 400 \r
 401                 public static byte ToByte (char value) \r
 402                 { \r
 403                         if (value > Byte.MaxValue)\r
 404                                 throw new OverflowException (Locale.GetText (\r
 405                                         "Value is greater than Byte.MaxValue"));\r
 406 \r
 407                         return (byte)value;\r
 408                 }\r
 409 \r
 410                 public static byte ToByte (DateTime value)\r
 411                 {\r
 412                         throw new InvalidCastException ("This conversion is not supported.");\r
 413                 }\r
 414         \r
 415                 public static byte ToByte (decimal value)\r
 416                 { \r
 417                         if (value > Byte.MaxValue || value < Byte.MinValue)\r
 418                                 throw new OverflowException (Locale.GetText (\r
 419                                         "Value is greater than Byte.MaxValue or less than Byte.MinValue"));\r
 420           \r
 421                         // Returned Even-Rounded\r
 422                         return (byte)(Math.Round (value));\r
 423                 }\r
 424         \r
 425                 public static byte ToByte (double value) \r
 426                 { \r
 427                         if (value > Byte.MaxValue || value < Byte.MinValue)\r
 428                                 throw new OverflowException (Locale.GetText (\r
 429                                         "Value is greater than Byte.MaxValue or less than Byte.MinValue"));\r
 430           \r
 431                         // This and the float version of ToByte are the only ones\r
 432                         // the spec listed as checking for .NaN and Infinity overflow\r
 433                         if (Double.IsNaN(value) || Double.IsInfinity(value))\r
 434                                 throw new OverflowException (Locale.GetText (\r
 435                                         "Value is equal to Double.NaN, Double.PositiveInfinity, or Double.NegativeInfinity"));\r
 436 \r
 437                         // Returned Even-Rounded\r
 438                         return (byte)(Math.Round (value));\r
 439                 }\r
 440 \r
 441                 public static byte ToByte (float value) \r
 442                 { \r
 443                         if (value > Byte.MaxValue || value < Byte.MinValue)\r
 444                                 throw new OverflowException (Locale.GetText (\r
 445                                         "Value is greater than Byte.MaxValue or less than Byte.Minalue"));\r
 446 \r
 447                         // This and the double version of ToByte are the only ones\r
 448                         // the spec listed as checking for .NaN and Infinity overflow\r
 449                         if (Single.IsNaN(value) || Single.IsInfinity(value))\r
 450                                 throw new OverflowException (Locale.GetText (\r
 451                                         "Value is equal to Single.NaN, Single.PositiveInfinity, or Single.NegativeInfinity"));\r
 452           \r
 453                         // Returned Even-Rounded, pass it as a double, could have this\r
 454                         // method just call Convert.ToByte ( (double)value)\r
 455                         return (byte)(Math.Round ( (double)value));\r
 456                 }\r
 457 \r
 458                 public static byte ToByte (int value) \r
 459                 { \r
 460                         if (value > Byte.MaxValue || value < Byte.MinValue)\r
 461                                 throw new OverflowException (Locale.GetText (\r
 462                                         "Value is greater than Byte.MaxValue or less than Byte.MinValue"));\r
 463           \r
 464                         return (byte)value; \r
 465                 }\r
 466 \r
 467                 public static byte ToByte (long value) \r
 468                 { \r
 469                         if (value > Byte.MaxValue || value < Byte.MinValue)\r
 470                                 throw new OverflowException (Locale.GetText (\r
 471                                         "Value is greater than Byte.MaxValue or less than Byte.MinValue"));\r
 472           \r
 473                         return (byte)value;\r
 474                 }\r
 475 \r
 476                 [CLSCompliant (false)]\r
 477                 public static byte ToByte (sbyte value) \r
 478                 { \r
 479                         if (value < Byte.MinValue)\r
 480                                 throw new OverflowException (Locale.GetText (\r
 481                                         "Value is less than Byte.MinValue"));\r
 482           \r
 483                         return (byte)value;\r
 484                 }\r
 485         \r
 486                 public static byte ToByte (short value) \r
 487                 { \r
 488                         if (value > Byte.MaxValue || value < Byte.MinValue)\r
 489                                 throw new OverflowException (Locale.GetText (\r
 490                                         "Value is greater than Byte.MaxValue or less than Byte.MinValue"));\r
 491           \r
 492                         return (byte)value; \r
 493                 }\r
 494 \r
 495                 public static byte ToByte (string value) \r
 496                 {\r
 497                         if (value == null)\r
 498                                 return 0; // LAMESPEC: Spec says throw ArgumentNullException\r
 499                         return Byte.Parse (value);\r
 500                 }\r
 501 \r
 502                 public static byte ToByte (string value, IFormatProvider provider) \r
 503                 {\r
 504                         if (value == null)\r
 505                                 return 0; // LAMESPEC: Spec says throw ArgumentNullException\r
 506                         return Byte.Parse (value, provider);\r
 507                 }\r
 508 \r
 509                 public static byte ToByte (string value, int fromBase)\r
 510                 {\r
 511                         int retVal = ConvertFromBase (value, fromBase, true);\r
 512 \r
 513                         if (retVal < (int) Byte.MinValue || retVal > (int) Byte.MaxValue)\r
 514                                 throw new OverflowException ();\r
 515                         else\r
 516                                 return (byte) retVal;\r
 517                 }\r
 518 \r
 519                 [CLSCompliant (false)]\r
 520                 public static byte ToByte (uint value) \r
 521                 { \r
 522                         if (value > Byte.MaxValue)\r
 523                                 throw new OverflowException (Locale.GetText (\r
 524                                         "Value is greater than Byte.MaxValue"));\r
 525 \r
 526                         return (byte)value;\r
 527                 }\r
 528 \r
 529                 [CLSCompliant (false)]\r
 530                 public static byte ToByte (ulong value) \r
 531                 { \r
 532                         if (value > Byte.MaxValue)\r
 533                                 throw new OverflowException (Locale.GetText (\r
 534                                         "Value is greater than Byte.MaxValue"));\r
 535 \r
 536                         return (byte)value;\r
 537                 }\r
 538 \r
 539                 [CLSCompliant (false)]\r
 540                 public static byte ToByte (ushort value) \r
 541                 { \r
 542                         if (value > Byte.MaxValue)\r
 543                                 throw new OverflowException (Locale.GetText (\r
 544                                         "Value is greater than Byte.MaxValue"));\r
 545 \r
 546                         return (byte)value;\r
 547                 }\r
 548 \r
 549                 public static byte ToByte (object value)\r
 550                 {\r
 551                         if (value == null)\r
 552                                 return 0;\r
 553                         return ToByte (value, null);\r
 554                 }\r
 555 \r
 556                 public static byte ToByte (object value, IFormatProvider provider)\r
 557                 {\r
 558                         if (value == null)\r
 559                                 return 0;\r
 560                         return ((IConvertible) value).ToByte (provider);\r
 561                 }\r
 562 \r
 563                 // ========== Char Conversions ========== //\r
 564 \r
 565                 public static char ToChar (bool value)\r
 566                 {\r
 567                         throw new InvalidCastException ("This conversion is not supported.");\r
 568                 }\r
 569                 \r
 570                 public static char ToChar (byte value) \r
 571                 { \r
 572                         return (char)value;\r
 573                 }\r
 574 \r
 575                 public static char ToChar (char value) \r
 576                 { \r
 577                         return value;\r
 578                 }\r
 579 \r
 580                 public static char ToChar (DateTime value)\r
 581                 {\r
 582                         throw new InvalidCastException ("This conversion is not supported.");\r
 583                 }\r
 584 \r
 585                 public static char ToChar (decimal value)\r
 586                 {\r
 587                         throw new InvalidCastException ("This conversion is not supported.");\r
 588                 }\r
 589 \r
 590                 public static char ToChar (double value)\r
 591                 {\r
 592                         throw new InvalidCastException ("This conversion is not supported.");\r
 593                 }\r
 594                 \r
 595                 public static char ToChar (int value) \r
 596                 { \r
 597                         if (value > Char.MaxValue || value < Char.MinValue)\r
 598                                 throw new OverflowException (Locale.GetText (\r
 599                                         "Value is greater than Char.MaxValue or less than Char.MinValue"));\r
 600           \r
 601                         return (char)value; \r
 602                 }\r
 603 \r
 604                 public static char ToChar (long value) \r
 605                 { \r
 606                         if (value > Char.MaxValue || value < Char.MinValue)\r
 607                                 throw new OverflowException (Locale.GetText (\r
 608                                         "Value is greater than Char.MaxValue or less than Char.MinValue"));\r
 609           \r
 610                         return (char)value; \r
 611                 }\r
 612 \r
 613                 public static char ToChar (float value)\r
 614                 {\r
 615                         throw new InvalidCastException ("This conversion is not supported.");\r
 616                 }\r
 617 \r
 618                 [CLSCompliant (false)]\r
 619                 public static char ToChar (sbyte value) \r
 620                 { \r
 621                         if (value < Char.MinValue)\r
 622                                 throw new OverflowException (Locale.GetText (\r
 623                                         "Value is less than Char.MinValue"));\r
 624           \r
 625                         return (char)value; \r
 626                 }\r
 627         \r
 628                 public static char ToChar (short value) \r
 629                 { \r
 630                         if (value < Char.MinValue)\r
 631                                 throw new OverflowException (Locale.GetText (\r
 632                                         "Value is less than Char.MinValue"));\r
 633           \r
 634                         return (char)value; \r
 635                 }\r
 636 \r
 637                 public static char ToChar (string value) \r
 638                 {\r
 639                         return Char.Parse (value);\r
 640                 }\r
 641 \r
 642                 public static char ToChar (string value, IFormatProvider provider)\r
 643                 {\r
 644                         return Char.Parse (value); // provider is ignored.\r
 645                 }\r
 646 \r
 647                 [CLSCompliant (false)]\r
 648                 public static char ToChar (uint value) \r
 649                 { \r
 650                         if (value > Char.MaxValue)\r
 651                                 throw new OverflowException (Locale.GetText (\r
 652                                         "Value is greater than Char.MaxValue"));\r
 653           \r
 654                         return (char)value; \r
 655                 }\r
 656 \r
 657                 [CLSCompliant (false)]\r
 658                 public static char ToChar (ulong value) \r
 659                 { \r
 660                         if (value > Char.MaxValue)\r
 661                                 throw new OverflowException (Locale.GetText (\r
 662                                         "Value is greater than Char.MaxValue"));\r
 663           \r
 664                         return (char)value; \r
 665                 }\r
 666 \r
 667                 [CLSCompliant (false)]\r
 668                 public static char ToChar (ushort value) \r
 669                 { \r
 670                         if (value > Char.MaxValue)\r
 671                                 throw new OverflowException (Locale.GetText (\r
 672                                         "Value is greater than Char.MaxValue"));\r
 673           \r
 674                         return (char)value; \r
 675                 }\r
 676 \r
 677                 public static char ToChar (object value)\r
 678                 {\r
 679                         if (value == null)\r
 680                                 return '\0';\r
 681                         return ToChar (value, null);\r
 682                 }\r
 683 \r
 684                 public static char ToChar (object value, IFormatProvider provider)\r
 685                 {\r
 686                         if (value == null)\r
 687                                 return '\0';\r
 688                         return ((IConvertible) value).ToChar (provider);\r
 689                 }\r
 690 \r
 691                 // ========== DateTime Conversions ========== //\r
 692         \r
 693                 public static DateTime ToDateTime (string value) \r
 694                 { \r
 695                         if (value == null)\r
 696                                 return DateTime.MinValue; // LAMESPEC: Spec says throw ArgumentNullException\r
 697                         return DateTime.Parse (value);\r
 698                 }\r
 699         \r
 700                 public static DateTime ToDateTime (string value, IFormatProvider provider) \r
 701                 {\r
 702                         if (value == null)\r
 703                                 return DateTime.MinValue; // LAMESPEC: Spec says throw ArgumentNullException\r
 704                         return DateTime.Parse (value, provider);\r
 705                 }\r
 706 \r
 707                 public static DateTime ToDateTime (bool value)\r
 708                 {\r
 709                         throw new InvalidCastException ("This conversion is not supported.");\r
 710                 }\r
 711 \r
 712                 public static DateTime ToDateTime (byte value)\r
 713                 {\r
 714                         throw new InvalidCastException ("This conversion is not supported.");\r
 715                 }\r
 716 \r
 717                 public static DateTime ToDateTime (char value)\r
 718                 {\r
 719                         throw new InvalidCastException ("This conversion is not supported.");\r
 720                 }\r
 721 \r
 722                 public static DateTime ToDateTime (DateTime value)\r
 723                 {\r
 724                         return value;\r
 725                 }\r
 726 \r
 727                 public static DateTime ToDateTime (decimal value)\r
 728                 {\r
 729                         throw new InvalidCastException ("This conversion is not supported.");\r
 730                 }\r
 731 \r
 732                 public static DateTime ToDateTime (double value)\r
 733                 {\r
 734                         throw new InvalidCastException ("This conversion is not supported.");\r
 735                 }\r
 736 \r
 737                 public static DateTime ToDateTime (short value)\r
 738                 {\r
 739                         throw new InvalidCastException ("This conversion is not supported.");\r
 740                 }\r
 741 \r
 742                 public static DateTime ToDateTime (int value)\r
 743                 {\r
 744                         throw new InvalidCastException ("This conversion is not supported.");\r
 745                 }\r
 746 \r
 747                 public static DateTime ToDateTime (long value)\r
 748                 {\r
 749                         throw new InvalidCastException ("This conversion is not supported.");\r
 750                 }\r
 751 \r
 752                 public static DateTime ToDateTime (float value)\r
 753                 {\r
 754                         throw new InvalidCastException ("This conversion is not supported.");\r
 755                 }\r
 756 \r
 757                 public static DateTime ToDateTime (object value)\r
 758                 {\r
 759                         if (value == null)\r
 760                                 return DateTime.MinValue;\r
 761                         return ToDateTime (value, null);\r
 762                 }\r
 763 \r
 764                 public static DateTime ToDateTime (object value, IFormatProvider provider)\r
 765                 {\r
 766                         if (value == null)\r
 767                                 return DateTime.MinValue;\r
 768                         return ((IConvertible) value).ToDateTime (provider);\r
 769                 }\r
 770 \r
 771                 [CLSCompliant (false)]\r
 772                 public static DateTime ToDateTime (sbyte value)\r
 773                 {\r
 774                         throw new InvalidCastException ("This conversion is not supported.");\r
 775                 }\r
 776                 [CLSCompliant (false)]\r
 777                 public static DateTime ToDateTime (ushort value)\r
 778                 {\r
 779                         throw new InvalidCastException ("This conversion is not supported.");\r
 780                 }\r
 781 \r
 782                 [CLSCompliant (false)]\r
 783                 public static DateTime ToDateTime (uint value)\r
 784                 {\r
 785                         throw new InvalidCastException ("This conversion is not supported.");\r
 786                 }\r
 787 \r
 788                 [CLSCompliant (false)]\r
 789                 public static DateTime ToDateTime (ulong value)\r
 790                 {\r
 791                         throw new InvalidCastException ("This conversion is not supported.");\r
 792                 }\r
 793 \r
 794                 // ========== Decimal Conversions ========== //\r
 795         \r
 796                 public static decimal ToDecimal (bool value) \r
 797                 { \r
 798                         return value ? 1 : 0; \r
 799                 }\r
 800         \r
 801                 public static decimal ToDecimal (byte value) \r
 802                 { \r
 803                         return (decimal)value; \r
 804                 }\r
 805 \r
 806                 public static decimal ToDecimal (char value)\r
 807                 {\r
 808                         throw new InvalidCastException ("This conversion is not supported.");\r
 809                 }\r
 810 \r
 811                 public static decimal ToDecimal (DateTime value)\r
 812                 {\r
 813                         throw new InvalidCastException ("This conversion is not supported.");\r
 814                 }\r
 815                                 \r
 816                 public static decimal ToDecimal (decimal value) \r
 817                 { \r
 818                         return value; \r
 819                 }\r
 820 \r
 821                 public static decimal ToDecimal (double value) \r
 822                 { \r
 823                         if (value > (double)Decimal.MaxValue || value < (double)Decimal.MinValue) \r
 824                                 throw new OverflowException (Locale.GetText (\r
 825                                         "Value is greater than Decimal.MaxValue or less than Decimal.MinValue"));\r
 826 \r
 827                         return (decimal)value; \r
 828                 }\r
 829 \r
 830                 public static decimal ToDecimal (float value) \r
 831                 {\r
 832                         return (decimal) value;\r
 833                 }\r
 834 \r
 835                 public static decimal ToDecimal (int value) \r
 836                 { \r
 837                         return (decimal)value; \r
 838                 }\r
 839         \r
 840                 public static decimal ToDecimal (long value) \r
 841                 { \r
 842                         return (decimal)value; \r
 843                 }\r
 844 \r
 845                 [CLSCompliant (false)]\r
 846                 public static decimal ToDecimal (sbyte value) \r
 847                 { \r
 848                         return (decimal)value; \r
 849                 }\r
 850         \r
 851                 public static decimal ToDecimal (short value) \r
 852                 { \r
 853                         return (decimal)value; \r
 854                 }\r
 855 \r
 856                 public static decimal ToDecimal (string value) \r
 857                 {\r
 858                         if (value == null)\r
 859                                 return new Decimal (0); // LAMESPEC: Spec says throw ArgumentNullException\r
 860                         return Decimal.Parse (value);\r
 861                 }\r
 862 \r
 863                 public static decimal ToDecimal (string value, IFormatProvider provider) \r
 864                 {\r
 865                         if (value == null)\r
 866                                 return new Decimal (0); // LAMESPEC: Spec says throw ArgumentNullException\r
 867                         return Decimal.Parse (value, provider);\r
 868                 }\r
 869 \r
 870                 [CLSCompliant (false)]\r
 871                 public static decimal ToDecimal (uint value) \r
 872                 { \r
 873                         return (decimal)value; \r
 874                 }\r
 875 \r
 876                 [CLSCompliant (false)]\r
 877                 public static decimal ToDecimal (ulong value) \r
 878                 { \r
 879                         return (decimal)value; \r
 880                 }\r
 881 \r
 882                 [CLSCompliant (false)]\r
 883                 public static decimal ToDecimal (ushort value) \r
 884                 { \r
 885                         return (decimal)value; \r
 886                 }\r
 887 \r
 888                 public static decimal ToDecimal (object value)\r
 889                 {\r
 890                         if (value == null)\r
 891                                 return new Decimal (0);\r
 892                         return ToDecimal (value, null);\r
 893                 }\r
 894 \r
 895                 public static decimal ToDecimal (object value, IFormatProvider provider)\r
 896                 {\r
 897                         if (value == null)\r
 898                                 return new Decimal (0);\r
 899                         return ((IConvertible) value).ToDecimal (provider);\r
 900                 }\r
 901                                                  \r
 902 \r
 903                 // ========== Double Conversions ========== //\r
 904         \r
 905                 public static double ToDouble (bool value) \r
 906                 { \r
 907                         return value ? 1 : 0; \r
 908                 }\r
 909         \r
 910                 public static double ToDouble (byte value) \r
 911                 { \r
 912                         return (double) value;\r
 913                 }\r
 914 \r
 915                 public static double ToDouble (char value)\r
 916                 {\r
 917                         throw new InvalidCastException ("This conversion is not supported.");\r
 918                 }\r
 919 \r
 920                 public static double ToDouble (DateTime value)\r
 921                 {\r
 922                         throw new InvalidCastException ("This conversion is not supported.");\r
 923                 }\r
 924         \r
 925                 public static double ToDouble (decimal value) \r
 926                 { \r
 927                         return (double)value; \r
 928                 }\r
 929 \r
 930                 public static double ToDouble (double value) \r
 931                 { \r
 932                         return value; \r
 933                 }\r
 934 \r
 935                 public static double ToDouble (float value) \r
 936                 { \r
 937                         return (double) value;\r
 938                 }\r
 939 \r
 940                 public static double ToDouble (int value) \r
 941                 { \r
 942                         return (double)value; \r
 943                 }\r
 944         \r
 945                 public static double ToDouble (long value) \r
 946                 { \r
 947                         return (double)value; \r
 948                 }\r
 949 \r
 950                 [CLSCompliant (false)]\r
 951                 public static double ToDouble (sbyte value) \r
 952                 { \r
 953                         return (double)value; \r
 954                 }\r
 955         \r
 956                 public static double ToDouble (short value) \r
 957                 { \r
 958                         return (double)value; \r
 959                 }\r
 960 \r
 961                 public static double ToDouble (string value) \r
 962                 {\r
 963                         if (value == null)\r
 964                                 return 0.0; // LAMESPEC: Spec says throw ArgumentNullException\r
 965                         return Double.Parse (value);\r
 966                 }\r
 967 \r
 968                 public static double ToDouble (string value, IFormatProvider provider) \r
 969                 {\r
 970                         if (value == null)\r
 971                                 return 0.0; // LAMESPEC: Spec says throw ArgumentNullException\r
 972                         return Double.Parse (value, provider);\r
 973                 }\r
 974 \r
 975                 [CLSCompliant (false)]\r
 976                 public static double ToDouble (uint value) \r
 977                 { \r
 978                         return (double)value; \r
 979                 }\r
 980 \r
 981                 [CLSCompliant (false)]\r
 982                 public static double ToDouble (ulong value) \r
 983                 { \r
 984                         return (double)value; \r
 985                 }\r
 986 \r
 987                 [CLSCompliant (false)]\r
 988                 public static double ToDouble (ushort value) \r
 989                 { \r
 990                         return (double)value; \r
 991                 }\r
 992 \r
 993                 public static double ToDouble (object value)\r
 994                 {\r
 995                         if (value == null)\r
 996                                 return 0.0;\r
 997                         return ToDouble (value, null);\r
 998                 }\r
 999 \r
1000                 public static double ToDouble (object value, IFormatProvider provider)\r
1001                 {\r
1002                         if (value == null)\r
1003                                 return 0.0;\r
1004                         return ((IConvertible) value).ToDouble (provider);\r
1005                 }\r
1006 \r
1007                 // ========== Int16 Conversions ========== //\r
1008 \r
1009                 public static short ToInt16 (bool value) \r
1010                 { \r
1011                         return (short)(value ? 1 : 0); \r
1012                 }\r
1013         \r
1014                 public static short ToInt16 (byte value) \r
1015                 { \r
1016                         return (short)value; \r
1017                 }\r
1018 \r
1019                 public static short ToInt16 (char value) \r
1020                 {\r
1021                         if (value > Int16.MaxValue) \r
1022                                 throw new OverflowException (Locale.GetText (\r
1023                                         "Value is greater than Int16.MaxValue"));\r
1024 \r
1025                         return (short)value;\r
1026                 }\r
1027 \r
1028                 public static short ToInt16 (DateTime value) \r
1029                 {\r
1030                         throw new InvalidCastException ("This conversion is not supported.");\r
1031                 }\r
1032         \r
1033                 public static short ToInt16 (decimal value) \r
1034                 { \r
1035                         if (value > Int16.MaxValue || value < Int16.MinValue) \r
1036                                 throw new OverflowException (Locale.GetText (\r
1037                                         "Value is greater than Int16.MaxValue or less than Int16.MinValue"));\r
1038           \r
1039                         // Returned Even-Rounded\r
1040                         return (short)(Math.Round (value));       \r
1041                 }\r
1042 \r
1043                 public static short ToInt16 (double value) \r
1044                 { \r
1045                         if (value > Int16.MaxValue || value < Int16.MinValue) \r
1046                                 throw new OverflowException (Locale.GetText (\r
1047                                         "Value is greater than Int16.MaxValue or less than Int16.MinValue"));\r
1048           \r
1049                         // Returned Even-Rounded\r
1050                         return (short)(Math.Round (value));       \r
1051                 }\r
1052  \r
1053                 public static short ToInt16 (float value) \r
1054                 { \r
1055                         if (value > Int16.MaxValue || value < Int16.MinValue) \r
1056                                 throw new OverflowException (Locale.GetText (\r
1057                                         "Value is greater than Int16.MaxValue or less than Int16.MinValue"));\r
1058           \r
1059                         // Returned Even-Rounded, use Math.Round pass as a double.\r
1060                         return (short)Math.Round ( (double)value);\r
1061                 }\r
1062 \r
1063                 public static short ToInt16 (int value) \r
1064                 { \r
1065                         if (value > Int16.MaxValue || value < Int16.MinValue) \r
1066                                 throw new OverflowException (Locale.GetText (\r
1067                                         "Value is greater than Int16.MaxValue or less than Int16.MinValue"));\r
1068 \r
1069                         return (short)value; \r
1070                 }\r
1071         \r
1072                 public static short ToInt16 (long value) \r
1073                 { \r
1074                         if (value > Int16.MaxValue || value < Int16.MinValue) \r
1075                                 throw new OverflowException (Locale.GetText (\r
1076                                         "Value is greater than Int16.MaxValue or less than Int16.MinValue"));\r
1077 \r
1078                         return (short)value; \r
1079                 }\r
1080 \r
1081                 [CLSCompliant (false)]\r
1082                 public static short ToInt16 (sbyte value) \r
1083                 { \r
1084                         return (short)value; \r
1085                 }\r
1086         \r
1087                 public static short ToInt16 (short value) \r
1088                 { \r
1089                         return value; \r
1090                 }\r
1091 \r
1092                 public static short ToInt16 (string value) \r
1093                 {\r
1094                         if (value == null)\r
1095                                 return 0; // LAMESPEC: Spec says throw ArgumentNullException\r
1096                         return Int16.Parse (value);\r
1097                 }\r
1098 \r
1099                 public static short ToInt16 (string value, IFormatProvider provider) \r
1100                 {\r
1101                         if (value == null)\r
1102                                 return 0; // LAMESPEC: Spec says throw ArgumentNullException\r
1103                         return Int16.Parse (value, provider);\r
1104                 }\r
1105 \r
1106                 public static short ToInt16 (string value, int fromBase)\r
1107                 {
1108                         int result = ConvertFromBase (value, fromBase, false);
1109                         if (fromBase != 10) {
1110                                 // note: no sign are available to detect negatives
1111                                 if (result > Int16.MaxValue) {
1112                                         // return negative 2's complement
1113                                         return Convert.ToInt16 (-(65536 - result));
1114                                 }
1115                         }\r
1116                         return Convert.ToInt16 (result);
1117                 }\r
1118 \r
1119                 [CLSCompliant (false)]\r
1120                 public static short ToInt16 (uint value) \r
1121                 { \r
1122                         if (value > Int16.MaxValue) \r
1123                                 throw new OverflowException (Locale.GetText (\r
1124                                         "Value is greater than Int16.MaxValue"));\r
1125 \r
1126                         return (short)value; \r
1127                 }\r
1128 \r
1129                 [CLSCompliant (false)]\r
1130                 public static short ToInt16 (ulong value) \r
1131                 { \r
1132                         if (value > (ulong)Int16.MaxValue) \r
1133                                 throw new OverflowException (Locale.GetText (\r
1134                                         "Value is greater than Int16.MaxValue"));\r
1135                         return (short)value; \r
1136                 }\r
1137 \r
1138                 [CLSCompliant (false)]\r
1139                 public static short ToInt16 (ushort value) \r
1140                 { \r
1141                         if (value > Int16.MaxValue) \r
1142                                 throw new OverflowException (Locale.GetText (\r
1143                                         "Value is greater than Int16.MaxValue"));\r
1144 \r
1145                         return (short)value; \r
1146                 }\r
1147 \r
1148                 public static short ToInt16 (object value)\r
1149                 {\r
1150                         if (value == null)\r
1151                                 return 0;\r
1152                         return ToInt16 (value, null);\r
1153                 }\r
1154 \r
1155                 public static short ToInt16 (object value, IFormatProvider provider)\r
1156                 {\r
1157                         if (value == null)\r
1158                                 return 0;\r
1159                         return ((IConvertible) value).ToInt16 (provider);\r
1160                 }\r
1161         \r
1162                 // ========== Int32 Conversions ========== //\r
1163 \r
1164                 public static int ToInt32 (bool value) \r
1165                 { \r
1166                         return value ? 1 : 0; \r
1167                 }\r
1168         \r
1169                 public static int ToInt32 (byte value) \r
1170                 { \r
1171                         return (int)value; \r
1172                 }\r
1173 \r
1174                 public static int ToInt32 (char value) \r
1175                 { \r
1176                         return (int)value; \r
1177                 }\r
1178 \r
1179                 public static int ToInt32 (DateTime value)\r
1180                 {\r
1181                         throw new InvalidCastException ("This conversion is not supported.");\r
1182                 }\r
1183         \r
1184                 public static int ToInt32 (decimal value) \r
1185                 { \r
1186                         if (value > Int32.MaxValue || value < Int32.MinValue) \r
1187                                 throw new OverflowException (Locale.GetText (\r
1188                                         "Value is greater than Int32.MaxValue or less than Int32.MinValue"));\r
1189 \r
1190                         // Returned Even-Rounded\r
1191                         return (int)(Math.Round (value));         \r
1192                 }\r
1193 \r
1194                 public static int ToInt32 (double value) \r
1195                 { \r
1196                         if (value > Int32.MaxValue || value < Int32.MinValue) \r
1197                                 throw new OverflowException (Locale.GetText (\r
1198                                         "Value is greater than Int32.MaxValue or less than Int32.MinValue"));\r
1199           \r
1200                         // Returned Even-Rounded\r
1201                         return (int)(Math.Round (value));         \r
1202                 }\r
1203  \r
1204                 public static int ToInt32 (float value) \r
1205                 { \r
1206                         if (value > Int32.MaxValue || value < Int32.MinValue) \r
1207                                 throw new OverflowException (Locale.GetText (\r
1208                                         "Value is greater than Int32.MaxValue or less than Int32.MinValue"));\r
1209           \r
1210                         // Returned Even-Rounded, pass as a double, could just call\r
1211                         // Convert.ToInt32 ( (double)value);\r
1212                         return (int)(Math.Round ( (double)value));\r
1213                 }\r
1214 \r
1215                 public static int ToInt32 (int value) \r
1216                 { \r
1217                         return value; \r
1218                 }\r
1219         \r
1220                 public static int ToInt32 (long value) \r
1221                 { \r
1222                         if (value > Int32.MaxValue || value < Int32.MinValue) \r
1223                                 throw new OverflowException (Locale.GetText (\r
1224                                         "Value is greater than Int32.MaxValue or less than Int32.MinValue"));\r
1225 \r
1226                         return (int)value; \r
1227                 }\r
1228 \r
1229                 [CLSCompliant (false)]\r
1230                 public static int ToInt32 (sbyte value) \r
1231                 { \r
1232                         return (int)value; \r
1233                 }\r
1234         \r
1235                 public static int ToInt32 (short value) \r
1236                 { \r
1237                         return (int)value; \r
1238                 }\r
1239 \r
1240                 public static int ToInt32 (string value) \r
1241                 {\r
1242                         if (value == null)\r
1243                                 return 0; // LAMESPEC: Spec says throw ArgumentNullException\r
1244                         return Int32.Parse (value);\r
1245                 }\r
1246 \r
1247                 public static int ToInt32 (string value, IFormatProvider provider) \r
1248                 {\r
1249                         if (value == null)\r
1250                                 return 0; // LAMESPEC: Spec says throw ArgumentNullException\r
1251                         return Int32.Parse (value, provider);\r
1252                 }\r
1253 \r
1254                 \r
1255                 public static int ToInt32 (string value, int fromBase)\r
1256                 {\r
1257                         return ConvertFromBase (value, fromBase, false);\r
1258                 }\r
1259                 \r
1260                 [CLSCompliant (false)]\r
1261                 public static int ToInt32 (uint value) \r
1262                 { \r
1263                         if (value > Int32.MaxValue) \r
1264                                 throw new OverflowException (Locale.GetText (\r
1265                                         "Value is greater than Int32.MaxValue"));\r
1266 \r
1267                         return (int)value; \r
1268                 }\r
1269 \r
1270                 [CLSCompliant (false)]\r
1271                 public static int ToInt32 (ulong value) \r
1272                 { \r
1273                         if (value > Int32.MaxValue) \r
1274                                 throw new OverflowException (Locale.GetText (\r
1275                                         "Value is greater than Int32.MaxValue"));\r
1276 \r
1277                         return (int)value; \r
1278                 }\r
1279 \r
1280                 [CLSCompliant (false)]\r
1281                 public static int ToInt32 (ushort value) \r
1282                 { \r
1283                         return (int)value; \r
1284                 }\r
1285 \r
1286                 public static int ToInt32 (object value)\r
1287                 {\r
1288                         if (value == null)\r
1289                                 return 0;\r
1290                         return ToInt32 (value, null);\r
1291                 }\r
1292 \r
1293                 public static int ToInt32 (object value, IFormatProvider provider)\r
1294                 {\r
1295                         if (value == null)\r
1296                                 return 0;\r
1297                         return ((IConvertible) value).ToInt32 (provider);\r
1298                 }\r
1299 \r
1300                 // ========== Int64 Conversions ========== //\r
1301 \r
1302                 public static long ToInt64 (bool value) \r
1303                 { \r
1304                         return value ? 1 : 0; \r
1305                 }\r
1306         \r
1307                 public static long ToInt64 (byte value) \r
1308                 { \r
1309                         return (long)(ulong)value; \r
1310                 }\r
1311 \r
1312                 public static long ToInt64 (char value) \r
1313                 { \r
1314                         return (long)value; \r
1315                 }\r
1316 \r
1317                 public static long ToInt64 (DateTime value)\r
1318                 {\r
1319                         throw new InvalidCastException ("This conversion is not supported.");\r
1320                 }\r
1321         \r
1322                 public static long ToInt64 (decimal value) \r
1323                 { \r
1324                         if (value > Int64.MaxValue || value < Int64.MinValue) \r
1325                                 throw new OverflowException (Locale.GetText (\r
1326                                         "Value is greater than Int64.MaxValue or less than Int64.MinValue"));\r
1327           \r
1328                         // Returned Even-Rounded\r
1329                         return (long)(Math.Round (value));        \r
1330                 }\r
1331 \r
1332                 public static long ToInt64 (double value) \r
1333                 { \r
1334                         if (value > Int64.MaxValue || value < Int64.MinValue) \r
1335                                 throw new OverflowException (Locale.GetText (\r
1336                                         "Value is greater than Int64.MaxValue or less than Int64.MinValue"));\r
1337           \r
1338                         // Returned Even-Rounded\r
1339                         return (long)(Math.Round (value));\r
1340                 }\r
1341  \r
1342                 public static long ToInt64 (float value) \r
1343                 { \r
1344                         if (value > Int64.MaxValue || value < Int64.MinValue) \r
1345                                 throw new OverflowException (Locale.GetText (\r
1346                                         "Value is greater than Int64.MaxValue or less than Int64.MinValue"));\r
1347           \r
1348                         // Returned Even-Rounded, pass to Math as a double, could\r
1349                         // just call Convert.ToInt64 ( (double)value);\r
1350                         return (long)(Math.Round ( (double)value));\r
1351                 }\r
1352 \r
1353                 public static long ToInt64 (int value) \r
1354                 { \r
1355                         return (long)value; \r
1356                 }\r
1357         \r
1358                 public static long ToInt64 (long value) \r
1359                 { \r
1360                         return value; \r
1361                 }\r
1362 \r
1363                 [CLSCompliant (false)]\r
1364                 public static long ToInt64 (sbyte value) \r
1365                 { \r
1366                         return (long)value; \r
1367                 }\r
1368         \r
1369                 public static long ToInt64 (short value) \r
1370                 { \r
1371                         return (long)value; \r
1372                 }\r
1373 \r
1374                 public static long ToInt64 (string value) \r
1375                 {\r
1376                         if (value == null)\r
1377                                 return 0; // LAMESPEC: Spec says throw ArgumentNullException\r
1378                         return Int64.Parse (value);\r
1379                 }\r
1380 \r
1381                 public static long ToInt64 (string value, IFormatProvider provider) \r
1382                 {\r
1383                         if (value == null)\r
1384                                 return 0; // LAMESPEC: Spec says throw ArgumentNullException\r
1385                         return Int64.Parse (value, provider);\r
1386                 }\r
1387 \r
1388                 public static long ToInt64 (string value, int fromBase)\r
1389                 {
1390                         return ConvertFromBase64 (value, fromBase, false);\r
1391                 }\r
1392 \r
1393                 [CLSCompliant (false)]\r
1394                 public static long ToInt64 (uint value) \r
1395                 { \r
1396                         return (long)(ulong)value; \r
1397                 }\r
1398 \r
1399                 [CLSCompliant (false)]\r
1400                 public static long ToInt64 (ulong value) \r
1401                 { \r
1402                         if (value > Int64.MaxValue) \r
1403                                 throw new OverflowException (Locale.GetText (\r
1404                                         "Value is greater than Int64.MaxValue"));\r
1405 \r
1406                         return (long)value; \r
1407                 }\r
1408 \r
1409                 [CLSCompliant (false)]\r
1410                 public static long ToInt64 (ushort value) \r
1411                 { \r
1412                         return (long)(ulong)value; \r
1413                 }\r
1414 \r
1415                 public static long ToInt64 (object value)\r
1416                 {\r
1417                         if (value == null)\r
1418                                 return 0;\r
1419                         return ToInt64 (value, null);\r
1420                 }\r
1421 \r
1422                 public static long ToInt64 (object value, IFormatProvider provider)\r
1423                 {\r
1424                         if (value == null)\r
1425                                 return 0;\r
1426                         return ((IConvertible) value).ToInt64 (provider);\r
1427                 }\r
1428                 \r
1429                 // ========== SByte Conversions ========== //\r
1430 \r
1431                 [CLSCompliant (false)]\r
1432                 public static sbyte ToSByte (bool value) \r
1433                 { \r
1434                         return (sbyte)(value ? 1 : 0); \r
1435                 }\r
1436 \r
1437                 [CLSCompliant (false)]\r
1438                 public static sbyte ToSByte (byte value) \r
1439                 { \r
1440                         if (value > SByte.MaxValue)\r
1441                                 throw new OverflowException (Locale.GetText (\r
1442                                         "Value is greater than SByte.MaxValue"));\r
1443 \r
1444                         return (sbyte)value; \r
1445                 }\r
1446 \r
1447                 [CLSCompliant (false)]\r
1448                 public static sbyte ToSByte (char value) \r
1449                 { \r
1450                         if (value > SByte.MaxValue)\r
1451                                 throw new OverflowException (Locale.GetText (\r
1452                                         "Value is greater than SByte.MaxValue"));\r
1453 \r
1454                         return (sbyte)value;\r
1455                 }\r
1456 \r
1457                 [CLSCompliant (false)]\r
1458                 public static sbyte ToSByte (DateTime value)\r
1459                 {\r
1460                         throw new InvalidCastException ("This conversion is not supported.");\r
1461                 }\r
1462                 \r
1463                 [CLSCompliant (false)]  \r
1464                 public static sbyte ToSByte (decimal value) \r
1465                 { \r
1466                         if (value > SByte.MaxValue || value < SByte.MinValue)\r
1467                                 throw new OverflowException (Locale.GetText (\r
1468                                         "Value is greater than SByte.MaxValue or less than SByte.MinValue"));\r
1469           \r
1470                         // Returned Even-Rounded\r
1471                         return (sbyte)(Math.Round (value));\r
1472                 }\r
1473 \r
1474                 [CLSCompliant (false)]\r
1475                 public static sbyte ToSByte (double value) \r
1476                 { \r
1477                         if (value > SByte.MaxValue || value < SByte.MinValue)\r
1478                                 throw new OverflowException (Locale.GetText (\r
1479                                         "Value is greater than SByte.MaxValue or less than SByte.MinValue"));\r
1480 \r
1481                         // Returned Even-Rounded\r
1482                         return (sbyte)(Math.Round (value));\r
1483                 }\r
1484 \r
1485                 [CLSCompliant (false)]\r
1486                 public static sbyte ToSByte (float value) \r
1487                 { \r
1488                         if (value > SByte.MaxValue || value < SByte.MinValue)\r
1489                                 throw new OverflowException (Locale.GetText (\r
1490                                         "Value is greater than SByte.MaxValue or less than SByte.Minalue"));\r
1491 \r
1492                         // Returned Even-Rounded, pass as double to Math\r
1493                         return (sbyte)(Math.Round ( (double)value));\r
1494                 }\r
1495 \r
1496                 [CLSCompliant (false)]\r
1497                 public static sbyte ToSByte (int value) \r
1498                 { \r
1499                         if (value > SByte.MaxValue || value < SByte.MinValue)\r
1500                                 throw new OverflowException (Locale.GetText (\r
1501                                         "Value is greater than SByte.MaxValue or less than SByte.MinValue"));\r
1502           \r
1503                         return (sbyte)value; \r
1504                 }\r
1505 \r
1506                 [CLSCompliant (false)]\r
1507                 public static sbyte ToSByte (long value) \r
1508                 { \r
1509                         if (value > SByte.MaxValue || value < SByte.MinValue)\r
1510                                 throw new OverflowException (Locale.GetText (\r
1511                                         "Value is greater than SByte.MaxValue or less than SByte.MinValue"));\r
1512           \r
1513                         return (sbyte)value;\r
1514                 }\r
1515 \r
1516                 [CLSCompliant (false)]\r
1517                 public static sbyte ToSByte (sbyte value) \r
1518                 { \r
1519                         return value;\r
1520                 }\r
1521 \r
1522                 [CLSCompliant (false)]\r
1523                 public static sbyte ToSByte (short value) \r
1524                 { \r
1525                         if (value > SByte.MaxValue || value < SByte.MinValue)\r
1526                                 throw new OverflowException (Locale.GetText (\r
1527                                         "Value is greater than SByte.MaxValue or less than SByte.MinValue"));\r
1528           \r
1529                         return (sbyte)value; \r
1530                 }\r
1531 \r
1532                 [CLSCompliant (false)]\r
1533                 public static sbyte ToSByte (string value) \r
1534                 {\r
1535                         if (value == null)\r
1536                                 return 0; // LAMESPEC: Spec says throw ArgumentNullException\r
1537                         return SByte.Parse (value);\r
1538                 }\r
1539                 \r
1540                 [CLSCompliant (false)]\r
1541                 public static sbyte ToSByte (string value, IFormatProvider provider) \r
1542                 {\r
1543                         if (value == null)\r
1544                                 throw new ArgumentNullException ("value");\r
1545                         return SByte.Parse (value, provider);\r
1546                 }\r
1547 \r
1548                 [CLSCompliant (false)]\r
1549                 public static sbyte ToSByte (string value, int fromBase)\r
1550                 {\r
1551                         int result = ConvertFromBase (value, fromBase, false);\r
1552                         if (fromBase != 10) {
1553                                 // note: no sign are available to detect negatives
1554                                 if (result > SByte.MaxValue) {
1555                                         // return negative 2's complement
1556                                         return Convert.ToSByte (-(256 - result));
1557                                 }
1558                         }\r
1559                         return Convert.ToSByte (result);
1560                 }\r
1561                 \r
1562                 [CLSCompliant (false)]\r
1563                 public static sbyte ToSByte (uint value) \r
1564                 { \r
1565                         if (value > SByte.MaxValue)\r
1566                                 throw new OverflowException (Locale.GetText (\r
1567                                         "Value is greater than SByte.MaxValue"));\r
1568 \r
1569                         return (sbyte)value;\r
1570                 }\r
1571 \r
1572                 [CLSCompliant (false)]\r
1573                 public static sbyte ToSByte (ulong value) \r
1574                 { \r
1575                         if (value > (ulong)SByte.MaxValue)\r
1576                                 throw new OverflowException (Locale.GetText (\r
1577                                         "Value is greater than SByte.MaxValue"));\r
1578 \r
1579                         return (sbyte)value;\r
1580                 }\r
1581 \r
1582                 [CLSCompliant (false)]\r
1583                 public static sbyte ToSByte (ushort value) \r
1584                 { \r
1585                         if (value > SByte.MaxValue)\r
1586                                 throw new OverflowException (Locale.GetText (\r
1587                                         "Value is greater than SByte.MaxValue"));\r
1588 \r
1589                         return (sbyte)value;\r
1590                 }\r
1591 \r
1592                 [CLSCompliant (false)]\r
1593                 public static sbyte ToSByte (object value)\r
1594                 {\r
1595                         if (value == null)\r
1596                                 return 0;\r
1597                         return ToSByte (value, null);\r
1598                 }\r
1599 \r
1600                 [CLSCompliant (false)]\r
1601                 public static sbyte ToSByte (object value, IFormatProvider provider)\r
1602                 {\r
1603                         if (value == null)\r
1604                                 return 0;\r
1605                         return ((IConvertible) value).ToSByte (provider);\r
1606                 }\r
1607 \r
1608                 // ========== Single Conversions ========== //\r
1609         \r
1610                 public static float ToSingle (bool value) \r
1611                 { \r
1612                         return value ? 1 : 0; \r
1613                 }\r
1614         \r
1615                 public static float ToSingle (byte value) \r
1616                 { \r
1617                         return (float)value; \r
1618                 }\r
1619 \r
1620                 public static float ToSingle (Char value)\r
1621                 {\r
1622                         throw new InvalidCastException ("This conversion is not supported.");\r
1623                 }\r
1624 \r
1625                 public static float ToSingle (DateTime value)\r
1626                 {\r
1627                         throw new InvalidCastException ("This conversion is not supported.");\r
1628                 }\r
1629         \r
1630                 public static float ToSingle (decimal value) \r
1631                 { \r
1632                         return (float)value; \r
1633                 }\r
1634 \r
1635                 public static float ToSingle (double value) \r
1636                 { \r
1637                         return (float)value; \r
1638                 }\r
1639         \r
1640                 public static float ToSingle (float value) \r
1641                 { \r
1642                         return value; \r
1643                 }\r
1644 \r
1645                 public static float ToSingle (int value) \r
1646                 { \r
1647                         return (float)value; \r
1648                 }\r
1649         \r
1650                 public static float ToSingle (long value) \r
1651                 { \r
1652                         return (float)value; \r
1653                 }\r
1654 \r
1655                 [CLSCompliant (false)]\r
1656                 public static float ToSingle (sbyte value) \r
1657                 { \r
1658                         return (float)value; \r
1659                 }\r
1660         \r
1661                 public static float ToSingle (short value) \r
1662                 { \r
1663                         return (float)value; \r
1664                 }\r
1665 \r
1666                 public static float ToSingle (string value) \r
1667                 {\r
1668                         if (value == null)\r
1669                                 return 0.0f; // LAMESPEC: Spec says throw ArgumentNullException\r
1670                         return Single.Parse (value);\r
1671                 }\r
1672 \r
1673                 public static float ToSingle (string value, IFormatProvider provider) \r
1674                 {\r
1675                         if (value == null)\r
1676                                 return 0.0f; // LAMESPEC: Spec says throw ArgumentNullException\r
1677                         return Single.Parse (value, provider);\r
1678                 }              \r
1679 \r
1680                 [CLSCompliant (false)]\r
1681                 public static float ToSingle (uint value) \r
1682                 { \r
1683                         return (float)value; \r
1684                 }\r
1685 \r
1686                 [CLSCompliant (false)]\r
1687                 public static float ToSingle (ulong value) \r
1688                 { \r
1689                         return (float)value; \r
1690                 }\r
1691 \r
1692                 [CLSCompliant (false)]\r
1693                 public static float ToSingle (ushort value) \r
1694                 { \r
1695                         return (float)value; \r
1696                 }\r
1697 \r
1698                 public static float ToSingle (object value)\r
1699                 {\r
1700                         if (value == null)\r
1701                                 return 0.0f;\r
1702                         return ToSingle (value, null);\r
1703                 }\r
1704 \r
1705 //              [CLSCompliant (false)]\r
1706                 public static float ToSingle (object value, IFormatProvider provider)\r
1707                 {\r
1708                         if (value == null)\r
1709                                 return 0.0f;\r
1710                         return ((IConvertible) value).ToSingle (provider);\r
1711                 }\r
1712 \r
1713                 // ========== String Conversions ========== //\r
1714         \r
1715                 public static string ToString (bool value) \r
1716                 { \r
1717                         return value.ToString (); \r
1718                 }\r
1719 \r
1720                 public static string ToString (bool value, IFormatProvider provider)\r
1721                 {\r
1722                         return value.ToString (); // the same as ToString (bool).\r
1723                 }\r
1724         \r
1725                 public static string ToString (byte value) \r
1726                 { \r
1727                         return value.ToString (); \r
1728                 }\r
1729         \r
1730                 public static string ToString (byte value, IFormatProvider provider) \r
1731                 {\r
1732                         return value.ToString (provider); \r
1733                 }\r
1734 \r
1735                 public static string ToString (byte value, int toBase)\r
1736                 {
1737                         if (value == 0)
1738                                 return "0";\r
1739                         if (toBase == 10)
1740                                 return value.ToString ();\r
1741
1742                         byte[] val = BitConverter.GetBytes (value);
1743
1744                         switch (toBase) {
1745                         case 2:
1746                                 return ConvertToBase2 (val);
1747                         case 8:
1748                                 return ConvertToBase8 (val);
1749                         case 16:
1750                                 return ConvertToBase16 (val);
1751                         default:
1752                                 throw new ArgumentException (Locale.GetText ("toBase is not valid."));
1753                         }\r
1754                 }\r
1755 \r
1756                 public static string ToString (char value) \r
1757                 { \r
1758                         return value.ToString (); \r
1759                 }\r
1760 \r
1761                 public static string ToString (char value, IFormatProvider provider)\r
1762                 {\r
1763                         return value.ToString (); // the same as ToString (char)\r
1764                 }\r
1765 \r
1766                 public static string ToString (DateTime value) \r
1767                 { \r
1768                         return value.ToString (); \r
1769                 }\r
1770 \r
1771                 public static string ToString (DateTime value, IFormatProvider provider) \r
1772                 { \r
1773                         return value.ToString (provider); \r
1774                 }\r
1775 \r
1776                 public static string ToString (decimal value) \r
1777                 {\r
1778                         return value.ToString ();\r
1779                 }\r
1780 \r
1781                 public static string ToString (decimal value, IFormatProvider provider) \r
1782                 { \r
1783                         return value.ToString (provider); \r
1784                 }\r
1785         \r
1786                 public static string ToString (double value) \r
1787                 { \r
1788                         return value.ToString (); \r
1789                 }\r
1790 \r
1791                 public static string ToString (double value, IFormatProvider provider) \r
1792                 { \r
1793                         return value.ToString (provider);\r
1794                 }\r
1795         \r
1796                 public static string ToString (float value) \r
1797                 { \r
1798                         return value.ToString (); \r
1799                 }\r
1800 \r
1801                 public static string ToString (float value, IFormatProvider provider) \r
1802                 { \r
1803                         return value.ToString (provider); \r
1804                 }\r
1805 \r
1806                 public static string ToString (int value) \r
1807                 { \r
1808                         return value.ToString (); \r
1809                 }\r
1810 \r
1811                 public static string ToString (int value, int toBase)\r
1812                 {\r
1813                         if (value == 0)
1814                                 return "0";\r
1815                         if (toBase == 10)
1816                                 return value.ToString ();\r
1817
1818                         byte[] val = BitConverter.GetBytes (value);
1819
1820                         switch (toBase) {
1821                         case 2:
1822                                 return ConvertToBase2 (val);
1823                         case 8:
1824                                 return ConvertToBase8 (val);
1825                         case 16:
1826                                 return ConvertToBase16 (val);
1827                         default:
1828                                 throw new ArgumentException (Locale.GetText ("toBase is not valid."));
1829                         }\r
1830                 }\r
1831 \r
1832                 public static string ToString (int value, IFormatProvider provider) \r
1833                 { \r
1834                         return value.ToString (provider); \r
1835                 }\r
1836         \r
1837                 public static string ToString (long value) \r
1838                 { \r
1839                         return value.ToString (); \r
1840                 }\r
1841 \r
1842                 public static string ToString (long value, int toBase)\r
1843                 {\r
1844                         if (value == 0)
1845                                 return "0";\r
1846                         if (toBase == 10)
1847                                 return value.ToString ();\r
1848
1849                         byte[] val = BitConverter.GetBytes (value);
1850
1851                         switch (toBase) {
1852                         case 2:
1853                                 return ConvertToBase2 (val);
1854                         case 8:
1855                                 return ConvertToBase8 (val);
1856                         case 16:
1857                                 return ConvertToBase16 (val);
1858                         default:
1859                                 throw new ArgumentException (Locale.GetText ("toBase is not valid."));
1860                         }\r
1861                 }\r
1862 \r
1863                 public static string ToString (long value, IFormatProvider provider) \r
1864                 { \r
1865                         return value.ToString (provider); \r
1866                 }\r
1867 \r
1868                 public static string ToString (object value)\r
1869                 {\r
1870                         return ToString (value, null);\r
1871                 }               \r
1872 \r
1873                 public static string ToString (object value, IFormatProvider provider)\r
1874                 {\r
1875                         if (value is IConvertible)\r
1876                                 return ((IConvertible) value).ToString (provider);\r
1877                         else if (value != null)\r
1878                                 return value.ToString ();\r
1879                         return String.Empty;\r
1880                 }                               \r
1881 \r
1882                 [CLSCompliant (false)]\r
1883                 public static string ToString (sbyte value) \r
1884                 { \r
1885                         return value.ToString (); \r
1886                 }\r
1887 \r
1888                 [CLSCompliant (false)]                          \r
1889                 public static string ToString (sbyte value, IFormatProvider provider) \r
1890                 { \r
1891                         return value.ToString (provider); \r
1892                 }\r
1893         \r
1894                 public static string ToString (short value) \r
1895                 { \r
1896                         return value.ToString (); \r
1897                 }\r
1898 \r
1899                 public static string ToString (short value, int toBase)\r
1900                 {\r
1901                         if (value == 0)
1902                                 return "0";\r
1903                         if (toBase == 10)
1904                                 return value.ToString ();\r
1905
1906                         byte[] val = BitConverter.GetBytes (value);
1907
1908                         switch (toBase) {
1909                         case 2:
1910                                 return ConvertToBase2 (val);
1911                         case 8:
1912                                 return ConvertToBase8 (val);
1913                         case 16:
1914                                 return ConvertToBase16 (val);
1915                         default:
1916                                 throw new ArgumentException (Locale.GetText ("toBase is not valid."));
1917                         }\r
1918                 }\r
1919 \r
1920                 public static string ToString (short value, IFormatProvider provider) \r
1921                 { \r
1922                         return value.ToString (provider); \r
1923                 }\r
1924 \r
1925                 public static string ToString (string value) \r
1926                 {\r
1927                         return value;\r
1928                 }\r
1929 \r
1930                 public static string ToString (string value, IFormatProvider provider)\r
1931                 {\r
1932                         return value; // provider is ignored.\r
1933                 }\r
1934 \r
1935                 [CLSCompliant (false)]\r
1936                 public static string ToString (uint value) \r
1937                 { \r
1938                         return value.ToString (); \r
1939                 }\r
1940 \r
1941                 [CLSCompliant (false)]\r
1942                 public static string ToString (uint value, IFormatProvider provider) \r
1943                 { \r
1944                         return value.ToString (provider); \r
1945                 }\r
1946 \r
1947                 [CLSCompliant (false)]\r
1948                 public static string ToString (ulong value) \r
1949                 { \r
1950                         return value.ToString (); \r
1951                 }\r
1952 \r
1953                 [CLSCompliant (false)]\r
1954                 public static string ToString (ulong value, IFormatProvider provider) \r
1955                 { \r
1956                         return value.ToString (provider); \r
1957                 }\r
1958 \r
1959                 [CLSCompliant (false)]\r
1960                 public static string ToString (ushort value) \r
1961                 { \r
1962                         return value.ToString (); \r
1963                 }\r
1964 \r
1965                 [CLSCompliant (false)]\r
1966                 public static string ToString (ushort value, IFormatProvider provider) \r
1967                 { \r
1968                         return value.ToString (provider); \r
1969                 }\r
1970                 \r
1971                 // ========== UInt16 Conversions ========== //\r
1972 \r
1973                 [CLSCompliant (false)]\r
1974                 public static ushort ToUInt16 (bool value) \r
1975                 { \r
1976                         return (ushort)(value ? 1 : 0); \r
1977                 }\r
1978 \r
1979                 [CLSCompliant (false)]\r
1980                 public static ushort ToUInt16 (byte value) \r
1981                 { \r
1982                         return (ushort)value; \r
1983                 }\r
1984 \r
1985                 [CLSCompliant (false)]\r
1986                 public static ushort ToUInt16 (char value) \r
1987                 { \r
1988                         return (ushort)value; \r
1989                 }\r
1990 \r
1991                 [CLSCompliant (false)]\r
1992                 public static ushort ToUInt16 (DateTime value)\r
1993                 {\r
1994                         throw new InvalidCastException ("This conversion is not supported.");\r
1995                 }\r
1996 \r
1997                 [CLSCompliant (false)]\r
1998                 public static ushort ToUInt16 (decimal value) \r
1999                 { \r
2000                         if (value > UInt16.MaxValue || value < UInt16.MinValue) \r
2001                                 throw new OverflowException (Locale.GetText (\r
2002                                         "Value is greater than UInt16.MaxValue or less than UInt16.MinValue"));\r
2003           \r
2004                         // Returned Even-Rounded\r
2005                         return (ushort)(Math.Round (value));      \r
2006                 }\r
2007 \r
2008                 [CLSCompliant (false)]\r
2009                 public static ushort ToUInt16 (double value) \r
2010                 { \r
2011                         if (value > UInt16.MaxValue || value < UInt16.MinValue) \r
2012                                 throw new OverflowException (Locale.GetText (\r
2013                                         "Value is greater than UInt16.MaxValue or less than UInt16.MinValue"));\r
2014           \r
2015                         // Returned Even-Rounded\r
2016                         return (ushort)(Math.Round (value));\r
2017                 }\r
2018 \r
2019                 [CLSCompliant (false)]\r
2020                 public static ushort ToUInt16 (float value) \r
2021                 { \r
2022                         if (value > UInt16.MaxValue || value < UInt16.MinValue) \r
2023                                 throw new OverflowException (Locale.GetText (\r
2024                                         "Value is greater than UInt16.MaxValue or less than UInt16.MinValue"));\r
2025           \r
2026                         // Returned Even-Rounded, pass as double to Math\r
2027                         return (ushort)(Math.Round ( (double)value));\r
2028                 }\r
2029 \r
2030                 [CLSCompliant (false)]\r
2031                 public static ushort ToUInt16 (int value) \r
2032                 { \r
2033                         if (value > UInt16.MaxValue || value < UInt16.MinValue) \r
2034                                 throw new OverflowException (Locale.GetText (\r
2035                                         "Value is greater than UInt16.MaxValue or less than UInt16.MinValue"));\r
2036 \r
2037                         return (ushort)value; \r
2038                 }\r
2039 \r
2040                 [CLSCompliant (false)]\r
2041                 public static ushort ToUInt16 (long value) \r
2042                 { \r
2043                         if (value > UInt16.MaxValue || value < UInt16.MinValue) \r
2044                                 throw new OverflowException (Locale.GetText (\r
2045                                         "Value is greater than UInt16.MaxValue or less than UInt16.MinValue"));\r
2046 \r
2047                         return (ushort)value; \r
2048                 }\r
2049 \r
2050                 [CLSCompliant (false)]\r
2051                 public static ushort ToUInt16 (sbyte value) \r
2052                 { \r
2053                         if (value < UInt16.MinValue) \r
2054                                 throw new OverflowException (Locale.GetText (\r
2055                                         "Value is less than UInt16.MinValue"));\r
2056 \r
2057                         return (ushort)value; \r
2058                 }\r
2059 \r
2060                 [CLSCompliant (false)]\r
2061                 public static ushort ToUInt16 (short value) \r
2062                 { \r
2063                         if (value < UInt16.MinValue) \r
2064                                 throw new OverflowException (Locale.GetText (\r
2065                                         "Value is less than UInt16.MinValue"));\r
2066 \r
2067                         return (ushort)value; \r
2068                 }\r
2069                 \r
2070                 [CLSCompliant (false)]\r
2071                 public static ushort ToUInt16 (string value) \r
2072                 {\r
2073                         if (value == null)\r
2074                                 return 0; // LAMESPEC: Spec says throw ArgumentNullException\r
2075                         return UInt16.Parse (value);\r
2076                 }\r
2077 \r
2078                 [CLSCompliant (false)]\r
2079                 public static ushort ToUInt16 (string value, IFormatProvider provider) \r
2080                 {\r
2081                         if (value == null)\r
2082                                 return 0; // LAMESPEC: Spec says throw ArgumentNullException\r
2083                         return UInt16.Parse (value, provider);\r
2084                 }\r
2085 \r
2086                 [CLSCompliant (false)]\r
2087                 public static ushort ToUInt16 (string value, int fromBase) \r
2088                 {\r
2089                         return ToUInt16 (ConvertFromBase (value, fromBase, true));\r
2090                 } \r
2091 \r
2092                 [CLSCompliant (false)]\r
2093                 public static ushort ToUInt16 (uint value) \r
2094                 { \r
2095                         if (value > UInt16.MaxValue) \r
2096                                 throw new OverflowException (Locale.GetText (\r
2097                                         "Value is greater than UInt16.MaxValue"));\r
2098 \r
2099                         return (ushort)value; \r
2100                 }\r
2101 \r
2102                 [CLSCompliant (false)]\r
2103                 public static ushort ToUInt16 (ulong value) \r
2104                 { \r
2105                         if (value > (ulong)UInt16.MaxValue) \r
2106                                 throw new OverflowException (Locale.GetText (\r
2107                                         "Value is greater than UInt16.MaxValue"));\r
2108 \r
2109                         return (ushort)value; \r
2110                 }\r
2111 \r
2112                 [CLSCompliant (false)]\r
2113                 public static ushort ToUInt16 (ushort value) \r
2114                 { \r
2115                         return value; \r
2116                 }\r
2117 \r
2118                 [CLSCompliant (false)]\r
2119                 public static ushort ToUInt16 (object value)\r
2120                 {\r
2121                         if (value == null)\r
2122                                 return 0;\r
2123                         return ToUInt16 (value, null);\r
2124                 }\r
2125 \r
2126                 [CLSCompliant (false)]\r
2127                 public static ushort ToUInt16 (object value, IFormatProvider provider)\r
2128                 {\r
2129                         if (value == null)\r
2130                                 return 0;\r
2131                         return ((IConvertible) value).ToUInt16 (provider);\r
2132                 }\r
2133 \r
2134                 // ========== UInt32 Conversions ========== //\r
2135 \r
2136                 [CLSCompliant (false)]\r
2137                 public static uint ToUInt32 (bool value) \r
2138                 { \r
2139                         return (uint)(value ? 1 : 0); \r
2140                 }\r
2141 \r
2142                 [CLSCompliant (false)]\r
2143                 public static uint ToUInt32 (byte value) \r
2144                 { \r
2145                         return (uint)value; \r
2146                 }\r
2147 \r
2148                 [CLSCompliant (false)]\r
2149                 public static uint ToUInt32 (char value) \r
2150                 { \r
2151                         return (uint)value; \r
2152                 }\r
2153 \r
2154                 [CLSCompliant (false)]\r
2155                 public static uint ToUInt32 (DateTime value)\r
2156                 {\r
2157                         throw new InvalidCastException ("This conversion is not supported.");\r
2158                 }\r
2159                 \r
2160                 [CLSCompliant (false)]\r
2161                 public static uint ToUInt32 (decimal value) \r
2162                 { \r
2163                         if (value > UInt32.MaxValue || value < UInt32.MinValue) \r
2164                                 throw new OverflowException (Locale.GetText (\r
2165                                         "Value is greater than UInt32.MaxValue or less than UInt32.MinValue"));\r
2166           \r
2167                         // Returned Even-Rounded\r
2168                         return (uint)(Math.Round (value));        \r
2169                 }\r
2170 \r
2171                 [CLSCompliant (false)]\r
2172                 public static uint ToUInt32 (double value) \r
2173                 { \r
2174                         if (value > UInt32.MaxValue || value < UInt32.MinValue) \r
2175                                 throw new OverflowException (Locale.GetText (\r
2176                                         "Value is greater than UInt32.MaxValue or less than UInt32.MinValue"));\r
2177           \r
2178                         // Returned Even-Rounded\r
2179                         return (uint)(Math.Round (value));        \r
2180                 }\r
2181 \r
2182                 [CLSCompliant (false)]\r
2183                 public static uint ToUInt32 (float value) \r
2184                 { \r
2185                         if (value > UInt32.MaxValue || value < UInt32.MinValue) \r
2186                                 throw new OverflowException (Locale.GetText (\r
2187                                         "Value is greater than UInt32.MaxValue or less than UInt32.MinValue"));\r
2188           \r
2189                         // Returned Even-Rounded, pass as double to Math\r
2190                         return (uint)(Math.Round ( (double)value));\r
2191                 }\r
2192 \r
2193                 [CLSCompliant (false)]\r
2194                 public static uint ToUInt32 (int value) \r
2195                 { \r
2196                         if (value < UInt32.MinValue) \r
2197                                 throw new OverflowException (Locale.GetText (\r
2198                                         "Value is less than UInt32.MinValue"));\r
2199 \r
2200                         return (uint)value; \r
2201                 }\r
2202 \r
2203                 [CLSCompliant (false)]\r
2204                 public static uint ToUInt32 (long value) \r
2205                 { \r
2206                         if (value > UInt32.MaxValue || value < UInt32.MinValue) \r
2207                                 throw new OverflowException (Locale.GetText (\r
2208                                         "Value is greater than UInt32.MaxValue or less than UInt32.MinValue"));\r
2209 \r
2210                         return (uint)value; \r
2211                 }\r
2212 \r
2213                 [CLSCompliant (false)]\r
2214                 public static uint ToUInt32 (sbyte value) \r
2215                 { \r
2216                         if (value < UInt32.MinValue) \r
2217                                 throw new OverflowException (Locale.GetText (\r
2218                                         "Value is less than UInt32.MinValue"));\r
2219 \r
2220                         return (uint)value; \r
2221                 }\r
2222 \r
2223                 [CLSCompliant (false)]\r
2224                 public static uint ToUInt32 (short value) \r
2225                 { \r
2226                         if (value < UInt32.MinValue) \r
2227                                 throw new OverflowException (Locale.GetText (\r
2228                                         "Value is less than UInt32.MinValue"));\r
2229 \r
2230                         return (uint)value; \r
2231                 }\r
2232 \r
2233                 [CLSCompliant (false)]\r
2234                 public static uint ToUInt32 (string value) \r
2235                 {\r
2236                         if (value == null)\r
2237                                 return 0; // LAMESPEC: Spec says throw ArgumentNullException\r
2238                         return UInt32.Parse (value);\r
2239                 }\r
2240 \r
2241                 [CLSCompliant (false)]\r
2242                 public static uint ToUInt32 (string value, IFormatProvider provider) \r
2243                 {\r
2244                         if (value == null)\r
2245                                 return 0; // LAMESPEC: Spec says throw ArgumentNullException\r
2246                         return UInt32.Parse (value, provider);\r
2247                 }\r
2248 \r
2249                 [CLSCompliant (false)]\r
2250                 public static uint ToUInt32 (string value, int fromBase)\r
2251                 {\r
2252                         return (uint) ConvertFromBase (value, fromBase, true);\r
2253                 }\r
2254 \r
2255                 [CLSCompliant (false)]\r
2256                 public static uint ToUInt32 (uint value) \r
2257                 { \r
2258                         return value; \r
2259                 }\r
2260 \r
2261                 [CLSCompliant (false)]\r
2262                 public static uint ToUInt32 (ulong value) \r
2263                 { \r
2264                         if (value > UInt32.MaxValue) \r
2265                                 throw new OverflowException (Locale.GetText (\r
2266                                         "Value is greater than UInt32.MaxValue"));\r
2267 \r
2268                         return (uint)value; \r
2269                 }\r
2270 \r
2271                 [CLSCompliant (false)]\r
2272                 public static uint ToUInt32 (ushort value) \r
2273                 { \r
2274                         return (uint)value; \r
2275                 }\r
2276 \r
2277                 [CLSCompliant (false)]\r
2278                 public static uint ToUInt32 (object value)\r
2279                 {\r
2280                         if (value == null)\r
2281                                 return 0;\r
2282                         return ToUInt32 (value, null);\r
2283                 }               \r
2284 \r
2285                 [CLSCompliant (false)]\r
2286                 public static uint ToUInt32 (object value, IFormatProvider provider)\r
2287                 {\r
2288                         if (value == null)\r
2289                                 return 0;\r
2290                         return ((IConvertible) value).ToUInt32 (provider);\r
2291                 }               \r
2292                 \r
2293 \r
2294                 // ========== UInt64 Conversions ========== //\r
2295 \r
2296                 [CLSCompliant (false)]\r
2297                 public static ulong ToUInt64 (bool value) \r
2298                 { \r
2299                         return (ulong)(value ? 1 : 0); \r
2300                 }\r
2301 \r
2302                 [CLSCompliant (false)]\r
2303                 public static ulong ToUInt64 (byte value) \r
2304                 { \r
2305                         return (ulong)value; \r
2306                 }\r
2307 \r
2308                 [CLSCompliant (false)]\r
2309                 public static ulong ToUInt64 (char value) \r
2310                 { \r
2311                         return (ulong)value; \r
2312                 }\r
2313 \r
2314                 [CLSCompliant (false)]\r
2315                 public static ulong ToUInt64 (DateTime value)\r
2316                 {\r
2317                         throw new InvalidCastException ("The conversion is not supported.");\r
2318                 }\r
2319 \r
2320                 [CLSCompliant (false)]\r
2321                 public static ulong ToUInt64 (decimal value) \r
2322                 { \r
2323                         if (value > UInt64.MaxValue || value < UInt64.MinValue) \r
2324                                 throw new OverflowException (Locale.GetText (\r
2325                                         "Value is greater than UInt64.MaxValue or less than UInt64.MinValue"));\r
2326           \r
2327                         // Returned Even-Rounded\r
2328                         return (ulong)(Math.Round (value));       \r
2329                 }\r
2330 \r
2331                 [CLSCompliant (false)]\r
2332                 public static ulong ToUInt64 (double value) \r
2333                 { \r
2334                         if (value > UInt64.MaxValue || value < UInt64.MinValue) \r
2335                                 throw new OverflowException (Locale.GetText (\r
2336                                         "Value is greater than UInt64.MaxValue or less than UInt64.MinValue"));\r
2337           \r
2338                         // Returned Even-Rounded\r
2339                         return (ulong)(Math.Round (value));       \r
2340                 }\r
2341                 \r
2342                 [CLSCompliant (false)] \r
2343                 public static ulong ToUInt64 (float value) \r
2344                 { \r
2345                         if (value > UInt64.MaxValue || value < UInt64.MinValue) \r
2346                                 throw new OverflowException (Locale.GetText (\r
2347                                         "Value is greater than UInt64.MaxValue or less than UInt64.MinValue"));\r
2348           \r
2349                         // Returned Even-Rounded, pass as a double to Math\r
2350                         return (ulong)(Math.Round ( (double)value));\r
2351                 }\r
2352                 \r
2353                 [CLSCompliant (false)]\r
2354                 public static ulong ToUInt64 (int value) \r
2355                 { \r
2356                         if (value < (int)UInt64.MinValue) \r
2357                                 throw new OverflowException (Locale.GetText (\r
2358                                         "Value is less than UInt64.MinValue"));\r
2359 \r
2360                         return (ulong)value; \r
2361                 }\r
2362                 \r
2363                 [CLSCompliant (false)]\r
2364                 public static ulong ToUInt64 (long value) \r
2365                 { \r
2366                         if (value < (long)UInt64.MinValue) \r
2367                                 throw new OverflowException (Locale.GetText (\r
2368                                         "Value is less than UInt64.MinValue"));\r
2369 \r
2370                         return (ulong)value; \r
2371                 }\r
2372 \r
2373                 [CLSCompliant (false)]\r
2374                 public static ulong ToUInt64 (sbyte value) \r
2375                 { \r
2376                         if (value < (sbyte)UInt64.MinValue) \r
2377                                 throw new OverflowException\r
2378                                 ("Value is less than UInt64.MinValue");\r
2379 \r
2380                         return (ulong)value; \r
2381                 }\r
2382                 \r
2383                 [CLSCompliant (false)]  \r
2384                 public static ulong ToUInt64 (short value) \r
2385                 { \r
2386                         if (value < (short)UInt64.MinValue) \r
2387                                 throw new OverflowException (Locale.GetText (\r
2388                                         "Value is less than UInt64.MinValue"));\r
2389 \r
2390                         return (ulong)value; \r
2391                 }\r
2392 \r
2393                 [CLSCompliant (false)]\r
2394                 public static ulong ToUInt64 (string value) \r
2395                 {\r
2396                         if (value == null)\r
2397                                 return 0; // LAMESPEC: Spec says throw ArgumentNullException\r
2398                         return UInt64.Parse (value);\r
2399                 }\r
2400 \r
2401                 [CLSCompliant (false)]\r
2402                 public static ulong ToUInt64 (string value, IFormatProvider provider) \r
2403                 {\r
2404                         if (value == null)\r
2405                                 return 0; // LAMESPEC: Spec says throw ArgumentNullException\r
2406                         return UInt64.Parse (value, provider);\r
2407                 }\r
2408 \r
2409                 [CLSCompliant (false)]\r
2410                 public static ulong ToUInt64 (string value, int fromBase)\r
2411                 {\r
2412                         return (ulong) ConvertFromBase (value, fromBase, true);\r
2413                 }                                             \r
2414 \r
2415                 [CLSCompliant (false)]\r
2416                 public static ulong ToUInt64 (uint value) \r
2417                 { \r
2418                         return (ulong)value; \r
2419                 }\r
2420 \r
2421                 [CLSCompliant (false)]\r
2422                 public static ulong ToUInt64 (ulong value) \r
2423                 { \r
2424                         return value; \r
2425                 }\r
2426                 \r
2427                 [CLSCompliant (false)]\r
2428                 public static ulong ToUInt64 (ushort value) \r
2429                 { \r
2430                         return (ulong)value; \r
2431                 }\r
2432 \r
2433                 [CLSCompliant (false)]\r
2434                 public static ulong ToUInt64 (object value)\r
2435                 {\r
2436                         if (value == null)\r
2437                                 return 0;\r
2438                         return ToUInt64 (value, null);\r
2439                 }               \r
2440 \r
2441                 [CLSCompliant (false)]\r
2442                 public static ulong ToUInt64 (object value, IFormatProvider provider)\r
2443                 {\r
2444                         if (value == null)\r
2445                                 return 0;\r
2446                         return ((IConvertible) value).ToUInt64 (provider);\r
2447                 }               \r
2448                 \r
2449 \r
2450                 // ========== Conversion / Helper Functions ========== //\r
2451 \r
2452                 public static object ChangeType (object value, Type conversionType)\r
2453                 {
2454                         if ((value != null) && (conversionType == null))
2455                                 throw new ArgumentNullException ("conversionType");\r
2456                         CultureInfo ci = CultureInfo.CurrentCulture;\r
2457                         NumberFormatInfo number = ci.NumberFormat;\r
2458                         return ToType (value, conversionType, number);\r
2459                 }\r
2460                 \r
2461                 public static object ChangeType (object value, TypeCode typeCode)\r
2462                 {\r
2463                         CultureInfo ci = CultureInfo.CurrentCulture;\r
2464                         Type conversionType = conversionTable [(int) typeCode];\r
2465                         NumberFormatInfo number = ci.NumberFormat;\r
2466                         return ToType (value, conversionType, number);\r
2467                 }\r
2468 \r
2469                 public static object ChangeType (object value, Type conversionType, IFormatProvider provider)\r
2470                 {\r
2471                         if ((value != null) && (conversionType == null))
2472                                 throw new ArgumentNullException ("conversionType");\r
2473                         return ToType (value, conversionType, provider);\r
2474                 }\r
2475                 \r
2476                 public static object ChangeType (object value, TypeCode typeCode, IFormatProvider provider)\r
2477                 {\r
2478                         Type conversionType = conversionTable [(int)typeCode];\r
2479                         return ToType (value, conversionType, provider);\r
2480                 }\r
2481 \r
2482                 private static bool NotValidBase (int value)\r
2483                 {\r
2484                         if ((value == 2) || (value == 8) ||\r
2485                            (value == 10) || (value == 16))\r
2486                                 return false;\r
2487                         \r
2488                         return true;\r
2489                 }\r
2490 \r
2491                 private static int ConvertFromBase (string value, int fromBase, bool unsigned)\r
2492                 {\r
2493                         if (NotValidBase (fromBase))\r
2494                                 throw new ArgumentException ("fromBase is not valid.");\r
2495                         if (value == null)\r
2496                                 return 0;\r
2497 \r
2498                         int chars = 0;\r
2499                         int result = 0;\r
2500                         int digitValue;\r
2501 \r
2502                         int i=0; \r
2503                         int len = value.Length;\r
2504                         bool negative = false;\r
2505 \r
2506                         // special processing for some bases
2507                         switch (fromBase) {
2508                         case 10:\r
2509                                 if (value[i] == '-') {
2510                                         if (unsigned) {
2511                                                 throw new OverflowException (
2512                                                         Locale.GetText ("Cannot convert negative to unsigned"));
2513                                         }\r
2514                                         negative = true;\r
2515                                         i++;\r
2516                                 }
2517                                 break;
2518                         case 16:
2519                                 if (len >= i+2) {
2520                                         // 0x00 or 0X00
2521                                         if ((value[i] == '0') && ((value [i+1] == 'x') || (value [i+1] == 'X'))) {
2522                                                 i+=2;
2523                                         }
2524                                         if (len == i) {
2525                                                 throw new FormatException (
2526                                                         Locale.GetText ("Missing number after prefix"));
2527                                         }
2528                                 }
2529                                 break;\r
2530                         }
2531 \r
2532                         if (value[i] == '+') {\r
2533                                 i++;\r
2534                         }\r
2535 \r
2536                         while(i<len) {\r
2537                                 char c = value[i++];\r
2538                                 if (Char.IsNumber (c))\r
2539                                         digitValue = c - '0';\r
2540                                 else if (Char.IsLetter (c))\r
2541                                         digitValue = Char.ToLowerInvariant (c) - 'a' + 10;\r
2542                                 else if (c == '-')
2543                                         throw new ArgumentException ("Negative are valid only for base 10");
2544                                 else\r
2545                                         throw new FormatException ("This is an invalid string: " + value);\r
2546 \r
2547                                 if (digitValue >= fromBase)\r
2548                                         throw new FormatException ("the digits are invalid.");\r
2549 \r
2550                                 result = (fromBase) * result + digitValue;\r
2551                                 chars ++;\r
2552                         }\r
2553 \r
2554 \r
2555                         if (chars == 0)\r
2556                                 throw new FormatException ("Could not find any digits.");\r
2557 \r
2558                         if (result > Int32.MaxValue || result < Int32.MinValue)\r
2559                                 throw new OverflowException ("There is an overflow.");\r
2560                         \r
2561                         if (negative)
2562                                 return -result;\r
2563                         else\r
2564                                 return result;
2565                 }\r
2566
2567                 // note: this has nothing to do with base64 encoding (just base and Int64)\r
2568                 private static long ConvertFromBase64 (string value, int fromBase, bool unsigned)\r
2569                 {\r
2570                         if (NotValidBase (fromBase))\r
2571                                 throw new ArgumentException ("fromBase is not valid.");\r
2572                         if (value == null)\r
2573                                 return 0;\r
2574 \r
2575                         int chars = 0;\r
2576                         int digitValue = -1;
2577                         uint Base = (uint) fromBase;\r
2578                         ulong result = 0;
2579                         bool negative = false;\r
2580 \r
2581                         foreach (char c in value) {\r
2582                                 if (Char.IsNumber (c))\r
2583                                         digitValue = c - '0';\r
2584                                 else if (Char.IsLetter (c))\r
2585                                         digitValue = Char.ToLowerInvariant (c) - 'a' + 10;
2586                                 else if ((c == '-') && (!unsigned)) {
2587                                         if (fromBase != 10)
2588                                                 throw new ArgumentException ("Negative are valid only for base 10");
2589                                         negative = true;
2590                                         continue;
2591                                 }\r
2592                                 else\r
2593                                         throw new FormatException ("This is an invalid string: " + value);\r
2594 \r
2595                                 if (digitValue >= fromBase)\r
2596                                         throw new FormatException ("the digits are invalid.");\r
2597 \r
2598                                 result = (ulong) (Base * result + (uint)digitValue);\r
2599                                 chars ++;\r
2600                         }\r
2601 \r
2602                         if (chars == 0)\r
2603                                 throw new FormatException ("Could not find any digits.");\r
2604
2605                         if (negative)
2606                                 return -1 * (long) result;
2607                         else\r
2608                                 return (long) result;\r
2609                 }\r
2610
2611                 private static void EndianSwap (ref byte[] value)
2612                 {
2613                         byte[] buf = new byte[value.Length];
2614                         for (int i = 0; i < value.Length; i++)
2615                                 buf[i] = value[value.Length-1-i];
2616                         value = buf;
2617                 }
2618
2619                 private static string ConvertToBase2 (byte[] value)
2620                 {
2621                         if (!BitConverter.IsLittleEndian)
2622                                 EndianSwap (ref value);
2623                         StringBuilder sb = new StringBuilder ();
2624                         for (int i = value.Length - 1; i >= 0; i--) {
2625                                 byte b = value [i];
2626                                 for (int j = 0; j < 8; j++) {
2627                                         if ((b & 0x80) == 0x80) {
2628                                                 sb.Append ('1');
2629                                         }
2630                                         else {
2631                                                 if (sb.Length > 0)
2632                                                         sb.Append ('0');
2633                                         }
2634                                         b <<= 1;
2635                                 }
2636                         }
2637                         return sb.ToString ();
2638                 }\r
2639 \r
2640                 private static string ConvertToBase8 (byte[] value)\r
2641                 {
2642                         if (!BitConverter.IsLittleEndian)
2643                                 EndianSwap (ref value);
2644                         ulong l = 0;
2645                         switch (value.Length) {
2646                         case 1:
2647                                 l = (ulong) value [0];
2648                                 break;
2649                         case 2:
2650                                 l = (ulong) BitConverter.ToUInt16 (value, 0);
2651                                 break;
2652                         case 4:
2653                                 l = (ulong) BitConverter.ToUInt32 (value, 0);
2654                                 break;
2655                         case 8:
2656                                 l = BitConverter.ToUInt64 (value, 0);
2657                                 break;
2658                         default:
2659                                 throw new ArgumentException ("value");
2660                         }
2661
2662                         StringBuilder sb = new StringBuilder ();
2663                         for (int i = 21; i >= 0; i--) {
2664                                 // 3 bits at the time
2665                                 char val = (char) ((l >> i * 3) & 0x7);
2666                                 if ((val != 0) || (sb.Length > 0)) {
2667                                         val += '0';
2668                                         sb.Append (val);
2669                                 }
2670                         }
2671                         return sb.ToString ();
2672                 }
2673
2674                 private static string ConvertToBase16 (byte[] value)
2675                 {
2676                         if (!BitConverter.IsLittleEndian)
2677                                 EndianSwap (ref value);
2678                         StringBuilder sb = new StringBuilder ();
2679                         for (int i = value.Length - 1; i >= 0; i--) {
2680                                 char high = (char)((value[i] >> 4) & 0x0f);
2681                                 if ((high != 0) || (sb.Length > 0)) {
2682                                         if (high < 10)
2683                                                 high += '0';
2684                                         else {
2685                                                 high -= (char) 10;
2686                                                 high += 'a';
2687                                         }
2688                                         sb.Append (high);
2689                                 }
2690
2691                                 char low = (char)(value[i] & 0x0f);
2692                                 if ((low != 0) || (sb.Length > 0)) {
2693                                         if (low < 10)
2694                                                 low += '0';
2695                                         else {
2696                                                 low -= (char) 10;
2697                                                 low += 'a';
2698                                         }
2699                                         sb.Append (low);
2700                                 }
2701                         }
2702                         return sb.ToString ();
2703                 }\r
2704
2705                 // Lookup table for the conversion ToType method. Order\r
2706                 // is important! Used by ToType for comparing the target\r
2707                 // type, and uses hardcoded array indexes.\r
2708                 private static readonly Type[] conversionTable = {\r
2709                         // Valid ICovnertible Types\r
2710                         null,               //  0 empty\r
2711                         typeof (object),   //  1 TypeCode.Object\r
2712                         typeof (DBNull),   //  2 TypeCode.DBNull\r
2713                         typeof (Boolean),  //  3 TypeCode.Boolean\r
2714                         typeof (Char),     //  4 TypeCode.Char\r
2715                         typeof (SByte),    //  5 TypeCode.SByte\r
2716                         typeof (Byte),     //  6 TypeCode.Byte\r
2717                         typeof (Int16),    //  7 TypeCode.Int16\r
2718                         typeof (UInt16),   //  8 TypeCode.UInt16\r
2719                         typeof (Int32),    //  9 TypeCode.Int32\r
2720                         typeof (UInt32),   // 10 TypeCode.UInt32\r
2721                         typeof (Int64),    // 11 TypeCode.Int64\r
2722                         typeof (UInt64),   // 12 TypeCode.UInt64\r
2723                         typeof (Single),   // 13 TypeCode.Single\r
2724                         typeof (Double),   // 14 TypeCode.Double\r
2725                         typeof (Decimal),  // 15 TypeCode.Decimal\r
2726                         typeof (DateTime), // 16 TypeCode.DateTime\r
2727                         null,               // 17 null.\r
2728                         typeof (String),   // 18 TypeCode.String\r
2729                 };\r
2730 \r
2731                 // Function to convert an object to another type and return\r
2732                 // it as an object. In place for the core data types to use\r
2733                 // when implementing IConvertible. Uses hardcoded indexes in \r
2734                 // the conversionTypes array, so if modify carefully.\r
2735                 internal static object ToType (object value, Type conversionType, \r
2736                                                IFormatProvider provider) \r
2737                 {
2738                         if (value == null) {
2739                                 if ((conversionType != null) && conversionType.IsValueType){
2740 #if NET_2_0
2741                                         throw new InvalidCastException ("Null object can not be converted to a value type.");
2742 #else
2743                                         //
2744                                         // Bug compatibility with 1.0
2745                                         //
2746                                         throw new NullReferenceException ("Null object can not be converted to a value type.");
2747 #endif
2748                                 } else
2749                                         return null;
2750                         }
2751 \r
2752                         if (conversionType == null)\r
2753                                 throw new InvalidCastException ("Cannot cast to destination type.");\r
2754 \r
2755                         if (value.GetType () == conversionType)\r
2756                                 return value;\r
2757                         \r
2758                         if (value is IConvertible) {\r
2759                                 IConvertible convertValue = (IConvertible) value;\r
2760 \r
2761                                 if (conversionType == conversionTable[0]) // 0 Empty\r
2762                                         throw new ArgumentNullException ();\r
2763                                 \r
2764                                 else if (conversionType == conversionTable[1]) // 1 TypeCode.Object\r
2765                                         return (object) value;\r
2766                                         \r
2767                                 else if (conversionType == conversionTable[2]) // 2 TypeCode.DBNull\r
2768                                         throw new InvalidCastException (\r
2769                                                 "Cannot cast to DBNull, it's not IConvertible");\r
2770                   \r
2771                                 else if (conversionType == conversionTable[3]) // 3 TypeCode.Boolean\r
2772                                         return (object) convertValue.ToBoolean (provider);\r
2773                                         \r
2774                                 else if (conversionType == conversionTable[4]) // 4 TypeCode.Char\r
2775                                         return (object) convertValue.ToChar (provider);\r
2776                   \r
2777                                 else if (conversionType == conversionTable[5]) // 5 TypeCode.SByte\r
2778                                         return (object) convertValue.ToSByte (provider);\r
2779 \r
2780                                 else if (conversionType == conversionTable[6]) // 6 TypeCode.Byte\r
2781                                         return (object) convertValue.ToByte (provider);\r
2782                                 \r
2783                                 else if (conversionType == conversionTable[7]) // 7 TypeCode.Int16\r
2784                                         return (object) convertValue.ToInt16 (provider);\r
2785                                         \r
2786                                 else if (conversionType == conversionTable[8]) // 8 TypeCode.UInt16\r
2787                                         return (object) convertValue.ToUInt16 (provider);\r
2788                   \r
2789                                 else if (conversionType == conversionTable[9]) // 9 TypeCode.Int32\r
2790                                         return (object) convertValue.ToInt32 (provider);\r
2791                         \r
2792                                 else if (conversionType == conversionTable[10]) // 10 TypeCode.UInt32\r
2793                                         return (object) convertValue.ToUInt32 (provider);\r
2794                   \r
2795                                 else if (conversionType == conversionTable[11]) // 11 TypeCode.Int64\r
2796                                         return (object) convertValue.ToInt64 (provider);\r
2797                   \r
2798                                 else if (conversionType == conversionTable[12]) // 12 TypeCode.UInt64\r
2799                                         return (object) convertValue.ToUInt64 (provider);\r
2800                   \r
2801                                 else if (conversionType == conversionTable[13]) // 13 TypeCode.Single\r
2802                                         return (object) convertValue.ToSingle (provider);\r
2803                   \r
2804                                 else if (conversionType == conversionTable[14]) // 14 TypeCode.Double\r
2805                                         return (object) convertValue.ToDouble (provider);\r
2806 \r
2807                                 else if (conversionType == conversionTable[15]) // 15 TypeCode.Decimal\r
2808                                         return (object) convertValue.ToDecimal (provider);\r
2809 \r
2810                                 else if (conversionType == conversionTable[16]) // 16 TypeCode.DateTime\r
2811                                         return (object) convertValue.ToDateTime (provider);\r
2812                                 \r
2813                                 else if (conversionType == conversionTable[18]) // 18 TypeCode.String\r
2814                                         return (object) convertValue.ToString (provider);\r
2815                                 else {\r
2816                                         throw new InvalidCastException (Locale.GetText ("Unknown target conversion type"));\r
2817                                 }\r
2818                         } else\r
2819                                 // Not in the conversion table\r
2820                                 throw new InvalidCastException ((Locale.GetText (\r
2821                                         "Value is not a convertible object: " + value.GetType().ToString() + " to " + conversionType.FullName)));\r
2822                 }\r
2823         }\r
2824 }\r