If an exception is thrown in a BackgroundWorker’s DoWork handler, the backgroundworker will catch it and place the exception in RunWorkerCompleted’s e.Error.

If it seems like the Exception’s still being thrown with no apparent way to catch it, it’s because if e.Error is not null. When that’s the case, e.Result will throw that error (wrapped in a TargetInvocationException) when accessed. Do not access e.Result without checking for e.Error first.

private void worker_RunWorkerCompleted(object sender, RunWorkerCompletedEventArgs e)
{
  EndCreate(e.Error, e.Result); // <--- THIS WILL CRASH IF e.Error IS NOT NULL
}
 
private void worker_RunWorkerCompleted(object sender, RunWorkerCompletedEventArgs e)
{
  // THIS WILL NOT.
  if (e.Error == null) {
    EndCreate(e.Error, e.Result);
  }
  else {
    EndCreate(e.Error, null); // accessing e.Result throws the exception
  }
}

1. Set the DefaultValue property on the respective DataColumns.

   This works fine for static values. However, you’re likely using the DataSet designer in Visual Studio, and it will hose itself if you try to set a GUID because it can’t tell them apart from a string. Plus, initializing with dynamic values like DateTime.Now won’t work because you’ll end up with the date of the creation of the column rather than the date of the row.

2. Initialize after creating it, but before adding it to the DataTable.

   If you’re creating the row manually, you can just set any initial values before adding it to the table. None of the values, indices, etc. are validated until that happens. Strong typed datasets are even nice enough to generate methods that take and return rows of your type.

   MyDataSet ds = new MyDataSet();
   MyTableRow row = ds.MyTable.NewMyTableRow();
   row.ID = new Guid();
   row.CreatedOn = DateTime.Now;
   ds.MyTable.AddMyTableRow(row);

3. Override the OnTableNewRow of the DataTable in a derived class. This doesn’t actually work.

   Like the derived classes created by the strong typed table generator. You can get to this method if you use the DataSet’s helpful partial class definition:

   // Note: does not actually work
   public partial class MyDataSet {
       public partial class MyTable {
           protected override void OnTableNewRow(DataTableNewRowEventArgs e) {
               MyDataSet.MyTableRow row = (MyDataSet.MyTableRow)e.Row;
               row.ID = new Guid();
               row.CreatedOn = DateTime.Now;
               base.OnTableNewRow(e);
           }
       }
   }

   It doesn’t work because this method is never called unless you also attach a handler to the TableNewRow event, defeating the whole point of creating a virtual method. GG, Microsoft. This set me back a whole afternoon trying to figure out why some of my tables ran the method and others didn’t.

   You can overcome this if you…

3. Handle the TableNewRow event of the DataTable.

   Good if you want to initialize with external values of some kind, but you can also attach the handler from inside the typed DataTable if you override the EndInit() method, which being part of ISupportInitialize, Visual Studio calls every time the table is initialized in a designer. If you use the dataset outside of the designer, well, you’re screwed.

   public partial class MyDataSet {
       public partial class MyTable {
           protected override void EndInit() {
               this.TableNewRow += (object sender, TableNewRowEventArgs e) => { // use 'delegate' if not C# 3.0
                   MyDataSet.MyTableRow row = (MyDataSet.MyTableRow)e.Row;
                   row.ID = new Guid();
                   row.CreatedOn = DateTime.Now;
               };
               base.OnTableNewRow(e);
           }
       }
   }

4. Use a BindingSource and handle the AddingNew event.

   You bound your dataset to a bunch of controls, and now you want to create new rows with data that’s only available in your presentation tier. BindingSources let you control the row creation process completely if you handle the AddingNew event. The downside is that you have to create the whole thing manually, and to do that you have to know how BindingSources work.

   Another caveat is that the BindingSource’s Position won’t move to the newly created item, like it would otherwise. You’ll have to do that yourself.

   myBindingSource.AddingNew += (object sender, AddingNewEventArgs e) => {
       DataRowView view = ((DataView)myBindingSource.List).AddNew();
       MyDataSet.MyTableRow row = (MyDataSet.MyTableRow)view.Row;
       row.ID = new Guid();
       row.CreatedOn = DateTime.Now;
       e.NewObject = view;
   }

   There’s a better way in which you don’t have to create the DataRowView…

