C＃または.NETで見た最も奇妙なコーナーケースは何ですか？[閉まっている]

私はいくつかのコーナーケースと頭の体操を集めており、いつももっと聞きたいです。このページでは、C＃言語のビットとボブだけを取り上げていますが、.NETのコアなことも興味深いものです。たとえば、こちらはページにはありませんが、信じられないようなものです。

string x = new string(new char[0]);
string y = new string(new char[0]);
Console.WriteLine(object.ReferenceEquals(x, y));

私はそれがFalseを出力することを期待します-結局のところ、「新規」（参照タイプを伴う）は常に新しいオブジェクトを作成しますね？C＃とCLIの両方の仕様は、そうすべきであると示しています。まあ、この特定のケースではありません。Trueを出力し、私がテストしたフレームワークのすべてのバージョンで実行しました。（確かに私はMonoで試したことはありません...）

明確にするために、これは私が探している種類の例にすぎません。この奇妙な点についての議論や説明は特に探していませんでした。（通常の文字列インターンと同じではありません。特に、コンストラクターが呼び出されたときに文字列インターンは通常発生しません。）私は、同様の奇妙な動作を本当に求めていました。

そこに潜んでいる他の宝石はありますか？

私は以前にこれをお見せしたと思いますが、私はここの楽しみが好きです-これは追跡するためにデバッグが必要でした！（元のコードは明らかにより複雑で微妙でした...）

    static void Foo<T>() where T : new()
    {
        T t = new T();
        Console.WriteLine(t.ToString()); // works fine
        Console.WriteLine(t.GetHashCode()); // works fine
        Console.WriteLine(t.Equals(t)); // works fine

        // so it looks like an object and smells like an object...

        // but this throws a NullReferenceException...
        Console.WriteLine(t.GetType());
    }

それで、Tは何でしたか...

回答：任意Nullable<T>-などint?。取得できないGetType（）を除いて、すべてのメソッドがオーバーライドされます。したがって、オブジェクトにキャスト（ボックス化）され（したがってnullに）、object.GetType（）...を呼び出してnullを呼び出します;-p

アップデート：プロット濃く... Ayende Rahienが投げた彼のブログ上で同様の課題を、しかしとwhere T : class, new()：

private static void Main() {
    CanThisHappen<MyFunnyType>();
}

public static void CanThisHappen<T>() where T : class, new() {
    var instance = new T(); // new() on a ref-type; should be non-null, then
    Debug.Assert(instance != null, "How did we break the CLR?");
}

しかし、それは敗北することができます！リモーティングなどで使用されるのと同じ間接参照を使用します。警告-以下は純粋な悪です：

class MyFunnyProxyAttribute : ProxyAttribute {
    public override MarshalByRefObject CreateInstance(Type serverType) {
        return null;
    }
}
[MyFunnyProxy]
class MyFunnyType : ContextBoundObject { }

これを実行するnew()と、呼び出しはプロキシ（MyFunnyProxyAttribute）にリダイレクトされ、プロキシが戻りますnull。さあ、目を洗ってください！

銀行家の丸め。

これはそれほどコンパイラのバグや誤動作ではありませんが、奇妙なコーナーケースです...

.Net Frameworkは、バンカーの丸めと呼ばれるスキームまたは丸めを採用しています。

Bankers 'Roundingでは、0.5の数値は最も近い偶数に丸められるため、

Math.Round(-0.5) == 0
Math.Round(0.5) == 0
Math.Round(1.5) == 2
Math.Round(2.5) == 2
etc...

これにより、よく知られた端数切り上げに基づく財務計算で予期しないバグが発生する可能性があります。

これはVisual Basicにも当てはまります。

Rec(0)（デバッガの下ではなく）として呼び出された場合、この関数は何をしますか？

static void Rec(int i)
{
    Console.WriteLine(i);
    if (i < int.MaxValue)
    {
        Rec(i + 1);
    }
}

