Jak przekonwertować uint na int w C #?

Dany:

 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

lub

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

--EDYTOWAĆ

Zawarte informacje, jak wspomniał Kenan EK

Zwróć uwagę na słowa kluczowe checkedi unchecked.

Ma to znaczenie, jeśli chcesz, aby wynik został obcięty do liczby int lub wyjątek, jeśli wynik nie mieści się w 32 bitach ze znakiem. Domyślnie nie jest zaznaczone.

Zakładając, że chcesz po prostu podnieść 32 bity z jednego typu i zrzucić je tak, jak są, do drugiego typu:

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

Typ docelowy ślepo wybierze 32 bity i ponownie je zinterpretuje.

I odwrotnie, jeśli bardziej zależy Ci na utrzymaniu wartości dziesiętnych / liczbowych w zakresie samego typu docelowego:

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

W takim przypadku otrzymasz wyjątki od przepełnienia, jeśli:

• rzutowanie ujemnej liczby int (np .: -1) na uint
• rzucając dodatni wynik między 2,147,483,648 a 4,294,967,295 na int

W naszym przypadku chcieliśmy, aby uncheckedrozwiązanie zachowywało 32 bity bez zmian, więc oto kilka przykładów:

Przykłady

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

Kod

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()przyjmuje uintjako wartość.

Zakładając, że wartość zawartą w uint można przedstawić w int, to jest to tak proste, jak:

int val = (int) uval;

Powiedziałbym, że używając tryParse, zwróci wartość „false”, jeśli uint jest zbyt duży dla int.
Nie zapominaj, że uint może być znacznie większy niż int, o ile przekroczysz 0

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

lub

int k = Convert.ToInt32(i)

int intNumber = (int)uintNumber;

W zależności od tego, jakiego rodzaju wartości oczekujesz, możesz sprawdzić, jak duży jest uintNumber przed wykonaniem konwersji. Int ma maksymalną wartość około 0,5 uinta.