Дженерики в обратном порядке?

Question

Есть ли способ сделать это без использования класса Type? Я предпочел бы использовать дженерики.

abstract class MyAbstract 
{ 
    protected abstract T GetSpecialType(); 

    private void MyPrivateFunction() 
    { 
     someT = GetSpecialType(); 

    } 
    private void DoSomething<T>() 
    { 
    } 
} 

class MyConcrete : MyAbstract 
{ 
    protected override T GetSpecialType() 
    { 
    return SomeReallySpecialClass(); 
    } 
} 

Уверен, что это сработает (его путь у меня есть сейчас), но его уродливый.

abstract class MyAbstract 
{ 
    protected abstract Type GetSpecialType(); 

    private void MyPrivateFunction() 
    { 
     Type someT = GetSpecialType(); 

    } 
    private void DoSomething(Type ofT) 
    { 
    } 
} 

class MyConcrete : MyAbstract 
{ 
    protected override Type GetSpecialType() 
    { 
    return typeof(SomeReallySpecialClas(); 
    } 
} 

или

Должен ли я поставить его в качестве общего параметра на абстрактном классе?

Answer 1

Мне не совсем понятно, что вы пытаетесь сделать, но, возможно, что-то вроде этого?

abstract class MyAbstract<T> 
{ 
    private void DoSomething() 
    { 
     // Use typeof(T) here as needed 
    } 
} 

class MyConcrete : MyAbstract<SomeReallySpecialClass> 
{ 
    // Is there any other logic here? 
} 

Answer 2

Я не могу понять, чего вы пытаетесь достичь. (Если я направляюсь в неправильном направлении, с этим ответом, вы можете уточнить ваш вопрос немного и добавить некоторые подробности того, что именно вы пытаетесь сделать)

---

Если вы просто пытаетесь создайте новые объекты на основе типового параметра типа, вы можете взглянуть на new constraint.

class ItemFactory<T> where T : new() 
{ 
    public T GetNewItem() 
    { 
     return new T(); 
    } 
} 

Включив «новую» тяготы он гарантирует, что любой тип предоставляется при создании Itemfactory класса должен иметь открытый конструктор без параметров, который означает, что вы можете создавать новые объекты внутри класса.