Избегайте случая двойного переключения в шаблоне стратегии

Рассмотрим следующий код. Идея состоит в том, чтобы создать абстрактное представление оси устройства, устройств и машины как интерфейса. Затем используйте фабрику, чтобы создать конкретные устройства и оси для (учитывая, что они не изменяемы) Mashine.

public static class Mashine
{
    public static bool Enable_B_X { get; set; }
    public static bool Enable_B_Y { get; set; }

    public static bool Enable_A_X { get; set; }
    public static bool Enable_A_Y { get; set; }
}

/// <summary>
/// Represents a single axis of a single device
/// </summary>
public interface IDeviceAxis
{
    void Enable();
    void Disable();
}
// general device that has two axis, but doesn't care about anything else
public interface IDevice
{
    IDeviceAxis X { get; }
    IDeviceAxis Y { get; }
}
// data model for an alternative Mashine representation
public interface IMachineModel
{
    IDevice A { get; }
    IDevice B { get; }
}

Применение:

public enum Device { A, B }

public enum Axis { X, Y }

// your control class
public class Control
{
    public IMachineModel devControl;

    public Control()
    {
        // MachineFactory see below
        devControl = MachineFactory.GetMachine();
    }

    public void Disable(Device dev, Axis dim)
    {
        GetAxis(dev, dim).Disable();
    }

    public void Enable(Device dev, Axis dim)
    {
        GetAxis(dev, dim).Enable();
    }

    private IDeviceAxis GetAxis(Device dev, Axis dim)
    {
        var device = GetDevice(dev);
        switch (dim)
        {
            case Axis.X:
                return device.X;
            case Axis.Y:
                return device.Y;
            default:
                throw new ArgumentException("Invalid Axis", "dim");
        }
    }
    private IDevice GetDevice(Device dev)
    {
        switch (dev)
        {
            case Device.A:
                return devControl.A;
            case Device.B:
                return devControl.B;
            default:
                throw new ArgumentException("Invalid Device", "dev");
        }
    }
}

Недостающая часть: конкретная реализация интерфейсов и фабрика, чтобы получить полное представление машины:

// concrete machine factory
public static class MachineFactory
{
    // factory for the whole Mashine wrapper
    public static IMachineModel GetMachine()
    {
        return new MachineModel
        {
            A = GetDeviceA(),
            B = GetDeviceB(),
        };
    }

    // factory methods specify the connection from the wrapper classes to the Mashine

    private static IDevice GetDeviceA()
    {
        return new MachineDevice(x => Mashine.Enable_A_X = x, y => Mashine.Enable_A_Y = y);
    }
    private static IDevice GetDeviceB()
    {
        return new MachineDevice(x => Mashine.Enable_B_X = x, y => Mashine.Enable_B_Y = y);
    }

    // concrete implementations can be used for the target Mashine

    private class MachineDeviceAxis : IDeviceAxis
    {
        Action<bool> _setterFunction;
        public MachineDeviceAxis(Action<bool> setter)
        {
            _setterFunction = setter;
        }

        public void Enable()
        {
            _setterFunction(true);
        }

        public void Disable()
        {
            _setterFunction(false);
        }
    }

    private class MachineDevice : IDevice
    {
        public MachineDevice(Action<bool> xSetter, Action<bool> ySetter)
        {
            X = new MachineDeviceAxis(xSetter);
            Y = new MachineDeviceAxis(ySetter);
        }
        public IDeviceAxis X { get; private set; }

        public IDeviceAxis Y { get; private set; }
    }

    private class MachineModel : IMachineModel
    {
        public IDevice A { get; set; }

        public IDevice B { get; set; }
    }
}

Что касается использования машинной абстракции, я думаю, что нет никакого реального преимущества в использовании enum Device и enum Axis. Сравните следующие коды:

// controllers
Control yourControl;
IMachineModel myMachineModel;
// usage
yourControl.Enable(Device.A, Axis.X);
myMachineModel.A.X.Enable();

Преимущество использования Control здесь на самом деле не улучшает код, если вы спросите меня.

Изменить другие параметры

Может быть, Enable и Disable уже переработаны? Как насчет некоторого общего Set(value) вместо этого:

