TestEncoding.cs | C# Online Compiler

TestEncoding.cs by mori3sh

using System;
using System.IO;
using System.Linq;
using System.Text;

/// <summary>A program.</summary>
/// <remarks>
/// 以下のプログラムでは、C#3.0で追加された拡張メソッドを定義して呼び出している.
/// 
/// 拡張メソッドについての詳細は以下を参照のこと.
/// https://msdn.microsoft.com/ja-jp/library/bb383977.aspx
/// 
/// </remarks>
public static class Program
{
    /// <summary>Main entry-point for this application.</summary>
    public static void Main()
    {
        // 半角英数字/ギリシャ文字(日本では全角)/ひらがなが、各文字集合/符号化形式でどのように扱われているかを調べる.
        string text = "012" + Environment.NewLine + "abc" + Environment.NewLine + "αβγ" + Environment.NewLine + "あいう";

        // dumps text.
        //
        // テキストを出力して、システムの内部のバイト表現(バイトシーケンス)を16進数で出力する.
        //
        text.DumpText();

        // encodings.
        // Unicode
        // Unicode (Big-Endian)
        // Unicode (UTF-8)
        //
        // Unicodeの代表的な符号化形式を扱うオブジェクトのリスト化.
        //
        var unicodeEncodings = new Encoding[] {
            // makes up a list of encodings.
            Encoding.Unicode,
            Encoding.BigEndianUnicode,
            Encoding.UTF8,
        };

        // dumps byte sequence without BOM.
        //
        // Unicodeテキストのバイト表現(バイトシーケンス)を、符号化形式名、コードページとともに、16進数で出力する.
        //
        // バイト数に注目すること.
        // BOMはつかない.
        //
        Console.WriteLine("Dumps byte sequence (Unicode):");
        foreach (var encoding in unicodeEncodings)
        {
            text.DumpEncodedText(encoding);
        }
        Console.WriteLine(string.Empty);

        // dumps byte sequence with BOM if necessary.
        //
        // Unicodeテキストのバイト表現(バイトシーケンス)を、符号化形式名、コードページとともに、16進数で出力する.
        //
        // BOMが先頭に付く.
        // BOMなしとの違いは、BOMのみ.
        //
        Console.WriteLine("Dumps byte sequence with BOM (Unicode):");
        foreach (var encoding in unicodeEncodings)
        {
            text.DumpEncodedTextStream(encoding);
        }
        Console.WriteLine(string.Empty);

        // Japanese (JIS)
        // Japanese (EUC)
        // Japanese (Shift-JIS)
        //
        // ASCII系の日本の代表的な符号化形式を扱うオブジェクトのリスト化.
        //
        var asciiEncodings = new Encoding[] {
            // makes up a list of encodings.
            Encoding.GetEncoding("iso-2022-jp"),
            Encoding.GetEncoding("EUC-JP"),
            Encoding.GetEncoding("shift_jis"),
        };

        // dumps byte sequence without BOM.
        //
        // ASCIIテキストのバイト表現(バイトシーケンス)を、符号化形式名、コードページとともに、16進数で出力する.
        //
        Console.WriteLine("Dumps byte sequence (ASCII):");
        foreach (var encoding in asciiEncodings)
        {
            text.DumpEncodedText(encoding);
        }
        Console.WriteLine(string.Empty);

        // dumps bit sequence of UTF-8.
        //
        // UTF-8のバイト表現(バイトシーケンス)は、少し特徴的なので、バイト数やビットシーケンスを詳しく見てみる.
        //
        Console.WriteLine("Dumps bit sequence (UTF-8):");

        // dumps BOM.
        //
        // BOMの文字コード、エンコードされたバイト表現(バイトシーケンス)に対して16進数表記と2進数表記を表示する.
        //
        // 2進数表記は、ビット演算をするビット幅で区切って、エンコード前後のビットパターンを比較する.
        //
        ((char)0xFEFF).DumpUtf8Character();

        // dumps text.
        //
        // Unicodeテキストを文字に分解して、各文字に対して、文字コード、エンコードされたバイト表現(バイトシーケンス)に対して16進数表記と2進数表記を表示する.
        //
        // 2進数表記は、ビット演算をするビット幅で区切って、エンコード前後のビットパターンを比較する.
        //
        foreach (var character in text)
        {
            character.DumpUtf8Character();
        }
        Console.WriteLine(string.Empty);

        // dumps byte sequence and character code.
        //
        // Unicode文字をASCIIのバイト表現(バイトシーケンス)とJISの文字コードである区点コードに変換する.
        //
        Console.WriteLine("Dumps hex sequence (ASCII):");
        foreach (var character in new char[] { 'α', 'β', 'γ', 'あ', 'い', 'う' })
        {
            character.DumpAsciiCharacter();
        }
    }

    /// <summary>A T extension method that dumps the given value.</summary>
    /// <typeparam name="T">Generic type parameter.</typeparam>
    /// <param name="value">The value to act on.</param>
    /// <remarks>型Tを文字列にして出力する.</remarks>
    public static void Dump<T>(this T value)
    {
        Console.WriteLine(value.ToString());
    }
}

/// <summary>A system string helper.</summary>
public static class SystemStringHelper
{
    /// <summary>A string extension method that dumps a text.</summary>
    /// <param name="value">The value to act on.</param>
    /// <remarks>
    /// テキストを出力して、システムの内部のバイト表現(バイトシーケンス)を16進数で出力する.
    /// </remarks>
    public static void DumpText(this string value)
    {
        Console.WriteLine("Original text:");
        Console.WriteLine(value);
        Console.WriteLine(string.Empty);

        // Windows system endian is little endian.
        byte[] defaultBytes = value.ToUnicodeSystemByteSequence();

        Console.WriteLine("{0, -30}{1}", "Hex Dump of system endian:", defaultBytes.ToHexString());
        Console.WriteLine(string.Empty);
    }

    /// <summary>
    /// A char extension method that converts a value to an unicode system byte sequence.
    /// </summary>
    /// <param name="value">The value to act on.</param>
    /// <returns>value as a byte[].</returns>
    /// <remarks>
    /// Unicode文字をバイト表現(バイトシーケンス)に変換する.
    /// バイトオーダは、システムの内部形式になる.
    /// </remarks>
    public static byte[] ToUnicodeSystemByteSequence(this char value)
    {
        // gets system byte sequence of character.
        return BitConverter.GetBytes(value);
    }

    /// <summary>
    /// A char extension method that converts a value to an unicode system byte sequence.
    /// </summary>
    /// <param name="value">The value to act on.</param>
    /// <returns>value as a byte[].</returns>
    /// <remarks>
    /// Unicode文字列をバイト表現(バイトシーケンス)に変換する.
    /// バイトオーダは、システムの内部形式になる.
    /// </remarks>
    public static byte[] ToUnicodeSystemByteSequence(this string value)
    {
        // gets system byte sequence of string.
        // 
        // 1. converts from string to char[].
        //
        // 2. converts from char[] to IEnumerable<IEnumerable<byte>>,
        // and converts from IEnumerable<IEnumerable<byte>> to IEnumerable<byte>.
        //
        // 3. converts from IEnumerable<byte> to byte[].
        return value.ToCharArray().SelectMany(character => character.ToUnicodeSystemByteSequence()).ToArray();
    }