回答：

• 32ビットJITでは、StackOverflowExceptionが発生します。
• 64ビットJITでは、すべての数値をint.MaxValueに出力する必要があります

これは、64ビットJITコンパイラが末尾呼び出しの最適化を適用するためですに対し、32ビットJITは適用しないためです。

残念ながら、これを検証するための64ビットマシンはありませんが、この方法は末尾呼び出しの最適化のすべての条件を満たしています。誰かが持っている場合は、それが本当かどうかを確認したいと思います。

これを割り当て！

これは私がパーティーで聞きたいものです（おそらく私がもう招待されない理由です）：

次のコードをコンパイルできますか？

    public void Foo()
    {
        this = new Teaser();
    }

簡単なチートは次のようになります：

string cheat = @"
    public void Foo()
    {
        this = new Teaser();
    }
";

しかし、本当の解決策はこれです：

public struct Teaser
{
    public void Foo()
    {
        this = new Teaser();
    }
}

したがって、値の型（構造体）がthis変数を再割り当てできることは、ほとんどわかっていません。

数年前、忠誠プログラムに取り組んでいたときに、顧客に与えられるポイントの量に問題がありました。この問題は、doubleをintにキャスト/変換することに関連していました。

以下のコードで：

double d = 13.6;

int i1 = Convert.ToInt32(d);
int i2 = (int)d;

i1 == i2ですか？

i1！= i2であることがわかります。変換およびキャスト演算子の丸めポリシーが異なるため、実際の値は次のとおりです。

i1 == 14
i2 == 13

Math.Ceiling（）またはMath.Floor（）（または、要件を満たすMidpointRoundingを持つMath.Round）を呼び出す方が常に良いです。

int i1 = Convert.ToInt32( Math.Ceiling(d) );
int i2 = (int) Math.Ceiling(d);

enum関数のオーバーロードがある場合でも、0を整数にする必要があります。

0を列挙型にマッピングするためのC＃コアチームの根拠は知っていましたが、それでも、必要なほど直角ではありません。Npgsqlの例。

テスト例：

namespace Craft
{
    enum Symbol { Alpha = 1, Beta = 2, Gamma = 3, Delta = 4 };


   class Mate
    {
        static void Main(string[] args)
        {

            JustTest(Symbol.Alpha); // enum
            JustTest(0); // why enum
            JustTest((int)0); // why still enum

            int i = 0;

            JustTest(Convert.ToInt32(0)); // have to use Convert.ToInt32 to convince the compiler to make the call site use the object version

            JustTest(i); // it's ok from down here and below
            JustTest(1);
            JustTest("string");
            JustTest(Guid.NewGuid());
            JustTest(new DataTable());

            Console.ReadLine();
        }

        static void JustTest(Symbol a)
        {
            Console.WriteLine("Enum");
        }

        static void JustTest(object o)
        {
            Console.WriteLine("Object");
        }
    }
}

これは、これまでに見た中で最も珍しいものの1つです（もちろん、ここのものは別として！）：

public class Turtle<T> where T : Turtle<T>
{
}

宣言することはできますが、実際に使用することはありません。これは、中心にあるクラスを別のTurtleでラップするように常に要求するためです。

[ジョーク]カメはずっと下にいると思います... [/ジョーク]

これは私が最近知っただけのものです...

interface IFoo
{
   string Message {get;}
}
...
IFoo obj = new IFoo("abc");
Console.WriteLine(obj.Message);

上記は一見奇妙に見えますが、実際には合法です。いいえ、本当に（私は重要な部分を見逃しましたが、「クラスを追加する」や「エイリアスをポイントに追加する」などのハックではありません。IFoousingIFoo Aでクラス"）。

その理由を理解できるかどうかを確認してください。インターフェイスをインスタンス化できないと誰が言うのでしょうか。

ブール値がTrueでもFalseでもないのはいつですか？

