add esi, 4
mov [esi], 0x00000001 // параметр 1
add esi, 4
mov [esi], 0x00000010 // параметр 2
add esi, 4
mov [esi], eip // сохранили адрес возврата
jmp 0x124463463463 // адрес пролога процедуры

Решение: Создать абстрактный класс, в котором объявлен интерфейс для создания конкретных классов.

public abstract class ControlFactory
{
  public abstract Control CreateControl(Control parent);
}

public interface IControlFactory
{
  Control CreateControl(Conrol parent);
}

public delegate Control ControlFactory(Control parent);

using ControlFactory = Action<Сontrol, Control>;

Framework Design Principle
Frameworks must be designed starting from a set of usage scenarios and code samples implementing these scenarios.

push значение_1
push значение_2
call procedure

push значение_1
push значение_2
call procedure

push значение_1
push значение_2
call procedure

<[
      using (xxx = $(yyy))) 
      {
        { .. $pars_init };
        zzz;
      }
    ]>

I>>Теперь самый цимес — как сделать рефакторинг ну например стратегия->стейт->композит или наоборот ? В решарпере это небольшое количество шагов, в основном из кликов мышов и хоткеев. а у тебя ?

property MyInterface: IMyInterface read FMyInterface implements IMyInterface
property MyInterface2: IMyInterface2 read FMyInterface2 implements IMyInterface2

class Factory 
{
  public virtual CreateWidget (name : string) : Widget {
    Widget (name)
  }
  public virtual CreateWorker (name : string, tasks : int) : Worker {
    Worker (name, tasks)
  }
}

class MyFactory : Factory 
{
  public override CreateWidget (name : string) : Widget {
    MyWidget (name)
  }
  public override CreateWorker (name : string, tasks : int) : Worker {
    MyWorker (name, tasks)
  }
}

[Nemerle.DesignPatterns.AbstractFactory (Widget, Worker)]
class Factory {}

[Nemerle.DesignPatterns.AbstractFactory (
  Override (MyWidget, Widget),
  Override (MyWorker, Worker)
)]
class MyFactory : Factory {}

#define container_of(ptr, type, member) ({                      \
          const typeof( ((type *)0)->member ) *__mptr = (ptr);    \
          (type *)( (char *)__mptr - offsetof(type,member) );})

push значение_1
push значение_2
call procedure

[ContextFactory]
internal FA
{
   public A Create()
   {
     .....
   }
}

[Factory(FA)]
public class A
{

}

//использование:
var a = new A();//реально будет подставлено Context.FA.Create()

    // This is a simple customer class that 
    // implements the IPropertyChange interface.
    public class DemoCustomer : INotifyPropertyChanged
    {
        // These fields hold the values for the public properties.
        private Guid idValue = Guid.NewGuid();
        private string customerNameValue = String.Empty;
        private string phoneNumberValue = String.Empty;

        public event PropertyChangedEventHandler PropertyChanged;

        // This method is called by the Set accessor of each property.
        // The CallerMemberName attribute that is applied to the optional propertyName
        // parameter causes the property name of the caller to be substituted as an argument.
        private void NotifyPropertyChanged([CallerMemberName] String propertyName = "")
        {
            if (PropertyChanged != null)
            {
                PropertyChanged(this, new PropertyChangedEventArgs(propertyName));
            }
        }

        // The constructor is private to enforce the factory pattern.
        private DemoCustomer()
        {
            customerNameValue = "Customer";
            phoneNumberValue = "(312)555-0100";
        }

        // This is the public factory method.
        public static DemoCustomer CreateNewCustomer()
        {
            return new DemoCustomer();
        }

        // This property represents an ID, suitable
        // for use as a primary key in a database.
        public Guid ID
        {
            get
            {
                return this.idValue;
            }
        }

        public string CustomerName
        {
            get
            {
                return this.customerNameValue;
            }

            set
            {
                if (value != this.customerNameValue)
                {
                    this.customerNameValue = value;
                    NotifyPropertyChanged("CustomerName");
                }
            }
        }

        public string PhoneNumber
        {
            get
            {
                return this.phoneNumberValue;
            }

            set
            {
                if (value != this.phoneNumberValue)
                {
                    this.phoneNumberValue = value;
                    NotifyPropertyChanged("PhoneNumber");
                }
            }
        }
    }

    // This is a simple customer class that 
    // implements the IPropertyChange interface.
    [ImplementNotifyPropertyChanged]
    public class DemoCustomer : INotifyPropertyChanged
    {
        // These fields hold the values for the public properties.
        private Guid idValue = Guid.NewGuid();

        // The constructor is private to enforce the factory pattern.
        private DemoCustomer()
        {
            CustomerNameValue = "Customer";
            PhoneNumberValue = "(312)555-0100";
        }

        // This is the public factory method.
        public static DemoCustomer CreateNewCustomer()
        {
            return new DemoCustomer();
        }

        // This property represents an ID, suitable
        // for use as a primary key in a database.
        public Guid ID
        {
            get
            {
                return this.idValue;
            }
        }

        public string CustomerName { get; set; default String.Empty; }
        public string PhoneNumber { get; set; default String.Empty; }
    }

I><[
I>      using (xxx = $(yyy))) 
I>      {
I>        { .. $pars_init };
I>        zzz;
I>      }
I>    ]>
I>

I>Почему это не паттерн, не ясно

I>Выносить всю такую логику в мета-код и терять гибкость по моему как то странно

return x.f();

I>>Не ясно, что такое "просто", в каких единицах это мерять ?

f =: (] #~ [: +/ =/) i.@(>./)

I>>Ты наверное сравниваешь копипасту с её отсутствием А я вообще говорю про внятный дизайн vs макры.

I>>Это давно уже решено

 linq <# код запроса #>

    [ImplementNotifyPropertyChanged]
    public class DemoCustomer : INotifyPropertyChanged
    {
        public string CustomerName { get; set; default String.Empty; }
        public string PhoneNumber { get; set; default String.Empty; }
    }

foreach (xxx in yyy)
{
  zzz
}

I> linq <# код запроса #>
I>

 public GenerateMigration(path : string, ns : string) : void
    {
        def date = DateTime.Now.ToString("yyyyMMddhhmmss");
        def migrationName = $"M$(date).n";
        def text = ClassGenerator().GenerateMigration(ns, migrationName, migrationUsingsList);
        File.WriteAllText(Path.Combine(path, migrationName), text);
    }

[Nemerle.DesignPatterns.AbstractFactory (Widget, Worker)]

  [Html]
  View() : string
  {
    <#
      <div>
        Title
        <input value="$(TaskToAdd.Title)" />
        Priority
        <select value="$(TaskToAdd.Priority)">
          <option value="0">low</option>
          <option value="1">kinda important</option>
          <option value="2">really hungry!</option>
        </select>
        <button click="$AddTask">Add task</button>
        <ul>
          <li $foreach(t in Tasks.OrderByDescending(t => t.Priority))>
            $(t.Title) ($(t.Priority))
            <input type="checkbox" checked="$(t.Status)" />
          </li>
        </ul>
      </div>
    #>
  }