Вложенные классы .NET
Текущая библиотека классов, над которой я работаю, будет иметь базовый класс (Field) с более чем 50 конкретными типами «полей», которые будут унаследованы от «Field» и вложены для обеспечения удобочитаемости. Например...
abstract class Field
{
public int Length { get; set; }
public class FieldA : Field
{
public static void DoSomething()
{
Console.WriteLine("Did something.");
}
}
}
Пока все выглядит хорошо, и я могу использовать код, как показано:
class Program
{
static void Main(string[] args)
{
Field.FieldA.DoSomething();
}
}
Однако почему это тоже работает? Что здесь происходит, что позволяет компилятору / IDE intellisense продолжать связывать эти "FieldA"?
class Program
{
static void Main(string[] args)
{
Field.FieldA.FieldA.FieldA.FieldA.FieldA.FieldA.FieldA.DoSomething();
}
}
Это ни в коем случае не нарушение работы приложения, но подумал, что это странно. То же самое делает в Boo (это фактический язык, используемый для библиотеки).
Ваш подход является разумным, особенно если вы хотите контролировать, кто может наследовать: сделайте базовый конструктор закрытым, и только вложенные типы могут наследовать от него. Я использую нечто подобное, когда пытаюсь смоделировать поведение enum с более богатой семантикой OO.
напоминает мне "луна учит студента"
Очевидная логическая оплошность с моей стороны. Спасибо за ответы.
Внутренний конструктор также ограничивает тех, кто может наследовать от него ...
Ответы 3
Похоже, вы хотели чего-то вроде:
abstract class Field
{
public int Length { get; set; }
}
public class FieldA : Field
{
public static void DoSomething()
{
Console.WriteLine("Did something.");
}
}
В противном случае вы определяете базовый класс с внутренним классом в нем, который также получат наследники. Итак, когда вы наследуете от внешнего класса, чтобы создать внутренний класс, вы запускаете цикл.
Это то, чего я боялся. Думаю, мне придется найти другой способ размещения моих классов. Спасибо за ответ.
Fieldимеет вложенный класс общественный с именемFieldAFieldAнаследуется отField- таким образом, вы всегда можете получить доступ к
FieldAизFieldA.
Ссылка не создает бесконечные цепочки, она просто указывает на один и тот же класс. (какой-то тестовый код)
Когда вы получаете доступ к FieldA.FieldA, последний FieldA доступен из-за того, что первый FieldA является экземпляром Field, поэтому последний FieldA фактически обращается к Field.FieldA.
FieldA наследует ссылку на класс FieldA, который наследует ссылку на класс FieldA, который наследует ссылку на класс FieldA, который наследует ссылку на класс FieldA, который наследует ссылку на класс FieldA, который наследует ссылку на класс FieldA, который наследует ссылку на класс FieldA, который ...
Работает потому что это то, что вы сказали ему делать.
Лол, это действительно круто. Пришлось проверить это на себе, чтобы поверить в это: p