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;
}
}
}