दिलचस्प पोस्ट
एक निर्भरता इंजेक्शन का उपयोग क्यों करता है? दिनांक या कैलेंडर ऑब्जेक्ट के लिए कोई दिनांक स्ट्रिंग कैसे परिवर्तित करें? सीधी डीआई कोड के विरोध में मुझे आईओसी कंटेनर की आवश्यकता क्यों है? जावास्क्रिप्ट का सबसे अधिक पूर्णांक मान क्या है, जो सटीकता को खोने के बिना एक नंबर पर जा सकता है? के साथ फाइल लिखना विफल रहता है फ्लोटिंगएक्शनबटन उदाहरण का समर्थन लाइब्रेरी के साथ ओपनसीवी नेटवर्क कैमरे के साथ PHP में आरएसए के साथ एन्क्रिप्ट और डिक्रिप्ट पाठ साधारण स्पष्टीकरण PHP OOP बनाम प्रक्रियात्मक? डेटा फ्रेम में समूह द्वारा टेक्स्ट संक्षिप्त करें "आधुनिक" और "शेष" के बीच अंतर क्या है? PHP का उपयोग कर SQL सर्वर में स्ट्रिंग कैसे बचें? मैं अपने Android एप्लिकेशन से क्रैश-डेटा कैसे प्राप्त करूं? बड़ी संख्या (बीग्नम) को संभालने के लिए जावास्क्रिप्ट में मानक समाधान क्या है? लोड करने के लिए ऐसी कोई फ़ाइल नहीं है – रूबीगाम्स (लोड एरर)

आप हेक्साडेसिमल स्ट्रिंग में एक बाइट सरणी कैसे परिवर्तित करते हैं, और इसके विपरीत?

आप एक बाइट सरणी को हेक्साडेसिमल स्ट्रिंग में कैसे परिवर्तित कर सकते हैं, और इसके विपरीत?

वेब के समाधान से एकत्रित समाधान "आप हेक्साडेसिमल स्ट्रिंग में एक बाइट सरणी कैसे परिवर्तित करते हैं, और इसके विपरीत?"

कोई एक:

public static string ByteArrayToString(byte[] ba) { StringBuilder hex = new StringBuilder(ba.Length * 2); foreach (byte b in ba) hex.AppendFormat("{0:x2}", b); return hex.ToString(); } 

या:

 public static string ByteArrayToString(byte[] ba) { string hex = BitConverter.ToString(ba); return hex.Replace("-",""); } 

उदाहरण के लिए, ऐसा करने के और भी अधिक संस्करण हैं

रिवर्स रूपांतरण इस तरह होगा:

 public static byte[] StringToByteArray(String hex) { int NumberChars = hex.Length; byte[] bytes = new byte[NumberChars / 2]; for (int i = 0; i < NumberChars; i += 2) bytes[i / 2] = Convert.ToByte(hex.Substring(i, 2), 16); return bytes; } 

Substring साथ संयोजन में सबसे अच्छा विकल्प Substring का उपयोग करना। Convert.ToByte अधिक जानकारी के लिए इस उत्तर को देखें। यदि आपको बेहतर प्रदर्शन की आवश्यकता है, तो आपको SubString ड्रॉप करने से पहले SubString

क्षमता का परिक्षण

नोट: 2015-08-20 के नए नेता

मैंने कुछ क्रूड Stopwatch प्रदर्शन परीक्षण, एक यादृच्छिक वाक्य (एन = 61, 1000 पुनरावृत्तियों) के साथ एक रन और प्रोजेक्ट गुटेनबर्ग पाठ (एन = 1,238, 957, 150 पुनरावृत्तियों) के साथ एक रन के माध्यम से विभिन्न रूपांतरण विधियों में से प्रत्येक को दौड़ा। यहां परिणाम हैं, मोटे तौर पर सबसे तेज़ी से धीमे। सभी मापन टैक्स में हैं ( 10,000 टीक्स = 1 एमएस ) और सभी रिश्तेदार नोट की तुलना [धीमी] StringBuilder कार्यान्वयन से की जाती है। उपयोग किए गए कोड के लिए, नीचे या टेस्ट फ्रेमवर्क रेपो देखें, जहां मैं इसे चलाने के लिए अब कोड को बनाए रखता हूं।

अस्वीकरण

चेतावनी: इन आंकड़ों पर कंक्रीट के लिए कुछ भी भरोसा मत करो; वे केवल नमूना डेटा का एक नमूना चलाने हैं यदि आपको वास्तव में श्रेष्ठ प्रदर्शन की ज़रूरत है, तो कृपया इन विधियों को अपने उत्पादन आवश्यकताओं के पर्यावरण प्रतिनिधि में डेटा प्रतिनिधि के साथ जांचें, जो आप उपयोग करेंगे।

परिणाम

  • बाइट unsafe (कोड इंचेस के माध्यम से) की खोज करें ( एयरब्रेर द्वारा रेपो का परीक्षण करने के लिए जोड़ा गया)
    • पाठ: 4,727.85 (105.2 एक्स)
    • वाक्य: 0.28 (99.7 एक्स)
  • बाइट द्वारा ढूंढें (कोड इंचेस के माध्यम से)
    • पाठ: 10,853.96 (45.8 एक्स तेज)
    • वाक्य: 0.65 (42.7 एक्स तेज)
  • बाइट मैनिपलेशन 2 (कोड इंचेस के माध्यम से)
    • पाठ: 12, 9 67.6 9 (38.4 एक्स तेज)
    • सजा: 0.73 (37.9 एक्स तेज)
  • बाइट मैनिपुललेशन (वालीद ईसा के माध्यम से)
    • पाठ: 16,856.64 (29.5 एक्स तेज)
    • वाक्य: 0.70 (39.5X तेज)
  • लुकअप / शिफ्ट (नाथन मोईनवाज़री के माध्यम से)
    • पाठ: 23,201.23 (21.4 एक्स तेज)
    • वाक्य: 1.24 (22.3 एक्स तेज)
  • चापलूसी द्वारा तलाशने (ब्रायन लैम्बर्ट के माध्यम से)
    • पाठ: 23,879.41 (20.8 एक्स तेज)
    • वाक्य: 1.15 (23.9 x तेज)
  • BitConverter ( BitConverter द्वारा)
    • पाठ: 113,26 9 .3 (4.4X तेज)
    • दंड: 9.98 (2.8 एक्स तेज)
  • {SoapHexBinary}.ToString (माइक्रॉफ़्ट के माध्यम से)
    • पाठ: 178,601.3 9 (2.8 एक्स तेज)
    • वाक्य: 10.68 (2.6X तेज)
  • {byte}.ToString("X2") ( {byte}.ToString("X2") का उपयोग करके) (विल डीन के उत्तर से प्राप्त)
    • पाठ: 308,805.38 (2.4X तेज)
    • वाक्य: 16.8 9 (2.4X तेज)
  • {byte}.ToString("X2") ( {IEnumerable}.Aggregate का उपयोग करना {IEnumerable}.Aggregate , {IEnumerable}.Aggregate आवश्यकता है। {IEnumerable}.Aggregate ) (मार्क के माध्यम से)
    • पाठ: 352,828.20 (2.1 एक्स तेज)
    • वाक्य: 16.87 (2.4X तेज)
  • Array.ConvertAll ( string.Join ) का उपयोग करके (विल डीन के माध्यम से)
    • पाठ: 675,451.57 (1.1X तेज)
    • वाक्य: 17.95 (2.2 एक्स तेज)
  • Array.ConvertAll ( string.Concat का उपयोग string.Concat , .NET 4.0 की आवश्यकता है) (विल डीन के माध्यम से)
    • पाठ: 752,078.70 (1.0X तेज)
    • वाक्य: 18.28 (2.2 एक्स तेज)
  • {StringBuilder}.AppendFormat ( {StringBuilder}.AppendFormat का उपयोग करके) (टॉमलिक द्वारा)
    • पाठ: 672,115.77 (1.1X तेज)
    • सजा: 36.82 (1.1X तेज)
  • {StringBuilder}.AppendFormat ( {IEnumerable}.Aggregate का उपयोग करना {IEnumerable}.Aggregate , {IEnumerable}.Aggregate आवश्यकता है। लीनक) (टॉमलिक के उत्तर से प्राप्त)
    • पाठ: 718,380.63 (1.0X तेज)
    • सजा: 39.71 (1.0X तेज)

