Какой это шаблон проектирования, и можно ли сделать в C# также (как в С++)?

//-------------ModulePosition  + SpecialPosition--------------------------------------------
 
 
 
 
struct ModulePosition
{
    __int64 data0;
};
 
 
 
struct SpecialPosition : ModulePosition
{
public:
    __int64 data2;
};
 
 
       //  объявлены как структуры, но сути шаблона проектирования это не меняет, аналогично было бы и с class
 
 
//------------------ModuleDrive + SpecialDrive--------------------------------------------
 
 
template< class Type >
class TemplateDrive
{   
public:
    Type field;
    Type MethodGet(Type element);
};
 
 
typedef TemplateDrive<ModulePosition> ModuleDrive;
 
 
 
// далее использование  ModuleDrive - ЭКВИВАЛЕНТНО TemplateDrive<ModulePosition>,  
// а потому класс, использующий именно ModulePosition, мы можем дописать как  ModuleDrive. 
// Попытка использовать с другим типом  TemplateDrive<ДругойТип>  провалится потому что в шаблонном class TemplateDrive - 
// нет реализации метода для всех других типов. По сути, конструкция выше эквивалентна конструкции C# 
// public partial class TemplateDrive<T> where T : ModulePosition
// и даже лучше т.к. в C# нельзя использовать везде без ограничений using ModuleDrive = TemplateDrive<ModulePosition>;  
// так, как в C++  typedef.  (using для этих целей можно использовать только в начале namespace).  
// Необъявление же реализации метода MethodGet - в классе TemplateDrive - так же решается и в C#, только с объявлением  abstract. 
// Поля в ModuleDrive объявляются закомментированными для удобства так же как и в C++, остаётся несущественная разница - 
// т.к. в C++ нет partial слова, то приходится комментировать и сам класс ModuleDrive, оставляя только реализацию методов. 
 
 
 
//class ModuleDrive   //  фактически - реализация класса будет здесь, но из-за отсутствия 'partial' приходится часть - оставлять в одном месте. 
//{
//public:
    //ModulePosition field;    //  Type field;  превращается в ModulePosition, т.к. в typedef объявлен тип 
 
 
    // здесь слово virtual повторно не нужно, т.к.  метод определен внутри класса TemplateDrive, видимо модификаторы virtual можно об-ть только внутри класса.
    // Если этот метод объявить как virtual в классе TemplateDrive тогда придется полностью переписывать код, а так - 
    // можно что то дописать в производных классах,  а часть оставить здесь и попадать сюда, в код базового класса тоже. 
    ModulePosition ModuleDrive::MethodGet(ModulePosition element)      // сигнатура та же, но Type -> превращается в ModulePosition
    {
        element.data0 = 11;   // "Точка1"
        field.data0 = 11;
        return element;
    }
//}    //  class ModuleDrive  
 
 
 
 
// Linker error LNK1120: 1 unresolved externals 
// TemplateDrive<SpecialPosition>* td2 = new TemplateDrive<SpecialPosition>();
// чтобы не было этой ошибки, нужно определить и в этом классе MethodGet, точнее - вызвать базовый 
    SpecialPosition TemplateDrive<SpecialPosition>::MethodGet(SpecialPosition element)      // сигнатура та же, но Type -> превращается в ModulePosition
    {
        //element.data0 = 11;
        //field.data0 = 11;
        //return element;
 
        ModulePosition el =  ((ModuleDrive*)this)->MethodGet((ModulePosition)element);  // "Точка2"
        element.data0 = el.data0;
        return element;
    }
 
 
 
