2015-12-19

浮動小数点数型 double と誤差～double の内部表現～

IEEE 754 倍精度浮動小数点形式

※ C# Advent Calendar 2015 の12月19日の記事。

前の日の記事: 真・Roslyn for Scripting! あなたのアプリケーションにもC#スクリプトを!! - kekyoの丼
次の日の記事: Code整形でちょっと役立つCodeMaidの利用方法

C 等を使用している場合と異なり、C# では、それがメモリ上でどのような姿をしているのかを意識する機会は少なめだ。

C の場合、型とメモリ上のビットの並びを意識したプログラミングをする機会が多い。ビット演算も比較的良く使われる。それに比べると、C# や Java などの言語だけを使っている場合は、そうした機会は割と少ない。

しかし、C# 等であっても、やはりそれぞれの型がメモリ上でどのようにして値を保持しているかを知っていることが有効な場合がある。例えば、double の演算では誤差が生じることが多いが、double の内部表現を知ることで、その理由も腑に落ちやすいだろう。

本記事では、敢えて C# の double (System.Double) の内部の表現に焦点を当ててみたい。後ろの方では、double の内部を見るクラスなども紹介する。

※ C# 6.0 を使用。

double を足したり引いたりすると誤差が生じる

C# で double や float のような浮動小数点数型を扱う場合には、誤差に注意する必要がある。

次の例では、↑ボタンを押す度に数値に 0.1 を足し、↓ボタンを押す度に数値から 0.1 を引いているのだが、何度も↑ボタンや↓ボタンを押した結果、誤差が生じている。

ちなみに、ソースコードは次のようなものだ。

UpDown.xaml.cs

using System.Windows;
using System.Windows.Controls;

namespace 浮動小数点数サンプル.WPF
{
    public partial class UpDown : UserControl
    {
        const double d = 0.1;

        public static readonly DependencyProperty ValueProperty = DependencyProperty.Register("Value", typeof(double), typeof(UpDown), new PropertyMetadata(0.0));

        public double Value {
            get { return (double)GetValue(ValueProperty); }
            set { SetValue(ValueProperty, value); }
        }

        public UpDown()
        { InitializeComponent(); }

        void OnUpButtonClick  (object sender, RoutedEventArgs e) => Value += d;
        void OnDownButtonClick(object sender, RoutedEventArgs e) => Value -= d;
    }
}

UpDown.xaml

<UserControl x:Class="浮動小数点数サンプル.WPF.UpDown"
             xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
             xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
             xmlns:mc="http://schemas.openxmlformats.org/markup-compatibility/2006" 
             xmlns:d="http://schemas.microsoft.com/expression/blend/2008" 
             xmlns:local="clr-namespace:浮動小数点数サンプル.WPF"
             mc:Ignorable="d" 
             d:DesignHeight="80" d:DesignWidth="200">
    <Grid>
        <Grid.RowDefinitions>
            <RowDefinition Height="*"/>
            <RowDefinition Height="*"/>
        </Grid.RowDefinitions>
        <Grid.ColumnDefinitions>
            <ColumnDefinition Width="Auto"/>
            <ColumnDefinition Width="Auto"/>
        </Grid.ColumnDefinitions>
        <RepeatButton Content="↑" Click="OnUpButtonClick"/>
        <RepeatButton Grid.Row="1" Content="↓" Click="OnDownButtonClick"/>
        <TextBlock Grid.Column="1" Grid.RowSpan="2" Text="{Binding Value, RelativeSource={RelativeSource FindAncestor, AncestorType={x:Type local:UpDown}}}" HorizontalAlignment="Right" VerticalAlignment="Center" TextWrapping="Wrap"/>
    </Grid>
</UserControl>

問題点を絞るために、もっとシンプルなサンプルで見てみよう。

次の例では、コンソールアプリケーションで、0.1 を 20 回足した後に20回引いてみて、値の変化を表示している。

0.1 を 20 回足した後に20回引くコンソールアプリケーション

using System;

public static class Extension
{
    // 回数繰り返す
    public static void Repeat(this int times, Action action)
    {
        for (var counter = 0; counter < times; counter++)
            action();
    }
}

static class Program
{
    static void WriteLine(double value) => Console.WriteLine($"{value:f16}");

    static void Main()
    {
        // 0.0 から 0.1 ずつ20回増やしていき、0.1 ずつ20回減らしていく
        const int    times = 20;
        const double d     =  0.1;
        double       value =  0.0;
        WriteLine(value);
        times.Repeat(() => WriteLine(value += d));
        times.Repeat(() => WriteLine(value -= d));
    }
}

実行結果は次の通りだ。

最後の方で誤差が生じているのが分かる。

0.1 を 20 回足した後に20回引くコンソールアプリケーションの実行結果


