Hi ROM,

I recommend choosing a better architecture to begin with, specifically one that is polymorphic.

Determine the functionality that you need from the Typed parameter implementation and create either an interface or abstract class
to encapsulate that functionality, such as ISuperControlTask.  Declare a protected factory method for its creation within
SuperControl.  This architecture is used by the framework in many cases and will probably suit your needs well, but you have many
choices in this matter and you should analyze your situation carefully and choose the best one.

Here's a quick example that makes use of an abstract class, lazy initialization, a factor method and a private, default
implementation.
If you need to extend the SuperControl or a SuperControlTask to add more functionality you can simply create two more classes that
inherit from each.

HTH

public abstract class SuperControlTask
{
   public abstract void PerformTask();
}

public class SuperControl : Control
{
   protected SuperControlTask Task
   {
       get
       {
           EnsureTask();

           return task;
       }
   }

   private SuperControlTask task;

   public void PerformTask()
   {
       EnsureTask();

       task.PerformTask();
   }

   private void EnsureTask()
   {
       if (task == null)
       {
           // lazy task initialization

           task = CreateTask();

           if (task == null)
               throw new InvalidOperationException("The SuperControl is not associated with a SuperControlTask.");
       }
   }

   protected virtual SuperControlTask CreateTask()
   {
       return new DefaultSuperControlTask();
   }

   private class DefaultSuperControlTask : SuperControlTask
   {
       public override void PerformTask()
       {
           // TODO: default task
       }
   }
}