Почему рекурсивный вызов конструктора делает недопустимым компиляцию кода C#?

Я думаю, потому что спецификация языка только исключает прямой вызов того же конструктора, который определяется.

от 10.11.1:

все конструкторы экземпляров (кроме конструкторов класса object) неявно включает вызов другого конструктора экземпляра непосредственно перед телом конструктора. Конструктор для неявного вызова определяется конструктор-инициализатор

...

• инициализатор конструктора экземпляра формы this(argument-listopt) вызывает конструктор экземпляра из самого класса для вызова ... Если объявление конструктора экземпляра содержит инициализатор конструктора, который вызывает сам конструктор, возникает ошибка времени компиляции

это последнее предложение, кажется, только исключите прямой вызов себя как производящий ошибку времени компиляции, например

Foo() : this() {}

является незаконным.

---

Я признаю, хотя я не вижу особых причин за то, что он. Конечно, на уровне IL такие конструкции разрешены, потому что во время выполнения могут быть выбраны разные конструкторы экземпляров, я считаю, что вы могли бы иметь рекурсию, если она завершается.

---

Я думаю, что другая причина, по которой он не помечает или предупреждает об этом, заключается в том, что он имеет не надо найти этой ситуации. Представьте себе гонку через сотни различных конструкторов, просто чтобы увидеть, если цикл тут exist-когда любая попытка использования будет быстро (как мы знаем) взорваться во время выполнения, для довольно крайнего случая.

когда он делает генерацию кода для каждого конструктора, все, что он считает constructor-initializer, инициализаторы полей и тело конструктора - он не учитывает никакого другого кода:

• если constructor-initializer является конструктором экземпляра для самого класса, он не испускает инициализаторы поля-он испускает constructor-initializer звонок, а затем тело.

• если constructor-initializer является конструктором экземпляра для прямого базового класса, он выдает инициализаторы полей, а затем constructor-initializer звонок, а затем тело.

ни в одном случае не нужно искать в другом месте - так что это не тот случай, когда он "не может" решить, где разместить поле инициализаторы-это просто следование некоторым простым правилам, которые учитывают только текущий конструктор.

ваш пример

class Foo
{
    int a = 42;

    Foo() :this(60)  { }
    Foo(int v)       { }
}

будет работать нормально, в том смысле, что вы можете создать экземпляр этого объекта Foo без проблем. Однако следующее будет больше похоже на код, о котором вы спрашиваете

class Foo
{
    int a = 42;

    Foo() :this(60)     { }
    Foo(int v) : this() { }
}

и это, и ваш код создадут stackoverflow (!), потому что рекурсия никогда не достигает дна. Поэтому ваш код игнорируется, потому что он никогда не выполняется.

другими словами, компилятор не может решить, куда поместить неисправный код, потому что он могу сказать,что рекурсия никогда не заканчивается. Я думаю, это потому, что он должен поместить его туда, где он будет вызываться только один раз, но рекурсивная природа конструкторов делает это невозможным.

рекурсия в смысле конструктора, создающего экземпляры самого себя в теле конструктора имеет смысл для меня, потому что, например, может быть использован для создания деревьев, где каждый узел указывает на другие узлы. Но рекурсия через предварительно конструкторы подобного проиллюстрированный этим вопросом никогда не может опуститься, поэтому для меня было бы разумно, если бы это было запрещено.

Я думаю, что это разрешено, потому что вы можете (могли) все еще поймать исключение и сделать что-то значимое с ним.

инициализация никогда не будет запущена, и она почти наверняка вызовет исключение StackOverflowException. Но это все еще может быть желаемым поведением, и не всегда означает, что процесс должен рухнуть.

как объяснено здесь https://stackoverflow.com/a/1599236/869482