ukrywanie właściwość z klasy pochodnej

Question

Jon Skeet wychowany ten problem raz na jego filmy (choć nie dostarczyła z odpowiedzią).

Powiedzmy, że mamy klasę o nazwie Person i klasy osoba ma właściwość Nazwa

Następnie mamy kolejną klasę Szpiega. Oczywiście Szpieg to Osoba, więc wywodzimy się z klasy Osoba.

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

public class Spy : Person 
{ 

} 

Nie chcemy, aby ludzie wiedzieli nazwę Szpiega tak, że chcemy to dać błąd kompilacji:

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

lub albo:

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

jak możemy zapobiegać tego rodzaju wydarzeniom?

Answer 1

Wpisz Name właściwość virtual w klasie podstawowej Person. W wyprowadzonej klasie Spy nadpisujemy właściwość i throw Exception w programie pobierającym.

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; 
     } 
    } 
} 

Ale zamiast rzucać wyjątek, Chciałbym zaproponować coś podobnego

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

Bo łamie LSP (wspomniane w innym odpowiedź). Co to oznacza tutaj (tylko przykład) jest zawsze mogę zrobić jak

Person x = new Spy(); 

i przekazać je do innej metody, która może być jak

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

Metoda ta jest nieświadomy z jakiegoś szpiega wędrując po stadionie, rozbija się, wykonując prosty uczciwy obowiązek!

Edit

Wystarczy, aby było jasne, to name=********** jest nadal nie jest dobrym rozwiązaniem. To po prostu uratuje od wyjątków! Później można znaleźć wiele Osób przemierzających kod z nazwą **********, co spowoduje późniejsze niespodzianki i inne problemy.

Lepszym rozwiązaniem byłby lepszy projekt. Sprawdź odpowiedź Nathana, by uzyskać jakąś wskazówkę.

Answer 2

Można ukryć podstawową metodę klasy lub własności z new słowa kluczowego:

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

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

Nie da Ci kompilacji błędów, i nadal będzie w stanie uzyskać dostęp do właściwości klasy bazowej Name jeśli oddasz.

Jeśli możesz zmodyfikować klasę podstawową, zmień właściwość na wirtualną. Następnie można go przesłonić w klasie pochodnej, klasie i rzucić wyjątek nawet przy wywołaniach polimorficznych.

Wszystko to będzie działać w czasie wykonywania, nic nie da się z tym zrobić podczas kompilacji.

I jak wspomnieli inni w swoich odpowiedziach, taki projekt przełamuje zasadę zastępowania Liskova i należy go unikać.

Answer 3

Jeśli część bycia osobą jest ujawniając swoją nazwę: Spy nie są ludzie

Mając Spy dziedziczą osoby łamie Liskov substitution principle: Obiekt może być zastąpiona jego podtypu.

Jeśli Spys nie ujawni swojego imienia i nazwiska, nie powinien być osobą w kontekście projektu. Może go zaprojektować inaczej:

public interface IPerson 
{ 
    void EatLunch(); 
} 

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

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

Przykładem tego biednego projektu w realnym świecie jest NetworkStream. Implementuje właściwość Position, rzucając wyjątek NotSupportedException. Kod napisany dla Stream może zostać złamany w czasie wykonywania dla NetworkStream. Nie jestem też fanem tego. Poradnik projektowania: złe rzeczy powinny się zepsuć w czasie kompilacji, a obiekty, które dziedziczą z interfejsów, których nie mogą wdrożyć, są okropne.

Answer 4

Nie możesz. Jak już wspomniano, możesz rzucić wyjątek podczas uzyskiwania dostępu do właściwości Nazwa szpiega, ale to się kompiluje. I, o czym już wspomniano, złamałoby to zasadę substytucji Liskov i chciałbym dodać również zasadę otwartą.