Check the string to see if all characters are hexadecimal values

Question

What is the most efficient way in C # 2.0 to check every character in a string and return true if all valid hexadecimal characters and false otherwise?

Example

void Test() { OnlyHexInString("123ABC"); // Returns true OnlyHexInString("123def"); // Returns true OnlyHexInString("123g"); // Returns false } bool OnlyHexInString(string text) { // Most efficient algorithm to check each digit in C# 2.0 goes here } 

Answer 1

 public bool OnlyHexInString(string test) { // For C-style hex notation (0xFF) you can use @"\A\b(0[xX])?[0-9a-fA-F]+\b\Z" return System.Text.RegularExpressions.Regex.IsMatch(test, @"\A\b[0-9a-fA-F]+\b\Z"); } 

Answer 2

Something like that:

(I don't know C #, so I'm not sure how to scroll line by line.)

 loop through the chars { bool is_hex_char = (current_char >= '0' && current_char <= '9') || (current_char >= 'a' && current_char <= 'f') || (current_char >= 'A' && current_char <= 'F'); if (!is_hex_char) { return false; } } return true; 

The code for the logic above

 private bool IsHex(IEnumerable<char> chars) { bool isHex; foreach(var c in chars) { isHex = ((c >= '0' && c <= '9') || (c >= 'a' && c <= 'f') || (c >= 'A' && c <= 'F')); if(!isHex) return false; } return true; } 

Answer 3

You can do a TryParse in a string to check if the string in its entirity is a hexadecimal number.

If this is a particularly long string, you can take it in pieces and go through it.

 // string hex = "bacg123"; Doesn't parse // string hex = "bac123"; Parses string hex = "bacg123"; long output; long.TryParse(hex, System.Globalization.NumberStyles.HexNumber, null, out output); 

Answer 4

I am using Int32.TryParse() for this. Here is the MSDN page .

Answer 5

Here is the LINQ yjerem version above:

 private static bool IsValidHexString(IEnumerable<char> hexString) { return hexString.Select(currentCharacter => (currentCharacter >= '0' && currentCharacter <= '9') || (currentCharacter >= 'a' && currentCharacter <= 'f') || (currentCharacter >= 'A' && currentCharacter <= 'F')).All(isHexCharacter => isHexCharacter); } 

Answer 6

Publishing the VB.NET version is Jeremy's answer because I came here looking for that version. It should be easy to convert it to C #.

 ''' <summary> ''' Checks if a string contains ONLY hexadecimal digits. ''' </summary> ''' <param name="str">String to check.</param> ''' <returns> ''' True if string is a hexadecimal number, False if otherwise. ''' </returns> Public Function IsHex(ByVal str As String) As Boolean If String.IsNullOrWhiteSpace(str) Then _ Return False Dim i As Int32, c As Char If str.IndexOf("0x") = 0 Then _ str = str.Substring(2) While (i < str.Length) c = str.Chars(i) If Not (((c >= "0"c) AndAlso (c <= "9"c)) OrElse ((c >= "a"c) AndAlso (c <= "f"c)) OrElse ((c >= "A"c) AndAlso (c <= "F"c))) _ Then Return False Else i += 1 End If End While Return True End Function 

Answer 7

Regular expression is not very effective in better times. The most effective would be to use a simple for loop to search the characters of a string and break up the first found invalid.

However, this can be done very succinctly with LINQ :

 bool isHex = myString.ToCharArray().Any(c => !"0123456789abcdefABCDEF".Contains(c)); 

I cannot vouch for efficiency since LINQ is LINQ, but Any () should have a pretty well optimized compilation scheme.

Answer 8

What about:

bool isHex = text.All("0123456789abcdefABCDEF".Contains);

This basically says: check to see if all characters in the text string in the string are valid hexadecimal values.

Which one is the easiest and most readable solution.

(don't forget to add using System.Linq; )

EDIT:
Just noticed that Enumerable.All() is only available with .NET 3.5.

Answer 9

In terms of performance, the fastest is likely to simply list the characters and perform a simple comparison check.

 bool OnlyHexInString(string text) { for (var i = 0; i < text.Length; i++) { var current = text[i]; if (!(Char.IsDigit(current) || (current >= 'a' && current <= 'f'))) { return false; } } return true; } 

To really find out which method is the fastest, although you need to do profiling.

Answer 10

  //Another workaround, although RegularExpressions is the best solution boolean OnlyHexInString(String text) { for(int i = 0; i < text.size(); i++) if( !Uri.IsHexDigit(text.charAt(i)) ) return false; return true; } 

Answer 11

In terms of programmer time, it is probably best to name a string-chain parsing function (e.g. Java Integer.parseInt (str, base)) and see if you get an exception. If you want to write it yourself and potentially have more time / space-efficiency ...

The most effective, I assume, will be a lookup table for each character. You will have a 2 ^ 8 (or 2 ^ 16 for Unicode) -entry array of booleans, each of which will be true if it is a valid hexadecimal character, or false if not. The code will look something like this (in Java, sorry ;-):

 boolean lut[256]={false,false,true,........} boolean OnlyHexInString(String text) { for(int i = 0; i < text.size(); i++) if(!lut[text.charAt(i)]) return false; return true; } 

Answer 12

This can be done using regular expressions, which are an effective way to check if a string matches a particular pattern.

A possible regular expression for a hexadecimal digit would be [A-Ha-h0-9], some implementations even have a specific code for hexadecimal digits, for example. [[: Xdigit:]].

Answer 13

You can expand the string and char using the following command:

  public static bool IsHex(this string value) { return value.All(c => c.IsHex()); } public static bool IsHex(this char c) { c = Char.ToLower(c); if (Char.IsDigit(c) || (c >= 'a' && c <= 'f')) return true; else return false; } 

Answer 14

Easy solution without regular expressions:

VB.NET:

 Public Function IsHexString(value As String) As Boolean Dim hx As String = "0123456789ABCDEF" For Each c As Char In value.ToUpper If Not hx.Contains(c) Then Return False Next Return True End Function 

Or in C #

 public bool IsHexString(string value) { string hx = "0123456789ABCDEF"; foreach (char c in value.ToUpper()) { if (!hx.Contains(c)) return false; } return true; } 

Answer 15

I am using this method:

 public static bool IsHex(this char c) { return (c >= '0' && c <= '9') || (c >= 'a' && c <= 'f') || (c >= 'A' && c <= 'F'); } 

Answer 16

And this is like a C # extension method ...

 public static class StringExtensions { public static bool IsHexString(this string str) { foreach (var c in str) { var isHex = ((c >= '0' && c <= '9') || (c >= 'a' && c <= 'f') || (c >= 'A' && c <= 'F')); if (!isHex) { return false; } } return true; } //bonus, verify whether a string can be parsed as byte[] public static bool IsParseableToByteArray(this string str) { return IsHexString(str) && str.Length % 2 == 0; } } 

Use it like that ...

 if("08c9b54d1099e73d121c4200168f252e6e75d215969d253e074a9457d0401cc6".IsHexString()) { //returns true... } 

Answer 17

I made this solution to solve this problem. Make sure that it doesn't matter before you run the query string.

 for (int i = 0; i < Request.Length; i += 2) if (!byte.TryParse(string.Join("", Request.Skip(i).Take(2)), NumberStyles.HexNumber, CultureInfo.InvariantCulture, out _)) return false; 

Answer 18

 public static bool HexInCardUID(string test) { if (test.Trim().Length != 14) return false; for (int i = 0; i < test.Length; i++) if (!Uri.IsHexDigit(Convert.ToChar(test.Substring(i, 1)))) return false; return true; }**strong text** 

Answer 19

Now only

 if (IsHex(text)) { return true; } else { return false; }