    /// <summary>
    /// A char extension method that converts a value to an unicode swapped byte sequence.
    /// </summary>
    /// <param name="value">The value to act on.</param>
    /// <returns>value as a byte[].</returns>
    /// <remarks>
    /// Unicode文字をバイト表現(バイトシーケンス)に変換する.
    /// バイトオーダは、システムの内部形式の逆順になる.
    /// </remarks>
    public static byte[] ToUnicodeSwappedByteSequence(this char value)
    {
        // gets system byte sequence of character.
        byte[] bytes = value.ToUnicodeSystemByteSequence();

        // swaps byte sequence.
        Array.Reverse(bytes);
        return bytes;
    }

    /// <summary>
    /// A char extension method that converts a value to an unicode swapped byte sequence.
    /// </summary>
    /// <param name="value">The value to act on.</param>
    /// <returns>value as a byte[].</returns>
    /// <remarks>
    /// Unicode文字列をバイト表現(バイトシーケンス)に変換する.
    /// バイトオーダは、システムの内部形式の逆順になる.
    /// </remarks>
    public static byte[] ToUnicodeSwappedByteSequence(this string value)
    {
        // gets swapped system byte sequence of string.
        // 
        // 1. converts from string to char[].
        //
        // 2. converts from char[] to IEnumerable<IEnumerable<byte>>,
        // and converts from IEnumerable<IEnumerable<byte>> to IEnumerable<byte>.
        //
        // 3. converts from IEnumerable<byte> to byte[].
        return value.ToCharArray().SelectMany(character => character.ToUnicodeSwappedByteSequence()).ToArray();
    }
}

/// <summary>An encoding helper.</summary>
public static class EncodingHelper
{
    /// <summary>A string extension method that dumps an encoded text.</summary>
    /// <param name="value">The value to act on.</param>
    /// <param name="encoding">The encoding.</param>
    /// <remarks>
    /// テキストのバイト表現(バイトシーケンス)を、符号化形式名、コードページとともに、16進数で出力する.
    /// </remarks>
    public static void DumpEncodedText(this string value, Encoding encoding)
    {
        // gets byte sequence without BOM.
        // 
        // 指定した符号化形式のバイト表現(バイトシーケンス)を取得する.
        // 
        byte[] bytes = encoding.GetBytes(value);

        // dumps byte sequence.
        // 
        // テキストのバイト表現(バイトシーケンス)を、符号化形式名、コードページとともに、16進数で出力する.
        // 
        bytes.DumpCharacters(encoding);
    }

    /// <summary>A string extension method that dumps an encoded text stream.</summary>
    /// <param name="value">The value to act on.</param>
    /// <param name="encoding">The encoding.</param>
    /// <remarks>
    /// テキストのバイト表現(バイトシーケンス)を、符号化形式名、コードページとともに、16進数で出力する.
    /// BOMをサポートするStreamWriterを利用して、必要ならBOMを出力する.
    /// </remarks>
    public static void DumpEncodedTextStream(this string value, Encoding encoding)
    {
        // creates stream on memory.
        // 
        // ストリームを作成する.
        // ファイルに保存するならファイルストリームでも良いが、メモリで処理するのでメモリストリームにしておく.
        // 
        using (var stream = new MemoryStream())
        {
            // creates writer for stream.
            // 
            // ストリームライタを作成して、ストリームに文字列のエンコードされたバイト表現(バイトシーケンス)を書き込む.
            // 
            using (var writer = new StreamWriter(stream, encoding))
            {
                // writes byte sequence and appends BOM if necessary.
                writer.Write(value);
            }

            // dumps stream.
            // 
            // ストリームからbyte[]を取得して出力する.
            // 
            stream.ToArray().DumpCharacters(encoding);
        }
    }

    /// <summary>A byte[] extension method that dumps the characters.</summary>
    /// <param name="value">The value to act on.</param>
    /// <param name="encoding">The encoding.</param>
    /// <remarks>
    /// テキストのバイト表現(バイトシーケンス)を、符号化形式名、コードページとともに、16進数で出力する.
    /// </remarks>
    public static void DumpCharacters(this byte[] value, Encoding encoding)
    {
        Console.Write("{0, -20} ({1, 5})  ", encoding.EncodingName, encoding.CodePage);
        Console.Write(value.ToHexString());
        Console.WriteLine(string.Empty);
    }
}

