nascondere la proprietà dalla classe derivata

Question

Jon Skeet ha sollevato questo problema una volta nei suoi video (sebbene non fornisse una risposta).

Diciamo che abbiamo una classe denominata persona e la classe persona ha Nome proprietà

Poi abbiamo un'altra classe, Spy. Ovviamente una Spia è una Persona quindi deriverà dalla classe Persona.

public class Person 
{ 
    public string Name { get; set; } 
} 

public class Spy : Person 
{ 

} 

Non vogliamo che la gente sappia il nome della spia in modo vorremmo questo per dare un errore di compilazione:

static void ReportSpy(Spy spy) { 
    string name = spy.Name; 
} 

o uno:

static void ReportSpy(Spy spy) 
{ 
    Person spyAsPerson = spy; 
    string name = spyAsPerson.Name; 
} 

Come potremmo impedire che questo tipo di cose accada?

Answer 1

Rendere Name proprietà virtual nella classe Person di base. Nella classe derivata Spy, sovrascrivere la proprietà e throw Exception in getter.

public class Person 
{ 
    public virtual string Name { get; set; } 
} 

public class Spy : Person 
{ 
    public override string Name 
    { 
     get 
     { 
      throw new Exception("You never ask for a spy's name!"); 
     } 
     set 
     { 
      base.Name = value; 
     } 
    } 
} 

Ma, invece di lanciare un'eccezione, io suggerirei qualcosa come

get 
{ 
    return "**********"; 
} 

Perché, si rompe LSP (detto in un'altra risposta). Ciò significa qui (solo un esempio) è, posso sempre fare come

Person x = new Spy(); 

e passarlo a un altro metodo, che potrebbe essere come

void RegisterForNextBallGame(Person p) 
{ 
    playerList.Add(p.Name); 
} 

Questo metodo di essere all'oscuro della una spia girovagando per lo stadio, si schianta mentre svolge un semplice e onesto dovere!

Modifica

Giusto per chiarire, questo è name=**********ancora non una soluzione giusta. Salverà solo dalle eccezioni! Più tardi, si potrebbero trovare molte persone che percorrono il codice con il nome ********** che causerà successive sorprese e altri problemi.

Una soluzione migliore sarebbe un design migliore. Controlla la risposta di Nathan per avere qualche suggerimento.

Answer 2

È possibile nascondere metodo della classe base o una proprietà con new parola chiave:

public class Person 
{ 
    public string Name { get; set; } 
} 

public class Spy : Person 
{ 
    public new string Name 
    { 
     get { throw new InvalidOperationException(); } 
    } 
} 

Non vi darà la compilazione errori, e sarete ancora in grado di accedere alla proprietà della classe base Name se lanci.

Se è possibile modificare la classe base, modificare la proprietà in virtuale. Quindi puoi sovrascriverlo nella derivata e nella classe e generare eccezioni anche con chiamate polimorfiche.

Tutto ciò funzionerà in fase di esecuzione, nulla che si possa fare al momento della compilazione.

E come altri hanno menzionato nelle loro risposte, tale progettazione rompe il principio di sostituzione di Liskov e dovrebbe essere evitato.

Answer 3

Se parte di essere una persona è rivelare il tuo nome: spia di non sono persone

Avere Spy ereditare da persona rompe il Liskov substitution principle: Un oggetto può essere sostituito con il suo sottotipo.

Se Spys non rivela il proprio nome, non dovrebbero essere Persone nel contesto del proprio progetto. Forse si potrebbe progettare in modo diverso:

public interface IPerson 
{ 
    void EatLunch(); 
} 

public interface INameDisclosingPerson : IPerson 
{ 
    string Name {get; set; } 
} 

public interface ISpy : IPerson 
{ 
    void DrinkCocktail(); 
    Package MakeDrop(); 
} 

Un esempio di questa povera di design nel mondo reale è NetworkStream. Implementa la proprietà Position lanciando NotSupportedException. Quindi il codice che scrivi per un Stream potrebbe interrompersi in fase di esecuzione per lo NetworkStream. Anche io non sono un fan di questo. Una guida alla progettazione: le cose sbagliate dovrebbero rompersi alla compilazione e gli oggetti che ereditano da interfacce che non possono implementare sono terribili.

Answer 4

Non è possibile. Come già accennato potresti lanciare un'eccezione quando accederai alla proprietà Nome di Spy, ma questa sarebbe comunque compilata. E, come già accennato, ciò spezzerebbe il principio di sostituzione di Liskov e, vorrei aggiungere, anche il principio di apertura chiusa.