Ripetizione delle dichiarazioni di ereditarietà dell'interfaccia

Question

Ripetizione delle dichiarazioni di ereditarietà dell'interfaccia

#1 da (5 voti)

2

Prendi il seguente esempio:

public interface ISerialRVD
{
    RouteValueDictionary ToRVD();
}

public interface IViewModel : ISerialRVD // Here?
{
    Int32 Page { get; set; }
    String Action { get; set; }
}

public class myViewModel : IViewModel, ISerialRVD // Or Here?
{

}

Capisco che se faccio IViewModel eredita ISerialRVD che sta forzando tutti coloro che implementano IViewModel ad implementare ISerialRVD ma dovrei fare solo : IViewModel o : IViewModel, ISerialRVD sulla classe che implementa IViewModel ?

A mia conoscenza ripetere la parte di ISerialRVD non fa male nulla, e voglio metterlo lì per rendere più chiaro l'implementazione di quell'interfaccia, ma se dovessi avere molte più interfacce diventerebbe abbastanza confuso. Mi sbaglio?

C'è un modo ragionevole di affrontare questo? Da una parte sento che dovrebbe essere prolisso e dirti cosa stai implementando, ma d'altra parte dovrebbe essere inferocibile dall'interfaccia stessa. Tutti gli IViewModels implementano ISerialRVD.

c# interfaces inheritance

posta Shelby115 24.06.2015 - 15:27

fonte

1 risposta

Leggi altre domande sui tag c# interfaces inheritance

Come gestire la valutazione? [chiuso] Convalida delle guide: quale metodo è preferito

score 5 · Accepted Answer

Immagina i seguenti casi:

interface IReadable { }

interface IWriteable extends IReadable { }

class MemoryStream implements IWriteable { }

Guardando solo la firma di MemoryStream , è ovvio che lo stream può essere letto? Probabilmente no: potresti credere che lo stream sia di sola scrittura, a meno che tu non lo sappia in quella specifica logica di business, puoi sempre leggere da un flusso scrivibile.

Pertanto, dichiarare entrambe le interfacce migliora la leggibilità in questo caso.

Ora considera un altro esempio:

interface IEquatable<T> { }

interface IComparable<T> extends IEquatable<T> { }

class Price implements IComparable<int> { }

Qui, la cosa naturale è credere che un oggetto che può essere numericamente paragonato ad un altro (cioè determinare se un oggetto è inferiore o superiore ad un altro), l'oggetto può anche essere confrontato rigorosamente con un altro (cioè , determinare se un oggetto è uguale a un altro). In effetti, la seconda interfaccia estende la prima, rispettando le aspettative.

Pertanto, dichiarare entrambe le interfacce è ridondante in questo caso.