Einschränken des generischen Parameters als abstrakt

Question

Ist es möglich, eine Einschränkung für einen generischen C# -Parameter anzugeben, wobei dieser Parameter abstrakt sein muss? So habe ich derzeit eine Methode, wo der generische Parameter einen parameterlosen Konstruktor haben muss, aber ich habe jetzt in ein Szenario, wo ich eine abstrakte T benötigt, so hoffte ich, die Methode mit einer überladen, die nur abstrakte Ts

akzeptiert

public static void SomeMethod<T>(IEnumberable<T> SomeParam) where T:SomeBase, new() 
{ 
    T tThing = new T(); 
    //do something simple 
} 
public static T SomeOtherMethod<T>(IEnumberable<T> SomeParam) where T:SomeBase, new() 
{ 
    T tThing = new T(); 
    //do something simple 
} 

public static void SomeMethod<T>(IEnumberable<T> SomeParam) where T:SomeBase, abstract() 
{ 
//do something clever 
} 
public static T SomeOtherMethod<T>(IEnumberable<T> SomeParam) where T:SomeBase, abstract() 
{ 
//do something clever 
} 

Wenn, wie ich vermute, die Antwort lautet "Sie können das nicht tun", gibt es eine vernünftige Problemumgehung?

Answer 1

Sie können den Compiler nicht anweisen, zu überprüfen, ob der type-Parameter abstrakt ist. Aber Sie können eine Laufzeitprüfung durchführen.

public static void SomeMethod<T>(IEnumerable<T> SomeParam) where T:SomeBase 
{ 
    Type type = typeof(T); 
    if(type.IsAbstract) 
    { 
     throw new Exception(string.Format("Cannot use SomeMethod with type {0} because it is abstract.", type.FullName)); 
    } 

    // Do the actual work 
} 

Oder:

public static void SomeMethod<T>(IEnumerable<T> SomeParam) where T:SomeBase 
{ 
    Type type = typeof(T); 
    if(type.IsAbstract) 
    { 
     SomeMethodAbstract<T>(SomeParam); 
    } 
    else 
    { 
     SomeMethodNonAbstract<T>(SomeParam); 
    } 
}