मैं C # में uint को int में कैसे बदलूं?

Question 1

Question 2

दिया हुआ:

 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

या

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

--EDIT

केनान ईके द्वारा उल्लिखित जानकारी शामिल है

Question 3

कीवर्ड checkedऔर uncheckedकीवर्ड पर ध्यान दें ।

यदि आप परिणाम को int या किसी अपवाद के लिए छोटा करना चाहते हैं तो परिणामित होता है यदि परिणाम हस्ताक्षरित 32 बिट्स में फिट नहीं होता है। डिफ़ॉल्ट अनियंत्रित है।

Question 4

मान लें कि आप बस 32 बिट्स को एक प्रकार से उठाते हैं और उन्हें डंप करते हैं, जैसा कि दूसरे प्रकार में है:

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

गंतव्य प्रकार नेत्रहीन रूप से 32 बिट्स को उठाएगा और उनकी पुनर्व्याख्या करेगा।

इसके विपरीत यदि आप गंतव्य प्रकार की सीमा के भीतर दशमलव / संख्यात्मक मान रखने में अधिक रुचि रखते हैं:

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

इस स्थिति में, आपको ओवरफ़्लो अपवाद मिलेगा यदि:

एक नकारात्मक इंट (उदा: -1) को एक यूइंट में डालना
2,147,483,648 और 4,294,967,295 के बीच एक पॉजिटिव यूइंट कास्ट करने का इरादा

हमारे मामले में, हम 32 uncheckedबिट्स को संरक्षित करने का समाधान चाहते हैं, इसलिए यहां कुछ उदाहरण दिए गए हैं:

उदाहरण

int => यूंट

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

कोड

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

Question 5

Convert.ToInt32()uintमान के रूप में लेता है ।

Question 6

यह मानते हुए कि यूंट में निहित मूल्य को एक इंट में दर्शाया जा सकता है, तो यह उतना ही सरल है:

int val = (int) uval;

Question 7

मैं कोशिश करूँगा कि ट्रायपर्स का उपयोग करूँ, यह 'झूठा' लौटाएगा यदि यूंट एक इंट के लिए बड़ा है।
यह मत भूलो कि एक यूंट एक इंट की तुलना में बहुत बड़ा हो सकता है, जब तक आप जा रहे हैं> 0

Question 8

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

या

int k = Convert.ToInt32(i)

Question 9

int intNumber = (int)uintNumber;

आप किस प्रकार के मूल्यों की अपेक्षा कर रहे हैं, इसके आधार पर, आप यह जांचना चाहते हैं कि रूपांतरण करने से पहले कितना बड़ा uintNumber है। एक इंट में अधिकतम एक .int का .5 होता है।