void textBoxFilter_KeyUp(object sender, KeyEventArgs e)
{
 var filterChars = this.textBoxFilter.Text.ToLower();
 this.Filter(filterChars);
}

void Filter(string filterChars)
{
 var persons = (FilterList<Person>)this.dataGridView1.DataSource;
 persons.Filter(p => p.Firstname.ToLower().Contains(filterChars));
}

I even created a screencast to demonstrate it:

The user can look at the data and decide to edit it:

Or the user is editing the data and can decide to commit or discard her changes:

A couple of years i ago i used to spread such display logic all over my code and it was hard to figure out which control was visible at a given point. Later on i refactored that code and encapsulated it in functions like: MakeControlsForDisplayVisible and MakeControlsForEditVisible which felt like a huge improvement. These days i have the feeling that a very simple state machine can improve the readability even better.

Ok, so how simple is simple? Currently the requirements list is pretty limited:

Anyway, here is how i would write the code today (Yeah, for a stupid example this looks like overkill):

private void InitializeButtonLayoutPanelMachine()
{
 controlStateMachine = new ControlStateMachine<DisplayAndEditStates>(buttonLayoutPanel);

 controlStateMachine.WhenStateChangesTo(DisplayAndEditStates.Display)
  .TheOnlyVisibleControlsAre(buttonEdit);

 controlStateMachine.WhenStateChangesTo(DisplayAndEditStates.Edit)
  .TheOnlyVisibleControlsAre(buttonSave, buttonCancel);
}

As always, here is the source: ControlStateMachine and WhenChangingState.

In case it is not clear what these methods should do i have defined the following specifications for them:

Get the code here: ControlChanges and WhenExecutingControlChanges. Stay tuned for more!

controlStateMachine = new ControlStateMachine<States>(this);

controlStateMachine.AfterEachStateChange()
 .Do(MakeRelevantButtonsVisible);

controlStateMachine.WhenStateChangesTo(States.RetrievingSubscriptionPeriod)
 .TheOnlyVisibleControlsAre(flowLayoutPanel1, datePicker1);

controlStateMachine.WhenStateChangesTo(States.RetrievingCustomerInformation)
 .MakeVisible(customerInput1)
 .Do(() => customerInput1.Dock = DockStyle.Fill);

controlStateMachine.WhenStateChangesTo(States.Ready)
 .MakeInvisible(customerInput1);

And here is another example:

wizardStateMachine = new WizardStateMachine<States>(controlStateMachine);

wizardStateMachine.InState(States.RetrievingSubscriptionPeriod)
 .OnCommand(WizardCommands.Next)
  .TransitionTo(States.RetrievingCustomerInformation);

wizardStateMachine.InState(States.RetrievingCustomerInformation)
 .OnCommand(WizardCommands.Back)
  .TransitionTo(States.RetrievingSubscriptionPeriod)
 .OnCommand(WizardCommands.Finish)
  .TransitionTo(States.Ready);

wizardStateMachine.InState(States.Ready)
 .OnCommand(WizardCommands.New)
  .Do(() => MessageBox.Show("Currently not supported"));

Stay tuned for future posts where i describe the problem space that have lead to this API.

Feel free to download CodeGenerator.zip.

Feel free to download the source: WorkItemTracker.zip

Edit (05/03/2008):
Refactored the code a little and added some features like sortable columns, loading default tfsserver and users from App.Config, …

The CreateManifestResourceNames target create the manifest resource names from the .RESX files.

[IN]
@(ResxWithNoCulture) - The names the non-culture .RESX files.
@(ResxWithCulture) - The names the culture .RESX files.
@(NonResxWithNoCulture) - The names of the non-culture non-RESX files (like bitmaps, etc).
@(NonResxWithCulture) - The names of the culture non-RESX files (like bitmaps, etc).

[OUT]
@(ManifestResourceWithNoCultureName) - The corresponding manifest resource name (.RESOURCE)
@(ManifestResourceWithCultureName) - The corresponding manifest resource name (.RESOURCE)
@(ManifestNonResxWithNoCulture) - The corresponding manifest resource name.
@(ManifestNonResxWithCulture) - The corresponding manifest resource name.