Billは、AがTrueでBがTrueの場合、（AおよびB）がFalseになるようにブール値をハッキングできることを発見しました。

ハッキングされたブール値

パーティーに少し遅れて到着しましたが、3 つ4つ 5つあります。

1. ロードまたは表示されていないコントロールでInvokeRequiredをポーリングすると、falseと表示され、別のスレッドから変更しようとすると顔が爆破されます（解決策はこれを参照することです）。コントロール）。

2. 私をつまずかせたもう1つは、

   enum MyEnum
   {
       Red,
       Blue,
   }

   MyEnum.Red.ToString（）を別のアセンブリで計算し、その間に誰かがあなたの列挙型を次のように再コンパイルした場合：

   enum MyEnum
   {
       Black,
       Red,
       Blue,
   }

   実行時には、「黒」が表示されます。

3. 私はいくつかの便利な定数を含む共有アセンブリを使用していました。前任者は見苦しい外観のget-onlyプロパティをたくさん残していたので、煩雑さを取り除き、public constを使用すると思いました。VSが参照ではなくそれらの値にそれらをコンパイルしたとき、私は少し驚きました。

4. あなたが別のアセンブリからインターフェイスの新しいメソッドを実装していますが、そのアセンブリの古いバージョンを参照し再構築する場合、あなたがいても、（「NewMethod」のない実装）TypeLoadExceptionを取得していないしている（参照、それを実装し、ここ）。

5. 辞書<、>： "アイテムが返される順序は未定義です。" これは恐ろしいことです。時々噛まれることもありますが、他の人に働きかけることができます。そして、やみくもに辞書がうまくいくと思い込んだだけの場合（「なぜそうすべきではないのでしょうか。私は、リストがそうです」）、本当にあなたがついにあなたの仮定に疑問を持ち始める前にあなたの鼻をそれに入れてください。

VB.NET、nullable、および三項演算子：

Dim i As Integer? = If(True, Nothing, 5)

iを含めることを期待していたため、デバッグに時間がかかりましたNothing。

私は本当に何を含んでいますか？0。

これは驚くべきことですが、実際には「正しい」動作ですNothing。VB.NETの場合null、CLRの場合とまったく同じではありません。コンテキストに応じて、値の型をNothing意味するnull場合もあれdefault(T)ば、値の場合Tもあります。上記の場合、およびの一般的なタイプとしてIf推論Integerします。したがって、この場合、はを意味します。Nothing5Nothing0

ロングショットで最初のコーナーケースに勝る2番目の本当に奇妙なコーナーケースを見つけました。

String.Equalsメソッド（String、String、StringComparison）は、実際には副作用がありません。

私はそれをいくつかの関数の先頭にある行に単独で持っているコードのブロックに取り組んでいました：

stringvariable1.Equals(stringvariable2, StringComparison.InvariantCultureIgnoreCase);

その行を削除すると、プログラムの他の場所でスタックオーバーフローが発生します。

そのコードは、BeforeAssemblyLoadイベントに本質的に対応するハンドラーをインストールし、実行しようとしていることがわかりました

if (assemblyfilename.EndsWith("someparticular.dll", StringComparison.InvariantCultureIgnoreCase))
{
    assemblyfilename = "someparticular_modified.dll";
}

今までに言う必要はありません。文字列比較で以前に使用されていないカルチャを使用すると、アセンブリの負荷が発生します。InvariantCultureも例外ではありません。

これは、エラーメッセージ「保護されたメモリの読み取りまたは書き込みを試みました。多くの場合、他のメモリが破損していることを示しています」を生成する構造体を作成する方法の例です。成功と失敗の違いは非常に微妙です。

次の単体テストは、問題を示しています。

