C# – Winforms DataBinding vs PropertyChanged Event Ordering Issue

cdata-bindingeventswinforms

I'm sorry if this has been asked before, but I did try digging through the multitude of DataBinding questions available and couldn't find one that matched my problem.

I'm doing a unidirectional databinding between a listbox index and some property on one of my entities, but I also need to run some additional logic after the databinding takes place. I tried doing it like this:

listBox.DataBindings.Add("SelectedIndex", entity, "Property", true, DataSourceUpdateMode.OnPropertyChanged);
listBox.SelectedIndexChanged += (s,e) => view.Refresh();

The problem is that the event handler runs before the databinding updates, but view.Refresh() depends on the value of entity.Property being updated. This results in my view not being refreshed until the the next time I change my index.

Is there any way to solve this with databinding? At the moment I've resorted to not using databinding whenever I have this scenario, and doing it manually instead:

listBox.SelectedIndex = entity.Property;
listBox.SelectedIndexChanged += OnIndexChanged;

private void OnIndexChanged(object sender, EventArgs e)
{
    entity.Property = listBox.SelectedIndex;
    view.Refresh();
}

But I'd prefer to avoid this since I'm using databinding for everything else and would like to keep consistency.

Update

I've found the solution. It looks like the Binding object itself holds BindingComplete event which is perfect for this. And since the DataBindings.Add method returns me the Binding object I can chain both together. My code therefore becomes:

listBox.DataBindings.Add("SelectedIndex", entity, "Property", true, DataSourceUpdateMode.OnPropertyChanged).BindingComplete += (s,e) => view.Refresh();

My only question now is if need to take care of unregistering this event manually, or if I can just call listBox.DataBindings.Clear(); and be done with it.

Best Answer

The method you're using returns an instance of a Binding. Why not listen to the BindingComplete event of the returned binding and call the Refresh method from there? The code will probably need to evaluate fields such as BindingCompleteContext and Exception to ensure the event is being triggered on a datasource change. You don't need to call listBox.DataBindings.Clear(). The bindings get removed when the control is disposed. You usually don't need to manually unregister the event, and I think in you're case, you don't need to manually unregister the event.

Related Solutions

C# – Deep cloning objects

Whereas one approach is to implement the ICloneable interface (described here, so I won't regurgitate), here's a nice deep clone object copier I found on The Code Project a while ago and incorporated it into our code. As mentioned elsewhere, it requires your objects to be serializable.

using System;
using System.IO;
using System.Runtime.Serialization;
using System.Runtime.Serialization.Formatters.Binary;

/// <summary>
/// Reference Article http://www.codeproject.com/KB/tips/SerializedObjectCloner.aspx
/// Provides a method for performing a deep copy of an object.
/// Binary Serialization is used to perform the copy.
/// </summary>
public static class ObjectCopier
{
    /// <summary>
    /// Perform a deep copy of the object via serialization.
    /// </summary>
    /// <typeparam name="T">The type of object being copied.</typeparam>
    /// <param name="source">The object instance to copy.</param>
    /// <returns>A deep copy of the object.</returns>
    public static T Clone<T>(T source)
    {
        if (!typeof(T).IsSerializable)
        {
            throw new ArgumentException("The type must be serializable.", nameof(source));
        }

        // Don't serialize a null object, simply return the default for that object
        if (ReferenceEquals(source, null)) return default;

        using var Stream stream = new MemoryStream();
        IFormatter formatter = new BinaryFormatter();
        formatter.Serialize(stream, source);
        stream.Seek(0, SeekOrigin.Begin);
        return (T)formatter.Deserialize(stream);
    }
}

The idea is that it serializes your object and then deserializes it into a fresh object. The benefit is that you don't have to concern yourself about cloning everything when an object gets too complex.

In case of you prefer to use the new extension methods of C# 3.0, change the method to have the following signature:

public static T Clone<T>(this T source)
{
   // ...
}

Now the method call simply becomes objectBeingCloned.Clone();.

EDIT (January 10 2015) Thought I'd revisit this, to mention I recently started using (Newtonsoft) Json to do this, it should be lighter, and avoids the overhead of [Serializable] tags. (NB @atconway has pointed out in the comments that private members are not cloned using the JSON method)

/// <summary>
/// Perform a deep Copy of the object, using Json as a serialization method. NOTE: Private members are not cloned using this method.
/// </summary>
/// <typeparam name="T">The type of object being copied.</typeparam>
/// <param name="source">The object instance to copy.</param>
/// <returns>The copied object.</returns>
public static T CloneJson<T>(this T source)
{            
    // Don't serialize a null object, simply return the default for that object
    if (ReferenceEquals(source, null)) return default;

    // initialize inner objects individually
    // for example in default constructor some list property initialized with some values,
    // but in 'source' these items are cleaned -
    // without ObjectCreationHandling.Replace default constructor values will be added to result
    var deserializeSettings = new JsonSerializerSettings {ObjectCreationHandling = ObjectCreationHandling.Replace};

    return JsonConvert.DeserializeObject<T>(JsonConvert.SerializeObject(source), deserializeSettings);
}

C# – How to remove all event handlers from an event

I found a solution on the MSDN forums. The sample code below will remove all Click events from button1.

public partial class Form1 : Form
{
    public Form1()
    {
        InitializeComponent();

        button1.Click += button1_Click;
        button1.Click += button1_Click2;
        button2.Click += button2_Click;
    }

    private void button1_Click(object sender, EventArgs e)  => MessageBox.Show("Hello");
    private void button1_Click2(object sender, EventArgs e) => MessageBox.Show("World");
    private void button2_Click(object sender, EventArgs e)  => RemoveClickEvent(button1);

    private void RemoveClickEvent(Button b)
    {
        FieldInfo f1 = typeof(Control).GetField("EventClick", 
            BindingFlags.Static | BindingFlags.NonPublic);

        object obj = f1.GetValue(b);
        PropertyInfo pi = b.GetType().GetProperty("Events",  
            BindingFlags.NonPublic | BindingFlags.Instance);

        EventHandlerList list = (EventHandlerList)pi.GetValue(b, null);
        list.RemoveHandler(obj, list[obj]);
    }
}

Best Answer

Related Solutions

C# – Deep cloning objects

C# – How to remove all event handlers from an event

Related Topic