public object InvokeMember(string name, System.Reflection.BindingFlags invokeAttr, System.Reflection.Binder binder, object target, object[] argsOrig, System.Reflection.ParameterModifier[] modifiers, System.Globalization.CultureInfo culture, string[] namedParameters)
        {        // Unwrap any AutoWrap'd objects (they need to be raw if a paramater)

            if (name == "[DISPID=-4]")
            {
                return new EnumVariantImpl(((IEnumerable)O).GetEnumerator());
            }


            object[] args = ПолучитьМассивРеальныхОбъектов(argsOrig);

            culture = CultureInfo.InvariantCulture;



            // Invoke whatever needs be invoked!
            object obj;

            try
            {

                if (T.IsEnum && !((invokeAttr & BindingFlags.InvokeMethod) == BindingFlags.InvokeMethod))
                    return ОбернутьОбъект(Enum.Parse(T, name));


                //           if (ЭтоСемерка)
                ПроверитьНаДоступКПолям(ref invokeAttr, args.Length);


                if (ЭтоТип)
                    obj = T.InvokeMember(name, invokeAttr, binder, null, args, modifiers, culture, namedParameters);
                else
                    obj = T.InvokeMember(name, invokeAttr, binder, O, args, modifiers, culture, namedParameters);

            }
            catch (Exception e)
            {
                ПоследняяОшибка = e;
                string Ошибка = "Ошибка в методе " + name + " " + e.Message + " " + e.Source;
  
                if (e.InnerException != null)
                    Ошибка = Ошибка + "\r\n" + e.InnerException.ToString();

                if (ВыводитьСообщениеОбОшибке)
                { 
                MessageBox.Show(Ошибка);
                MessageBox.Show(e.StackTrace);
                MessageBox.Show(invokeAttr.ToString());
                }
                throw new COMException(Ошибка);
            }

            // Так как параметры могут изменяться (OUT) и передаются по ссылке
            // нужно обратно обернуть параметры
            УстановитьИзмененияВМассиве(argsOrig, args);

            return ОбернутьОбъект(obj);
        }

EP>>Это изменение контракта, которое прекрасно выражается в системе типов — у doSomething поменяется тип параметра и приведённый код не скомпилируется

EP>>>>Конечно значит, именно поэтому в реализациях std::sort используется introsort, которая хоть и основана на quicksort, но выдаёт линеаритмическую сложность

EP>>>>>>Так тут есть простой выбор — by-value или by-reference. Это совершенно не тоже самое что и засучив рукава нарезать байт-буфера на структуры

...
EP>>

EP>>Этот массив, по терминам GC, спокойно может попасть под классификацию OG

dot>Так в этих же случаях и в яве всё будет всё в YG, а значит никакого жуткого O(N).

EP>>>>А мы ВНЕЗАПНО не JVM обсуждаем, а вполне конкретную Java. Если брать JVM — то например если в неё скомпилировать C++ — то он там положит всех на лопатки

EP>>И JS кстати получается реально быстрый. На одном из тестов работает практически в два раза быстрее чем аналогичный код на C#. JS, в веб-браузере, Карл! И этом при том что в C# версии были структуры. Если же брать аналогичный код на Java — то всё будет ещё круче Можем кстати сравнить.

EP>>Не нужно вручную нарезать массивы на структуры

struct World
{
    void set(std::string msg) { this->msg = msg; }
    std::string greet() { return msg; }
    std::string msg;
    // ...
}
// указываем те методы которые хотим экспортировать:
BOOST_PYTHON_MODULE(hello)
{
    class_<World>("World")
        .def("greet", &World::greet)
        .def("set", &World::set)
    ;
}
// можно сократить до вот такого варианта:
PYTHON_CLASS_SIMPLIFIED
(
    hello,
    World,
    greet, set
)

>>> import hello
>>> planet = hello.World()
>>> planet.set('howdy')
>>> planet.greet()
'howdy'