0.0000000000000000
0.1000000000000000
0.2000000000000000
0.3000000000000000
0.4000000000000000
0.5000000000000000
0.6000000000000000
0.7000000000000000
0.8000000000000000
0.9000000000000000
1.0000000000000000
1.1000000000000000
1.2000000000000000
1.3000000000000000
1.4000000000000000
1.5000000000000000
1.6000000000000000
1.7000000000000000
1.8000000000000000
1.9000000000000000
2.0000000000000000
1.9000000000000000
1.8000000000000000
1.7000000000000000
1.6000000000000000
1.5000000000000000
1.4000000000000000
1.3000000000000000
1.2000000000000000
1.1000000000000000
1.0000000000000000
0.9000000000000000
0.8000000000000000
0.7000000000000000
0.6000000000000000
0.5000000000000000
0.4000000000000000
0.3000000000000000
0.2000000000000000
0.0999999999999998
-0.0000000000000002

どうしてこのような誤差が生じるのだろうか?

情報落ち

「情報落ち」と呼ばれる現象がある。

絶対値が大きな値と小さな値を足したり引いたりした場合、小さい方の数値の末尾の分の情報が失われる、というものだ。

例えば、十進数で 1111111111.11111 と 1.11111111112345 を足す場合を考えてみよう。 double の有効桁は十進数で15桁程度なので、そうした場合を想定してみる。

有効桁が15桁の場合、1111111111.11111 + 1.11111111112345 = 1111111112.22222 となり、足し算の結果が小さい方の数値の末尾の分小さくなっている。このような演算を繰り返すと、どんどんこの分の誤差が積もっていくことになる。

今回の場合だが、果たして 0.1 を足したり引いたりするだけで、このような誤差が生じるのだろうか。 0.1 の足し算や引き算であれば、有効桁が15桁もあれば誤差は生じないのではなかろうか。

その鍵は、double の内部表現にある。

二進数としての小数

double の内部表現は二進数である。

そこで、二進数としての小数を考えてみよう。

例えば、十進数で 2.5 の場合、これを二進数で表現すると次のようになる。

2.5₍₁₀₎ = 2 + 0.5 = 10₍₂₎ + 1×2^-1 = 10.1₍₂₎

そして、十進数で 0.1 の場合、二進数で表現すると、次のように循環小数となるのだ。

0.1₍₁₀₎ = 0.0 0011 0011 0011…₍₂₎

double 内部の二進数としての有効桁は、52 + 1桁である。十進数としての 0.1 を入れたつもりでも、実際には循環小数の全ての桁を格納できる訳ではないので、有効桁を超えた分の情報はなくなってしまい、僅かに 0.1 と異なる値が格納されることになる。

また、この場合、有効桁いっぱいまで使って 0.1 に近い値を表現しているので、絶対値がより大きい値との演算で情報落ちが起こることがある。

double の内部表現

では、double の内部表現をもっと詳しくみてみよう。

double は、次のような構造をしている。これは、「IEEE 754 倍精度浮動小数点形式」と呼ばれる形式だ。

64ビットの中に二進数で、符号部、指数部、仮数部の三つが格納されており、次のような値を表す。

-1^符号部 × 1.仮数部 × 2^{指数部 ‐ 1023}

部分	ビット数	意味	補足
符号部	1 ビット	負の数かどうかを表す	1: 負の数、0: 負の数ではない
指数部	11 ビット	指数	1023 足される
仮数部	52 ビット	仮数の絶対値	非 0 の場合 1.XXXXX… になるように指数部で調整され、最上位の 1 は省かれる

例えば、2.5₍₁₀₎ の場合だと次のようになる:

2.5₍₁₀₎
= 10.1₍₂₎
= 10.1₍₂₎×2⁰
= 1.01₍₂₎×2¹ (1.XXXXX… になるように調整)

そして、それぞれの部分は次のようになる。

部分	値	補足
符号部	0	負の数でない
指数部	10000000000	1₍₁₀₎+1023₍₁₀₎=1024₍₁₀₎=10000000000₍₂₎
仮数部	0100000000000000000000000000000000000000000000000000	1.0100000000000000000000000000000000000000000000000000 の先頭の 1. を省いたもの

従って、2.5₍₁₀₎ を double に格納したときの全体の内部表現は、|0|10000000000|0100000000000000000000000000000000000000000000000000| となる。

そして、0.1₍₁₀₎ の場合だと次のようになる:

0.1₍₁₀₎
= 0.0 0011 0011 0011 …₍₂₎ (循環小数となる)
= 1.1 0011 0011 …₍₂₎ × 2^-4 (1.XXXXX… になるように調整)

それぞれの部分は次のようになる。

部分	値	補足
符号部	0	負の数でない
指数部	‭01111111011	-4₍₁₀₎+1023₍₁₀₎=1019₍₁₀₎=‭01111111011₍₂₎
仮数部	1001100110011001100110011001100110011001100110011010	1.1 0011 0011 …₍₂₎ の整数部分の1を省略し、最後の桁の次の桁を「0捨1入」