何がうまくいかなかったかを調べてみてください。

    [Test]
    public void Test()
    {
        var bar = new MyClass
        {
            Foo = 500
        };
        bar.Foo += 500;

        Assert.That(bar.Foo.Value.Amount, Is.EqualTo(1000));
    }

    private class MyClass
    {
        public MyStruct? Foo { get; set; }
    }

    private struct MyStruct
    {
        public decimal Amount { get; private set; }

        public MyStruct(decimal amount) : this()
        {
            Amount = amount;
        }

        public static MyStruct operator +(MyStruct x, MyStruct y)
        {
            return new MyStruct(x.Amount + y.Amount);
        }

        public static MyStruct operator +(MyStruct x, decimal y)
        {
            return new MyStruct(x.Amount + y);
        }

        public static implicit operator MyStruct(int value)
        {
            return new MyStruct(value);
        }

        public static implicit operator MyStruct(decimal value)
        {
            return new MyStruct(value);
        }
    }

C＃は、配列が多次元でなく、型間に継承関係があり、型が参照型である限り、配列とリスト間の変換をサポートします

object[] oArray = new string[] { "one", "two", "three" };
string[] sArray = (string[])oArray;

// Also works for IList (and IEnumerable, ICollection)
IList<string> sList = (IList<string>)oArray;
IList<object> oList = new string[] { "one", "two", "three" };

これは機能しないことに注意してください：

object[] oArray2 = new int[] { 1, 2, 3 }; // Error: Cannot implicitly convert type 'int[]' to 'object[]'
int[] iArray = (int[])oArray2;            // Error: Cannot convert type 'object[]' to 'int[]'

これは私が偶然に遭遇した中で最も奇妙なものです。

public class DummyObject
{
    public override string ToString()
    {
        return null;
    }
}

次のように使用します。

DummyObject obj = new DummyObject();
Console.WriteLine("The text: " + obj.GetType() + " is " + obj);

をスローしNullReferenceExceptionます。C＃コンパイラによって複数の追加がコンパイルされ、が呼び出されることがわかりますString.Concat(object[])。.NET 4より前のバージョンでは、オブジェクトがnullかどうかがチェックされるが、ToString（）の結果ではないConcatのオーバーロードにバグがあります。

object obj2 = args[i];
string text = (obj2 != null) ? obj2.ToString() : string.Empty;
// if obj2 is non-null, but obj2.ToString() returns null, then text==null
int length = text.Length;

これはECMA-334§14.7.4によるバグです。

2項の+演算子は、一方または両方のオペランドがtypeの場合に文字列連結を実行しますstring。文字列連結のオペランドがの場合、null空の文字列が置換されます。それ以外の場合、文字列以外のオペランドはToString、typeから継承された仮想メソッドを呼び出すことにより、文字列表現に変換されますobject。がをToString返すnull場合、空の文字列が置換されます。

興味深い-私が最初にそれを見たとき、それはC＃コンパイラがチェックしているものだと思いましたが、干渉の可能性を取り除くためにILを直接放出したとしても、それはまだ起こりnewobjます。チェックしています。

var method = new DynamicMethod("Test", null, null);
var il = method.GetILGenerator();

il.Emit(OpCodes.Ldc_I4_0);
il.Emit(OpCodes.Newarr, typeof(char));
il.Emit(OpCodes.Newobj, typeof(string).GetConstructor(new[] { typeof(char[]) }));

il.Emit(OpCodes.Ldc_I4_0);
il.Emit(OpCodes.Newarr, typeof(char));
il.Emit(OpCodes.Newobj, typeof(string).GetConstructor(new[] { typeof(char[]) }));

il.Emit(OpCodes.Call, typeof(object).GetMethod("ReferenceEquals"));
il.Emit(OpCodes.Box, typeof(bool));
il.Emit(OpCodes.Call, typeof(Console).GetMethod("WriteLine", new[] { typeof(object) }));

il.Emit(OpCodes.Ret);

method.Invoke(null, null);

また、これtrueをチェックすることと同じですstring.Empty。つまり、このオペコードは空の文字列をインターンするために特別な動作をする必要があります。

