Предоставление читателям возможности делать предположения, основанные на опыте, и поэтому быстрее понимать код.

static void GenericTypeDemo(Args _args) 

{ 

    ClrObject o = new ClrObject(“System.Collections.Generic.List`1[System.Int32]”); 

    ClrObject enumerator; 

    int theValue; 


    // o is an instance of an IEnumerable<int> 

    o.Add(1); 

    o.Add(4); 

    o.Add(12); 


    print o.ToString(); 


    enumerator = o.GetEnumerator(); 


    while (enumerator.MoveNext()) 

    { 

        theValue = enumerator.get_Current(); 

        print theValue; 

    } 


    pause; 

}

 Врап=Новый("Addin.VK.WrapperNet"); 
 Список=Новый("Addin.VK.NetObject"); 

 Данные=Врап.СоздатьОбъект("System.Collections.Generic.List`1[System.String]"); 

 Список.Обернуть(Данные); 

    Для сч=1 По 10 Цикл 
       Список.Add(строка(сч));     
    КонецЦикла;

bool Init(void* pConnection) 

long GetInfo() 

void Done() 

bool RegisterExtensionAs(WCHAR_T** wsLanguageExt) 

long GetNProps() 

long FindProp(const WCHAR_T* wsPropName) 

const WCHAR_T* GetPropName(long lPropNum, long lPropAlias) 

bool GetPropVal(const long lPropNum, tVariant* pvarPropVal) 

bool SetPropVal(const long lPropNum, tVariant* varPropVal) 

bool IsPropReadable(const long lPropNum) 

bool IsPropWritable(const long lPropNum) 

long GetNMethods() 

long FindMethod(const WCHAR_T* wsMethodName) 

const WCHAR_T* GetMethodName(const long lMethodNum, 
                            const long lMethodAlias) 

long GetNParams(const long lMethodNum) 


bool GetParamDefValue(const long lMethodNum, const long lParamNum, 
                          tVariant *pvarParamDefValue) 


bool HasRetVal(const long lMethodNum) 

bool CallAsProc(const long lMethodNum, 
                    tVariant* paParams, const long lSizeArray) 

bool CallAsFunc(const long lMethodNum, 
                tVariant* pvarRetValue, tVariant* paParams, const long lSizeArray) 

void SetLocale(const WCHAR_T* loc) 


bool setMemManager(void* mem)

Init(void* pConnection) 

void Done() 
bool setMemManager(void* mem)

public object InvokeMember( 
    string name, 
    BindingFlags invokeAttr, 
    object[] args 
)

using System;
using System.Collections.Generic;
using System.Reflection;

namespace CoreClrDLL
{
    public class Program
    {
        public static object ExecuteMethod(object objOrig, string MethodName, params object[] argsOrig)
        {
            object res = null;

            Type T = objOrig.GetType();

            var list = new List<Type>();

            foreach (var obj in argsOrig)
                list.Add(obj.GetType());

            var Method = T.GetMethod(MethodName, list.ToArray());

            res = Method.Invoke(objOrig, argsOrig);

            return res;

        }


        public static int TestFunction(int i)
        {


            var rn = new Random(i);

            //   int res = rn.Next(10000);
            int res = (int)ExecuteMethod(rn, "Next", 10000);

            return res;

        }
    }
}

typedef int (STDMETHODCALLTYPE *ManagedMethod)(int); 
HRESULT  CreateDelegate2(ICLRRuntimeHost2* pCLRRuntimeHost, DWORD appDomainID, wstring AssemblyName, wstring ClassName, wstring MethodName, INT_PTR *fnPtr) 
{ 

    HRESULT    hr = pCLRRuntimeHost->CreateDelegate( 
        appDomainID, 
        AssemblyName.c_str(), 
        ClassName.c_str(), 
        MethodName.c_str(), 
        (INT_PTR*)fnPtr); 

    return hr; 

}

ManagedMethod pTestFunction; 

    hr = CreateDelegate2(pCLRRuntimeHost, domainId, L"CoreClrDLL", L"CoreClrDLL.Program", L"TestFunction", (INT_PTR*)&pTestFunction); 
    if (FAILED(hr)) 
    { 
        printf_s("Failed to create a delegate to the managed entry point: (%d).\n", hr); 

    } 
    else 
    printf_s("result method  pTestFunction(555) : (%d).\n", pTestFunction(555));

void Метод(int парам, string str)
 void Метод(int парам, object str)

void Метод(int парам, params object[] str)
void Метод(int парам,int пара2, object str)

public abstract object[] GetCustomAttributes(
    Type attributeType,
    bool inherit
)

public static IEnumerable<Attribute> GetCustomAttributes(this ParameterInfo element, Type attributeType, bool inherit);

public static object call(MethodInfo Method, object Target, params object[] input)
        {

   
            ParameterInfo[] parameters = Method.GetParameters();
            bool hasParams = false;
            if (parameters.Length > 0)
                hasParams = parameters[parameters.Length - 1].GetCustomAttributes(typeof(ParamArrayAttribute), false).GetEnumerator().MoveNext();

            if (hasParams)
            {
                int lastParamPosition = parameters.Length - 1;

                object[] realParams = new object[parameters.Length];
                for (int i = 0; i < lastParamPosition; i++)
                    realParams[i] = input[i];

                Type paramsType = parameters[lastParamPosition].ParameterType.GetElementType();
                Array extra = Array.CreateInstance(paramsType, input.Length - lastParamPosition);
                for (int i = 0; i < extra.Length; i++)
                    extra.SetValue(input[i + lastParamPosition], i);

                realParams[lastParamPosition] = extra;

                input = realParams;
            }

            return Method.Invoke(Target, input);
        }

bool CAddInNative::CallAsFunc(const long lMethodNum,
                tVariant* pvarRetValue, tVariant* paParams, const long lSizeArray)
{ 
    return false; 
}

S>Нельзя просто так взять и перенести COM на платформу, которая его не поддерживает. Ваш кэп

S>Простой способ: AmbigiousMatchException

S>Сложный способ — подрубаем DLR, как советовал выше

Type T = typeof(string);

var Method = T.GetMethod("Format",new Type[]{ T,  typeof(Object[])});

S>Я бы не заморачивался с как минимум до следующего релиза. Если конечно нет желания оседлать хайп и снять все сливки Риски соответствующие.

pCLRRuntimeHost->UnloadAppDomain(domainId, true);

    // Stop the runtime host
    pCLRRuntimeHost->Stop();

public static int TestFunctionIntPtr(IntPtr i)
        {


            
            int res = Marshal.ReadInt32(i);

            return res;

        }

typedef int (STDMETHODCALLTYPE *ManagedMethodIntPtr)(int*);

ManagedMethodIntPtr pTestFunctionIntPtr;
    //TestFunctionIntPtr

    hr = CreateDelegate2(pCLRRuntimeHost, domainId, L"CoreClrDLL", L"CoreClrDLL.Program", L"TestFunctionIntPtr", (INT_PTR*)&pTestFunctionIntPtr);
    if (FAILED(hr))
    {
        printf_s("Failed to create a delegate to the managed entry point: (%d).\n", hr);

    }
    else
    {
        cout << "Press Key";
        cin.get();
        int i = 555;
        printf_s("result method  pTestFunctionIntPtr(555) : (%d).\n", pTestFunctionIntPtr(&i));
    }

        private static CallSite<Action<CallSite, Type, object, object>> callSite;

        static void Main(string[] args)
        {
            CallADynamic(1, 2);
            CallADynamic(null, null);
            CallADynamic(null, new object());
        }

        private static void CallADynamic(params object[] data)
        {
            if (callSite == null)
            {
                callSite =
                    CallSite<Action<CallSite, Type, object, object>>.Create(
                        Binder.InvokeMember(
                            CSharpBinderFlags.ResultDiscarded,
                            "CallA", null, typeof(Program), new CSharpArgumentInfo[]
                            {
                                CSharpArgumentInfo.Create(CSharpArgumentInfoFlags.UseCompileTimeType | CSharpArgumentInfoFlags.IsStaticType, null),
                                CSharpArgumentInfo.Create(CSharpArgumentInfoFlags.None, null),
                                CSharpArgumentInfo.Create(CSharpArgumentInfoFlags.None, null)
                            }));
            }
            callSite.Target(callSite, typeof(Program), data[0], data[1]);
        }

        static void CallA(params int[] args)
        {
            Console.WriteLine("params");
        }

        static void CallA(object a, object b)
        {
            Console.WriteLine("objects");
        }

        static void CallA(object a, string b)
        {
            Console.WriteLine("object+string");
        }

	P.S.

public static CallSite<Func<CallSite, Type, object, object, object>>  CallADynamic2Params(string MethodName)
        {
            
             var   res =
                    CallSite<Func<CallSite, Type, object, object, object>>.Create(
                        Binder.InvokeMember(
                            CSharpBinderFlags.ResultDiscarded,
                            MethodName,null, typeof(Program),  new CSharpArgumentInfo[]
                            {
                                CSharpArgumentInfo.Create(CSharpArgumentInfoFlags.UseCompileTimeType | CSharpArgumentInfoFlags.IsStaticType, null),
                                CSharpArgumentInfo.Create(CSharpArgumentInfoFlags.None, null),
                                CSharpArgumentInfo.Create(CSharpArgumentInfoFlags.None, null)
                            }));

            return res;
        }

        public static object CallFor2Param(Type type, object DynamicCalSite, params object[] data)
        {
            var cS = (CallSite<Func<CallSite, Type, object, object, object>>)DynamicCalSite;
            return cS.Target(cS, type, data[0], data[1]);


        }

var callSite = DynamicCall.CallADynamic2Params("CallA");

            DynamicCall.CallFor2Param(typeof(DynamicCall),callSite,1, 2);
            DynamicCall.CallFor2Param(typeof(DynamicCall), callSite, null, null);
            DynamicCall.CallFor2Param(typeof(DynamicCall), callSite, null, new object());

            double d = 78;
            var obj1 = DynamicCall.CallFor2Param(typeof(DynamicCall), callSite, 1, d);

static public int CallA(ref int a, double b)
        {
            a = 9;
            SB.AppendLine("ref int+double");
            return 9;
        }

 public class MyComparer : IComparer<Type>
    {

        public int Compare(Type TypeA, Type TypeB)
        {
            if (TypeA.IsAssignableFrom(TypeB)) return 1;

            if (TypeB.IsAssignableFrom(TypeA)) return -1;

            if (TypeA.IsByRef) return -1;

            if (TypeB.IsByRef) return  1;

            return 0;
        }

    }

var Comp = new MyComparer();
var tt = (new Type[] { typeof(int), typeof(int).MakeByRefType(),  typeof(double), typeof(object), typeof(string) }).OrderBy(t=>t, Comp).ToArray();

var Method = typeof(DynamicCall).GetMethod("CallA", new Type[] { typeof(int).MakeByRefType(), typeof(double) });

            object[] парам= new object[] { i,d};
            res = Method.Invoke(null, парам);

namespace CoreClrDLL
{

   

    public class ИнформацияОТипе: IComparable<ИнформацияОТипе>
    {
        public Type Тип;
        bool IsByRef;
        bool IsValue;
        int УровеньИерархии;
        bool IsNullable;
        public ИнформацияОТипе(Type type)
        {
            var TI = type.GetTypeInfo();
            IsByRef = TI.IsByRef;

           

            if (IsByRef)
            {
                Тип = type.GetElementType();
                TI = Тип.GetTypeInfo();
                
            }
            else
                Тип = type;


            IsValue = TI.IsValueType;

            if (IsValue)
            {
                УровеньИерархии = 0;
                if (TI.IsGenericType && TI.GetGenericTypeDefinition() == typeof(Nullable<>))
                {
                    IsNullable = true;

                    Тип = TI.GenericTypeArguments[0];
                }

            }
            else
                УровеньИерархии = НайтиУровень(0, Тип);


        }

        static int НайтиУровень(int Уровень, Type type)
        {

            if (type == typeof(object))
                return Уровень;

            return НайтиУровень(Уровень + 1, type.GetTypeInfo().BaseType);

        }

       
        public  int CompareTo(ИнформацияОТипе elem)
        {
           

            int res = -IsByRef.CompareTo(elem.IsByRef);

            if (res != 0) return res;

            if (Тип == elem.Тип)
                return 0;

            res = -IsValue.CompareTo(elem.IsValue);

            if (res != 0) return res;


            if (IsValue && elem.IsValue)
            {
                res = IsNullable.CompareTo(elem.IsNullable);

                if (res != 0) return res;

            }

            res = -УровеньИерархии.CompareTo(elem.УровеньИерархии);

            if (res != 0) return res;

           

            return Тип.ToString().CompareTo(elem.Тип.ToString());
        }

        public bool Равняется(Type type)
        {

            if (type==null)
            {
                if (!IsValue)
                    return true;

                if (IsNullable)
                    return true;
                else
                    return false;

            }

            // или использовать IsInstanceOfType
            if (IsValue) return Тип == type;

                return Тип.IsAssignableFrom(type);

        }
    }


    

    public class ИнфoрмацияОМетоде<T>  where T : MethodBase
    {
        public T Method;
        public ИнформацияОТипе[] Параметры;
        public int КоличествоПараметров;
        public bool hasParams;
        public Type TypeParams;
        public int КоличествоПараметровПарамс;
        public ИнформацияОТипе ИнформацияОТипеЭлемента;

        public static Dictionary<Type, ИнформацияОТипе> ИнформацияПоТипу = new Dictionary<Type, ИнформацияОТипе>();

        public static ИнформацияОТипе ПолучитьИнформациюОТипе(Type type)
        {
            ИнформацияОТипе ИТ = null;
            if (!ИнформацияПоТипу.TryGetValue(type,out ИТ))
            {
                ИТ = new ИнформацияОТипе(type);
                ИнформацияПоТипу[type] = ИТ;


            }
            return ИТ;
        }
       public ИнфoрмацияОМетоде(T MI)
        {
            Method = MI;

            ParameterInfo[] parameters = Method.GetParameters();
            hasParams = false;
            КоличествоПараметров = parameters.Length;
            if (КоличествоПараметров > 0)
            { 
                hasParams = parameters[parameters.Length - 1].GetCustomAttributes(typeof(ParamArrayAttribute), false).GetEnumerator().MoveNext();
            }

            if (hasParams)
            {
                TypeParams = parameters[parameters.Length - 1].ParameterType.GetElementType();
                ИнформацияОТипеЭлемента = ПолучитьИнформациюОТипе(TypeParams);

            }

            Параметры = new ИнформацияОТипе[КоличествоПараметров];

            for(int i=0;i< parameters.Length;i++)
            {

                Параметры[i] = ПолучитьИнформациюОТипе(parameters[i].ParameterType);

            }
        }

       public ИнфoрмацияОМетоде(ИнфoрмацияОМетоде<T> ИМ, int КолПарам)
        {
            Method = ИМ.Method;
            КоличествоПараметров = КолПарам;
            КоличествоПараметровПарамс = ИМ.КоличествоПараметров;
            hasParams = true;
            TypeParams = ИМ.TypeParams;
            ИнформацияОТипеЭлемента = ИМ.ИнформацияОТипеЭлемента;

            Параметры = new ИнформацияОТипе[КолПарам];

            for (int i = 0; i < КоличествоПараметровПарамс - 1; i++)
            {

                Параметры[i] =ИМ.Параметры[i];

            }

            
            var ИОТ= ПолучитьИнформациюОТипе(ИМ.TypeParams);

            for (int i = КоличествоПараметровПарамс - 1; i < КолПарам; i++)
            {

                Параметры[i] = ИОТ;

            }
        }

        // Добавить парамс как обычный метод
        public ИнфoрмацияОМетоде(ИнфoрмацияОМетоде<T> ИМ)
        {
            Method = ИМ.Method;
            КоличествоПараметров = ИМ.КоличествоПараметров;
            КоличествоПараметровПарамс = 0;
            hasParams = false;


            Параметры = ИМ.Параметры;
        }

        public bool Сравнить(Type[] параметры)
        {

            for (int i = 0; i < КоличествоПараметров ; i++)
            {

                if (!Параметры[i].Равняется(параметры[i]))
                      return false;

            }

            return true;
        }


       
        public bool СравнитьПарамс(Type[] параметры)
        {
           var ПоследнийПарам = КоличествоПараметров - 1;

            if (параметры.Length < ПоследнийПарам)
                return false;

            for (int i = 0; i < ПоследнийПарам; i++)
            {

                if (!Параметры[i].Равняется(параметры[i]))
                    return false;

            }

            
            
            
            for (int i = ПоследнийПарам; i < параметры.Length; i++)
            {

                if ( !ИнформацияОТипеЭлемента.Равняется(параметры[i]))
                    return false;

            }

            return true;
        }

        public object ВыполнитьМетод(object Target, params object[] input)
        {

            if (!hasParams)
                return Method.Invoke(Target, input);


            int последняяПозиция = КоличествоПараметров - 1;

                object[] realParams = new object[КоличествоПараметров];
                for (int i = 0; i < последняяПозиция; i++)
                    realParams[i] = input[i];

                
                Array массивПараметров = Array.CreateInstance(TypeParams, input.Length - последняяПозиция);
                for (int i = 0; i < массивПараметров.Length; i++)
                массивПараметров.SetValue(input[i + последняяПозиция], i);

                realParams[последняяПозиция] = массивПараметров;



            var res= Method.Invoke(Target, realParams);

            массивПараметров = (Array)realParams[последняяПозиция];
            for (int i = 0; i < массивПараметров.Length; i++)
                input[i + последняяПозиция] = realParams.GetValue(i);


            return res;


        }

    }
}

var tint = typeof(int).MakeByRefType().GetElementType();

static public void CallA(params int[] args)

static public void CallA(int arg1,int arg1)

namespace CoreClrDLL
{

    public class СравнительМетодов<T> : IComparer<ИнфoрмацияОМетоде<T>>   where T : MethodBase
    {


        public int Compare(ИнфoрмацияОМетоде<T> A, ИнфoрмацияОМетоде<T> B)
        {
            int res = 0;
            for (int i=0; i< A.Параметры.Count(); i++)
            {

                res = A.Параметры[i].CompareTo(B.Параметры[i]);

                if (res != 0) return res;
            }

            res = A.hasParams.CompareTo(B.hasParams);

            if (res != 0) return res;


            res = -A.КоличествоПараметровПарамс.CompareTo(B.КоличествоПараметровПарамс);
            if (res != 0) return res;

            return A.Method.ToString().CompareTo(B.Method.ToString());
        }


       
    }

    public class СравнительМетодовСпарамс<T> : IComparer<ИнфoрмацияОМетоде<T>> where T : MethodBase
    {


        public int Compare(ИнфoрмацияОМетоде<T> A, ИнфoрмацияОМетоде<T> B)
        {


            int res = 0;
            res = -A.КоличествоПараметров.CompareTo(B.КоличествоПараметров);
            if (res != 0) return res;

            for (int i = 0; i < A.Параметры.Count() - 1; i++)
            {

                res = A.Параметры[i].CompareTo(B.Параметры[i]);

                if (res != 0) return res;
            }

            res = A.hasParams.CompareTo(B.hasParams);

            if (res != 0) return res;


           

            return A.Method.ToString().CompareTo(B.Method.ToString());
        }
    }
    public class ВсеМетодыПоИмени<T> where T : MethodBase
    {
         Dictionary<int, List<ИнфoрмацияОМетоде<T>>> ОбычныеМетоды=new Dictionary<int, List<ИнфoрмацияОМетоде<T>>>();

         List<ИнфoрмацияОМетоде<T>> МетодыСParams=new List<ИнфoрмацияОМетоде<T>>();

        void ДобавитьВСловарь(ИнфoрмацияОМетоде<T> им, int КоличествоПараметров)
        {
            List<ИнфoрмацияОМетоде <T>> СписокМетодов = null;

            if (!ОбычныеМетоды.TryGetValue(КоличествоПараметров, out СписокМетодов))
            {
                СписокМетодов = new List<ИнфoрмацияОМетоде<T>>();
                ОбычныеМетоды[КоличествоПараметров] = СписокМетодов;


            }


            СписокМетодов.Add(им);
        }

        void ДобавитПарамсВСписок(KeyValuePair<int, List<ИнфoрмацияОМетоде<T>>>[] Массив, ИнфoрмацияОМетоде<T> Им)
        {
            int минКолПарам = Им.КоличествоПараметров - 1;

            
            foreach (var кв in Массив)
            {

                if (кв.Key < минКолПарам) continue;


                var им = new ИнфoрмацияОМетоде<T>(Им, кв.Key);
                кв.Value.Add(им);

            }

        }
        void ДобавитьМетодыСпарамсВОбычныеМетоды()
        {

            var KV = ОбычныеМетоды.OrderBy(x => x.Key).ToArray();
            foreach (var им in МетодыСParams)
            {

                ДобавитПарамсВСписок(KV, им);


            }

            foreach (var kv in KV)
            {
                kv.Value.Sort(new СравнительМетодов<T>());

            }
        }
        public ВсеМетодыПоИмени(IEnumerable<T> методы)
        {

            foreach(var метод in методы)
            {

                var им = new ИнфoрмацияОМетоде<T>(метод);

                if (им.hasParams)
                {
                    МетодыСParams.Add(им);
                    var ОбычныйМетод = new ИнфoрмацияОМетоде<T>(им);
                    ДобавитьВСловарь(ОбычныйМетод, ОбычныйМетод.КоличествоПараметров);
                }
                else
                {

                    ДобавитьВСловарь(им, им.КоличествоПараметров);
                }

            }


            ДобавитьМетодыСпарамсВОбычныеМетоды();

            МетодыСParams.Sort(new СравнительМетодовСпарамс<T>());

         

        }

        public ИнфoрмацияОМетоде<T> НайтиМетод(object[] параметрыОбъекты)
        {

            Type[] параметры = new Type[параметрыОбъекты.Length];

            for (var i=0; i< параметрыОбъекты.Length; i++)
            {
                if (параметрыОбъекты[i] == null)
                    параметры[i] = null;
                else
                    параметры[i] = параметрыОбъекты[i].GetType();


            }
            List<ИнфoрмацияОМетоде<T>> СписокМетодов;

            if (ОбычныеМетоды.TryGetValue(параметры.Length, out СписокМетодов))
            {
                if (параметры.Length == 0) return СписокМетодов[0];

                foreach (var метод in СписокМетодов)
                {
                    if (метод.Сравнить(параметры))
                        return метод;

                }


            }


            foreach (var метод in МетодыСParams)
            {
                if (метод.СравнитьПарамс(параметры))
                    return метод;

            }

            return null;
        }
    }
}

public static void НайтиИВыполнитьМетод(ВсеМетодыПоИмени<MethodInfo> ВсеМетоды, params object[] параметры)
        {
            var метод = ВсеМетоды.НайтиМетод(параметры);
            if (метод != null)
                   метод.ВыполнитьМетод(null, параметры);

        }
        public static void ТестПоискаМетода()
        {

            DynamicCall.SB.Clear();
            var методы = typeof(DynamicCall).GetMethods().Where(x => x.Name == "CallA").ToArray();

            var всеМетоды = new ВсеМетодыПоИмени<MethodInfo>(методы);
            //DynamicCall.CallADynamic(1, 2);
            //DynamicCall.CallADynamic(null, null);
            //DynamicCall.CallADynamic(null, new object());

            double d = 6;
            НайтиИВыполнитьМетод(всеМетоды, 2, d);
            НайтиИВыполнитьМетод(всеМетоды, 1, 2);
            НайтиИВыполнитьМетод(всеМетоды, null, null);
            НайтиИВыполнитьМетод(всеМетоды, null, new object());
            НайтиИВыполнитьМетод(всеМетоды, 1, new int[] { 1,2,3});

            string ss = DynamicCall.SB.ToString();
        }

С моим кодом пока работаю только я один.

[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
         delegate void myDelegate(IntPtr thisptr);

  public static void TestCallBack(IntPtr Str,IntPtr FuncPtr)
        {

            myDelegate fun = Marshal.GetDelegateForFunctionPointer<myDelegate>(FuncPtr);

            fun(Str);

            var str = Marshal.PtrToStringUni(Str);
        }

typedef void(STDMETHODCALLTYPE *ManagedTestCallBack)(const wchar_t*, void(*) (const wchar_t*));

    typedef void(STDMETHODCALLTYPE *ManagedTestCallBack)(const wchar_t*, void(*) (const wchar_t*));
    
void TestCallBack(const wchar_t* str)
{

    printf_s("Return string %S.\n", str);
}


    ManagedTestCallBack pTestCallBack;
    
    
    hr = CreateDelegate2(pCLRRuntimeHost, domainId, L"CoreClrDLL", L"CoreClrDLL.Program", L"TestCallBack", (INT_PTR*)&pTestCallBack);
        if (FAILED(hr))
        {
            printf_s("Failed to create a delegate to the managed entry point: (%d).\n", hr);
    
        }
        else
        {
            wchar_t* str = L"Test str from unmanaged";
            pTestCallBack(str, TestCallBack);
        }

ManagedTestCallBack pTestCallBack;


hr = CreateDelegate2(pCLRRuntimeHost, domainId, L"CoreClrDLL", L"CoreClrDLL.Program", L"TestCallBack", (INT_PTR*)&pTestCallBack);
    if (FAILED(hr))
    {
        printf_s("Failed to create a delegate to the managed entry point: (%d).\n", hr);

    }
    else
    {
        wchar_t* str = L"Test str from unmanaged";
        pTestCallBack(str, TestCallBack);
    }

Процедура ExtractFields(S,aList,Delimiter,QuoteChar)
    FieldStart=0; ScanField=1; ScanQuoted=2; EndQuoted=3;

   //{initialize by clearing the string list, and
   // starting in FieldStart state}
   // Assert(aList <> nil, 'TDExtractFields: list is nil');
    aList= новый Массив;
    if ( (S=неопределено) или (СтрДлина(S) =0 )) Тогда
        aList.Add("");
        return;
    КонецЕсли;

    State = FieldStart;

   //  RStringBuilder SB= new RStringBuilder();
    SB="";
    StartPos=1;
    EndPos=СтрДлина(S);
    Inx=1;

   // {read through all the characters in the string}
    while (Inx <=EndPos) Цикл

       //    {get the next character}
        Ch = Сред(S,Inx,1);

       //    {switch processing on the state}
        Если State =FieldStart Тогда

            if  ( Ch = QuoteChar) Тогда
                State = ScanQuoted;
                StartPos=Inx+1;
                SB="";
                Inx=НайтиВПодстроке(S,StartPos,QuoteChar);
                продолжить;
            else
                if ( Ch = Delimiter) Тогда

namespace CoreClrDLL
{

//    struct _tVariant
//    {
//        _ANONYMOUS_UNION union
//        {
//            int8_t i8Val;
//            int16_t shortVal;
//            int32_t lVal;
//        int intVal;
//        unsigned int uintVal;
//        int64_t llVal;
//        uint8_t ui8Val;
//        uint16_t ushortVal;
//        uint32_t ulVal;
//        uint64_t ullVal;
//        int32_t errCode;
//        long hRes;
//        float fltVal;
//        double dblVal;
//        bool bVal;
//        char chVal;
//        wchar_t wchVal;
//        DATE date;
//        IID IDVal;
//        struct _tVariant *pvarVal;
//        struct tm      tmVal;
//        _ANONYMOUS_STRUCT struct
//        {
//            void* pInterfaceVal;
//        IID InterfaceID;
//    }
//    __VARIANT_NAME_2/*iface*/;
//        _ANONYMOUS_STRUCT struct
//        {
//            char* pstrVal;
//    uint32_t strLen; //count of bytes
//}
//__VARIANT_NAME_3/*str*/;
//        _ANONYMOUS_STRUCT struct
//        {
//            WCHAR_T* pwstrVal;
//uint32_t wstrLen; //count of symbol
//        } __VARIANT_NAME_4/*wstr*/;
//    } __VARIANT_NAME_1;
//    uint32_t cbElements;    //Dimension for an one-dimensional array in pvarVal
//TYPEVAR vt;
//};
   public enum EnumVar
    {
        VTYPE_EMPTY = 0,
        VTYPE_NULL,
        VTYPE_I2,                   //int16_t
        VTYPE_I4,                   //int32_t
        VTYPE_R4,                   //float
        VTYPE_R8,                   //double
        VTYPE_DATE,                 //DATE (double)
        VTYPE_TM,                   //struct tm
        VTYPE_PSTR,                 //struct str    string
        VTYPE_INTERFACE,            //struct iface
        VTYPE_ERROR,                //int32_t errCode
        VTYPE_BOOL,                 //bool
        VTYPE_VARIANT,              //struct _tVariant *
        VTYPE_I1,                   //int8_t
        VTYPE_UI1,                  //uint8_t
        VTYPE_UI2,                  //uint16_t
        VTYPE_UI4,                  //uint32_t
        VTYPE_I8,                   //int64_t
        VTYPE_UI8,                  //uint64_t
        VTYPE_INT,                  //int   Depends on architecture
        VTYPE_UINT,                 //unsigned int  Depends on architecture
        VTYPE_HRESULT,              //long hRes
        VTYPE_PWSTR,                //struct wstr
        VTYPE_BLOB,                 //means in struct str binary data contain
        VTYPE_CLSID,                //UUID
        VTYPE_STR_BLOB = 0xfff,
        VTYPE_VECTOR = 0x1000,
        VTYPE_ARRAY = 0x2000,
        VTYPE_BYREF = 0x4000,    //Only with struct _tVariant *
        VTYPE_RESERVED = 0x8000,
        VTYPE_ILLEGAL = 0xffff,
        VTYPE_ILLEGALMASKED = 0xfff,
        VTYPE_TYPEMASK = 0xfff
    };

    public class РаботаСВариантами
    {
      public static  object ПолучитьОбъекИзIntPtr(IntPtr Элемент)
        {
            IntPtr текПоз = Элемент + 44;
            int размерIntPtr = Marshal.SizeOf<IntPtr>();
            EnumVar тип =(EnumVar) Marshal.ReadInt16(текПоз);

            switch (тип)
            {
                case EnumVar.VTYPE_EMPTY:
                case EnumVar.VTYPE_NULL: return null;
                case EnumVar.VTYPE_I2: return Marshal.ReadInt16(Элемент);
                case EnumVar.VTYPE_I4: return Marshal.ReadInt32(Элемент);
                case EnumVar.VTYPE_R4: return Marshal.PtrToStructure<float>(Элемент);
                case EnumVar.VTYPE_R8: return Marshal.PtrToStructure<double>(Элемент);
                case EnumVar.VTYPE_BOOL:return Marshal.ReadByte(Элемент)!=0;
                case EnumVar.VTYPE_I1: return (sbyte)Marshal.ReadByte(Элемент);
                case EnumVar.VTYPE_UI1: return Marshal.ReadByte(Элемент);
                case EnumVar.VTYPE_UI2: return (UInt16)Marshal.ReadInt16(Элемент);

                case EnumVar.VTYPE_UI4: return (UInt32)Marshal.ReadInt32(Элемент);

                case EnumVar.VTYPE_I8: return Marshal.ReadInt64(Элемент);
                case EnumVar.VTYPE_UI8: return (UInt64)Marshal.ReadInt64(Элемент);
                case EnumVar.VTYPE_PWSTR: return Marshal.PtrToStringUni(Marshal.ReadIntPtr(Элемент));

                case EnumVar.VTYPE_BLOB:
                    текПоз = Элемент + размерIntPtr;
                    byte[] res = new byte[Marshal.ReadInt32(текПоз)];
                    Marshal.Copy(Marshal.ReadIntPtr(Элемент), res,0,res.Length);
                    return res;
            }
            return null;
            }



        }
}

static object[] ПолучитьМассивПараметров(IntPtr МассивПараметров, int РазмерМассива)
        {

            var result = new object[РазмерМассива];
            IntPtr ТекПоз = МассивПараметров;
            for (var i=0; i< result.Length; i++)
            {
                result[i] = РаботаСВариантами.ПолучитьОбъекИзIntPtr(ТекПоз);

                ТекПоз += 48;
            }

            return result;
        }
        public static bool CallAsFunc(int Target, IntPtr ИмяМетодаPtr, IntPtr ReturnValue, IntPtr МассивПараметров,int РазмерМассива)
            {

            string ИмяМетода = Marshal.PtrToStringUni(ИмяМетодаPtr);
            var параметры = ПолучитьМассивПараметров(МассивПараметров, РазмерМассива);
            return true;

        }

typedef void(STDMETHODCALLTYPE *ManagedCallAsFunc)(const __int32, const wchar_t*, tVariant* pvarRetValue, tVariant* paParams, const __int32  lSizeArray);

ManagedCallAsFunc  pCallAsFunc;

hr = CreateDelegate2(pCLRRuntimeHost, domainId, L"CoreClrDLL", L"CoreClrDLL.Program", L"CallAsFunc", (INT_PTR*)&pCallAsFunc);
    if (FAILED(hr))
    {
        printf_s("Failed to create a delegate to the managed entry point: (%d).\n", hr);

    }
    else
    {
        //(const __int32, const wchar_t*, tVariant* pvarRetValue, tVariant* paParams, const __int32  lSizeArray);
        wchar_t* str = L"Test str from unmanaged";
        tVariant* paParams = new tVariant[4];
        tVariant* paP = paParams;
        paP->vt = VTYPE_I4;
        paP->lVal = 8;

        paP++;

        paP->vt = VTYPE_BOOL;
        paP->lVal = true;

        paP++;
        paP->vt = VTYPE_PWSTR;
        paP->pwstrVal = str;

        byte* pb = new byte[4]; pb[0] = 27; pb[1] = 28; pb[2] = 29; pb[3] = 30;
        paP++;
        paP->vt = VTYPE_BLOB;
        paP->pstrVal = (char*)pb;
        paP->strLen = 4;
        pCallAsFunc(-1, str, 0, paParams, 4);
    }

 public struct ЭлементХранилища
    {
        internal AutoWrap Объект;
        internal int Next;


       internal ЭлементХранилища(AutoWrap Объект)
        {

            this.Объект = Объект;
            Next = -1;
        }

        internal ЭлементХранилища(AutoWrap Объект, int next)
        {

            this.Объект = Объект;
            Next = next;
        }
    }

   internal class ХранилищеОбъектов
    {
     
         List<ЭлементХранилища> Элементы= new List<ЭлементХранилища>();
         int FirstDeleted = -1;

        public int Add(AutoWrap Объект)
        {



            var элемент = new ЭлементХранилища(Объект);




            if (FirstDeleted == -1)
            { Элементы.Add(элемент);
                return Элементы.Count-1;
            }
            else
            {
               int newPos = FirstDeleted;
                FirstDeleted = Элементы[newPos].Next;
                Элементы[newPos] = элемент;
                return newPos;

            }
 
        }

        public void RemoveKey(int Pos)
        {
            if (Pos > -1 && Pos < Элементы.Count && Элементы[Pos].Объект != null)
            {
               
                var Элемент = new ЭлементХранилища(null, FirstDeleted);
                Элементы[Pos] =Элемент;
            
                FirstDeleted = Pos;
            }
                           


        }

        public AutoWrap GetValue(int Pos)
        {

            if (!(Pos > -1 && Pos < Элементы.Count && Элементы[Pos].Объект != null))
                return null;

            return Элементы[Pos].Объект;

        }

    }

public class AutoWrap
    {
        [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
        internal delegate IntPtr ВыделитьПамятьDelegate(int КоличествоБайтов);

        internal static ХранилищеОбъектов СписокОбъектов;
        internal static int ХэшДляСсылки=new Guid().GetHashCode();


        protected internal object O = null;
        protected internal Type T = null; // Тип может быть и интерфейсом
        protected internal int ИндекасВСписке;


        internal bool ЭтоТип;
        internal bool IsEnum;
        internal bool ЭтоExpandoObject;
        internal static bool ЭтоСемерка = false;
        internal static bool ВыводитьСообщениеОбОшибке = true;
        internal static Exception ПоследняяОшибка = null;

        internal static ВыделитьПамятьDelegate ВыделитьПямять;

        public static void SetDelegate(IntPtr ДляВыделенияПамяти)
        {
            ВыделитьПямять = Marshal.GetDelegateForFunctionPointer<ВыделитьПамятьDelegate>(ДляВыделенияПамяти);

        }
        static AutoWrap()
        {
            СписокОбъектов = new ХранилищеОбъектов();
            var первый = new AutoWrap(typeof(NetObjectToNative));

        }


        public AutoWrap(object obj)
        {

            ИндекасВСписке = СписокОбъектов.Add(this);
            O = obj;
            if (O is Type)
            {
                T = O as Type;
                ЭтоТип = true;
            }
            else
            {
                T = O.GetType();
                ЭтоТип = false;
                ЭтоExpandoObject = O is System.Dynamic.ExpandoObject;
                IsEnum = T.GetTypeInfo().IsEnum;


            }

 public static bool CallAsFunc(int Target, IntPtr ИмяМетодаPtr, IntPtr ReturnValue, IntPtr МассивПараметров, int РазмерМассива)
        {
            var AW = СписокОбъектов.GetValue(Target);

            if (AW == null) return false;

            bool IsReturnValue = ReturnValue != IntPtr.Zero;

            string ИмяМетода = Marshal.PtrToStringUni(ИмяМетодаPtr);
            var параметры = ПолучитьМассивПараметров(МассивПараметров, РазмерМассива);

            object result = null;
            List<int> ИзмененныеПараметры = new List<int>();

           

            var res = AW.TryInvokeMember(ИмяМетода, параметры, out result, ИзмененныеПараметры);
            if (!res) return false;

            foreach( var i in ИзмененныеПараметры)
            {
                РаботаСВариантами.УстановитьОбъектВIntPtr(параметры[i], МассивПараметров+48*i);

            }

            if (IsReturnValue) РаботаСВариантами.УстановитьОбъектВIntPtr(ОбернутьОбъект(result), ReturnValue);

            return true;

        }

      public static   int GetNParams(int Target, IntPtr ИмяМетодаPtr)
{
            var AW = СписокОбъектов.GetValue(Target);
            if (AW == null) return -1;

            string ИмяМетода = Marshal.PtrToStringUni(ИмяМетодаPtr);
            return ИнформацияПоТипам.КоличествоПараметровДляМетода(AW.T, ИмяМетода);

        }

    public static  bool SetPropVal(int Target, IntPtr ИмяСвойстваPtr, IntPtr pvarPropVal)
{

            var AW = СписокОбъектов.GetValue(Target);
            if (AW == null) return false;

            string ИмяСвойства = Marshal.PtrToStringUni(ИмяСвойстваPtr);

            object result = РаботаСВариантами.ПолучитьОбъекИзIntPtr(pvarPropVal);

            var res = AW.TrySetMember(ИмяСвойства,result);
            

            return res;
}
        //---------------------------------------------------------------------------//
        public static bool GetPropVal(int Target, IntPtr ИмяСвойстваPtr, IntPtr varPropVal)
{
            var AW = СписокОбъектов.GetValue(Target);
            if (AW == null) return false;

            string ИмяСвойства = Marshal.PtrToStringUni(ИмяСвойстваPtr);

            object result = null;
            var res = AW.TryGetMember(ИмяСвойства, out result);
            if (!res) return false;

            РаботаСВариантами.УстановитьОбъектВIntPtr(ОбернутьОбъект(result), varPropVal);

            return true;
}

        public static void DeleteObject(int Target)
        {
            СписокОбъектов.RemoveKey(Target);

        }

var sB= new System.Text.StringBuilder();
sB.Append("Новая Строка");
var str=sB.ToString();
sB.Capacity=40;
var capacity=sB.Capacity

// Загрузим Core CLR
    // И создадим домен
    //Первый параметр это путь к папке с coreclr.dll
    NetObjectToNative::ManagedDomainLoader* mD = NetObjectToNative::ManagedDomainLoader::InitManagedDomain(L"c:\\Program Files\\DNX\\runtimes\\dnx-coreclr-win-x86.1.0.0-rc1-update1\\bin\\", L"", L"");

    if (!mD)  return 0;

    tVariant Params[4];
    tVariant RetVal;
    tVariant* paParams = Params;

    paParams->vt = VTYPE_PWSTR;
    paParams->pwstrVal = L"System.Text.StringBuilder";

    cout << "Press Key";
    cin.get();

    // 0 это индекс вспомогательного класса для получения типов объектов и прочих удобный методов
   bool res=mD->pCallAsFunc(0, L"Новый", &RetVal, paParams, 1);
   if(!res) return 0;


   // Так как в 1С нет возможности установить пользовательский тип
   // то возвращаем byte[12] который будет ID объекта
   // первые четыре байта ХэшДляСсылки=new Guid().GetHashCode(); одинаковый для всех .Net объектов
   // вторые 4 байта это хэш объекта
   // третьи это индекс в списке экспортируемых объектов
   // Можно его передавать в качестве параметра типа BLOB
   byte ref[12];
   memcpy(ref, RetVal.pstrVal, 12);
   // Теперь мы можем передавать ссылку ref в параметрах;
   long* target =(long*)RetVal.pstrVal;

   long Target = target[2]; // Получили индекс в списке
   
   wprintf_s(L"index : %d\n", Target);

   // Память выделяется на стороне натива. Нам и удалять.
   delete[] RetVal.pstrVal;

   paParams->vt = VTYPE_PWSTR;
   paParams->pwstrVal = L"Новая Строка";

// 0 так как вызывается как void даже если метод что то и возвращает, что бы не оборачивать результат
    res = mD->pCallAsFunc(Target, L"Append", 0, paParams, 1);

    res = mD->pCallAsFunc(Target, L"ToString", &RetVal, paParams, 0);
    wprintf_s(L"index : %S\n", RetVal.pwstrVal);

    delete[] RetVal.pstrVal;

    paParams->vt = VTYPE_I4;
    paParams->lVal =40;
    res = mD->pSetPropVal(Target, L"Capacity", paParams);


    res = mD->pGetPropVal(Target, L"Capacity", &RetVal);
    wprintf_s(L"Capacity : %d\n", RetVal.lVal);

    // Удалим объект из списка. Теперь его может собрать GC
    mD->pDeleteObject(Target);
    
    // Создадим объект через тип

    paParams->vt = VTYPE_PWSTR;
    paParams->pwstrVal = L"System.Text.StringBuilder";
// Получим ID оббъекта typeof(System.Text.StringBuilder)
    res = mD->pCallAsFunc(0, L"ПолучитьТип", &RetVal, paParams, 1);

    //paParams[0] = RetVal;

    // Скопируем ID оббъекта typeof(System.Text.StringBuilder)
    memcpy(ref, RetVal.pstrVal, 12);

    // Установим ссылку в параметрах
    paParams->vt = VTYPE_BLOB;
    paParams->pstrVal =(char*) ref;
    paParams->strLen = 12;


    // И создадим экземпляр StringBuilder
    res = mD->pCallAsFunc(0, L"Новый", &RetVal, paParams, 1);
    if (!res) return 0;


    // Выгрузим домен
    delete mD;

    return 0;

Перем   Врап,СсылкаНаДомен;
Функция СоздатьОбъектПоСсылке(Ссылка)
    
    рез = Новый("AddIn.NetObjectToNative.NetObjectToNative");
    рез.УстановитьСсылку(СсылкаНаДомен,Ссылка);    
    возврат  рез
КонецФункции // СоздатьОбъектПоСсылке()


Процедура КнопкаВыполнитьНажатие(Кнопка)
    
    СылкаСБ=Врап.Новый("System.Text.StringBuilder","Первая Строка");
    СсылкаCultureInfo=Врап.ПолучитьТип("System.Globalization.CultureInfo");
    
    СсылкаCultureInfoES=Врап.Новый(СсылкаCultureInfo,"es-ES");
    
    // 
    СultureInfo=СоздатьОбъектПоСсылке(СсылкаCultureInfo);
    
    СБ=СоздатьОбъектПоСсылке(СылкаСБ);
    Сообщить(СБ.Capacity);
    Сообщить(СБ.ПолучитьСсылку());
    
    СсылкаInvariantCulture=СultureInfo.InvariantCulture;
    
    // К сожалению 1С вызывает метод имеющий возвращаемое значение как функцию даже если вызов идет как процедура
    //Нужно очистить ссылку в списке объектов
    ссылка=Сб.Append("Новая Строка"); Врап.ОчиститьСсылку(ссылка);
    ссылка=Сб.AppendLine();   Врап.ОчиститьСсылку(ссылка);
    ссылка=Сб.Append("Вторая Строка"); Врап.ОчиститьСсылку(ссылка);
    ссылка=Сб.AppendLine();     Врап.ОчиститьСсылку(ссылка);
    
    ссылка=Сб.AppendFormat("AppendFormat {0}, {1}, {2}, {3}, {4},", "Строка", 21, 45.89, ТекущаяДата(),истина );   Врап.ОчиститьСсылку(ссылка);
    ссылка=Сб.AppendLine(); Врап.ОчиститьСсылку(ссылка);
    
    // Так как в параметрах можно передавать только простые типы закодирум ссылку на объект в строку
    ссылка=Сб.AppendFormat(СсылкаCultureInfoES,"AppendFormat {0}, {1}, {2}, {3}, {4},", "Строка", 21, 45.89, ТекущаяДата(),истина );  Врап.ОчиститьСсылку(ссылка);
    ссылка=Сб.AppendLine(); Врап.ОчиститьСсылку(ссылка);
    
    ссылка=Сб.AppendFormat(СсылкаInvariantCulture,"AppendFormat {0}, {1}, {2}, {3}, {4},", "Строка", 21, 45.89, ТекущаяДата(),истина ); 
    Врап.ОчиститьСсылку(СсылкаInvariantCulture);
    
    
    
    
    
    Сообщить(СБ.ToString());
    СБ.Capacity=40;
    Сообщить(СБ.Capacity);
    
    // Очистка ссылок СБ и  СultureInfo осуществляется внутри ВК
КонецПроцедуры

Процедура ПриОткрытии() 
    
    
    ИмяФайла="d:\MyPrograms\VNCOMP83\AddInNetObjectToNative\AddInNetObjectToNative\Debug\AddInNetObjectToNative.dll";
    
    ПодключитьВнешнююКомпоненту(ИмяФайла, "NetObjectToNative",ТипВнешнейКомпоненты.Native); 
    Врап = Новый("AddIn.NetObjectToNative.LoaderCLR");
    CoreClrDir="c:\Program Files\DNX\runtimes\dnx-coreclr-win-x86.1.0.0-rc1-update1\bin\";
    ДиректорияNetObjectToNative="d:\MyPrograms\VNCOMP83\NetObjectToNative\NetObjectToNative\bin\Debug\";
    
    СсылкаНаДомен=Врап.СоздатьОбертку(CoreClrDir,ДиректорияNetObjectToNative,"");
    
КонецПроцедуры

СылкаСБ=Врап.Новый("System.Text.StringBuilder","Первая Строка"); 
//Сообщить(СылкаСБ); 

СсылкаCultureInfo=Врап.ПолучитьТип("System.Globalization.CultureInfo"); 

    СсылкаCultureInfo=Врап.Новый(СсылкаCultureInfo,"es-ES"); 
// Здесь уже СсылкаCultureInfo указывает на объект 

// 
    СultureInfo=СоздатьОбъектПоСсылке(СсылкаCultureInfo); 

И СultureInfo это не тип а объект СсылкаCultureInfo,"es-ES");   

   
// Вызываем статический метод     
    СсылкаInvariantCulture=СultureInfo.InvariantCulture;

namespace TestDllForCoreClr
{
    public class Тестовый
    {
        public static string Поле = "Статическое поле";
        public string СвойствоОбъекта { get; set; }

        public  Тестовый(string СвойствоОбъекта)
            {
            this.СвойствоОбъекта = СвойствоОбъекта;
            }

        public string ПолучитьСтроку()
        {

            return "Привет из CoreClr";
        }

        public int ПолучитьЧисло(int число)
        {

            return число;
        }
    }
}

    paParams->vt = VTYPE_PWSTR;
    paParams->pwstrVal = L"TestDllForCoreClr.Тестовый, TestDllForCoreClr, Version=1.0.0.0, Culture=neutral, PublicKeyToken=null";

    auto par2 = paParams;
    par2++;
    par2->vt = VTYPE_PWSTR;
    par2->pwstrVal = L"Свойство из Конструктора";
    res = mD->pCallAsFunc(0, L"Новый", &RetVal, paParams, 2);

    long testRef = GetTarget(&RetVal);
    paParams->vt = VTYPE_I4;
    paParams->lVal = 3;

    res = mD->pCallAsFunc(testRef, L"ПолучитьЧисло", &RetVal, paParams, 1);
    wprintf_s(L"input int : %d\n", RetVal.lVal);


    TestCallMethod(mD, testRef);
    TestCallMethod(mD, testRef);
    TestCallMethod(mD, testRef);

void TestCallMethod(NetObjectToNative::ManagedDomainLoader* mD, long Target)
{
    tVariant Params[4];
    tVariant RetVal;
    tVariant* paParams = Params;
    typedef std::chrono::high_resolution_clock Clock;
    auto start = Clock::now();
    

    long r = 0;
    for (int i = 0; i < 1000000; i++)
    {
        
        paParams->lVal = i;
        paParams->vt = VTYPE_I4;
        mD->pCallAsFunc(Target, L"ПолучитьЧисло", &RetVal, paParams, 1);
        
        r += RetVal.lVal;
        r %= 1 << 30;

    }

    auto finish = Clock::now();


    auto elapsed = std::chrono::duration_cast<std::chrono::nanoseconds>(finish - start).count() / 1000000000.0;


    wprintf_s(L"Tme=:  %.2f  second\n", elapsed);
    wprintf_s(L"Eval Value=:  %d \n", r);
}


Получилось около 3 сек 2.8, на моем i3-2120 3.3 GHz

Может я что делаю не так?

long GetTarget(tVariant* CurParam)
{
    wchar_t* curstr = CurParam->pwstrVal;
    curstr += 13;
    wstring temp = curstr;
    return stol(temp);

}

using System.Text;
using System.Threading.Tasks;
using System.Linq.Expressions;
using Microsoft.CSharp.RuntimeBinder;
using System.Dynamic;
using System.Runtime.CompilerServices;
namespace Тестовый
{
   public class DynamicInvoker
    {
       public static object InvokeMember(object target, string methodName, params object[] args)
        {
            var targetParam = CSharpArgumentInfo.Create(CSharpArgumentInfoFlags.None, null);
            CSharpArgumentInfo[] parameterFlags = new CSharpArgumentInfo[args.Length + 1];
            System.Linq.Expressions.Expression[] parameters = new System.Linq.Expressions.Expression[args.Length + 1];
            parameterFlags[0] = targetParam;
            parameters[0] = System.Linq.Expressions.Expression.Constant(target);
            for (int i = 0; i < args.Length; i++)
            {
                parameterFlags[i + 1] = CSharpArgumentInfo.Create(CSharpArgumentInfoFlags.Constant | CSharpArgumentInfoFlags.UseCompileTimeType, null);
                parameters[i + 1] = System.Linq.Expressions.Expression.Constant(args[i]);
            }
            var csb = Binder.InvokeMember(CSharpBinderFlags.None, methodName, null, typeof(DynamicInvoker), parameterFlags);
            var de = DynamicExpression.Dynamic(csb, typeof(object), parameters);
            LambdaExpression expr = System.Linq.Expressions.Expression.Lambda(de);
            return expr.Compile().DynamicInvoke();
        }

        public static object GetValue(object target,string name)
        {
            
            CallSite<Func<CallSite, object, object>> callSite = CallSite<Func<CallSite, object, object>>.Create(Binder.GetMember(CSharpBinderFlags.None, name, typeof(DynamicInvoker), new CSharpArgumentInfo[] { CSharpArgumentInfo.Create(CSharpArgumentInfoFlags.None, null) }));
               
            return callSite.Target(callSite, target);
        }
        public static void SetValue(object target, string name,  object value)
        {
          
                CallSite<Func<CallSite, object, object, object>> callSite = CallSite<Func<CallSite, object, object, object>>.Create(Binder.SetMember(CSharpBinderFlags.None, name, typeof(DynamicInvoker), new CSharpArgumentInfo[] { CSharpArgumentInfo.Create(CSharpArgumentInfoFlags.None, null), CSharpArgumentInfo.Create(CSharpArgumentInfoFlags.UseCompileTimeType, null) }));
                callSite.Target(callSite, target, value);
        }


    }
}

void ВывестиСвойство(object target, string ИмяСвойства)
        {
            textBox.AppendText(ИмяСвойства+"="+DynamicInvoker.GetValue(target, ИмяСвойства).ToString() + Environment.NewLine);

        }
        private void button_Click(object sender, RoutedEventArgs e)
        {
            dynamic res = new ExpandoObject();
            res.Имя = "Тест ExpandoObject";
            res.Число = 456;
            res.ВСтроку = (Func<string>)(() => res.Имя);
            res.Сумма = (Func<int,int,int>)((x,y) => x+y);

            textBox.Clear();
            textBox.AppendText("ВСтроку="+DynamicInvoker.InvokeMember(res, "ВСтроку").ToString()+Environment.NewLine);
            textBox.AppendText("Сумма=" + DynamicInvoker.InvokeMember(res, "Сумма", 1, 2).ToString() + Environment.NewLine);

            ВывестиСвойство(res, "Имя");
            ВывестиСвойство(res, "Число");

            DynamicInvoker.SetValue(res, "Имя","Новое Имя");
            DynamicInvoker.SetValue(res, "Число","768");

            ВывестиСвойство(res, "Имя");
            ВывестиСвойство(res, "Число");

        }

// public T ДженерикМетод<V, T>(V param1, T param2, V param3) 
Сообщить(Тест.ДженерикМетод(1,"Привет",3));
//


//public V ДженерикМетод2<K, V>(Dictionary<K, V> param1, K param2, V param3)

Словарь= ъНовый("System.Collections.Generic.Dictionary`2[System.Int32,System.String]");
Сообщить(Тест.ДженерикМетод2(Словарь.ПолучитьСсылку(),3,"Привет2"));

// public K ДженерикМетод3<K>(IList<K> param1, int param2, K param3)

List=ъНовый("System.Collections.Generic.List`1[System.String]");
Сообщить(Тест.ДженерикМетод3(List.ПолучитьСсылку(),3,"Привет3"));

public class Тестовый 
    { 
      public Action<string, string, string>   ВнешнееСобытие1С;

// И сделаем эмуляцию события.



public async void TestВнешнегоСобытия() 
        { 
            for(int i=0;i<100; i++)
            {
                var значение = i.ToString();
                Task.Run(async() =>
                {
                   await Task.Delay(1000).ConfigureAwait(false);
                   this?.ВнешнееСобытие1С("Тестовый", "ТестовоеСообщение", значение);
                });

                await Task.Delay(50).ConfigureAwait(false);
            }


        }

Процедура ВнешнееСобытие(Источник, Событие, Данные)
    // Вставить содержимое обработчика.

    
    Сообщить("Источник="+Источник);
    Сообщить("Событие="+Событие);
    Сообщить("Данные="+Данные);
КонецПроцедуры

Процедура ТестВнешнегоСобытияНажатие(Элемент)
    // Вставить содержимое обработчика.

    Тестовый=ъТип("TestDllForCoreClr.Тестовый, TestDllForCoreClr, Version=1.0.0.0, Culture=neutral, PublicKeyToken=null");

Тест=ъ(Врап.Новый(Тестовый.ПолучитьСсылку()," Свойство из Конструктора")); 

Делегат=Ъ(Врап.ПолучитьДелегатВнешнегоСобытия1C());
Тест.ВнешнееСобытие1С=Делегат.ПолучитьСсылку();
Тест.TestВнешнегоСобытия();
КонецПроцедуры

Перем   Тест;

//public static int OptionalParam(int x, int y, int z = 5, int s = 4,string str="Привет")
    //       {
    //           return x + y + z + s;
    //       }

Сообщить("OptionalParam(int x, int y)="+Тестовый.OptionalParam(1,2));
    Сообщить("OptionalParam(int x, int y, int z = 5)="+Тестовый.OptionalParam(1,2,3));
    Сообщить("OptionalParam(int x, int y, int z = 5, int s,string str)="+Тестовый.OptionalParam(1,2,3,4,"ХаХа"));

 public struct ЭлементХранилища
    {
        internal AutoWrap Объект;
        internal int Next;


        internal ЭлементХранилища(AutoWrap Объект)
        {

            this.Объект = Объект;
            Next = -1;
        }

        internal ЭлементХранилища(AutoWrap Объект, int next)
        {

            this.Объект = Объект;
            Next = next;
        }
    }

    internal class ХранилищеОбъектов
    {
        const int НачальноеКоличествоЭлементов = 2;
        ЭлементХранилища[] Элементы = new ЭлементХранилища[НачальноеКоличествоЭлементов];
        int КоличествоЭлементов = 0;
        int РазмерМассива = НачальноеКоличествоЭлементов;
        int FirstDeleted = -1;
        static SpinLock sl = new SpinLock();
        public int Add(AutoWrap Объект)
        {



            var элемент = new ЭлементХранилища(Объект);

            var gotLock = false;
            try
            {
                sl.Enter(ref gotLock);


                if (FirstDeleted == -1)
                {
                    
                    return AddInArray(элемент);
                }
                else
                {
                    int newPos = FirstDeleted;
                    FirstDeleted = Элементы[newPos].Next;
                    Элементы[newPos] = элемент;
                    return newPos;

                }
            }
            finally
            {
                 if (gotLock) sl.Exit();
            }

        }

        int AddInArray(ЭлементХранилища Элемент)
        {

               if (КоличествоЭлементов == РазмерМассива)
                {
                    var temp = new ЭлементХранилища[РазмерМассива * 2];
                    Array.Copy(Элементы, 0, temp, 0, Элементы.Length);
                    Элементы = temp;
                    РазмерМассива = Элементы.Length;

                }

                Элементы[КоличествоЭлементов] = Элемент;
                var res = КоличествоЭлементов;
                КоличествоЭлементов++;
                return res;
                   
        }
        public void RemoveKey(int Pos)
        {
            var элементы = Элементы;
            // Первый элемнт никогда не удаляем.
            if (Pos > 0 && Pos < элементы.Length && элементы[Pos].Объект != null)
            {
                var gotLock = false;
                try
                {
                    sl.Enter(ref gotLock);

                    var Элемент = new ЭлементХранилища(null, FirstDeleted);
                    Элементы[Pos] = Элемент;

                    FirstDeleted = Pos;
                }

                finally
                {
                   if (gotLock) sl.Exit();
                }
            }



        }

        public AutoWrap GetValue(int Pos)
        {
        
          // По идее для получения элемента не нужно никаких блокировок
          // Получает текущий массив элеменов
            var элементы = Элементы;
            if (!(Pos > -1 && Pos < элементы.Length && элементы[Pos].Объект != null))
                return null;

            return элементы[Pos].Объект;

        }

    }

if (КоличествоЭлементов == РазмерМассива)
                {
                    var temp = new ЭлементХранилища[РазмерМассива * 2];
                    Array.Copy(Элементы, 0, temp, 0, Элементы.Length);
                    Элементы = temp;
                    РазмерМассива = Элементы.Length;

                }

public AutoWrap GetValue(int Pos)
        {
        
          // По идее для получения элемента не нужно никаких блокировок
          // Получает текущий массив элементов
            var элементы = Элементы;
            if (!(Pos > -1 && Pos < элементы.Length && элементы[Pos].Объект != null))
                return null;

            return элементы[Pos].Объект;

        }

Interlocked.CompareExchange(ref Элементы, temp, Элементы);

Interlocked.CompareExchange(ref Элементы, null, null);

int РазмерМассива => Элементы.Length;

V>Interlocked.CompareExchange(ref Элементы, temp, Элементы);
V>

V>Interlocked.CompareExchange(ref Элементы, null, null);
V>

V>int РазмерМассива => Элементы.Length;
V>

 var элементы = Элементы;

var элементы = Interlocked.CompareExchange(ref Элементы, null, null);

Необработанное исключение по адресу 0x00007FFD76FB8528 (ucrtbase.dll) в 1cv8.exe: Недопустимый параметр был передан функции, для которой недопустимые параметры вызывают неустранимую ошибку.

Библиотека времени выполнения C (CRT)
Общие изменения
•Двоичные файлы, полученные в результате рефакторинга

Был осуществлен рефакторинг библиотеки CRT, в результате чего она была разделена на два разных двоичных файла — универсальный CRT (ucrtbase), который содержит большинство стандартных функциональных возможностей, и библиотеку времени выполнения VC (vcruntime140), которая содержит функции, связанные с компилятором, такие как обработка исключений и встроенные функции. В случае использования параметров проекта по умолчанию это изменение вас не затронет, так как компоновщик будет автоматически использовать новые библиотеки по умолчанию. Если вы установили для свойства Игнорировать все стандартные библиотекикомпоновщика в проекте значение Да или используете параметр компоновщика /NODEFAULTLIB в командной строке, необходимо обновить список библиотек (в свойстве Дополнительные зависимости), чтобы включить в него новые подвергнутые рефакторингу библиотеки. Замените старую библиотеку CRT (libcmt.lib, libcmtd.lib, msvcrt.lib, msvcrtd.lib) эквивалентными подвергнутыми рефакторингу библиотеками. Для каждой из двух подвергнутых рефакторингу библиотек существует статическая (.lib) и динамическая (.dll) версии, а также версия выпуска (без суффикса) и отладочная версия (с суффиксом "d"). Динамические версии имеют библиотеку импорта, с которой выполняется связь. Рефакторингу подвергнуты две библиотеки: универсальная CRT (а именно ucrtbase.dll или ucrtbase.lib, ucrtbased.dll или ucrtbased.lib) и библиотека времени выполнения VC — libvcruntime.lib, libvcruntime.dll, libvcruntimed.lib и libvcruntimed.dll. См. раздел Особенности библиотеки CRT.

ucrtbase.dll!_invoke_watson() Нет данных
ucrtbase.dll!_invalid_parameter() Нет данных
ucrtbase.dll!_invalid_parameter_noinfo() Нет данных
ucrtbase.dll!_setmode() Нет данных
clrjit.dll!jitStartup() Нет данных
coreclr.dll!EEJitManager::SetCpuInfo(void) Нет данных
coreclr.dll!EEJitManager::LoadJIT(void) Нет данных
coreclr.dll!UnsafeJitFunction(class MethodDesc *,class COR_ILMETHOD_DECODER *,unsigned long,unsigned long,unsigned long *) Нет данных
coreclr.dll!MethodDesc::MakeJitWorker(class COR_ILMETHOD_DECODER *,unsigned long,unsigned long) Нет данных
coreclr.dll!MethodDesc::DoPrestub(class MethodTable *) Нет данных
coreclr.dll!PreStubWorker() Нет данных
coreclr.dll!ThePreStub() Нет данных
coreclr.dll!UMThunkStub() Нет данных
> AddInNetObjectToNative64.dll!NetObjectToNative::ManagedDomainLoader::CreateManagedDomain(NetObjectToNative::CoreClrStartParams * pCoreClrStartupParams)Строка 128 C++

In Jitstartup, JIT creates a file descriptor for stdout and unconditionally passes it to setmode, without checking for failures. This happens at https://github.com/dotnet/coreclr/blob/ee680783778ed0abb186ae41a8c861d5cdcadccd/src/jit/ee_il_dll.cpp#L76.

Failure to check for invalid descriptors can result in setmode triggering failfast.

In Jitstartup, JIT creates a file descriptor for stdout and unconditionally passes it to setmode, without checking for failures. This happens at https://github.com/dotnet/coreclr/blob/ee680783778ed0abb186ae41a8c861d5cdcadccd/src/jit/ee_il_dll.cpp#L76.

Failure to check for invalid descriptors can result in setmode triggering failfast.