5 // Derek Holden (dholden@draper.com)
7 // (C) Ximian, Inc. http://www.ximian.com
11 // System.Convert class. This was written word for word off the
12 // Library specification for System.Convert in the ECMA TC39 TG2
13 // and TG3 working documents. The first page of which has a table
14 // for all legal conversion scenerios.
16 // This header and the one above it can be formatted however, just trying
17 // to keep it consistent w/ the existing mcs headers.
19 // This Convert class could be written another way, with each type
20 // implementing IConvertible and defining their own conversion functions,
21 // and this class just calling the type's implementation. Or, they can
22 // be defined here and the implementing type can use these functions when
23 // defining their IConvertible interface. Byte's ToBoolean() calls
24 // Convert.ToBoolean(byte), or Convert.ToBoolean(byte) calls
25 // byte.ToBoolean(). The first case is what is done here.
27 // See http://lists.ximian.com/archives/public/mono-list/2001-July/000525.html
29 // There are also conversion functions that are not defined in
30 // the ECMA draft, such as there is no bool ToBoolean(DateTime value),
31 // and placing that somewhere won't compile w/ this Convert since the
32 // function doesn't exist. However calling that when using Microsoft's
33 // System.Convert doesn't produce any compiler errors, it just throws
34 // an InvalidCastException at runtime.
36 // Whenever a decimal, double, or single is converted to an integer
37 // based type, it is even rounded. This uses Math.Round which only
38 // has Round(decimal) and Round(double), so in the Convert from
39 // single cases the value is passed to Math as a double. This
40 // may not be completely necessary.
42 // The .NET Framework SDK lists DBNull as a member of this class
43 // as 'public static readonly object DBNull;'.
45 // It should also be decided if all the cast return values should be
46 // returned as unchecked or not.
48 // All the XML function comments were auto generated which is why they
49 // sound someone redundant.
51 // TYPE | BOOL BYTE CHAR DT DEC DBL I16 I32 I64 SBYT SNGL STR UI16 UI32 UI64
52 // -----+--------------------------------------------------------------------
53 // BOOL | X X X X X X X X X X X X X
54 // BYTE | X X X X X X X X X X X X X X
55 // CHAR | X X X X X X X X X X
57 // DEC | X X X X X X X X X X X X X
58 // DBL | X X X X X X X X X X X X X
59 // I16 | X X X X X X X X X X X X X X
60 // I32 | X X X X X X X X X X X X X X
61 // I64 | X X X X X X X X X X X X X X
62 // SBYT | X X X X X X X X X X X X X X
63 // SNGL | X X X X X X X X X X X X X
64 // STR | X X X X X X X X X X X X X X X
65 // UI16 | X X X X X X X X X X X X X X
66 // UI32 | X X X X X X X X X X X X X X
67 // UI64 | X X X X X X X X X X X X X X
72 public sealed class Convert {
74 // ========== Boolean Conversions ========== //
76 public static bool ToBoolean (bool value)
81 public static bool ToBoolean (byte value)
86 public static bool ToBoolean (decimal value)
91 public static bool ToBoolean (double value)
96 public static bool ToBoolean (float value)
101 public static bool ToBoolean (int value)
106 public static bool ToBoolean (long value)
111 public static bool ToBoolean (sbyte value)
116 public static bool ToBoolean (short value)
121 public static bool ToBoolean (string value)
123 return Boolean.Parse (value);
126 public static bool ToBoolean (uint value)
131 public static bool ToBoolean (ulong value)
136 public static bool ToBoolean (ushort value)
141 // ========== Byte Conversions ========== //
143 public static byte ToByte (bool value)
145 return (byte)(value ? 1 : 0);
148 public static byte ToByte (byte value)
153 public static byte ToByte (char value)
155 if (value > Byte.MaxValue)
156 throw new OverflowException
157 ("Value is greater than Byte.MaxValue");
162 public static byte ToByte (decimal value)
164 if (value > Byte.MaxValue || value < Byte.MinValue)
165 throw new OverflowException
166 ("Value is greater than Byte.MaxValue or less than Byte.MinValue");
168 // Returned Even-Rounded
169 return (byte)(Math.Round (value));
172 public static byte ToByte (double value)
174 if (value > Byte.MaxValue || value < Byte.MinValue)
175 throw new OverflowException
176 ("Value is greater than Byte.MaxValue or less than Byte.MinValue");
178 // This and the float version of ToByte are the only ones
179 // the spec listed as checking for .NaN and Infinity overflow
180 if (Double.IsNaN(value) || Double.IsInfinity(value))
181 throw new OverflowException
182 ("Value is equal to Double.NaN, Double.PositiveInfinity, or Double.NegativeInfinity");
184 // Returned Even-Rounded
185 return (byte)(Math.Round (value));
188 public static byte ToByte (float value)
190 if (value > Byte.MaxValue || value < Byte.MinValue)
191 throw new OverflowException
192 ("Value is greater than Byte.MaxValue or less than Byte.Minalue");
194 // This and the double version of ToByte are the only ones
195 // the spec listed as checking for .NaN and Infinity overflow
196 if (Single.IsNaN(value) || Single.IsInfinity(value))
197 throw new OverflowException
198 ("Value is equal to Single.NaN, Single.PositiveInfinity, or Single.NegativeInfinity");
200 // Returned Even-Rounded, pass it as a double, could have this
201 // method just call Convert.ToByte ( (double)value)
202 return (byte)(Math.Round ( (double)value));
205 public static byte ToByte (int value)
207 if (value > Byte.MaxValue || value < Byte.MinValue)
208 throw new OverflowException
209 ("Value is greater than Byte.MaxValue or less than Byte.MinValue");
214 public static byte ToByte (long value)
216 if (value > Byte.MaxValue || value < Byte.MinValue)
217 throw new OverflowException
218 ("Value is greater than Byte.MaxValue or less than Byte.MinValue");
223 public static byte ToByte (sbyte value)
225 if (value < Byte.MinValue)
226 throw new OverflowException
227 ("Value is less than Byte.MinValue");
232 public static byte ToByte (short value)
234 if (value > Byte.MaxValue || value < Byte.MinValue)
235 throw new OverflowException
236 ("Value is greater than Byte.MaxValue or less than Byte.MinValue");
241 public static byte ToByte (string value)
243 return Byte.Parse (value);
246 public static byte ToByte (string value, IFormatProvider provider)
248 return Byte.Parse (value, provider);
251 public static byte ToByte (uint value)
253 if (value > Byte.MaxValue)
254 throw new OverflowException
255 ("Value is greater than Byte.MaxValue");
260 public static byte ToByte (ulong value)
262 if (value > Byte.MaxValue)
263 throw new OverflowException
264 ("Value is greater than Byte.MaxValue");
269 public static byte ToByte (ushort value)
271 if (value > Byte.MaxValue)
272 throw new OverflowException
273 ("Value is greater than Byte.MaxValue");
278 // ========== Char Conversions ========== //
280 public static char ToChar (byte value)
285 public static char ToChar (char value)
290 public static char ToChar (int value)
292 if (value > Char.MaxValue || value < Char.MinValue)
293 throw new OverflowException
294 ("Value is greater than Char.MaxValue or less than Char.MinValue");
299 public static char ToChar (long value)
301 if (value > Char.MaxValue || value < Char.MinValue)
302 throw new OverflowException
303 ("Value is greater than Char.MaxValue or less than Char.MinValue");
308 public static char ToChar (sbyte value)
310 if (value < Char.MinValue)
311 throw new OverflowException
312 ("Value is less than Char.MinValue");
317 public static char ToChar (short value)
319 if (value < Char.MinValue)
320 throw new OverflowException
321 ("Value is less than Char.MinValue");
326 public static char ToChar (string value)
328 return Char.Parse (value);
331 public static char ToChar (uint value)
333 if (value > Char.MaxValue)
334 throw new OverflowException
335 ("Value is greater than Char.MaxValue");
340 public static char ToChar (ulong value)
342 if (value > Char.MaxValue)
343 throw new OverflowException
344 ("Value is greater than Char.MaxValue");
349 public static char ToChar (ushort value)
351 if (value > Char.MaxValue)
352 throw new OverflowException
353 ("Value is greater than Char.MaxValue");
358 // ========== DateTime Conversions ========== //
360 public static DateTime ToDateTime (string value)
362 return DateTime.Parse (value);
365 public static DateTime ToDateTime (string value, IFormatProvider provider)
367 return DateTime.Parse (value, provider);
370 // ========== Decimal Conversions ========== //
372 public static decimal ToDecimal (bool value)
374 return value ? 1 : 0;
377 public static decimal ToDecimal (byte value)
379 return (decimal)value;
382 public static decimal ToDecimal (decimal value)
387 public static decimal ToDecimal (double value)
389 if (value > (double)Decimal.MaxValue || value < (double)Decimal.MinValue)
390 throw new OverflowException
391 ("Value is greater than Decimal.MaxValue or less than Decimal.MinValue");
393 return (decimal)value;
396 public static decimal ToDecimal (float value)
398 if (value > (double)Decimal.MaxValue || value < (double)Decimal.MinValue)
399 throw new OverflowException
400 ("Value is greater than Decimal.MaxValue or less than Decimal.MinValue");
402 return (decimal)value;
405 public static decimal ToDecimal (int value)
407 return (decimal)value;
410 public static decimal ToDecimal (long value)
412 return (decimal)value;
415 public static decimal ToDecimal (sbyte value)
417 return (decimal)value;
420 public static decimal ToDecimal (short value)
422 return (decimal)value;
425 public static decimal ToDecimal (string value)
427 return Decimal.Parse (value);
430 public static decimal ToDecimal (string value, IFormatProvider provider)
432 return Decimal.Parse (value, provider);
435 public static decimal ToDecimal (uint value)
437 return (decimal)value;
440 public static decimal ToDecimal (ulong value)
442 return (decimal)value;
445 public static decimal ToDecimal (ushort value)
447 return (decimal)value;
450 // ========== Double Conversions ========== //
452 public static double ToDouble (bool value)
454 return value ? 1 : 0;
457 public static double ToDouble (byte value)
459 return (double)value;
462 public static double ToDouble (decimal value)
464 return (double)value;
467 public static double ToDouble (double value)
472 public static double ToDouble (float value)
474 return (double)value;
477 public static double ToDouble (int value)
479 return (double)value;
482 public static double ToDouble (long value)
484 return (double)value;
487 public static double ToDouble (sbyte value)
489 return (double)value;
492 public static double ToDouble (short value)
494 return (double)value;
497 public static double ToDouble (string value)
499 return Double.Parse (value);
502 public static double ToDouble (string value, IFormatProvider provider)
504 return Double.Parse (value, provider);
507 public static double ToDouble (uint value)
509 return (double)value;
512 public static double ToDouble (ulong value)
514 return (double)value;
517 public static double ToDouble (ushort value)
519 return (double)value;
522 // ========== Int16 Conversions ========== //
524 public static short ToInt16 (bool value)
526 return (short)(value ? 1 : 0);
529 public static short ToInt16 (byte value)
534 public static short ToInt16 (char value)
536 if (value > Int16.MaxValue)
537 throw new OverflowException
538 ("Value is greater than Int16.MaxValue");
543 public static short ToInt16 (decimal value)
545 if (value > Int16.MaxValue || value < Int16.MinValue)
546 throw new OverflowException
547 ("Value is greater than Int16.MaxValue or less than Int16.MinValue");
549 // Returned Even-Rounded
550 return (short)(Math.Round (value));
553 public static short ToInt16 (double value)
555 if (value > Int16.MaxValue || value < Int16.MinValue)
556 throw new OverflowException
557 ("Value is greater than Int16.MaxValue or less than Int16.MinValue");
559 // Returned Even-Rounded
560 return (short)(Math.Round (value));
563 public static short ToInt16 (float value)
565 if (value > Int16.MaxValue || value < Int16.MinValue)
566 throw new OverflowException
567 ("Value is greater than Int16.MaxValue or less than Int16.MinValue");
569 // Returned Even-Rounded, use Math.Round pass as a double.
570 return (short)Math.Round ( (double)value);
573 public static short ToInt16 (int value)
575 if (value > Int16.MaxValue || value < Int16.MinValue)
576 throw new OverflowException
577 ("Value is greater than Int16.MaxValue or less than Int16.MinValue");
582 public static short ToInt16 (long value)
584 if (value > Int16.MaxValue || value < Int16.MinValue)
585 throw new OverflowException
586 ("Value is greater than Int16.MaxValue or less than Int16.MinValue");
591 public static short ToInt16 (sbyte value)
596 public static short ToInt16 (short value)
601 public static short ToInt16 (string value)
603 return Int16.Parse (value);
606 public static short ToInt16 (string value, IFormatProvider provider)
608 return Int16.Parse (value, provider);
611 public static short ToInt16 (uint value)
613 if (value > Int16.MaxValue)
614 throw new OverflowException
615 ("Value is greater than Int16.MaxValue");
620 public static short ToInt16 (ulong value)
622 if (value > (ulong)Int16.MaxValue)
623 throw new OverflowException
624 ("Value is greater than Int16.MaxValue");
629 public static short ToInt16 (ushort value)
631 if (value > Int16.MaxValue)
632 throw new OverflowException
633 ("Value is greater than Int16.MaxValue");
638 // ========== Int32 Conversions ========== //
640 public static int ToInt32 (bool value)
642 return value ? 1 : 0;
645 public static int ToInt32 (byte value)
650 public static int ToInt32 (char value)
655 public static int ToInt32 (decimal value)
657 if (value > Int32.MaxValue || value < Int32.MinValue)
658 throw new OverflowException
659 ("Value is greater than Int32.MaxValue or less than Int32.MinValue");
661 // Returned Even-Rounded
662 return (int)(Math.Round (value));
665 public static int ToInt32 (double value)
667 if (value > Int32.MaxValue || value < Int32.MinValue)
668 throw new OverflowException
669 ("Value is greater than Int32.MaxValue or less than Int32.MinValue");
671 // Returned Even-Rounded
672 return (int)(Math.Round (value));
675 public static int ToInt32 (float value)
677 if (value > Int32.MaxValue || value < Int32.MinValue)
678 throw new OverflowException
679 ("Value is greater than Int32.MaxValue or less than Int32.MinValue");
681 // Returned Even-Rounded, pass as a double, could just call
682 // Convert.ToInt32 ( (double)value);
683 return (int)(Math.Round ( (double)value));
686 public static int ToInt32 (int value)
691 public static int ToInt32 (long value)
693 if (value > Int32.MaxValue || value < Int32.MinValue)
694 throw new OverflowException
695 ("Value is greater than Int32.MaxValue or less than Int32.MinValue");
700 public static int ToInt32 (sbyte value)
705 public static int ToInt32 (short value)
710 public static int ToInt32 (string value)
712 return Int32.Parse (value);
715 public static int ToInt32 (string value, IFormatProvider provider)
717 return Int32.Parse (value, provider);
720 public static int ToInt32 (uint value)
722 if (value > Int32.MaxValue)
723 throw new OverflowException
724 ("Value is greater than Int32.MaxValue");
729 public static int ToInt32 (ulong value)
731 if (value > Int32.MaxValue)
732 throw new OverflowException
733 ("Value is greater than Int32.MaxValue");
738 public static int ToInt32 (ushort value)
743 // ========== Int64 Conversions ========== //
745 public static long ToInt64 (bool value)
747 return value ? 1 : 0;
750 public static long ToInt64 (byte value)
755 public static long ToInt64 (char value)
760 public static long ToInt64 (decimal value)
762 if (value > Int64.MaxValue || value < Int64.MinValue)
763 throw new OverflowException
764 ("Value is greater than Int64.MaxValue or less than Int64.MinValue");
766 // Returned Even-Rounded
767 return (long)(Math.Round (value));
770 public static long ToInt64 (double value)
772 if (value > Int64.MaxValue || value < Int64.MinValue)
773 throw new OverflowException
774 ("Value is greater than Int64.MaxValue or less than Int64.MinValue");
776 // Returned Even-Rounded
777 return (long)(Math.Round (value));
780 public static long ToInt64 (float value)
782 if (value > Int64.MaxValue || value < Int64.MinValue)
783 throw new OverflowException
784 ("Value is greater than Int64.MaxValue or less than Int64.MinValue");
786 // Returned Even-Rounded, pass to Math as a double, could
787 // just call Convert.ToInt64 ( (double)value);
788 return (long)(Math.Round ( (double)value));
791 public static long ToInt64 (int value)
796 public static long ToInt64 (long value)
801 public static long ToInt64 (sbyte value)
806 public static long ToInt64 (short value)
811 public static long ToInt64 (string value)
813 return Int64.Parse (value);
816 public static long ToInt64 (string value, IFormatProvider provider)
818 return Int64.Parse (value, provider);
821 public static long ToInt64 (uint value)
826 public static long ToInt64 (ulong value)
828 if (value > Int64.MaxValue)
829 throw new OverflowException
830 ("Value is greater than Int64.MaxValue");
835 public static long ToInt64 (ushort value)
840 // ========== SByte Conversions ========== //
842 public static sbyte ToSByte (bool value)
844 return (sbyte)(value ? 1 : 0);
847 public static sbyte ToSByte (byte value)
849 if (value > SByte.MaxValue)
850 throw new OverflowException
851 ("Value is greater than SByte.MaxValue");
856 public static sbyte ToSByte (char value)
858 if (value > SByte.MaxValue)
859 throw new OverflowException
860 ("Value is greater than SByte.MaxValue");
865 public static sbyte ToSByte (decimal value)
867 if (value > SByte.MaxValue || value < SByte.MinValue)
868 throw new OverflowException
869 ("Value is greater than SByte.MaxValue or less than SByte.MinValue");
871 // Returned Even-Rounded
872 return (sbyte)(Math.Round (value));
875 public static sbyte ToSByte (double value)
877 if (value > SByte.MaxValue || value < SByte.MinValue)
878 throw new OverflowException
879 ("Value is greater than SByte.MaxValue or less than SByte.MinValue");
881 // Returned Even-Rounded
882 return (sbyte)(Math.Round (value));
885 public static sbyte ToSByte (float value)
887 if (value > SByte.MaxValue || value < SByte.MinValue)
888 throw new OverflowException
889 ("Value is greater than SByte.MaxValue or less than SByte.Minalue");
891 // Returned Even-Rounded, pass as double to Math
892 return (sbyte)(Math.Round ( (double)value));
895 public static sbyte ToSByte (int value)
897 if (value > SByte.MaxValue || value < SByte.MinValue)
898 throw new OverflowException
899 ("Value is greater than SByte.MaxValue or less than SByte.MinValue");
904 public static sbyte ToSByte (long value)
906 if (value > SByte.MaxValue || value < SByte.MinValue)
907 throw new OverflowException
908 ("Value is greater than SByte.MaxValue or less than SByte.MinValue");
913 public static sbyte ToSByte (sbyte value)
918 public static sbyte ToSByte (short value)
920 if (value > SByte.MaxValue || value < SByte.MinValue)
921 throw new OverflowException
922 ("Value is greater than SByte.MaxValue or less than SByte.MinValue");
927 public static sbyte ToSByte (string value)
929 return SByte.Parse (value);
932 public static sbyte ToSByte (string value, IFormatProvider provider)
934 return SByte.Parse (value, provider);
937 public static sbyte ToSByte (uint value)
939 if (value > SByte.MaxValue)
940 throw new OverflowException
941 ("Value is greater than SByte.MaxValue");
946 public static sbyte ToSByte (ulong value)
948 if (value > (ulong)SByte.MaxValue)
949 throw new OverflowException
950 ("Value is greater than SByte.MaxValue");
955 public static sbyte ToSByte (ushort value)
957 if (value > SByte.MaxValue)
958 throw new OverflowException
959 ("Value is greater than SByte.MaxValue");
964 // ========== Single Conversions ========== //
966 public static float ToSingle (bool value)
968 return value ? 1 : 0;
971 public static float ToSingle (byte value)
976 public static float ToSingle (decimal value)
981 public static float ToSingle (double value)
983 if (value > Single.MaxValue || value < Single.MinValue)
984 throw new OverflowException
985 ("Value is greater than Single.MaxValue or less than Single.MinValue");
990 public static float ToSingle (float value)
995 public static float ToSingle (int value)
1000 public static float ToSingle (long value)
1002 return (float)value;
1005 public static float ToSingle (sbyte value)
1007 return (float)value;
1010 public static float ToSingle (short value)
1012 return (float)value;
1015 public static float ToSingle (string value)
1017 return Single.Parse (value);
1020 public static float ToSingle (string value, IFormatProvider provider)
1022 return Single.Parse (value, provider);
1025 public static float ToSingle (uint value)
1027 return (float)value;
1030 public static float ToSingle (ulong value)
1032 return (float)value;
1035 public static float ToSingle (ushort value)
1037 return (float)value;
1040 // ========== String Conversions ========== //
1042 public static string ToString (bool value)
1044 return value.ToString ();
1047 public static string ToString (byte value)
1049 return value.ToString ();
1052 public static string ToString (byte value, IFormatProvider provider)
1054 return value.ToString (provider);
1057 public static string ToString (char value)
1059 return value.ToString ();
1062 public static string ToString (DateTime value)
1064 return value.ToString ();
1067 public static string ToString (DateTime value, IFormatProvider provider)
1069 return value.ToString (provider);
1072 public static string ToString (decimal value)
1074 return value.ToString ();
1077 public static string ToString (decimal value, IFormatProvider provider)
1079 return value.ToString (provider);
1082 public static string ToString (double value)
1084 return value.ToString ();
1087 public static string ToString (double value, IFormatProvider provider)
1089 return value.ToString (provider);
1092 public static string ToString (float value)
1094 return value.ToString ();
1097 public static string ToString (float value, IFormatProvider provider)
1099 return value.ToString (provider);
1102 public static string ToString (int value)
1104 return value.ToString ();
1107 public static string ToString (int value, IFormatProvider provider)
1109 return value.ToString (provider);
1112 public static string ToString (long value)
1114 return value.ToString ();
1117 public static string ToString (long value, IFormatProvider provider)
1119 return value.ToString (provider);
1122 public static string ToString (sbyte value)
1124 return value.ToString ();
1127 public static string ToString (sbyte value, IFormatProvider provider)
1129 return value.ToString (provider);
1132 public static string ToString (short value)
1134 return value.ToString ();
1137 public static string ToString (short value, IFormatProvider provider)
1139 return value.ToString (provider);
1142 public static string ToString (string value)
1147 public static string ToString (uint value)
1149 return value.ToString ();
1152 public static string ToString (uint value, IFormatProvider provider)
1154 return value.ToString (provider);
1157 public static string ToString (ulong value)
1159 return value.ToString ();
1162 public static string ToString (ulong value, IFormatProvider provider)
1164 return value.ToString (provider);
1167 public static string ToString (ushort value)
1169 return value.ToString ();
1172 public static string ToString (ushort value, IFormatProvider provider)
1174 return value.ToString (provider);
1177 // ========== UInt16 Conversions ========== //
1179 public static ushort ToUInt16 (bool value)
1181 return (ushort)(value ? 1 : 0);
1184 public static ushort ToUInt16 (byte value)
1186 return (ushort)value;
1189 public static ushort ToUInt16 (char value)
1191 return (ushort)value;
1194 public static ushort ToUInt16 (decimal value)
1196 if (value > UInt16.MaxValue || value < UInt16.MinValue)
1197 throw new OverflowException
1198 ("Value is greater than UInt16.MaxValue or less than UInt16.MinValue");
1200 // Returned Even-Rounded
1201 return (ushort)(Math.Round (value));
1204 public static ushort ToUInt16 (double value)
1206 if (value > UInt16.MaxValue || value < UInt16.MinValue)
1207 throw new OverflowException
1208 ("Value is greater than UInt16.MaxValue or less than UInt16.MinValue");
1210 // Returned Even-Rounded
1211 return (ushort)(Math.Round (value));
1214 public static ushort ToUInt16 (float value)
1216 if (value > UInt16.MaxValue || value < UInt16.MinValue)
1217 throw new OverflowException
1218 ("Value is greater than UInt16.MaxValue or less than UInt16.MinValue");
1220 // Returned Even-Rounded, pass as double to Math
1221 return (ushort)(Math.Round ( (double)value));
1224 public static ushort ToUInt16 (int value)
1226 if (value > UInt16.MaxValue || value < UInt16.MinValue)
1227 throw new OverflowException
1228 ("Value is greater than UInt16.MaxValue or less than UInt16.MinValue");
1230 return (ushort)value;
1233 public static ushort ToUInt16 (long value)
1235 if (value > UInt16.MaxValue || value < UInt16.MinValue)
1236 throw new OverflowException
1237 ("Value is greater than UInt16.MaxValue or less than UInt16.MinValue");
1239 return (ushort)value;
1242 public static ushort ToUInt16 (sbyte value)
1244 if (value < UInt16.MinValue)
1245 throw new OverflowException
1246 ("Value is less than UInt16.MinValue");
1248 return (ushort)value;
1251 public static ushort ToUInt16 (short value)
1253 if (value < UInt16.MinValue)
1254 throw new OverflowException
1255 ("Value is less than UInt16.MinValue");
1257 return (ushort)value;
1260 public static ushort ToUInt16 (string value)
1262 return UInt16.Parse (value);
1265 public static ushort ToUInt16 (string value, IFormatProvider provider)
1267 return UInt16.Parse (value, provider);
1270 public static ushort ToUInt16 (uint value)
1272 if (value > UInt16.MaxValue)
1273 throw new OverflowException
1274 ("Value is greater than UInt16.MaxValue");
1276 return (ushort)value;
1279 public static ushort ToUInt16 (ulong value)
1281 if (value > (ulong)UInt16.MaxValue)
1282 throw new OverflowException
1283 ("Value is greater than UInt16.MaxValue");
1285 return (ushort)value;
1288 public static ushort ToUInt16 (ushort value)
1293 // ========== UInt32 Conversions ========== //
1295 public static uint ToUInt32 (bool value)
1297 return (uint)(value ? 1 : 0);
1300 public static uint ToUInt32 (byte value)
1305 public static uint ToUInt32 (char value)
1310 public static uint ToUInt32 (decimal value)
1312 if (value > UInt32.MaxValue || value < UInt32.MinValue)
1313 throw new OverflowException
1314 ("Value is greater than UInt32.MaxValue or less than UInt32.MinValue");
1316 // Returned Even-Rounded
1317 return (uint)(Math.Round (value));
1320 public static uint ToUInt32 (double value)
1322 if (value > UInt32.MaxValue || value < UInt32.MinValue)
1323 throw new OverflowException
1324 ("Value is greater than UInt32.MaxValue or less than UInt32.MinValue");
1326 // Returned Even-Rounded
1327 return (uint)(Math.Round (value));
1330 public static uint ToUInt32 (float value)
1332 if (value > UInt32.MaxValue || value < UInt32.MinValue)
1333 throw new OverflowException
1334 ("Value is greater than UInt32.MaxValue or less than UInt32.MinValue");
1336 // Returned Even-Rounded, pass as double to Math
1337 return (uint)(Math.Round ( (double)value));
1340 public static uint ToUInt32 (int value)
1342 if (value < UInt32.MinValue)
1343 throw new OverflowException
1344 ("Value is less than UInt32.MinValue");
1349 public static uint ToUInt32 (long value)
1351 if (value > UInt32.MaxValue || value < UInt32.MinValue)
1352 throw new OverflowException
1353 ("Value is greater than UInt32.MaxValue or less than UInt32.MinValue");
1358 public static uint ToUInt32 (sbyte value)
1360 if (value < UInt32.MinValue)
1361 throw new OverflowException
1362 ("Value is less than UInt32.MinValue");
1367 public static uint ToUInt32 (short value)
1369 if (value < UInt32.MinValue)
1370 throw new OverflowException
1371 ("Value is less than UInt32.MinValue");
1376 public static uint ToUInt32 (string value)
1378 return UInt32.Parse (value);
1381 public static uint ToUInt32 (string value, IFormatProvider provider)
1383 return UInt32.Parse (value, provider);
1386 public static uint ToUInt32 (uint value)
1391 public static uint ToUInt32 (ulong value)
1393 if (value > UInt32.MaxValue)
1394 throw new OverflowException
1395 ("Value is greater than UInt32.MaxValue");
1400 public static uint ToUInt32 (ushort value)
1405 // ========== UInt64 Conversions ========== //
1407 public static ulong ToUInt64 (bool value)
1409 return (ulong)(value ? 1 : 0);
1412 public static ulong ToUInt64 (byte value)
1414 return (ulong)value;
1417 public static ulong ToUInt64 (char value)
1419 return (ulong)value;
1422 public static ulong ToUInt64 (decimal value)
1424 if (value > UInt64.MaxValue || value < UInt64.MinValue)
1425 throw new OverflowException
1426 ("Value is greater than UInt64.MaxValue or less than UInt64.MinValue");
1428 // Returned Even-Rounded
1429 return (ulong)(Math.Round (value));
1432 public static ulong ToUInt64 (double value)
1434 if (value > UInt64.MaxValue || value < UInt64.MinValue)
1435 throw new OverflowException
1436 ("Value is greater than UInt64.MaxValue or less than UInt64.MinValue");
1438 // Returned Even-Rounded
1439 return (ulong)(Math.Round (value));
1442 public static ulong ToUInt64 (float value)
1444 if (value > UInt64.MaxValue || value < UInt64.MinValue)
1445 throw new OverflowException
1446 ("Value is greater than UInt64.MaxValue or less than UInt64.MinValue");
1448 // Returned Even-Rounded, pass as a double to Math
1449 return (ulong)(Math.Round ( (double)value));
1452 public static ulong ToUInt64 (int value)
1454 if (value < (int)UInt64.MinValue)
1455 throw new OverflowException
1456 ("Value is less than UInt64.MinValue");
1458 return (ulong)value;
1461 public static ulong ToUInt64 (long value)
1463 if (value < (long)UInt64.MinValue)
1464 throw new OverflowException
1465 ("Value is less than UInt64.MinValue");
1467 return (ulong)value;
1470 public static ulong ToUInt64 (sbyte value)
1472 if (value < (sbyte)UInt64.MinValue)
1473 throw new OverflowException
1474 ("Value is less than UInt64.MinValue");
1476 return (ulong)value;
1479 public static ulong ToUInt64 (short value)
1481 if (value < (short)UInt64.MinValue)
1482 throw new OverflowException
1483 ("Value is less than UInt64.MinValue");
1485 return (ulong)value;
1488 public static ulong ToUInt64 (string value)
1490 return UInt64.Parse (value);
1493 public static ulong ToUInt64 (string value, IFormatProvider provider)
1495 return UInt64.Parse (value, provider);
1498 public static ulong ToUInt64 (uint value)
1500 return (ulong)value;
1503 public static ulong ToUInt64 (ulong value)
1508 public static ulong ToUInt64 (ushort value)
1510 return (ulong)value;
1513 // ========== Conversion / Helper Fucntions ========== //
1515 // Lookup table for the conversion ToType method. Order
1516 // is important! Used by ToType for comparing the target
1517 // type, and uses hardcoded array indexes.
1518 private static Type[] conversionTable = {
1519 // Valid ICovnertible Types
1520 typeof (Boolean), // 0 TypeCode.Boolean
1521 typeof (Byte), // 1 TypeCode.Byte
1522 typeof (Char), // 2 TypeCode.Char
1523 typeof (DateTime), // 3 TypeCode.DateTime
1524 typeof (Decimal), // 4 TypeCode.Decimal
1525 typeof (Double), // 5 TypeCode.Double
1526 typeof (Int16), // 6 TypeCode.Int16
1527 typeof (Int32), // 7 TypeCode.Int32
1528 typeof (Int64), // 8 TypeCode.Int64
1529 typeof (SByte), // 9 TypeCode.Sbyte
1530 typeof (Single), // 10 TypeCode.Single
1531 typeof (String), // 11 TypeCode.String
1532 typeof (UInt16), // 12 TypeCode.UInt16
1533 typeof (UInt32), // 13 TypeCode.UInt32
1534 typeof (UInt64), // 14 TypeCode.UInt64
1536 // Invalid IConvertible Interface Types
1537 typeof (Object) // 15 TypeCode.Object
1540 // Function to convert an object to another type and return
1541 // it as an object. In place for the core data types to use
1542 // when implementing IConvertible. Uses hardcoded indexes in
1543 // the conversionTypes array, so if modify carefully.
1544 internal static object ToType (object value, Type conversionType,
1545 IFormatProvider provider)
1548 throw new ArgumentException
1549 ("Invalid conversion from null value");
1551 if (value is IConvertible) {
1552 IConvertible convertValue = (IConvertible)value;
1554 if (conversionType == conversionTable[0]) {
1555 // 0 TypeCode.Boolean
1556 return (object)(convertValue.ToBoolean (provider));
1558 } else if (conversionType == conversionTable[1]) {
1560 return (object)(convertValue.ToByte (provider));
1562 } else if (conversionType == conversionTable[2]) {
1564 return (object)(convertValue.ToChar (provider));
1566 } else if (conversionType == conversionTable[3]) {
1567 // 3 TypeCode.DateTime
1568 return (object)(convertValue.ToDateTime (provider));
1570 } else if (conversionType == conversionTable[4]) {
1571 // 4 TypeCode.Decimal
1572 return (object)(convertValue.ToDecimal (provider));
1574 } else if (conversionType == conversionTable[5]) {
1575 // 5 TypeCode.Double
1576 return (object)(convertValue.ToDouble (provider));
1578 } else if (conversionType == conversionTable[6]) {
1580 return (object)(convertValue.ToInt16 (provider));
1582 } else if (conversionType == conversionTable[7]) {
1584 return (object)(convertValue.ToInt32 (provider));
1586 } else if (conversionType == conversionTable[8]) {
1588 return (object)(convertValue.ToInt64 (provider));
1590 } else if (conversionType == conversionTable[9]) {
1592 return (object)(convertValue.ToSByte (provider));
1594 } else if (conversionType == conversionTable[10]) {
1595 // 10 TypeCode.Single
1596 return (object)(convertValue.ToSingle (provider));
1598 } else if (conversionType == conversionTable[11]) {
1599 // 11 TypeCode.String
1600 return (object)(convertValue.ToString (provider));
1602 } else if (conversionType == conversionTable[12]) {
1603 // 12 TypeCode.UInt16
1604 return (object)(convertValue.ToUInt16 (provider));
1606 } else if (conversionType == conversionTable[13]) {
1607 // 13 TypeCode.UInt32
1608 return (object)(convertValue.ToUInt32 (provider));
1610 } else if (conversionType == conversionTable[14]) {
1611 // 14 TypeCode.UInt64
1612 return (object)(convertValue.ToUInt64 (provider));
1614 } else if (conversionType == conversionTable[15]) {
1615 // 15 TypeCode.Object
1616 return (object)(value);
1619 // Not in the conversion table
1620 throw new InvalidCastException
1621 ("Unknown target conversion type");
1624 // Value is not IConvertible
1625 throw new ArgumentException
1626 ("Value is not a convertible object");