namespace HexaEncoding
{
#region[Directive]
using System;
using System.Text;
#endregion[Directive]
/// <summary>
/// Summary description for HexEncoding.
/// </summary>
public class HexaEncoding
{
public HexaEncoding()
{
//
// TODO: Add constructor logic here
//
}
public static int GetByteCount(string hexString)
{
int numHexChars = 0;
char c;
// remove all none A-F, 0-9, characters
for (int i=0; i<hexString.Length; i++)
{
c = hexString[i];
if (IsHexDigit(c))
numHexChars++;
}
// if odd number of characters, discard last character
if (numHexChars % 2 != 0)
{
numHexChars--;
}
return numHexChars / 2; // 2 characters per byte
}
/// <summary>
/// Creates a byte array from the hexadecimal string. Each two characters are combined
/// to create one byte. First two hexadecimal characters become first byte in returned array.
/// Non-hexadecimal characters are ignored.
/// </summary>
/// <param name="hexString">string to convert to byte array</param>
/// <param name="discarded">number of characters in string ignored</param>
/// <returns>byte array, in the same left-to-right order as the hexString</returns>
public static byte[] GetBytes(string hexString, out int discarded)
{
discarded = 0;
string newString = "";
char c;
// remove all none A-F, 0-9, characters
for (int i=0; i<hexString.Length; i++)
{
c = hexString[i];
if (IsHexDigit(c))
newString += c;
else
discarded++;
}
// if odd number of characters, discard last character
if (newString.Length % 2 != 0)
{
discarded++;
newString = newString.Substring(0, newString.Length-1);
}
int byteLength = newString.Length / 2;
byte[] bytes = new byte[byteLength];
string hex;
int j = 0;
for (int i=0; i<bytes.Length; i++)
{
hex = new String(new Char[] {newString[j], newString[j+1]});
bytes[i] = HexToByte(hex);
j = j+2;
}
return bytes;
}
public static string ToString(byte[] bytes)
{
string hexString = "";
for (int i = 0; i < bytes.Length; i++)
{
hexString += bytes[i].ToString("X2");
}
return hexString;
}
public static string ToString(byte[] bytes, int offset, int receiveSize)
{
string hexString = "";
for (int i = offset; i < receiveSize; i++)
{
hexString += bytes[i].ToString("X2");
}
return hexString;
}
/// <summary>
/// Determines if given string is in proper hexadecimal string format
/// </summary>
/// <param name="hexString"></param>
/// <returns></returns>
public static bool InHexFormat(string hexString)
{
bool hexFormat = true;
foreach (char digit in hexString)
{
if (!IsHexDigit(digit))
{
hexFormat = false;
break;
}
}
return hexFormat;
}
/// <summary>
/// Returns true is c is a hexadecimal digit (A-F, a-f, 0-9)
/// </summary>
/// <param name="c">Character to test</param>
/// <returns>true if hex digit, false if not</returns>
public static bool IsHexDigit(Char c)
{
int numChar;
int numA = Convert.ToInt32('A');
int num1 = Convert.ToInt32('0');
c = Char.ToUpper(c);
numChar = Convert.ToInt32(c);
if (numChar >= numA && numChar < (numA + 6))
return true;
if (numChar >= num1 && numChar < (num1 + 10))
return true;
return false;
}
/// <summary>
/// Converts 1 or 2 character string into equivalant byte value
/// </summary>
/// <param name="hex">1 or 2 character string</param>
/// <returns>byte</returns>
private static byte HexToByte(string hex)
{
if (hex.Length > 2 || hex.Length <= 0)
throw new ArgumentException("hex must be 1 or 2 characters in length");
byte newByte = byte.Parse(hex, System.Globalization.NumberStyles.HexNumber);
return newByte;
}
}
}
namespace HexaEncoding
{ #region[Directive] using System; using System.Collections.Generic; using System.Linq; using System.Text; #endregion[Directive] /// <summary> /// This class contain the convertion function /// </summary> public class DataElementConvertion { /// <summary> /// This function is used to convert hexa value /// to char /// </summary> /// <param name="hexavalue">contain the hexa value</param> /// <returns>character representation of the hexa format</returns> public static char HexaToChar(string hexavalue) { StringBuilder hexaString = new StringBuilder(); hexaString.AppendFormat("0x{0}", hexavalue); int hexaNum = Convert.ToInt32(hexaString.ToString(), 16); char charValue = Convert.ToChar(hexaNum); return charValue; } /// <summary> /// This function is used to convert the char to hexa /// </summary> /// <param name="charvalue">string data type:Contain the char value</param> /// <returns>string data type:Contain the string data</returns> public static string ChartoHexa(string charvalue) { byte[] asciivalue = Encoding.ASCII.GetBytes(charvalue); string value = string.Empty; for (int i = 0; i < asciivalue.Length; i++) { value += Convert.ToString(asciivalue[i], 16); } return value; } /// <summary> /// This function is used to convert bit map /// to byte /// </summary> /// <param name="bitmap">string data type</param> /// <returns>array of byte</returns> public static byte[] bitmapToByte(string bitmap) { int discard=0; return HexaEncoding.GetBytes(bitmap, out discard); } /// <summary> /// This function is used to convert the byte to binary /// </summary> /// <param name="bytes">bytes contain all the bytes</param> /// <returns>string data type:return back the string of binary value</returns> public static string ByteToBinary(byte[] bytes) { StringBuilder strbHexa = new StringBuilder(); foreach (byte data in bytes) { strbHexa.AppendFormat("{0:x2}", data); } string hexaString = strbHexa.ToString(); string binaryData = string.Empty; foreach (char hexaChar in hexaString) { string binaryString = Convert.ToString(Convert.ToInt32(hexaChar.ToString(), 16), 2); binaryData += binaryString.Length > 3 ? binaryString : binaryString.PadLeft(4, '0'); } return binaryData; } /// <summary> /// This function is used to do byte to byte /// </summary> /// <param name="bytes">bytes contains all the bytes</param> /// <returns>string data type:return back the string of binary data</returns> public static string ByteToBinary(byte bytes) { string hexaString = Convert.ToString(bytes, 16); string binaryData = string.Empty; foreach (char hexaChar in hexaString) { string binaryString = Convert.ToString(Convert.ToInt32(hexaChar.ToString(), 16), 2); binaryData += binaryString.Length > 3 ? binaryString : binaryString.PadLeft(4, '0'); } return binaryData; } /// <summary> /// This function is used to do the bit map detail : /// ie provide the positions of the data in dataelement string /// </summary> /// <param name="bytes">array of byte</param> /// <returns>array of string</returns> public static string[] BitmapDetail(byte[] bytes) { string binaryData = ByteToBinary(bytes); string[] bitMapDetail = new string[binaryData.Length]; for (int i = 0; i < binaryData.Length; i++) { bitMapDetail[i] = binaryData[i].ToString() == "1" ? (i + 1).ToString() : string.Empty; } return bitMapDetail; } /// <summary> /// This function is used to convert the binary to hexa /// </summary> /// <param name="binayString">binary string data</param> /// <returns>hexa string data</returns> public static string BinaryToHexa(string binayString) { StringBuilder hexaValue = new StringBuilder(); string[] noOfbytes = BytesDetail(binayString); foreach (string bytes in noOfbytes) { int decimalvalue = BinaryToDecimal(bytes); string hexaData = Convert.ToString(decimalvalue, 16); hexaValue.Append(hexaData); } return hexaValue.ToString(); } /// <summary> /// This function is used to find out no of bytes /// </summary> /// <param name="binayString">string data type</param> /// <returns>array of string data type</returns> public static string[] BytesDetail(string binayString) { string binaryData = binayString; Int64 binarylength = binayString.Trim().Length; Int64 noBytes = binarylength / 4; string[] binaryDetail = new string[noBytes]; for (int i = 0; i < noBytes; i++) { int startindex = (4 * i); int length = (noBytes == 0) ? 0 : (startindex == 0) ? 4 : (binarylength - startindex) < binarylength ? 4 : 0; if (length == 0) { binaryDetail[i] = binaryData.Substring(startindex); } else { binaryDetail[i] = binaryData.Substring(startindex, length); } } return binaryDetail; } /// <summary> /// This function is used to convert binary to decimal /// </summary> /// <param name="binaryString">binaryString is contain four bits(0000 or 0101) </param> /// <returns>return decimal value</returns> public static int BinaryToDecimal(string binaryString) { int decimalValue = 0; int j = 0; for (int i = binaryString.Length - 1; i >= 0; i--) { decimalValue += Convert.ToInt32(binaryString[i].ToString()) * Convert.ToInt32(pow(double.Parse("2"), j)); j++; } return decimalValue; } /// <summary> /// This function is used to calculate the power /// of the number /// </summary> /// <param name="power">double data type</param> /// <param name="number">int data type</param> /// <returns>double data type</returns> public static double pow(double number, int power) { return power == 0 ? 1 : power == 1 ? number : number * pow(number, --power); } /// <summary> /// This function is used to trim the string /// </summary> /// <param name="isoRequest">string data type</param> /// <returns>string data type</returns> public static string StringTrim(string isoRequest) { StringBuilder isoRequestMessage = new StringBuilder(); char[] isoRequestChar = isoRequest.ToCharArray(); for (int i = 0; i < isoRequestChar.Length; i++) { if (!string.IsNullOrEmpty(isoRequestChar[i].ToString())) { isoRequestMessage.Append(isoRequestChar[i].ToString()); } } return isoRequestMessage.ToString(); } /// <summary> /// This function is used to convert the decimal to binary /// </summary> /// <param name="decimalValue">string Data Type</param> /// <returns>string Data Type</returns> public static string DecimalToBinary(string decimalValue) { // Declare a few variables we're going to need Int64 BinaryHolder; char[] BinaryArray; string BinaryResult = ""; Int64 decivalue = Convert.ToInt64(decimalValue); while (decivalue > 0) { BinaryHolder = decivalue % 2; BinaryResult += BinaryHolder; decivalue = decivalue / 2; } // The algoritm gives us the binary number in reverse order (mirrored) // We store it in an array so that we can reverse it back to normal BinaryArray = BinaryResult.ToCharArray(); Array.Reverse(BinaryArray); BinaryResult = new string(BinaryArray); return BinaryResult.PadLeft(8, '0'); } /// <summary> /// This function is used to convert the hexa value to the decimal value /// </summary> /// <returns>it will return the decimal value as integer</returns> public static int HexaToDecimal(string hexaValue) { int decimalValue = 0; int j = 0; for (int i = hexaValue.Length - 1; i >= 0; i--) { int hexaDecivalue = 0; switch (hexaValue[i].ToString()) { case "A": hexaDecivalue = 10; break; case "B": hexaDecivalue = 11; break; case "C": hexaDecivalue = 12; break; case "D": hexaDecivalue = 13; break; case "E": hexaDecivalue = 14; break; case "F": hexaDecivalue = 15; break; default: hexaDecivalue = Convert.ToInt32(hexaValue[i].ToString()); break; } decimalValue += hexaDecivalue * Convert.ToInt32(pow(double.Parse("16"), j)); j++; } return decimalValue; } /// <summary> /// This function will check whether string contain[A-F] or [a-f] /// </summary> /// <param name="hexaValue">contain the hexa value</param> /// <returns>true if hex digit, false if not</returns> public static bool IsHexaFormat(string hexaValue) { bool ishexa = true; foreach (char c in hexaValue) { if (!IsHexaDigit(c)) { ishexa = false; break; } } return ishexa; } /// <summary> /// This function is used to check the char is in hexa format /// i.e whether it is contain[A-F]or [a-f] /// </summary> /// <param name="hexachar">hexa char value</param> /// <returns>if hexa true,or false</returns> private static bool IsHexaDigit(char c) { int numChar; int numA = Convert.ToInt32('A'); c = Char.ToUpper(c); numChar = Convert.ToInt32(c); if (numChar >= numA && numChar < (numA + 6)) return true; return false; } /// <summary> /// This function is used to convert the decimal value to /// the hexa /// </summary> /// <param name="value">decimal value</param> /// <returns>return hexa value</returns> public static string DecimalToHexa(int value) { Int64 HexaHolder; char[] HexaArray; string HexaResult = ""; Int64 decivalue = value; while (decivalue > 0) { HexaHolder = decivalue % 16; string hexavalue = string.Empty; switch (HexaHolder.ToString()) { case "10": hexavalue = "A"; break; case "11": hexavalue = "B"; break; case "12": hexavalue = "C"; break; case "13": hexavalue = "D"; break; case "14": hexavalue = "E"; break; case "15": hexavalue = "F"; break; default: hexavalue = HexaHolder.ToString(); break; } HexaResult += hexavalue; decivalue = decivalue / 16; } // The algoritm gives us the binary number in reverse order (mirrored) // We store it in an array so that we can reverse it back to normal HexaArray = HexaResult.ToCharArray(); Array.Reverse(HexaArray); HexaResult = new string(HexaArray); return HexaResult; } } }
Join the conversation! Your thoughts help the community grow.