Скажите пожалуйста дурная затея или нет. Для управлением состояния зависимых объектов ввести использовать класс который в себе содержит некое булево выражение и значение которого автоматически пересчитывается.

Вот к примеру я написал NotifiableBoolExpression, которому мы задаем некую формулу в св-ве Expression. Пусть мы имеем объект у которого Enabled мы задали некой формулой и далее его значение автоматом пересчитывается в зависимости от смены значений объектов от которых наш объект зависит.

Ниже коды классов.
Не нравится мне то что слишком много левых event'ов и цепочка по смене значения может быть длинной.
Хочется объекту написать так:
someObject.Enabled.Expression = new NotifiableAndBool(...,...);

В общем покритикуйте пож-ста.
Мне что-то кажется что идея дурная, но с другой стороны мне она немного нравится.

    public abstract class NotifiableBool
    {
        public abstract bool Value { get;}
        
        public event EventHandler ValueChanged;

        protected void Notify(EventArgs eventArgs)
        {
            if (null == ValueChanged)
                return;

           

            Exception raisedException = null;
            foreach (EventHandler d in ValueChanged.GetInvocationList())
            {
                try
                {
                    d(this, eventArgs);
                }
                catch (Exception ex)
                {
                    if (null == raisedException)
                        raisedException = ex;
                }
            }
            if (null != raisedException)
            {
                throw raisedException;
            }
        }
    }


    public class NotifiableBoolExpression : NotifiableBool
    {
        NotifiableBool _expression;
      
        public NotifiableBoolExpression() : this(new NotifiableConstBool(false))
        {
        }

        public NotifiableBoolExpression(bool value)
            : this(new NotifiableConstBool(value))
        {
        }

        public NotifiableBoolExpression(NotifiableBool expression)
        {
            _expression = expression;
            _expression.ValueChanged += new EventHandler(_expression_ValueChanged);
        }

        void _expression_ValueChanged(object sender, EventArgs e)
        {
            Notify(e);
        }


        public override bool Value
        {
            get { return _expression.Value; }
        }

        public NotifiableBool Expression
        {
            get { return _expression; }
            set 
            {
                if (_expression == value)
                    return;

                NotifiableBool tmp = _expression;

                _expression = value;

                if (tmp.Value != value.Value)
                    base.Notify(EventArgs.Empty);
            }
        }        
    }

    public class NotifiableConstBool : NotifiableBool
    {
        bool _value;

        public NotifiableConstBool(bool value)
        {
            _value = value;
        }

        public void setValue(bool value)
        {

            if (_value == value)
                return;

            _value = value;

            Notify(EventArgs.Empty);
        }

        public override bool Value
        {
            get
            {
                return _value;
            }
        }
    }


    public class NotifiableNotBool : NotifiableBool
    {
        NotifiableBool _val;


        public NotifiableNotBool(NotifiableBool val)
        {
            _val = val;
            _val.ValueChanged += new EventHandler(_val_ValueChanged);
        }

        void _val_ValueChanged(object sender, EventArgs e)
        {
            Notify(e);
        }

        public override bool Value
        {
            get { return !(_val.Value); }
        }
    }

    public class NotifiableAndBool : NotifiableBool
    {
        bool _value;
        NotifiableBool _val1;
        NotifiableBool _val2;

        public NotifiableAndBool(NotifiableBool val1, NotifiableBool val2)
        {
            _val1 = val1;
            _val2 = val2;
            _val1.ValueChanged += new EventHandler(operand_ValueChanged);
            _val2.ValueChanged += new EventHandler(operand_ValueChanged);
        }

        void operand_ValueChanged(object sender, EventArgs e)
        {
            bool tv = _val1.Value && _val2.Value;
            if (tv != _value)
            {
                _value = tv;
                Notify(e);
            }
        }

        public override bool Value
        {
            get 
            {
                return _val1.Value && _val2.Value;
            }
        }
    }

    public class NotifiableOrBool : NotifiableBool
    {
        bool _value;
        NotifiableBool _val1;
        NotifiableBool _val2;

        public NotifiableOrBool(NotifiableBool val1, NotifiableBool val2)
        {
            _val1 = val1;
            _val2 = val2;
            _val1.ValueChanged += new EventHandler(operand_ValueChanged);
            _val2.ValueChanged += new EventHandler(operand_ValueChanged);
        }

        void operand_ValueChanged(object sender, EventArgs e)
        {
            bool tv = _val1.Value || _val2.Value;
            if (tv != _value)
            {
                _value = tv;
                Notify(e);
            }
        }

        public override bool Value
        {
            get
            {
                return _val1.Value || _val2.Value;
            }
        }
    }