/// <summary>An UTF 8 helper.</summary>
public static class Utf8Helper
{
    /// <summary>A char extension method that dumps an UTF 8 character.</summary>
    /// <param name="value">The value to act on.</param>
    /// <remarks>
    /// Unicode文字の文字コード、UTF-8エンコードされたバイト表現(バイトシーケンス)に対して16進数表記と2進数表記を表示する.
    /// </remarks>
    public static void DumpUtf8Character(this char value)
    {
        // gets display character name.
        // 
        // 表示されない文字に名前を割り当てる.
        // 
        string character = (value == 0xFEFF) ? "BOM" :
                           (value == 0x000D) ? "CR" :
                           (value == 0x000A) ? "LF" :
                            value.ToString();

        // gets Unicode character code.
        // 
        // 2バイトのUnicodeの文字コードを取得する.
        // 
        ushort code = Convert.ToUInt16(value);

        // gets swapped byte sequence for display.
        // 
        // 文字(文字コード)のバイト表現(バイトシーケンス)を読みやすいようにひっくり返し、出力用に16進数文字列に変換する.
        // 
        byte[] swappedBytes = value.ToUnicodeSwappedByteSequence();
        string swappedBytesHex = swappedBytes.ToHexString();

        // gets split bit sequence before mask.
        // 
        // 文字コードのビット表現(ビットシーケンス)を取得して、UTF-8のエンコードの仕様に従い、区切り文字を挿入する.
        // 
        string splitBitSequence = string.Empty;
        if (code < 0x80)
        {
            // From U+0000 to U+007F
            // 
            // LSBから7ビットの部分に区切り文字を挿入する.
            // 
            splitBitSequence = code.ToBinaryString().SetSeparator("-", new int[] { 7 });
        }
        else if (code < 0x800)
        {
            // From U+0080 to U+07FF
            // 
            // LSBから順に、6ビット、11ビットの部分に区切り文字を挿入する.
            // 
            splitBitSequence = code.ToBinaryString().SetSeparator("-", new int[] { 6, 11 });
        }
        else if (code < 0xD800 || 0xDFFF < code)
        {
            // From U+0800 to U+D7FF
            // From U+E000 to U+FFFF
            // 
            // LSBから順に、6ビット、12ビットの部分に区切り文字を挿入する.
            // 
            splitBitSequence = code.ToBinaryString().SetSeparator("-", new int[] { 6, 12 });
        }
        else
        {
            // From U+D800 to U+DFFF
            // 
            // サロゲートペアは今回は扱わない.
            // 
            splitBitSequence = "not supported over U+FFFF characters...";
        }

        // gets UTF-8 byte sequence.
        // 
        // UTF-8エンコードのバイト表現(バイトシーケンス)を取得して、出力用に16進数文字列に変換する.
        // 
        byte[] utf8Bytes = Encoding.UTF8.GetBytes(value.ToString());
        string utf8BytesHex = utf8Bytes.ToHexString();

        // gets split bit sequence after mask.
        // 
        // UTF-8エンコードのビット表現(ビットシーケンス)を取得して、UTF-8のエンコードの仕様に従い、区切り文字を挿入する.
        // 
        string utf8SplitBitSequence = string.Empty;
        if (utf8Bytes.Length == 1)
        {
            // From U+0000 to U+007F
            // 
            // LSBから7ビットの部分に区切り文字を挿入する.
            // 
            utf8SplitBitSequence = utf8Bytes[0].ToBinaryString().SetSeparator("-", new int[] { 7 });
        }
        else if (utf8Bytes.Length == 2)
        {
            // From U+0080 to U+07FF
            // 
            // LSBから、5ビットの部分に区切り文字を挿入する.
            // 
            utf8SplitBitSequence = utf8Bytes[0].ToBinaryString().SetSeparator("-", new int[] { 5 });
            // 
            // LSBから、6ビットの部分に区切り文字を挿入する.
            // 
            utf8SplitBitSequence += " " + utf8Bytes[1].ToBinaryString().SetSeparator("-", new int[] { 6 });
        }
        else if (utf8Bytes.Length == 3)
        {
            // From U+0800 to U+D7FF
            // From U+E000 to U+FFFF
            // 
            // (3-3)は、以下のコメントを解除して、修正してから実行して確かめること.
            //utf8Bytes[0] = unchecked((byte)(([3-3-1])code >> [3-3-2] | [3-3-4]));
            //utf8Bytes[1] = unchecked((byte)(([3-3-1])code >> [3-3-3] & 0x003F | [3-3-5]));
            //utf8Bytes[2] = unchecked((byte)(([3-3-1])code & 0x003F | [3-3-5]));
            // 
            // LSBから、4ビットの部分に区切り文字を挿入する.
            // 
            utf8SplitBitSequence = utf8Bytes[0].ToBinaryString().SetSeparator("-", new int[] { 4 });
            // 
            // LSBから、6ビットの部分に区切り文字を挿入する.
            // 
            utf8SplitBitSequence += " " + utf8Bytes[1].ToBinaryString().SetSeparator("-", new int[] { 6 });
            // 
            // LSBから、6ビットの部分に区切り文字を挿入する.
            // 
            utf8SplitBitSequence += " " + utf8Bytes[2].ToBinaryString().SetSeparator("-", new int[] { 6 });
        }
        else
        {
            // From U+D800 to U+DFFF
            // 
            // サロゲートペアは今回は扱わない.
            // 
            splitBitSequence = "not supported over U+FFFF characters...";
        }

        Console.Write("'{0}'  Unicode: {1} (16) = {2} (2), UTF-8:  {3} (16) = {4} (2)", character, swappedBytesHex, splitBitSequence, utf8BytesHex, utf8SplitBitSequence);
        Console.WriteLine(string.Empty);
    }
}

/// <summary>An ASCII helper.</summary>
public static class AsciiHelper
{
    /// <summary>A char extension method that dumps an ASCII character.</summary>
    /// <param name="value">The value to act on.</param>
    /// <remarks>
    /// Unicode文字をASCIIのバイト表現(バイトシーケンス)とJISの文字コードである区点コードに変換する.
    /// </remarks>
    public static void DumpAsciiCharacter(this char value)
    {
        var character = value.ToString();

        // Japanese (JIS)
        // Japanese (EUC)
        // Japanese (Shift-JIS)
        //
        // ASCII系の日本の代表的な符号化形式を扱うオブジェクトのリスト化.
        //
        var asciiEncodings = new Encoding[] {
            // makes up a list of encodings.
            Encoding.GetEncoding("iso-2022-jp"),
            Encoding.GetEncoding("EUC-JP"),
            Encoding.GetEncoding("shift_jis"),
        };

        // gets byte sequence of JIS.
        // 
        // JISエンコードのバイト表現(バイトシーケンス)を取得する.
        // 
        byte[] jisBytes = asciiEncodings[0].GetBytes(character);

        // skips escape byte sequence.
        // 
        // JISエンコードのバイト表現(バイトシーケンス)からエスケープシーケンスを取り除く.
        // 
        var jisRawBytes = jisBytes.SkipWhile(x => x != 0x1B).Skip(3).TakeWhile(x => x != 0x1B);

        // gets hex string.
        // 
        // JISエンコードのバイト表現(バイトシーケンス)からエスケープシーケンスを取り除いたものを出力用に16進数文字列に変換する.
        // 
        var jisHexString = jisRawBytes.ToArray().ToHexString();

        // gets jis code (word-point number) string.
        // 
        // JISエンコードのバイト表現(バイトシーケンス)からエスケープシーケンスを取り除いたものを区点コードに変換する.
        // 
        var jisCodeString = jisRawBytes.Select(x => unchecked((byte)(x - 0x20))).ToArray().ToWordPointNumberString();


        // gets byte sequence of EUC-JP.
        // 
        // EUC-JPエンコードのバイト表現(バイトシーケンス)を取得する.
        // 
        byte[] eucJpBytes = asciiEncodings[1].GetBytes(character);

        // gets hex string.
        // 
        // EUC-JPエンコードのバイト表現(バイトシーケンス)を出力用に16進数文字列に変換する.
        // 
        var eucJpHexString = eucJpBytes.ToArray().ToHexString();

        // gets jis code (word-point number) string.
        // 
        // EUC-JPエンコードのバイト表現(バイトシーケンス)を区点コードに変換する.
        // 
        var eucJpCodeString = eucJpBytes.Select(x => unchecked((byte)(x - 0xA0))).ToArray().ToWordPointNumberString();


        // gets byte sequence of Shift-JIS.
        // 
        // Shift JISエンコードのバイト表現(バイトシーケンス)を取得する.
        // 
        byte[] shiftJisBytes = asciiEncodings[2].GetBytes(character);

        // gets hex string.
        // 
        // Shift JISエンコードのバイト表現(バイトシーケンス)を出力用に16進数文字列に変換する.
        // 
        var shiftJisHexString = shiftJisBytes.ToArray().ToHexString();

        // decodes byte sequence.
        // 
        // Shift JISエンコードのバイト表現(バイトシーケンス)を区点コードに変換する.
        // 
        byte wordNumber = 0;
        byte upper = 0;
        if (0x80 < shiftJisBytes[0] && shiftJisBytes[0] < 0xA0)
        {
            upper = unchecked((byte)(shiftJisBytes[0] - 0x80));
        }
        else if (0xDF < shiftJisBytes[0] && shiftJisBytes[0] < 0xF0)
        {
            upper = unchecked((byte)(shiftJisBytes[0] - 0xDF + 0x1F));
        }

        byte pointNumber = 0;
        if (0x3F < shiftJisBytes[1] && shiftJisBytes[1] < 0x7F)
        {
            wordNumber = unchecked((byte)((upper - 1) * 2 + 1));
            pointNumber = unchecked((byte)(shiftJisBytes[1] - 0x3F));
        }
        else if (0x7F < shiftJisBytes[1] && shiftJisBytes[1] < 0x9F)
        {
            wordNumber = unchecked((byte)((upper - 1) * 2 + 1));
            pointNumber = unchecked((byte)(shiftJisBytes[1] - 0x7F + 0x3F));
        }
        else if (0x9E < shiftJisBytes[1] && shiftJisBytes[1] < 0xFD)
        {
            wordNumber = unchecked((byte)((upper - 1) * 2 + 2));
            pointNumber = unchecked((byte)(shiftJisBytes[1] - 0x9E));
        }

        // gets jis code (word-point number) string.
        var shiftJisCodeString = new byte[] { wordNumber, pointNumber }.ToWordPointNumberString();


        Console.Write("'{0}'  JIS: {1} ({2}), EUC-JP: {3} ({4}), Shift JIS: {5} ({6})", character, jisHexString, jisCodeString, eucJpHexString, eucJpCodeString, shiftJisHexString, shiftJisCodeString);
        Console.WriteLine(string.Empty);
    }

