mcs/class/corlib/System/Convert.cs

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