mcs/class/corlib/System/Convert.cs

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