// класс SpecialDrive, в отличие от ModuleDrive уже не объявляется через typedef, а прямо наследуется от TemplateDrive<SpecialPosition>. 
// Поскольку ModuleDrive  в свою очередь, не наследовался в другую ветку, а объявлялся прямо, то 
// 1) TemplateDrive<SpecialPosition>  ------> объект  наследник    от  ModuleDrive  (эквивалентен ему и  TemplateDrive<ModulePosition>)
//     поскольку тип в шаблоне - наследник. (SpecialPosition).  См.. свойство КОВАРИАНТНОСТИ. 
//     Содержит новое только в SpecialPosition внутреннем типе 
// 2) SpecialDrive - наследник от  TemplateDrive<SpecialPosition>, и следовательно от ModuleDrive. (содержит что то свое новое)
//     это значит что если сравнить SpecialDrive и ModuleDrive - то внутри и тип полей которые были ModulePosition- заменится на производные, 
//     и сигнатуры методов использующие этот тип,   и к тому же, сами методы можно переопределить,  + создать новые. 
// МНОГОКЛАССОВОЕ наследование в этом и состоит. - 
//  Ниже, попадем в  "Точка3"   "Точка2"    "Точка1"  - последовательно, используя SpecialDrive  объект 
 
 
class SpecialDrive : TemplateDrive<SpecialPosition>
{
public:
    //SpecialPosition field;    //  Type field;  здесь превращается в SpecialPosition, т.к. тип объявлен у класса предка 
    int field2;   //  новое поле 
 
 
    // сигнатура та же, но Type -> превращается в SpecialPosition  - компилятор не ругается! 
    SpecialPosition MethodGet(SpecialPosition element) 
    {
        
        //element = TemplateDrive<SpecialPosition>::MethodGet(element); 
        element = ((TemplateDrive<SpecialPosition>*)this)->MethodGet(element);  // "Точка3"
 
        // доопределяем своё
        element.data2 = 22;
        field.data0 = 22;
 
        return element;
    }
};
 
 
 
void CFreecellTemplateCppDlg::OnBnClickedOk()
{
    
    ModuleDrive md1;
    TemplateDrive<SpecialPosition> td1;
    SpecialDrive sd1;
 
    // выше видно, что от чего наследуется,  ModuleDrive   ->  TemplateDrive<SpecialPosition>   ->  SpecialDrive
    //Watch:
    //в md1 видим что поле field имеет тип  ModulePosition
    //в td1 видим что поле field имеет тип  SpecialPosition
    //в sd1 - еще появилось поле field2
 
 
 
 
    ModuleDrive* m1 = new ModuleDrive();
    SpecialDrive* m3 = new SpecialDrive();
 
    ModulePosition posM;
    posM.data0 = 100;
    m1->MethodGet(posM);   // 
 
    SpecialPosition posS;
    posS.data0 = 100;
    m3->MethodGet(posS);   //  Здесь, попадем в  "Точка3"   "Точка2"    "Точка1"  - последовательно, используя SpecialDrive  объект 
 
 
    // таким образом SpecialDrive НЕЯВНО унаследован от ModuleDrive,  одновременно с внутренними полями и сигнатурами методов, 
    // у SpecialDrive  внутри везде используется SpecialPosition,  а у ModuleDrive  - используется ModulePosition.  
 
    // Получается многоклассвое наследование.  Если далее создать еще пару классов,  к примеру 
    // ModuleController  и   SpecialController (3-й уровень),  второй так же неявно унаследовать от первого, а внутренние классы у них будут 
    // использоваться, вышеописанные  ModuleDrive и SpecialDrive (2-й уровень)  соответственно, то получим уже связное множество из 3-х классов, 
    // унаследованное от связного множества из  3-х классов. 
    // Продолжая по аналогии,  можно создать целый проект из N классов, который можно использовать как базовый для 
    // другого проекта, из унаследованных этих N классов. 
    
 
 
 
    CDialogEx::OnOK();
}
 
 
 
 
//----------------------------------------------------------------------------------------------------

    ModuleDrive* m1 = new ModuleDrive();
    ModuleDrive* m3 = (ModuleDrive*) new SpecialDrive();
 
    ModulePosition posM;
    posM.data0 = 100;
 
    m1->MethodGet(posM);   
    m3->MethodGet(posS);

ModuleDrive* m3 = new SpecialDrive();

virtual ModulePosition MethodGet(ModulePosition element) 
 
override SpecialPosition MethodGet(SpecialPosition element)