Cómo implementar la encapsulación condicional en C#

Question

Me preguntaba cómo se pueden ocultar condicionalmente los datos en clase. Por ejemplo, digamos que tengo una clase llamada Car que tiene tres campos: Engine, MeterReading y Mileage.

Tengo otras tres entidades llamadas: Conductor, mecánico y pasajero. Ahora lo que quiero es que:

Un conductor sólo debe ser capaz de acceder a Kilometraje (y no del motor y MeterReading)

un mecánico sólo debe ser capaz de acceder a motor y cambio de kilometraje (y no MeterReading)

Un pasajero sólo debe ser capaz de acceder MeterReading (y no del motor y cambio de kilometraje)

Cuál podría ser la mejor manera de poner en práctica esta .. (sin basar toda la lógica en si else)?

¿Alguna idea, chicos?

Gracias.

Answer 1

Yo usaría explicit interface implementation. Oculta la implementación de la interfaz cuando se accede a un objeto por su tipo. La implementación solo es accesible cuando se accede por interfaz. En su ejemplo:

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 primera idea que me vino a la mente es que tu clase Car implemente 3 interfaces diferentes que cada clase puede usar para interactuar con tu clase Car.

Por ejemplo, (y mis nombres sin duda puede ser mejorado, pero se debe tener la idea), la interfaz IDriverAccess podría ser la siguiente:

public interface IDriverAccess 
{ 
    double Mileage { get; } 
} 

La interfaz IMechanicAccess podría ser la siguiente:

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

    double Mileage { get; } 
} 

Y así sucesivamente. Su clase de automóvil puede implementar estas interfaces, pero las clases para el conductor, el mecánico, el pasajero & solo usarán las interfaces para interactuar con el objeto.

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

Answer 3

me gustaría crear estas 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; } 
    } 
} 

Y que cada persona utilice la interfaz para acceder al coche.

Answer 4

haga que la clase implemente las interfaces IEngine, ImaterReading y demás. Proporcione a cada entidad solo el acceso a la interfaz especificada. dicen que un disco tiene acceso IMilage solamente, un IMilage mecánico e IEngine.