I was attempting to get around the VS2005 designer giving error messages
because a usercontrol is inherited from an abstract class.

Made use of   TypeDescriptionProvider   to try this  (found in a online
article).  And it does work, until the project gets recompiled after the
control has been open in the designer.  (can compile before opening control
without issue (appearently))

Using two instances of VS to debug the design time, what I saw following a
recompile, the Type objectType passed into GetReflectionType() (see code
below)  says its the correct type, has the right name, the right assembly,
etc, but the passed objectType (X) does not compare as being equal to a  
typeof(X).  

The design window can be closed, the solution can be closed, the problem
continues.   VS has to be shutdown and relaunched before this stops occuring.
(i.e. the passed objectType (X) does compare as equal to typeof(X) )

I have VS sp1 installed.  Tried installing hotfix  KB912019.  No effect.

TIA for your assistance

***************************************************
***************************************************

   [TypeDescriptionProvider(typeof(ConcreteClassProvider_CCBB))]
   abstract public class X: System.Windows.Forms.UserControl
   { ... }

   // Here is a concrete version of X that acts as a stand in
   internal class ConcreteForm_CCBB : X
   {
   }

   // Here is our type description provider.  All our provider needs to
   // do is return ConcreteForm as the reflection type.
   internal class ConcreteClassProvider_CCBB : TypeDescriptionProvider
   {

     // Because we only want to augment the metadata for AbstractForm,
instead of
       // completely replace it, we pass into the base class the current type
       // description provider.  This is the provider that normally handles
       // metadata for AbstractForm.  By doing this all we have to do is
       // override the areas we want to change.
       public ConcreteClassProvider_CCBB()
           : base(TypeDescriptor.GetProvider(typeof(X)))
       {
           System.Console.WriteLine("in ConcreteClassProvider_CCBB");
       }

       // Tell anyone who reflects on us that the concrete form is the
       // form to reflect against, not the abstract form. This way, the
       // designer does not see an abstract class.
       public override Type GetReflectionType(Type objectType, object
instance)
       {
           System.Console.WriteLine("in
ConcreteClassProvider_CCBB.GetReflectionType");

           if (typeof(X).Equals(typeof(X)))
           {
               //   TRUE
               System.Console.WriteLine("X matches  X");
           }
           if (objectType.Equals(objectType))
           {
               //    TRUE
               System.Console.WriteLine("objectType matches objectType");
           }
           if (objectType.Equals(typeof(X)))
           {
           //    FALSE
               System.Console.WriteLine("it matches X");
           }
           if (objectType.Name.Equals("X"))
           {
               //    TRUE
               System.Console.WriteLine("its Name matches X");
           }
           if (objectType.IsAbstract &&
typeof(X).IsAssignableFrom(objectType))
           {
               //    FALSE
               objectType = typeof(ConcreteForm_CCBB);
           }
           return base.GetReflectionType(objectType, instance);
       }

       // If the designer tries to create an instance of AbstractForm, we
override
       // it here to create a concerete form instead.
       public override object CreateInstance(IServiceProvider provider,
Type objectType, Type[] argTypes, object[] args)
       {
          System.Console.WriteLine("in
ConcreteClassProvider_CCBB.CreateInstance");
           if (objectType.IsAbstract &&
typeof(X).IsAssignableFrom(objectType))
           {
               objectType = typeof(ConcreteForm_CCBB);
           }

           return base.CreateInstance(provider, objectType, argTypes, args);
       }
   }