For C# applications the transformation is like:

Resources1.resx => RootNamespace.Resources1 => Build into main assembly
SubFolder\Resources1.resx => RootNamespace.SubFolder.Resources1 => Build into main assembly
Resources1.fr.resx => RootNamespace.Resources1.fr => Build into satellite assembly
Resources1.notaculture.resx => RootNamespace.Resources1.notaculture => Build into main assembly

For other project systems, this transformation may be different.

With Attrice Corporation Microsoft Build Sidekick v2 you can easily visualize the flow throughout the targets via Tools -> View Targets Diagram.

private void Form1_Load(object sender, EventArgs e)
{
 this.dateTimePicker1.Value = new DateTime(2007, 8, 31);
 this.dateTimePicker1.Format = DateTimePickerFormat.Custom;
 this.dateTimePicker1.CustomFormat = "MM/yyyy";
}

Now, change to 09/2007 and notice that you get an Exception, because the control tries to create an unrepresentable new DateTime(2007, 8+1, 31). Thus, if you’re going to use the DateTimePicker for MM/yyyy input make sure to set it’s value to a DateTimeTime with a day component that exists for all months/years (thus a value between 1 and 28).

Addendum: As usual, super moderator and MVP Hans Passant provided a nice workaround for the problem:)

public class MonthPicker : DateTimePicker {
  public MonthPicker() {
    this.Format = DateTimePickerFormat.Custom;
    this.CustomFormat = "MM/yyyy";
    DateTime now = DateTime.Now;
    this.Value = new DateTime(now.Year, now.Month, 1);
  }
  protected override void WndProc(ref Message m) {
    if (m.Msg == 0x204e) {
      NMHDR hdr = (NMHDR)m.GetLParam(typeof(NMHDR));
      if (hdr.code == -759) {
        NMDATETIMECHANGE dt = (NMDATETIMECHANGE)m.GetLParam(typeof(NMDATETIMECHANGE));
        this.Value = new DateTime(dt.st.wYear, dt.st.wMonth, 1);
        return;
      }
    }
    base.WndProc(ref m);
  }
  // P/Invoke declarations
  [StructLayout(LayoutKind.Sequential)]
  private struct NMHDR {
    public IntPtr hWnd;
    public IntPtr id;
    public int code;
  }
  [StructLayout(LayoutKind.Sequential, CharSet = CharSet.Auto)]
  private class NMDATETIMECHANGE {
    public NMHDR nmhdr;
    public int dwFlags;
    public SYSTEMTIME st;
  }
  [StructLayout(LayoutKind.Sequential)]
  private class SYSTEMTIME {
    public short wYear;
    public short wMonth;
    public short wDayOfWeek;
    public short wDay;
    public short wHour;
    public short wMinute;
    public short wSecond;
    public short wMilliseconds;
  }
}

this.constantsExtenderProvider1 = new WindowsApplication1.ConstantsExtenderProvider();

this.constantsExtenderProvider1.SetConstants(this.button1, new string[] {
 "Operation1",
 "Operation5"});

this.constantsExtenderProvider1.SetConstants(this, null);

private ConstantsExtenderProvider constantsExtenderProvider1;

Now, what if we’re not happy with those generated SetXXX methods on each Component? The problem is that this code is not generated by the serializer for the ConstantsExtenderProvider but by the serializers for the Components. An easy workaround for this problem is to set the DesignerSerializationVisibilityAttribute on the GetXXX method in our IExtenderProvider to Hidden.

With those ugly SetXXX methods out of the way it’s up to us to do it better. We do this by implementing a custom serializer for our ConstantsExtenderProvider:

