Comment implémenter l'encapsulation conditionnelle en C#

Question

Je me demandais comment on peut conditionnellement cacher les données en classe. Par exemple, disons que j'ai une classe appelée Car qui a trois champs: Engine, MeterReading et Mileage.

J'ai trois autres entités appelées: Driver, Mechanic et Passenger. Maintenant, ce que je veux est que:

Un pilote ne devrait être en mesure d'accéder Mileage (et non du moteur et MeterReading)

Un mécanicien ne doit pouvoir accéder à moteur et le kilométrage (et non MeterReading)

Un passager devrait seulement pouvoir accéder à MeterReading (et non au moteur et au kilométrage)

Quelle pourrait être la meilleure manière d'implémenter ceci .. (sans baser toute la logique dessus si d'autres instructions)?

Des idées les gars?

Merci.

Answer 1

Je voudrais utiliser explicit interface implementation. Il cache l'implémentation de l'interface lorsque l'objet est accédé par son type. L'implémentation est accessible uniquement lors de l'accès par interface. Dans votre exemple:

interface IUsableByPassenger 
{ 
    MeterReading MeterReading 
    { 
     get; set; 
    } 
} 

interface IUsableByDriver 
{ 
    Mileage Mileage 
    { 
     get; set; 
    } 
} 

interface IUsableByMechanic : IUsableByDriver 
{ 
    Engine Engine 
    { 
     get; set; 
    } 
} 

class Car : IUsableByMechanic, IUsableByPassenger 
{ 
    Mileage IUsableByDriver.Mileage 
    { 
     // implement mileage access 
    } 

    Engine IUsableByMechanic.Engine 
    { 
     // implement engine access 
    } 

    MeterReading IUsableByPassenger.MeterReading 
    { 
     // implement engine access 
    } 
} 

class Mechanic 
{ 
    public Mechanic(IUsableByMechanic usable) 
    { 
     // usable.MeterReading is not here 
    } 
} 

Answer 2

La première idée qui est venue à l'esprit serait que votre classe Car implémente 3 interfaces différentes que chaque autre classe peut utiliser pour interagir avec votre classe Car.

Par exemple, (et mes noms peuvent certainement être améliorés, mais vous devriez avoir l'idée), le pourrait être aussi l'interface IDriverAccess suit:

public interface IDriverAccess 
{ 
    double Mileage { get; } 
} 

L'interface IMechanicAccess pourrait être la suivante:

public interface IMechanicAccess 
{ 
    EngineObject Engine { get; set; } 

    double Mileage { get; } 
} 

Et ainsi de suite. Votre classe de voiture peut ensuite mettre en œuvre ces interfaces, mais les classes pour le conducteur, le mécanicien, & passager utiliseront simplement les interfaces pour interagir avec l'objet.

public Car : IDriverAccess, IMechanicAccess, IPassengerAccess 
{ 
    // implement the interfaces 
} 

Answer 3

Je voudrais créer ces interfaces:

public interface IDriviableCar 
{ 
    object Mileage { get; } 
} 

public interface IRepairableCar 
{ 
    object Engine { get; } 
} 

public interface IHirableCar 
{ 
    object MeterReader { get; } 
} 

public class Car : IDriviableCar, IRepairableCar, IHirableCar 
{ 
    private object _mileage; 

    private object _engine; 

    private object _meterReader; 

    public object Mileage 
    { 
     get { return _mileage; } 
    } 

    public object Engine 
    { 
     get { return _engine; } 
    } 

    public object MeterReader 
    { 
     get { return _meterReader; } 
    } 
} 

Et que chaque personne utilise l'interface pour accéder à la voiture.

Answer 4

faire classe Car implémenté les interfaces IEngine, ImaterReading et ainsi de suite. Donnez à chaque entité uniquement l'accès à l'interface spécifc. dire un lecteur a obtenu l'accès IMilage seulement, un mécanicien IMilage et IEngine.