5. Use a BindingSource and handle the ListChanged event.

   This is the easiest way to initialize rows directly on the BindingSource. Unlike the AddingNew method, the BindingSource creates the row, and sets the Position to the new item.

   myBindingSource.ListChanged += (object sender, ListChangedEventArgs e) => {
       if (e.ListChangedType == ListChangedType.ItemAdded) {
           DataRowView view = (DataRowView)myBindingSource[e.NewIndex];
           if (view.IsNew) { // Check if the row is in its detached state
               MyDataSet.MyTableRow row = (MyDataSet.MyTableRow)view.Row
               row.ID = new Guid();
               row.CreatedOn = DateTime.Now;
               bs.ResetItem(e.NewIndex); // this is needed to get the controls to show the new values that we just set.
           }
       }
   }

   The ListChanged event is called twice. First when the row is created in its detached state, and then again when it’s added to the Rows collection of the DataTable. We only need to handle it the first time. The call to ResetItem will make sure that all the bound controls read the new values.

6. Use control-specific events.

   Some controls have their own events to initialize new rows. I don’t recommend using this approach, because it’s too control-specific. It’s much more interoperable to initialize at the BindingSource. You never know how that AddNew might be called.

Depending on what kind of data you’re initializing, and in which tier, you might need to mix and match. #4 for the data tier and #6 for the forms do the job for me.

private string myData;
public string MyData // A property
{
  get { return myData; } // called when the property is read
  set { myData = value; } // called when the property is written to
}
 
private EventHandler myDataChanged;
public event EventHandler MyDataChanged // An event
{
  add { myDataChanged = (EventHandler)Delegate.Combine( myDataChanged, value ); } // called when a handler is attached
  remove { myDataChanged = (EventHandler)Delegate.Remove( myDataChanged, value ); } // called when a handler is detached
}

A vanilla event declaration, without the accessors, does this internally. It also acquires a lock every time it accesses the EventHandler to be thread safe, which we’re not doing here, and you should, if you need the safety.

A great application of this is to simulate “bubble” events in WinForms like in ASP.NET. Take for example a form with a user control with a button in it. If I wanted to receive the button’s click event on the form, I would have to either expose the button, or handle its event in the control, and raise a different one on the control:

public class MyControl : UserControl
{
  public event EventHandler MyButtonClick;
  Button btn;
 
  public MyControl()
  {
    btn = new Button();
    btn.Click += new EventHandler( btn_Click );
  }
 
  private void myBtn_Click( object sender, EventArgs e )
  {
    if ( MyButtonClick != null )
      MyButtonClick( sender, e );
  }
}
 
public class MyForm : Form
{
  MyControl ctl;
 
  public Form()
  {
    ctl = new MyControl();
    ctl.MyButtonClick += new EventHandler( ctl_MyButtonClick );
  }
 
  private void ctl_MyButtonClick( object sender, EventArgs e )
  {
    // Button clicked on the control!
  }
}

This can get rather bothersome and ugly if you have many buttons. Using an event accessor you can take the handler and attach it to anything you like, so you can just pass-through the handler directly to the button(s).

public class MyControl : UserControl
{
  Button btn;
 
  public MyControl()
  {
    btn = new Button();
  }
 
  public event EventHandler MyButtonClick
  {
    add { btn.Click += value; }
    remove { btn.Click -= value; }
  }
}

There’s one caveat to this technique, and that’s when you handle the event somewhere upstream, the “sender” would be the button, not the MyControl. This might break encapsulation, and if that’s important to you, the handle/re-raise method is the way to go.

I found the solution by looking through it’s source code. We still expose a public property, however, instead of setting it manually, we can simply instruct Visual Studio to set the property for us, when it generates the designer code for any component we put it into.

private ContainerControl parentControl;
public ContainerControl ParentControl
{
    get { return parentControl; }
    set { parentControl = value; }
}
 
public override ISite Site
{
    set
    {
        base.Site = value;
        if (value == null)
            return;
 
        IDesignerHost host = (IDesignerHost)value.GetService( typeof( IDesignerHost ) );
        if (host != null)
        {
            IComponent baseComp = host.RootComponent;
 
            if (baseComp is ContainerControl)
                this.ContainerControl = (ContainerControl)baseComp;
        }
    }
}

We’re overriding the Site property, so that we can intercept it’s ISite, which will be set when the Component is added to its container. We can then request its IDesignerHost service, which is an interface used to communicate during design time with an aware IDE, such as Visual Studio. We then save it in our public property, which Visual Studio will then automatically add to the generated code of any Control that you drop the component in:

/// 
/// Required method for Designer support - do not modify
/// the contents of this method with the code editor.
/// 
private void InitializeComponent()
{
    this.components = new System.ComponentModel.Container();
    this.decorator = new Sunstorm.Tests.FormDecorator( this.components );
    this.SuspendLayout();
    //
    // decorator
    //
    this.decorator.ContainerControl = this;
    //
    // TestForm
    //
    this.Name = "TestForm";
    this.Size = new System.Drawing.Size( 510, 339 );
    this.ResumeLayout( false );
}

From there, you can manipulate the parent in any way you want.