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