Forcer les sous-classes d'une interface à implémenter ToString

Question

Disons que j'ai une interface IFoo et que toutes les sous-classes de IFoo doivent remplacer la méthode ToString de Object. Est-ce possible?

ajoutant simplement la signature de la méthode à IFoo en tant que telle ne fonctionne pas:

interface IFoo 
{ 
    String ToString(); 
} 

puisque toutes les sous-classes étendent Object et fournissent une mise en œuvre de cette façon, le compilateur ne se plaint pas. Aucune suggestion?

Answer 1

Je ne crois pas que vous pouvez le faire avec une interface. Vous pouvez utiliser une classe de base abstraite si:

public abstract class Base 
{ 
    public abstract override string ToString(); 
} 

Answer 2

abstract class Foo 
{ 
    public override abstract string ToString(); 
} 

class Bar : Foo 
{ 
    // need to override ToString() 
} 

Answer 3

Je ne pense pas que vous pouvez forcer une sous-classe à dérogation l'une des méthodes virtuelles de la classe de base à moins que ces méthodes sont abstraites.

Answer 4

L'implémentation d'une méthode d'interface scelle implicitement la méthode (ainsi que son remplacement). Donc, à moins que vous ne le disiez autrement, la première implémentation d'une interface termine la chaîne de substitution en C#.

Essential .NET

Résumé class = votre ami

Vérifier this question

Answer 5

Jon & Andrew: Ce truc abstrait est vraiment utile; Je n'avais aucune idée que vous pouviez terminer la chaîne en la déclarant comme abstraite. Cheers :)

Dans le passé, quand j'ai exigé que ToString() être outrepassée dans les classes dérivées, je l'ai toujours utilisé un modèle comme les suivantes:

public abstract class BaseClass 
{ 
    public abstract string ToStringImpl(); 

    public override string ToString() 
    { 
     return ToStringImpl(); 
    }  
} 

Answer 6

Je sais que cela ne répond pas votre question, mais puisqu'il n'y a aucun moyen de faire ce que vous demandez, j'ai pensé que je partagerais ma propre approche pour que les autres voient. J'utilise un hybride de Mark et Andrew solutions proposées.

Dans mon application, tous les domaines-entités dérivent d'une classe de base abstraite:

public abstract class Entity 
{ 
    /// <summary> 
    /// Returns a <see cref="System.String"/> that represents this instance. 
    /// </summary> 
    public override string ToString() 
    { 
     return this is IHasDescription 
        ? ((IHasDescription) this).EntityDescription 
        : base.ToString(); 
    } 
} 

L'interface se définit uniquement un accesseur simple:

public interface IHasDescription : IEntity 
{ 
    /// <summary> 
    /// Creates a description (in english) of the Entity. 
    /// </summary> 
    string EntityDescription { get; } 
} 

Alors maintenant, il y a une chute arrière mécanisme intégré - ou en d'autres termes, un Entity qui implémente IHasDescription doit fournir le EntityDescription, mais tout Entity peut encore convertir en une chaîne. Je sais que ce n'est pas radicalement différent des autres solutions proposées ici, mais j'aime l'idée de minimiser la responsabilité du type de base Entity, de sorte que la mise en œuvre de l'interface de description reste facultative, mais vous êtes obligé de implémente réellement la méthode de description si vous implémentez l'interface.

à mon humble avis, les interfaces qui sont mises en œuvre par la mise en œuvre comme la classe de base object ne devrait pas « compter » - il serait agréable d'avoir une option de compilateur pour cela, mais, oh bien ...