लुकअप टेबल्स बाइट हेरफेर से आगे ले गए हैं। असल में, किसी भी प्रकार के उपन्यास या बाइट हेक्स में होने वाले कुछ precomputing का कोई रूप है। फिर, जैसा कि आप डेटा के माध्यम से चीर करते हैं, आप अगले भाग को देखने के लिए देख सकते हैं कि यह हेक्स स्ट्रिंग क्या होगा। उस मान को कुछ फ़ैशन में परिणामी स्ट्रिंग आउटपुट में जोड़ा जाता है। लंबे समय से बाइट हेरफेर के लिए, कुछ डेवलपर्स द्वारा पढ़ने में संभवतः कठिन है, यह शीर्ष-प्रदर्शन करने वाला दृष्टिकोण था।

आपकी सबसे अच्छी शर्त अभी भी कुछ प्रतिनिधि डेटा ढूंढने जा रही है और उत्पादन-जैसे वातावरण में इसे बाहर करने की कोशिश कर रही है। यदि आपके पास अलग-अलग मेमोरी बाधाएं हैं, तो आप कम आवंटन वाले एक विधि को पसंद कर सकते हैं जो तेज हो जाएगा लेकिन अधिक मेमोरी का उपयोग करेंगे।

परीक्षण कोड

मैं उपयोग किए गए परीक्षण कोड के साथ खेलने के लिए बेझिझक एक संस्करण यहां शामिल है, लेकिन रेपो को क्लोन करने और अपने स्वयं के तरीके जोड़ने के लिए स्वतंत्र महसूस करें। अगर आपको कुछ दिलचस्प मिल जाए या इसे उपयोग करने वाले परीक्षण ढांचे में सुधार करना चाहते हैं, तो कृपया एक पुल अनुरोध सबमिट करें

  1. नई स्थैतिक विधि ( Func<byte[], string> ) को / टेस्ट्स / कॉन्वर्टबाइटएरेरेओहेक्सस्ट्रिंग / टेस्ट सीएस में जोड़ें।
  2. उस विधि का नाम उस कक्षा में TestCandidates रिटर्न मान में जोड़ें।
  3. सुनिश्चित करें कि आप उस संस्करण में GenerateTestInput में टिप्पणियों को टॉगल करके इच्छित आवृत्ति संस्करण, वाक्य या टेक्स्ट चला रहे हैं।
  4. F5 मारा और आउटपुट के लिए प्रतीक्षा करें (एक HTML डंप भी / bin फ़ोल्डर में उत्पन्न होता है)
 static string ByteArrayToHexStringViaStringJoinArrayConvertAll(byte[] bytes) { return string.Join(string.Empty, Array.ConvertAll(bytes, b => b.ToString("X2"))); } static string ByteArrayToHexStringViaStringConcatArrayConvertAll(byte[] bytes) { return string.Concat(Array.ConvertAll(bytes, b => b.ToString("X2"))); } static string ByteArrayToHexStringViaBitConverter(byte[] bytes) { string hex = BitConverter.ToString(bytes); return hex.Replace("-", ""); } static string ByteArrayToHexStringViaStringBuilderAggregateByteToString(byte[] bytes) { return bytes.Aggregate(new StringBuilder(bytes.Length * 2), (sb, b) => sb.Append(b.ToString("X2"))).ToString(); } static string ByteArrayToHexStringViaStringBuilderForEachByteToString(byte[] bytes) { StringBuilder hex = new StringBuilder(bytes.Length * 2); foreach (byte b in bytes) hex.Append(b.ToString("X2")); return hex.ToString(); } static string ByteArrayToHexStringViaStringBuilderAggregateAppendFormat(byte[] bytes) { return bytes.Aggregate(new StringBuilder(bytes.Length * 2), (sb, b) => sb.AppendFormat("{0:X2}", b)).ToString(); } static string ByteArrayToHexStringViaStringBuilderForEachAppendFormat(byte[] bytes) { StringBuilder hex = new StringBuilder(bytes.Length * 2); foreach (byte b in bytes) hex.AppendFormat("{0:X2}", b); return hex.ToString(); } static string ByteArrayToHexViaByteManipulation(byte[] bytes) { char[] c = new char[bytes.Length * 2]; byte b; for (int i = 0; i < bytes.Length; i++) { b = ((byte)(bytes[i] >> 4)); c[i * 2] = (char)(b > 9 ? b + 0x37 : b + 0x30); b = ((byte)(bytes[i] & 0xF)); c[i * 2 + 1] = (char)(b > 9 ? b + 0x37 : b + 0x30); } return new string(c); } static string ByteArrayToHexViaByteManipulation2(byte[] bytes) { char[] c = new char[bytes.Length * 2]; int b; for (int i = 0; i < bytes.Length; i++) { b = bytes[i] >> 4; c[i * 2] = (char)(55 + b + (((b - 10) >> 31) & -7)); b = bytes[i] & 0xF; c[i * 2 + 1] = (char)(55 + b + (((b - 10) >> 31) & -7)); } return new string(c); } static string ByteArrayToHexViaSoapHexBinary(byte[] bytes) { SoapHexBinary soapHexBinary = new SoapHexBinary(bytes); return soapHexBinary.ToString(); } static string ByteArrayToHexViaLookupAndShift(byte[] bytes) { StringBuilder result = new StringBuilder(bytes.Length * 2); string hexAlphabet = "0123456789ABCDEF"; foreach (byte b in bytes) { result.Append(hexAlphabet[(int)(b >> 4)]); result.Append(hexAlphabet[(int)(b & 0xF)]); } return result.ToString(); } static readonly uint* _lookup32UnsafeP = (uint*)GCHandle.Alloc(_Lookup32, GCHandleType.Pinned).AddrOfPinnedObject(); static string ByteArrayToHexViaLookup32UnsafeDirect(byte[] bytes) { var lookupP = _lookup32UnsafeP; var result = new string((char)0, bytes.Length * 2); fixed (byte* bytesP = bytes) fixed (char* resultP = result) { uint* resultP2 = (uint*)resultP; for (int i = 0; i < bytes.Length; i++) { resultP2[i] = lookupP[bytesP[i]]; } } return result; } static uint[] _Lookup32 = Enumerable.Range(0, 255).Select(i => { string s = i.ToString("X2"); return ((uint)s[0]) + ((uint)s[1] << 16); }).ToArray(); static string ByteArrayToHexViaLookupPerByte(byte[] bytes) { var result = new char[bytes.Length * 2]; for (int i = 0; i < bytes.Length; i++) { var val = _Lookup32[bytes[i]]; result[2*i] = (char)val; result[2*i + 1] = (char) (val >> 16); } return new string(result); } static string ByteArrayToHexViaLookup(byte[] bytes) { string[] hexStringTable = new string[] { "00", "01", "02", "03", "04", "05", "06", "07", "08", "09", "0A", "0B", "0C", "0D", "0E", "0F", "10", "11", "12", "13", "14", "15", "16", "17", "18", "19", "1A", "1B", "1C", "1D", "1E", "1F", "20", "21", "22", "23", "24", "25", "26", "27", "28", "29", "2A", "2B", "2C", "2D", "2E", "2F", "30", "31", "32", "33", "34", "35", "36", "37", "38", "39", "3A", "3B", "3C", "3D", "3E", "3F", "40", "41", "42", "43", "44", "45", "46", "47", "48", "49", "4A", "4B", "4C", "4D", "4E", "4F", "50", "51", "52", "53", "54", "55", "56", "57", "58", "59", "5A", "5B", "5C", "5D", "5E", "5F", "60", "61", "62", "63", "64", "65", "66", "67", "68", "69", "6A", "6B", "6C", "6D", "6E", "6F", "70", "71", "72", "73", "74", "75", "76", "77", "78", "79", "7A", "7B", "7C", "7D", "7E", "7F", "80", "81", "82", "83", "84", "85", "86", "87", "88", "89", "8A", "8B", "8C", "8D", "8E", "8F", "90", "91", "92", "93", "94", "95", "96", "97", "98", "99", "9A", "9B", "9C", "9D", "9E", "9F", "A0", "A1", "A2", "A3", "A4", "A5", "A6", "A7", "A8", "A9", "AA", "AB", "AC", "AD", "AE", "AF", "B0", "B1", "B2", "B3", "B4", "B5", "B6", "B7", "B8", "B9", "BA", "BB", "BC", "BD", "BE", "BF", "C0", "C1", "C2", "C3", "C4", "C5", "C6", "C7", "C8", "C9", "CA", "CB", "CC", "CD", "CE", "CF", "D0", "D1", "D2", "D3", "D4", "D5", "D6", "D7", "D8", "D9", "DA", "DB", "DC", "DD", "DE", "DF", "E0", "E1", "E2", "E3", "E4", "E5", "E6", "E7", "E8", "E9", "EA", "EB", "EC", "ED", "EE", "EF", "F0", "F1", "F2", "F3", "F4", "F5", "F6", "F7", "F8", "F9", "FA", "FB", "FC", "FD", "FE", "FF", }; StringBuilder result = new StringBuilder(bytes.Length * 2); foreach (byte b in bytes) { result.Append(hexStringTable[b]); } return result.ToString(); } 