つまり、0.1₍₁₀₎ を double に格納したときの全体の内部表現は、|0|‭01111111011|1001100110011001100110011001100110011001100110011010| となる。

尚、同じく浮動小数点数型である float に関しても同様だ。こちらは、4 バイト = 32 ビット (符号部 1 ビット、指数部 8 ビット、仮数部 23 ビット) となる。

C# で double の内部の値を見てみよう

最後に、C# で double の内部の値を見るクラスを作ってみよう。

先ず、double をバイト列にしたり、バイト列を十六進数表現に変換したり、十六進数表現を二進数表現に変換したりするメソッド群を用意した。

バイト列に変換するのには、System.BitConverter クラスが使用できる。また、メモリ上での配置がリトルエンディアンになっている場合は、反転する必要があるが、これも System.BitConverter クラスで判定できる。

十六進数や二進数としての表現は、文字列として得られるようにした。

BinaryUtility.cs

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

public static class BinaryUtility
{
    // バイト列をビッグ エンディアンに変換 (メモリ上での配置がリトル エンディアンになっている場合は反転)
    public static byte[] ToBigEndian(this byte[] bytes) =>
        BitConverter.IsLittleEndian ? bytes.Reverse().ToArray() : bytes;

    // double をバイト列に変換 (ビッグ エンディアン)
    public static byte[] ToBytes(this double value) =>
        BitConverter.GetBytes(value).ToBigEndian();

    // バイト列を十六進数に変換
    public static string ToHexadecimalNumber(this byte[] byteArray) =>
        BitConverter.ToString(byteArray).Replace("-", "");

    // 十六進数一桁を二進数に変換
    public static string HexadecimalNumberToBinaryNumber(char hexadecimalNumber) =>
        Convert.ToString(Convert.ToInt32(hexadecimalNumber.ToString(), 16), 2).PadLeft(4, '0');

    // 十六進数を二進数に変換
    public static string HexadecimalNumberToBinaryNumber(string hexadecimalString) =>
        hexadecimalString.Select(character => HexadecimalNumberToBinaryNumber(character))
                         .Aggregate(new StringBuilder(), (stringBuilder, text) => stringBuilder.Append(text))
                         .ToString();

    // 二進数一桁を int に変換
    public static int BinaryNumberToInteger(char binaryNumber) =>
        binaryNumber == '0' ? 0 : 1;
}

次に、これを利用して、double 即ち IEEE 754 倍精度浮動小数点形式から各部分の値を取り出すクラスを作ってみよう。

IEEE754Double.cs

using System;

// IEEE 754 倍精度 浮動小数点形式 (8バイト)
// 符号部 1bit   マイナス符号があるとき1
// 指数部 11bits 指数 + 2^10−1 (2^10−1 = 1024 - 1 = 1023)
// 仮数部 52bits 整数部分の1を省略
// ※ 仮数部は整数部分が1のみになるように調整
public class IEEE754Double
{
    const int       exponentBias = 1024 - 1; // 指数のバイアス: 2^10−1 = 1024 - 1 = 1023
    readonly double value;                   // double としての値
    readonly string hexadecimalNumber;       // 十六進数
    readonly string binaryNumber;            // ニ進数

    public IEEE754Double(double value)
    {
        this.value        = value;
        hexadecimalNumber = value.ToBytes().ToHexadecimalNumber();
        binaryNumber      = BinaryUtility.HexadecimalNumberToBinaryNumber(HexadecimalNumber);
    }

    // double としての値
    public double Value => value;

    // 十六進数
    public string HexadecimalNumber => hexadecimalNumber;

    // ニ進数
    public string BinaryNumber => binaryNumber;

    // 符号部の二進数 (マイナス符号があるかないか: 符号部 1bit)
    public char SignBinaryNumber => binaryNumber[0];

    // 指数部の二進数 (指数部 11bits)
    public string ExponentBinaryNumber => binaryNumber.Substring(1, 11);

    // 仮数部の二進数 (仮数部 52bits : 整数部分の1を省略した小数部分)
    public string DigitsBinaryNumber => binaryNumber.Substring(1 + 11, 64 - 1 - 11);

    // 符号 (マイナス符号があるかないか: 符号部 1bit から取得)
    public bool Sign => SignBinaryNumber == '1';

    // 指数 (「指数部 11bits: 指数 + 指数のバイアス」から取得)
    public int Exponent => Convert.ToInt32(ExponentBinaryNumber, 2) - exponentBias;

    // 仮数
    public double Digits
    {
        get {
            var wholeDigitsBinaryNumber = "1" + DigitsBinaryNumber; // 二進数
            // 二進数を double に変換
            var result = 0.0;
            for (var index = wholeDigitsBinaryNumber.Length - 1; index >= 0; index--)
                result = result / 2.0 + BinaryUtility.BinaryNumberToInteger(wholeDigitsBinaryNumber[index]);
            return result;
        }
    }

