Wie konvertiert man in C# Zahlen zwischen hexadezimal und dezimal?

Question

Wie konvertiert man zwischen hexadezimalen Zahlen und Dezimalzahlen in C#?

Answer 1

Um aus Dezimalzahl zu konvertieren tun verhexen ...

string hexValue = decValue.ToString("X"); 

Um von hex zu konvertieren entweder in Dezimalzahlen tun ...

int decValue = int.Parse(hexValue, System.Globalization.NumberStyles.HexNumber); 

oder

int decValue = Convert.ToInt32(hexValue, 16); 

Answer 2

String stringrep = myintvar.ToString("X"); 

int num = int.Parse("FF", System.Globalization.NumberStyles.HexNumber); 

Answer 3

Es sieht aus wie man sagen kann,

Convert.ToInt64(value, 16) 

das Dezimalsystem von hexdecimal zu erhalten.

Andersherum ist:

otherVar.ToString("X"); 

Answer 4

From Geekpedia:

// Store integer 182 
int decValue = 182; 

// Convert integer 182 as a hex in a string variable 
string hexValue = decValue.ToString("X"); 

// Convert the hex string back to the number 
int decAgain = int.Parse(hexValue, System.Globalization.NumberStyles.HexNumber); 

Answer 5

Hex -> Dezimal:

Convert.ToInt64(hexValue, 16); 

Dezimal -> Hex

string.format("{0:x}", decValue); 

Answer 6

static string chex(byte e)     // Convert a byte to a string representing that byte in hexadecimal 
    { 
     string r = ""; 
     string chars = "ABCDEF"; 
     r += chars[e >> 4]; 
     return r += chars[e &= 0x0F]; 
    }   // Easy enough... 

    static byte CRAZY_BYTE(string t, int i)  // Take a byte, if zero return zero, else throw exception (i=0 means false, i>0 means true) 
    { 
     if (i == 0) return 0; 
     throw new Exception(t); 
    } 

    static byte hbyte(string e)     // Take 2 characters: these are hex chars, convert it to a byte 
    {           // WARNING: This code will make small children cry. Rated R. 
     e = e.ToUpper(); // 
     string msg = "INVALID CHARS";   // The message that will be thrown if the hex str is invalid 

     byte[] t = new byte[]     // Gets the 2 characters and puts them in seperate entries in a byte array. 
     {          // This will throw an exception if (e.Length != 2). 
      (byte)e[CRAZY_BYTE("INVALID LENGTH", e.Length^0x02)], 
      (byte)e[0x01] 
     }; 

     for (byte i = 0x00; i < 0x02; i++)  // Convert those [ascii] characters to [hexadecimal] characters. Error out if either character is invalid. 
     { 
      t[i] -= (byte)((t[i] >= 0x30) ? 0x30 : CRAZY_BYTE(msg, 0x01));         // Check for 0-9 
      t[i] -= (byte)((!(t[i] < 0x0A)) ? (t[i] >= 0x11 ? 0x07 : CRAZY_BYTE(msg, 0x01)) : 0x00);  // Check for A-F 
     }   

     return t[0x01] |= t[0x00] <<= 0x04;  // The moment of truth. 
    } 

Answer 7

Diese ist nicht wirklich einfacher Weg, aber dieser Quellcode ermöglicht es Ihnen, jede Art von Oktalzahl zu korrigieren, zB 23.214, 23 und 0,512 und so weiter. Hoffe, dass dies wird Ihnen helfen ..

public string octal_to_decimal(string m_value) 
    { 
     double i, j, x = 0; 
     Int64 main_value; 
     int k = 0; 
     bool pw = true, ch; 
     int position_pt = m_value.IndexOf("."); 
     if (position_pt == -1) 
     { 
      main_value = Convert.ToInt64(m_value); 
      ch = false; 
     } 
     else 
     { 
      main_value = Convert.ToInt64(m_value.Remove(position_pt, m_value.Length - position_pt)); 
      ch = true; 
     } 

     while (k <= 1) 
     { 
      do 
      { 
       i = main_value % 10;          // Return Remainder 
       i = i * Convert.ToDouble(Math.Pow(8, x));     // calculate power 
       if (pw) 
        x++; 
       else 
        x--; 
       o_to_d = o_to_d + i;          // Saving Required calculated value in main variable 
       main_value = main_value/10;        // Dividing the main value 
      } 
      while (main_value >= 1); 
      if (ch) 
      { 
       k++; 
       main_value = Convert.ToInt64(Reversestring(m_value.Remove(0, position_pt + 1))); 
      } 
      else 
       k = 2; 
      pw = false; 
      x = -1; 
     } 
     return (Convert.ToString(o_to_d)); 
    }  

Answer 8

Wenn es über die Kapazität der normalen integer eine wirklich große Hex-String ist:

Für .NET 3.5 können wir BouncyCastle des BigInteger-Klasse verwenden:

String hex = "68c7b05d0000000002f8"; 
// results in "494809724602834812404472" 
String decimal = new Org.BouncyCastle.Math.BigInteger(hex, 16).ToString(); 

.NET 4.0 hat die BigInteger Klasse.

Answer 9

Eine Erweiterungsmethode zum Konvertieren eines Bytearrays in eine Hexadezimaldarstellung. Dies füllt jedes Byte mit führenden Nullen auf.

