C# References; Utrzymywanie członków w ukryciu

Question

Wyobraź sobie, że masz zdefiniowaną klasę.

public class SomeClass 
{ 
    public Manager m { get; protected set; } 
    public SpecialData data { get; protected set; } 

    //More methods and member code here... 
} 

Potrzebuję mojej klasy menedżera, aby jakoś zmienić zestaw odniesienia dla członka SpecialData. Mógłbym to zrobić z podwójnym wskaźnikiem lub klasami znajomych w C++, ale ta opcja nie jest dostępna w C#, niestety. W jaki sposób mogę zabezpieczyć SpecialData przed zewnętrznymi użytkownikami, pozostawiając kontrolę klasy nad ustawieniami? Mogę to zrobić za pomocą wewnętrznego słowa kluczowego, ale to nie wydaje się niewiarygodnie bezpieczne ani czyste ...

Każda pomoc jest bardzo doceniana.

Answer 1

Jeśli klasa menedżer jest częścią tego samego zespołu co SomeClass, dzięki czemu element internal pozwoliłoby na zajęcia w tym samym zespole, aby uzyskać dostęp do setter:

public SpecialData data { get; protected internal set; } 

ten jest podobny do korzystania friend w C++, z wyjątkiem tego, że "przyjaźń" jest rozszerzona na wszystkich członków tego samego zespołu.

Jeśli menedżer jest częścią innego pakietu, można użyć atrybutu InternalsVisibleTo w zespole. W tym przypadku jednak powinieneś podpisać zespół, do którego rozszerzysz przyjaźń, aby uniknąć prób uzyskania dostępu do setera z nieautoryzowanego kodu.

Answer 2

utworzyć klasę, która dziedziczy SomeClass i wygląda rodzaju to:

internal class SomeClassDecorator : SomeClass 
{ 
    public void SetSpecialData(SpecialData value) 
    { 
     data = value; 
    } 
} 

Protected oznacza, że ​​jest ona dostępna do pochodnych klasy, a ponieważ SomeClass nie jest uszczelniona, można po prostu czerpać z niego i czynić czegokolwiek potrzebujesz. Możesz wtedy użyć tego dekoratora zamiast samego SomeClass. Co więcej, możesz mieć tyle dekoratorów, ile potrzebujesz, z których każdy obsługuje specjalne urządzenie SpecialData.

Answer 3

Może to nie być dokładnie to, czego szukasz, ale słowo kluczowe internal opisane here może zarządzać dostępem w obrębie tego samego zespołu; wydaje się być podobnym celem, jak słowo kluczowe friend w C++.

Answer 4

Można wprowadzić właściwość internal. To sprawi, że właściwość będzie widoczna tylko w tym samym zespole. Opcjonalnie można użyć opcji InternalsVisibleToAttribute, aby umożliwić określonym zestwom dostęp do tej właściwości.

Innym podejściem jest użycie interface ukryć, że właściwość:

public interface ISomeClass 
{ 
    Manager m { get; } 
    SpecialData data { get; set; } 
} 

public class SomeClass : ISomeClass 
{ 
    public Manager m { get; protected set; } 
    SpecialData ISomeClass.data { get; set; } 

    //More methods and member code here... 
} 

W ten sposób data jest widoczne z Interface.

Więc to nie działa:

SomeClass c = new SomeClass(); 
c.data; 

Ale to robi:

ISomeClass c = new SomeClass(); 
c.data; 

Answer 5

Co o tworzeniu zdarzenie od klasy Manager, coś podobnego zdarzenia RequestChangeSpecialData. Manager uruchamia zdarzenie, a SomeClass zmieni instancję SpecialData.

public class SomeClass 
{ 
    private Manager _m; 

    public Manager M 
    { 
     get { return _m} 
     set 
     { 
      // register/unregister event on property assignment 
      if(_m != null) 
       _m.RequestChangeSpecialData -= RequestChangeSpecialData; 

      _m = value; 

      if(_m != null) 
       _m.RequestChangeSpecialData += RequestChangeSpecialData; 

     } 
    } 

    public SpecialData Data { get; private set; } 

    private void RequestChangeSpecialData(object sender, ChangeSpecialDataEventArgs e) 
    { 
     // set the new reference 
     Data = e.SpecialData; 
    } 

} 

public class Manager 
{ 
    public void DoSomething() 
    { 
     // the manager class wants to do something, and wants to change the SpecialData instance.., so it fires the event RequestChangeSpecialData 


     SpecialData data = new SpecialData(); 

     // if the event is bound. 
     if(RequestChangeSpecialData != null) 
      RequestChangeSpecialData(this, new ChangeSpecialDataEventArgs(data)); 
    } 

    public event EventHandler<ChangeSpecialDataEventArgs> RequestChangeSpecialData; 
} 

public class ChangeSpecialDataEventArgs : EventArgs 
{ 
    public SpecialData Data {get; private set; } 

    public ChangeSpecialDataEventArgs(SpecialData Data) 
    { 
     Data = data; 
    } 
} 

NIETESTOWANY (napisał w notatniku)

Teraz Manager jest w stanie zmienić właściwość SpecialData. W ten sposób menedżer nie jest zależny od interfejsu lub zespołu SomeClass /.