    public override string ToString() => $"{SignString}{Digits} * 2^{Exponent}";

    // 符号文字列 (- または +)
    string SignString => Sign ? "-" : "+";
}

これらを使って、2.5₍₁₀₎ と 0.1₍₁₀₎ の内部の値をみてみよう。

Program.cs

using System;

static class Program
{
    static void WriteLine(double value)
    {
        var i3eDouble = new IEEE754Double(value);
        Console.WriteLine($"{i3eDouble.Value:f16}, {i3eDouble.HexadecimalNumber}, {i3eDouble.BinaryNumber}, {i3eDouble.ToString()}");
    }

    static void Main()
    {
        WriteLine(2.5);
        WriteLine(0.1);
    }
}

実行結果は次のようになる。先に考察したのと同じ結果だ。


2.5000000000000000, 4004000000000000, 0100000000000100000000000000000000000000000000000000000000000000, +1.25 * 2^1
0.1000000000000000, 3FB999999999999A, 0011111110111001100110011001100110011001100110011001100110011010, +1.6 * 2^-4

試しに、double.MaxValue、double.MinValue、double.PositiveInfinity、double.NegativeInfinity、double.NaN を出してみると次のようになった。


179769313486232000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0000000000000000, 7FEFFFFFFFFFFFFF, 0111111111101111111111111111111111111111111111111111111111111111, +2 * 2^1023
-179769313486232000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0000000000000000, FFEFFFFFFFFFFFFF, 1111111111101111111111111111111111111111111111111111111111111111, -2 * 2^1023
∞, 7FF0000000000000, 0111111111110000000000000000000000000000000000000000000000000000, +1 * 2^1024
-∞, FFF0000000000000, 1111111111110000000000000000000000000000000000000000000000000000, -1 * 2^1024
NaN, FFF8000000000000, 1111111111111000000000000000000000000000000000000000000000000000, -1.5 * 2^1024

double.PositiveInfinity、double.NegativeInfinity、double.NaN に関しては最後の部分は無用だが、それぞれの内部表現は確認できた。

では、始めの方で行った、0.1 を足したり引いたりする例について試してみよう。

Program.cs

using System;

public static class Extension
{
    // 回数繰り返す
    public static void Repeat(this int times, Action action)
    {
        for (var counter = 0; counter < times; counter++)
            action();
    }
}

static class Program
{
    static void WriteLine(double value)
    {
        var i3eDouble = new IEEE754Double(value);
        Console.WriteLine($"{i3eDouble.Value:f16}, {i3eDouble.HexadecimalNumber}, {i3eDouble.BinaryNumber}, {i3eDouble.ToString()}");
    }

    static void Main()
    {
        // 0.0 から 0.1 ずつ20回増やしていき、0.1 ずつ20回減らしていく
        const int    times = 20;
        const double d     =  0.1;
        double       value =  0.0;
        WriteLine(value);
        times.Repeat(() => WriteLine(value += d));
        times.Repeat(() => WriteLine(value -= d));
    }
}

実行結果は次のようになった。二進数の演算で誤差が生じている箇所が確認できるだろうか。


