Различие между событиями, вызванными взаимодействием с пользователем, и моим собственным кодом

Я создал класс, который назвал SuspendLatch. Предложения о лучшем имени приветствуются, но оно делает то, что вам нужно, и вы можете использовать его так:

void Method()
{
    using (suspendLatch.GetToken())
    {
        // Update selected index etc
    }
}

void listbox1_SelectedIndexChanged(object sender, EventArgs e)
{
    if (suspendLatch.HasOutstandingTokens)
    {
        return;
    }

    // Do some work
}

Это некрасиво, но работает, и, в отличие от событий отмены регистрации или логических флагов, поддерживает вложенные операции, немного похожие на TransactionScope. Вы продолжаете брать токены из защелки, и только когда последний токен удален, HasOutstandingTokens возвращает false. Красиво и безопасно. Но не поточно ...

Вот код SuspendLatch:

public class SuspendLatch
{
    private IDictionary<Guid, SuspendLatchToken> tokens = new Dictionary<Guid, SuspendLatchToken>();

    public SuspendLatchToken GetToken()
    {
        SuspendLatchToken token = new SuspendLatchToken(this);
        tokens.Add(token.Key, token);
        return token;
    }

    public bool HasOutstandingTokens
    {
        get { return tokens.Count > 0; }
    }

    public void CancelToken(SuspendLatchToken token)
    {
        tokens.Remove(token.Key);
    }

    public class SuspendLatchToken : IDisposable
    {
        private bool disposed = false;
        private Guid key = Guid.NewGuid();
        private SuspendLatch parent;

        internal SuspendLatchToken(SuspendLatch parent)
        {
            this.parent = parent;
        }

        public Guid Key
        {
            get { return this.key; }
        }

        public override bool Equals(object obj)
        {
            SuspendLatchToken other = obj as SuspendLatchToken;

            if (other != null)
            {
                return Key.Equals(other.Key);
            }
            else
            {
                return false;
            }
        }

        public override int GetHashCode()
        {
            return Key.GetHashCode();
        }

        public override string ToString()
        {
            return Key.ToString();
        }

        public void Dispose()
        {
            Dispose(true);
            GC.SuppressFinalize(this);
        }

        protected virtual void Dispose(bool disposing)
        {
            if (!disposed)
            {
                if (disposing)
                {
                    // Dispose managed resources.
                    parent.CancelToken(this);
                }

                // There are no unmanaged resources to release, but
                // if we add them, they need to be released here.
            }
            disposed = true;

            // If it is available, make the call to the
            // base class's Dispose(Boolean) method
            //base.Dispose(disposing);
        }
    }
}

Я думаю, что лучше всего было бы использовать переменную флага:

bool updatingCheckbox = false;

void updateCheckBox()
{
    updatingCheckBox = true;

    checkbox.Checked = true;

    updatingCheckBox = false;
}

void checkbox_CheckedChanged( object sender, EventArgs e )
{
    if (!updatingCheckBox)
        PerformActions()
}

[Изменить: публикация только кода не совсем понятна]

В этом случае обработчик событий не будет выполнять свои обычные операции при изменении флажка с помощью updateCheckBox ().

Я всегда использовал логическую переменную флага для защиты от нежелательных обработчиков событий. Пример приложения TaskVision научил меня это делать.

Ваш код обработчика событий для всех ваших событий будет выглядеть так:

private bool lockEvents;

protected void MyEventHandler(object sender, EventArgs e)
{
    if (this.lockEvents)
    {
        return;
    }

    this.lockEvents = true;
    //Handle your event...
    this.lockEvents = false;
}

Я позволил событию загореться. Но я устанавливаю флаг перед изменением индекса и возвращаю его обратно после. В обработчике событий я проверяю, установлен ли флаг, и выхожу из обработчика, если он установлен.

Я думаю, вы должны сосредоточиться на объекте, а не на происходящем событии.

Скажем, например, у вас мероприятие

void combobox_Changed( object sender, EventArgs e )
{
    PerformActions()
}

и PerformActions сделали что-то,

void PerformActions()
{
    (listBox.SelectedItem as IPerson).Nationality = 
        (comboBox.SelectedItem as INationality)
}

то внутри человека вы ожидаете увидеть что-то вроде

class Person: IPerson
{
    INationality Nationality
    {
        get { return m_nationality; }
        set 
        {
          if (m_nationality <> value)
          {
             m_nationality = value;
             this.IsDirty = true;
          }
        }
    }
}

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

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

Я наконец-то нашел решение, чтобы избежать слишком частого срабатывания ненужного события.

Я использую счетчик и подключаю / отключаю события, которые хочу замаскировать, только один раз, когда он не нужен, и когда он снова нужен.

В приведенном ниже примере показано, как я скрываю событие CellValueChanged таблицы данных.

EventMask valueChangedEventMask;

// In the class constructor
valueChangedEventMask = new EventMask(
    () => { dgv.CellValueChanged += new DataGridViewCellEventHandler(dgv_CellValueChanged); },
    () => { dgv.CellValueChanged -= new DataGridViewCellEventHandler(dgv_CellValueChanged); }
);

// Use push to hide the event and pop to make it available again. The operation can be nested or be used in the event itself.
void changeCellOperation()
{
    valueChangedEventMask.Push();

    ...
    cell.Value = myNewCellValue
    ...

    valueChangedEventMask.Pop();
}

// The class
public class EventMask
{
    Action hook;
    Action unHook;

    int count = 0;

    public EventMask(Action hook, Action unHook)
    {
        this.hook = hook;
        this.unHook = unHook;
    }

    public void Push()
    {
        count++;
        if (count == 1)
            unHook();
    }

    public void Pop()
    {
        count--;
        if (count == 0)
            hook();
    }
}