Скажем, есть базовый дженерик класс для общей обработки данных разных типов

class Bace<T> // нет ограничений на тип T
{
T Value { get; set; }
}

И унаследованный класс для обработки числовых данных - тут использую интерфейс INumber для ограничения на числа.

class Derived<T> : Base<T>
where T: INumber<T>
{
}

Так вот, хочется не просто числа обрабатывать, а налловые числа. Для этого вычитал, что надо сделать ограничение ещё и на структуру

class Derived<T> : Base<T>
where T: struct, INumber<T>
{
}

Тогда можно будет переопределить поле Value как налловое и работать в нём с налловыми числами

class Derived<T> : Base<T>
where T: struct, INumber<T>
{
new T? Value { get; set; }
}

Как считаете, будет это работать?

Сразу второй вопрос. Вот есть в базовом классе общая обработка для всех типов, включая ссылочные. И хочется сохранить эту обработку и в производном классе, т.к. хотя там и налловая структура, но код по сути выглядит одинаково. Разница лишь в самом типе: T или T?. Скажем, есть метод с определённым кодом (неважно какой)

class Bace<T> // нет ограничений на тип T
{
T ProcessValue(T input) {...}
}

Ну и в потомке хочу такой же по сути код, лишь сам параметр будет теперь налловой структурой, а не любым типом

class Derived<T> : Base<T>
where T: struct, INumber<T>
{
T? ProcessValue(T? input) {...} // как определить этот метод? через new, override, ещё как-то?
}

Как сделать так, чтобы код не надо было повторять, заменяя лишь тип параметра? Ведь метод ProcessValue в потомковом классе, вызванный из базового класса, не может работать с параметрами типа T? с такими ограничениями на тип (у меня в Студии компилятор выдаёт ошибку - что-то типа о несовпадении сигнатур или типов параметров метода). Т.е. этот метод по сути переопределять придётся. Но т.к. код базового метода меня устраивает, я не хочу его копировать - хочу переиспользовать.

Копировать код из метода в метод не хочется, т.к. если обновлять базовый метод, то и потомковый тоже придётся обновлять - но уже руками.

приведи пример, как ты хочешь использовать эти свои классы.

class Base<T>
{
    protected T CoreProcess(T input)
    {
        // общий код
    }
    public T ProcessValue(T input) => CoreProcess(input);
}

----

class Derived<T> : Base<T>
    where T : struct, INumber<T>
{
    public T? ProcessValue(T? input)
    {
        if (input is null)
            return null;

        return CoreProcess(input.Value);
    }
}