Qual evento CheckedListBox é disparado depois que um item é verificado?

Eu tenho um CheckedListBox onde desejo um evento após a verificação de um item para que eu possa usar CheckedItems com o novo estado.

Como ItemChecked é disparado antes de CheckedItems ser atualizado, ele não funcionará imediatamente.

Que tipo de método ou evento posso usar para ser notificado quando o CheckedItems for atualizado?

Você pode usar o ItemCheckevento, se também verificar o novo estado do item que está sendo clicado. Isso está disponível nos argumentos do evento, como e.NewValue. Se NewValueestiver marcada, inclua o item atual junto com a coleção adequada em sua lógica:

    private void checkedListBox1_ItemCheck(object sender, ItemCheckEventArgs e)
    {                     
        List<string> checkedItems = new List<string>();
        foreach (var item in checkedListBox1.CheckedItems)
            checkedItems.Add(item.ToString());

        if (e.NewValue == CheckState.Checked)
            checkedItems.Add(checkedListBox1.Items[e.Index].ToString());
        else
            checkedItems.Remove(checkedListBox1.Items[e.Index].ToString());

        foreach (string item in checkedItems)
        {
            ...
        }
    }

Como outro exemplo, para determinar se a coleção estará vazia após este item ser (des) marcado:

private void ListProjects_ItemCheck(object sender, ItemCheckEventArgs args)
{
    if (ListProjects.CheckedItems.Count == 1 && args.NewValue == CheckState.Unchecked)
        // The collection is about to be emptied: there's just one item checked, and it's being unchecked at this moment
        ...
    else
        // The collection will not be empty once this click is handled
        ...
}

Existem várias postagens StackOverflow relacionadas a isso ... Além da solução de Branimir , aqui estão duas outras simples:

Execução atrasada no ItemCheck (também aqui ):

    void checkedListBox1_ItemCheck(object sender, ItemCheckEventArgs e)
    {
        this.BeginInvoke((MethodInvoker) (
            () => Console.WriteLine(checkedListBox1.SelectedItems.Count)));
    }

Usando o evento MouseUp :

    void checkedListBox1_MouseUp(object sender, MouseEventArgs e)
    {
        Console.WriteLine(checkedListBox1.SelectedItems.Count);
    }

Prefiro a primeira opção, pois a segunda resultaria em falsos positivos (ou seja, disparar com muita frequência).

Eu tentei isso e funcionou:

private void clbOrg_ItemCheck(object sender, ItemCheckEventArgs e)
{
    CheckedListBox clb = (CheckedListBox)sender;
    // Switch off event handler
    clb.ItemCheck -= clbOrg_ItemCheck;
    clb.SetItemCheckState(e.Index, e.NewValue);
    // Switch on event handler
    clb.ItemCheck += clbOrg_ItemCheck;

    // Now you can go further
    CallExternalRoutine();        
}

Derivar CheckedListBoxe implementar

/// <summary>
/// Raises the <see cref="E:System.Windows.Forms.CheckedListBox.ItemCheck"/> event.
/// </summary>
/// <param name="ice">An <see cref="T:System.Windows.Forms.ItemCheckEventArgs"/> that contains the event data.
///                 </param>
protected override void OnItemCheck(ItemCheckEventArgs e)
{           
    base.OnItemCheck(e);

    EventHandler handler = AfterItemCheck;
    if (handler != null)
    {
        Delegate[] invocationList = AfterItemCheck.GetInvocationList();
        foreach (var receiver in invocationList)
        {
            AfterItemCheck -= (EventHandler) receiver;
        }

        SetItemCheckState(e.Index, e.NewValue);

        foreach (var receiver in invocationList)
        {
            AfterItemCheck += (EventHandler) receiver;
        }
    }
    OnAfterItemCheck(EventArgs.Empty);
}

public event EventHandler AfterItemCheck;

public void OnAfterItemCheck(EventArgs e)
{
    EventHandler handler = AfterItemCheck;
    if (handler != null)
        handler(this, e);
}

Embora não seja ideal, você pode calcular os CheckedItems usando os argumentos que são passados ​​para o ItemCheckevento. Se você olhar este exemplo no MSDN , poderá descobrir se o item recém-alterado foi marcado ou desmarcado, o que o deixa em uma posição adequada para trabalhar com os itens.

Você pode até criar um novo evento que dispara depois que um item é verificado, o que lhe daria exatamente o que você queria, se desejasse.

Após alguns testes, pude constatar que o evento SelectedIndexChanged é acionado após o evento ItemCheck. Manter a propriedade CheckOnClick True

Melhor codificação

Isso funciona, mas não tenho certeza de como é elegante!

