C#

[C/C++/CLI/C#] 二値Enum型を作りたい。

T.Hirase — Thu, 30 Jul 2009 23:39:00 GMT

うすたー：Enum で bool 型を使いたい時って？ (R.Tanaka.Ichiro's Blog)

前回の記事があまりにひどいできだったので、やり直します。

戻り値はtrue/falseでいいですか？

たとえば、データの書き込み関数「TryWritingBytes」を考えます。バッファリングやハードウェアの都合上、書き込みには失敗する可能性があります。

以下に、TryWritingBytes関数の使用例を示します。同関数の実装は省略。

extern bool TryWritingBytes(void * data, size_t size);

int main()
{
	// something to do.
	
	if (TryWritingBytes(data, size)) {
		// 成功時の処理
	} else {
		// 失敗時の処理
	}
	
	// something to do.
}

このTryWritingBytesの戻り値は、書き込み成功時にtrueを返す仕様になります。が、こういう「成功=Trueだな」みたいに、経験十分プログラマ的な感覚で決められた関数って、危ういと思います。みんながみんな経験十分プログラマとは限らないからです。

成功不成功という値を作るべし。

そんなわけで、trueがどっちを表すかなんて、不毛な議論やコメントを書くくらいなら、さっさと別の二値型を作って、読む人も書く人も間違えないようにすべきです。

そんなこんなで、このコード：

enum IsSuccess : bool {
	Success,
	Failed
};

extern IsSuccess TryWritingBytes(void * data, size_t size);

int main()
{
	// something to do.
	
	if (TryWritingBytes(data, size) == Success) {
		// 成功時の処理
	} else {	// Failed
		// 失敗時の処理
	}
	
	// something to do.
}

こんな言語仕様あった方がいいと思いません？

補足

先の記事で、私、「true/falseを別名で扱いたいだけです」と書いていますが、考え直したところ、全然ダメです。true/falseを別名で扱うこともやはり手段であって、目的ではないですし、仮にできたとしても、所詮別名、成功不成功を表す別名にtrue/falseを代入できてしまいますから。

なので、やっぱり、二値Enum。

また先の記事のコメントやトラックバックで、いくつか代替方法をいただきましたが、やはり私を含む経験不足プログラマが見てもわかりやすい方式（二値Enumに限らず）が言語仕様に組み込まれる方が良いと思います。

ちなみに、別に今回の二値Enumがベストな解だとは思っていません。

あとあと、最後に。他にも言語仕様に不満ってありません？　っていうか何でテキストエディタなんだよ？　とか。クラスのメソッドを編集するのに、どのファイルを開けばいいかなんて、覚えるのなんて意味ないよ？　とか。もっと自由にやらせろ、的な。

追記＠2009-07-30T23:40

Success/False以外の例をいくつか。

enum OpenClose : bool { Open, Close };
OpenClose CheckOpenClose();
OpenClose OpenTray();

enum YesNo : bool { Yes, No };
YesNo CheckResponse();
YesNo WaitResponse();

enum GoodBad : bool { Good, Bad };
GoodBad CheckFile(const char * file_name);

enum MaleFemale : bool { Male, Female };
MaleFemale CheckSexuality();

などなど

[C#] Enumを二値扱いたかったりする。

T.Hirase — Fri, 17 Jul 2009 11:34:00 GMT

以下、妄想コード。

enum ProcResult : bool  /* 2値であることを宣言 */
{
    Success,
    Failure,
}

class Program
{
    static void Main(string[] args)
    {
        ProcResult v = ProcResult.Success;
        v = !v; /* 2値なんで、「!」演算したいよぅ。 */

        System.Console.WriteLine(v);
    }
}

[C#] char.IsLetter('あ') == True??!

T.Hirase — Thu, 18 Jun 2009 00:53:00 GMT

MSDN曰く「指定した Unicode 文字がアルファベット文字かどうかを示します。」ですが、表題とおり、「あ」は True となります。

２００４年に川俣氏が「「あ」がアルファベット扱い?　.NET FrameworkのChar.IsDigitとChar.IsLetterの正しい挙動」で指摘されていますが、未だに直っていないようです。

メソッド名通りの正しい動作だとは思いますが、残念なことにドキュメントが間違っています。というかアメリカ人は「Letter=Alphabet」だったのでしょうね。実装を確かめずにドキュメントを書くと、こうなるようです。

[C#] Visual Studio アドインで新規ウィンドウを作成する。

T.Hirase — Fri, 08 May 2009 02:23:00 GMT

参考：Windows2.CreateToolWindow2 メソッド (MSDN)

メモでございます。

public void Exec(string commandName, vsCommandExecOption executeOption, ref object varIn, ref object varOut, ref bool handled)
{
    handled = false;
    if (executeOption == vsCommandExecOption.vsCommandExecOptionDoDefault)
    {
        if (commandName == "Sample.Connect.SampleWindow")
        {
            Windows2 windows = this._addInInstance.DTE.Windows as Windows2;
            if (windows == null)
                return;

            Assembly thisAssembly = Assembly.GetAssembly(this.GetType());
            object controlObject = null;
            Window window;
            window = windows.CreateToolWindow2(this._addInInstance, thisAssembly.Location, "Sample.MyUserControl", "Sample Window", "{374A85F2-DA7E-4ab0-8E0F-998E2FED0F55}", ref controlObject);
            if (window != null)
            {
                window.Visible = true;
            }
            handled = true;
            return;
        }
    }
}

あらかじめ、UserControl を継承した Sample.MyUserControl クラスを作っておく必要があります。

このコードは、Visual Studio 2008 で生成したコードを元に追加したものです。

以上

[C#] 複素数型を作る。

T.Hirase — Thu, 05 Feb 2009 10:37:00 GMT

元ネタ：[C#]コンプレックスと戦う

C# ジェネリクスの制限に打ち勝つ

型制約として値型を用いることができない、operator+-*/ をGetMethod()できない、そんな C# ジェネリックでも、複素数型を定義してみました。

namespace Sample
{
    using System;
    using System.ComponentModel;

    struct Complex<TValue>
    {
        public TValue Real { get; set; }
        public TValue Imaginary { get; set; }

        public static Complex<TValue> operator +(Complex<TValue> lft, Complex<TValue> rgt)
        {
            return new Complex<TValue>() { Real = Adder(lft.Real, rgt.Real), Imaginary = Adder(lft.Imaginary, rgt.Imaginary) };
        }

        public static Complex<TValue> operator -(Complex<TValue> lft, Complex<TValue> rgt)
        {
            return new Complex<TValue>() { Real = Subtractor(lft.Real, rgt.Real), Imaginary = Subtractor(lft.Imaginary, rgt.Imaginary) };
        }

        public static Complex<TValue> operator *(Complex<TValue> lft, Complex<TValue> rgt)
        {
            return new Complex<TValue>() { Real = Multiplier(lft.Real, rgt.Real), Imaginary = Multiplier(lft.Imaginary, rgt.Imaginary) };
        }

        public static Complex<TValue> operator /(Complex<TValue> lft, Complex<TValue> rgt)
        {
            return new Complex<TValue>() { Real = Divider(lft.Real, rgt.Real), Imaginary = Divider(lft.Imaginary, rgt.Imaginary) };
        }

        static Complex()
        {
            var tvalue_type = typeof(TValue);
            if (tvalue_type == typeof(sbyte))
            {
                Complex<sbyte>.Adder = (x, y) => (sbyte)(x + y);
                Complex<sbyte>.Subtractor = (x, y) => (sbyte)(x - y);
                Complex<sbyte>.Multiplier = (x, y) => (sbyte)(x * y);
                Complex<sbyte>.Divider = (x, y) => (sbyte)(x / y);
            }
            else if (tvalue_type == typeof(byte))
            {
                Complex<byte>.Adder = (x, y) => (byte)(x + y);
                Complex<byte>.Subtractor = (x, y) => (byte)(x - y);
                Complex<byte>.Multiplier = (x, y) => (byte)(x * y);
                Complex<byte>.Divider = (x, y) => (byte)(x / y);
            }
            else if (tvalue_type == typeof(short))
            {
                Complex<short>.Adder = (x, y) => (short)(x + y);
                Complex<short>.Subtractor = (x, y) => (short)(x - y);
                Complex<short>.Multiplier = (x, y) => (short)(x * y);
                Complex<short>.Divider = (x, y) => (short)(x / y);
            }
            else if (tvalue_type == typeof(ushort))
            {
                Complex<ushort>.Adder = (x, y) => (ushort)(x + y);
                Complex<ushort>.Subtractor = (x, y) => (ushort)(x - y);
                Complex<ushort>.Multiplier = (x, y) => (ushort)(x * y);
                Complex<ushort>.Divider = (x, y) => (ushort)(x / y);
            }
            else if (tvalue_type == typeof(int))
            {
                Complex<int>.Adder = (x, y) => (int)(x + y);
                Complex<int>.Subtractor = (x, y) => (int)(x - y);
                Complex<int>.Multiplier = (x, y) => (int)(x * y);
                Complex<int>.Divider = (x, y) => (int)(x / y);
            }
            else if (tvalue_type == typeof(uint))
            {
                Complex<uint>.Adder = (x, y) => (uint)(x + y);
                Complex<uint>.Subtractor = (x, y) => (uint)(x - y);
                Complex<uint>.Multiplier = (x, y) => (uint)(x * y);
                Complex<uint>.Divider = (x, y) => (uint)(x / y);
            }
            else if (tvalue_type == typeof(long))
            {
                Complex<long>.Adder = (x, y) => (long)(x + y);
                Complex<long>.Subtractor = (x, y) => (long)(x - y);
                Complex<long>.Multiplier = (x, y) => (long)(x * y);
                Complex<long>.Divider = (x, y) => (long)(x / y);
            }
            else if (tvalue_type == typeof(ulong))
            {
                Complex<ulong>.Adder = (x, y) => (ulong)(x + y);
                Complex<ulong>.Subtractor = (x, y) => (ulong)(x - y);
                Complex<ulong>.Multiplier = (x, y) => (ulong)(x * y);
                Complex<ulong>.Divider = (x, y) => (ulong)(x / y);
            }
            else if (tvalue_type == typeof(float))
            {
                Complex<float>.Adder = (x, y) => (float)(x + y);
                Complex<float>.Subtractor = (x, y) => (float)(x - y);
                Complex<float>.Multiplier = (x, y) => (float)(x * y);
                Complex<float>.Divider = (x, y) => (float)(x / y);
            }
            else if (tvalue_type == typeof(double))
            {
                Complex<double>.Adder = (x, y) => (double)(x + y);
                Complex<double>.Subtractor = (x, y) => (double)(x - y);
                Complex<double>.Multiplier = (x, y) => (double)(x * y);
                Complex<double>.Divider = (x, y) => (double)(x / y);
            }
            else if (tvalue_type == typeof(decimal))
            {
                Complex<decimal>.Adder = (x, y) => (decimal)(x + y);
                Complex<decimal>.Subtractor = (x, y) => (decimal)(x - y);
                Complex<decimal>.Multiplier = (x, y) => (decimal)(x * y);
                Complex<decimal>.Divider = (x, y) => (decimal)(x / y);
            }
            else
            {
                throw new NotSupportedException();
            }
        }

        private static Func<TValue, TValue, TValue> Adder { get; set; }
        private static Func<TValue, TValue, TValue> Subtractor { get; set; }
        private static Func<TValue, TValue, TValue> Multiplier { get; set; }
        private static Func<TValue, TValue, TValue> Divider { get; set; }

        public override string ToString()
        {
            return String.Format("({0}) + ({1})i", Real.ToString(), Imaginary.ToString());
        }
    }

    class Program
    {
        static void Main(string[] args)
        {
            #region +
            Console.WriteLine((new Complex<sbyte> { Real = 1, Imaginary = 1 } + new Complex<sbyte> { Real = 1, Imaginary = 2 }).ToString());
            Console.WriteLine((new Complex<byte> { Real = 1, Imaginary = 1 } + new Complex<byte> { Real = 1, Imaginary = 2 }).ToString());
            Console.WriteLine((new Complex<short> { Real = 1, Imaginary = 1 } + new Complex<short> { Real = 1, Imaginary = 2 }).ToString());
            Console.WriteLine((new Complex<ushort> { Real = 1, Imaginary = 1 } + new Complex<ushort> { Real = 1, Imaginary = 2 }).ToString());
            Console.WriteLine((new Complex<int> { Real = 1, Imaginary = 1 } + new Complex<int> { Real = 1, Imaginary = 2 }).ToString());
            Console.WriteLine((new Complex<uint> { Real = 1, Imaginary = 1 } + new Complex<uint> { Real = 1, Imaginary = 2 }).ToString());
            Console.WriteLine((new Complex<long> { Real = 1, Imaginary = 1 } + new Complex<long> { Real = 1, Imaginary = 2 }).ToString());
            Console.WriteLine((new Complex<ulong> { Real = 1, Imaginary = 1 } + new Complex<ulong> { Real = 1, Imaginary = 2 }).ToString());
            Console.WriteLine((new Complex<float> { Real = 1, Imaginary = 1 } + new Complex<float> { Real = 1, Imaginary = 2 }).ToString());
            Console.WriteLine((new Complex<double> { Real = 1, Imaginary = 1 } + new Complex<double> { Real = 1, Imaginary = 2 }).ToString());
            Console.WriteLine((new Complex<decimal> { Real = 1, Imaginary = 1 } + new Complex<decimal> { Real = 1, Imaginary = 2 }).ToString());
            #endregion
            #region -
            Console.WriteLine((new Complex<sbyte> { Real = 1, Imaginary = 1 } - new Complex<sbyte> { Real = 1, Imaginary = 2 }).ToString());
            Console.WriteLine((new Complex<byte> { Real = 1, Imaginary = 1 } - new Complex<byte> { Real = 1, Imaginary = 2 }).ToString());
            Console.WriteLine((new Complex<short> { Real = 1, Imaginary = 1 } - new Complex<short> { Real = 1, Imaginary = 2 }).ToString());
            Console.WriteLine((new Complex<ushort> { Real = 1, Imaginary = 1 } - new Complex<ushort> { Real = 1, Imaginary = 2 }).ToString());
            Console.WriteLine((new Complex<int> { Real = 1, Imaginary = 1 } - new Complex<int> { Real = 1, Imaginary = 2 }).ToString());
            Console.WriteLine((new Complex<uint> { Real = 1, Imaginary = 1 } - new Complex<uint> { Real = 1, Imaginary = 2 }).ToString());
            Console.WriteLine((new Complex<long> { Real = 1, Imaginary = 1 } - new Complex<long> { Real = 1, Imaginary = 2 }).ToString());
            Console.WriteLine((new Complex<ulong> { Real = 1, Imaginary = 1 } - new Complex<ulong> { Real = 1, Imaginary = 2 }).ToString());
            Console.WriteLine((new Complex<float> { Real = 1, Imaginary = 1 } - new Complex<float> { Real = 1, Imaginary = 2 }).ToString());
            Console.WriteLine((new Complex<double> { Real = 1, Imaginary = 1 } - new Complex<double> { Real = 1, Imaginary = 2 }).ToString());
            Console.WriteLine((new Complex<decimal> { Real = 1, Imaginary = 1 } - new Complex<decimal> { Real = 1, Imaginary = 2 }).ToString());
            #endregion
            #region *
            Console.WriteLine((new Complex<sbyte> { Real = 1, Imaginary = 1 } * new Complex<sbyte> { Real = 1, Imaginary = 2 }).ToString());
            Console.WriteLine((new Complex<byte> { Real = 1, Imaginary = 1 } * new Complex<byte> { Real = 1, Imaginary = 2 }).ToString());
            Console.WriteLine((new Complex<short> { Real = 1, Imaginary = 1 } * new Complex<short> { Real = 1, Imaginary = 2 }).ToString());
            Console.WriteLine((new Complex<ushort> { Real = 1, Imaginary = 1 } * new Complex<ushort> { Real = 1, Imaginary = 2 }).ToString());
            Console.WriteLine((new Complex<int> { Real = 1, Imaginary = 1 } * new Complex<int> { Real = 1, Imaginary = 2 }).ToString());
            Console.WriteLine((new Complex<uint> { Real = 1, Imaginary = 1 } * new Complex<uint> { Real = 1, Imaginary = 2 }).ToString());
            Console.WriteLine((new Complex<long> { Real = 1, Imaginary = 1 } * new Complex<long> { Real = 1, Imaginary = 2 }).ToString());
            Console.WriteLine((new Complex<ulong> { Real = 1, Imaginary = 1 } * new Complex<ulong> { Real = 1, Imaginary = 2 }).ToString());
            Console.WriteLine((new Complex<float> { Real = 1, Imaginary = 1 } * new Complex<float> { Real = 1, Imaginary = 2 }).ToString());
            Console.WriteLine((new Complex<double> { Real = 1, Imaginary = 1 } * new Complex<double> { Real = 1, Imaginary = 2 }).ToString());
            Console.WriteLine((new Complex<decimal> { Real = 1, Imaginary = 1 } * new Complex<decimal> { Real = 1, Imaginary = 2 }).ToString());
            #endregion
            #region /
            Console.WriteLine((new Complex<sbyte> { Real = 1, Imaginary = 1 } / new Complex<sbyte> { Real = 1, Imaginary = 2 }).ToString());
            Console.WriteLine((new Complex<byte> { Real = 1, Imaginary = 1 } / new Complex<byte> { Real = 1, Imaginary = 2 }).ToString());
            Console.WriteLine((new Complex<short> { Real = 1, Imaginary = 1 } / new Complex<short> { Real = 1, Imaginary = 2 }).ToString());
            Console.WriteLine((new Complex<ushort> { Real = 1, Imaginary = 1 } / new Complex<ushort> { Real = 1, Imaginary = 2 }).ToString());
            Console.WriteLine((new Complex<int> { Real = 1, Imaginary = 1 } / new Complex<int> { Real = 1, Imaginary = 2 }).ToString());
            Console.WriteLine((new Complex<uint> { Real = 1, Imaginary = 1 } / new Complex<uint> { Real = 1, Imaginary = 2 }).ToString());
            Console.WriteLine((new Complex<long> { Real = 1, Imaginary = 1 } / new Complex<long> { Real = 1, Imaginary = 2 }).ToString());
            Console.WriteLine((new Complex<ulong> { Real = 1, Imaginary = 1 } / new Complex<ulong> { Real = 1, Imaginary = 2 }).ToString());
            Console.WriteLine((new Complex<float> { Real = 1, Imaginary = 1 } / new Complex<float> { Real = 1, Imaginary = 2 }).ToString());
            Console.WriteLine((new Complex<double> { Real = 1, Imaginary = 1 } / new Complex<double> { Real = 1, Imaginary = 2 }).ToString());
            Console.WriteLine((new Complex<decimal> { Real = 1, Imaginary = 1 } / new Complex<decimal> { Real = 1, Imaginary = 2 }).ToString());
            #endregion
        }
    }
}

ちなみに、string でも Adder だけは定義可能なので、επιστημη氏の「あらあらあら」も C# で可能。

[C#] ジェネリック＋型情報で頑張る「文字列→値」変換

T.Hirase — Fri, 23 Jan 2009 10:20:00 GMT

Ｒ・田中一郎さんの「またジェネリックで挫折」しないように、ジェネリック＋型情報で頑張る日記。

namespace Sample
{
    using System;
    using System.ComponentModel;
    using System.Diagnostics;

    static class Program
    {
        static void Main(string[] args)
        {
            var value = ToNumeric<Decimal>("10.2");
            Console.WriteLine(value);
        }

        static public T ToNumeric<T>(string value)
        {
            if (value == null) return default(T);

            if (String.IsNullOrEmpty(value)) return default(T);

            try
            {
                var converter = GetNumericConverter<T>();
                if (converter != null && converter.CanConvertFrom(typeof(String)))
                {
                    return (T)converter.ConvertFromString(value);
                }
            }
            catch (Exception e)  // Exception を捕りたくないんだけど、他に方法がない。
            {
                Debug.WriteLine(e.Message);
            }
            return default(T);
        }

        static BaseNumberConverter GetNumericConverter<T>()
        {
            Type typeInfo = typeof(T);

            if (typeInfo == typeof(Byte)) return new ByteConverter();
            if (typeInfo == typeof(Decimal)) return new DecimalConverter();
            if (typeInfo == typeof(Double)) return new DoubleConverter();
            if (typeInfo == typeof(Int16)) return new Int16Converter();
            if (typeInfo == typeof(Int32)) return new Int32Converter();
            if (typeInfo == typeof(Int64)) return new Int64Converter();
            if (typeInfo == typeof(SByte)) return new SByteConverter();
            if (typeInfo == typeof(Single)) return new SingleConverter();
            if (typeInfo == typeof(UInt16)) return new UInt32Converter();
            if (typeInfo == typeof(UInt32)) return new UInt32Converter();
            if (typeInfo == typeof(UInt64)) return new UInt32Converter();

            return null;
        }
    }
}

仕事のブログ更新

T.Hirase — Tue, 09 Dec 2008 09:35:00 GMT

こんなの書きました↓

CRIチャンネル「ミドルウェアにしてミドルウェアにあらず。」。

よろしくどうぞ。

[C#] カスタムコントロールをローカライズできないのは何故？

T.Hirase — Sun, 23 Nov 2008 14:43:00 GMT

最近作ったとあるカスタムコントロールを Windows Form に貼ったときに、なぜか Windows Form の Localizable プロパティを操作できなくなっていました。現象は以下の通り。

Localizable プロパティを操作したときに「プロパティの値が無効です」ダイアログが出る。
そのダイアログの詳細には「オブジェクト参照がオブジェクトインスタンスに設定されていません。」と出る。
Localizable プロパティの値が True から False に変わる場合でも、False から True に変わる場合でも現象は同じ。
件のカスタムコントロールを外せば、Localizable プロパティを操作できる。
この現象が起きているとき、ビルドした際にはローカライズ済みリソースが出力されない。（もちろん Localizable プロパティが True になっている。）
カスタムコントロール内には null ポインタを逆参照しているようなプロパティもない。（そんなのあったら、Localizable 云々の前に発見できるはず。）

ところで。

Localizable プロパティはどこにある？

このデバッグしているときに、今更気付いたのですが、System.Windows.Forms.Form.Localizable なんてプロパティは存在しません。デバッグのためにコード上で Localizable プロパティを操作しようと思ったのですが、そんなものありませんでした。Localizable プロパティと Language プロパティは、は、System.ComponentModel.Design.Serialization.CodeDomLocalizationProvider 拡張プロバイダによって提供されるプロパティでありました。

（拡張プロバイダによって追加されるプロパティで有名なのは、ToolTip のプロパティかな。）

さてさて。

何が悪さをしていたのか？

答えは、カスタムコントロールに設定していた、カスタムのデザイナ内のとあるイベントハンドラ。

いうか、これ→「方法 : デザインモードでコントロールの外観と動作を拡張する」のサンプルソース内の「changeService_ComponentChanged()」メソッド（ページ内検索してくださいね）。

void changeService_ComponentChanged(object sender, ComponentChangedEventArgs e)
{
    if (object.ReferenceEquals(
        e.Component, 
        this.relatedControl))
    {
        if (e.Member.Name == "Margin" ||
            e.Member.Name == "Padding" )
        {
            this.marginAndPaddingAdorner.Invalidate();
        }
    }
}

ここの、イベントソース ComponentChangedEventArgs のプロパティ Member が null でした。

えぇ・・。所詮はサンプルソースということなのですね。

[C#] スタティックなメンバは、そのクラスが始めて使われるときに初期化されるという誤解でハマった８月のある日

T.Hirase — Thu, 02 Oct 2008 22:28:00 GMT

C# にて、「スタティックなメンバは、そのクラスが始めて使われるときに初期化されるという誤解」をしていたという、ある自分のある８月の話。

次のようなコードで、不思議なことが起こります。

using System;
using System.Windows.Forms;

public class MyForm : Form
{
    private MyForm()
    {
        MessageBox.Show("Called \"MyForm.MyForm()\"");
    }

    static MyForm defaultForm = new MyForm();
    public static MyForm Default
    {
        get { return defaultForm; }
    }
}

static class Program
{
    [STAThread]
    static void Main()
    {
        Application.EnableVisualStyles();
        Application.SetCompatibleTextRenderingDefault(false);

        MessageBox.Show("Do \"Application.Run(MyForm.Default);\"");
        Application.Run(MyForm.Default);
    }
}

スタティックなメンバの初期化タイミングに関する罠

上記のコードで、Program.Main() 中の Application.SetCompatibleTextRenderingDefault(false); ですが、このメソッドは、Form の初期化前に呼ぶ必要があります。Form を初期化してから呼び出すと、以下のような例外が起こります。

System.InvalidOperationException はハンドルされませんでした。
  Message="最初の IWin32Window オブジェクトがアプリケーションで作成される前に、SetCompatibleTextRenderingDefault が呼び出されなければなりません。"
  Source="System.Windows.Forms"
  StackTrace:
       場所 System.Windows.Forms.Application.SetCompatibleTextRenderingDefault(Boolean defaultValue)
       場所 Program.Main() 場所 D:\CodeGagdet\TestStaticClass\TestStaticClass\Program.cs:行 25
       場所 System.AppDomain._nExecuteAssembly(Assembly assembly, String[] args)
       場所 System.AppDomain.ExecuteAssembly(String assemblyFile, Evidence assemblySecurity, String[] args)
       場所 Microsoft.VisualStudio.HostingProcess.HostProc.RunUsersAssembly()
       場所 System.Threading.ThreadHelper.ThreadStart_Context(Object state)
       場所 System.Threading.ExecutionContext.Run(ExecutionContext executionContext, ContextCallback callback, Object state)
       場所 System.Threading.ThreadHelper.ThreadStart()
  InnerException:

上記のコードでも、きちんとこの順番を守って呼び出している「つもり」です。

しかし、よく見ると、MyForm は自身のインスタンスをスタティックメンバー defaultForm として持っています。

この defaultForm の初期化は、「MyForm が初めて使用される Application.Run() 時に行われる」ものだと思っていたら痛い目にあいました。。

実行条件によって変わるスタティックメンバーの初期化タイミング

実は、スタティックなメンバーの初期化タイミングは、実行条件によって変わっていました。

Debugビルド + デバッグあり実行: 初めて MyForm が使用される MyForm.Defaul プロパティの呼び出し直前。
Debugビルド + デバッグなし実行: 同上
Releaseビルド + デバッグあり実行: 同上
Releaseビルド + デバッグなし実行: Program.Main関数に入ったとき。あるいは、その直前。

４つ目のケース「Releaseビルド + デバッグなし実行」では、defaultForm が Application.SetCompatibleTextRenderingDefault() より手前で初期化されます。

これでは、先に挙げた例外 InvalidOperationException が発生します。

もちろん、上手くいく系もあるでしょうし、逆に Debug モードでだって上手くいかない系もあるかと思います。

解決方法（追記＠2008-10-03）

    static MyForm defaultForm;
    public static MyForm Default
    {
        get
        {
            if (defaultForm == null)
                defaultForm = new MyForm();
            return defaultForm;
        }
    }

スタティックなメンバーのインスタンス生成を自分が意図したタイミングまで引き伸ばしますことで解決しました。

コメント欄にもあるように、スタティックなコンストラクタを用意することでも解決するようですが、これもタイミングが本当に一定なのかがわからないという意味で、やめた方が良いでしょう。

まとめ

スタティックなメンバーの初期化は、いつ行われるかわかりません。

少なくとも初めてそのクラスが使われるまでには初期化されますが、今回のようなケースだとだいぶ痛い目に合います。

そんなこんなで、気をつけましょうね、という日記でした。

[C++/C#] インタフェースっていったい・・・？

T.Hirase — Mon, 14 Jul 2008 22:00:00 GMT

C++0xのコンセプトの話

アキラさんのC++0xの資料を拝見して、コンセプトって、なんでインタフェースっていう名前にならなかったのか疑問に思ったのは自分だけ？

だって、インタフェースと機能は同じで、しばりが少ないってだけな印象なのに。。同じダックタイピングなのに。

いうなれば、コンセプトがインタフェースらしく振舞うのであれば、それは最早インタフェースだと思う。

C#のインタフェースの話

なんで継承/実装していないとキャストできないのか不思議。明示的に継承していない場合でも、関係なしにダウンキャストできていいと思うのですが。。

こんな感じ↓

using System;
interface IMyMeMine
{
    void Hello();
}

class SayHello
{
    public void Hello() { Console.WriteLine("Hello"); }
}

class Program
{
    static void Main(String[] args)
    {
        Hello(new SayHello());
    }

    static void Hello<T>(T t) where T:IMyMeMine
    {
        t.Hello();
    }
}

たとえばシステムのクラスをジェネリックに扱いたい場合に、ときどきやりたい。

C#