0.0000000000000000, 0000000000000000, 0000000000000000000000000000000000000000000000000000000000000000, +1 * 2^-1023
0.1000000000000000, 3FB999999999999A, 0011111110111001100110011001100110011001100110011001100110011010, +1.6 * 2^-4
0.2000000000000000, 3FC999999999999A, 0011111111001001100110011001100110011001100110011001100110011010, +1.6 * 2^-3
0.3000000000000000, 3FD3333333333334, 0011111111010011001100110011001100110011001100110011001100110100, +1.2 * 2^-2
0.4000000000000000, 3FD999999999999A, 0011111111011001100110011001100110011001100110011001100110011010, +1.6 * 2^-2
0.5000000000000000, 3FE0000000000000, 0011111111100000000000000000000000000000000000000000000000000000, +1 * 2^-1
0.6000000000000000, 3FE3333333333333, 0011111111100011001100110011001100110011001100110011001100110011, +1.2 * 2^-1
0.7000000000000000, 3FE6666666666666, 0011111111100110011001100110011001100110011001100110011001100110, +1.4 * 2^-1
0.8000000000000000, 3FE9999999999999, 0011111111101001100110011001100110011001100110011001100110011001, +1.6 * 2^-1
0.9000000000000000, 3FECCCCCCCCCCCCC, 0011111111101100110011001100110011001100110011001100110011001100, +1.8 * 2^-1
1.0000000000000000, 3FEFFFFFFFFFFFFF, 0011111111101111111111111111111111111111111111111111111111111111, +2 * 2^-1
1.1000000000000000, 3FF1999999999999, 0011111111110001100110011001100110011001100110011001100110011001, +1.1 * 2^0
1.2000000000000000, 3FF3333333333333, 0011111111110011001100110011001100110011001100110011001100110011, +1.2 * 2^0
1.3000000000000000, 3FF4CCCCCCCCCCCD, 0011111111110100110011001100110011001100110011001100110011001101, +1.3 * 2^0
1.4000000000000000, 3FF6666666666667, 0011111111110110011001100110011001100110011001100110011001100111, +1.4 * 2^0
1.5000000000000000, 3FF8000000000001, 0011111111111000000000000000000000000000000000000000000000000001, +1.5 * 2^0
1.6000000000000000, 3FF999999999999B, 0011111111111001100110011001100110011001100110011001100110011011, +1.6 * 2^0
1.7000000000000000, 3FFB333333333335, 0011111111111011001100110011001100110011001100110011001100110101, +1.7 * 2^0
1.8000000000000000, 3FFCCCCCCCCCCCCF, 0011111111111100110011001100110011001100110011001100110011001111, +1.8 * 2^0
1.9000000000000000, 3FFE666666666669, 0011111111111110011001100110011001100110011001100110011001101001, +1.9 * 2^0
2.0000000000000000, 4000000000000001, 0100000000000000000000000000000000000000000000000000000000000001, +1 * 2^1
1.9000000000000000, 3FFE666666666668, 0011111111111110011001100110011001100110011001100110011001101000, +1.9 * 2^0
1.8000000000000000, 3FFCCCCCCCCCCCCE, 0011111111111100110011001100110011001100110011001100110011001110, +1.8 * 2^0
1.7000000000000000, 3FFB333333333334, 0011111111111011001100110011001100110011001100110011001100110100, +1.7 * 2^0
1.6000000000000000, 3FF999999999999A, 0011111111111001100110011001100110011001100110011001100110011010, +1.6 * 2^0
1.5000000000000000, 3FF8000000000000, 0011111111111000000000000000000000000000000000000000000000000000, +1.5 * 2^0
1.4000000000000000, 3FF6666666666666, 0011111111110110011001100110011001100110011001100110011001100110, +1.4 * 2^0
1.3000000000000000, 3FF4CCCCCCCCCCCC, 0011111111110100110011001100110011001100110011001100110011001100, +1.3 * 2^0
1.2000000000000000, 3FF3333333333332, 0011111111110011001100110011001100110011001100110011001100110010, +1.2 * 2^0
1.1000000000000000, 3FF1999999999998, 0011111111110001100110011001100110011001100110011001100110011000, +1.1 * 2^0
1.0000000000000000, 3FEFFFFFFFFFFFFD, 0011111111101111111111111111111111111111111111111111111111111101, +2 * 2^-1
0.9000000000000000, 3FECCCCCCCCCCCCA, 0011111111101100110011001100110011001100110011001100110011001010, +1.8 * 2^-1
0.8000000000000000, 3FE9999999999997, 0011111111101001100110011001100110011001100110011001100110010111, +1.6 * 2^-1
0.7000000000000000, 3FE6666666666664, 0011111111100110011001100110011001100110011001100110011001100100, +1.4 * 2^-1
0.6000000000000000, 3FE3333333333331, 0011111111100011001100110011001100110011001100110011001100110001, +1.2 * 2^-1
0.5000000000000000, 3FDFFFFFFFFFFFFC, 0011111111011111111111111111111111111111111111111111111111111100, +2 * 2^-2
0.4000000000000000, 3FD9999999999996, 0011111111011001100110011001100110011001100110011001100110010110, +1.6 * 2^-2
0.3000000000000000, 3FD3333333333330, 0011111111010011001100110011001100110011001100110011001100110000, +1.2 * 2^-2
0.2000000000000000, 3FC9999999999993, 0011111111001001100110011001100110011001100110011001100110010011, +1.6 * 2^-3
0.0999999999999998, 3FB999999999998C, 0011111110111001100110011001100110011001100110011001100110001100, +1.6 * 2^-4
-0.0000000000000002, BCAC000000000000, 1011110010101100000000000000000000000000000000000000000000000000, -1.75 * 2^-53

まとめ

以上、double の内部表現について、C# を使って説明してみた。

2015-12-10

Visual Studio Code の拡張機能「Twitter Client」を試してみる

※ Visual Studio / Visual Studio Code Advent Calendar の12月10日の記事。

前の日の記事: Visual Studio 2015 を初めて使う方に、最初に知ってほしいショートカットキーなど - BEACHSIDE BLOG
次の日の記事: Visual Studio CodeでJavaScript開発しよう - C#でプログラミングあれこれ

Visual Studio Code の拡張機能

Microsoft の開発者向けテキストエディターである Visual Studio Code には、インテリセンスやデバッグ機能などの Visual Studio の素晴らしい機能があり、Windows 以外にも Linux や OS X で使うことができる。オープンソースだ。

豊富な拡張機能も魅力だ。これにより、様々な機能を使うことができる。また、C# や JavaScript のみならず、Go、D Language、Haskell 等の沢山のプログラミング言語にも対応できる。

