嘗試從ExpandoObject獲取動態提示時出現「System.StackOverflowException」錯誤

Question

我在工作中遇到了一個奇怪的錯誤，它發生在我嘗試訪問特殊類的特殊方法中的動態屬性時。經過研究，我發現了那個問題的代碼，但我仍然不知道爲什麼。

這裏是我的代碼（我使用.NET 4.5）

public class MyCommand<TResult> 
    : Command<MyCommand<TResult>> 
    where TResult : class 
{ 
} 

public class MyDacAction : DacActionBase<MyDacAction, MyCommand<string>> 
{ 
    public override void Execute() 
    { 
     dynamic x = new System.Dynamic.ExpandoObject(); 
     x.AAA = 100; 
     int b = x.AAA; 
    } 
} 

public abstract class DacActionBase<TCommand, TDacCommand> 
    where TCommand : class 
    where TDacCommand : class, new() 
{ 
    public virtual void Execute() 
    { 

    } 
} 

public abstract class Command<TCommand> 
    : CommandBase<TCommand> 
    where TCommand : class 
{ 
    public virtual void Execute() 
    { 
    } 
} 

public abstract class CommandBase<TCommand> where TCommand : class 
{ 
} 

class Program 
{ 
    static void Main(string[] args) 
    { 
     var test = new MyDacAction(); 
     test.Execute(); 
    } 
} 

如果創建一個控制檯應用程序，並運行此代碼，你會看到StackOverflowException在該行

int b = x.AAA; 

當測試，我發現兩個變化，錯誤不會丟棄

1.

public class MyCommand 
    : Command<MyCommand> 
{ 
} 

public class MyDacAction : DacActionBase<MyDacAction, MyCommand> 
{ 
    public override void Execute() 
    { 
     dynamic x = new System.Dynamic.ExpandoObject(); 
     x.AAA = 100; 
     int b = x.AAA; 
    } 
} 

2.

public abstract class Command<TCommand> 
    where TCommand : class 
{ 
    public virtual void Execute() 
    { 
    } 
} 

你能告訴我爲什麼發生這個錯誤？

Answer 1

有一個開放問題#7527在CoreFX庫

動態類型解析進入無限遞歸

具有以下repro.txt此錯誤。

namespace SOE2 
{ 
    class Program 
    { 
     static void Main(string[] args) 
     { 
      // vvv--- changing "dynamic" to "var" or "string" here fixes the issue 
      dynamic parsedDocument = ""; 

      var mystery = new FailingClass<string>(); 

      Console.WriteLine("Entering..."); 
      mystery.FailingMethod(parsedDocument); 
      Console.WriteLine("... and we are back!"); 
      Console.ReadLine(); 
     } 
    } 

    public abstract class CommonBase<T> 
    { 
    } 

    // Technically, this class does nothing and deriving from it should be identical to deriving from CommonBase 
    public abstract class FailingClassBase<T> : CommonBase<T> 
    { 
    } 

    // However, deriving from CommonBase instead of FailingClassBase here also fixes the issue 
    // ----------------------------vvvvvvvvvvvvvvvv 
    public class FailingClass<T> : FailingClassBase<FailingClass<T>> 
    { 
     public void FailingMethod(T src) 
     { 
     } 
    } 
}