This is something which could called generic specialization, by the analogy with C++ template specialization.
It looks like your efforts are useless until you work with generic methods; it is not possible to specialize the implementation via overriding for a concrete type. I want to give you an alternative idea: move a generic parameter from a method to a type. Just think about it:
class Base<T> {
internal protected virtual void Create(T item) { }
}
struct ConcreteType {}
class Derived : Base<ConcreteType> {
internal protected override void Create(ConcreteType item) { }
}
Pretty similar to what you wanted, but in this way it can work.
More typically, the first method would be abstract:
abstract class Base<T> {
internal protected abstract void Create(T item)
}
class Derived : Base<ConcreteType> {
internal protected override void Create(ConcreteType item) { }
}
Note that you don't have to specialize all the generic parameters in the derived type, but still can override the method with a specialized generic parameter; this is how to do it:
abstract class Base<SomeType, ParameterType> {
internal protected abstract void Create(ParameterType item);
}
class Derived<SomeType> : Base<SomeType, ConcreteType> {
internal protected override void Create(ConcreteType item) { }
}
Are you getting it? This way you can get yourself enough flexibility which could suit your goals. Again, think about it.
—SA