Welches CheckedListBox-Ereignis wird ausgelöst, nachdem ein Element überprüft wurde?

Ich habe eine CheckedListBox, in der ich ein Ereignis möchte, nachdem ein Element überprüft wurde, damit ich CheckedItems mit dem neuen Status verwenden kann.

Da ItemChecked ausgelöst wird, bevor CheckedItems aktualisiert wird, funktioniert es nicht sofort.

Welche Art von Methode oder Ereignis kann ich verwenden, um benachrichtigt zu werden, wenn CheckedItems aktualisiert wird?

Sie können das ItemCheckEreignis verwenden, wenn Sie auch den neuen Status des Elements überprüfen, auf das geklickt wird. Dies ist in den Ereignisargumenten als verfügbar e.NewValue. Wenn diese NewValueOption aktiviert ist, fügen Sie das aktuelle Element zusammen mit der eigentlichen Sammlung in Ihre Logik ein:

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

Als weiteres Beispiel, um festzustellen, ob die Sammlung leer ist, nachdem dieses Element (nicht) aktiviert wurde:

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

Es gibt viele verwandte StackOverflow-Beiträge zu diesem Thema ... Neben der Lösung von Branimir gibt es hier zwei weitere einfache:

Verzögerte Ausführung bei ItemCheck (auch hier ):

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

Verwenden des MouseUp-Ereignisses :

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

Ich bevorzuge die erste Option, da die zweite zu Fehlalarmen führen würde (dh zu oft feuern).

Ich habe es versucht und es hat funktioniert:

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

Ableiten von CheckedListBoxund implementieren

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

Obwohl dies nicht ideal ist, können Sie die CheckedItems mithilfe der Argumente berechnen, die an das ItemCheckEreignis übergeben werden. Wenn Sie sich dieses Beispiel auf MSDN ansehen , können Sie herausfinden, ob das neu geänderte Element aktiviert oder deaktiviert wurde, sodass Sie in einer geeigneten Position sind, um mit den Elementen zu arbeiten.

Sie können sogar ein neues Ereignis erstellen, das ausgelöst wird, nachdem ein Element überprüft wurde. Dadurch erhalten Sie genau das, was Sie möchten, wenn Sie dies wünschen.

Nach einigen Tests konnte ich feststellen, dass das Ereignis SelectedIndexChanged nach dem Ereignis ItemCheck ausgelöst wird. Behalten Sie die Eigenschaft CheckOnClick True bei

Beste Codierung

Dies funktioniert, nicht sicher, wie elegant es ist!

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

Ich weiß nicht, ob dies zutrifft, aber ich wollte ein Kontrollkästchen verwenden, um die Ergebnisse zu filtern. Da der Benutzer Elemente aktiviert und deaktiviert hat, sollte die Liste Elemente anzeigen / ausblenden.

Ich hatte einige Probleme, die mich zu diesem Beitrag führten. Ich wollte nur erzählen, wie ich es ohne etwas Besonderes gemacht habe.

Hinweis: Ich habe CheckOnClick = true, aber ohne würde es wahrscheinlich immer noch funktionieren

Das von mir verwendete Ereignis ist " SelectedIndexChanged ".

Die von mir verwendete Aufzählung lautet " .CheckedItems ".

Dies gibt die Ergebnisse, von denen ich denke, dass wir sie erwarten können. So vereinfacht kommt es darauf an ...

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

}

Angenommen, Sie möchten die Argumente beibehalten, werden ItemCheckaber benachrichtigt, nachdem das Modell geändert wurde, sollte dies folgendermaßen aussehen:

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

Wo CheckedItemsChangedkönnte sein:

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

Ich benutze einen Timer, um dieses Problem zu lösen. Aktivieren Sie den Timer über das ItemCheck-Ereignis. Ergreifen Sie Maßnahmen beim Timer's Tick-Event.

Dies funktioniert unabhängig davon, ob das Element per Mausklick oder durch Drücken der Leertaste überprüft wird. Wir werden die Tatsache ausnutzen, dass der gerade aktivierte (oder nicht aktivierte) Artikel immer der ausgewählte Artikel ist.

Das Intervall des Timers kann so niedrig wie 1 sein. Wenn das Tick-Ereignis ausgelöst wird, wird der neue Status "Überprüft" gesetzt.

Dieser VB.NET-Code zeigt das Konzept. Es gibt viele Variationen, die Sie verwenden können. Möglicherweise möchten Sie das Intervall des Timers erhöhen, damit der Benutzer den Prüfstatus für mehrere Elemente ändern kann, bevor er Maßnahmen ergreift. Führen Sie dann im Tick-Ereignis einen sequentiellen Durchlauf aller Elemente in der Liste durch, oder verwenden Sie die CheckedItems-Auflistung, um entsprechende Maßnahmen zu ergreifen.

Aus diesem Grund deaktivieren wir zuerst den Timer im ItemCheck-Ereignis. Deaktivieren und dann aktivieren bewirkt, dass die Intervallperiode neu gestartet wird.

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

Wenn wir bei normalem Verhalten ein Element überprüfen, ändert sich der Überprüfungsstatus des Elements, bevor der Ereignishandler ausgelöst wird. Eine CheckListBox hat jedoch ein anderes Verhalten: Der Ereignishandler wird ausgelöst, bevor sich der Prüfstatus des Elements ändert, und dies macht es schwierig, unsere Jobs zu korrigieren.

Um dieses Problem zu lösen, sollten wir meiner Meinung nach den Event-Handler verschieben.

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

Ich habe es versucht und es hat funktioniert:

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

Bestimmen Sie anhand des Index der Liste.