preponderantes con heredado métodos genéricos

Question

tengo este código en la clase base

protected virtual bool HasAnyStuff<TObject>(TObject obj) where TObject:class 
    { 
     return false; 
    } 

En la clase de niño estoy preponderantes con

protected override bool HasAnyStuff<Customer>(Customer obj) 
    { 
    //some stuff 
     if Customer.sth etc 
     return false; 
    } 

estoy recibiendo este error

'' 'parámetro Type declaración debe ser un identificador no un tipo '' '

¿Qué estoy haciendo mal aquí?

Answer 1

No puede anular el parámetro de tipo de un método genérico en una clase derivada. Para lograr una funcionalidad similar, una opción es tener su clase base sea una clase genérica, y que su clase derivada como

class Derived : BaseClass<Customer> 
{ 
    protected override bool HasAnyStuff(Customer customer) 
    { 
     // ... 
    } 
} 

donde BaseClass está declarada como

class BaseClass<T> where T : class 
{ 
    // ... 
    protected virtual bool HasAnyStuff(T obj) 
    { 
     // ... 
    } 
} 

Alternativamente, dependiendo exactamente cómo se usa su clase derivada, puede anular el método HasAnyStuff con un argumento no genérico Customer.

public bool HasAnyStuff(Customer customer) 
{ 
    // ... 
} 

Sin embargo, tenga en cuenta que el nuevo HasAnyStuff no se llamará si usted no está trabajando con una instancia de DerivedClass. Es decir,

BaseClass foo = new DerivedClass(); 
foo.HasAnyStuff(new Customer()); 

llamará 's método genérico, no DerivedClass' s BaseClass método no genérico.

Answer 2

Tenía el mismo estuche de uso que usted está buscando. Hay un método genérico en la clase base y quiero anular el método para un solo tipo. Para todos los demás tipos, quería que el método se comportara de la misma manera. Aquí hay un ejemplo simple basado en su pregunta.

class BaseClass 
{ 
    protected virtual bool HasAnyStuff<TObject>(TObject obj) 
    { 
     return false; 
    } 
} 

class DerivedClass : BaseClass 
{ 
    protected override bool HasAnyStuff<TObject>(TObject obj) 
    { 
     if (typeof(TObject) != typeof(AlarmTran)) return base.HasAnyStuff<TObject>(obj); 

     //some stuff 
     //if Customer.sth etc 
     return false; 
    } 
} 

También puede invertir la lógica if para manejar múltiples sustituciones de muchos tipos diferentes.

protected override bool HasAnyStuff<TObject>(TObject obj) 
{ 
    if (typeof(TObject) == typeof(AlarmTran)) 
    { 
     //some stuff 
     //if Customer.sth etc 
     return false; 
    } 
    else if (typeof(TObject) == typeof(...)) 
    { 
     ... 
     return ...; 
    } 

    return base.HasAnyStuff<TObject>(obj); 
} 

Answer 3

Similar a la respuesta de John Carpenter, se puede reemplazar el método genérico con el mismo método genérico, sino simplemente utilizar el operador as para comprobar y echarlo al tipo deseado. Esto tiene el beneficio adicional de usar pruebas nulas para comprobar si la conversión funcionó.

Base Clase

protected virtual bool HasAnyStuff<TObject>(TObject obj) 
{ 
    .... // base implementation 
} 

heredada Clase

protected override bool HasAnyStuff<TObject>(TObject obj) 
{ 
    var customer = obj as Customer; 
    if (customer == null) // conversion failed. object is not of type Customer 
    { 
     return base.HasAnyStuff(obj); 
    } 

    .... // do stuff with the customer 
}