अपडेट (2010-01-13)

विश्लेषण के लिए वलीद का जवाब जोड़ा गया जल्दी।

अपडेट (2011-10-05)

जोड़ा गया string.Concat लिए सभी संस्करण (.NET 4.0 की आवश्यकता है)। string.Join सममूल्य पर। संस्करण जोड़ें

अपडेट (2012-02-05)

टेस्ट रिपो में StringBuilder.Append(b.ToString("X2")) जैसे अधिक प्रकार शामिल हैं। कोई भी परिणाम नाराज किसी भी {IEnumerable}.Aggregate से अधिक तेज है। उदाहरण के लिए, BitConverter , लेकिन BitConverter अभी भी जीतता है।

अपडेट (2012-04-03)

माइक्रॉफ्ट के SoapHexBinary का विश्लेषण, जो कि तीसरे स्थान पर आ गया है, के लिए जोड़ा गया।

अपडेट (2013-01-15)

जोड़ा गया कोड इन्चाहास के बाइट हेरफेर का जवाब, जो पहली जगह ले लिया (टेक्स्ट के बड़े ब्लॉकों पर बड़े अंतर से)।

अपडेट (2013-05-23)

ब्रायन लैम्बर्ट के ब्लॉग से नेथन मोईनवज़री का लुकअप उत्तर और संस्करण जोड़ा गया दोनों ही तेज, लेकिन मैं प्रयोग किया गया परीक्षण मशीन (लीड एएमडी फेनोम 9750) पर लीड नहीं ले रहा हूं।

अपडेट (2014-07-31)

जोड़ा @ कोड इनकाओस के नए बाइट-आधारित लुकअप उत्तर ऐसा लगता है कि वाक्य परीक्षण और पूर्ण-पाठ परीक्षण दोनों पर सीधा ले लिया है।

अपडेट (2015-08-20)

इस उत्तर के रेपो के लिए एयरब्रेसर के ऑप्टिमाइज़ेशन और unsafe संस्करण जोड़ा गया यदि आप असुरक्षित गेम में खेलना चाहते हैं, तो आप दोनों छोटे स्ट्रिंग और बड़े ग्रंथों पर पहले शीर्ष विजेताओं में से किसी एक पर बहुत बड़ा प्रदर्शन प्राप्त कर सकते हैं।

सोपहाक्सबरीनी नामक एक वर्ग है जो वास्तव में आप क्या चाहते हैं।

 using System.Runtime.Remoting.Metadata.W3cXsd2001; public static byte[] GetStringToBytes(string value) { SoapHexBinary shb = SoapHexBinary.Parse(value); return shb.Value; } public static string GetBytesToString(byte[] value) { SoapHexBinary shb = new SoapHexBinary(value); return shb.ToString(); } 

क्रिप्टो कोड लिखते समय डेटा निर्भर ब्रांड्स और तालिका देखने से बचने के लिए सामान्य है, यह सुनिश्चित करने के लिए कि रनटाइम डेटा पर निर्भर नहीं करता है, क्योंकि डेटा निर्भर टाइम्स साइड-चैनल हमलों को जन्म दे सकता है।

यह बहुत तेज है

 static string ByteToHexBitFiddle(byte[] bytes) { char[] c = new char[bytes.Length * 2]; int b; for (int i = 0; i < bytes.Length; i++) { b = bytes[i] >> 4; c[i * 2] = (char)(55 + b + (((b-10)>>31)&-7)); b = bytes[i] & 0xF; c[i * 2 + 1] = (char)(55 + b + (((b-10)>>31)&-7)); } return new string(c); } 

फेंग्लूई माग्लाफ़्फ़फ़ास्टथथू रलेह वाग्ह्नग्ल फ्टाग्न


यहाँ आने वाले अपनी सभी आशाओं को छोड़ दें

अजीब बिट नगण्य की एक व्याख्या:

  1. bytes[i] >> 4 एक बाइट के उच्च कुबड़ा को निकालता है
    bytes[i] & 0xF एक बाइट के कम bytes[i] & 0xF निकालता है
  2. b - 10
    मानों b < 10 लिए < 0 , जो एक दशमलव अंक बन जाएगा
    b > 10 मान के लिए >= 0 , जो A से F तक एक अक्षर बन जाएगा।
  3. हस्ताक्षर किए गए 32 बिट पूर्णांक पर i >> 31 का उपयोग चिह्न को अर्क कर देता है, विस्तार करने के लिए धन्यवाद। यह i < 0 लिए -1 और 0 लिए i >= 0
  4. संयोजन 2) और 3), से पता चलता है कि (b-10)>>31 अक्षरों के लिए 0 और अंकों के लिए -1
  5. पत्रों के मामले को देखते हुए, अंतिम सारांश 0 हो जाता है, और b 10 से 15 की सीमा में है। हम इसे A (65) से F (70) में जोड़ना चाहते हैं, जिसका अर्थ है 55 ( 'A'-10 ) ।
  6. अंकों के मामले को देखते हुए, हम आखिरी सारांश को अनुकूलित करना चाहते हैं, ताकि यह सीमा 0 से 9 की सीमा 0 (48) से 9 (57) तक नक्शे b हो जाए। इसका मतलब है कि इसे -7 ( '0' - 55 ) बनने की आवश्यकता है।
    अब हम सिर्फ 7 के साथ गुणा कर सकते हैं। क्योंकि 1 के सभी बिट्स 1 के द्वारा प्रतिनिधित्व करते हैं, फिर भी हम (0 & -7) == 0 और (-1 & -7) == -7 बजाय & -7 उपयोग कर सकते हैं।

कुछ और विचार:

  • मैंने c में इंडेक्स के दूसरे लूप वैरिएबल का इस्तेमाल नहीं किया, क्योंकि माप से पता चलता है कि i इसे सस्ता से गणना करता i
  • वास्तव में i < bytes.Length का प्रयोग कर रहा i < bytes.Length के ऊपरी बाउंड के रूप में लम्बाई bytes[i] पर सीमाओं को रोकने के लिए जटर को अनुमति देता है, इसलिए मैंने उस संस्करण को चुना।
  • b बनाने से कोई भी अनावश्यक रूपांतरण और बाइट को अनुमति देता है।

यदि आप BitConverter से अधिक लचीलेपन चाहते हैं, लेकिन उन BitConverter 1990 के दशक-शैली स्पष्ट लूप नहीं चाहते हैं, तो आप ऐसा कर सकते हैं:

 String.Join(String.Empty, Array.ConvertAll(bytes, x => x.ToString("X2"))); 

या, यदि आप .NET 4.0 का प्रयोग कर रहे हैं:

 String.Concat(Array.ConvertAll(bytes, x => x.ToString("X2"))); 

(मूल पोस्ट पर एक टिप्पणी से उत्तरार्द्ध।)

आप BitConverter.ToString विधि का उपयोग कर सकते हैं:

 byte[] bytes = {0, 1, 2, 4, 8, 16, 32, 64, 128, 256} Console.WriteLine( BitConverter.ToString(bytes)); 

आउटपुट:

00-01-02-04-08-10-20-40-80-एफएफ

अधिक जानकारी: बिटकोनवर। टॉस्ट्रिंग विधि (बाइट [])

आज मुझे बहुत ही समस्या का सामना करना पड़ा, और मैं इस कोड पर आया:

 private static string ByteArrayToHex(byte[] barray) { char[] c = new char[barray.Length * 2]; byte b; for (int i = 0; i < barray.Length; ++i) { b = ((byte)(barray[i] >> 4)); c[i * 2] = (char)(b > 9 ? b + 0x37 : b + 0x30); b = ((byte)(barray[i] & 0xF)); c[i * 2 + 1] = (char)(b > 9 ? b + 0x37 : b + 0x30); } return new string(c); } 

स्रोत: फोरम डाक बाइट [] सरणी से हेक्स स्ट्रिंग (पीज़रा द्वारा पोस्ट देखें)। मैंने 0x उपसर्ग को निकालने के लिए कोड थोडा संशोधित किया।

मैंने कोड को कुछ प्रदर्शन परीक्षण किया और यह बीटकोनरवर.ToString () (सबसे तेज अनुसार पट्जि के पद के अनुसार) की तुलना में लगभग आठ बार तेज था।

