mcs/class/corlib/System/Convert.cs

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