diferencia - ¿Cómo convierto uint a int en C#?
byte to int c# (8)
Convert.ToInt32 () toma uint como un valor.
¿Cómo convierto uint a int en C #?
Dado:
uint n = 3;
int i = checked((int)n); //throws OverflowException if n > Int32.MaxValue
int i = unchecked((int)n); //converts the bits only
//i will be negative if n > Int32.MaxValue
int i = (int)n; //same behavior as unchecked
o
int i = Convert.ToInt32(n); //same behavior as checked
--EDITAR
Información incluida según lo mencionado por Kenan EK
Suponiendo que el valor contenido en el uint se puede representar en un int, entonces es tan simple como:
int val = (int) uval;
Suponiendo que quiere simplemente levantar los 32 bits de un tipo y volcarlos tal como están en el otro tipo:
uint asUint = unchecked((uint)myInt);
int asInt = unchecked((int)myUint);
El tipo de destino elegirá ciegamente los 32 bits y los reinterpretará.
Por el contrario, si está más interesado en mantener los valores decimales / numéricos dentro del rango del tipo de destino en sí:
uint asUint = checked((uint)myInt);
int asInt = checked((int)myUint);
En este caso, obtendrá excepciones de desbordamiento si:
- lanzando un int negativo (p. ej .: -1) a un uint
- lanzando un mensaje positivo entre 2,147,483,648 y 4,294,967,295 a un int
En nuestro caso, queríamos la solución unchecked marcar para preservar los 32bits tal como están, así que aquí hay algunos ejemplos:
Ejemplos
int => uint
int....: 0000000000 (00-00-00-00)
asUint.: 0000000000 (00-00-00-00)
------------------------------
int....: 0000000001 (01-00-00-00)
asUint.: 0000000001 (01-00-00-00)
------------------------------
int....: -0000000001 (FF-FF-FF-FF)
asUint.: 4294967295 (FF-FF-FF-FF)
------------------------------
int....: 2147483647 (FF-FF-FF-7F)
asUint.: 2147483647 (FF-FF-FF-7F)
------------------------------
int....: -2147483648 (00-00-00-80)
asUint.: 2147483648 (00-00-00-80)
uint => int
uint...: 0000000000 (00-00-00-00)
asInt..: 0000000000 (00-00-00-00)
------------------------------
uint...: 0000000001 (01-00-00-00)
asInt..: 0000000001 (01-00-00-00)
------------------------------
uint...: 2147483647 (FF-FF-FF-7F)
asInt..: 2147483647 (FF-FF-FF-7F)
------------------------------
uint...: 4294967295 (FF-FF-FF-FF)
asInt..: -0000000001 (FF-FF-FF-FF)
------------------------------
Código
int[] testInts = { 0, 1, -1, int.MaxValue, int.MinValue };
uint[] testUints = { uint.MinValue, 1, uint.MaxValue / 2, uint.MaxValue };
foreach (var Int in testInts)
{
uint asUint = unchecked((uint)Int);
Console.WriteLine("int....: {0:D10} ({1})", Int, BitConverter.ToString(BitConverter.GetBytes(Int)));
Console.WriteLine("asUint.: {0:D10} ({1})", asUint, BitConverter.ToString(BitConverter.GetBytes(asUint)));
Console.WriteLine(new string(''-'',30));
}
Console.WriteLine(new string(''='', 30));
foreach (var Uint in testUints)
{
int asInt = unchecked((int)Uint);
Console.WriteLine("uint...: {0:D10} ({1})", Uint, BitConverter.ToString(BitConverter.GetBytes(Uint)));
Console.WriteLine("asInt..: {0:D10} ({1})", asInt, BitConverter.ToString(BitConverter.GetBytes(asInt)));
Console.WriteLine(new string(''-'', 30));
}
Yo diría que usando tryParse, devolverá ''false'' si el uint es demasiado grande para un int.
No olvides que un uint puede ir mucho más grande que un int, siempre y cuando va> 0
int intNumber = (int)uintNumber;
Dependiendo de qué tipo de valores espere, es posible que desee comprobar cuán grande es uintNumber antes de realizar la conversión. Un int tiene un valor máximo de alrededor de .5 de uint.
uint i = 10;
int j = (int)i;
or
int k = Convert.ToInt32(i)