Introduction

• We are going to go deeper on customized use of the BindingSource class than you will need for pure data operations.
• For later work, you will be able to drag a table onto a form and get most of this done automatically.
• I hope the detail here will give you clearer picture of what is going on under the surface.
• Code for this is in project VS\BasicBindingSource.

BindingSource

• A BindingSource is the preferred data source for applications.
• Supports binding to
  • database tables
  • web services
  • objects
• For this example, we will bind to an object type.
• The BindingSource object can be bound to any collection supporting IList, but editing of list contents and event responsiveness need an IBindingList/BindingList.
• The BindingSource object can manage the list itself, given only the type of element in the list. This is what we do in this example.
• The BindingSource object has Filter and Sort properties that can be used to, well, filter and sort the items that are shown.
• By managing the list (or being given an IBindingList), the BindingSource can respond to list changes and can initiate list changes.
• If the underlying elements support IEditableObject, they support BeginEdit/EndEdit/CancelEdit operations.
• If the underlying elements support the INotifyPropertyChanged event, then changes made to an element in the list will be noticed by the BindingSource, which will notify anyone bound to it, which will cause them to update their displays.
• DataTable.Rows supports IBindingList
• DataRow supports IEditableObject and INotifyPropertyChanged.

 

• We will develop our own type that supports IEditableObject and INotifyPropertyChanged.
  • (This is overkill for simple display-only applications.)
• We will then data-bind some controls to a BindingSource maintaining a list of these objects.

IEditableObject

• An editable object supports BeginEdit / EndEdit / CancelEdit.
• To support cancellation, the object needs to keep backup copies of original values for public properties in order to restore them if CancelEdit is called.
• The contract for IEditableObject says the additional calls to BeginEdit while an edit is in process have no effect.

To design this, we take the Student class defined earlier, and extract an interface. Here is the code:

    interface IStudent
    {
        int Grade { get; set; }
        Color GradeColor { get; }
        string Name { get; set; }
    }
	
	public class Student : IStudent
    {

       // other code unchanged, following added:

        internal new Student MemberwiseClone()
        {
            return new Student(this.name, this.grade);
        }
    }

We now add a new class, EditableStudent, that keeps one copy of the student data as current, and keeps as backup copy as necessary. It also has flag indicating if an edit is in process.

   public class EditableStudent : IStudent, IEditableObject, INotifyPropertyChanged
    {

        #region Basics
		
        Student m_currentData;
        Student m_backupData;
        bool m_inTx = false;


        public EditableStudent()
        {
            m_currentData = new Student();
            m_backupData = null;
        }


        public EditableStudent(string name, int grade)
        {
            m_currentData = new Student(name, grade);
            m_backupData = null;
        }


        public override string ToString()
        {
            return m_currentData.ToString();
        }


        #endregion


        #region IEditableObject Members


        public void BeginEdit()
        {
            if (!m_inTx)
            {
                m_backupData = m_currentData.MemberwiseClone();
                m_inTx = true;
            }
        }


        public void CancelEdit()
        {
            if (m_inTx)
            {
                m_currentData = m_backupData;
                m_inTx = false;
            }
        }


        public void EndEdit()
        {
            if (m_inTx)
            {
                m_backupData = null;
                m_inTx = false;
            }
        }


        #endregion
   
       /// ...
    }

INotifyPropertyChanged

• The INotifyPropertyChanged event provides a simple notification that a property has changed.
• We provide a public event variable for subscribers.
• We have to code all public property changes to signal this event.
• The argument to the event is of of type PropertyChangedEventArgs. It is initialized with a string which is the name of the property that changed.
• For this example, the implementation of the methods for IStudent have to trigger the event whenever a property value is changed.

     public class EditableStudent : IStudent, IEditableObject, INotifyPropertyChanged
      {
          // ...
  
  
  
          #region IStudent Members
  
  
          public int Grade
          {
              get
              {
                  return this.m_currentData.Grade;
              }
              set
              {
                  if (this.m_currentData.Grade != value)
                  {
                      this.m_currentData.Grade = value;
                      Notify("Grade");
                  }
              }
          }
  
          public System.Drawing.Color GradeColor
          {
              get { return this.m_currentData.GradeColor; }
          }
  
          public string Name
          {
              get
              {
                  return this.m_currentData.Name;
              }
              set
              {
                  if (this.m_currentData.Name != value)
                  {
                      this.m_currentData.Name = value;
                      Notify("Name");
                  }
              }
          }
  
          #endregion
  
          #region INotifyPropertyChanged Members
  
          public event PropertyChangedEventHandler PropertyChanged;
  
          private void Notify(string info)
          {
              if (PropertyChanged != null)
                  PropertyChanged(this, new PropertyChangedEventArgs(info));
          }
  
          #endregion
  
      }

