Pourquoi Predicate <> est-il scellé?

Question

Je voulais dériver une classe à partir de Predicate < IMyInterface>, mais il semble que le prédicat <> soit scellé. Dans mon cas, je voulais simplement retourner le résultat inversé (!) De la fonction désignée. J'ai d'autres moyens d'atteindre l'objectif. Ma question est de savoir ce que les concepteurs de MS ont pu penser en décidant de sceller le Prédicat <>?

Sans beaucoup de réflexion je suis venu avec: (a) simplifié leur test, juste un temps vs le commerce des coûts hors (b) « Incorrect » pourrait venir de tirer de prédicats <>

Qu'est-ce que vous pense? Mise à jour: Il y a n prédicats qui sont ajoutés dynamiquement à une liste de prédicats pendant une phase d'initialisation. Chacun est mutuellement exclusif (si Abc est ajouté, NotAbc ne sera pas ajouté). J'ai observé un modèle qui ressemble à:

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 

ne est pas que je ne peux pas résoudre le problème, son que je me demande pourquoi je ne pouvais pas le résoudre d'une certaine façon.

Answer 1

Le prédicat est un délégué. Vous ne pouvez pas hériter d'un type de délégué. Si vous souhaitez obtenir la valeur inversée, utilisez les touches suivantes:

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

Answer 2

Predicate<T> est un type de délégué. Vous ne pouvez jamais dériver de délégués.

Pour être honnête, il ne semble pas que l'héritage soit vraiment approprié ici - il suffit d'écrire une méthode qui retourne l'inverse de l'original. Il est aussi simple que cela:

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

Answer 3

La fonctionnalité d'un délégué est de gérer une liste de pointeurs de type de méthode sûre. Les concepteurs de C# ont décidé qu'il n'y avait rien à ajouter à cette fonctionnalité et il n'y a aucune raison de changer le comportement des délégués. Donc, Jon a raison, l'héritage n'est pas approprié ici.

Les délégués peuvent pointer vers une liste de méthodes. Nous ajoutons à cette liste avec + = opérateur ou avec Delegate.Combine. Si la signature de la méthode n'est pas vide, le résultat de la dernière méthode invoquée est renvoyé (si un rappel est correctement effectué).