    /// <summary>
    /// A byte[] extension method that converts a value to a word point number string.
    /// </summary>
    /// <param name="value">The value to act on.</param>
    /// <returns>value as a string.</returns>
    public static string ToWordPointNumberString(this byte[] value)
    {
        return string.Format("{0}-{1}", value[0], value[1]);
    }
}

/// <summary>A hexadecimal string helper.</summary>
public static class HexStringHelper
{
    /// <summary>
    /// A byte[] extension method that converts a value to a hexadecimal string.
    /// </summary>
    /// <param name="value">The value to act on.</param>
    /// <returns>value as a string.</returns>
    public static string ToHexString(this byte[] value)
    {
        return BitConverter.ToString(value);
    }
}

/// <summary>A binary string helper.</summary>
public static class BinaryStringHelper
{
    /// <summary>A byte extension method that converts a value to a binary string.</summary>
    /// <param name="value">The value to act on.</param>
    /// <returns>value as a string.</returns>
    public static string ToBinaryString(this byte value)
    {
        return Convert.ToString(value, 2).SetPadding(8);
    }

    /// <summary>A byte extension method that converts a value to a binary string.</summary>
    /// <param name="value">The value to act on.</param>
    /// <param name="digits">The digits.</param>
    /// <returns>value as a string.</returns>
    public static string ToBinaryString(this byte value, int digits)
    {
        return Convert.ToString(value, 2).SetPadding(digits);
    }

    /// <summary>A byte extension method that converts a value to a binary string.</summary>
    /// <param name="value">The value to act on.</param>
    /// <returns>value as a string.</returns>
    public static string ToBinaryString(this sbyte value)
    {
        return unchecked(((sbyte)value).ToBinaryString(8));
    }

    /// <summary>A byte extension method that converts a value to a binary string.</summary>
    /// <param name="value">The value to act on.</param>
    /// <param name="digits">The digits.</param>
    /// <returns>value as a string.</returns>
    public static string ToBinaryString(this sbyte value, int digits)
    {
        return unchecked(((sbyte)value).ToBinaryString(digits));
    }

    /// <summary>A byte extension method that converts a value to a binary string.</summary>
    /// <param name="value">The value to act on.</param>
    /// <returns>value as a string.</returns>
    public static string ToBinaryString(this ushort value)
    {
        return unchecked(((short)value).ToBinaryString(16));
    }

    /// <summary>A byte extension method that converts a value to a binary string.</summary>
    /// <param name="value">The value to act on.</param>
    /// <param name="digits">The digits.</param>
    /// <returns>value as a string.</returns>
    public static string ToBinaryString(this ushort value, int digits)
    {
        return unchecked(((short)value).ToBinaryString(digits));
    }

    /// <summary>A byte extension method that converts a value to a binary string.</summary>
    /// <param name="value">The value to act on.</param>
    /// <returns>value as a string.</returns>
    public static string ToBinaryString(this short value)
    {
        return Convert.ToString(value, 2).SetPadding(16);
    }

    /// <summary>A byte extension method that converts a value to a binary string.</summary>
    /// <param name="value">The value to act on.</param>
    /// <param name="digits">The digits.</param>
    /// <returns>value as a string.</returns>
    public static string ToBinaryString(this short value, int digits)
    {
        return Convert.ToString(value, 2).SetPadding(digits);
    }

    /// <summary>A string extension method that sets a padding.</summary>
    /// <param name="binaryString">The binaryString to act on.</param>
    /// <param name="digits">The digits.</param>
    /// <returns>A string.</returns>
    public static string SetPadding(this string binaryString, int digits)
    {
        // adds lost digits.
        // 
        // Convert.ToString()では、上位の連続する0が省略されるので補う.
        // 
        int length = binaryString.Length;
        if (digits > length) return binaryString.Insert(0, new string('0', digits - length));

        return binaryString;
    }

    /// <summary>A string extension method that sets a separator.</summary>
    /// <param name="binaryString">The binaryString to act on.</param>
    /// <param name="separator">The separator.</param>
    /// <param name="digitsList">List of digits.</param>
    /// <returns>A string.</returns>
    public static string SetSeparator(this string binaryString, string separator, int[] digitsList)
    {
        // adds lost digits.
        var result = binaryString;
        int length = result.Length;

        if (digitsList.Length > 0)
        {
            // digitsList: from lsb to msb
            // 
            // 右(LSB)側から数えた位置がリストに入っていると仮定している.
            // 
            foreach (var digits in digitsList)
            {
                // 
                // 右(LSB)側から数えた位置を左(MSB)側から数えた位置に変換して、挿入場所を決める.
                // 右(LSB)側から数えた位置は、小さい順にリストに入っていると仮定している.
                // 
                var position = length - digits;
                if (position > 0) result = result.Insert(position, separator);
            }
        }

        return result;
    }
}

​x
 