/// <summary> 
    /// Turns the byte array into its Hex representation. 
    /// </summary> 
    public static string ToHex(this byte[] y) 
    { 
     StringBuilder sb = new StringBuilder(); 
     foreach (byte b in y) 
     { 
      sb.Append(b.ToString("X").PadLeft(2, "0"[0])); 
     } 
     return sb.ToString(); 
    } 

Answer 10

Wenn Sie maximale Leistung wollen, wenn sie von Hex-Dezimalzahl tun Konvertierung können Sie den Ansatz mit bereits befüllte Tabelle von Hex-Dezimal-Werte verwenden.

Hier ist der Code, der diese Idee veranschaulicht. Mein performance tests zeigte, dass es 20% bis 40% schneller als Convert.ToInt32 sein kann (...):

class TableConvert 
    { 
     static sbyte[] unhex_table = 
     { -1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1 
     ,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1 
     ,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1 
     , 0, 1, 2, 3, 4, 5, 6, 7, 8, 9,-1,-1,-1,-1,-1,-1 
     ,-1,10,11,12,13,14,15,-1,-1,-1,-1,-1,-1,-1,-1,-1 
     ,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1 
     ,-1,10,11,12,13,14,15,-1,-1,-1,-1,-1,-1,-1,-1,-1 
     ,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1 
     }; 

     public static int Convert(string hexNumber) 
     { 
      int decValue = unhex_table[(byte)hexNumber[0]]; 
      for (int i = 1; i < hexNumber.Length; i++) 
      { 
       decValue *= 16; 
       decValue += unhex_table[(byte)hexNumber[i]]; 
      } 
      return decValue; 
     } 
    } 

Answer 11

Hier ist meine Funktion:

using System; 
using System.Collections.Generic; 
class HexadecimalToDecimal 
{ 
    static Dictionary<char, int> hexdecval = new Dictionary<char, int>{ 
     {'0', 0}, 
     {'1', 1}, 
     {'2', 2}, 
     {'3', 3}, 
     {'4', 4}, 
     {'5', 5}, 
     {'6', 6}, 
     {'7', 7}, 
     {'8', 8}, 
     {'9', 9}, 
     {'a', 10}, 
     {'b', 11}, 
     {'c', 12}, 
     {'d', 13}, 
     {'e', 14}, 
     {'f', 15}, 
    }; 

    static decimal HexToDec(string hex) 
    { 
     decimal result = 0; 
     hex = hex.ToLower(); 

     for (int i = 0; i < hex.Length; i++) 
     { 
      char valAt = hex[hex.Length - 1 - i]; 
      result += hexdecval[valAt] * (int)Math.Pow(16, i); 
     } 

     return result; 
    } 

    static void Main() 
    { 

     Console.WriteLine("Enter Hexadecimal value"); 
     string hex = Console.ReadLine().Trim(); 

     //string hex = "29A"; 
     Console.WriteLine("Hex {0} is dec {1}", hex, HexToDec(hex)); 

     Console.ReadKey(); 
    } 
} 

Answer 12

Meine Version ist glaube ich ein wenig mehr verständlich, weil mein C# -Wissen nicht so hoch ist. Ich verwende diesen Algorithmus: http://easyguyevo.hubpages.com/hub/Convert-Hex-to-Decimal (Das Beispiel 2)

using System; 
using System.Collections.Generic; 

static class Tool 
{ 
    public static string DecToHex(int x) 
    { 
     string result = ""; 

     while (x != 0) 
     { 
      if ((x % 16) < 10) 
       result = x % 16 + result; 
      else 
      { 
       string temp = ""; 

       switch (x % 16) 
       { 
        case 10: temp = "A"; break; 
        case 11: temp = "B"; break; 
        case 12: temp = "C"; break; 
        case 13: temp = "D"; break; 
        case 14: temp = "E"; break; 
        case 15: temp = "F"; break; 
       } 

       result = temp + result; 
      } 

      x /= 16; 
     } 

     return result; 
    } 

    public static int HexToDec(string x) 
    { 
     int result = 0; 
     int count = x.Length - 1; 
     for (int i = 0; i < x.Length; i++) 
     { 
      int temp = 0; 
      switch (x[i]) 
      { 
       case 'A': temp = 10; break; 
       case 'B': temp = 11; break; 
       case 'C': temp = 12; break; 
       case 'D': temp = 13; break; 
       case 'E': temp = 14; break; 
       case 'F': temp = 15; break; 
       default: temp = -48 + (int)x[i]; break; // -48 because of ASCII 
      } 

      result += temp * (int)(Math.Pow(16, count)); 
      count--; 
     } 

     return result; 
    } 
} 

class Program 
{ 
    static void Main(string[] args) 
    { 
     Console.Write("Enter Decimal value: "); 
     int decNum = int.Parse(Console.ReadLine()); 

     Console.WriteLine("Dec {0} is hex {1}", decNum, Tool.DecToHex(decNum)); 

     Console.Write("\nEnter Hexadecimal value: "); 
     string hexNum = Console.ReadLine().ToUpper(); 

     Console.WriteLine("Hex {0} is dec {1}", hexNum, Tool.HexToDec(hexNum)); 

     Console.ReadKey(); 
    } 
} 

Answer 13

Convert binären

Convert.ToString(Convert.ToUInt32(binary1, 2), 16).ToUpper() 

Answer 14

Hex zu Dezimal-Konvertierung

Convert.ToInt32(number, 16); 

Dezimal zu Hex-Konvertierung

verhexen

int.Parse(number, System.Globalization.NumberStyles.HexNumber) 

For more details Check this article