Public Class Item
   Public ID As Guid
   Public Text As String

   Public Sub New(ByVal id As Guid, ByVal name As String)
      Me.ID = id
      Me.Text = name
   End Sub
End Class

Public Sub Load(sender As Object, e As EventArgs) Handles Me.Load
   Dim box As New ComboBox
   Me.Controls.Add(box)          'Sorry I forgot this line the first time.'
   Dim h As IntPtr = box.Handle  'Im not sure you need this but you might.'
   Try
      box.Items.Add(New Item(Guid.Empty, Nothing))
   Catch ex As Exception
      MsgBox(ex.ToString())
   End Try
End Sub

出力は、「保護されたメモリを読み取ろうとしました。これは、他のメモリが破損していることを示しています。」

PropertyInfo.SetValue（）は、intをenumに、intをnull可能intに、enumをnull可能enumに割り当てることができますが、intをnull可能enumに割り当てることはできません。

enumProperty.SetValue(obj, 1, null); //works
nullableIntProperty.SetValue(obj, 1, null); //works
nullableEnumProperty.SetValue(obj, MyEnum.Foo, null); //works
nullableEnumProperty.SetValue(obj, 1, null); // throws an exception !!!

詳細な説明はこちら

型引数によってはあいまいになる可能性のあるメソッドを持つジェネリッククラスがある場合はどうでしょうか。最近、双方向辞書を書いているこの状況に出くわしました。Get()渡された引数の反対を返す対称メソッドを書きたかったのです。このようなもの：

class TwoWayRelationship<T1, T2>
{
    public T2 Get(T1 key) { /* ... */ }
    public T1 Get(T2 key) { /* ... */ }
}

あなたは、インスタンスを作るところならばすべてがうまくいいですT1し、T2さまざまな種類のとおりです。

var r1 = new TwoWayRelationship<int, string>();
r1.Get(1);
r1.Get("a");

しかし、T1とT2が同じ場合（そしておそらく別のサブクラスである場合）は、コンパイラエラーです。

var r2 = new TwoWayRelationship<int, int>();
r2.Get(1);  // "The call is ambiguous..."

興味深いことに、2番目のケースの他のすべてのメソッドはまだ使用可能です。コンパイラエラーが発生するのは、あいまいになったメソッドの呼び出しのみです。興味深いケースですが、少し可能性が低くあいまいです。

C＃アクセシビリティパズル

次の派生クラスは、その基本クラスからプライベートフィールドにアクセスしており、コンパイラは静かに反対側を調べます。

public class Derived : Base
{
    public int BrokenAccess()
    {
        return base.m_basePrivateField;
    }
}

フィールドは確かにプライベートです：

private int m_basePrivateField = 0;

このようなコードをコンパイルするにはどうすればよいですか？

。

。

。

。

。

。

。

回答

コツはDerived、次の内部クラスとして宣言することですBase。

public class Base
{
    private int m_basePrivateField = 0;

    public class Derived : Base
    {
        public int BrokenAccess()
        {
            return base.m_basePrivateField;
        }
    }
}

内部クラスには、外部クラスメンバーへのフルアクセスが与えられます。この場合、内部クラスも偶然外部クラスから派生しています。これにより、プライベートメンバーのカプセル化を「解除」できます。

今日は素敵な小さなものを見つけました：

public class Base
{
   public virtual void Initialize(dynamic stuff) { 
   //...
   }
}
public class Derived:Base
{
   public override void Initialize(dynamic stuff) {
   base.Initialize(stuff);
   //...
   }
}

これはコンパイルエラーを投げます。

メソッド 'Initialize'の呼び出しは動的にディスパッチされる必要がありますが、ベースアクセス式の一部であるため、ディスパッチできません。動的な引数をキャストするか、ベースアクセスを削除することを検討してください。