EP>// наш класс:
EP>struct World
EP>{
EP>    void set(std::string msg) { this->msg = msg; }
EP>    std::string greet() { return msg; }
EP>    std::string msg;
EP>};
EP>// указываем те методы которых хотим экспортировать:
EP>BOOST_PYTHON_MODULE(hello)
EP>{
EP>    class_<World>("World")
EP>        .def("greet", &World::greet)
EP>        .def("set", &World::set)
EP>    ;
EP>}
EP>// можно сократить до вот такого варианта:
EP>PYTHON_MODULE_SIMPLIFIED
EP>(
EP>    hello,
EP>    World,
EP>    greet, set
EP>)
EP>

>>>> import hello
>>>> planet = hello.World()
>>>> planet.set('howdy')
>>>> planet.greet()
EP>'howdy'
EP>

public class AutoWrap : IReflect
    {
// Два основных поля Объект и его тип
        protected internal object O = null;
        protected internal Type T = null;

 public AutoWrap(object obj)
        {
            O = obj;
            if (O is Type)
            {
                T = O as Type;
                ЭтоТип = true;
            }
            else
            {
                T = O.GetType();
                ЭтоТип = false;
            }



        }

// Бывает нужно обратиться не к статическим методам, а к методат типа
        public AutoWrap(object obj, Type type)
        {
            O = obj;
            T = type;
            ЭтоТип = false;


        }

 public object ТипКакОбъект(object Тип)
        {
            if (Тип is AutoWrap)
                Тип = ((AutoWrap)Тип).T;
            Type T = ((Type)Тип);

            return new AutoWrap(T, T.GetType());
        }

   public object СоздатьОбъект(object Тип, params object[] argOrig)
        {
            //   MessageBox.Show(Тип.ToString() + " параметров=" + args.Length.ToString());

            var res = ТипДляСоздатьОбъект(Тип);

            object[] args = AutoWrap.ПолучитьМассивРеальныхОбъектов(argOrig);
            return AutoWrap.ОбернутьОбъект(System.Activator.CreateInstance(res, args));

        }

EP>Причём тут "во время исполнения"? Ты свой класс, для которого нужен IDispatch, меняешь в runtime? Ты этого не говорил в условии

The primary limitation of IDispatch is that it assumes that objects are static. In other words, since objects do not change during run time, type information can fully describe them at compile time.

S> public object InvokeMember(string name, System.Reflection.BindingFlags invokeAttr, System.Reflection.Binder binder, object target, object[] argsOrig, System.Reflection.ParameterModifier[] modifiers, System.Globalization.CultureInfo culture, string[] namedParameters)
S>        {        // Unwrap any AutoWrap'd objects (they need to be raw if a paramater)

S>            if (name == "[DISPID=-4]")
S>            {
S>                return new EnumVariantImpl(((IEnumerable)O).GetEnumerator());
S>            }
        [поскипана куча]
S>

#define    DISPID_NEWENUM    ( -4 )

[
    object,
    dual // Это разрешает поддержку IDispatch
]
interface MyInterface
{
    // твои методы
};

[
    coclass,
    default(MyInterface)
]
class MyClass
{
    // реализации методов
};

S>> public object InvokeMember(string name, System.Reflection.BindingFlags invokeAttr, System.Reflection.Binder binder, object target, object[] argsOrig, System.Reflection.ParameterModifier[] modifiers, System.Globalization.CultureInfo culture, string[] namedParameters)
S>>        {        // Unwrap any AutoWrap'd objects (they need to be raw if a paramater)

S>>            if (name == "[DISPID=-4]")
S>>            {
S>>                return new EnumVariantImpl(((IEnumerable)O).GetEnumerator());
S>>            }
MX>        [поскипана куча]
S>>

MX>#define    DISPID_NEWENUM    ( -4 )
MX>

MX>[
MX>    object,
MX>    dual // Это разрешает поддержку IDispatch
MX>]
MX>interface MyInterface
MX>{
MX>    // твои методы
MX>};

MX>[
MX>    coclass,
MX>    default(MyInterface)
MX>]
MX>class MyClass
MX>{
MX>    // реализации методов
MX>};
MX>

 [ComVisible(true)]
    [InterfaceType(ComInterfaceType.InterfaceIsIDispatch)]
  //  [Guid("33B45C9D-1AED-41F9-8880-36AB6AE84749")]
    public interface IEventFor1C
    {
        [DispId(0x60020000)]
        void Событие();

        [DispId(0x60020001)]
        void СобытиеСПараметром(object value);
    }

   

    [ComVisible(true)]
    [ClassInterface(ClassInterfaceType.AutoDual)]
    [Guid("62F8156C-13B9-4484-B152-82023243E1D3")]
    [ComSourceInterfaces(typeof(IEventFor1C))]
    public class ClassForEvent1C
    {
        [ComVisible(false)]
        public delegate void Событие_Delgate();
        public delegate void СобытиеСПараметром_Delgate(object value);
        public object Объект;
        private SynchronizationContext Sc;

        public ClassForEvent1C(object Объект,String СобытиеОбъекта,bool ЕстьПараметр=false)
        {
            this.Объект = Объект;
            BindingFlags bf = BindingFlags.DeclaredOnly | BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Instance;
            EventInfo ei = Объект.GetType().GetEvent(СобытиеОбъекта, bf);
              if (!ЕстьПараметр)
            ei.AddEventHandler(Объект, new System.Action(ВнешнееСобытие));
             else
            ei.AddEventHandler(Объект, new System.Action<object>(ВнешнееСобытиеСПараметром));

            SynchronizationContext.SetSynchronizationContext(new WindowsFormsSynchronizationContext());
            Sc = SynchronizationContext.Current;

        }
        public event Событие_Delgate Событие;
        public event СобытиеСПараметром_Delgate СобытиеСПараметром;
       
        private void ВнешнееСобытие()
        {
          if (this.Событие != null) //Событие();
              Sc.Send(d => Событие(), null);

        
        }

        
        private void ВнешнееСобытиеСПараметром(object value)
        {
            if (this.СобытиеСПараметром != null) //Событие();
                Sc.Send(d => СобытиеСПараметром(AutoWrap.ОбернутьОбъект(value)), null);


        }

    }

 void OnGetMessageImage(object value);

 wa.OnGetMessageImage += (mediaNode, from, id, fileName, fileSize, url, preview) =>
            {
                ОтослатьСобытиеСПараметром(OnGetMessageImage, new { mediaNode = mediaNode, from = from, id = id, fileName = fileName, fileSize = fileSize, url = url, preview = preview }, "OnGetMessageImage");
            };

whatsappFor1C=Сборка.GetType("whatsappFor1C.whatsappFor1C");
    ВАОбертка=врап.СоздатьОбъект(whatsappFor1C,врап,Телефон,Пароль,Ник);
    СтатусСоединения=Врап.ПолучитьТип("WhatsAppApi.ApiBase+CONNECTION_STATUS");

    wa=ВАОбертка.wa;
    ВА=Врап.ПолучитьРеальныйОбъект(ВАОбертка);
    
    ДобавитьОбработчик Ва.OnConnectFailed, ПриОшибкеСоединения;
    ДобавитьОбработчик Ва.OnConnectSuccess, ПриУспешномСоединении;

EP>>>>>>Причём тут "во время исполнения"? Ты свой класс, для которого нужен IDispatch, меняешь в runtime? Ты этого не говорил в условии

EP>>Нет, не с любой

EP>>>>В C++ объект любого типа можно создать где угодно (не считая несколько экстремальных случаев к теме не относящихся) — в любой кучке байт достаточного размера

struct Widget
{
    Data x;
};

shared_ptr<Widget> ref_counted_widget;