Why doesn't a bound value persist to the datasource the first time it changes when using EndCurrentEdit?

Question

I have a CheckBox that has it's Checked property bound to a bool value. During the CheckedChanged event, some logic runs which uses the bool property on the data source.

My problem is the first time the CheckBox gets checked by the user, the bound data source does not get updated. Subsequent updates work fine though.

Here's some sample code for testing the problem. Just create a blank form and add a CheckBox to it.

public partial class Form1 : Form
{
    private bool _testBool;
    public bool TestBool
    {
        get { return _testBool; }
        set { _testBool = value; }
    }

    public Form1()
    {
        InitializeComponent();

        checkBox1.DataBindings.Add(new Binding("Checked", this, "TestBool"));
        checkBox1.CheckedChanged += new EventHandler(checkBox1_CheckedChanged);
    }

    void checkBox1_CheckedChanged(object sender, EventArgs e)
    {
        checkBox1.BindingContext[this].EndCurrentEdit();

        Debug.WriteLine(TestBool.ToString());
    }
}

The first time I check the box, the TestBool property remains at false, even though checkBox1.Checked is set to true. Subsequent changes do correctly update the TestBool property to match checkBox1.Checked though.

If I add a breakpoint to the CheckedChanged event and check out checkBox1.BindingContext[this].Bindings[0] from the immediate window, I can see that modified = false the first time it runs, which is probably why EndCurrentEdit() is not correctly updating the data source.

The same thing also occurs with using a TextBox and the TextChanged event, so this isn't limited to just CheckBox.Checked.

Why is this? And is there a generic common way of fixing the problem?

Edit: I know of a few workarounds so far, although none are ideal since they are not generic and need to be remembered everytime we want to use a Changed event.

• setting the property on the datasource directly from the CheckedChanged event
• finding the binding and calling WriteValue()
• hooking up the bindings after the control has been loaded

I am more concerned with learning why this is happening, although if someone knows of a standard generic solution to prevent it from happening that does not rely on any special coding in the Changed event, I'd be happy with that too.

Answer 1

Controls usually want to go through their validation first before writing to the data source, so the writing of the value usually won't happen until you try to leave the control.

You can force the writing of the value yourself:

void checkBox1_CheckedChanged(object sender, EventArgs e) {
  Binding b = checkBox1.DataBindings["Checked"];
  if (b != null) {
    b.WriteValue();
  }
  Debug.WriteLine(TestBool.ToString());
}

Answer 2

Apparently, the CheckedChanged event is too early in the process.

But you can leverage BindingComplete:

public partial class Form1 : Form
{
    private Boolean _testBool;
    public Boolean TestBool
    {
        get { return _testBool; }
        set { _testBool = value; }
    }

    public Form1()
    {
        InitializeComponent();

        checkBox1.DataBindings.Add(new Binding("Checked", this, "TestBool", true, DataSourceUpdateMode.OnPropertyChanged));
        checkBox1.DataBindings[0].BindingComplete += Form1_BindingComplete;
    }

    private void Form1_BindingComplete(Object sender, BindingCompleteEventArgs e)
    {
        Debug.WriteLine("BindingComplete:  " + TestBool.ToString());
    }
}

Note that the event will fire at startup as the initial bind linkage occurs. You will have to deal with that possible unintended consequence, but otherwise, it works on the first click and every click.

Also note that the true (format) is required in the Binding constructor to make the event fire.

Answer 3

The closest I can find for an explanation to this behavior is this 3rd party explanation

Basically, this is an issue of timing. The way binding works in DotNet is actually very simple. There's no magic in the DotNet framework that tells the BindingManager when something changes. What it does is, when you bind to a property (such as CheckedValue) The BindingManager looks for an event on the control called propertynameChanged (e.g. "CheckedValueChanged"). This is the same event your code is hooking into on your sample form.

When the control fires the event, the order in which the listeners receive the event is arbitrary. There's no reliable way to tell whether the BindingManager will get the event first or the Form will.

My CheckBox1_CheckChanged event is running before the BindingManager handles the changed event, so the data source hasn't been updated at this time.

My best guess as to why this only happens the first time is that the control isn't visible yet, so some code doesn't get run that should fix the order events get handled in. I've seen other posts about not being able to bind to non-visible items due to the handle not being created yet, and one answer states

Until the control is visible for the first time some back-end initialization never happens, and part of that initialization is enabling the data binding.

So I suspect that this is somehow related.

I can verify that if I attach the Changed handler later on such as during the Load event, it works as I would expect.

public partial class Form1 : Form
{
    private bool _testBool;
    public bool TestBool
    {
        get { return _testBool; }
        set { _testBool = value; }
    }

    public Form1()
    {
        InitializeComponent();

        checkBox1.DataBindings.Add(new Binding("Checked", this, "TestBool"));
        Load += new EventHandler(Form1_Load);
    }

    void Form1_Load(object sender, EventArgs e)
    {
        checkBox1.CheckedChanged += new EventHandler(checkBox1_CheckedChanged);
    }

    void checkBox1_CheckedChanged(object sender, EventArgs e)
    {
        // Not needed anymore
        //checkBox1.BindingContext[this].EndCurrentEdit();

        Debug.WriteLine(TestBool.ToString());
    }
}