एक अन्य लुकअप तालिका आधारित दृष्टिकोण यह प्रत्येक प्रत्येक बाइट के लिए केवल एक लुकअप तालिका का उपयोग करता है, प्रति चापलूसी प्रति लुकअप तालिका के बजाय

 private static readonly uint[] _lookup32 = CreateLookup32(); private static uint[] CreateLookup32() { var result = new uint[256]; for (int i = 0; i < 256; i++) { string s=i.ToString("X2"); result[i] = ((uint)s[0]) + ((uint)s[1] << 16); } return result; } private static string ByteArrayToHexViaLookup32(byte[] bytes) { var lookup32 = _lookup32; var result = new char[bytes.Length * 2]; for (int i = 0; i < bytes.Length; i++) { var val = lookup32[bytes[i]]; result[2*i] = (char)val; result[2*i + 1] = (char) (val >> 16); } return new string(result); } 

मैंने यह देखने का प्रयोग करते हुए संस्करण की struct{char X1, X2} , struct{char X1, X2} , struct{byte X1, X2} का प्रयोग कर तालिका में भी किया है।

संकलन लक्ष्य (एक्स 86, एक्स 64) के आधार पर उन दोनों के पास लगभग समान प्रदर्शन था या इस प्रकार की तुलना में थोड़ा धीमा था।


और भी उच्च प्रदर्शन के लिए, unsafe भाई:

 private static readonly uint[] _lookup32Unsafe = CreateLookup32Unsafe(); private static readonly uint* _lookup32UnsafeP = (uint*)GCHandle.Alloc(_lookup32Unsafe,GCHandleType.Pinned).AddrOfPinnedObject(); private static uint[] CreateLookup32Unsafe() { var result = new uint[256]; for (int i = 0; i < 256; i++) { string s=i.ToString("X2"); if(BitConverter.IsLittleEndian) result[i] = ((uint)s[0]) + ((uint)s[1] << 16); else result[i] = ((uint)s[1]) + ((uint)s[0] << 16); } return result; } public static string ByteArrayToHexViaLookup32Unsafe(byte[] bytes) { var lookupP = _lookup32UnsafeP; var result = new char[bytes.Length * 2]; fixed(byte* bytesP = bytes) fixed (char* resultP = result) { uint* resultP2 = (uint*)resultP; for (int i = 0; i < bytes.Length; i++) { resultP2[i] = lookupP[bytesP[i]]; } } return new string(result); } 

या यदि आप इसे सीधे स्ट्रिंग में लिखने के लिए स्वीकार्य मानते हैं:

 public static string ByteArrayToHexViaLookup32UnsafeDirect(byte[] bytes) { var lookupP = _lookup32UnsafeP; var result = new string((char)0, bytes.Length * 2); fixed (byte* bytesP = bytes) fixed (char* resultP = result) { uint* resultP2 = (uint*)resultP; for (int i = 0; i < bytes.Length; i++) { resultP2[i] = lookupP[bytesP[i]]; } } return result; } 

इस समस्या को एक लुक अप तालिका का उपयोग करके भी हल किया जा सकता है यह दोनों एनकोडर और डिकोडर के लिए स्थिर स्मृति की एक छोटी राशि की आवश्यकता होगी। हालांकि यह विधि तेजी से होगी:

  • एन्कोडर तालिका 512 बाइट्स या 1024 बाइट्स (दो बार आकार अगर दोनों ऊपरी और निचले मामले की आवश्यकता है)
  • विकोडक तालिका 256 बाइट्स या 64 कि.बा. (या तो एक एकल अक्षर देखो या दोहरे रंग का लुक अप)

एन्कोडिंग तालिका के लिए मेरा समाधान 1024 बाइट्स का उपयोग करता है, और डीकोडिंग के लिए 256 बाइट्स।

डिकोडिंग

 private static readonly byte[] LookupTable = new byte[] { 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x0A, 0x0B, 0x0C, 0x0D, 0x0E, 0x0F, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x0A, 0x0B, 0x0C, 0x0D, 0x0E, 0x0F, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF }; private static byte Lookup(char c) { var b = LookupTable[c]; if (b == 255) throw new IOException("Expected a hex character, got " + c); return b; } public static byte ToByte(char[] chars, int offset) { return (byte)(Lookup(chars[offset]) << 4 | Lookup(chars[offset + 1])); } 

एन्कोडिंग

 private static readonly char[][] LookupTableUpper; private static readonly char[][] LookupTableLower; static Hex() { LookupTableLower = new char[256][]; LookupTableUpper = new char[256][]; for (var i = 0; i < 256; i++) { LookupTableLower[i] = i.ToString("x2").ToCharArray(); LookupTableUpper[i] = i.ToString("X2").ToCharArray(); } } public static char[] ToCharLower(byte[] b, int bOffset) { return LookupTableLower[b[bOffset]]; } public static char[] ToCharUpper(byte[] b, int bOffset) { return LookupTableUpper[b[bOffset]]; } 

तुलना

 StringBuilderToStringFromBytes: 106148 BitConverterToStringFromBytes: 15783 ArrayConvertAllToStringFromBytes: 54290 ByteManipulationToCharArray: 8444 TableBasedToCharArray: 5651 * 

* यह समाधान

ध्यान दें

डिकोडिंग के दौरान IOException और IndexOutRangeException हो सकता है (यदि कोई वर्ण बहुत अधिक मूल्य> 256 है)। डे / एन्कोडिंग स्ट्रीम या एरे के लिए तरीके लागू किए जाने चाहिए, यह केवल अवधारणा का प्रमाण है।

यह Tomalak के अत्यधिक लोकप्रिय उत्तर (और बाद के संपादनों) के संशोधन 4 का उत्तर है ।

मैं यह मामला बनाऊँगा कि यह संपादन गलत है, और बताएं कि इसे क्यों वापस किया जा सकता है रास्ते में, आप कुछ आंतरिक सीखने के बारे में कुछ सीख सकते हैं, और अभी तक एक और उदाहरण देखेंगे कि समय से पहले अनुकूलन वास्तव में क्या है और आप इसे कैसे काट सकते हैं।

tl; dr: बस String.Substring उपयोग String.Substring और String.Substring यदि आप जल्दी में हैं (नीचे "मूल कोड"), तो यह सबसे अच्छा संयोजन है यदि आप String.Substring को पुन: लागू नहीं करना चाहते हैं। Convert.ToByte कुछ और उन्नत (अन्य उत्तर देखें) का उपयोग करें जो Convert.ToByte उपयोग नहीं करता है। यदि आपको प्रदर्शन की आवश्यकता है तो। String.Substring अलावा अन्य किसी भी चीज़ का उपयोग करें। String.Substring साथ संयोजन में String.Substring । करने के लिए, जब तक कि इस उत्तर की टिप्पणियों में किसी के बारे में कुछ दिलचस्प नहीं है।

चेतावनी: यह उत्तर अप्रचलित हो सकता है यदि Convert.ToByte(char[], Int32) ओवरलोड को रूपरेखा में लागू किया गया है। यह जल्द ही होने की संभावना नहीं है

एक सामान्य नियम के रूप में, मुझे यह कहना पसंद नहीं है "समय से पहले का अनुकूलन नहीं करें", क्योंकि कोई नहीं जानता कि "समयपूर्व" कब है। अनुकूलन के लिए या नहीं तय करने पर निर्णय लेने पर आपको केवल एक ही चीज़ पर विचार करना चाहिए: "क्या मेरे पास ऑप्टिमाइज़ेशन के तरीकों की जांच करने के लिए समय और संसाधन हैं?" यदि आप नहीं करते हैं, तो यह बहुत जल्द है, जब तक कि आपकी प्रोजेक्ट अधिक परिपक्व न हो जाए या जब तक आपको प्रदर्शन की आवश्यकता न हो, तब तक इंतजार करें (यदि वास्तविक आवश्यकता है, तो आप समय बना सकते हैं)। इस बीच, सरल चीज करें जो संभवत: बजाय काम कर सके।

मूल कोड:

  public static byte[] HexadecimalStringToByteArray_Original(string input) { var outputLength = input.Length / 2; var output = new byte[outputLength]; for (var i = 0; i < outputLength; i++) output[i] = Convert.ToByte(input.Substring(i * 2, 2), 16); return output; } 

संशोधन 4:

  public static byte[] HexadecimalStringToByteArray_Rev4(string input) { var outputLength = input.Length / 2; var output = new byte[outputLength]; using (var sr = new StringReader(input)) { for (var i = 0; i < outputLength; i++) output[i] = Convert.ToByte(new string(new char[2] { (char)sr.Read(), (char)sr.Read() }), 16); } return output; } 

