c# - सी#पूर्णांक हेक्स में कनवर्ट करें और फिर से वापस करें




hex type-conversion (6)

मैं निम्नलिखित कैसे परिवर्तित कर सकता हूं?

2 9 34 (पूर्णांक) बी 76 (हेक्स)

मुझे बताएं कि मैं क्या करने की कोशिश कर रहा हूं। मेरे पास मेरे डेटाबेस में उपयोगकर्ता आईडी हैं जो पूर्णांक के रूप में संग्रहीत हैं। उपयोगकर्ताओं को उनकी आईडी का संदर्भ देने के बजाय मैं उन्हें हेक्स मान का उपयोग करना चाहता हूं। मुख्य कारण यह है कि यह छोटा है।

इसलिए न केवल मुझे पूर्णांक से हेक्स तक जाने की आवश्यकता है, बल्कि मुझे हेक्स से पूर्णांक तक जाने की भी आवश्यकता है।

क्या सी # में ऐसा करने का कोई आसान तरीका है?


इसे हेक्स में बदलने के लिए निम्न का प्रयास करें

public static string ToHex(this int value) {
  return String.Format("0x{0:X}", value);
}

और फिर वापस

public static int FromHex(string value) {
  // strip the leading 0x
  if ( value.StartsWith("0x", StringComparison.OrdinalIgnoreCase)) {
    value = value.Substring(2);
  }
  return Int32.Parse(value, NumberStyles.HexNumber);
}

उपयोग:

int myInt = 2934;
string myHex = myInt.ToString("X");  // Gives you hexadecimal
int myNewInt = Convert.ToInt32(myHex, 16);  // Back to int again.

देखें कि कैसे: अधिक जानकारी और उदाहरणों के लिए हेक्साडेसिमल स्ट्रिंग्स और न्यूमेरिक प्रकार (सी # प्रोग्रामिंग गाइड) के बीच कनवर्ट करें


मैंने इस जवाब को प्राप्त करने से पहले int से हेक्स स्ट्रिंग को परिवर्तित करने के लिए अपना स्वयं का समाधान बनाया और वापस। आश्चर्य की बात नहीं है, यह .NET समाधान से काफी तेज है क्योंकि कम कोड ओवरहेड है।

        /// <summary>
        /// Convert an integer to a string of hexidecimal numbers.
        /// </summary>
        /// <param name="n">The int to convert to Hex representation</param>
        /// <param name="len">number of digits in the hex string. Pads with leading zeros.</param>
        /// <returns></returns>
        private static String IntToHexString(int n, int len)
        {
            char[] ch = new char[len--];
            for (int i = len; i >= 0; i--)
            {
                ch[len - i] = ByteToHexChar((byte)((uint)(n >> 4 * i) & 15));
            }
            return new String(ch);
        }

        /// <summary>
        /// Convert a byte to a hexidecimal char
        /// </summary>
        /// <param name="b"></param>
        /// <returns></returns>
        private static char ByteToHexChar(byte b)
        {
            if (b < 0 || b > 15)
                throw new Exception("IntToHexChar: input out of range for Hex value");
            return b < 10 ? (char)(b + 48) : (char)(b + 55);
        }

        /// <summary>
        /// Convert a hexidecimal string to an base 10 integer
        /// </summary>
        /// <param name="str"></param>
        /// <returns></returns>
        private static int HexStringToInt(String str)
        {
            int value = 0;
            for (int i = 0; i < str.Length; i++)
            {
                value += HexCharToInt(str[i]) << ((str.Length - 1 - i) * 4);
            }
            return value;
        }

        /// <summary>
        /// Convert a hex char to it an integer.
        /// </summary>
        /// <param name="ch"></param>
        /// <returns></returns>
        private static int HexCharToInt(char ch)
        {
            if (ch < 48 || (ch > 57 && ch < 65) || ch > 70)
                throw new Exception("HexCharToInt: input out of range for Hex value");
            return (ch < 58) ? ch - 48 : ch - 55;
        }

समय कोड:

static void Main(string[] args)
        {
            int num = 3500;
            long start = System.Diagnostics.Stopwatch.GetTimestamp();
            for (int i = 0; i < 2000000; i++)
                if (num != HexStringToInt(IntToHexString(num, 3)))
                    Console.WriteLine(num + " = " + HexStringToInt(IntToHexString(num, 3)));
            long end = System.Diagnostics.Stopwatch.GetTimestamp();
            Console.WriteLine(((double)end - (double)start)/(double)System.Diagnostics.Stopwatch.Frequency);

            for (int i = 0; i < 2000000; i++)
                if (num != Convert.ToInt32(num.ToString("X3"), 16))
                    Console.WriteLine(i);
            end = System.Diagnostics.Stopwatch.GetTimestamp();
            Console.WriteLine(((double)end - (double)start)/(double)System.Diagnostics.Stopwatch.Frequency);
            Console.ReadLine(); 
        }

परिणाम:

Digits : MyCode : .Net
1 : 0.21 : 0.45
2 : 0.31 : 0.56
4 : 0.51 : 0.78
6 : 0.70 : 1.02
8 : 0.90 : 1.25

हेक्स तक:

string hex = intValue.ToString("X");

Int करने के लिए:

int intValue = int.Parse(hex, System.Globalization.NumberStyles.HexNumber)


int valInt = 12;
Console.WriteLine(valInt.ToString("X"));  // C  ~ possibly single-digit output 
Console.WriteLine(valInt.ToString("X2")); // 0C ~ always double-digit output





type-conversion