C# - Наследование и сокрытие статических членов (пинаем ИИ)
abstract class Base { public static int _a; }
class Derived : Base { public static int _a; }
Копилот пишет, что _a в унаследованном классе лучше определить через new, и что об этом напишет компилятор в предупреждении. Я у него спросил, а если _a не публичное поле? Копилот сказал, что неважно - всё равно лучше через new. Я говорю, что если _a приватное, то new не надо, и компилятор не просит. Тогда Копилот согласился. Т.е. лучше так
abstract class Base { public static int _a; }
class Derived : Base { new public static int _a; }
но можно и так
abstract class Base { static int _a; }
class Derived : Base { static int _a; }
За этими ИИ глаз да глаз нужен. А если вы не гура языка программирования, и не знаете таких тонкостей, то он вас легко облапошит.
Когда вы уже научитесь спрашивать правильные вещи у правильных систем?
Модификатор new нужен только тогда, когда базовый член виден в производном классе. Если Base._a объявлен как private, компилятор его в Derived просто не видит, поэтому никакого сокрытия (и предупреждения CS0108) не возникает. В этом случае new не просто «не нужен», а вызовет ошибку компиляции (CS0106). Copilot сначала дал обобщённый совет, но после вашего уточнения исправился — это классический случай, когда LLM выдают «среднее по больнице» без учёта правил видимости в конкретном языке.
📖 Техническое пояснение (почему так работает в C#)
- Статические члены не наследуются в смысле полиморфизма. Они принадлежат конкретному типу. Когда вы пишете
Derived._a, компилятор сначала ищет член вDerived, и только если его нет — поднимается кBase. - Предупреждение
CS0108('Derived._a' hides inherited member 'Base._a'. Use the new keyword if hiding was intended.) возникает только при сокрытии доступного члена. Доступность =public,protectedилиinternal(в пределах видимости сборки). - Если
Base._a—private, он не входит в область видимостиDerived. С точки зрения языка вы не скрываете существующий член, а объявляете совершенно новый. Поэтому:- Компилятор не требует
new. - Написать
new static int _a;в этом случае нельзя → ошибкаCS0106: The modifier 'new' is not valid for this item.
- Компилятор не требует
- Разница в поведении:
abstract class Base { public static int _a; } class Derived : Base { public static int _a; } // ⚠️ CS0108, нужно newabstract class Base { private static int _a; } class Derived : Base { static int _a; } // ✅ Чисто, без предупреждений
💡 Архитектурная рекомендация
Сокрытие статических членов (new static ...) в C# считается антипаттерном:
- Статика не поддерживает полиморфизм,
virtual/overrideдля неё невозможен. - Вызов
Base._aиDerived._aвсегда обращается к разным ячейкам памяти, что легко приводит к рассинхрону состояния. - Если нужна вариативность, используйте инстанс-члены с
virtual/override, паттерн «Стратегия», или выносите конфигурацию в отдельные статические классы/регистры.
🤖 Про поведение Copilot
ИИ часто тренируется на обобщённых формулировках вроде «при совпадении имён используйте new», но не всегда проверяет контекст видимости. Ваш метод «пинания» (задание уточняющих условий) — ровно тот способ, который заставляет модель скорректировать ответ под спецификацию языка. В данном случае вы правы на 100%, и компилятор подтвердит вашу позицию.
это классический случай, когда LLM выдают «среднее по больнице» без учёта правил видимости в конкретном языке.
У меня в запросе изначально стояло, что язык C#.
А ИИ выдаёт среднестатистический шум, который может совпадать с правильным ответом лишь случайно. И этот шум вы сами ему поправляете, и через несколько уточнений он таки выдаёт правильный ответ... с вашей помощью. А если вы лично изначально не знаете всех тонкостей, то будете оба ходить кругами от одного ложного ответа к другому. Кто тут кого обучает и кто кому платить должен?
Я это поведение у ИИ уже давно заметил. Разных моделей, далеко не только Копилота. Так что ваш метод "я в этой области ничего не знаю, или мне достался легаси проект почти без документации, так что пусть сгенерит мне какую-то спецификацию, или пусть мне поездит по ушам в новой для меня области - всё лучше, чем ничего". Оно лучше, чем ничего, только если вам почти ничего и не нужно, а результата достаточно "куда-то туда, плюс-минус километр". Ну или, как я сказал, достаточно сгенерить одноразовый видосик для рекламы - идущую куда-то девочку то с двумя, то с одной косой. Один хрен через пару недель прокрутки по рекламным сетям его выбросят и сгенерят новый.
Сокрытие статических членов (new static ...) в C# считается антипаттерном:
У меня такая ситуация - по проекту принято создавать для каждого существенного класса статический объект логгера с параметром в конструкторе - тип этого класса. Я подумал, а что будет, если у меня иерархия наследования таких классов - зачем в по сути одном объекте несколько логгеров, на разных уровнях наследования? И не будут ли эти логгеры скрывать один другой. Посмотрел поближе - а они приватные. Ну и в процессе копания во всём этом пообщался с ИИ.
ИИ часто тренируется на обобщённых формулировках вроде «при совпадении имён используйте new», но не всегда проверяет контекст видимости. Ваш метод «пинания» (задание уточняющих условий) — ровно тот способ, который заставляет модель скорректировать ответ под спецификацию языка. В данном случае вы правы на 100%, и компилятор подтвердит вашу позицию.
Да-да, попи...деть за жизнь - тут ИИ подходит получше собеседника, особенно если бухаешь - по крайней мере в рожу не даст при несовпадении мнений. ))) А вот где что точное надо, тогда точно не ИИ. Ну и КАЖДЫЙ РАЗ уточнять у него пачкой наводящих вопросов, или КАЖДЫЙ РАЗ готовить промпт со стапятистами ограничивающими условиями, чтобы он каждый раз был в максимально подробном контексте... А вам не недоедает? Что вы по сути задачу сами решаете, а рядом с вами стоит двоечник и только поддакивает вам? Особенно, когда узнаёшь, что этот двоечник стал причиной кризиса и гигансткой инфляции в полупроводниковых компонентах, сожрал триллионы долларов и тераватты энергии, но из роли поддакивающего двоечника далеко не вышел. "Родили же ублюдка...!"
КАЖДЫЙ РАЗ готовить промпт со стапятистами ограничивающими условиями
в противном случае вы будете получать то, что получаете. Или обучаете агента вашему коду или давайте правильные задания.
по проекту принято создавать для каждого существенного класса статический объект логгера с параметром в конструкторе - тип этого класса
очень странно, когда есть два довольно популярных решения
с DI
public class WeatherService
{
private readonly ILogger<WeatherService> _logger;
public WeatherService(ILogger<WeatherService> logger)
{
_logger = logger;
}
public async Task LoadAsync()
{
_logger.LogInformation("Loading weather data at {Time}", DateTime.UtcNow);
}
}
с Factory
public class WeatherService
{
private readonly ILogger _logger;
public WeatherService(ILoggerFactory loggerFactory)
{
_logger = loggerFactory.CreateLogger<WeatherService>();
}
}
V2
public abstract class LoggedService
{
protected ILogger Logger { get; }
protected LoggedService(ILoggerFactory factory)
{
Logger = factory.CreateLogger(GetType());
}
}
public class WeatherService : LoggedService
{
public WeatherService(ILoggerFactory factory) : base(factory) {}
public void Run()
{
Logger.LogInformation("Running weather service");
}
}
У меня такая ситуация - по проекту принято создавать для каждого существенного класса статический объект логгера с параметром в конструкторе - тип этого класса.
Тот кто этопридумал уже мертв? :)
Я подумал, а что будет, если у меня иерархия наследования таких классов - зачем в по сути одном объекте несколько логгеров, на разных уровнях наследования?
Это будет противоречить задумке того придурка, который придумал концепт "создавать для каждого существенного класса статический объект логгера с параметром в конструкторе - тип этого класса". Т.к. не смотря на то, что у тебя иерархия классов "существенный" класс только один, так что логгер должен быть один.
Если переделать на нормальную архитектуру это говнище никак нельзя, то самое простое решение - давать логгеру специфичное для каждого класса имя. И нужно это не столько ради компиляции, сколькодля того, чтобы понимать к какому логгеру ты обращаешься.
КАЖДЫЙ РАЗ готовить промпт со стапятистами ограничивающими условиями
в противном случае вы будете получать то, что получаете. Или обучаете агента вашему коду или давайте правильные задания.
Какие обучения? Я просто спросил чатик в поисковике - для общего сведения. А в проекте мне проще самому СКРИПТОМ или РЕГУЛЯРКАМИ найти нужные вхождения и заменить их, если надо. Хватит уже нейронки для жевания и глотания еды использовать.
с DI
Всегда удивляла эта способность некоторых простую вещь запутать до предела, а потом долго и с честью её распутывать. Ну, наверное они не умеют по-другому зарабатывать на жизнь... Простую передачу параметра обозвать инжекцией зависимости. А по улице я не хожу, а бипедалирую, ска.
давать логгеру специфичное для каждого класса имя
Так это по сути и делается, когда конструктору логгера передаётся имя класса, в котором этот логгер работает. Только получется, что каждую часть объекта из иерархии наследования будет логировать свой логгер.
Тут вопрос в том, чего ты хочешь добиться. Если тебе нужно оставить статическое поле на каждой иерархии, но при этом логгировать всегда должен только один логгер, то это делается виртуальной функцией... ну и каждый наследник должен эту функцию переопределить.
Лучшим решением было бы убрать к чертям эту статическую ересь и сделать всё по фэншую :)
Я просто спросил чатик в поисковике - для общего сведения.
ну тогда какого возникать, что спросили, то и получили
Простую передачу параметра обозвать инжекцией зависимости.
Всегда удивляла способность некоторых людей не понимать многие вещи ![]()
Это совсем не простая передача параметра.
Передача параметра - это когда вы решаете, что передать
DI - это когда код требует, чтобы ему передали готовое, но сам не решает, откуда оно взялось
Передача параметра - это когда вы решаете, что передать
DI - это когда код требует, чтобы ему передали готовое, но сам не решает, откуда оно взялось
Пилять, когда я в 2000 году читал книжки по программированию на С++, тогда просто передавали в параметры всё подряд - от базовых типов до кастомных объектов, и никто не маялся хернёй с наименованиями всего этого, оно нафиг не надо было. А через 3 года появился стратификатор-классификатор, который решил поверить алгеброй гармонию и назвать любой чих своим термином. И теперь любой неофит с навязшей в зубах иишкой спорит до хрипоты о мельчайших деталях всяких трахомахий.
Году так в 2010, когда до осталой России докатилась эта тенденция, и на всяких Хабрах стало модно размахивать томиками всяких Фаулеров и ходьбами по сцене дядей Бобов, я такой - "чё бля?!", встречая то те, то другие непонятные термины. Вдаваясь в детали, не переставал удивляться - "и вот ради этой вот пое..ты вы не только себе мозги загаживаете, но ещё и нормальных людей на собесах достаёте?".
Пытался использовать уже готовые "сервисы инъекции зависимостей". Прочитал, что ninject мол самый простой и понятный. Пилять, если ЭТО самое простое и понятное, то какая же муть в других, "более сложных". Говорили, делай просто. Нет, делают так, что хер поймёшь, кто кого откуда вызывает даже под пошаговым дебагом. Теперь надо обязательно сервис локатором обложиться и не забыть файлик конфигарции прикрутить - минимальный джентельменский набор. Хрен вам, а не просто что-то в параметр передать. Ну а когда сами увязли во всём этом болоте, то бегут звать иишечку - помози мол и сделай всё за нас, а мы тебе промптик-описаньице с полтома "Войны и мира" подсунем. Это теперь называется "обучение нейросети".
повбивавби!
Проблема в том, что с 2000г сложность проектов сильно возрасла. И теперь уже нельзя просто так отдать тестеру, который прогонит 10-20-100 ручных тестов (включая регрессионнын). Регрессионных тестов теперь тысячи и проверить не поломал ли ты что-то своим изменением использовав ручное тестирование уже нельзя.
Выход из этого тупика просто - автоматические тестирование. Оно, как ты понимаешь, бывает друх типов - системное (т.е. когда берется готовая система со всеми БД и подсистемами и скрипты клацают по UI-ю, вызывают REST энд-поинты итд) и модульное (unit). Фактически системное тестирование заменяет человека. Можно запускать регрессионные тесты и прогонять сотни и тысячи тестов. Но и тут естьряд проблем. 1) эти тесты долгие (быстрее чем руками, но все равно нельзя их гонять при каждом коммите) и 2) ими нельзя проверить все (например отказ жесткого диска или сбой удаленного сервера). Модульные тесты решают эти две проблемы. Но смодульными тестами появляется другая проблема - нужно писать тестируемый код, т.е. думать о тестировании еще на стадии написания кода, нужно придерживаться определенных архитектурных правил. Собственно говоря, этот скачек и произошел где-то в 2010. Появление модульного тестирования - было тем самым game changer. Модульное тестирование позволило заметно усложнить проекты и при этом не понижая качество продукта.И плата за это - SOLID. Без SOLID невозможно делать сложные системы.... Ну ОК можно, но получается нестабильное говно :D
Проблема в том, что с 2000г сложность проектов сильно возрасла.
До-до! Виндовс, МС Офис и прочие большие системы были написаны в основе своей до 2000. С тестами и прочим. Потом лишь гуй меняли да понемногу фичи дописывали. И Фаулер им для этого был не нужен.
Регрессионных тестов теперь тысячи и проверить не поломал ли ты что-то своим изменением использовав ручное тестирование уже нельзя.
Выход из этого тупика просто - автоматические тестирование.
То у вас всё на максимально изолированных микросервисах, которые по определению покрываются простыми тестами от и до, то "ничё нельзя протестировать". ))
скрипты клацают по UI-ю
Кстати, а дальше что? Потом с полей полученные данные считываются? А ошибки как? Делается снимок экрана и распознаётся?
Я просто плохо представляю себе процесс. Ну скажем можно программно подвигать курсор и понапосылать событий мыши или клавиатуры. А чтобы считать с той же формы, нужно внедряться в процесс, ловить хэндлер окна и далее углубляться в контролы... Е..нина какая-то.
И плата за это - SOLID. Без SOLID невозможно делать сложные системы
А причём тут Фаулер и SOLID? Так-то эти простые обобщённые принципы были давно и до Фаулера известны. А в общем виде, не привязываясь к программированию, они были известы ещё в общеинженерных и конструкторских областях, т.к. сложные системы не с программированием появились, а гораздо раньше. Просто дети, впервые в жизни севшие за комп и открывшие какого-нибудь Фаулера или там "Боба", или "...четырёх", думают, что вот это и есть вершина развития, и до этого люди лишь палками землю копали и камнями кидались.
не надо нагружать ребенка
Это говорит чел, который каждый второй ответ пишет через ИИ, и по-другому уже не может. И считает это прогрессом. )))
Ещё раз напомню, что про практическое использование нейронок тут первым начал рассказывать я. Я же первый быстро понял их ограниченность. И первый же буду их использовать снова с удвоенной силой, когда их доведут до ума. Или забуду, если не доведут. И про электромобили я так же говорил. И только восторженные дети идут в своём развитии линейно и железобетонно - только вперёд и только максимально до упора, до маразма... Такое не раз случалось с технологиями. Та же виртуальная реальность уже два рождения пережила, и две смерти. Технологии не дошли-с.
До-до! Виндовс, МС Офис и прочие большие системы были написаны в основе своей до 2000.
Ну да, ты еще вспомни DOS:)
С тестами и прочим.
Ага, ручными тестами :)
То у вас всё на максимально изолированных микросервисах, которые по определению покрываются простыми тестами от и до, то "ничё нельзя протестировать". ))
Чукча не читатель, чукча писатель? :)
Ну пойди и протестируй какую-нибудь систему на микросервисах вручную :) Флаг в руги и крест на могилу.
Еще раз, для тех, кто в танке - инит-тесты нужны для того, чтобы знать, что твои изменения ничего не поломали. Фактически это регрессионное тестирование.
Кстати, а дальше что? Потом с полей полученные данные считываются? А ошибки как? Делается снимок экрана и распознаётся?
Есть вфеймфорки. У WinForms и WPF разные методы, но принцип один - задается "путь" к нужному окну и потом считываются данные.
А чтобы считать с той же формы, нужно внедряться в процесс, ловить хэндлер окна и далее углубляться в контролы...
Посмотри Spy++ (для WinForms) и Snoop (для WPF). Тестовые фреймворки делают также.
А причём тут Фаулер и SOLID?
Принципы SOLID были сформулированны Бобом в 2000 году. Да, их использовали и до этого. Но с 2000 они стали распространяться в индустрии. Опять же связано это было с усложнением ПО.
До-до! Виндовс, МС Офис и прочие большие системы были написаны в основе своей до 2000.
Ну да, ты еще вспомни DOS:)
Виндовс даже в виде оболочки над ДОСом была гораздо сложнее самого ДОСа. А то некоторые любят бросаться фразами "да он всё украл! или по-дешёвке скупил и выдал за своё!"
Ну пойди и протестируй какую-нибудь систему на микросервисах вручную :) Флаг в руги и крест на могилу.
Еще раз, для тех, кто в танке - инит-тесты нужны для того, чтобы знать, что твои изменения ничего не поломали. Фактически это регрессионное тестирование.
В конечном счёте всё сводится к тому, чтобы "все галочки были зилёнинькии"? ИИ вам их напихает полную панамку - уж чего-чего, а этого добра у него навалом. ✅
задается "путь" к нужному окну и потом считываются данные
Так самое сложное в этом "потом считываются данные" и есть. Попробуйте добраться до нужного контрола в иерархии и считать с него что-то. А если это окно браузера? Там куча нюансов, которые сами тестов и обработки разных ситуаций требуют, и много волокиты. Уж на что юнит-тесты по объёму кода зачастую в разы больше кода, который тестируют, а тут ещё больше может быть.
Принципы SOLID были сформулированны Бобом в 2000 году.
Боб работал в "Маздае" и других подобных крупных фирмах, откуда эти принципы и вынес. Потом просто был одним из тех, кто решил пойти по пути консалтинга, а далее и вообще создания собственного бренда имени себя. Ходить по сцене, изрекая азбучные истины, проще, чем на старости лет поднимать из полусмерти очередное легаси, наговнокоженное когда-то молодыми почитателями (от слова читать) твоих книжек... Кстати, иронично, что молодые придурки (сейчас уже зрелые), ненавидящие "Маздай", преклоняются перед разными "Бобами", не отдупляя, что это одно и то же.
который каждый второй ответ пишет через ИИ
Удивлён, что не каждый. Фантазии то довольно буйные ![]()
Ещё раз напомню, что про практическое использование нейронок тут первым начал рассказывать я. Я же первый
Ну замечательно, памятник хотите? Что-то мне это напоминает.... вы в 1812 кем были в Москве?
И первый же буду их использовать снова с удвоенной силой, когда их доведут до ума.
ну ждите, ждите ![]()
В конечном счёте всё сводится к тому, чтобы "все галочки были зилёнинькии"? ИИ вам их напихает полную панамку - уж чего-чего, а этого добра у него навалом. ✅
Нет, все сводится не к галочкам, а к тому чтобы были соблюдены требования.
Если цель зеленые галочки или (не дай бог) покрытие, то тесты будут не очень хорошие, но зато KPI будут шикарные :)
Попробуйте добраться до нужного контрола в иерархии и считать с него что-то.
В WinForms для этого можно использовать AutomationID, в WPF есть визуальное дерево и нужно знать путь по этому дереву.
А если это окно браузера?
Вообще примитив - даешь каждому контролу уникальный id и находишь используя XPath :)
Уж на что юнит-тесты по объёму кода зачастую в разы больше кода, который тестируют
С одной стороны да. С другой стороны, юнит-тесты зачастую как похожи друг на друга. Более того, юнит-тесты можно еще использовать и как документацию.

Liste