Private Sub chkFilters_Changed(ByVal sender As System.Object, ByVal e As System.EventArgs) Handles chkFilters.ItemCheck
    Static Updating As Boolean
    If Updating Then Exit Sub
    Updating = True

    Dim cmbBox As CheckedListBox = sender
    Dim Item As ItemCheckEventArgs = e

    If Item.NewValue = CheckState.Checked Then
        cmbBox.SetItemChecked(Item.Index, True)
    Else
        cmbBox.SetItemChecked(Item.Index, False)
    End If

    'Do something with the updated checked box
    Call LoadListData(Me, False)

    Updating = False
End Sub

Não sei se isso se aplica, mas eu queria usar uma caixa de seleção para filtrar os resultados. Assim, conforme o usuário marcava e desmarcava os itens, eu queria que a lista mostrasse / ocultasse os itens.

Eu estava tendo alguns problemas que me levaram a este post. Só queria compartilhar como fiz isso, sem nada de especial.

Nota: Tenho CheckOnClick = true, mas provavelmente ainda funcionaria sem

O evento que uso é " SelectedIndexChanged "

a enumeração que uso é " .CheckedItems "

Isso dá os resultados que acho que podemos esperar. Tão simplificado se resume a ....

private void clb1_SelectedIndexChanged(object sender, EventArgs e)
{
   // This just spits out what is selected for testing
   foreach (string strChoice in clb1.CheckedItems)
   {
      listBox1.Items.Add(strChoice);
   }

   //Something more like what I'm actually doing
   foreach (object myRecord in myRecords)
   {
        if (clb1.CheckItems.Contains(myRecord["fieldname"])
        {
            //Display this record
        }
   }

}

Supondo que você queira preservar os argumentos, ItemCheckmas seja notificado depois que o modelo for alterado, deve ser assim:

CheckedListBox ctrl = new CheckedListBox();
ctrl.ItemCheck += (s, e) => BeginInvoke((MethodInvoker)(() => CheckedItemsChanged(s, e)));

Onde CheckedItemsChangedpoderia ser:

private void CheckedItemsChanged(object sender, EventArgs e)
{
    DoYourThing();
}

Eu uso um Timer para resolver este problema. Habilite o cronômetro por meio do evento ItemCheck. Tome uma atitude no evento Timer's Tick.

Isso funciona se o item é verificado através de um clique do mouse ou pressionando a barra de espaço. Aproveitaremos o fato de que o item que acabou de ser marcado (ou desmarcado) é sempre o Item selecionado.

O intervalo do temporizador pode ser tão baixo quanto 1. No momento em que o evento Tick é gerado, o novo status Verificado será definido.

Este código VB.NET mostra o conceito. Existem muitas variações que você pode empregar. Você pode querer aumentar o intervalo do temporizador para permitir que o usuário altere o status de verificação em vários itens antes de agir. Em seguida, no evento Tick, faça uma passagem sequencial de todos os itens na lista ou use sua coleção CheckedItems para tomar a ação apropriada.

É por isso que primeiro desabilitamos o Timer no evento ItemCheck. Desativar e Ativar faz com que o período de intervalo seja reiniciado.

Private Sub ckl_ItemCheck(ByVal sender As Object, _
                          ByVal e As System.Windows.Forms.ItemCheckEventArgs) _
    Handles ckl.ItemCheck

tmr.Enabled = False
tmr.Enabled = True

End Sub


Private Sub tmr_Tick(ByVal sender As System.Object, _
                     ByVal e As System.EventArgs) _
    Handles tmr.Tick

tmr.Enabled = False
Debug.Write(ckl.SelectedIndex)
Debug.Write(": ")
Debug.WriteLine(ckl.GetItemChecked(ckl.SelectedIndex).ToString)

End Sub

No comportamento normal, quando verificamos um item, o estado de verificação do item muda antes que o manipulador de eventos seja acionado. Mas um CheckListBox tem um comportamento diferente: o manipulador de eventos é gerado antes que o estado de verificação do item seja alterado e isso torna difícil corrigir nossos trabalhos.

Em minha opinião, para resolver esse problema, devemos adiar o manipulador de eventos.

private void _clb_ItemCheck(object sender, ItemCheckEventArgs e) {
 // Defer event handler execution
 Task.Factory.StartNew(() => {
     Thread.Sleep(1000);
     // Do your job at here
 })
 .ContinueWith(t => {
     // Then update GUI at here
 },TaskScheduler.FromCurrentSynchronizationContext());}

Eu tentei isso e funcionou:

    private List<bool> m_list = new List<bool>();
    private void Initialize()
    {
        for(int i=0; i < checkedListBox1.Items.Count; i++)
        {
            m_list.Add(false);
        }
    }

    private void checkedListBox1_ItemCheck(object sender, ItemCheckEventArgs e)
    {
        if (e.NewValue == CheckState.Checked)
        {
            m_list[e.Index] = true;
            checkedListBox1.SetItemChecked(e.Index, true);
        }
        else
        {
            m_list[e.Index] = false;
            checkedListBox1.SetItemChecked(e.Index, false);
        }
    }

determinar pelo índice da lista.