C # 'da uint'i int'e nasıl dönüştürürüm?

Verilen:

 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

veya

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

--DÜZENLE

Kenan EK tarafından belirtildiği gibi dahil edilen bilgiler

checkedVe uncheckedanahtar kelimelerine dikkat edin .

Sonucun int olarak kesilmesini veya sonuç işaretli 32 bite uymuyorsa bir istisnanın ortaya çıkmasını istiyorsanız önemlidir. Varsayılan işaretli değildir.

32 bitleri bir türden kaldırıp diğer türe olduğu gibi dökmek istediğinizi varsayarsak:

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

Hedef türü körü körüne 32 biti seçecek ve yeniden yorumlayacaktır.

Tersine, ondalık / sayısal değerleri hedef türünün kendi aralığı içinde tutmakla daha fazla ilgileniyorsanız:

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

Bu durumda, aşağıdaki durumlarda taşma istisnaları alırsınız:

• bir uint'e negatif int (örneğin: -1) çevirmek
• bir int'e 2,147,483,648 ile 4,294,967,295 arasında pozitif bir uint yayınlamak

Bizim durumumuzda, uncheckedçözümün 32 biti olduğu gibi korumasını istedik, işte bazı örnekler:

Örnekler

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()uintdeğer olarak alır .

Uint'in içerdiği değerin bir int içinde gösterilebileceğini varsayarsak, bu kadar basittir:

int val = (int) uval;

TryParse kullanarak şunu söyleyebilirim, uint bir int için büyükse 'false' döndürür.
Unutmayın, bir uint,> 0 olduğu sürece int'ten çok daha büyük olabilir.

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

veya

int k = Convert.ToInt32(i)

int intNumber = (int)uintNumber;

Ne tür değerler beklediğinize bağlı olarak, dönüşümü yapmadan önce uintNumber'ın ne kadar büyük olduğunu kontrol etmek isteyebilirsiniz. Bir int, bir uint'in yaklaşık 0,5'lik bir maksimum değerine sahiptir.