I already tested that but didn't worked. I put the Dispose call in
protected override void Dispose(bool disposing) and also in OnClose as you
suggested but didn't worked.

So I still think this is a bug.
Can you plese test your solutions next time you are posting?

I worked hard with Reflector and CLR Profiler to and I found out that some
developer wrongly made a field static. Is about static field
commandStatusHash from internal class
System.Windows.Forms.Design.CommandSet+CommandSetItem. The workaround is to
remove some of its items during Dispose (items that are related to
DesignSurface that is disposed).

My opinion is that is issue is indeed a bug and what I'm doing here is only
a workaround. My opinion is that it should be fixed with next service pack.

I forgot to mention that there still are 16 bytes that are leaking at each
step, but this is significantly less than previous and I can live with it.

See the workaround bellow:

using System;
using System.Collections.Generic;
using System.Windows.Forms;
using System.Drawing;
using System.ComponentModel.Design;
using System.Windows.Forms.Design;
using System.Reflection;
using System.Collections;

namespace TestMemLeakDesignSurface
{
   static class Program
   {
       /// <summary>
       /// The main entry point for the application.
       /// </summary>
       [STAThread]
       static void Main()
       {
           Application.EnableVisualStyles();
           Application.SetCompatibleTextRenderingDefault(false);
           Application.Run(new MainForm());
       }
   }

   class MainForm : Form
   {
       public MainForm()
       {
           this.Text = "MainForm TestMemLeakDesignSurface";

           Button btnShowDialog = new Button();
           this.Width = 500;
           btnShowDialog.Text = "Show Dialog";
           btnShowDialog.Location= new Point(20, 20);

           Button btnCallGC = new Button();
           btnCallGC.Text = "Call GC";
           btnCallGC.Location=  new Point(200, 20);

           btnShowDialog.Click += new EventHandler(btnShowDialog_Click);
           btnCallGC.Click += new EventHandler(btnCallGC_Click);

           this.Controls.Add(btnCallGC);
           this.Controls.Add(btnShowDialog);
       }

       void btnShowDialog_Click(object sender, EventArgs e)
       {
           using (DesignSufaceHostForm form = new DesignSufaceHostForm())
           {
               form.ShowDialog(this);
           }
       }

       void btnCallGC_Click(object sender, EventArgs e)
       {
           // do whatever is possible to force GC to collect
           // nobody refer the DesignSufaceHostForm or Designed Form
           System.GC.Collect();
           System.GC.WaitForPendingFinalizers();
           System.GC.Collect();
           System.GC.WaitForPendingFinalizers();
           System.GC.Collect();
           System.GC.WaitForPendingFinalizers();
           long totalMemeory = System.GC.GetTotalMemory(true);
           MessageBox.Show(string.Format("totalMemory: {0:n}",
totalMemeory));
       }
   }

   public class DesignedForm : Form
   {
       public DesignedForm()
       {
           this.Size = new Size(300, 300);
           this.Text = "Designed Form";
       }
   }

   class DesignSufaceHostForm : Form
   {
       DesignSurface designSurface;
       public DesignSufaceHostForm()
       {
           this.Size = new Size(500, 500);
           this.Text = "Host of DesignSuface";
           designSurface = new DesignSurface();
           designSurface.BeginLoad(typeof(DesignedForm));
           Control view = designSurface.View as Control;
           if (view != null)
           {
               view.Dock = DockStyle.Fill;
               this.Controls.Add(view);
           }
       }
       protected override void Dispose(bool disposing)
       {

           if (disposing)
           {
               ClearControlCommandSetWorkaround clearHelper = new
ClearControlCommandSetWorkaround(designSurface);

               designSurface.Dispose();

               clearHelper.DoClear();
               base.Dispose(disposing);
           }
       }
   }

