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 //\r
   7 // (C) Ximian, Inc.  http://www.ximian.com\r
   8 //\r
   9 \r
  10 //\r
  11 // System.Convert class. This was written word for word off the \r
  12 // Library specification for System.Convert in the ECMA TC39 TG2 \r
  13 // and TG3 working documents. The first page of which has a table\r
  14 // for all legal conversion scenerios.\r
  15 //\r
  16 // This header and the one above it can be formatted however, just trying\r
  17 // to keep it consistent w/ the existing mcs headers.\r
  18 //\r
  19 // This Convert class could be written another way, with each type \r
  20 // implementing IConvertible and defining their own conversion functions,\r
  21 // and this class just calling the type's implementation. Or, they can \r
  22 // be defined here and the implementing type can use these functions when \r
  23 // defining their IConvertible interface. Byte's ToBoolean() calls \r
  24 // Convert.ToBoolean(byte), or Convert.ToBoolean(byte) calls \r
  25 // byte.ToBoolean(). The first case is what is done here.\r
  26 //\r
  27 // See http://lists.ximian.com/archives/public/mono-list/2001-July/000525.html\r
  28 //\r
  29 // There are also conversion functions that are not defined in\r
  30 // the ECMA draft, such as there is no bool ToBoolean(DateTime value), \r
  31 // and placing that somewhere won't compile w/ this Convert since the\r
  32 // function doesn't exist. However calling that when using Microsoft's\r
  33 // System.Convert doesn't produce any compiler errors, it just throws\r
  34 // an InvalidCastException at runtime.\r
  35 //\r
  36 // Whenever a decimal, double, or single is converted to an integer\r
  37 // based type, it is even rounded. This uses Math.Round which only \r
  38 // has Round(decimal) and Round(double), so in the Convert from \r
  39 // single cases the value is passed to Math as a double. This \r
  40 // may not be completely necessary.\r
  41 //\r
  42 // The .NET Framework SDK lists DBNull as a member of this class\r
  43 // as 'public static readonly object DBNull;'. \r
  44 //\r
  45 // It should also be decided if all the cast return values should be\r
  46 // returned as unchecked or not.\r
  47 //\r
  48 // All the XML function comments were auto generated which is why they\r
  49 // sound someone redundant.\r
  50 //\r
  51 // TYPE | BOOL BYTE CHAR DT DEC DBL I16 I32 I64 SBYT SNGL STR UI16 UI32 UI64\r
  52 // -----+--------------------------------------------------------------------\r
  53 // BOOL |   X    X           X   X   X   X   X    X    X   X    X    X    X\r
  54 // BYTE |   X    X    X      X   X   X   X   X    X    X   X    X    X    X\r
  55 // CHAR |        X    X              X   X   X    X        X    X    X    X\r
  56 // DT   |                 X                                X\r
  57 // DEC  |   X    X           X   X   X   X   X    X    X   X    X    X    X\r
  58 // DBL  |   X    X           X   X   X   X   X    X    X   X    X    X    X\r
  59 // I16  |   X    X    X      X   X   X   X   X    X    X   X    X    X    X\r
  60 // I32  |   X    X    X      X   X   X   X   X    X    X   X    X    X    X\r
  61 // I64  |   X    X    X      X   X   X   X   X    X    X   X    X    X    X\r
  62 // SBYT |   X    X    X      X   X   X   X   X    X    X   X    X    X    X\r
  63 // SNGL |   X    X           X   X   X   X   X    X    X   X    X    X    X\r
  64 // STR  |   X    X    X   X  X   X   X   X   X    X    X   X    X    X    X\r
  65 // UI16 |   X    X    X      X   X   X   X   X    X    X   X    X    X    X\r
  66 // UI32 |   X    X    X      X   X   X   X   X    X    X   X    X    X    X\r
  67 // UI64 |   X    X    X      X   X   X   X   X    X    X   X    X    X    X\r
  68 //\r
  69 \r
  70 using System.Security.Cryptography;\r
  71 \r
  72 namespace System {\r
  73   \r
  74         public sealed class Convert {\r
  75         \r
  76                 // ========== BASE 64 Conversions ========== //\r
  77                 // the BASE64 convert methods are using the Base64 converting methods\r
  78                 // from System.Security.Cryptography.ToBase64Transform and\r
  79                 // System.Security.Cryptography.FromBase64Transform\r
  80                 //\r
  81                 // should be changed to a stand-alone class Base64Encoder & Base64Decoder\r
  82                 \r
  83                 public static byte[] FromBase64CharArray(char[] inArray, int offset, int length)\r
  84                 {\r
  85                         if (inArray == null)\r
  86                                 throw new ArgumentNullException();\r
  87                         \r
  88                         int len = inArray.Length;\r
  89                         if (len < 4 || len % 4 != 0)\r
  90                                 throw new FormatException();\r
  91                                 \r
  92                         byte[] inArr = new System.Text.UnicodeEncoding().GetBytes(inArray);\r
  93                         FromBase64Transform t = new FromBase64Transform();\r
  94                         \r
  95                         return t.TransformFinalBlock(inArr, 0, inArr.Length);\r
  96                 }\r
  97                 \r
  98                 public static byte[] FromBase64String(string s)\r
  99                 {\r
 100                         if (s == null)\r
 101                                 throw new ArgumentNullException();\r
 102                         \r
 103                         char[] inArr = s.ToCharArray();\r
 104 \r
 105                         return FromBase64CharArray(inArr, 0, inArr.Length);\r
 106                 }\r
 107                 \r
 108                 public static int ToBase64CharArray(byte[] inArray, int offsetIn, int length, \r
 109                                                     char[] outArray, int offsetOut)\r
 110                 {\r
 111                         if (inArray == null || outArray == null)\r
 112                                 throw new ArgumentNullException();\r
 113                         \r
 114                         if (offsetIn < 0 || length < 0 || offsetOut < 0 || (offsetIn + length) > inArray.Length)\r
 115                                 throw new ArgumentOutOfRangeException();\r
 116                         \r
 117                         ToBase64Transform t = new ToBase64Transform();\r
 118                         byte[] outArr = t.TransformFinalBlock(inArray, offsetIn, length);\r
 119                         \r
 120                         char[] cOutArr = new System.Text.ASCIIEncoding().GetChars(outArr);\r
 121                         \r
 122                         if ((offsetOut + cOutArr.Length) > outArray.Length)\r
 123                                 throw new ArgumentOutOfRangeException();\r
 124                         \r
 125                         Array.Copy(cOutArr, 0, outArray, offsetOut, cOutArr.Length);\r
 126                         \r
 127                         return cOutArr.Length;\r
 128                 }\r
 129                 \r
 130                 public static string ToBase64String(byte[] inArray)\r
 131                 {\r
 132                         if (inArray == null)\r
 133                                 throw new ArgumentNullException();\r
 134 \r
 135                         return ToBase64String(inArray, 0, inArray.Length);\r
 136                 }\r
 137                 \r
 138                 public static string ToBase64String(byte[] inArray, int offset, int length)\r
 139                 {\r
 140                         if (inArray == null)\r
 141                                 throw new ArgumentNullException();\r
 142                         \r
 143                         if (offset < 0 || length < 0 || (offset + length) > inArray.Length)\r
 144                                 throw new ArgumentOutOfRangeException();\r
 145                         \r
 146                         // FIXME: change to stand alone Base64 Encoder class\r
 147                         ToBase64Transform t = new ToBase64Transform();\r
 148                         byte[] outArr = t.TransformFinalBlock(inArray, offset, length);\r
 149                         \r
 150                         return (new System.Text.ASCIIEncoding().GetString(outArr));\r
 151                 }\r
 152                 \r
 153                 // ========== Boolean Conversions ========== //\r
 154         \r
 155                 public static bool ToBoolean (bool value) \r
 156                 { \r
 157                         return value; \r
 158                 }\r
 159 \r
 160                 public static bool ToBoolean (byte value) \r
 161                 { \r
 162                         return (value != 0); \r
 163                 }\r
 164 \r
 165                 public static bool ToBoolean (decimal value) \r
 166                 { \r
 167                         return (value != 0M); \r
 168                 }\r
 169 \r
 170                 public static bool ToBoolean (double value) \r
 171                 { \r
 172                         return (value != 0); \r
 173                 }\r
 174 \r
 175                 public static bool ToBoolean (float value) \r
 176                 { \r
 177                         return (value != 0f); \r
 178                 }\r
 179 \r
 180                 public static bool ToBoolean (int value) \r
 181                 { \r
 182                         return (value != 0); \r
 183                 }\r
 184 \r
 185                 public static bool ToBoolean (long value) \r
 186                 { \r
 187                         return (value != 0); \r
 188                 }\r
 189 \r
 190                 public static bool ToBoolean (sbyte value) \r
 191                 { \r
 192                         return (value != 0); \r
 193                 }\r
 194         \r
 195                 public static bool ToBoolean (short value) \r
 196                 { \r
 197                         return (value != 0); \r
 198                 }\r
 199 \r
 200                 public static bool ToBoolean (string value) \r
 201                 {\r
 202                         return Boolean.Parse (value);\r
 203                 }\r
 204         \r
 205                 public static bool ToBoolean (uint value) \r
 206                 { \r
 207                         return (value != 0);\r
 208                 }\r
 209 \r
 210                 public static bool ToBoolean (ulong value) \r
 211                 { \r
 212                         return (value != 0); \r
 213                 }\r
 214 \r
 215                 public static bool ToBoolean (ushort value) \r
 216                 { \r
 217                         return (value != 0); \r
 218                 }\r
 219 \r
 220                 // ========== Byte Conversions ========== //\r
 221         \r
 222                 public static byte ToByte (bool value) \r
 223                 { \r
 224                         return (byte)(value ? 1 : 0); \r
 225                 }\r
 226         \r
 227                 public static byte ToByte (byte value) \r
 228                 { \r
 229                         return value; \r
 230                 }\r
 231 \r
 232                 public static byte ToByte (char value) \r
 233                 { \r
 234                         if (value > Byte.MaxValue)\r
 235                                 throw new OverflowException\r
 236                                 ("Value is greater than Byte.MaxValue");\r
 237 \r
 238                         return (byte)value;\r
 239                 }\r
 240         \r
 241                 public static byte ToByte (decimal value) \r
 242                 { \r
 243                         if (value > Byte.MaxValue || value < Byte.MinValue)\r
 244                                 throw new OverflowException\r
 245                                 ("Value is greater than Byte.MaxValue or less than Byte.MinValue");\r
 246           \r
 247                         // Returned Even-Rounded\r
 248                         return (byte)(Math.Round (value));\r
 249                 }\r
 250         \r
 251                 public static byte ToByte (double value) \r
 252                 { \r
 253                         if (value > Byte.MaxValue || value < Byte.MinValue)\r
 254                                 throw new OverflowException\r
 255                                 ("Value is greater than Byte.MaxValue or less than Byte.MinValue");\r
 256           \r
 257                         // This and the float version of ToByte are the only ones\r
 258                         // the spec listed as checking for .NaN and Infinity overflow\r
 259                         if (Double.IsNaN(value) || Double.IsInfinity(value))\r
 260                                 throw new OverflowException\r
 261                                 ("Value is equal to Double.NaN, Double.PositiveInfinity, or Double.NegativeInfinity");\r
 262 \r
 263                         // Returned Even-Rounded\r
 264                         return (byte)(Math.Round (value));\r
 265                 }\r
 266 \r
 267                 public static byte ToByte (float value) \r
 268                 { \r
 269                         if (value > Byte.MaxValue || value < Byte.MinValue)\r
 270                                 throw new OverflowException\r
 271                                 ("Value is greater than Byte.MaxValue or less than Byte.Minalue");\r
 272 \r
 273                         // This and the double version of ToByte are the only ones\r
 274                         // the spec listed as checking for .NaN and Infinity overflow\r
 275                         if (Single.IsNaN(value) || Single.IsInfinity(value))\r
 276                                 throw new OverflowException\r
 277                                 ("Value is equal to Single.NaN, Single.PositiveInfinity, or Single.NegativeInfinity");\r
 278           \r
 279                         // Returned Even-Rounded, pass it as a double, could have this\r
 280                         // method just call Convert.ToByte ( (double)value)\r
 281                         return (byte)(Math.Round ( (double)value));\r
 282                 }\r
 283 \r
 284                 public static byte ToByte (int value) \r
 285                 { \r
 286                         if (value > Byte.MaxValue || value < Byte.MinValue)\r
 287                                 throw new OverflowException\r
 288                                 ("Value is greater than Byte.MaxValue or less than Byte.MinValue");\r
 289           \r
 290                         return (byte)value; \r
 291                 }\r
 292 \r
 293                 public static byte ToByte (long value) \r
 294                 { \r
 295                         if (value > Byte.MaxValue || value < Byte.MinValue)\r
 296                                 throw new OverflowException\r
 297                                 ("Value is greater than Byte.MaxValue or less than Byte.MinValue");\r
 298           \r
 299                         return (byte)value;\r
 300                 }\r
 301 \r
 302                 public static byte ToByte (sbyte value) \r
 303                 { \r
 304                         if (value < Byte.MinValue)\r
 305                                 throw new OverflowException\r
 306                                 ("Value is less than Byte.MinValue");\r
 307           \r
 308                         return (byte)value;\r
 309                 }\r
 310         \r
 311                 public static byte ToByte (short value) \r
 312                 { \r
 313                         if (value > Byte.MaxValue || value < Byte.MinValue)\r
 314                                 throw new OverflowException\r
 315                                 ("Value is greater than Byte.MaxValue or less than Byte.MinValue");\r
 316           \r
 317                         return (byte)value; \r
 318                 }\r
 319 \r
 320                 public static byte ToByte (string value) \r
 321                 {\r
 322                         return Byte.Parse (value);\r
 323                 }\r
 324 \r
 325                 public static byte ToByte (string value, IFormatProvider provider) \r
 326                 {\r
 327                         return Byte.Parse (value, provider);\r
 328                 }\r
 329         \r
 330                 public static byte ToByte (uint value) \r
 331                 { \r
 332                         if (value > Byte.MaxValue)\r
 333                                 throw new OverflowException\r
 334                                 ("Value is greater than Byte.MaxValue");\r
 335 \r
 336                         return (byte)value;\r
 337                 }\r
 338 \r
 339                 public static byte ToByte (ulong value) \r
 340                 { \r
 341                         if (value > Byte.MaxValue)\r
 342                                 throw new OverflowException\r
 343                                 ("Value is greater than Byte.MaxValue");\r
 344 \r
 345                         return (byte)value;\r
 346                 }\r
 347 \r
 348                 public static byte ToByte (ushort value) \r
 349                 { \r
 350                         if (value > Byte.MaxValue)\r
 351                                 throw new OverflowException\r
 352                                 ("Value is greater than Byte.MaxValue");\r
 353 \r
 354                         return (byte)value;\r
 355                 }\r
 356 \r
 357                 // ========== Char Conversions ========== //\r
 358         \r
 359                 public static char ToChar (byte value) \r
 360                 { \r
 361                         return (char)value;\r
 362                 }\r
 363 \r
 364                 public static char ToChar (char value) \r
 365                 { \r
 366                         return value;\r
 367                 }\r
 368 \r
 369                 public static char ToChar (int value) \r
 370                 { \r
 371                         if (value > Char.MaxValue || value < Char.MinValue)\r
 372                                 throw new OverflowException\r
 373                                 ("Value is greater than Char.MaxValue or less than Char.MinValue");\r
 374           \r
 375                         return (char)value; \r
 376                 }\r
 377 \r
 378                 public static char ToChar (long value) \r
 379                 { \r
 380                         if (value > Char.MaxValue || value < Char.MinValue)\r
 381                                 throw new OverflowException\r
 382                                 ("Value is greater than Char.MaxValue or less than Char.MinValue");\r
 383           \r
 384                         return (char)value; \r
 385                 }\r
 386 \r
 387                 public static char ToChar (sbyte value) \r
 388                 { \r
 389                         if (value < Char.MinValue)\r
 390                                 throw new OverflowException\r
 391                                 ("Value is less than Char.MinValue");\r
 392           \r
 393                         return (char)value; \r
 394                 }\r
 395         \r
 396                 public static char ToChar (short value) \r
 397                 { \r
 398                         if (value < Char.MinValue)\r
 399                                 throw new OverflowException\r
 400                                 ("Value is less than Char.MinValue");\r
 401           \r
 402                         return (char)value; \r
 403                 }\r
 404 \r
 405                 public static char ToChar (string value) \r
 406                 {\r
 407                         return Char.Parse (value);\r
 408                 }\r
 409         \r
 410                 public static char ToChar (uint value) \r
 411                 { \r
 412                         if (value > Char.MaxValue)\r
 413                                 throw new OverflowException\r
 414                                 ("Value is greater than Char.MaxValue");\r
 415           \r
 416                         return (char)value; \r
 417                 }\r
 418 \r
 419                 public static char ToChar (ulong value) \r
 420                 { \r
 421                         if (value > Char.MaxValue)\r
 422                                 throw new OverflowException\r
 423                                 ("Value is greater than Char.MaxValue");\r
 424           \r
 425                         return (char)value; \r
 426                 }\r
 427 \r
 428                 public static char ToChar (ushort value) \r
 429                 { \r
 430                         if (value > Char.MaxValue)\r
 431                                 throw new OverflowException\r
 432                                 ("Value is greater than Char.MaxValue");\r
 433           \r
 434                         return (char)value; \r
 435                 }\r
 436 \r
 437                 // ========== DateTime Conversions ========== //\r
 438         \r
 439                 public static DateTime ToDateTime (string value) \r
 440                 { \r
 441                         return DateTime.Parse (value);\r
 442                 }\r
 443         \r
 444                 public static DateTime ToDateTime (string value, IFormatProvider provider) \r
 445                 {\r
 446                         return DateTime.Parse (value, provider);\r
 447                 }\r
 448 \r
 449                 // ========== Decimal Conversions ========== //\r
 450         \r
 451                 public static decimal ToDecimal (bool value) \r
 452                 { \r
 453                         return value ? 1 : 0; \r
 454                 }\r
 455         \r
 456                 public static decimal ToDecimal (byte value) \r
 457                 { \r
 458                         return (decimal)value; \r
 459                 }\r
 460         \r
 461                 public static decimal ToDecimal (decimal value) \r
 462                 { \r
 463                         return value; \r
 464                 }\r
 465 \r
 466                 public static decimal ToDecimal (double value) \r
 467                 { \r
 468                         if (value > (double)Decimal.MaxValue || value < (double)Decimal.MinValue) \r
 469                                 throw new OverflowException\r
 470                                 ("Value is greater than Decimal.MaxValue or less than Decimal.MinValue");\r
 471 \r
 472                         return (decimal)value; \r
 473                 }\r
 474 \r
 475                 public static decimal ToDecimal (float value) \r
 476                 { \r
 477                         if (value > (double)Decimal.MaxValue || value < (double)Decimal.MinValue) \r
 478                                 throw new OverflowException\r
 479                                 ("Value is greater than Decimal.MaxValue or less than Decimal.MinValue");\r
 480 \r
 481                         return (decimal)value; \r
 482                 }\r
 483 \r
 484                 public static decimal ToDecimal (int value) \r
 485                 { \r
 486                         return (decimal)value; \r
 487                 }\r
 488         \r
 489                 public static decimal ToDecimal (long value) \r
 490                 { \r
 491                         return (decimal)value; \r
 492                 }\r
 493 \r
 494                 public static decimal ToDecimal (sbyte value) \r
 495                 { \r
 496                         return (decimal)value; \r
 497                 }\r
 498         \r
 499                 public static decimal ToDecimal (short value) \r
 500                 { \r
 501                         return (decimal)value; \r
 502                 }\r
 503 \r
 504                 public static decimal ToDecimal (string value) \r
 505                 {\r
 506                         return Decimal.Parse (value);\r
 507                 }\r
 508 \r
 509                 public static decimal ToDecimal (string value, IFormatProvider provider) \r
 510                 {\r
 511                         return Decimal.Parse (value, provider);\r
 512                 }\r
 513         \r
 514                 public static decimal ToDecimal (uint value) \r
 515                 { \r
 516                         return (decimal)value; \r
 517                 }\r
 518 \r
 519                 public static decimal ToDecimal (ulong value) \r
 520                 { \r
 521                         return (decimal)value; \r
 522                 }\r
 523 \r
 524                 public static decimal ToDecimal (ushort value) \r
 525                 { \r
 526                         return (decimal)value; \r
 527                 }\r
 528 \r
 529                 // ========== Double Conversions ========== //\r
 530         \r
 531                 public static double ToDouble (bool value) \r
 532                 { \r
 533                         return value ? 1 : 0; \r
 534                 }\r
 535         \r
 536                 public static double ToDouble (byte value) \r
 537                 { \r
 538                         return (double)value; \r
 539                 }\r
 540         \r
 541                 public static double ToDouble (decimal value) \r
 542                 { \r
 543                         return (double)value; \r
 544                 }\r
 545 \r
 546                 public static double ToDouble (double value) \r
 547                 { \r
 548                         return value; \r
 549                 }\r
 550 \r
 551                 public static double ToDouble (float value) \r
 552                 { \r
 553                         return (double)value; \r
 554                 }\r
 555 \r
 556                 public static double ToDouble (int value) \r
 557                 { \r
 558                         return (double)value; \r
 559                 }\r
 560         \r
 561                 public static double ToDouble (long value) \r
 562                 { \r
 563                         return (double)value; \r
 564                 }\r
 565 \r
 566                 public static double ToDouble (sbyte value) \r
 567                 { \r
 568                         return (double)value; \r
 569                 }\r
 570         \r
 571                 public static double ToDouble (short value) \r
 572                 { \r
 573                         return (double)value; \r
 574                 }\r
 575 \r
 576                 public static double ToDouble (string value) \r
 577                 {\r
 578                         return Double.Parse (value);\r
 579                 }\r
 580 \r
 581                 public static double ToDouble (string value, IFormatProvider provider) \r
 582                 {\r
 583                         return Double.Parse (value, provider);\r
 584                 }\r
 585         \r
 586                 public static double ToDouble (uint value) \r
 587                 { \r
 588                         return (double)value; \r
 589                 }\r
 590 \r
 591                 public static double ToDouble (ulong value) \r
 592                 { \r
 593                         return (double)value; \r
 594                 }\r
 595 \r
 596                 public static double ToDouble (ushort value) \r
 597                 { \r
 598                         return (double)value; \r
 599                 }\r
 600 \r
 601                 // ========== Int16 Conversions ========== //\r
 602 \r
 603                 public static short ToInt16 (bool value) \r
 604                 { \r
 605                         return (short)(value ? 1 : 0); \r
 606                 }\r
 607         \r
 608                 public static short ToInt16 (byte value) \r
 609                 { \r
 610                         return (short)value; \r
 611                 }\r
 612 \r
 613                 public static short ToInt16 (char value) \r
 614                 { \r
 615                         if (value > Int16.MaxValue) \r
 616                                 throw new OverflowException\r
 617                                 ("Value is greater than Int16.MaxValue");\r
 618 \r
 619                         return (short)value; \r
 620                 }\r
 621         \r
 622                 public static short ToInt16 (decimal value) \r
 623                 { \r
 624                         if (value > Int16.MaxValue || value < Int16.MinValue) \r
 625                                 throw new OverflowException\r
 626                                 ("Value is greater than Int16.MaxValue or less than Int16.MinValue");\r
 627           \r
 628                         // Returned Even-Rounded\r
 629                         return (short)(Math.Round (value));       \r
 630                 }\r
 631 \r
 632                 public static short ToInt16 (double value) \r
 633                 { \r
 634                         if (value > Int16.MaxValue || value < Int16.MinValue) \r
 635                                 throw new OverflowException\r
 636                                 ("Value is greater than Int16.MaxValue or less than Int16.MinValue");\r
 637           \r
 638                         // Returned Even-Rounded\r
 639                         return (short)(Math.Round (value));       \r
 640                 }\r
 641  \r
 642                 public static short ToInt16 (float value) \r
 643                 { \r
 644                         if (value > Int16.MaxValue || value < Int16.MinValue) \r
 645                                 throw new OverflowException\r
 646                                 ("Value is greater than Int16.MaxValue or less than Int16.MinValue");\r
 647           \r
 648                         // Returned Even-Rounded, use Math.Round pass as a double.\r
 649                         return (short)Math.Round ( (double)value);\r
 650                 }\r
 651 \r
 652                 public static short ToInt16 (int value) \r
 653                 { \r
 654                         if (value > Int16.MaxValue || value < Int16.MinValue) \r
 655                                 throw new OverflowException\r
 656                                 ("Value is greater than Int16.MaxValue or less than Int16.MinValue");\r
 657 \r
 658                         return (short)value; \r
 659                 }\r
 660         \r
 661                 public static short ToInt16 (long value) \r
 662                 { \r
 663                         if (value > Int16.MaxValue || value < Int16.MinValue) \r
 664                                 throw new OverflowException\r
 665                                 ("Value is greater than Int16.MaxValue or less than Int16.MinValue");\r
 666 \r
 667                         return (short)value; \r
 668                 }\r
 669 \r
 670                 public static short ToInt16 (sbyte value) \r
 671                 { \r
 672                         return (short)value; \r
 673                 }\r
 674         \r
 675                 public static short ToInt16 (short value) \r
 676                 { \r
 677                         return value; \r
 678                 }\r
 679 \r
 680                 public static short ToInt16 (string value) \r
 681                 {\r
 682                         return Int16.Parse (value);\r
 683                 }\r
 684 \r
 685                 public static short ToInt16 (string value, IFormatProvider provider) \r
 686                 {\r
 687                         return Int16.Parse (value, provider);\r
 688                 }\r
 689         \r
 690                 public static short ToInt16 (uint value) \r
 691                 { \r
 692                         if (value > Int16.MaxValue) \r
 693                                 throw new OverflowException\r
 694                                 ("Value is greater than Int16.MaxValue");\r
 695 \r
 696                         return (short)value; \r
 697                 }\r
 698 \r
 699                 public static short ToInt16 (ulong value) \r
 700                 { \r
 701                         if (value > (ulong)Int16.MaxValue) \r
 702                                 throw new OverflowException\r
 703                                 ("Value is greater than Int16.MaxValue");\r
 704 \r
 705                         return (short)value; \r
 706                 }\r
 707 \r
 708                 public static short ToInt16 (ushort value) \r
 709                 { \r
 710                         if (value > Int16.MaxValue) \r
 711                                 throw new OverflowException\r
 712                                 ("Value is greater than Int16.MaxValue");\r
 713 \r
 714                         return (short)value; \r
 715                 }\r
 716 \r
 717                 // ========== Int32 Conversions ========== //\r
 718 \r
 719                 public static int ToInt32 (bool value) \r
 720                 { \r
 721                         return value ? 1 : 0; \r
 722                 }\r
 723         \r
 724                 public static int ToInt32 (byte value) \r
 725                 { \r
 726                         return (int)value; \r
 727                 }\r
 728 \r
 729                 public static int ToInt32 (char value) \r
 730                 { \r
 731                         return (int)value; \r
 732                 }\r
 733         \r
 734                 public static int ToInt32 (decimal value) \r
 735                 { \r
 736                         if (value > Int32.MaxValue || value < Int32.MinValue) \r
 737                                 throw new OverflowException\r
 738                                 ("Value is greater than Int32.MaxValue or less than Int32.MinValue");\r
 739 \r
 740                         // Returned Even-Rounded\r
 741                         return (int)(Math.Round (value));         \r
 742                 }\r
 743 \r
 744                 public static int ToInt32 (double value) \r
 745                 { \r
 746                         if (value > Int32.MaxValue || value < Int32.MinValue) \r
 747                                 throw new OverflowException\r
 748                                 ("Value is greater than Int32.MaxValue or less than Int32.MinValue");\r
 749           \r
 750                         // Returned Even-Rounded\r
 751                         return (int)(Math.Round (value));         \r
 752                 }\r
 753  \r
 754                 public static int ToInt32 (float value) \r
 755                 { \r
 756                         if (value > Int32.MaxValue || value < Int32.MinValue) \r
 757                                 throw new OverflowException\r
 758                                 ("Value is greater than Int32.MaxValue or less than Int32.MinValue");\r
 759           \r
 760                         // Returned Even-Rounded, pass as a double, could just call\r
 761                         // Convert.ToInt32 ( (double)value);\r
 762                         return (int)(Math.Round ( (double)value));\r
 763                 }\r
 764 \r
 765                 public static int ToInt32 (int value) \r
 766                 { \r
 767                         return value; \r
 768                 }\r
 769         \r
 770                 public static int ToInt32 (long value) \r
 771                 { \r
 772                         if (value > Int32.MaxValue || value < Int32.MinValue) \r
 773                                 throw new OverflowException\r
 774                                 ("Value is greater than Int32.MaxValue or less than Int32.MinValue");\r
 775 \r
 776                         return (int)value; \r
 777                 }\r
 778 \r
 779                 public static int ToInt32 (sbyte value) \r
 780                 { \r
 781                         return (int)value; \r
 782                 }\r
 783         \r
 784                 public static int ToInt32 (short value) \r
 785                 { \r
 786                         return (int)value; \r
 787                 }\r
 788 \r
 789                 public static int ToInt32 (string value) \r
 790                 {\r
 791                         return Int32.Parse (value);\r
 792                 }\r
 793 \r
 794                 public static int ToInt32 (string value, IFormatProvider provider) \r
 795                 {\r
 796                         return Int32.Parse (value, provider);\r
 797                 }\r
 798         \r
 799                 public static int ToInt32 (uint value) \r
 800                 { \r
 801                         if (value > Int32.MaxValue) \r
 802                                 throw new OverflowException\r
 803                                 ("Value is greater than Int32.MaxValue");\r
 804 \r
 805                         return (int)value; \r
 806                 }\r
 807 \r
 808                 public static int ToInt32 (ulong value) \r
 809                 { \r
 810                         if (value > Int32.MaxValue) \r
 811                                 throw new OverflowException\r
 812                                 ("Value is greater than Int32.MaxValue");\r
 813 \r
 814                         return (int)value; \r
 815                 }\r
 816 \r
 817                 public static int ToInt32 (ushort value) \r
 818                 { \r
 819                         return (int)value; \r
 820                 }\r
 821 \r
 822                 // ========== Int64 Conversions ========== //\r
 823 \r
 824                 public static long ToInt64 (bool value) \r
 825                 { \r
 826                         return value ? 1 : 0; \r
 827                 }\r
 828         \r
 829                 public static long ToInt64 (byte value) \r
 830                 { \r
 831                         return (long)value; \r
 832                 }\r
 833 \r
 834                 public static long ToInt64 (char value) \r
 835                 { \r
 836                         return (long)value; \r
 837                 }\r
 838         \r
 839                 public static long ToInt64 (decimal value) \r
 840                 { \r
 841                         if (value > Int64.MaxValue || value < Int64.MinValue) \r
 842                                 throw new OverflowException\r
 843                                 ("Value is greater than Int64.MaxValue or less than Int64.MinValue");\r
 844           \r
 845                         // Returned Even-Rounded\r
 846                         return (long)(Math.Round (value));        \r
 847                 }\r
 848 \r
 849                 public static long ToInt64 (double value) \r
 850                 { \r
 851                         if (value > Int64.MaxValue || value < Int64.MinValue) \r
 852                                 throw new OverflowException\r
 853                                 ("Value is greater than Int64.MaxValue or less than Int64.MinValue");\r
 854           \r
 855                         // Returned Even-Rounded\r
 856                         return (long)(Math.Round (value));        \r
 857                 }\r
 858  \r
 859                 public static long ToInt64 (float value) \r
 860                 { \r
 861                         if (value > Int64.MaxValue || value < Int64.MinValue) \r
 862                                 throw new OverflowException\r
 863                                 ("Value is greater than Int64.MaxValue or less than Int64.MinValue");\r
 864           \r
 865                         // Returned Even-Rounded, pass to Math as a double, could\r
 866                         // just call Convert.ToInt64 ( (double)value);\r
 867                         return (long)(Math.Round ( (double)value));\r
 868                 }\r
 869 \r
 870                 public static long ToInt64 (int value) \r
 871                 { \r
 872                         return (long)value; \r
 873                 }\r
 874         \r
 875                 public static long ToInt64 (long value) \r
 876                 { \r
 877                         return value; \r
 878                 }\r
 879 \r
 880                 public static long ToInt64 (sbyte value) \r
 881                 { \r
 882                         return (long)value; \r
 883                 }\r
 884         \r
 885                 public static long ToInt64 (short value) \r
 886                 { \r
 887                         return (long)value; \r
 888                 }\r
 889 \r
 890                 public static long ToInt64 (string value) \r
 891                 {\r
 892                         return Int64.Parse (value);\r
 893                 }\r
 894 \r
 895                 public static long ToInt64 (string value, IFormatProvider provider) \r
 896                 {\r
 897                         return Int64.Parse (value, provider);\r
 898                 }\r
 899         \r
 900                 public static long ToInt64 (uint value) \r
 901                 { \r
 902                         return (long)value; \r
 903                 }\r
 904 \r
 905                 public static long ToInt64 (ulong value) \r
 906                 { \r
 907                         if (value > Int64.MaxValue) \r
 908                                 throw new OverflowException\r
 909                                 ("Value is greater than Int64.MaxValue");\r
 910 \r
 911                         return (long)value; \r
 912                 }\r
 913 \r
 914                 public static long ToInt64 (ushort value) \r
 915                 { \r
 916                         return (long)value; \r
 917                 }\r
 918 \r
 919                 // ========== SByte Conversions ========== //\r
 920         \r
 921                 public static sbyte ToSByte (bool value) \r
 922                 { \r
 923                         return (sbyte)(value ? 1 : 0); \r
 924                 }\r
 925         \r
 926                 public static sbyte ToSByte (byte value) \r
 927                 { \r
 928                         if (value > SByte.MaxValue)\r
 929                                 throw new OverflowException\r
 930                                 ("Value is greater than SByte.MaxValue");\r
 931 \r
 932                         return (sbyte)value; \r
 933                 }\r
 934 \r
 935                 public static sbyte ToSByte (char value) \r
 936                 { \r
 937                         if (value > SByte.MaxValue)\r
 938                                 throw new OverflowException\r
 939                                 ("Value is greater than SByte.MaxValue");\r
 940 \r
 941                         return (sbyte)value;\r
 942                 }\r
 943         \r
 944                 public static sbyte ToSByte (decimal value) \r
 945                 { \r
 946                         if (value > SByte.MaxValue || value < SByte.MinValue)\r
 947                                 throw new OverflowException\r
 948                                 ("Value is greater than SByte.MaxValue or less than SByte.MinValue");\r
 949           \r
 950                         // Returned Even-Rounded\r
 951                         return (sbyte)(Math.Round (value));\r
 952                 }\r
 953         \r
 954                 public static sbyte ToSByte (double value) \r
 955                 { \r
 956                         if (value > SByte.MaxValue || value < SByte.MinValue)\r
 957                                 throw new OverflowException\r
 958                                 ("Value is greater than SByte.MaxValue or less than SByte.MinValue");\r
 959 \r
 960                         // Returned Even-Rounded\r
 961                         return (sbyte)(Math.Round (value));\r
 962                 }\r
 963 \r
 964                 public static sbyte ToSByte (float value) \r
 965                 { \r
 966                         if (value > SByte.MaxValue || value < SByte.MinValue)\r
 967                                 throw new OverflowException\r
 968                                 ("Value is greater than SByte.MaxValue or less than SByte.Minalue");\r
 969 \r
 970                         // Returned Even-Rounded, pass as double to Math\r
 971                         return (sbyte)(Math.Round ( (double)value));\r
 972                 }\r
 973 \r
 974                 public static sbyte ToSByte (int value) \r
 975                 { \r
 976                         if (value > SByte.MaxValue || value < SByte.MinValue)\r
 977                                 throw new OverflowException\r
 978                                 ("Value is greater than SByte.MaxValue or less than SByte.MinValue");\r
 979           \r
 980                         return (sbyte)value; \r
 981                 }\r
 982 \r
 983                 public static sbyte ToSByte (long value) \r
 984                 { \r
 985                         if (value > SByte.MaxValue || value < SByte.MinValue)\r
 986                                 throw new OverflowException\r
 987                                 ("Value is greater than SByte.MaxValue or less than SByte.MinValue");\r
 988           \r
 989                         return (sbyte)value;\r
 990                 }\r
 991 \r
 992                 public static sbyte ToSByte (sbyte value) \r
 993                 { \r
 994                         return value;\r
 995                 }\r
 996         \r
 997                 public static sbyte ToSByte (short value) \r
 998                 { \r
 999                         if (value > SByte.MaxValue || value < SByte.MinValue)\r
1000                                 throw new OverflowException\r
1001                                 ("Value is greater than SByte.MaxValue or less than SByte.MinValue");\r
1002           \r
1003                         return (sbyte)value; \r
1004                 }\r
1005 \r
1006                 public static sbyte ToSByte (string value) \r
1007                 {\r
1008                         return SByte.Parse (value);\r
1009                 }\r
1010 \r
1011                 public static sbyte ToSByte (string value, IFormatProvider provider) \r
1012                 {\r
1013                         return SByte.Parse (value, provider);\r
1014                 }\r
1015         \r
1016                 public static sbyte ToSByte (uint value) \r
1017                 { \r
1018                         if (value > SByte.MaxValue)\r
1019                                 throw new OverflowException\r
1020                                 ("Value is greater than SByte.MaxValue");\r
1021 \r
1022                         return (sbyte)value;\r
1023                 }\r
1024 \r
1025                 public static sbyte ToSByte (ulong value) \r
1026                 { \r
1027                         if (value > (ulong)SByte.MaxValue)\r
1028                                 throw new OverflowException\r
1029                                 ("Value is greater than SByte.MaxValue");\r
1030 \r
1031                         return (sbyte)value;\r
1032                 }\r
1033 \r
1034                 public static sbyte ToSByte (ushort value) \r
1035                 { \r
1036                         if (value > SByte.MaxValue)\r
1037                                 throw new OverflowException\r
1038                                 ("Value is greater than SByte.MaxValue");\r
1039 \r
1040                         return (sbyte)value;\r
1041                 }\r
1042 \r
1043                 // ========== Single Conversions ========== //\r
1044         \r
1045                 public static float ToSingle (bool value) \r
1046                 { \r
1047                         return value ? 1 : 0; \r
1048                 }\r
1049         \r
1050                 public static float ToSingle (byte value) \r
1051                 { \r
1052                         return (float)value; \r
1053                 }\r
1054         \r
1055                 public static float ToSingle (decimal value) \r
1056                 { \r
1057                         return (float)value; \r
1058                 }\r
1059 \r
1060                 public static float ToSingle (double value) \r
1061                 { \r
1062                         if (value > Single.MaxValue || value < Single.MinValue)\r
1063                                 throw new OverflowException\r
1064                                 ("Value is greater than Single.MaxValue or less than Single.MinValue");\r
1065 \r
1066                         return (float)value; \r
1067                 }\r
1068         \r
1069                 public static float ToSingle (float value) \r
1070                 { \r
1071                         return value; \r
1072                 }\r
1073 \r
1074                 public static float ToSingle (int value) \r
1075                 { \r
1076                         return (float)value; \r
1077                 }\r
1078         \r
1079                 public static float ToSingle (long value) \r
1080                 { \r
1081                         return (float)value; \r
1082                 }\r
1083 \r
1084                 public static float ToSingle (sbyte value) \r
1085                 { \r
1086                         return (float)value; \r
1087                 }\r
1088         \r
1089                 public static float ToSingle (short value) \r
1090                 { \r
1091                         return (float)value; \r
1092                 }\r
1093 \r
1094                 public static float ToSingle (string value) \r
1095                 {\r
1096                         return Single.Parse (value);\r
1097                 }\r
1098 \r
1099                 public static float ToSingle (string value, IFormatProvider provider) \r
1100                 {\r
1101                         return Single.Parse (value, provider);\r
1102                 }\r
1103         \r
1104                 public static float ToSingle (uint value) \r
1105                 { \r
1106                         return (float)value; \r
1107                 }\r
1108 \r
1109                 public static float ToSingle (ulong value) \r
1110                 { \r
1111                         return (float)value; \r
1112                 }\r
1113 \r
1114                 public static float ToSingle (ushort value) \r
1115                 { \r
1116                         return (float)value; \r
1117                 }\r
1118 \r
1119                 // ========== String Conversions ========== //\r
1120         \r
1121                 public static string ToString (bool value) \r
1122                 { \r
1123                         return value.ToString (); \r
1124                 }\r
1125         \r
1126                 public static string ToString (byte value) \r
1127                 { \r
1128                         return value.ToString (); \r
1129                 }\r
1130         \r
1131                 public static string ToString (byte value, IFormatProvider provider) \r
1132                 {\r
1133                         return value.ToString (provider); \r
1134                 }\r
1135 \r
1136                 public static string ToString (char value) \r
1137                 { \r
1138                         return value.ToString (); \r
1139                 }\r
1140 \r
1141                 public static string ToString (DateTime value) \r
1142                 { \r
1143                         return value.ToString (); \r
1144                 }\r
1145 \r
1146                 public static string ToString (DateTime value, IFormatProvider provider) \r
1147                 { \r
1148                         return value.ToString (provider); \r
1149                 }\r
1150 \r
1151                 public static string ToString (decimal value) \r
1152                 {\r
1153                         return value.ToString ();\r
1154                 }\r
1155 \r
1156                 public static string ToString (decimal value, IFormatProvider provider) \r
1157                 { \r
1158                         return value.ToString (provider); \r
1159                 }\r
1160         \r
1161                 public static string ToString (double value) \r
1162                 { \r
1163                         return value.ToString (); \r
1164                 }\r
1165 \r
1166                 public static string ToString (double value, IFormatProvider provider) \r
1167                 { \r
1168                         return value.ToString (provider);\r
1169                 }\r
1170         \r
1171                 public static string ToString (float value) \r
1172                 { \r
1173                         return value.ToString (); \r
1174                 }\r
1175 \r
1176                 public static string ToString (float value, IFormatProvider provider) \r
1177                 { \r
1178                         return value.ToString (provider); \r
1179                 }\r
1180 \r
1181                 public static string ToString (int value) \r
1182                 { \r
1183                         return value.ToString (); \r
1184                 }\r
1185 \r
1186                 public static string ToString (int value, IFormatProvider provider) \r
1187                 { \r
1188                         return value.ToString (provider); \r
1189                 }\r
1190         \r
1191                 public static string ToString (long value) \r
1192                 { \r
1193                         return value.ToString (); \r
1194                 }\r
1195 \r
1196                 public static string ToString (long value, IFormatProvider provider) \r
1197                 { \r
1198                         return value.ToString (provider); \r
1199                 }\r
1200 \r
1201                 public static string ToString (sbyte value) \r
1202                 { \r
1203                         return value.ToString (); \r
1204                 }\r
1205 \r
1206                 public static string ToString (sbyte value, IFormatProvider provider) \r
1207                 { \r
1208                         return value.ToString (provider); \r
1209                 }\r
1210         \r
1211                 public static string ToString (short value) \r
1212                 { \r
1213                         return value.ToString (); \r
1214                 }\r
1215 \r
1216                 public static string ToString (short value, IFormatProvider provider) \r
1217                 { \r
1218                         return value.ToString (provider); \r
1219                 }\r
1220 \r
1221                 public static string ToString (string value) \r
1222                 {\r
1223                         return value;\r
1224                 }\r
1225 \r
1226                 public static string ToString (uint value) \r
1227                 { \r
1228                         return value.ToString (); \r
1229                 }\r
1230 \r
1231                 public static string ToString (uint value, IFormatProvider provider) \r
1232                 { \r
1233                         return value.ToString (provider); \r
1234                 }\r
1235 \r
1236                 public static string ToString (ulong value) \r
1237                 { \r
1238                         return value.ToString (); \r
1239                 }\r
1240 \r
1241                 public static string ToString (ulong value, IFormatProvider provider) \r
1242                 { \r
1243                         return value.ToString (provider); \r
1244                 }\r
1245 \r
1246                 public static string ToString (ushort value) \r
1247                 { \r
1248                         return value.ToString (); \r
1249                 }\r
1250 \r
1251                 public static string ToString (ushort value, IFormatProvider provider) \r
1252                 { \r
1253                         return value.ToString (provider); \r
1254                 }\r
1255 \r
1256                 // ========== UInt16 Conversions ========== //\r
1257 \r
1258                 public static ushort ToUInt16 (bool value) \r
1259                 { \r
1260                         return (ushort)(value ? 1 : 0); \r
1261                 }\r
1262         \r
1263                 public static ushort ToUInt16 (byte value) \r
1264                 { \r
1265                         return (ushort)value; \r
1266                 }\r
1267 \r
1268                 public static ushort ToUInt16 (char value) \r
1269                 { \r
1270                         return (ushort)value; \r
1271                 }\r
1272         \r
1273                 public static ushort ToUInt16 (decimal value) \r
1274                 { \r
1275                         if (value > UInt16.MaxValue || value < UInt16.MinValue) \r
1276                                 throw new OverflowException\r
1277                                 ("Value is greater than UInt16.MaxValue or less than UInt16.MinValue");\r
1278           \r
1279                         // Returned Even-Rounded\r
1280                         return (ushort)(Math.Round (value));      \r
1281                 }\r
1282 \r
1283                 public static ushort ToUInt16 (double value) \r
1284                 { \r
1285                         if (value > UInt16.MaxValue || value < UInt16.MinValue) \r
1286                                 throw new OverflowException\r
1287                                 ("Value is greater than UInt16.MaxValue or less than UInt16.MinValue");\r
1288           \r
1289                         // Returned Even-Rounded\r
1290                         return (ushort)(Math.Round (value));\r
1291                 }\r
1292  \r
1293                 public static ushort ToUInt16 (float value) \r
1294                 { \r
1295                         if (value > UInt16.MaxValue || value < UInt16.MinValue) \r
1296                                 throw new OverflowException\r
1297                                 ("Value is greater than UInt16.MaxValue or less than UInt16.MinValue");\r
1298           \r
1299                         // Returned Even-Rounded, pass as double to Math\r
1300                         return (ushort)(Math.Round ( (double)value));\r
1301                 }\r
1302 \r
1303                 public static ushort ToUInt16 (int value) \r
1304                 { \r
1305                         if (value > UInt16.MaxValue || value < UInt16.MinValue) \r
1306                                 throw new OverflowException\r
1307                                 ("Value is greater than UInt16.MaxValue or less than UInt16.MinValue");\r
1308 \r
1309                         return (ushort)value; \r
1310                 }\r
1311         \r
1312                 public static ushort ToUInt16 (long value) \r
1313                 { \r
1314                         if (value > UInt16.MaxValue || value < UInt16.MinValue) \r
1315                                 throw new OverflowException\r
1316                                 ("Value is greater than UInt16.MaxValue or less than UInt16.MinValue");\r
1317 \r
1318                         return (ushort)value; \r
1319                 }\r
1320 \r
1321                 public static ushort ToUInt16 (sbyte value) \r
1322                 { \r
1323                         if (value < UInt16.MinValue) \r
1324                                 throw new OverflowException\r
1325                                 ("Value is less than UInt16.MinValue");\r
1326 \r
1327                         return (ushort)value; \r
1328                 }\r
1329         \r
1330                 public static ushort ToUInt16 (short value) \r
1331                 { \r
1332                         if (value < UInt16.MinValue) \r
1333                                 throw new OverflowException\r
1334                                 ("Value is less than UInt16.MinValue");\r
1335 \r
1336                         return (ushort)value; \r
1337                 }\r
1338 \r
1339                 public static ushort ToUInt16 (string value) \r
1340                 {\r
1341                         return UInt16.Parse (value);\r
1342                 }\r
1343 \r
1344                 public static ushort ToUInt16 (string value, IFormatProvider provider) \r
1345                 {\r
1346                         return UInt16.Parse (value, provider);\r
1347                 }\r
1348         \r
1349                 public static ushort ToUInt16 (uint value) \r
1350                 { \r
1351                         if (value > UInt16.MaxValue) \r
1352                                 throw new OverflowException\r
1353                                 ("Value is greater than UInt16.MaxValue");\r
1354 \r
1355                         return (ushort)value; \r
1356                 }\r
1357 \r
1358                 public static ushort ToUInt16 (ulong value) \r
1359                 { \r
1360                         if (value > (ulong)UInt16.MaxValue) \r
1361                                 throw new OverflowException\r
1362                                 ("Value is greater than UInt16.MaxValue");\r
1363 \r
1364                         return (ushort)value; \r
1365                 }\r
1366 \r
1367                 public static ushort ToUInt16 (ushort value) \r
1368                 { \r
1369                         return value; \r
1370                 }\r
1371 \r
1372                 // ========== UInt32 Conversions ========== //\r
1373 \r
1374                 public static uint ToUInt32 (bool value) \r
1375                 { \r
1376                         return (uint)(value ? 1 : 0); \r
1377                 }\r
1378         \r
1379                 public static uint ToUInt32 (byte value) \r
1380                 { \r
1381                         return (uint)value; \r
1382                 }\r
1383 \r
1384                 public static uint ToUInt32 (char value) \r
1385                 { \r
1386                         return (uint)value; \r
1387                 }\r
1388         \r
1389                 public static uint ToUInt32 (decimal value) \r
1390                 { \r
1391                         if (value > UInt32.MaxValue || value < UInt32.MinValue) \r
1392                                 throw new OverflowException\r
1393                                 ("Value is greater than UInt32.MaxValue or less than UInt32.MinValue");\r
1394           \r
1395                         // Returned Even-Rounded\r
1396                         return (uint)(Math.Round (value));        \r
1397                 }\r
1398 \r
1399                 public static uint ToUInt32 (double value) \r
1400                 { \r
1401                         if (value > UInt32.MaxValue || value < UInt32.MinValue) \r
1402                                 throw new OverflowException\r
1403                                 ("Value is greater than UInt32.MaxValue or less than UInt32.MinValue");\r
1404           \r
1405                         // Returned Even-Rounded\r
1406                         return (uint)(Math.Round (value));        \r
1407                 }\r
1408  \r
1409                 public static uint ToUInt32 (float value) \r
1410                 { \r
1411                         if (value > UInt32.MaxValue || value < UInt32.MinValue) \r
1412                                 throw new OverflowException\r
1413                                 ("Value is greater than UInt32.MaxValue or less than UInt32.MinValue");\r
1414           \r
1415                         // Returned Even-Rounded, pass as double to Math\r
1416                         return (uint)(Math.Round ( (double)value));\r
1417                 }\r
1418 \r
1419                 public static uint ToUInt32 (int value) \r
1420                 { \r
1421                         if (value < UInt32.MinValue) \r
1422                                 throw new OverflowException\r
1423                                 ("Value is less than UInt32.MinValue");\r
1424 \r
1425                         return (uint)value; \r
1426                 }\r
1427         \r
1428                 public static uint ToUInt32 (long value) \r
1429                 { \r
1430                         if (value > UInt32.MaxValue || value < UInt32.MinValue) \r
1431                                 throw new OverflowException\r
1432                                 ("Value is greater than UInt32.MaxValue or less than UInt32.MinValue");\r
1433 \r
1434                         return (uint)value; \r
1435                 }\r
1436 \r
1437                 public static uint ToUInt32 (sbyte value) \r
1438                 { \r
1439                         if (value < UInt32.MinValue) \r
1440                                 throw new OverflowException\r
1441                                 ("Value is less than UInt32.MinValue");\r
1442 \r
1443                         return (uint)value; \r
1444                 }\r
1445         \r
1446                 public static uint ToUInt32 (short value) \r
1447                 { \r
1448                         if (value < UInt32.MinValue) \r
1449                                 throw new OverflowException\r
1450                                 ("Value is less than UInt32.MinValue");\r
1451 \r
1452                         return (uint)value; \r
1453                 }\r
1454 \r
1455                 public static uint ToUInt32 (string value) \r
1456                 {\r
1457                         return UInt32.Parse (value);\r
1458                 }\r
1459 \r
1460                 public static uint ToUInt32 (string value, IFormatProvider provider) \r
1461                 {\r
1462                         return UInt32.Parse (value, provider);\r
1463                 }\r
1464         \r
1465                 public static uint ToUInt32 (uint value) \r
1466                 { \r
1467                         return value; \r
1468                 }\r
1469 \r
1470                 public static uint ToUInt32 (ulong value) \r
1471                 { \r
1472                         if (value > UInt32.MaxValue) \r
1473                                 throw new OverflowException\r
1474                                 ("Value is greater than UInt32.MaxValue");\r
1475 \r
1476                         return (uint)value; \r
1477                 }\r
1478 \r
1479                 public static uint ToUInt32 (ushort value) \r
1480                 { \r
1481                         return (uint)value; \r
1482                 }\r
1483 \r
1484                 // ========== UInt64 Conversions ========== //\r
1485 \r
1486                 public static ulong ToUInt64 (bool value) \r
1487                 { \r
1488                         return (ulong)(value ? 1 : 0); \r
1489                 }\r
1490         \r
1491                 public static ulong ToUInt64 (byte value) \r
1492                 { \r
1493                         return (ulong)value; \r
1494                 }\r
1495 \r
1496                 public static ulong ToUInt64 (char value) \r
1497                 { \r
1498                         return (ulong)value; \r
1499                 }\r
1500         \r
1501                 public static ulong ToUInt64 (decimal value) \r
1502                 { \r
1503                         if (value > UInt64.MaxValue || value < UInt64.MinValue) \r
1504                                 throw new OverflowException\r
1505                                 ("Value is greater than UInt64.MaxValue or less than UInt64.MinValue");\r
1506           \r
1507                         // Returned Even-Rounded\r
1508                         return (ulong)(Math.Round (value));       \r
1509                 }\r
1510 \r
1511                 public static ulong ToUInt64 (double value) \r
1512                 { \r
1513                         if (value > UInt64.MaxValue || value < UInt64.MinValue) \r
1514                                 throw new OverflowException\r
1515                                 ("Value is greater than UInt64.MaxValue or less than UInt64.MinValue");\r
1516           \r
1517                         // Returned Even-Rounded\r
1518                         return (ulong)(Math.Round (value));       \r
1519                 }\r
1520  \r
1521                 public static ulong ToUInt64 (float value) \r
1522                 { \r
1523                         if (value > UInt64.MaxValue || value < UInt64.MinValue) \r
1524                                 throw new OverflowException\r
1525                                 ("Value is greater than UInt64.MaxValue or less than UInt64.MinValue");\r
1526           \r
1527                         // Returned Even-Rounded, pass as a double to Math\r
1528                         return (ulong)(Math.Round ( (double)value));\r
1529                 }\r
1530 \r
1531                 public static ulong ToUInt64 (int value) \r
1532                 { \r
1533                         if (value < (int)UInt64.MinValue) \r
1534                                 throw new OverflowException\r
1535                                 ("Value is less than UInt64.MinValue");\r
1536 \r
1537                         return (ulong)value; \r
1538                 }\r
1539         \r
1540                 public static ulong ToUInt64 (long value) \r
1541                 { \r
1542                         if (value < (long)UInt64.MinValue) \r
1543                                 throw new OverflowException\r
1544                                 ("Value is less than UInt64.MinValue");\r
1545 \r
1546                         return (ulong)value; \r
1547                 }\r
1548 \r
1549                 public static ulong ToUInt64 (sbyte value) \r
1550                 { \r
1551                         if (value < (sbyte)UInt64.MinValue) \r
1552                                 throw new OverflowException\r
1553                                 ("Value is less than UInt64.MinValue");\r
1554 \r
1555                         return (ulong)value; \r
1556                 }\r
1557         \r
1558                 public static ulong ToUInt64 (short value) \r
1559                 { \r
1560                         if (value < (short)UInt64.MinValue) \r
1561                                 throw new OverflowException\r
1562                                 ("Value is less than UInt64.MinValue");\r
1563 \r
1564                         return (ulong)value; \r
1565                 }\r
1566 \r
1567                 public static ulong ToUInt64 (string value) \r
1568                 {\r
1569                         return UInt64.Parse (value);\r
1570                 }\r
1571 \r
1572                 public static ulong ToUInt64 (string value, IFormatProvider provider) \r
1573                 {\r
1574                         return UInt64.Parse (value, provider);\r
1575                 }\r
1576         \r
1577                 public static ulong ToUInt64 (uint value) \r
1578                 { \r
1579                         return (ulong)value; \r
1580                 }\r
1581 \r
1582                 public static ulong ToUInt64 (ulong value) \r
1583                 { \r
1584                         return value; \r
1585                 }\r
1586 \r
1587                 public static ulong ToUInt64 (ushort value) \r
1588                 { \r
1589                         return (ulong)value; \r
1590                 }\r
1591 \r
1592                 // ========== Conversion / Helper Fucntions ========== //\r
1593         \r
1594                 // Lookup table for the conversion ToType method. Order\r
1595                 // is important! Used by ToType for comparing the target\r
1596                 // type, and uses hardcoded array indexes.\r
1597                 private static Type[] conversionTable = {\r
1598                         // Valid ICovnertible Types\r
1599                         typeof (Boolean),  //  0 TypeCode.Boolean\r
1600                         typeof (Byte),     //  1 TypeCode.Byte\r
1601                         typeof (Char),     //  2 TypeCode.Char\r
1602                         typeof (DateTime), //  3 TypeCode.DateTime\r
1603                         typeof (Decimal),  //  4 TypeCode.Decimal\r
1604                         typeof (Double),   //  5 TypeCode.Double\r
1605                         typeof (Int16),    //  6 TypeCode.Int16\r
1606                         typeof (Int32),    //  7 TypeCode.Int32\r
1607                         typeof (Int64),    //  8 TypeCode.Int64\r
1608                         typeof (SByte),    //  9 TypeCode.Sbyte\r
1609                         typeof (Single),   // 10 TypeCode.Single\r
1610                         typeof (String),   // 11 TypeCode.String\r
1611                         typeof (UInt16),   // 12 TypeCode.UInt16\r
1612                         typeof (UInt32),   // 13 TypeCode.UInt32\r
1613                         typeof (UInt64),   // 14 TypeCode.UInt64\r
1614           \r
1615                         // Invalid IConvertible Interface Types\r
1616                         typeof (Object)    // 15 TypeCode.Object\r
1617                 };\r
1618 \r
1619                 // Function to convert an object to another type and return\r
1620                 // it as an object. In place for the core data types to use\r
1621                 // when implementing IConvertible. Uses hardcoded indexes in \r
1622                 // the conversionTypes array, so if modify carefully.\r
1623                 internal static object ToType (object value, Type conversionType, \r
1624                                                IFormatProvider provider) \r
1625                 {\r
1626                         if (value == null)\r
1627                                 throw new ArgumentException\r
1628                                 ("Invalid conversion from null value");\r
1629 \r
1630                         if (value is IConvertible) {\r
1631                                 IConvertible convertValue = (IConvertible)value;\r
1632 \r
1633                                 if (conversionType == conversionTable[0]) {\r
1634                                         // 0 TypeCode.Boolean\r
1635                                         return (object)(convertValue.ToBoolean (provider));\r
1636 \r
1637                                 } else if (conversionType == conversionTable[1]) {\r
1638                                         // 1 TypeCode.Byte\r
1639                                         return (object)(convertValue.ToByte (provider));\r
1640                   \r
1641                                 } else if (conversionType == conversionTable[2]) {\r
1642                                         // 2 TypeCode.Char\r
1643                                         return (object)(convertValue.ToChar (provider));\r
1644                   \r
1645                                 } else if (conversionType == conversionTable[3]) {\r
1646                                         // 3 TypeCode.DateTime\r
1647                                         return (object)(convertValue.ToDateTime (provider));\r
1648                   \r
1649                                 } else if (conversionType == conversionTable[4]) {\r
1650                                         // 4 TypeCode.Decimal\r
1651                                         return (object)(convertValue.ToDecimal (provider));\r
1652                   \r
1653                                 } else if (conversionType == conversionTable[5]) {\r
1654                                         // 5 TypeCode.Double\r
1655                                         return (object)(convertValue.ToDouble (provider));\r
1656 \r
1657                                 } else if (conversionType == conversionTable[6]) {\r
1658                                         // 6 TypeCode.Int16\r
1659                                         return (object)(convertValue.ToInt16 (provider));\r
1660                   \r
1661                                 } else if (conversionType == conversionTable[7]) {\r
1662                                         // 7 TypeCode.Int32\r
1663                                         return (object)(convertValue.ToInt32 (provider));\r
1664                   \r
1665                                 } else if (conversionType == conversionTable[8]) {\r
1666                                         // 8 TypeCode.Int64\r
1667                                         return (object)(convertValue.ToInt64 (provider));\r
1668                   \r
1669                                 } else if (conversionType == conversionTable[9]) {\r
1670                                         // 9 TypeCode.Sbyte\r
1671                                         return (object)(convertValue.ToSByte (provider));\r
1672                   \r
1673                                 } else if (conversionType == conversionTable[10]) {\r
1674                                         // 10 TypeCode.Single\r
1675                                         return (object)(convertValue.ToSingle (provider));\r
1676                   \r
1677                                 } else if (conversionType == conversionTable[11]) {\r
1678                                         // 11 TypeCode.String\r
1679                                         return (object)(convertValue.ToString (provider));\r
1680                   \r
1681                                 } else if (conversionType == conversionTable[12]) {  \r
1682                                         // 12 TypeCode.UInt16\r
1683                                         return (object)(convertValue.ToUInt16 (provider));\r
1684                   \r
1685                                 } else if (conversionType == conversionTable[13]) {\r
1686                                         // 13 TypeCode.UInt32\r
1687                                         return (object)(convertValue.ToUInt32 (provider));\r
1688                   \r
1689                                 } else if (conversionType == conversionTable[14]) {\r
1690                                         // 14 TypeCode.UInt64\r
1691                                         return (object)(convertValue.ToUInt64 (provider));\r
1692 \r
1693                                 } else if (conversionType == conversionTable[15]) {\r
1694                                         // 15 TypeCode.Object\r
1695                                         return (object)(value);\r
1696 \r
1697                                 } else  {               \r
1698                                         // Not in the conversion table\r
1699                                         throw new InvalidCastException\r
1700                                         ("Unknown target conversion type");\r
1701                                 }\r
1702                         } else {\r
1703                                 // Value is not IConvertible\r
1704                                 throw new ArgumentException\r
1705                                 ("Value is not a convertible object");\r
1706                         }\r
1707                 }\r
1708         }\r
1709 }\r