Quel événement CheckedListBox se déclenche après la vérification d'un élément?

J'ai un CheckedListBox où je veux un événement après qu'un élément est vérifié afin que je puisse utiliser CheckedItems avec le nouvel état.

Étant donné qu'ItemChecked est déclenché avant la mise à jour de CheckedItems, cela ne fonctionnera pas immédiatement.

Quel type de méthode ou d'événement puis-je utiliser pour être averti lorsque CheckedItems est mis à jour?

Vous pouvez utiliser l' ItemCheckévénement si vous vérifiez également le nouvel état de l'élément sur lequel l'utilisateur clique. Ceci est disponible dans l'événement args, comme e.NewValue. Si NewValueest coché, incluez l'élément actuel avec la collection appropriée dans votre logique:

    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)
        {
            ...
        }
    }

Comme autre exemple, pour déterminer si la collection sera vide une fois que cet élément est (non) vérifié:

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
        ...
}

Il y a beaucoup d'articles liés à StackOverflow à ce sujet ... En plus de la solution de Branimir , en voici deux plus simples:

Exécution retardée sur ItemCheck (également ici ):

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

Utilisation de l'événement MouseUp :

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

Je préfère la première option, car la seconde entraînerait des faux positifs (c'est-à-dire tirant trop souvent).

Je l'ai essayé et ça marche:

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();        
}

Dériver CheckedListBoxet mettre en œuvre

/// <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);
}

Bien que ce ne soit pas idéal, vous pouvez calculer les CheckedItems à l'aide des arguments transmis à l' ItemCheckévénement. Si vous regardez cet exemple sur MSDN , vous pouvez déterminer si l'élément nouvellement modifié a été coché ou non, ce qui vous laisse dans une position appropriée pour travailler avec les éléments.

Vous pouvez même créer un nouvel événement qui se déclenche après la vérification d'un élément, ce qui vous donnerait exactement ce que vous vouliez si vous le souhaitiez.

Après quelques tests, j'ai pu voir que l'événement SelectedIndexChanged est déclenché après l'événement ItemCheck. Conservez la propriété CheckOnClick True

Meilleur codage

Cela fonctionne, je ne sais pas à quel point c'est élégant!

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

Je ne sais pas si cela s'applique, mais je voulais utiliser une liste de contrôle pour filtrer les résultats. Donc, comme l'utilisateur a vérifié et décoché les éléments, je voulais que la liste affiche \ masquer les éléments.

J'avais des problèmes qui m'ont conduit à ce post. Je voulais juste partager comment je l'ai fait sans rien de spécial.

Remarque: j'ai CheckOnClick = true mais cela fonctionnerait probablement toujours sans

L'événement que j'utilise est " SelectedIndexChanged "

l'énumération que j'utilise est " .CheckedItems "

Cela donne les résultats auxquels je pense que nous pouvons nous attendre. Si simplifié, cela revient à ...

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
        }
   }

}

En supposant que vous souhaitiez conserver les arguments de ItemCheckmais être notifié après la modification du modèle, cela devrait ressembler à ceci:

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

Où CheckedItemsChangedpourrait être:

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

J'utilise une minuterie pour résoudre ce problème. Activez le minuteur via l'événement ItemCheck. Agissez dans l'événement Timer's Tick.

Cela fonctionne que l'élément soit vérifié via un clic de souris ou en appuyant sur la barre d'espace. Nous profiterons du fait que l'élément qui vient d'être coché (ou non coché) est toujours l'élément sélectionné.

L'intervalle de la minuterie peut être aussi bas que 1. Au moment où l'événement Tick est déclenché, le nouvel état Vérifié sera défini.

Ce code VB.NET montre le concept. Il existe de nombreuses variantes que vous pouvez utiliser. Vous souhaiterez peut-être augmenter l'intervalle du minuteur pour permettre à l'utilisateur de modifier l'état de vérification de plusieurs éléments avant d'agir. Ensuite, dans l'événement Tick, effectuez un passage séquentiel de tous les éléments de la liste ou utilisez sa collection CheckedItems pour prendre les mesures appropriées.

C'est pourquoi nous désactivons d'abord le minuteur dans l'événement ItemCheck. Désactiver puis Activer entraîne le redémarrage de la période d'intervalle.

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

Dans un comportement normal, lorsque nous vérifions un élément, l'état de vérification de l'élément changera avant que le gestionnaire d'événements ne soit déclenché. Mais un CheckListBox a un comportement différent: le gestionnaire d'événements est déclenché avant que l'état de vérification de l'élément change et cela rend difficile la correction de nos travaux.

À mon avis, pour résoudre ce problème, nous devrions différer le gestionnaire d'événements.

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());}

Je l'ai essayé et ça marche:

    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);
        }
    }

déterminer par index de la liste.