c# - ejemplos - checkedlistbox vb net checked items

¿Qué evento CheckedListBox se activa después de que un elemento está marcado?

Question

Tengo un CheckedListBox en el que quiero un evento después de que se ha marcado un elemento para poder usar CheckedItems con el nuevo estado.

Como ItemChecked se activa antes de que se actualice CheckedItems, no funcionará de la caja.

¿Qué tipo de método o evento puedo usar para recibir una notificación cuando se actualicen CheckedItems?

Answer 1

Aunque no es ideal, puede calcular CheckedItems utilizando los argumentos que se pasan al evento ItemCheck . Si observa este ejemplo en MSDN , puede determinar si el elemento recientemente modificado se ha marcado o no, lo que lo deja en una posición adecuada para trabajar con los elementos.

Incluso podría crear un nuevo evento que se active después de marcar un elemento, lo que le daría exactamente lo que deseaba si lo deseaba.

Answer 2

Derivar de CheckedListBox e 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);
}

Answer 3

Después de algunas pruebas, pude ver que el evento SelectedIndexChanged se desencadena después del evento ItemCheck. Mantenga la propiedad CheckOnClick True

Mejor codificación

Answer 4

En el comportamiento normal, cuando verificamos un elemento, el estado de verificación del elemento cambiará antes de que se eleve el manejador de eventos. Pero CheckListBox funciona con un comportamiento diferente: el controlador de eventos eleva antes de comprobar el estado del cambio de elemento y dificulta la corrección de nuestros trabajos.

En mi opinión, para resolver este problema, debemos diferir el controlador 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());}

Answer 5

Esto funciona, aunque no estoy seguro de lo elegante que es.

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

Answer 6

Hay muchas publicaciones relacionadas con en este ... Además de Branimir''s solución Branimir''s , aquí hay dos más simples:

Ejecución retrasada en ItemCheck (también here ):

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

Usando el evento MouseUp :

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

Prefiero la primera opción, ya que la segunda daría lugar a falsos positivos (es decir, disparando con demasiada frecuencia).

Answer 7

Intenté esto y funcionó:

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

Answer 8

No sé si esto aplica, pero quería usar una lista de verificación para filtrar los resultados. Entonces, a medida que el usuario marcó y desmarcó los elementos, quise que la lista mostrara / ocultar elementos.

Estaba teniendo algunos problemas que me llevaron a esta publicación. Solo quería compartir cómo lo hice sin nada especial.

Nota: Tengo CheckOnClick = verdadero, pero probablemente todavía funcione sin

El evento que uso es " SelectedIndexChanged "

la enumeración que uso es " .CheckedItems "

Esto da los resultados que creo que podemos esperar. Tan simplificado se reduce 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
        }
   }

}

Answer 9

Suponiendo que desea conservar los argumentos de ItemCheck pero recibir una notificación después de que se modificó el modelo, debería tener el siguiente aspecto:

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

Donde CheckedItemsChanged podría ser:

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

Answer 10

Yo uso un temporizador para resolver este problema. Habilite el temporizador mediante el evento ItemCheck. Actúa en el evento Timer''s Tick.

Esto funciona si el elemento se comprueba con un clic del mouse o presionando la barra espaciadora. Aprovecharemos el hecho de que el artículo que acaba de marcarse (o no) siempre es el Elemento seleccionado.

El intervalo del temporizador puede ser tan bajo como 1. Para cuando se produce el evento Tick, se establecerá el nuevo estado verificado.

Este código de VB.NET muestra el concepto. Hay muchas variaciones que puede emplear. Es posible que desee aumentar el intervalo del temporizador para permitir al usuario cambiar el estado de verificación en varios elementos antes de tomar medidas. Luego, en el evento Tick, haga un pase secuencial de todos los elementos en la lista o use su colección CheckedItems para tomar las medidas apropiadas.

Es por eso que primero desactivamos el temporizador en el evento ItemCheck. Desactivar y Activar hace que el período de intervalo vuelva a iniciarse.

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

Answer 11

Puede usar el evento ItemCheck , si también verifica el nuevo estado del elemento que se está haciendo clic. Esto está disponible en el evento args, como e.NewValue . Si se NewValue , incluya el elemento actual junto con la colección propia en su 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 otro ejemplo, para determinar si la colección estará vacía después de que (item) esté 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
        ...
}