どんな拡張機能があるかは、次のサイトで見ることができる。

Twitter Client 拡張機能

この記事では、Visual Studio Code の拡張機能の一つ、"Twitter Client" を紹介したい。

この拡張機能を使うことによって、テキストエディターから出ることなく、Twitter のタイムラインを見たり、呟いたりすることができる。

実際にインストールして使ってみよう。

以下で、その手順を示したい。

1. Visual Studio Code のインストール

Visual Studio Code (現在 Version 0.10.3) は、次のサイトからダウンロードしてインストールすることができる。

Visual Studio Code

インストールが完了したら起動してみよう。

2. Twitter Client 拡張機能のインストール

次に、Visual Studio Code に Twitter Client 拡張機能をインストールする。

詳しい内容は、次のページで見ることができる (英語)。

Twitter Client - Visual Studio Code - Visual Studio Marketplace

Visual Studio Code で F1キーを押すと、上にコマンドを入力するテキストボックスが現れる。

ここに、"ext install" と入力し、Enter キーを押す。

暫く待つと、拡張機能がリストアップされてくる (インターネット接続が必要)。

ここで、"ext install " の後ろに "twitter" と入力する。"Twitter Client" が表示されるので、右側の雲のアイコンをクリックしてインストールする。

インストールが終わると、"Restart Now" というボタンが表示される。クリックして Visual Studio Code を再起動しよう。

3. Twitter Developer Account による Twitter App の作成

Twitter のクライアントアプリを作るためには、Twitter Developer Account によって Twitter App の作成を行う必要がある。

その手順は次のページで見ることができる (英語)。

How to Register a Twitter App in 8 Easy Steps

"Twitter Client" には、このステップの為のウィザードが用意されている。見てみよう。

再び F1 キーを押して、コマンドとして "Twi Wizard" と入力する。

すると、"Twitter Client" のウィザードが起動し、Twitter App をセットアップする手順を教えてくれる。 "Continue" をクリックしよう。

すると、"https://apps.twitter.com" で Twitter App を作成するか訊いてくる。 "Continue" をクリックする。

Web ブラウザーで、"https://apps.twitter.com" が開かれる。ここで Twitter App の作成を行う。Twitter にログインしよう (Twitter アカウントが必要)。

"Create New App" をクリックする。

Visual Studio Code 側では、ウィザードを進めていこう。

すると、Web ブラウザー側では、Twitter App を作成するための必要事項の入力を求められる。入力しよう。

Twitter App が作成されたら、"Access level" が "Read & write" になっているのを確認しておこう (もし違っていたら、"modify app permissions" から変更しておく)。

次に、"Keys and Access Tokens" のタブをクリックして切り替える。

ここに表示されている "Consumer Key (API Key)" と "Consumer Secret (API Secret)" は、後で使うのでメモしておく。

そして、下部の "Create my access token" をクリックしよう。

"Access token" が表示される。 "Access Token" と "Access Token Secret" をメモっておこう。

4. Twitter Developer Account による Twitter App の作成

メモっておいたキーやトークンは、Visual Studio Code で入力する。

Visual Studio Code で、メニューから "File" - "Preferences" - "User Settings" を選ぶ。

Visual Studio Code で "User Settings" を開く

"settings.json" というファイルが開く。右側がユーザー用の設定ファイルだ。次のように入力する。

"twitter.consumerkey": "xxxx", // Consumer Key (API Key)

"twitter.consumersecret": "xxxx", // Consumer Secret (API Secret)

"twitter.accesstokenkey": "xxxx", // Access Token

"twitter.accesstokensecret": "xxxx" // Access Token Secret

5. "Twitter Client" を使ってみよう

以上で準備は完了だ。使ってみよう。

Visual Studio Code の下部に "Twitter" と書かれたボタンが表示されている。

クリックしてみよう。

すると、上の方に Twitter 用のコマンドが表示される。

例えば、"Home" をクリックしてみると、自分のタイムラインが表示される筈だ。

"User" を選んで自分の呟きだけに切り替え、"Post" を使って呟いてみると次のような感じだ。

まとめ

今回は、Visual Studio Code の拡張機能の一つ Twitter Client を試した。

Visual Studio Code には、他にも豊富な拡張機能がある。是非試してほしい。

2015-07-02

Microsoft MVP for .NET を受賞しました

Microsoft MVP Award を再受賞しました。11年目になります。

1月から、Visual C#, Visual Basic, Visual F# が .NET に統合されたため、今回は .NET という技術専門分野での受賞になりました。

いくつかの IT 系の大企業が、このような表彰制度を用意して、技術者を (かなり本気で) 褒めてくださいます。大人になると、中々褒められる機会がないので、こうして褒められるとかなり嬉しいものです。ありがたいことです。

子供はもちろんのこと、大人であっても褒める、ということの大切さを改めて感じます。

そして、お世話になっている皆様に感謝です。ありがとうございます。