class ConstantsSerializer<T> : CodeDomSerializer
{
 public override object Serialize(IDesignerSerializationManager manager, object value)
 {
  ConstantsExtenderProvider provider = value as ConstantsExtenderProvider;

  CodeDomSerializer baseClassSerializer = manager.GetSerializer(typeof(ConstantsExtenderProvider).BaseType, typeof(CodeDomSerializer)) as CodeDomSerializer;
  CodeStatementCollection statements = baseClassSerializer.Serialize(manager, value) as CodeStatementCollection;

  IDesignerHost host = (IDesignerHost)manager.GetService(typeof(IDesignerHost));
  ComponentCollection components = host.Container.Components;
  this.SerializeExtender(manager, provider, components, statements);

  return statements;
 }

 private void SerializeExtender(IDesignerSerializationManager manager, ConstantsExtenderProvider provider, ComponentCollection components, CodeStatementCollection statements)
 {
  foreach (IComponent component in components)
  {
   Control control = component as Control;
   if (control != null && (control as Form == null))
   {
    CodeMethodInvokeExpression methodcall = new CodeMethodInvokeExpression(base.SerializeToExpression(manager, provider), "SetConstants");
    methodcall.Parameters.Add(new CodeFieldReferenceExpression(new CodeThisReferenceExpression(), control.Name));

    string[] constants = provider.GetConstants(control);
    if (constants != null)
    {
     StringBuilder sb = new StringBuilder();
     sb.Append("new string[] { ");

     foreach (string constant in constants)
     {
      sb.Append(typeof(T).FullName);
      sb.Append(".");
      sb.Append(constant);
      sb.Append(", ");
     }

     sb.Remove(sb.Length - 2, 2);
     sb.Append(" }");

     methodcall.Parameters.Add(new CodeSnippetExpression(sb.ToString()));
    }
    else
    {
     methodcall.Parameters.Add(new CodePrimitiveExpression(null));
    }
    
    statements.Add(methodcall);
   }
  }
 }
}

And now the generated code looks like:

this.constantsExtenderProvider1.SetConstants(this.button1, new string[] { WindowsApplication1.Constants.Operation1, WindowsApplication1.Constants.Operation5 });

As always, feel free to download the ConstantsExtenderProvider source.

1. Create a UserControl
2. Add a property to the control
3. Add an Editor attribute to the property
4. Build
5. Drag a UserControl on the designer form
6. Test via Visual Studio’s Property Window if the UITypeEditor works as expected
7. Everytime i changed some code: Restart Visual Studio, load the project and repeat 6.

A tedious task to say the least. Yesterday i figured out that i could drag a PropertyGrid on the designer form, and set it’s SelectedObject property to a class with a property that uses the custom UITypeEditor; Instead of having to reload visual studio i can simply start a debug session, and click on the property in the PropertyGrid. Now it’s a breeze to develop custom UITypeEditors

private void Form1_Load(object sender, EventArgs e)
{
 // display an instance of PersonEntry, 
 // a class with a property that should use the custom UITypeEditor i want to test
 this.propertyGrid1.SelectedObject = new PersonEntry(new Person("Tim", "Van Wassenhove"));
}

public class PersonEntry
{
 ...

 // instruct the PropertyGrid to use my custom PersonUITypeEditor
 [Editor(typeof(PersonUITypeEditor), typeof(UITypeEditor))]
 public Person Person
 {
  get { return this.person; }
  set { this.person = value; }
 }
}

public class PersonUITypeEditor : UITypeEditor
{
 public override UITypeEditorEditStyle GetEditStyle(ITypeDescriptorContext context)
 {
  return UITypeEditorEditStyle.Modal;
 }

 public override object EditValue(ITypeDescriptorContext context, IServiceProvider provider, object value)
 {
  Person person = value as Person;

  IWindowsFormsEditorService svc = context.GetService(typeof(IWindowsFormsEditorService)) as IWindowsFormsEditorService;
  if (svc != null)
  {
   using (PersonEditorForm personEditorForm = new PersonEditorForm(person))
   {
    if (svc.ShowDialog(personEditorForm) == DialogResult.OK)
    {
     return personEditorForm.Person;
    }
   }
  }

  return value;
 }
}