Perché il predicato <> è sigillato?

Question

Ho voluto derivare una classe da Predicate < IMyInterface>, ma sembra come se Predicato <> sia sigillato. Nel mio caso volevo semplicemente restituire il risultato invertito (!) Della funzione designata. Ho altri modi per raggiungere l'obiettivo. La mia domanda è: cosa avrebbero pensato i progettisti di MS quando decidevano di sigillare Predicato <>?

senza troppi pensieri mi si avvicinò con: (a) semplificato il loro test, solo un momento vs commercio costo off (b) "non va bene" potrebbe venire da derivante dalla Predicate <>

Cosa ti pensare?

Aggiornamento: ci sono n predicati che vengono aggiunti dinamicamente a un elenco di predicati durante una fase di inizializzazione. Ciascuno è mutuamente esclusivo (se viene aggiunto Abc, non verrà aggiunto NotAbc). Ho osservato un modello che assomiglia a:

bool Happy(IMyInterface I) {...} 
bool NotHappy(IMyInterface I) { return !Happy(I); } 
bool Hungry(IMyInterface I) {...} 
bool NotHungry(IMyInterface I) { return !Hungry(I); } 
bool Busy(IMyInterface I) {...} 
bool NotBusy(IMyInterface I) { return !Busy(I); } 
bool Smart(IMyInterface I) {...} 
bool NotSmart(IMyInterface I) {...} //Not simply !Smart 

Non è che non riesco a risolvere il problema, la sua che mi chiedo il motivo per cui non ho potuto risolverlo in un certo modo.

Answer 1

Il predicato è un delegato. Non puoi ereditare da un tipo di delegato. Se si desidera ottenere il valore invertito, utilizzare il seguente:

Predicate<T> p; 
Predicate<T> inverted = t => !p(t); 

Answer 2

Predicate<T> è un tipo delegato. Non puoi mai derivare dai delegati.

A dire il vero, non sembra che l'ereditarietà sia davvero appropriata qui in ogni caso - basta scrivere un metodo che restituisce un inverso dell'originale. E 'semplice come questo:

public static Predicate<T> Invert<T>(Predicate<T> original) 
{ 
    return t => !original(t); 
} 

Answer 3

La funzionalità di un delegato è quello di gestire un elenco di tipo metodo sicuro puntatori. I progettisti C# hanno deciso che non c'è nulla da aggiungere a questa funzionalità e non vi è alcun motivo per modificare il comportamento dei delegati.

Quindi, Jon ha ragione, l'ereditarietà non è appropriata qui.

I delegati possono fare riferimento a un elenco di metodi. Aggiungiamo a questa lista con + = operatore o con Delegate.Combine. Se la firma del metodo non è nullo, viene restituito il risultato dell'ultimo metodo richiamato (se il richiamo è corretto).