※ もし、執筆や技術系セッションなどご要望があれば、よろしくお願いします (こちら等へ)。

2015-06-24

『日経ソフトウェア 2015年8月号』【特集1】「最新Visual Studioで、Windowsアプリを作ろう」のPart 1-3を執筆

日経ソフトウェア 2015年8月号

『日経ソフトウェア 2015年8月号』で、【特集1】「最新Visual Studioで、Windowsアプリを作ろう」のPart 1-3を執筆しました。

『日経ソフトウェア 2015年8月号』
発売日	2015年6月24日
出版社	日経BP社
Amazon.co.jp	雑誌
Amazon.co.jp	Kindle版

Visual Studio の最新版 Visual Studio 2015 のこの夏の登場を前に、無料で使える Visual Studio Community 2015 RC を使った Windows アプリケーションの作り方の記事を書きました。

Visual Studio を使ったことがない人でも分かるように書きましたが、Visual Studio 2015 の新しい機能も紹介していますので、既に Visual Studio をお使いの方もぜひどうぞ。

日経ソフトウエアのサイトで冒頭を読むことができます。

次のような内容です。

Part 1. Visual Studio を始めよう
Visual Studio 2015 のインストール方法と、何ができて、どう便利か、新機能とともに紹介しています。
Part 2. キッチンタイマーを作ってみよう
Visual Basic + Windows フォームで、デジタル時計 → ストップウォッチ → キッチンタイマーと段階的に機能を追加していくチュートリアルです。
Part 3. アナログ時計アプリを作ってみよう
C# + WPF で、デジタル時計 → アナログ時計と段階的に機能を追加していくチュートリアルです。
WPF の標準的な作り方として、Model-View-ViewModel に分けた設計方法をご紹介しています。

尚、Part 4 は日本マイクロソフトによる「Visual Studio 2015 の新機能」です。

『C#実践開発手法』レビュー

『C#実践開発手法』

『C#実践開発手法』という本を監訳された長沢智治さんにいただいた。レビューしたい。

タイトル	C#実践開発手法
サブタイトル等	デザインパターンとSOLID原則によるアジャイルなコーディング (マイクロソフト公式解説書)
著者・監訳・翻訳	Gary McLean Hall (著), 長沢智治 (監訳), クイープ (翻訳)
出版社	日経BP社
発売日	2015年6月4日
本体価格	¥5,000+税
頁数	440頁
本の種類	単行本、Kindle

原書 (英語) は次の通り。

タイトル	Adaptive Code via C#
サブタイトル	Agile coding with design patterns and SOLID principles
著者	Gary McLean Hall
出版社	Microsoft Press
発売日	2014年10月19日
頁数	448頁
本の種類	ペーパーバック、Kindle

内容

次のような内容となっている。

開発手法であるスクラム
モジュールの依存関係の原則
インタフェイスを使った Adaptive な (適応力のある) 設計方法
ユニットテスト (単体テスト) とリファクタリング (内部構造の改善)
SOLID の原則 (単一責務の原則、開放/閉鎖の原則、リスコフの置換原則、インタフェイス分離の原則、依存性反転の原則)
開発のサンプル
Git などのツールの紹介

何故プログラマーには本書が重要か

ソフトウェアは変化し続ける

ソフトウェア開発は、常に追加・変更し続けるのが特徴だ。一気に全体が出来上がる訳ではない。最初の1行を書いてから、段々と機能が足され、また、改良されていく。変更し続けるのが特徴なので、なるべく変化を受け入れやすい作り方をする方が良い。

本書には、そういう「Adaptive Code (適応力のあるコード)」を書くための原則とそれを実践するための方法としてベストプラクティスが書かれている。

原則は重要

ソフトウェア開発において、原則は重要だ。

C# 等のプログラミング言語の文法を覚えればそれだけでソフトウェアが書けるかというと、そうではない。また、いつもいつも日進月歩の開発技術を一から習得しなおさないといけないかというと、それも違う。経験があり優秀な技術者は、新しいプログラミング言語、新しい開発基盤でも実力を発揮するものだ。

そこには、個々の開発技術にそれほど依存せず、新しい技術が出てきたときにも使える知恵があるだろう。つまり、プログラミング言語や技術のトレンド等の枠を超えて重要な、開発手法や原則、パターン、アンチパターン、ベストプラクティスというものがあるのだ。

それは、偉大な先人の知恵が集まったものだ。経験のあるプログラマーが長年掛かって身に付ける暗黙知のような技術を、先人が形式知として習得しやすくしてくれたのだ。そうした知恵は広くソフトウェア開発に応用が効き、また、ドッグイヤーと言われるソフトウェア開発の技術革新の中でも古びない。また、プログラマー同士がコミュニケーションするときの語彙としてもずっと重要なものだ。プログラマーとしては是非とも知っておきたい。