Example

• Start a Windows Application project.
• Add the IStudent, Student and EditableStudent code. Compile. (If you don't compile, you won't be able to find the EditableStudent when you need it in just a little bit.)
• Place two text boxes on the form, named tbName and tbGrade.
• Go to Properties on tbName.
  • Open the (DataBindings) property.
  • Hit the down arrow next to the Text property.
  • There are no data sources yet, so click on Add project data source.
  • This will bring up the Data Source Configuration Wizard.
    • Select Object on the first screen.
    • Find the EditableStudent class on the next screen.
  • This will create a data source for EditableStudent. Now, for the Text property binding, open the EditableStudent data source and select the Name property. This binds the Text property of the text box to the Name property of EditableStudent.
• As a result, you will note that an instance variable of type BindingSource named editableStudentBindingSource is added to the form.
• Similarly, you can now bind the Text property of tbGrade to the Grade property of EditableStudent.
• To bind the BackColor property of tbGrade, hit the ... button next to the (Advanced) entry in (DataBindings). In the resulting dialog, select BackColor, then select the GradeColor property of EditableStudent.

Under the surface, the following code is being generated here and there:

private System.Windows.Forms.BindingSource editableStudentBindingSource;
	
this.tbName.DataBindings
   .Add(new System.Windows.Forms.Binding("Text", 
                                         this.editableStudentBindingSource, 
                                         "Name", 
                                         true));

this.tbGrade.DataBindings
   .Add(new System.Windows.Forms.Binding("BackColor", 
                                         this.editableStudentBindingSource, 
                                         "GradeColor", 
                                         true));
 this.tbGrade.DataBindings
   .Add(new System.Windows.Forms.Binding("Text", 
                                         this.editableStudentBindingSource, 
                                         "Grade", 
                                         true));

this.editableStudentBindingSource.DataSource 
   = typeof(BasicBindingSource.EditableStudent);

In our form code, we will add a load event to initialize the list.

        private void Form1_Load(object sender, EventArgs e)
        {
            editableStudentBindingSource.Add(new EditableStudent("Fred", 95));
            editableStudentBindingSource.Add(new EditableStudent("Ted", 80));
            editableStudentBindingSource.Add(new EditableStudent("Ed", 65));
        }

Add two buttons, btnNext and btnPrev. The following click handlers causes the current position to change.

        private void btnNext_Click(object sender, EventArgs e)
        {
            editableStudentBindingSource.Position++;
        }

        private void btnPrev_Click(object sender, EventArgs e)
        {
            editableStudentBindingSource.Position--;
        }

Add three buttons, btnAdd, btnSave, btnCancel.

• btnAdd: adds a new record. When the underlying item type supports IEditableObject, it adds the new item provisionally; if CancelEdit is called, the new item won't be added. A list navigation will call EndEdit, or you can call EndEdit yourself.
• btnSave and btnCancel call EndEdit and CancelEdit directly.
• Note that every time you navigate to a new item, EndEdit is called on the item you are leaving and BeginEdit is called on the item you are moving to.

          private void btnAdd_Click(object sender, EventArgs e)
          {
              editableStudentBindingSource.AddNew();
          }
  
          private void btnSave_Click(object sender, EventArgs e)
          {
              editableStudentBindingSource.EndEdit();
          }
  
          private void btnCancel_Click(object sender, EventArgs e)
          {
              editableStudentBindingSource.CancelEdit();
          }

Add a btnReport with the handler shown below. This shows the use of the Count, Position and Current properties of a BindingSource.

        private void btnReport_Click(object sender, EventArgs e)
        {
            StringBuilder sb = new StringBuilder();
            sb.AppendFormat("Number of records = {0}", editableStudentBindingSource.Count);
            sb.AppendLine();
            sb.AppendFormat("Current record is #{0}: {1}",
                editableStudentBindingSource.Position,
                (EditableStudent)editableStudentBindingSource.Current);
            sb.AppendLine();
            foreach (EditableStudent s in editableStudentBindingSource)
                sb.AppendLine(s.ToString());

            MessageBox.Show(sb.ToString(), "Current status of students");
        }

Enjoy.