mcs/class/corlib/System/Convert.cs

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