「原則だのパターンだのは、実務では役に立たない」というのを聞いたことがある。それは違うと思う。パターンをどこにでも適用しさえすれば良い、ということではない。サンプルコードそのものをコピー & ペーストして使え、という話でも断じてない。原則やパターン等は、「守破離」でいう「守」だ。基礎なのだ。

確かに、単にそれらの開発手法や原則、パターン、アンチパターン、ベストプラクティスを並べただけでは、中々理解が難しい場合もある。実務への応用が易しくない場合もあるだろう。抽象的な知識は、広く使えて古びないが、具体的な知識と違って、深く理解しないと現場で活かしづらい。

本書は、単なる原則論にとどまっておらず、豊富な C# のサンプルコードや Visual Studio 等のツールの使い方の例によって、具体的に実践方法をあげている。ここが、とても重要なところだと思う。

プログラマーの必読書

過去にこうした知恵が書かれたプログラマーの必読書としては、次のようなものがあった:

『達人プログラマー ―システム開発の職人から名匠への道』 (2000/11)
『達人プログラマー ―ソフトウェア開発に不可欠な基礎知識バージョン管理/ユニットテスト/自動化』 (2005/3)
『アジャイルソフトウェア開発の奥義』 (2004/6/30)
『アジャイルソフトウェア開発の奥義第2版オブジェクト指向開発の神髄と匠の技』 (2008/7/1)

本書『C#実践開発手法』は、C#プログラマーにとって、そうした本に並ぶものだと思う。より新しい内容も含まれているし、何より Visual Studio と C# による実装レベルにまで具体的に噛み砕いている。中堅のC#プログラマーに必読だろう。

2015-06-12

Microsoft Virtual Academy の紹介

Microsoft Virtual Academy (MVA) についてご紹介します。

Microsoft Virtual Academy (MVA) は Microsoft が提供するオンライントレーニングです。

特長

全コース無償
開発者向けや IT プロ向けの様々な学習コースが充実
Visual Studio、SQL Server、Windows、Office など、マイクロソフト技術について幅広く学べる
de:code 2015 のキーノートなど、マイクロソフトのカンファレンスやイベントのセッションを視聴できる
映像やパワーポイントの資料による分かりやすい説明
映像やパワーポイントの資料はダウンロード可能
日本語の映像の視聴に加えて、英語の映像も (日本語字幕付きで) 視聴できる
いつでも好きな時に受講できる
ダッシュボードで、学習の計画を建てたり、進み具合をチェックできる
学習が進むにつれてポイントがたまっていき、ランキングを競うことができる

使い方

Microsoft Virtual Academy (MVA) は 5 回までは会員登録なしで、すぐに授業動画の視聴と資料のダウンロードが可能です。
さっそく授業を閲覧して、使い方を確認してみましょう。

コースのURLをクリックします。
例. Visual Studio 2015 における統合開発環境の進化
動画を再生してみましょう。
資料をダウンロードしてみましょう。
Microsoft Virtual Academy (MVA) に登録。
Microsoft Virtual Academy (MVA) の会員登録は無料です。登録すると Microsoft Virtual Academy (MVA) に掲載されているすべての授業動画や資料を閲覧できます。さらに学習に便利な学習履歴の閲覧や、受講証の発行、学習ランキングを使用することができます。
マイクロソフトアカウントがある方はマイクロソフトアカウントでサインイン、ない方は「Sign up now」からアカウントを作成してください。

開発者向け3コース

それでは、多くの学習コースの中から、開発者向けの3つをご紹介します。

各コース名をクリックすることで、それぞれを受講することができます。

コース名	説明	コース内容
Visual Studio 2015 における統合開発環境の進化	リリース間近な Visual Studio 2015 の最新の開発環境の説明。	開発ツールの強化～ Visual Studio 2015 開発基盤の強化～ Team Foundation Server 2015
Unity を使用した Windows 用の 2D および 3D ゲーム開発ジャンプスタート	C# と Unity を使用した Windows 用の Unity ゲームを開発する方法。ビデオは英語だが、日本語字幕付き。	概要とアーキテクチャ 2D ゲーム開発 2D および 3D アセットの作成 3D ゲーム開発 Windows プラットフォームの構築ゲームの最適化 Unity 内のアプリケーションライフサイクル管理 (ALM) マーケティングと収益化 Prime[31] および Azure モバイルサービス最後のしあげの追加公開形式の Q&A ログ
Microsoft Azure の基礎	Microsoft Azure の最初のコース。	シリーズの概要 Microsoft Azure をお勧めする理由 Microsoft Azure サービスの範囲 Azure へのアクセスに使用するツールと API Azure ポータルとプレビューポータルの操作組織アカウントとサブスクリプションの作成サブスクリプションとディレクトリの理解 How Do I: ディレクトリの管理 How Do I: マネージャユーザー、サブスクリプションの役割、およびディレクトリの役割 How Do I: サブスクリプションとサービス管理者の管理ジオ (主要地域)、地域、およびデータセンターの理解参考情報