base.Initialize（stuff as object）;と書いた場合、それは完全に機能しますが、これはここでは「魔法の言葉」のようです。まったく同じように機能するため、すべてがまだ動的として受信されます...

私たちが使用しているAPIでは、ドメインオブジェクトを返すメソッドが特別な「nullオブジェクト」を返す場合があります。この実装では、比較演算子とEquals()メソッドがオーバーライドされtrueて、nullます。

したがって、このAPIのユーザーは次のようなコードを持っている可能性があります。

return test != null ? test : GetDefault();

または、おそらく次のようにもう少し冗長です：

if (test == null)
    return GetDefault();
return test;

どこGetDefault()我々が代わりに使用したいといういくつかのデフォルト値を返す方法がありますnull。ReSharperを使用していて、次のいずれかに書き換えることをお勧めしているので、驚きに襲われました。

return test ?? GetDefault();

検査対象ではなく、適切なのAPIから返されたヌル・オブジェクトである場合はnull、コードの挙動は、現在のNULL合体演算子として、実際のチェックが変更されたnull実行していない、operator=またはEquals()。

この奇妙なケースを考えてみましょう：

public interface MyInterface {
  void Method();
}
public class Base {
  public void Method() { }
}
public class Derived : Base, MyInterface { }

BaseおよびDerivedが同じアセンブリで宣言されている場合、インターフェイスを実装していなくBase::Methodても、コンパイラーは仮想化して（CILで）シールBaseします。

場合BaseとDerived異なるアセンブリにあるコンパイルするときに、Derivedアセンブリの中で、それはメンバーを紹介しますので、コンパイラは、他のアセンブリを変更しないDerivedためにそれは明示的な実装になるMyInterface::Methodことはただの呼び出しを委任しますBase::Method。

コンパイラは、インターフェイスに関するポリモーフィックディスパッチをサポートするためにこれを行う必要があります。つまり、そのメソッドを仮想化する必要があります。

以下は、私が単に欠けていた一般的な知識かもしれませんが、ええ。少し前に、仮想プロパティを含むバグケースがありました。コンテキストを少し抽象化し、次のコードを検討して、指定した領域にブレークポイントを適用します。

class Program
{
    static void Main(string[] args)
    {
        Derived d = new Derived();
        d.Property = "AWESOME";
    }
}

class Base
{
    string _baseProp;
    public virtual string Property 
    { 
        get 
        {
            return "BASE_" + _baseProp;
        }
        set
        {
            _baseProp = value;
            //do work with the base property which might 
            //not be exposed to derived types
            //here
            Console.Out.WriteLine("_baseProp is BASE_" + value.ToString());
        }
    }
}

class Derived : Base
{
    string _prop;
    public override string Property 
    {
        get { return _prop; }
        set 
        { 
            _prop = value; 
            base.Property = value;
        } //<- put a breakpoint here then mouse over BaseProperty, 
          //   and then mouse over the base.Property call inside it.
    }

    public string BaseProperty { get { return base.Property; } private set { } }
}

