using System;

using System.Numerics;

using System.Globalization;

using System.Text;

using System.Linq;

public class Program

{

    public static void Main()

    {

        string hex = "3018E51206F26DC000000002";

        //hex = "3018E";

               hex = "303400C0E4424C80009FE8D8";

​

        BigInteger bigint = BigInteger.Parse(hex, NumberStyles.HexNumber);

        Console.WriteLine("" + bigint.ToBinaryString());

        Console.WriteLine("" + bigint.ToBinaryString().Length + "  " + (bigint.ToBinaryString().Length / 4));

        string bin = "01100000011010000000000110000001110010001000010010011001000000000000000100111111110100011011000";

        string hex2 = BinaryStringToHexString(bin);

        Console.WriteLine("" + hex2);

        Console.WriteLine("" + BinaryStringToDecString(bin));

    }

    public static string BinaryStringToHexString(string binary)

    {

        if (string.IsNullOrEmpty(binary))

            return binary;

​

        StringBuilder result = new StringBuilder(binary.Length / 8 + 1);

​

        // TODO: check all 1's or 0's... throw otherwise

​

        int mod4Len = binary.Length % 8;

        if (mod4Len != 0)

        {

            // pad to length multiple of 8

            binary = binary.PadLeft(((binary.Length / 8) + 1) * 8, '0');

        }

​

        for (int i = 0; i < binary.Length; i += 8)

        {

            string eightBits = binary.Substring(i, 8);

            result.AppendFormat("{0:X2}", Convert.ToByte(eightBits, 2));

        }

​

        return result.ToString();

    }

    public static BigInteger BinaryStringToDecString(string binary)

    {

        if (string.IsNullOrEmpty(binary))

            return 0;

​

        BigInteger res = 0;

        if (binary.Count(b => b == '1') + binary.Count(b => b == '0') != binary.Length) return res;

        foreach (var c in binary)

        {

            res <<= 1;

            res += c == '1' ? 1 : 0;

        }

​

        return res;

    }

}

​

​

​

/// <summary>

/// Extension methods to convert <see cref="System.Numerics.BigInteger"/>

/// instances to hexadecimal, octal, and binary strings.

/// </summary>

public static class BigIntegerExtensions

{

  /// <summary>

  /// Converts a <see cref="BigInteger"/> to a binary string.

  /// </summary>

  /// <param name="bigint">A <see cref="BigInteger"/>.</param>

  /// <returns>

  /// A <see cref="System.String"/> containing a binary

  /// representation of the supplied <see cref="BigInteger"/>.

  /// </returns>

  public static string ToBinaryString(this BigInteger bigint)

  {

    var bytes = bigint.ToByteArray();

    var idx = bytes.Length - 1;

​

    // Create a StringBuilder having appropriate capacity.

    var base2 = new StringBuilder(bytes.Length * 8);

​

    // Convert first byte to binary.

    var binary = Convert.ToString(bytes[idx], 2);

​

    // Ensure leading zero exists if value is positive.

    if (binary[0] != '0' && bigint.Sign == 1)

    {

      base2.Append('0');

    }

​

    // Append binary string to StringBuilder.

    base2.Append(binary);

​

    // Convert remaining bytes adding leading zeros.

    for (idx--; idx >= 0; idx--)

    {

      base2.Append(Convert.ToString(bytes[idx], 2).PadLeft(8, '0'));

    }

​

    return base2.ToString();

  }

​

  /// <summary>

  /// Converts a <see cref="BigInteger"/> to a hexadecimal string.

  /// </summary>

  /// <param name="bigint">A <see cref="BigInteger"/>.</param>

  /// <returns>

  /// A <see cref="System.String"/> containing a hexadecimal

  /// representation of the supplied <see cref="BigInteger"/>.

  /// </returns>

  public static string ToHexadecimalString(this BigInteger bigint)

  {

    return bigint.ToString("X");

  }

​

  /// <summary>

  /// Converts a <see cref="BigInteger"/> to a octal string.

  /// </summary>

  /// <param name="bigint">A <see cref="BigInteger"/>.</param>

  /// <returns>

  /// A <see cref="System.String"/> containing an octal

  /// representation of the supplied <see cref="BigInteger"/>.

  /// </returns>

  public static string ToOctalString(this BigInteger bigint)

  {

    var bytes = bigint.ToByteArray();

    var idx = bytes.Length - 1;

​

    // Create a StringBuilder having appropriate capacity.

    var base8 = new StringBuilder(((bytes.Length / 3) + 1) * 8);

​

    // Calculate how many bytes are extra when byte array is split

    // into three-byte (24-bit) chunks.

    var extra = bytes.Length % 3;

​

    // If no bytes are extra, use three bytes for first chunk.

    if (extra == 0)

    {

      extra = 3;

    }

​

    // Convert first chunk (24-bits) to integer value.

    int int24 = 0;

    for (; extra != 0; extra--)

    {

      int24 <<= 8;

      int24 += bytes[idx--];

    }

​

    // Convert 24-bit integer to octal without adding leading zeros.

    var octal = Convert.ToString(int24, 8);

​

    // Ensure leading zero exists if value is positive.

    if (octal[0] != '0' && bigint.Sign == 1)

    {

      base8.Append('0');

    }

​

    // Append first converted chunk to StringBuilder.

    base8.Append(octal);

​

    // Convert remaining 24-bit chunks, adding leading zeros.

    for (; idx >= 0; idx -= 3)

    {

      int24 = (bytes[idx] << 16) + (bytes[idx - 1] << 8) + bytes[idx - 2];

      base8.Append(Convert.ToString(int24, 8).PadLeft(8, '0'));

    }

​

    return base8.ToString();

  }

}