संशोधन String.Substring से बचा जाता है और इसके बजाय String.Substring का उपयोग करता है। दिए गए कारण यह है:

संपादित करें: आप सिंगल पास पार्सर का उपयोग करके लंबे स्ट्रिंग के प्रदर्शन को बेहतर बना सकते हैं, जैसे:

खैर, String.Substring के लिए संदर्भ कोड को String.Substring , String.Substring , यह स्पष्ट रूप से पहले से ही "एकल-पास" है; और यह क्यों नहीं होना चाहिए? यह बाइट-स्तर पर संचालित होता है, किराए के जोड़े पर नहीं।

यह एक नई स्ट्रिंग आवंटित करता है, लेकिन फिर आपको Convert.ToByte करने के लिए किसी को भी आवंटित करना होगा। इसके अलावा, संशोधन में दिए गए समाधान हर आवृत्ति पर एक अन्य वस्तु (दो-चार सरणी) आवंटित करता है; you can safely put that allocation outside the loop and reuse the array to avoid that.

  public static byte[] HexadecimalStringToByteArray(string input) { var outputLength = input.Length / 2; var output = new byte[outputLength]; var numeral = new char[2]; using (var sr = new StringReader(input)) { for (var i = 0; i < outputLength; i++) { numeral[0] = (char)sr.Read(); numeral[1] = (char)sr.Read(); output[i] = Convert.ToByte(new string(numeral), 16); } } return output; } 

Each hexadecimal numeral represents a single octet using two digits (symbols).

But then, why call StringReader.Read twice? Just call its second overload and ask it to read two characters in the two-char array at once; and reduce the amount of calls by two.

  public static byte[] HexadecimalStringToByteArray(string input) { var outputLength = input.Length / 2; var output = new byte[outputLength]; var numeral = new char[2]; using (var sr = new StringReader(input)) { for (var i = 0; i < outputLength; i++) { var read = sr.Read(numeral, 0, 2); Debug.Assert(read == 2); output[i] = Convert.ToByte(new string(numeral), 16); } } return output; } 

What you're left with is a string reader whose only added "value" is a parallel index (internal _pos ) which you could have declared yourself (as j for example), a redundant length variable (internal _length ), and a redundant reference to the input string (internal _s ). In other words, it's useless.

If you wonder how Read "reads", just look at the code , all it does is call String.CopyTo on the input string. The rest is just book-keeping overhead to maintain values we don't need.

So, remove the string reader already, and call CopyTo yourself; it's simpler, clearer, and more efficient.

  public static byte[] HexadecimalStringToByteArray(string input) { var outputLength = input.Length / 2; var output = new byte[outputLength]; var numeral = new char[2]; for (int i = 0, j = 0; i < outputLength; i++, j += 2) { input.CopyTo(j, numeral, 0, 2); output[i] = Convert.ToByte(new string(numeral), 16); } return output; } 

Do you really need a j index that increments in steps of two parallel to i ? Of course not, just multiply i by two (which the compiler should be able to optimize to an addition).

  public static byte[] HexadecimalStringToByteArray_BestEffort(string input) { var outputLength = input.Length / 2; var output = new byte[outputLength]; var numeral = new char[2]; for (int i = 0; i < outputLength; i++) { input.CopyTo(i * 2, numeral, 0, 2); output[i] = Convert.ToByte(new string(numeral), 16); } return output; } 

What does the solution look like now? Exactly like it was at the beginning, only instead of using String.Substring to allocate the string and copy the data to it, you're using an intermediary array to which you copy the hexadecimal numerals to, then allocate the string yourself and copy the data again from the array and into the string (when you pass it in the string constructor). The second copy might be optimized-out if the string is already in the intern pool, but then String.Substring will also be able to avoid it in these cases.

In fact, if you look at String.Substring again, you see that it uses some low-level internal knowledge of how strings are constructed to allocate the string faster than you could normally do it, and it inlines the same code used by CopyTo directly in there to avoid the call overhead.

String.Substring

  • Worst-case: One fast allocation, one fast copy.
  • Best-case: No allocation, no copy.

Manual method

  • Worst-case: Two normal allocations, one normal copy, one fast copy.
  • Best-case: One normal allocation, one normal copy.