using System;
using System.IO;
using System.Linq;
using System.Text;
​
/// <summary>A program.</summary>
/// <remarks>
/// 以下のプログラムでは、C#3.0で追加された拡張メソッドを定義して呼び出している.
/// 
/// 拡張メソッドについての詳細は以下を参照のこと.
/// https://msdn.microsoft.com/ja-jp/library/bb383977.aspx
/// 
/// </remarks>
public static class Program
{
    /// <summary>Main entry-point for this application.</summary>
    public static void Main()
    {
        // 半角英数字/ギリシャ文字(日本では全角)/ひらがなが、各文字集合/符号化形式でどのように扱われているかを調べる.
        string text = "012" + Environment.NewLine + "abc" + Environment.NewLine + "αβγ" + Environment.NewLine + "あいう";
​
        // dumps text.
        //
        // テキストを出力して、システムの内部のバイト表現(バイトシーケンス)を16進数で出力する.
        //
        text.DumpText();
​
        // encodings.
        // Unicode
        // Unicode (Big-Endian)
        // Unicode (UTF-8)
        //
        // Unicodeの代表的な符号化形式を扱うオブジェクトのリスト化.
        //
        var unicodeEncodings = new Encoding[] {
            // makes up a list of encodings.
            Encoding.Unicode,
            Encoding.BigEndianUnicode,
            Encoding.UTF8,
        };
​
        // dumps byte sequence without BOM.
        //
        // Unicodeテキストのバイト表現(バイトシーケンス)を、符号化形式名、コードページとともに、16進数で出力する.
        //
        // バイト数に注目すること.
        // BOMはつかない.
        //
        Console.WriteLine("Dumps byte sequence (Unicode):");
        foreach (var encoding in unicodeEncodings)
        {
            text.DumpEncodedText(encoding);
        }
        Console.WriteLine(string.Empty);
​
        // dumps byte sequence with BOM if necessary.
        //
        // Unicodeテキストのバイト表現(バイトシーケンス)を、符号化形式名、コードページとともに、16進数で出力する.
        //
        // BOMが先頭に付く.
        // BOMなしとの違いは、BOMのみ.
        //
        Console.WriteLine("Dumps byte sequence with BOM (Unicode):");
        foreach (var encoding in unicodeEncodings)
        {
            text.DumpEncodedTextStream(encoding);
        }
        Console.WriteLine(string.Empty);
​
        // Japanese (JIS)
        // Japanese (EUC)
        // Japanese (Shift-JIS)
        //
        // ASCII系の日本の代表的な符号化形式を扱うオブジェクトのリスト化.
        //
        var asciiEncodings = new Encoding[] {
            // makes up a list of encodings.
            Encoding.GetEncoding("iso-2022-jp"),
            Encoding.GetEncoding("EUC-JP"),
            Encoding.GetEncoding("shift_jis"),
        };
​
        // dumps byte sequence without BOM.
        //
        // ASCIIテキストのバイト表現(バイトシーケンス)を、符号化形式名、コードページとともに、16進数で出力する.
        //
        Console.WriteLine("Dumps byte sequence (ASCII):");
        foreach (var encoding in asciiEncodings)
        {
            text.DumpEncodedText(encoding);
        }
        Console.WriteLine(string.Empty);
​
        // dumps bit sequence of UTF-8.
        //
        // UTF-8のバイト表現(バイトシーケンス)は、少し特徴的なので、バイト数やビットシーケンスを詳しく見てみる.
        //
        Console.WriteLine("Dumps bit sequence (UTF-8):");
​
        // dumps BOM.
        //
        // BOMの文字コード、エンコードされたバイト表現(バイトシーケンス)に対して16進数表記と2進数表記を表示する.
        //
        // 2進数表記は、ビット演算をするビット幅で区切って、エンコード前後のビットパターンを比較する.
        //
        ((char)0xFEFF).DumpUtf8Character();
​
        // dumps text.
        //
        // Unicodeテキストを文字に分解して、各文字に対して、文字コード、エンコードされたバイト表現(バイトシーケンス)に対して16進数表記と2進数表記を表示する.
        //
        // 2進数表記は、ビット演算をするビット幅で区切って、エンコード前後のビットパターンを比較する.
        //
        foreach (var character in text)
        {
            character.DumpUtf8Character();
        }
        Console.WriteLine(string.Empty);
​
        // dumps byte sequence and character code.
        //
        // Unicode文字をASCIIのバイト表現(バイトシーケンス)とJISの文字コードである区点コードに変換する.
        //
        Console.WriteLine("Dumps hex sequence (ASCII):");
        foreach (var character in new char[] { 'α', 'β', 'γ', 'あ', 'い', 'う' })
        {
            character.DumpAsciiCharacter();
        }
    }
​
    /// <summary>A T extension method that dumps the given value.</summary>
    /// <typeparam name="T">Generic type parameter.</typeparam>
    /// <param name="value">The value to act on.</param>
    /// <remarks>型Tを文字列にして出力する.</remarks>
    public static void Dump<T>(this T value)
    {
        Console.WriteLine(value.ToString());
    }
}
​
/// <summary>A system string helper.</summary>
public static class SystemStringHelper
{
    /// <summary>A string extension method that dumps a text.</summary>
    /// <param name="value">The value to act on.</param>
    /// <remarks>
    /// テキストを出力して、システムの内部のバイト表現(バイトシーケンス)を16進数で出力する.
    /// </remarks>
    public static void DumpText(this string value)
    {
        Console.WriteLine("Original text:");
        Console.WriteLine(value);
        Console.WriteLine(string.Empty);
​
        // Windows system endian is little endian.
        byte[] defaultBytes = value.ToUnicodeSystemByteSequence();
​
        Console.WriteLine("{0, -30}{1}", "Hex Dump of system endian:", defaultBytes.ToHexString());
        Console.WriteLine(string.Empty);
    }
​
    /// <summary>
    /// A char extension method that converts a value to an unicode system byte sequence.
    /// </summary>
    /// <param name="value">The value to act on.</param>
    /// <returns>value as a byte[].</returns>
    /// <remarks>
    /// Unicode文字をバイト表現(バイトシーケンス)に変換する.
    /// バイトオーダは、システムの内部形式になる.
    /// </remarks>
    public static byte[] ToUnicodeSystemByteSequence(this char value)
    {
        // gets system byte sequence of character.
        return BitConverter.GetBytes(value);
    }
​
    /// <summary>
    /// A char extension method that converts a value to an unicode system byte sequence.
    /// </summary>
    /// <param name="value">The value to act on.</param>
    /// <returns>value as a byte[].</returns>
    /// <remarks>
    /// Unicode文字列をバイト表現(バイトシーケンス)に変換する.
    /// バイトオーダは、システムの内部形式になる.
    /// </remarks>
    public static byte[] ToUnicodeSystemByteSequence(this string value)
    {
        // gets system byte sequence of string.
        // 
        // 1. converts from string to char[].
        //
        // 2. converts from char[] to IEnumerable<IEnumerable<byte>>,
        // and converts from IEnumerable<IEnumerable<byte>> to IEnumerable<byte>.
        //
        // 3. converts from IEnumerable<byte> to byte[].
        return value.ToCharArray().SelectMany(character => character.ToUnicodeSystemByteSequence()).ToArray();
    }
​
    /// <summary>
    /// A char extension method that converts a value to an unicode swapped byte sequence.
    /// </summary>
    /// <param name="value">The value to act on.</param>
    /// <returns>value as a byte[].</returns>
    /// <remarks>
    /// Unicode文字をバイト表現(バイトシーケンス)に変換する.
    /// バイトオーダは、システムの内部形式の逆順になる.
    /// </remarks>
    public static byte[] ToUnicodeSwappedByteSequence(this char value)
    {
        // gets system byte sequence of character.
        byte[] bytes = value.ToUnicodeSystemByteSequence();
​
        // swaps byte sequence.
        Array.Reverse(bytes);
        return bytes;
    }
​
    /// <summary>
    /// A char extension method that converts a value to an unicode swapped byte sequence.
    /// </summary>
    /// <param name="value">The value to act on.</param>
    /// <returns>value as a byte[].</returns>
    /// <remarks>
    /// Unicode文字列をバイト表現(バイトシーケンス)に変換する.
    /// バイトオーダは、システムの内部形式の逆順になる.
    /// </remarks>
    public static byte[] ToUnicodeSwappedByteSequence(this string value)
    {
        // gets swapped system byte sequence of string.
        // 
        // 1. converts from string to char[].
        //
        // 2. converts from char[] to IEnumerable<IEnumerable<byte>>,
        // and converts from IEnumerable<IEnumerable<byte>> to IEnumerable<byte>.
        //
        // 3. converts from IEnumerable<byte> to byte[].
        return value.ToCharArray().SelectMany(character => character.ToUnicodeSwappedByteSequence()).ToArray();
    }
}
​
/// <summary>An encoding helper.</summary>
public static class EncodingHelper
{
    /// <summary>A string extension method that dumps an encoded text.</summary>
    /// <param name="value">The value to act on.</param>
    /// <param name="encoding">The encoding.</param>
    /// <remarks>
    /// テキストのバイト表現(バイトシーケンス)を、符号化形式名、コードページとともに、16進数で出力する.
    /// </remarks>
    public static void DumpEncodedText(this string value, Encoding encoding)
    {
        // gets byte sequence without BOM.
        // 
        // 指定した符号化形式のバイト表現(バイトシーケンス)を取得する.
        // 
        byte[] bytes = encoding.GetBytes(value);
​
        // dumps byte sequence.
        // 
        // テキストのバイト表現(バイトシーケンス)を、符号化形式名、コードページとともに、16進数で出力する.
        // 
        bytes.DumpCharacters(encoding);
    }
​
    /// <summary>A string extension method that dumps an encoded text stream.</summary>
    /// <param name="value">The value to act on.</param>
    /// <param name="encoding">The encoding.</param>
    /// <remarks>
    /// テキストのバイト表現(バイトシーケンス)を、符号化形式名、コードページとともに、16進数で出力する.
    /// BOMをサポートするStreamWriterを利用して、必要ならBOMを出力する.
    /// </remarks>
    public static void DumpEncodedTextStream(this string value, Encoding encoding)
    {
        // creates stream on memory.
        // 
        // ストリームを作成する.
        // ファイルに保存するならファイルストリームでも良いが、メモリで処理するのでメモリストリームにしておく.
        // 
        using (var stream = new MemoryStream())
        {
            // creates writer for stream.
            // 
            // ストリームライタを作成して、ストリームに文字列のエンコードされたバイト表現(バイトシーケンス)を書き込む.
            // 
            using (var writer = new StreamWriter(stream, encoding))
            {
                // writes byte sequence and appends BOM if necessary.
                writer.Write(value);
            }
​
            // dumps stream.
            // 
            // ストリームからbyte[]を取得して出力する.
            // 
            stream.ToArray().DumpCharacters(encoding);
        }
    }
​
    /// <summary>A byte[] extension method that dumps the characters.</summary>
    /// <param name="value">The value to act on.</param>
    /// <param name="encoding">The encoding.</param>
    /// <remarks>
    /// テキストのバイト表現(バイトシーケンス)を、符号化形式名、コードページとともに、16進数で出力する.
    /// </remarks>
    public static void DumpCharacters(this byte[] value, Encoding encoding)
    {
        Console.Write("{0, -20} ({1, 5})  ", encoding.EncodingName, encoding.CodePage);
        Console.Write(value.ToHexString());
        Console.WriteLine(string.Empty);
    }
}
​
/// <summary>An UTF 8 helper.</summary>
public static class Utf8Helper
{
    /// <summary>A char extension method that dumps an UTF 8 character.</summary>
    /// <param name="value">The value to act on.</param>
    /// <remarks>
    /// Unicode文字の文字コード、UTF-8エンコードされたバイト表現(バイトシーケンス)に対して16進数表記と2進数表記を表示する.
    /// </remarks>
    public static void DumpUtf8Character(this char value)
    {
        // gets display character name.
        // 
        // 表示されない文字に名前を割り当てる.
        // 
        string character = (value == 0xFEFF) ? "BOM" :
                           (value == 0x000D) ? "CR" :
                           (value == 0x000A) ? "LF" :
                            value.ToString();
​
        // gets Unicode character code.
        // 
        // 2バイトのUnicodeの文字コードを取得する.
        // 
        ushort code = Convert.ToUInt16(value);
​
        // gets swapped byte sequence for display.
        // 
        // 文字(文字コード)のバイト表現(バイトシーケンス)を読みやすいようにひっくり返し、出力用に16進数文字列に変換する.
        // 
        byte[] swappedBytes = value.ToUnicodeSwappedByteSequence();
        string swappedBytesHex = swappedBytes.ToHexString();
​
        // gets split bit sequence before mask.
        // 
        // 文字コードのビット表現(ビットシーケンス)を取得して、UTF-8のエンコードの仕様に従い、区切り文字を挿入する.
        // 
        string splitBitSequence = string.Empty;
        if (code < 0x80)
        {
            // From U+0000 to U+007F
            // 
            // LSBから7ビットの部分に区切り文字を挿入する.
            // 
            splitBitSequence = code.ToBinaryString().SetSeparator("-", new int[] { 7 });
        }
        else if (code < 0x800)
        {
            // From U+0080 to U+07FF
            // 
            // LSBから順に、6ビット、11ビットの部分に区切り文字を挿入する.
            // 
            splitBitSequence = code.ToBinaryString().SetSeparator("-", new int[] { 6, 11 });
        }
        else if (code < 0xD800 || 0xDFFF < code)
        {
            // From U+0800 to U+D7FF
            // From U+E000 to U+FFFF
            // 
            // LSBから順に、6ビット、12ビットの部分に区切り文字を挿入する.
            // 
            splitBitSequence = code.ToBinaryString().SetSeparator("-", new int[] { 6, 12 });
        }
        else
        {
            // From U+D800 to U+DFFF
            // 
            // サロゲートペアは今回は扱わない.
            // 
            splitBitSequence = "not supported over U+FFFF characters...";
        }
​
        // gets UTF-8 byte sequence.
        // 
        // UTF-8エンコードのバイト表現(バイトシーケンス)を取得して、出力用に16進数文字列に変換する.
        // 
        byte[] utf8Bytes = Encoding.UTF8.GetBytes(value.ToString());
        string utf8BytesHex = utf8Bytes.ToHexString();
​
        // gets split bit sequence after mask.
        // 
        // UTF-8エンコードのビット表現(ビットシーケンス)を取得して、UTF-8のエンコードの仕様に従い、区切り文字を挿入する.
        // 
        string utf8SplitBitSequence = string.Empty;
        if (utf8Bytes.Length == 1)
        {
            // From U+0000 to U+007F
            // 
            // LSBから7ビットの部分に区切り文字を挿入する.
            // 
            utf8SplitBitSequence = utf8Bytes[0].ToBinaryString().SetSeparator("-", new int[] { 7 });
        }
        else if (utf8Bytes.Length == 2)
        {
            // From U+0080 to U+07FF
            // 
            // LSBから、5ビットの部分に区切り文字を挿入する.
            // 
            utf8SplitBitSequence = utf8Bytes[0].ToBinaryString().SetSeparator("-", new int[] { 5 });
            // 
            // LSBから、6ビットの部分に区切り文字を挿入する.
            // 
            utf8SplitBitSequence += " " + utf8Bytes[1].ToBinaryString().SetSeparator("-", new int[] { 6 });
        }
        else if (utf8Bytes.Length == 3)
        {
            // From U+0800 to U+D7FF
            // From U+E000 to U+FFFF
            // 
            // (3-3)は、以下のコメントを解除して、修正してから実行して確かめること.
            //utf8Bytes[0] = unchecked((byte)(([3-3-1])code >> [3-3-2] | [3-3-4]));
            //utf8Bytes[1] = unchecked((byte)(([3-3-1])code >> [3-3-3] & 0x003F | [3-3-5]));
            //utf8Bytes[2] = unchecked((byte)(([3-3-1])code & 0x003F | [3-3-5]));
            // 
            // LSBから、4ビットの部分に区切り文字を挿入する.
            // 
            utf8SplitBitSequence = utf8Bytes[0].ToBinaryString().SetSeparator("-", new int[] { 4 });
            // 
            // LSBから、6ビットの部分に区切り文字を挿入する.
            // 
            utf8SplitBitSequence += " " + utf8Bytes[1].ToBinaryString().SetSeparator("-", new int[] { 6 });
            // 
            // LSBから、6ビットの部分に区切り文字を挿入する.
            // 
            utf8SplitBitSequence += " " + utf8Bytes[2].ToBinaryString().SetSeparator("-", new int[] { 6 });
        }
        else
        {
            // From U+D800 to U+DFFF
            // 
            // サロゲートペアは今回は扱わない.
            // 
            splitBitSequence = "not supported over U+FFFF characters...";
        }
​
        Console.Write("'{0}'  Unicode: {1} (16) = {2} (2), UTF-8:  {3} (16) = {4} (2)", character, swappedBytesHex, splitBitSequence, utf8BytesHex, utf8SplitBitSequence);
        Console.WriteLine(string.Empty);
    }
}
​
/// <summary>An ASCII helper.</summary>
public static class AsciiHelper
{
    /// <summary>A char extension method that dumps an ASCII character.</summary>
    /// <param name="value">The value to act on.</param>
    /// <remarks>
    /// Unicode文字をASCIIのバイト表現(バイトシーケンス)とJISの文字コードである区点コードに変換する.
    /// </remarks>
    public static void DumpAsciiCharacter(this char value)
    {
        var character = value.ToString();
​
        // Japanese (JIS)
        // Japanese (EUC)
        // Japanese (Shift-JIS)
        //
        // ASCII系の日本の代表的な符号化形式を扱うオブジェクトのリスト化.
        //
        var asciiEncodings = new Encoding[] {
            // makes up a list of encodings.
            Encoding.GetEncoding("iso-2022-jp"),
            Encoding.GetEncoding("EUC-JP"),
            Encoding.GetEncoding("shift_jis"),
        };
​
        // gets byte sequence of JIS.
        // 
        // JISエンコードのバイト表現(バイトシーケンス)を取得する.
        // 
        byte[] jisBytes = asciiEncodings[0].GetBytes(character);
​
        // skips escape byte sequence.
        // 
        // JISエンコードのバイト表現(バイトシーケンス)からエスケープシーケンスを取り除く.
        // 
        var jisRawBytes = jisBytes.SkipWhile(x => x != 0x1B).Skip(3).TakeWhile(x => x != 0x1B);
​
        // gets hex string.
        // 
        // JISエンコードのバイト表現(バイトシーケンス)からエスケープシーケンスを取り除いたものを出力用に16進数文字列に変換する.
        // 
        var jisHexString = jisRawBytes.ToArray().ToHexString();
​
        // gets jis code (word-point number) string.
        // 
        // JISエンコードのバイト表現(バイトシーケンス)からエスケープシーケンスを取り除いたものを区点コードに変換する.
        // 
        var jisCodeString = jisRawBytes.Select(x => unchecked((byte)(x - 0x20))).ToArray().ToWordPointNumberString();
​
​
        // gets byte sequence of EUC-JP.
        // 
        // EUC-JPエンコードのバイト表現(バイトシーケンス)を取得する.
        // 
        byte[] eucJpBytes = asciiEncodings[1].GetBytes(character);
​
        // gets hex string.
        // 
        // EUC-JPエンコードのバイト表現(バイトシーケンス)を出力用に16進数文字列に変換する.
        // 
        var eucJpHexString = eucJpBytes.ToArray().ToHexString();
​
        // gets jis code (word-point number) string.
        // 
        // EUC-JPエンコードのバイト表現(バイトシーケンス)を区点コードに変換する.
        // 
        var eucJpCodeString = eucJpBytes.Select(x => unchecked((byte)(x - 0xA0))).ToArray().ToWordPointNumberString();
​
​
        // gets byte sequence of Shift-JIS.
        // 
        // Shift JISエンコードのバイト表現(バイトシーケンス)を取得する.
        // 
        byte[] shiftJisBytes = asciiEncodings[2].GetBytes(character);
​
        // gets hex string.
        // 
        // Shift JISエンコードのバイト表現(バイトシーケンス)を出力用に16進数文字列に変換する.
        // 
        var shiftJisHexString = shiftJisBytes.ToArray().ToHexString();
​
        // decodes byte sequence.
        // 
        // Shift JISエンコードのバイト表現(バイトシーケンス)を区点コードに変換する.
        // 
        byte wordNumber = 0;
        byte upper = 0;
        if (0x80 < shiftJisBytes[0] && shiftJisBytes[0] < 0xA0)
        {
            upper = unchecked((byte)(shiftJisBytes[0] - 0x80));
        }
        else if (0xDF < shiftJisBytes[0] && shiftJisBytes[0] < 0xF0)
        {
            upper = unchecked((byte)(shiftJisBytes[0] - 0xDF + 0x1F));
        }
​
        byte pointNumber = 0;
        if (0x3F < shiftJisBytes[1] && shiftJisBytes[1] < 0x7F)
        {
            wordNumber = unchecked((byte)((upper - 1) * 2 + 1));
            pointNumber = unchecked((byte)(shiftJisBytes[1] - 0x3F));
        }
        else if (0x7F < shiftJisBytes[1] && shiftJisBytes[1] < 0x9F)
        {
            wordNumber = unchecked((byte)((upper - 1) * 2 + 1));
            pointNumber = unchecked((byte)(shiftJisBytes[1] - 0x7F + 0x3F));
        }
        else if (0x9E < shiftJisBytes[1] && shiftJisBytes[1] < 0xFD)
        {
            wordNumber = unchecked((byte)((upper - 1) * 2 + 2));
            pointNumber = unchecked((byte)(shiftJisBytes[1] - 0x9E));
        }
​
        // gets jis code (word-point number) string.
        var shiftJisCodeString = new byte[] { wordNumber, pointNumber }.ToWordPointNumberString();
​
​
        Console.Write("'{0}'  JIS: {1} ({2}), EUC-JP: {3} ({4}), Shift JIS: {5} ({6})", character, jisHexString, jisCodeString, eucJpHexString, eucJpCodeString, shiftJisHexString, shiftJisCodeString);
        Console.WriteLine(string.Empty);
    }
​
    /// <summary>
    /// A byte[] extension method that converts a value to a word point number string.
    /// </summary>
    /// <param name="value">The value to act on.</param>
    /// <returns>value as a string.</returns>
    public static string ToWordPointNumberString(this byte[] value)
    {
        return string.Format("{0}-{1}", value[0], value[1]);
    }
}
​
/// <summary>A hexadecimal string helper.</summary>
public static class HexStringHelper
{
    /// <summary>
    /// A byte[] extension method that converts a value to a hexadecimal string.
    /// </summary>
    /// <param name="value">The value to act on.</param>
    /// <returns>value as a string.</returns>
    public static string ToHexString(this byte[] value)
    {
        return BitConverter.ToString(value);
    }
}
​
/// <summary>A binary string helper.</summary>
public static class BinaryStringHelper
{
    /// <summary>A byte extension method that converts a value to a binary string.</summary>
    /// <param name="value">The value to act on.</param>
    /// <returns>value as a string.</returns>
    public static string ToBinaryString(this byte value)
    {
        return Convert.ToString(value, 2).SetPadding(8);
    }
​
    /// <summary>A byte extension method that converts a value to a binary string.</summary>
    /// <param name="value">The value to act on.</param>
    /// <param name="digits">The digits.</param>
    /// <returns>value as a string.</returns>
    public static string ToBinaryString(this byte value, int digits)
    {
        return Convert.ToString(value, 2).SetPadding(digits);
    }
​
    /// <summary>A byte extension method that converts a value to a binary string.</summary>
    /// <param name="value">The value to act on.</param>
    /// <returns>value as a string.</returns>
    public static string ToBinaryString(this sbyte value)
    {
        return unchecked(((sbyte)value).ToBinaryString(8));
    }
​
    /// <summary>A byte extension method that converts a value to a binary string.</summary>
    /// <param name="value">The value to act on.</param>
    /// <param name="digits">The digits.</param>
    /// <returns>value as a string.</returns>
    public static string ToBinaryString(this sbyte value, int digits)
    {
        return unchecked(((sbyte)value).ToBinaryString(digits));
    }
​
    /// <summary>A byte extension method that converts a value to a binary string.</summary>
    /// <param name="value">The value to act on.</param>
    /// <returns>value as a string.</returns>
    public static string ToBinaryString(this ushort value)
    {
        return unchecked(((short)value).ToBinaryString(16));
    }
​
    /// <summary>A byte extension method that converts a value to a binary string.</summary>
    /// <param name="value">The value to act on.</param>
    /// <param name="digits">The digits.</param>
    /// <returns>value as a string.</returns>
    public static string ToBinaryString(this ushort value, int digits)
    {
        return unchecked(((short)value).ToBinaryString(digits));
    }
​
    /// <summary>A byte extension method that converts a value to a binary string.</summary>
    /// <param name="value">The value to act on.</param>
    /// <returns>value as a string.</returns>
    public static string ToBinaryString(this short value)
    {
        return Convert.ToString(value, 2).SetPadding(16);
    }
​
    /// <summary>A byte extension method that converts a value to a binary string.</summary>
    /// <param name="value">The value to act on.</param>
    /// <param name="digits">The digits.</param>
    /// <returns>value as a string.</returns>
    public static string ToBinaryString(this short value, int digits)
    {
        return Convert.ToString(value, 2).SetPadding(digits);
    }
​
    /// <summary>A string extension method that sets a padding.</summary>
    /// <param name="binaryString">The binaryString to act on.</param>
    /// <param name="digits">The digits.</param>
    /// <returns>A string.</returns>
    public static string SetPadding(this string binaryString, int digits)
    {
        // adds lost digits.
        // 
        // Convert.ToString()では、上位の連続する0が省略されるので補う.
        // 
        int length = binaryString.Length;
        if (digits > length) return binaryString.Insert(0, new string('0', digits - length));
​
        return binaryString;
    }
​
    /// <summary>A string extension method that sets a separator.</summary>
    /// <param name="binaryString">The binaryString to act on.</param>
    /// <param name="separator">The separator.</param>
    /// <param name="digitsList">List of digits.</param>
    /// <returns>A string.</returns>
    public static string SetSeparator(this string binaryString, string separator, int[] digitsList)
    {
        // adds lost digits.
        var result = binaryString;
        int length = result.Length;
​
        if (digitsList.Length > 0)
        {
            // digitsList: from lsb to msb
            // 
            // 右(LSB)側から数えた位置がリストに入っていると仮定している.
            // 
            foreach (var digits in digitsList)
            {
                // 
                // 右(LSB)側から数えた位置を左(MSB)側から数えた位置に変換して、挿入場所を決める.
                // 右(LSB)側から数えた位置は、小さい順にリストに入っていると仮定している.
                // 
                var position = length - digits;
                if (position > 0) result = result.Insert(position, separator);
            }
        }
​
        return result;
    }
}
​

Valor da Hora trabalhada:

Cached Result
Last Run:	8:53:12 am
Compile:	0.006s
Execute:	0.05s
Memory:	2.84Mb
CPU:	0.056s

View IL Code