public interface IAxisParameter<TParameter>
{
    void Set(TParameter value);
}

public interface IDeviceAxis
{
    IAxisParameter<bool> Enabled { get; }

    IAxisParameter<double> Position { get; }

    IAxisParameter<bool> Start { get; }
}

Применение:

public class Control
{
    public void Disable(Device dev, Axis dim)
    {
        GetAxis(dev, dim).Enabled.Set(false);
    }

    public void Enable(Device dev, Axis dim)
    {
        GetAxis(dev, dim).Enabled.Set(true);
    }

    // rest of the code as in the original answer above
}

Затем измените внутреннюю реализацию машины соответствующим образом:

// inside factory

    // added implementation
    private class MachineParameter<TParam> : IAxisParameter<TParam>
    {
        Action<TParam> _setterFunction;
        public MachineParameter(Action<TParam> setter)
        {
            _setterFunction = setter;
        }
        public void Set(TParam value)
        {
            _setterFunction(value);
        }
    }

    // changed implementation
    private class MachineDeviceAxis : IDeviceAxis
    {
        public IAxisParameter<bool> Enabled { get; set; }

        public IAxisParameter<double> Position { get; set; }

        public IAxisParameter<bool> Start { get; set; }
    }

    // changed factory methods

    private static IDeviceAxis GetDeviceAxisA_X()
    {
        return new MachineDeviceAxis
        {
            Enabled = new MachineParameter<bool>(x => Mashine.Enable_A_X = x),
            Position = null, // TODO
            Start = null, // TODO
        };
    }
    private static IDeviceAxis GetDeviceAxisA_Y()
    {
        return new MachineDeviceAxis
        {
            Enabled = new MachineParameter<bool>(y => Mashine.Enable_A_Y = y),
            Position = null, // TODO
            Start = null, // TODO
        };
    }
    private static IDevice GetDeviceA()
    {
        return new MachineDevice
        {
            X = GetDeviceAxisA_X(),
            Y = GetDeviceAxisA_Y(),
        };
    }
    private static IDevice GetDeviceB()
    {
        // TODO same thing for device B
        return null;
    }

Концепция должна быть ясной... в конце концов вам нужно написать код для каждого свойства реальной машины. Возможно, было бы неплохо реорганизовать создание параметров внутри фабрики так, как это сделал @Fildor в своем примере связанного кода.

Изменить: сделать заводской код более компактным

Вместо того, чтобы раздувать фабрику отдельным методом для каждого параметра, перегруппируйте создание установщиков параметров, чтобы создать установщики для одного типа параметра на всех устройствах в одном месте (например, CreateEnabledParameterSetters):

// concrete machine factory
public static class MachineFactory
{
    // factory for the whole Mashine wrapper
    public static IMachineModel GetMachine()
    {
        var enabledSetters = CreateEnabledParameterSetters();
        return new MachineModel
        {
            A = GetDevice(enabledSetters, 0 /*A*/),
            B = GetDevice(enabledSetters, 1 /*B*/),
        };
    }

    // factory methods specify the connection from the wrapper classes to the Mashine

    private static Action<bool>[,] CreateEnabledParameterSetters()
    {
        return new Action<bool>[,]
        {
            { x => Mashine.Enable_A_X = x, x => Mashine.Enable_A_Y = x },
            { x => Mashine.Enable_B_X = x, x => Mashine.Enable_B_Y = x },
        };
    }
    private static IDeviceAxis GetDeviceAxis(Action<bool>[,] enabledSetters, int deviceIndex, int axisIndex)
    {
        return new MachineDeviceAxis
        {
            Enabled = new MachineParameter<bool>(enabledSetters[deviceIndex, axisIndex]),
            Position = null, // TODO
            Start = null, // TODO
        };
    }
    private static IDevice GetDevice(Action<bool>[,] enabledSetters, int deviceIndex)
    {
        return new MachineDevice
        {
            X = GetDeviceAxis(enabledSetters, deviceIndex, 0 /*X*/),
            Y = GetDeviceAxis(enabledSetters, deviceIndex, 1 /*Y*/),
        };
    }

// ...