Conclusion? If you want to use Convert.ToByte(String, Int32) (because you don't want to re-implement that functionality yourself), there doesn't seem to be a way to beat String.Substring ; all you do is run in circles, re-inventing the wheel (only with sub-optimal materials).

Note that using Convert.ToByte and String.Substring is a perfectly valid choice if you don't need extreme performance. Remember: only opt for an alternative if you have the time and resources to investigate how it works properly.

If there was a Convert.ToByte(char[], Int32) , things would be different of course (it would be possible to do what I described above and completely avoid String ).

I suspect that people who report better performance by "avoiding String.Substring " also avoid Convert.ToByte(String, Int32) , which you should really be doing if you need the performance anyway. Look at the countless other answers to discover all the different approaches to do that.

Disclaimer: I haven't decompiled the latest version of the framework to verify that the reference source is up-to-date, I assume it is.

Now, it all sounds good and logical, hopefully even obvious if you've managed to get so far. But is it true?

 Intel(R) Core(TM) i7-3720QM CPU @ 2.60GHz Cores: 8 Current Clock Speed: 2600 Max Clock Speed: 2600 -------------------- Parsing hexadecimal string into an array of bytes -------------------- HexadecimalStringToByteArray_Original: 7,777.09 average ticks (over 10000 runs), 1.2X HexadecimalStringToByteArray_BestEffort: 8,550.82 average ticks (over 10000 runs), 1.1X HexadecimalStringToByteArray_Rev4: 9,218.03 average ticks (over 10000 runs), 1.0X 

हाँ!

Props to Partridge for the bench framework, it's easy to hack. The input used is the following SHA-1 hash repeated 5000 times to make a 100,000 bytes long string.

 209113288F93A9AB8E474EA78D899AFDBB874355 

Have fun! (But optimize with moderation.)

This is a great post. I like Waleed's solution. I haven't run it through patridge's test but it seems to be quite fast. I also needed the reverse process, converting a hex string to a byte array, so I wrote it as a reversal of Waleed's solution. Not sure if it's any faster than Tomalak's original solution. Again, I did not run the reverse process through patridge's test either.

 private byte[] HexStringToByteArray(string hexString) { int hexStringLength = hexString.Length; byte[] b = new byte[hexStringLength / 2]; for (int i = 0; i < hexStringLength; i += 2) { int topChar = (hexString[i] > 0x40 ? hexString[i] - 0x37 : hexString[i] - 0x30) << 4; int bottomChar = hexString[i + 1] > 0x40 ? hexString[i + 1] - 0x37 : hexString[i + 1] - 0x30; b[i / 2] = Convert.ToByte(topChar + bottomChar); } return b; } 

Complement to answer by @CodesInChaos (reversed method)

 public static byte[] HexToByteUsingByteManipulation(string s) { byte[] bytes = new byte[s.Length / 2]; for (int i = 0; i < bytes.Length; i++) { int hi = s[i*2] - 65; hi = hi + 10 + ((hi >> 31) & 7); int lo = s[i*2 + 1] - 65; lo = lo + 10 + ((lo >> 31) & 7) & 0x0f; bytes[i] = (byte) (lo | hi << 4); } return bytes; } 

Explanation:

& 0x0f is to support also lower case letters

hi = hi + 10 + ((hi >> 31) & 7); is the same as:

hi = ch-65 + 10 + (((ch-65) >> 31) & 7);

For '0'..'9' it is the same as hi = ch - 65 + 10 + 7; which is hi = ch - 48 (this is because of 0xffffffff & 7 ).

For 'A'..'F' it is hi = ch - 65 + 10; (this is because of 0x00000000 & 7 ).

For 'a'..'f' we have to big numbers so we must subtract 32 from default version by making some bits 0 by using & 0x0f .

65 is code for 'A'

48 is code for '0'

7 is the number of letters between '9' and 'A' in the ASCII table ( ...456789:;<=>?@ABCD... ).

Not to pile on to the many answers here, but I found a fairly optimal (~4.5x better than accepted), straightforward implementation of the hex string parser. First, output from my tests (the first batch is my implementation):

 Give me that string: 04c63f7842740c77e545bb0b2ade90b384f119f6ab57b680b7aa575a2f40939f Time to parse 100,000 times: 50.4192 ms Result as base64: BMY/eEJ0DHflRbsLKt6Qs4TxGfarV7aAt6pXWi9Ak58= BitConverter'd: 04-C6-3F-78-42-74-0C-77-E5-45-BB-0B-2A-DE-90-B3-84-F1-19-F6-AB-5 7-B6-80-B7-AA-57-5A-2F-40-93-9F Accepted answer: (StringToByteArray) Time to parse 100000 times: 233.1264ms Result as base64: BMY/eEJ0DHflRbsLKt6Qs4TxGfarV7aAt6pXWi9Ak58= BitConverter'd: 04-C6-3F-78-42-74-0C-77-E5-45-BB-0B-2A-DE-90-B3-84-F1-19-F6-AB-5 7-B6-80-B7-AA-57-5A-2F-40-93-9F With Mono's implementation: Time to parse 100000 times: 777.2544ms Result as base64: BMY/eEJ0DHflRbsLKt6Qs4TxGfarV7aAt6pXWi9Ak58= BitConverter'd: 04-C6-3F-78-42-74-0C-77-E5-45-BB-0B-2A-DE-90-B3-84-F1-19-F6-AB-5 7-B6-80-B7-AA-57-5A-2F-40-93-9F With SoapHexBinary: Time to parse 100000 times: 845.1456ms Result as base64: BMY/eEJ0DHflRbsLKt6Qs4TxGfarV7aAt6pXWi9Ak58= BitConverter'd: 04-C6-3F-78-42-74-0C-77-E5-45-BB-0B-2A-DE-90-B3-84-F1-19-F6-AB-5 7-B6-80-B7-AA-57-5A-2F-40-93-9F 

The base64 and 'BitConverter'd' lines are there to test for correctness. Note that they are equal.

The implementation:

 public static byte[] ToByteArrayFromHex(string hexString) { if (hexString.Length % 2 != 0) throw new ArgumentException("String must have an even length"); var array = new byte[hexString.Length / 2]; for (int i = 0; i < hexString.Length; i += 2) { array[i/2] = ByteFromTwoChars(hexString[i], hexString[i + 1]); } return array; } private static byte ByteFromTwoChars(char p, char p_2) { byte ret; if (p <= '9' && p >= '0') { ret = (byte) ((p - '0') << 4); } else if (p <= 'f' && p >= 'a') { ret = (byte) ((p - 'a' + 10) << 4); } else if (p <= 'F' && p >= 'A') { ret = (byte) ((p - 'A' + 10) << 4); } else throw new ArgumentException("Char is not a hex digit: " + p,"p"); if (p_2 <= '9' && p_2 >= '0') { ret |= (byte) ((p_2 - '0')); } else if (p_2 <= 'f' && p_2 >= 'a') { ret |= (byte) ((p_2 - 'a' + 10)); } else if (p_2 <= 'F' && p_2 >= 'A') { ret |= (byte) ((p_2 - 'A' + 10)); } else throw new ArgumentException("Char is not a hex digit: " + p_2, "p_2"); return ret; } 

I tried some stuff with unsafe and moving the (clearly redundant) character-to-nibble if sequence to another method, but this was the fastest it got.

(I concede that this answers half the question. I felt that the string->byte[] conversion was underrepresented, while the byte[]->string angle seems to be well covered. Thus, this answer.)

Safe versions:

 public static class HexHelper { [System.Diagnostics.Contracts.Pure] public static string ToHex(this byte[] value) { if (value == null) throw new ArgumentNullException("value"); const string hexAlphabet = @"0123456789ABCDEF"; var chars = new char[checked(value.Length * 2)]; unchecked { for (int i = 0; i < value.Length; i++) { chars[i * 2] = hexAlphabet[value[i] >> 4]; chars[i * 2 + 1] = hexAlphabet[value[i] & 0xF]; } } return new string(chars); } [System.Diagnostics.Contracts.Pure] public static byte[] FromHex(this string value) { if (value == null) throw new ArgumentNullException("value"); if (value.Length % 2 != 0) throw new ArgumentException("Hexadecimal value length must be even.", "value"); unchecked { byte[] result = new byte[value.Length / 2]; for (int i = 0; i < result.Length; i++) { // 0(48) - 9(57) -> 0 - 9 // A(65) - F(70) -> 10 - 15 int b = value[i * 2]; // High 4 bits. int val = ((b - '0') + ((('9' - b) >> 31) & -7)) << 4; b = value[i * 2 + 1]; // Low 4 bits. val += (b - '0') + ((('9' - b) >> 31) & -7); result[i] = checked((byte)val); } return result; } } } 

Unsafe versions For those who prefer performance and do not afraid of unsafeness. About 35% faster ToHex and 10% faster FromHex.

 public static class HexUnsafeHelper { [System.Diagnostics.Contracts.Pure] public static unsafe string ToHex(this byte[] value) { if (value == null) throw new ArgumentNullException("value"); const string alphabet = @"0123456789ABCDEF"; string result = new string(' ', checked(value.Length * 2)); fixed (char* alphabetPtr = alphabet) fixed (char* resultPtr = result) { char* ptr = resultPtr; unchecked { for (int i = 0; i < value.Length; i++) { *ptr++ = *(alphabetPtr + (value[i] >> 4)); *ptr++ = *(alphabetPtr + (value[i] & 0xF)); } } } return result; } [System.Diagnostics.Contracts.Pure] public static unsafe byte[] FromHex(this string value) { if (value == null) throw new ArgumentNullException("value"); if (value.Length % 2 != 0) throw new ArgumentException("Hexadecimal value length must be even.", "value"); unchecked { byte[] result = new byte[value.Length / 2]; fixed (char* valuePtr = value) { char* valPtr = valuePtr; for (int i = 0; i < result.Length; i++) { // 0(48) - 9(57) -> 0 - 9 // A(65) - F(70) -> 10 - 15 int b = *valPtr++; // High 4 bits. int val = ((b - '0') + ((('9' - b) >> 31) & -7)) << 4; b = *valPtr++; // Low 4 bits. val += (b - '0') + ((('9' - b) >> 31) & -7); result[i] = checked((byte)val); } } return result; } } } 

BTW For benchmark testing initializing alphabet every time convert function called is wrong, alphabet must be const (for string) or static readonly (for char[]). Then alphabet-based conversion of byte[] to string becomes as fast as byte manipulation versions.

And of course test must be compiled in Release (with optimization) and with debug option "Suppress JIT optimization" turned off (same for "Enable Just My Code" if code must be debuggable).

Why make it complex? This is simple in Visual Studio 2008:

C#:

 string hex = BitConverter.ToString(YourByteArray).Replace("-", ""); 

VB:

 Dim hex As String = BitConverter.ToString(YourByteArray).Replace("-", "") 

Inverse function for Waleed Eissa code (Hex String To Byte Array):

  public static byte[] HexToBytes(this string hexString) { byte[] b = new byte[hexString.Length / 2]; char c; for (int i = 0; i < hexString.Length / 2; i++) { c = hexString[i * 2]; b[i] = (byte)((c < 0x40 ? c - 0x30 : (c < 0x47 ? c - 0x37 : c - 0x57)) << 4); c = hexString[i * 2 + 1]; b[i] += (byte)(c < 0x40 ? c - 0x30 : (c < 0x47 ? c - 0x37 : c - 0x57)); } return b; } 

Waleed Eissa function with lower case support:

  public static string BytesToHex(this byte[] barray, bool toLowerCase = true) { byte addByte = 0x37; if (toLowerCase) addByte = 0x57; char[] c = new char[barray.Length * 2]; byte b; for (int i = 0; i < barray.Length; ++i) { b = ((byte)(barray[i] >> 4)); c[i * 2] = (char)(b > 9 ? b + addByte : b + 0x30); b = ((byte)(barray[i] & 0xF)); c[i * 2 + 1] = (char)(b > 9 ? b + addByte : b + 0x30); } return new string(c); } 

Extension methods (disclaimer: completely untested code, BTW…):

 public static class ByteExtensions { public static string ToHexString(this byte[] ba) { StringBuilder hex = new StringBuilder(ba.Length * 2); foreach (byte b in ba) { hex.AppendFormat("{0:x2}", b); } return hex.ToString(); } } 

etc.. Use either of Tomalak's three solutions (with the last one being an extension method on a string).

From Microsoft's developers, a nice, simple conversion:

 public static string ByteArrayToString(byte[] ba) { // Concatenate the bytes into one long string return ba.Aggregate(new StringBuilder(32), (sb, b) => sb.Append(b.ToString("X2")) ).ToString(); } 

While the above is clean an compact, performance junkies will scream about it using enumerators. You can get peak performance with an improved version of Tomolak's original answer:

 public static string ByteArrayToString(byte[] ba) { StringBuilder hex = new StringBuilder(ba.Length * 2); for(int i=0; i < ga.Length; i++) // <-- Use for loop is faster than foreach hex.Append(ba[i].ToString("X2")); // <-- ToString is faster than AppendFormat return hex.ToString(); } 

This is the fastest of all the routines I've seen posted here so far. Don't just take my word for it… performance test each routine and inspect its CIL code for yourself.

In terms of speed, this seems to be better than anything here:

  public static string ToHexString(byte[] data) { byte b; int i, j, k; int l = data.Length; char[] r = new char[l * 2]; for (i = 0, j = 0; i < l; ++i) { b = data[i]; k = b >> 4; r[j++] = (char)(k > 9 ? k + 0x37 : k + 0x30); k = b & 15; r[j++] = (char)(k > 9 ? k + 0x37 : k + 0x30); } return new string(r); } 

I did not get the code you suggested to work, Olipro. hex[i] + hex[i+1] apparently returned an int .

I did, however have some success by taking some hints from Waleeds code and hammering this together. It's ugly as hell but it seems to work and performs at 1/3 of the time compared to the others according to my tests (using patridges testing mechanism). Depending on input size. Switching around the ?:s to separate out 0-9 first would probably yield a slightly faster result since there are more numbers than letters.

 public static byte[] StringToByteArray2(string hex) { byte[] bytes = new byte[hex.Length/2]; int bl = bytes.Length; for (int i = 0; i < bl; ++i) { bytes[i] = (byte)((hex[2 * i] > 'F' ? hex[2 * i] - 0x57 : hex[2 * i] > '9' ? hex[2 * i] - 0x37 : hex[2 * i] - 0x30) << 4); bytes[i] |= (byte)(hex[2 * i + 1] > 'F' ? hex[2 * i + 1] - 0x57 : hex[2 * i + 1] > '9' ? hex[2 * i + 1] - 0x37 : hex[2 * i + 1] - 0x30); } return bytes; } 

This version of ByteArrayToHexViaByteManipulation could be faster.

From my reports:

  • ByteArrayToHexViaByteManipulation3: 1,68 average ticks (over 1000 runs), 17,5X
  • ByteArrayToHexViaByteManipulation2: 1,73 average ticks (over 1000 runs), 16,9X
  • ByteArrayToHexViaByteManipulation: 2,90 average ticks (over 1000 runs), 10,1X
  • ByteArrayToHexViaLookupAndShift: 3,22 average ticks (over 1000 runs), 9,1X
  •  static private readonly char[] hexAlphabet = new char[] {'0','1','2','3','4','5','6','7','8','9','A','B','C','D','E','F'}; static string ByteArrayToHexViaByteManipulation3(byte[] bytes) { char[] c = new char[bytes.Length * 2]; byte b; for (int i = 0; i < bytes.Length; i++) { b = ((byte)(bytes[i] >> 4)); c[i * 2] = hexAlphabet[b]; b = ((byte)(bytes[i] & 0xF)); c[i * 2 + 1] = hexAlphabet[b]; } return new string(c); } 

And I think this one is an optimization:

  static private readonly char[] hexAlphabet = new char[] {'0','1','2','3','4','5','6','7','8','9','A','B','C','D','E','F'}; static string ByteArrayToHexViaByteManipulation4(byte[] bytes) { char[] c = new char[bytes.Length * 2]; for (int i = 0, ptr = 0; i < bytes.Length; i++, ptr += 2) { byte b = bytes[i]; c[ptr] = hexAlphabet[b >> 4]; c[ptr + 1] = hexAlphabet[b & 0xF]; } return new string(c); } 

I'll enter this bit fiddling competition as I have an answer that also uses bit-fiddling to decode hexadecimals. Note that using character arrays may be even faster as calling StringBuilder methods will take time as well.

 public static String ToHex (byte[] data) { int dataLength = data.Length; // pre-create the stringbuilder using the length of the data * 2, precisely enough StringBuilder sb = new StringBuilder (dataLength * 2); for (int i = 0; i < dataLength; i++) { int b = data [i]; // check using calculation over bits to see if first tuple is a letter // isLetter is zero if it is a digit, 1 if it is a letter int isLetter = (b >> 7) & ((b >> 6) | (b >> 5)) & 1; // calculate the code using a multiplication to make up the difference between // a digit character and an alphanumerical character int code = '0' + ((b >> 4) & 0xF) + isLetter * ('A' - '9' - 1); // now append the result, after casting the code point to a character sb.Append ((Char)code); // do the same with the lower (less significant) tuple isLetter = (b >> 3) & ((b >> 2) | (b >> 1)) & 1; code = '0' + (b & 0xF) + isLetter * ('A' - '9' - 1); sb.Append ((Char)code); } return sb.ToString (); } public static byte[] FromHex (String hex) { // pre-create the array int resultLength = hex.Length / 2; byte[] result = new byte[resultLength]; // set validity = 0 (0 = valid, anything else is not valid) int validity = 0; int c, isLetter, value, validDigitStruct, validDigit, validLetterStruct, validLetter; for (int i = 0, hexOffset = 0; i < resultLength; i++, hexOffset += 2) { c = hex [hexOffset]; // check using calculation over bits to see if first char is a letter // isLetter is zero if it is a digit, 1 if it is a letter (upper & lowercase) isLetter = (c >> 6) & 1; // calculate the tuple value using a multiplication to make up the difference between // a digit character and an alphanumerical character // minus 1 for the fact that the letters are not zero based value = ((c & 0xF) + isLetter * (-1 + 10)) << 4; // check validity of all the other bits validity |= c >> 7; // changed to >>, maybe not OK, use UInt? validDigitStruct = (c & 0x30) ^ 0x30; validDigit = ((c & 0x8) >> 3) * (c & 0x6); validity |= (isLetter ^ 1) * (validDigitStruct | validDigit); validLetterStruct = c & 0x18; validLetter = (((c - 1) & 0x4) >> 2) * ((c - 1) & 0x2); validity |= isLetter * (validLetterStruct | validLetter); // do the same with the lower (less significant) tuple c = hex [hexOffset + 1]; isLetter = (c >> 6) & 1; value ^= (c & 0xF) + isLetter * (-1 + 10); result [i] = (byte)value; // check validity of all the other bits validity |= c >> 7; // changed to >>, maybe not OK, use UInt? validDigitStruct = (c & 0x30) ^ 0x30; validDigit = ((c & 0x8) >> 3) * (c & 0x6); validity |= (isLetter ^ 1) * (validDigitStruct | validDigit); validLetterStruct = c & 0x18; validLetter = (((c - 1) & 0x4) >> 2) * ((c - 1) & 0x2); validity |= isLetter * (validLetterStruct | validLetter); } if (validity != 0) { throw new ArgumentException ("Hexadecimal encoding incorrect for input " + hex); } return result; } 

Converted from Java code.

And for inserting into an SQL string (if you're not using command parameters):

 public static String ByteArrayToSQLHexString(byte[] Source) { return = "0x" + BitConverter.ToString(Source).Replace("-", ""); } 

Yet another variation for diversity:

 public static byte[] FromHexString(string src) { if (String.IsNullOrEmpty(src)) return null; int index = src.Length; int sz = index / 2; if (sz <= 0) return null; byte[] rc = new byte[sz]; while (--sz >= 0) { char lo = src[--index]; char hi = src[--index]; rc[sz] = (byte)( ( (hi >= '0' && hi <= '9') ? hi - '0' : (hi >= 'a' && hi <= 'f') ? hi - 'a' + 10 : (hi >= 'A' && hi <= 'F') ? hi - 'A' + 10 : 0 ) << 4 | ( (lo >= '0' && lo <= '9') ? lo - '0' : (lo >= 'a' && lo <= 'f') ? lo - 'a' + 10 : (lo >= 'A' && lo <= 'F') ? lo - 'A' + 10 : 0 ) ); } return rc; } 

Not optimized for speed, but more LINQy than most answers (.NET 4.0):

 <Extension()> Public Function FromHexToByteArray(hex As String) As Byte() hex = If(hex, String.Empty) If hex.Length Mod 2 = 1 Then hex = "0" & hex Return Enumerable.Range(0, hex.Length \ 2).Select(Function(i) Convert.ToByte(hex.Substring(i * 2, 2), 16)).ToArray End Function <Extension()> Public Function ToHexString(bytes As IEnumerable(Of Byte)) As String Return String.Concat(bytes.Select(Function(b) b.ToString("X2"))) End Function 

Two mashups which folds the two nibble operations into one.

Probably pretty efficient version:

 public static string ByteArrayToString2(byte[] ba) { char[] c = new char[ba.Length * 2]; for( int i = 0; i < ba.Length * 2; ++i) { byte b = (byte)((ba[i>>1] >> 4*((i&1)^1)) & 0xF); c[i] = (char)(55 + b + (((b-10)>>31)&-7)); } return new string( c ); } 

Decadent linq-with-bit-hacking version:

 public static string ByteArrayToString(byte[] ba) { return string.Concat( ba.SelectMany( b => new int[] { b >> 4, b & 0xF }).Select( b => (char)(55 + b + (((b-10)>>31)&-7))) ); } 

And reverse:

 public static byte[] HexStringToByteArray( string s ) { byte[] ab = new byte[s.Length>>1]; for( int i = 0; i < s.Length; i++ ) { int b = s[i]; b = (b - '0') + ((('9' - b)>>31)&-7); ab[i>>1] |= (byte)(b << 4*((i&1)^1)); } return ab; } 

Another way is by using stackalloc to reduce GC memory pressure:

 static string ByteToHexBitFiddle(byte[] bytes) { var c = stackalloc char[bytes.Length * 2 + 1]; int b; for (int i = 0; i < bytes.Length; ++i) { b = bytes[i] >> 4; c[i * 2] = (char)(55 + b + (((b - 10) >> 31) & -7)); b = bytes[i] & 0xF; c[i * 2 + 1] = (char)(55 + b + (((b - 10) >> 31) & -7)); } c[bytes.Length * 2 ] = '\0'; return new string(c); } 

Here's my shot at it. I've created a pair of extension classes to extend string and byte. On the large file test, the performance is comparable to Byte Manipulation 2.

The code below for ToHexString is an optimized implementation of the lookup and shift algorithm. It is almost identical to the one by Behrooz, but it turns out using a foreach to iterate and a counter is faster than an explicitly indexing for .

It comes in 2nd place behind Byte Manipulation 2 on my machine and is very readable code. The following test results are also of interest:

ToHexStringCharArrayWithCharArrayLookup: 41,589.69 average ticks (over 1000 runs), 1.5X ToHexStringCharArrayWithStringLookup: 50,764.06 average ticks (over 1000 runs), 1.2X ToHexStringStringBuilderWithCharArrayLookup: 62,812.87 average ticks (over 1000 runs), 1.0X

Based on the above results it seems safe to conclude that:

  1. The penalties for indexing into a string to perform the lookup vs. a char array are significant in the large file test.
  2. The penalties for using a StringBuilder of known capacity vs. a char array of known size to create the string are even more significant.

Here's the code:

 using System; namespace ConversionExtensions { public static class ByteArrayExtensions { private readonly static char[] digits = new char[] { '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', 'A', 'B', 'C', 'D', 'E', 'F' }; public static string ToHexString(this byte[] bytes) { char[] hex = new char[bytes.Length * 2]; int index = 0; foreach (byte b in bytes) { hex[index++] = digits[b >> 4]; hex[index++] = digits[b & 0x0F]; } return new string(hex); } } } using System; using System.IO; namespace ConversionExtensions { public static class StringExtensions { public static byte[] ToBytes(this string hexString) { if (!string.IsNullOrEmpty(hexString) && hexString.Length % 2 != 0) { throw new FormatException("Hexadecimal string must not be empty and must contain an even number of digits to be valid."); } hexString = hexString.ToUpperInvariant(); byte[] data = new byte[hexString.Length / 2]; for (int index = 0; index < hexString.Length; index += 2) { int highDigitValue = hexString[index] <= '9' ? hexString[index] - '0' : hexString[index] - 'A' + 10; int lowDigitValue = hexString[index + 1] <= '9' ? hexString[index + 1] - '0' : hexString[index + 1] - 'A' + 10; if (highDigitValue < 0 || lowDigitValue < 0 || highDigitValue > 15 || lowDigitValue > 15) { throw new FormatException("An invalid digit was encountered. Valid hexadecimal digits are 0-9 and AF."); } else { byte value = (byte)((highDigitValue << 4) | (lowDigitValue & 0x0F)); data[index / 2] = value; } } return data; } } } 

Below are the test results that I got when I put my code in @patridge's testing project on my machine. I also added a test for converting to a byte array from hexadecimal. The test runs that exercised my code are ByteArrayToHexViaOptimizedLookupAndShift and HexToByteArrayViaByteManipulation. The HexToByteArrayViaConvertToByte was taken from XXXX. The HexToByteArrayViaSoapHexBinary is the one from @Mykroft's answer.

Intel Pentium III Xeon processor

  Cores: 4 <br/> Current Clock Speed: 1576 <br/> Max Clock Speed: 3092 <br/> 

Converting array of bytes into hexadecimal string representation


ByteArrayToHexViaByteManipulation2: 39,366.64 average ticks (over 1000 runs), 22.4X

ByteArrayToHexViaOptimizedLookupAndShift: 41,588.64 average ticks (over 1000 runs), 21.2X

ByteArrayToHexViaLookup: 55,509.56 average ticks (over 1000 runs), 15.9X

ByteArrayToHexViaByteManipulation: 65,349.12 average ticks (over 1000 runs), 13.5X

ByteArrayToHexViaLookupAndShift: 86,926.87 average ticks (over 1000 runs), 10.2X

ByteArrayToHexStringViaBitConverter: 139,353.73 average ticks (over 1000 runs),6.3X

ByteArrayToHexViaSoapHexBinary: 314,598.77 average ticks (over 1000 runs), 2.8X

ByteArrayToHexStringViaStringBuilderForEachByteToString: 344,264.63 average ticks (over 1000 runs), 2.6X

ByteArrayToHexStringViaStringBuilderAggregateByteToString: 382,623.44 average ticks (over 1000 runs), 2.3X

ByteArrayToHexStringViaStringBuilderForEachAppendFormat: 818,111.95 average ticks (over 1000 runs), 1.1X

ByteArrayToHexStringViaStringConcatArrayConvertAll: 839,244.84 average ticks (over 1000 runs), 1.1X

ByteArrayToHexStringViaStringBuilderAggregateAppendFormat: 867,303.98 average ticks (over 1000 runs), 1.0X

ByteArrayToHexStringViaStringJoinArrayConvertAll: 882,710.28 average ticks (over 1000 runs), 1.0X


For performance I would go with drphrozens solution. A tiny optimization for the decoder could be to use a table for either char to get rid of the "<< 4".

Clearly the two method calls are costly. If some kind of check is made either on input or output data (could be CRC, checksum or whatever) the if (b == 255)... could be skipped and thereby also the method calls altogether.

Using offset++ and offset instead of offset and offset + 1 might give some theoretical benefit but I suspect the compiler handles this better than me.

 private static readonly byte[] LookupTableLow = new byte[] { 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x0A, 0x0B, 0x0C, 0x0D, 0x0E, 0x0F, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x0A, 0x0B, 0x0C, 0x0D, 0x0E, 0x0F, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF }; private static readonly byte[] LookupTableHigh = new byte[] { 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x00, 0x10, 0x20, 0x30, 0x40, 0x50, 0x60, 0x70, 0x80, 0x90, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xA0, 0xB0, 0xC0, 0xD0, 0xE0, 0xF0, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xA0, 0xB0, 0xC0, 0xD0, 0xE0, 0xF0, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF }; private static byte LookupLow(char c) { var b = LookupTableLow[c]; if (b == 255) throw new IOException("Expected a hex character, got " + c); return b; } private static byte LookupHigh(char c) { var b = LookupTableHigh[c]; if (b == 255) throw new IOException("Expected a hex character, got " + c); return b; } public static byte ToByte(char[] chars, int offset) { return (byte)(LookupHigh(chars[offset++]) | LookupLow(chars[offset])); } 

This is just off the top of my head and has not been tested or benchmarked.

If performance matters, here's an optimized solution:

  static readonly char[] _hexDigits = "0123456789abcdef".ToCharArray(); public static string ToHexString(this byte[] bytes) { char[] digits = new char[bytes.Length * 2]; for (int i = 0; i < bytes.Length; i++) { int d1, d2; d1 = Math.DivRem(bytes[i], 16, out d2); digits[2 * i] = _hexDigits[d1]; digits[2 * i + 1] = _hexDigits[d2]; } return new string(digits); } 

It's about 2.5 times faster that BitConverter.ToString , and about 7 times faster that BitConverter.ToString + removal of the '-' chars.