しながら、Derivedオブジェクトコンテキスト、あなたは同じ動作を得ることができます追加するときbase.Property、時計、または入力としてbase.Property [クイックウォッチへ。

何が起こっているのかを理解するのに少し時間がかかりました。結局、私はクイックウォッチに啓蒙されました。クイックウォッチに移動してDerivedオブジェクトd（またはオブジェクトのコンテキストthis）を探索し、フィールドを選択するbaseと、クイックウォッチ上部の編集フィールドに次のキャストが表示されます。

((TestProject1.Base)(d))

つまり、baseがそのように置き換えられた場合、呼び出しは次のようになります。

public string BaseProperty { get { return ((TestProject1.Base)(d)).Property; } private set { } }

ウォッチ、クイックウォッチ、デバッグのマウスオーバーツールチップ"AWESOME"の"BASE_AWESOME"場合、ポリモーフィズムを考慮するときではなく、それを表示することは理にかなっています。なぜそれがキャストに変換されるのかはまだわかりcallません。1つの仮説は、これらのモジュールのコンテキストからは利用できない可能性があり、callvirt。

とにかく、それは明らかに機能の点で何も変更せず、Derived.BasePropertyそれでも本当に戻ります"BASE_AWESOME"。したがって、これは実際のバグの原因ではなく、単に混乱を招くコンポーネントです。しかし、特にBaseプロジェクトで公開されておらず、サードパーティDLLとして参照されている場合に、開発者がデバッグセッション中にその事実を知らない開発者を誤解させる可能性があることは興味深いことに気付きました。

「おーい、待って..何？DLLのようなものです。何か面白いことをしています。」

これはかなり難しいです。本当にBegin / EndInvokeをサポートするRealProxy実装を構築しようとしているときに遭遇しました（これを恐ろしいハックなしでは不可能にするMSに感謝します）。この例は基本的にCLRのバグです。BeginInvokeのアンマネージコードパスは、RealProxy.PrivateInvoke（および私のInvokeオーバーライド）からの戻りメッセージがIAsyncResultのインスタンスを返すことを検証しません。返されると、下部のテストで示されているように、CLRは信じられないほど混乱し、何が起こっているのかまったくわかりません。

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Runtime.Remoting.Proxies;
using System.Reflection;
using System.Runtime.Remoting.Messaging;

namespace BrokenProxy
{
    class NotAnIAsyncResult
    {
        public string SomeProperty { get; set; }
    }

    class BrokenProxy : RealProxy
    {
        private void HackFlags()
        {
            var flagsField = typeof(RealProxy).GetField("_flags", BindingFlags.NonPublic | BindingFlags.Instance);
            int val = (int)flagsField.GetValue(this);
            val |= 1; // 1 = RemotingProxy, check out System.Runtime.Remoting.Proxies.RealProxyFlags
            flagsField.SetValue(this, val);
        }

        public BrokenProxy(Type t)
            : base(t)
        {
            HackFlags();
        }

        public override IMessage Invoke(IMessage msg)
        {
            var naiar = new NotAnIAsyncResult();
            naiar.SomeProperty = "o noes";
            return new ReturnMessage(naiar, null, 0, null, (IMethodCallMessage)msg);
        }
    }

    interface IRandomInterface
    {
        int DoSomething();
    }

    class Program
    {
        static void Main(string[] args)
        {
            BrokenProxy bp = new BrokenProxy(typeof(IRandomInterface));
            var instance = (IRandomInterface)bp.GetTransparentProxy();
            Func<int> doSomethingDelegate = instance.DoSomething;
            IAsyncResult notAnIAsyncResult = doSomethingDelegate.BeginInvoke(null, null);

            var interfaces = notAnIAsyncResult.GetType().GetInterfaces();
            Console.WriteLine(!interfaces.Any() ? "No interfaces on notAnIAsyncResult" : "Interfaces");
            Console.WriteLine(notAnIAsyncResult is IAsyncResult); // Should be false, is it?!
            Console.WriteLine(((NotAnIAsyncResult)notAnIAsyncResult).SomeProperty);
            Console.WriteLine(((IAsyncResult)notAnIAsyncResult).IsCompleted); // No way this works.
        }
    }
}

出力：

No interfaces on notAnIAsyncResult
True
o noes

Unhandled Exception: System.EntryPointNotFoundException: Entry point was not found.
   at System.IAsyncResult.get_IsCompleted()
   at BrokenProxy.Program.Main(String[] args) 

これがWindows Vista / 7の奇妙なことなのか、.Netの奇妙なことなのかはわかりませんが、しばらく頭を悩ませていました。

string filename = @"c:\program files\my folder\test.txt";
System.IO.File.WriteAllText(filename, "Hello world.");
bool exists = System.IO.File.Exists(filename); // returns true;
string text = System.IO.File.ReadAllText(filename); // Returns "Hello world."

Windows Vista / 7では、ファイルは実際に書き込まれます C:\Users\<username>\Virtual Store\Program Files\my folder\test.txt

C＃コンパイラが無効なCILを生成する可能性があると思ったことはありませんか？これを実行すると、次のようになりますTypeLoadException。

interface I<T> {
  T M(T p);
}
abstract class A<T> : I<T> {
  public abstract T M(T p);
}
abstract class B<T> : A<T>, I<int> {
  public override T M(T p) { return p; }
  public int M(int p) { return p * 2; }
}
class C : B<int> { }

class Program {
  static void Main(string[] args) {
    Console.WriteLine(new C().M(42));
  }
}

ただし、C＃4.0コンパイラでどのように処理されるかはわかりません。

編集：これは私のシステムからの出力です：

C:\Temp>type Program.cs
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;

namespace ConsoleApplication1 {

  interface I<T> {
    T M(T p);
  }
  abstract class A<T> : I<T> {
    public abstract T M(T p);
  }
  abstract class B<T> : A<T>, I<int> {
    public override T M(T p) { return p; }
    public int M(int p) { return p * 2; }
  }
  class C : B<int> { }

  class Program {
    static void Main(string[] args) {
      Console.WriteLine(new C().M(11));
    }
  }

}
C:\Temp>csc Program.cs
Microsoft (R) Visual C# 2008 Compiler version 3.5.30729.1
for Microsoft (R) .NET Framework version 3.5
Copyright (C) Microsoft Corporation. All rights reserved.


C:\Temp>Program

Unhandled Exception: System.TypeLoadException: Could not load type 'ConsoleAppli
cation1.C' from assembly 'Program, Version=0.0.0.0, Culture=neutral, PublicKeyTo
ken=null'.
   at ConsoleApplication1.Program.Main(String[] args)

C:\Temp>peverify Program.exe

Microsoft (R) .NET Framework PE Verifier.  Version  3.5.30729.1
Copyright (c) Microsoft Corporation.  All rights reserved.

[token  0x02000005] Type load failed.
[IL]: Error: [C:\Temp\Program.exe : ConsoleApplication1.Program::Main][offset 0x
00000001] Unable to resolve token.
2 Error(s) Verifying Program.exe

C:\Temp>ver

Microsoft Windows XP [Version 5.1.2600]

C＃には、クロージャの処理方法に関して、非常にエキサイティングなものがあります。

スタック変数の値をクロージャのない変数にコピーする代わりに、プリプロセッサマジックは、変数のすべての発生をオブジェクトにラップして、スタックから直接-ヒープに移動します。:)

おそらく、C＃はML自体（AFAIKをコピーするスタック値を使用する）よりも機能的に完全な（またはラムダ完全なハフ）言語です。C＃と同様に、F＃にもその機能があります。

それは私に多くの喜びをもたらします、MSの皆さん、ありがとう！

奇妙なことではありませんが、スタックベースのVM言語からは本当に予期しないことが起こります:)

少し前に私が尋ねた質問から：

条件演算子は暗黙的にキャストできませんか？

与えられた：

Bool aBoolValue;

どこにaBoolValueTrueまたはFalseが割り当てられます。

以下はコンパイルされません：

Byte aByteValue = aBoolValue ? 1 : 0;

しかし、これは：

Int anIntValue = aBoolValue ? 1 : 0;

提供された答えもかなり良いです。

C＃でのスコープ指定は、本当に奇妙な場合があります。一例を挙げましょう。

if (true)
{
   OleDbCommand command = SQLServer.CreateCommand();
}

OleDbCommand command = SQLServer.CreateCommand();

コマンドが再宣言されているため、これはコンパイルに失敗しますか？stackoverflowのこのスレッドと私のブログで、なぜこのように機能するかについて、いくつかの興味深い推測があります。