Comment convertir uint en int en C #?

Donné:

 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

ou

int i = Convert.ToInt32(n); //same behavior as checked

--ÉDITER

Informations incluses comme mentionné par Kenan EK

Prenez note des mots checked- uncheckedclés et .

Il est important que vous souhaitiez que le résultat soit tronqué en entier ou qu'une exception soit levée si le résultat ne tient pas dans les 32 bits signés. La valeur par défaut n'est pas cochée.

En supposant que vous souhaitiez simplement soulever les 32 bits d'un type et les vider tels quels dans l'autre type:

uint asUint = unchecked((uint)myInt);
int asInt = unchecked((int)myUint);

Le type de destination choisira aveuglément les 32 bits et les réinterprétera.

Inversement, si vous êtes plus intéressé à conserver les valeurs décimales / numériques dans la plage du type de destination lui-même:

uint asUint = checked((uint)myInt);
int asInt = checked((int)myUint);

Dans ce cas, vous obtiendrez des exceptions de dépassement de capacité si:

• transtyper un entier négatif (par exemple: -1) en uint
• lancer un uint positif entre 2,147,483,648 et 4,294,967,295 à un int

Dans notre cas, nous voulions que la uncheckedsolution conserve les 32 bits tels quels, voici donc quelques exemples:

Exemples

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)
------------------------------

Code

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));
}  

Convert.ToInt32()prend uintcomme valeur.

En supposant que la valeur contenue dans uint puisse être représentée dans un int, alors c'est aussi simple que:

int val = (int) uval;

Je dirais qu'en utilisant tryParse, il renverra 'false' si uint est trop grand pour un int.
N'oubliez pas qu'un uint peut aller beaucoup plus grand qu'un int, tant que vous allez> 0

uint i = 10;
int j = (int)i;

ou

int k = Convert.ToInt32(i)

int intNumber = (int)uintNumber;

Selon le type de valeurs que vous attendez, vous voudrez peut-être vérifier la taille de uintNumber avant de procéder à la conversion. Un int a une valeur maximale d'environ 0,5 d'un uint.