C#

private DialogControls _controls = new DialogControls();
[DesignerSerializationVisibility(DesignerSerializationVisibility.Visible)]
[Editor(typeof(ControlsEditor), typeof(UITypeEditor))]
[Category("Controls")]
[Description("A list of controls that are added to the dialog")]
public DialogControls Controls {
    get { return _controls; }
    set { _controls = value; }
}

bool ShouldSerializeControls() { return Controls.Count > 0; }
void ResetControls() { Controls.Clear(); Controls.ProminentIndex = -1; }

[Serializable]
public class ControlGroup : IList<Control>, ICollection, ISerializable {
   public ControlGroup() { }

   List<Control> _controls = new List<Control>();

   #region IList<Control>, ICollection implementation
      // Implemented through _controls
      // ...
   #endregion

   #region ISerializable
   public ControlGroup(SerializationInfo info, StreamingContext context) {
      Control[] controls = (Control[])info.GetValue("controls", typeof(Control[]));
      _controls.AddRange(controls);
   }

   public virtual void GetObjectData(SerializationInfo info, StreamingContext context) {
      info.AddValue("controls", _controls.ToArray());
   }
   #endregion
}

[Serializable]
public class DialogControls : ControlGroup, ISerializable {
   public DialogControls() { }
   public int ProminentIndex { get; set; } = -1;
   public Control ProminentControl { get { return ProminentIndex >= 0 ? this[ProminentIndex + 1] : null; } }

   #region ISerializable
   public DialogControls(SerializationInfo info, StreamingContext context) : base(info, context) {
      ProminentIndex = info.GetInt32("prominent");
   }

   public override void GetObjectData(SerializationInfo info, StreamingContext context) {
      base.GetObjectData(info, context);
      info.AddValue("prominent", ProminentIndex);
   }
   #endregion
}

[Serializable]
public abstract class Control : ISerializable {
   protected const ControlState DefaultState = ControlState.Enabled | ControlState.Visible;

   public Control() { }
   protected Control(Control other) {
      _state = other._state;
   }
   internal CommonFileDialog _dlg = null;

   internal IFileDialogCustomize fdc { get { return (IFileDialogCustomize)_dlg?._pDialog; } }

   uint _id = 0;
   public uint ID { get { return _id; } internal set { _id = value; } }

   // An enumerated value
   protected ControlState _state = DefaultState;
   public ControlState State {
      get {
         fdc?.GetControlState(ID, out _state);
         return _state;
      }
      set {
         _state = value;
         fdc?.SetControlState(ID, _state);
      }
   }

   internal abstract void AddToDialog(CommonFileDialog owner);
   internal abstract bool CanMakeProminent { get; }
   internal abstract string Value { get; }
   internal abstract string Description { get; }
   internal abstract string Type { get; }
   public abstract Control Clone();

   #region ISerializable

   // _state is the only field I need serialised here. ID and _dlg are not set until runtime.
   public Control(SerializationInfo info, StreamingContext context) {
      _state = (ControlState)info.GetValue("state", typeof(ControlState));
   }

   public virtual void GetObjectData(SerializationInfo info, StreamingContext context) {
      info.AddValue("state", State);
   }
   #endregion
}

[Serializable]
public sealed class CheckBox : Control, ISerializable {

   string _label;
   public string Label {
      get {
         return _label;
      }
      set {
         _label = value;
         fdc?.SetControlLabel(ID, _label);
      }
   }
   internal bool _checked;
   public bool Checked {
      get {
         return _checked;
      }
      set {
         _checked = value;
         fdc?.SetCheckButtonState(ID, _checked);
      }
   }

   public CheckBox() { }
   CheckBox(CheckBox other) : base(other) { _label = other._label; _checked = other._checked; }
   public CheckBox(string label, bool check) {
      Label = label;
      Checked = check;
   }

   #region ISerializable
   public CheckBox(SerializationInfo info, StreamingContext context) : base(info, context) {
      _label = info.GetString("label");
      _checked = info.GetBoolean("checked");
   }

   public override void GetObjectData(SerializationInfo info, StreamingContext context) {
      base.GetObjectData(info, context);
      info.AddValue("label", _label);
      info.AddValue("checked", _checked);
   }
   #endregion

   #region Control overrides
   internal override void AddToDialog(CommonFileDialog dlg) {
      // This is where the _dlg and ID properties are set at runtime, and the controls are actually added to the fdc
   }
   internal override bool CanMakeProminent { get { return true; } }
   internal override string Type { get; } = "CheckBox";
   internal override string Description { get { return Label; } }
   internal override string Value { get { return Checked.ToString(); } }
   public override Control Clone() { return new CheckBox(this); }
   public override string ToString() {
      return string.Format("{0}({1}, {2})", Type, Description, Value);
   }
   #endregion
}

If the value you are waiting for comes from the filesystem or a database or the network, then there is no need for a thread to sit around and wait for the data when it can be servicing other requests. Instead, the Task might register a callback to receive the value(s) when they're ready.