   /// <summary>
   /// This class is present as workaround for a bug
   ///
http://lab.msdn.microsoft.com/productfeedback/viewfeedback.aspx?feedbackid=8131e
f87-3227-49a0-925c-67a2ade8ef2b
   ///
   /// Because Microsoft chose to hide a lot of classes we are forced to
heavely use the
   /// reflection to accomplish this.
   /// </summary>
   internal class ClearControlCommandSetWorkaround
   {
       object commandSet;

       internal ClearControlCommandSetWorkaround(DesignSurface
designSurface)
       {
           IDesignerHost host =
designSurface.GetService(typeof(IDesignerHost)) as IDesignerHost;
           IDesigner designer = host.GetDesigner(host.RootComponent);
           DocumentDesigner docDesigner = designer as DocumentDesigner;
           commandSet = GetFieldValue(docDesigner, "commandSet");
       }
       internal void DoClear()
       {
           // I think that commandStatusHash should not be static
           // now we have to clear the hash for Event handler references
           // that have as target the current commandSet
           Type commandSetItemType =
commandSet.GetType().Assembly.GetType("System.Windows.Forms.Design.CommandSet+CommandSetItem");
           Hashtable commandStatusHash = GetFieldValue(null,
"commandStatusHash", commandSetItemType) as Hashtable;
           List<EventHandler> ehToRemove = new List<EventHandler>();
           foreach (EventHandler eh in commandStatusHash.Keys)
           {
               if(eh.Target == commandSet)
               {
                   ehToRemove.Add(eh);
               }
           }
           foreach (EventHandler eh in ehToRemove)
           {
               commandStatusHash.Remove(eh);
           }
           /*
           // the source-code comented was a previous workaround
           // seems that it is not needed anymore.

           SetFieldValue(commandSet, "baseControl", null);

           Type[] cmdSetTypes = new Type[] {
                       commandSet.GetType(),
                       commandSet.GetType().BaseType };
           foreach (Type cmdSetType in cmdSetTypes)
           {
               Array cmdSetItemsArray = GetFieldValue(commandSet,
"commandSet", cmdSetType) as Array;
               foreach (object cmdSetItem in cmdSetItemsArray)
               {
                   SetFieldValue(cmdSetItem, "statusHandler", null);
               }
               SetFieldValue(commandSet, "commandSet", null, cmdSetType);
           }
           */
       }
       #region Reflection related helpers
       static FieldInfo GetFieldInfo(object obj, string fieldName, Type
objType)
       {
           FieldInfo fieldInfo = objType.GetField(fieldName,
BindingFlags.GetField | BindingFlags.NonPublic | BindingFlags.Instance |
BindingFlags.Static | BindingFlags.FlattenHierarchy);
           if (fieldInfo != null)
               return fieldInfo;

           if (objType == typeof(object))
               return null;

           return GetFieldInfo(obj, fieldName, objType.BaseType);
       }
       static FieldInfo GetFieldInfo(object obj, string fieldName)
       {
           return GetFieldInfo(obj, fieldName, obj.GetType());
       }
       static object GetFieldValue(object obj, string fieldName)
       {
           return GetFieldValue(obj, fieldName, obj.GetType());
       }
       static object GetFieldValue(object obj, string fieldName, Type type)
       {
           FieldInfo fieldInfo = GetFieldInfo(obj, fieldName, type);

           if (fieldInfo == null)
           {
               return null;
           }
           return fieldInfo.GetValue(obj);
       }
       static void SetFieldValue(object obj, string fieldName, object
fieldValue, Type type)
       {
           FieldInfo fieldInfo = GetFieldInfo(obj, fieldName, type);
           if (fieldInfo == null)
           {
               return;
           }
           fieldInfo.SetValue(obj, fieldValue);
       }
       static void SetFieldValue(object obj, string fieldName, object
fieldValue)
       {
           SetFieldValue(obj, fieldName, fieldValue, obj.GetType());
       }
       #endregion
   }
}

PS. For Willy
From your part (as MVP) I expected a more clear response and maybe a
workaround like the one I found.
Can you see if I'm right and my fix don't have side effects that may broke
something else?