Example #1
0
        public void SetMemberValue(CodeGenerator generator, ArgBuilder targetObject, string memberName, LocalBuilder memberValue)
        {
            generator.Ldarg(targetObject);
            generator.Load(memberName);
            generator.Ldloc(memberValue);

            // Type originalType = memberValue.LocalType.IsEnum ? typeof(int) : memberValue.LocalType;
            if (memberValue.LocalType.IsValueType)
            {
                generator.Box(memberValue.LocalType.IsEnum ? typeof(int) : memberValue.LocalType);
            }
            //���ֵΪ�գ����ܵ���ToString
            generator.Load(null);
            generator.If(Cmp.NotEqualTo);
            generator.Ldloc(memberValue);

            // Type originalType = memberValue.LocalType.IsEnum ? typeof(int) : memberValue.LocalType;
            if (memberValue.LocalType.IsValueType)
            {
                generator.Box(memberValue.LocalType.IsEnum ? typeof(int) : memberValue.LocalType);
            }
            generator.Call(typeof(object).GetMethod("ToString", Type.EmptyTypes));
            generator.Else();
            generator.LoadDefaultValue(memberValue.LocalType);
            if (memberValue.LocalType.IsValueType)
            {
                generator.Box(memberValue.LocalType.IsEnum ? typeof(int) : memberValue.LocalType);
            }
            generator.EndIf();
            generator.Call(typeof(NameValueCollection).GetMethod("Add", new Type[] { typeof(string), typeof(string) }));
        }
Example #2
0
        public void EndSetMembers(CodeGenerator generator, ArgBuilder targetObject)
        {
            generator.Ldarg(targetObject);
            generator.Load(null);
            generator.If(Cmp.EqualTo);
            generator.Pop();
            LocalBuilder dataRow = generator.DeclareLocal(typeof(DataRow));
            generator.Ldloc(locDataTable);
            generator.Call(typeof(DataTable).GetMethod("NewRow"));
            generator.Stloc(dataRow);

            LocalBuilder locCurrent = generator.DeclareLocal(typeof(string));
            LocalBuilder locEnumerator = generator.DeclareLocal(typeof(Dictionary<string, object>.KeyCollection.Enumerator));

            generator.Ldloc(locMemberValues);
            generator.Call(typeof(Dictionary<string, object>).GetMethod("get_Keys"));
            generator.Call(typeof(Dictionary<string, object>.KeyCollection).GetMethod("GetEnumerator"));
            generator.Stloc(locEnumerator);
            MethodInfo getCurrentMethod = typeof(Dictionary<string, object>.KeyCollection.Enumerator).GetMethod("get_Current");
            MethodInfo moveNextMethod = typeof(Dictionary<string, object>.KeyCollection.Enumerator).GetMethod("MoveNext");
            generator.ForEach(locCurrent, typeof(string), typeof(Dictionary<string, object>.KeyCollection.Enumerator), locEnumerator, getCurrentMethod);

            generator.Ldloc(dataRow);
            generator.Ldloc(locCurrent);

            generator.Ldloc(locMemberValues);
            generator.Ldloc(locCurrent);
            generator.Call(typeof(Dictionary<string, object>).GetMethod("get_Item"));

            generator.Call(typeof(DataRow).GetMethod("set_Item", new Type[] { typeof(string), typeof(object) }));
            generator.EndForEach(moveNextMethod);
            generator.Ldloc(dataRow);
            generator.EndIf();
        }
Example #3
0
        public void GetMemberValue(CodeGenerator generator, ArgBuilder targetObject, string memberName, ref LocalBuilder memberValue)
        {
            LocalBuilder locValue = generator.DeclareLocal(typeof(string));
            Type targetType = memberValue.LocalType;
            Type originalType = ConvertorGeneratorHelper.GetOriginalType(targetType);

            generator.Ldarg(targetObject);
            generator.Load(memberName);
            generator.Call(typeof(NameValueCollection).GetMethod("get_Item", new Type[] { typeof(string) }));
            generator.Stloc(locValue);

            if (targetType.IsAssignableFrom(typeof(string)))
            {
                generator.Ldloc(locValue);
                generator.Stloc(memberValue);
                return;
            }
            else
            {
                generator.Ldloc(locValue);
                generator.Call(typeof(string).GetMethod("IsNullOrEmpty"));
                generator.Load(true);
                generator.If(Cmp.NotEqualTo);
                if (targetType == typeof(Guid))
                {
                    generator.Ldloc(locValue);
                    generator.New(typeof(Guid).GetConstructor(new Type[] { typeof(string) }));
                    generator.Stloc(memberValue);
                }
                else
                {
                    MethodInfo parseMethod = targetType.GetMethod("Parse", new Type[] { typeof(string) });
                    if (parseMethod != null)
                    {
                        generator.Ldloc(locValue);
                        generator.Call(parseMethod);
                        generator.Stloc(memberValue);
                    }
                    else
                    {
                        generator.Ldloc(locValue);
                        generator.Load(originalType);
                        generator.Call(typeof(Convert).GetMethod("ChangeType", new Type[] { typeof(object), typeof(Type) }));
                        if (targetType.IsValueType)
                        {
                            generator.UnboxAny(targetType);
                        }
                        generator.Stloc(memberValue);
                    }
                }
                generator.Else();
                generator.LoadDefaultValue(targetType);
                generator.Stloc(memberValue);
                generator.EndIf();
            }
        }
Example #4
0
 public void SetMemberValue(CodeGenerator generator, ArgBuilder targetObject, string memberName, LocalBuilder memberValue)
 {
     generator.Ldarg(targetObject);
     generator.Load(memberName);
     generator.Ldloc(memberValue);
     if (memberValue.LocalType.IsValueType)
     {
         generator.Box(memberValue.LocalType.IsEnum ? typeof(int) : memberValue.LocalType);
     }
     generator.Call(typeof(IDictionary).GetMethod("Add"));
 }
Example #5
0
        public void SetMemberValue(CodeGenerator generator, ArgBuilder targetObject, string memberName, LocalBuilder memberValue)
        {
            generator.Ldarg(targetObject);
            if (memberValue.LocalType.FullName.StartsWith("System.Nullable`1["))
            {
                generator.Ldloc(memberValue);
                generator.Load(null);
                generator.If(Cmp.EqualTo);
                generator.LoadMember(typeof(DBNull).GetField("Value"));
                generator.Stloc(memberValue);
                generator.EndIf();
            }
            generator.Load(null);

            generator.If(Cmp.EqualTo);
            PropertyInfo columns = typeof(DataTable).GetProperty("Columns");
            generator.Ldloc(locDataTable);
            generator.LoadMember(columns);
            generator.Load(memberName);
            generator.Ldtoken(CommonUtils.GetOriginalTypeOfNullableType(memberValue.LocalType.IsEnum ? typeof(int) : memberValue.LocalType));
            generator.Call(typeof(Type).GetMethod("GetTypeFromHandle", new Type[] { typeof(RuntimeTypeHandle) }));
            generator.Call(typeof(DataColumnCollection).GetMethod("Add", new Type[] { typeof(string), typeof(Type) }));
            generator.Pop();

            generator.Ldloc(locMemberValues);
            generator.Load(memberName);
            generator.Ldloc(memberValue);
            if (memberValue.LocalType.IsValueType)
            {
                generator.Box(memberValue.LocalType.IsEnum ? typeof(int) : memberValue.LocalType);
            }
            generator.Call(typeof(Dictionary<string, object>).GetMethod("Add"));
            generator.Else();
            generator.Ldarg(targetObject);
            generator.Load(memberName);
            generator.Ldloc(memberValue);
            if (memberValue.LocalType.IsValueType)
            {
                generator.Box(memberValue.LocalType);
            }
            generator.Call(typeof(DataRow).GetMethod("set_Item", new Type[] { typeof(string), typeof(object) }));
            generator.EndIf();
        }
Example #6
0
        public void GetMemberValue(CodeGenerator generator, ArgBuilder targetObject, string memberName, ref LocalBuilder memberValue)
        {
            Type inputType = targetObject.ArgType;
            MemberInfo memberInfo = ConvertorGeneratorHelper.GetMemberInfo(inputType, memberName);
            if (memberInfo == null)
            {
                return;
            }
            Type srcMemberType = ConvertorGeneratorHelper.GetMemberType(memberInfo);
            Type destMemberType = memberValue.LocalType;
            if (memberValue.LocalType.IsAssignableFrom(srcMemberType))
            {
                generator.Ldarg(targetObject);
                generator.LoadMember(memberInfo);
                generator.Stloc(memberValue);
                return;
            }

            Type converTargetType = ConvertorGeneratorHelper.GetOriginalType(destMemberType);

            Type convertSourceType = ConvertorGeneratorHelper.GetOriginalType(srcMemberType);

            //ת������
            if (typeof(IConvertible).IsAssignableFrom(convertSourceType))
            {
                generator.Ldarg(targetObject);
                generator.LoadMember(memberInfo);
                if (convertSourceType.IsValueType)
                {
                    generator.Box(srcMemberType);
                }
                //�Ƿ�Ϊ��
                generator.Load(null);
                generator.If(Cmp.NotEqualTo);
                //�����Ϊ�գ���������ת��
                generator.Ldarg(targetObject);
                generator.LoadMember(memberInfo);
                if (convertSourceType.IsValueType)
                {
                    generator.Box(srcMemberType);
                }
                generator.Load(converTargetType);
                generator.Call(typeof(Convert).GetMethod("ChangeType", new Type[] { typeof(object), typeof(Type) }));
                if (destMemberType.IsValueType)
                {
                    generator.UnboxAny(destMemberType);
                }
                generator.Stloc(memberValue);
                //���Ϊ�գ������Ĭ��ֵ
                generator.Else();
                generator.LoadDefaultValue(destMemberType);
                generator.Stloc(memberValue);
                generator.EndIf();
            }
        }
Example #7
0
        public override ConvertHandler GetConvertHandler(Type inputType, Type outputType, object inputObject, object outputObject, Dictionary<string, string> mappingNames, List<string> ignoreList, Dictionary<int, string> mappingOrders, bool mappingSpecifiedOnly)
        {
            Dictionary<string, string> distToSrc = new Dictionary<string, string>();
            Dictionary<string, MemberInfo> members = new Dictionary<string, MemberInfo>();
            foreach (string sourceName in mappingNames.Keys)
            {
                MemberInfo sourceMember = ConvertorGeneratorHelper.GetMemberInfo(inputType, sourceName);
                Check.Require(sourceMember != null, string.Format("member named {0} could not be found in {1}", sourceName, outputType.FullName));
                distToSrc.Add(mappingNames[sourceName], sourceName);
                members.Add(mappingNames[sourceName], sourceMember);
            }
            if (!mappingSpecifiedOnly)
            {
                Dictionary<string, MemberInfo> sourceMembers = ConvertorGeneratorHelper.GetMembers(inputType);
                foreach (string sourceName in sourceMembers.Keys)
                {
                    if (!ignoreList.Contains(sourceName) && !distToSrc.ContainsKey(sourceName))
                    {
                        distToSrc.Add(sourceName, sourceName);
                        members.Add(sourceName, sourceMembers[sourceName]);
                    }
                }
            }

            CodeGenerator gen = new CodeGenerator();
            gen.BeginMethod("m" + Guid.NewGuid().ToString("N"), typeof(ConvertHandler));

            ArgBuilder inputObjectArg = new ArgBuilder(0, inputType);
            ArgBuilder outputObjectArg = new ArgBuilder(1, outputType);

            int currentCount = 0;
            int memberCount = members.Count;
            string[] keys = new string[memberCount];
            distToSrc.Keys.CopyTo(keys, 0);
            List<string> keyList = new List<string>(keys);
            MemberSetterGenerator.BeginSetMembers(gen, outputObjectArg);
            while (currentCount < memberCount)
            {
                currentCount++;
                string targetName = ConvertorGeneratorHelper.GetCurrentKey(mappingOrders, currentCount, keyList).Replace("_", "");
                if (string.IsNullOrEmpty(targetName))
                {
                    continue;
                }
                string sourceName = distToSrc[targetName].Replace("_","");
                if (MemberGetterGenerator.ContainsMember(sourceName, inputType, inputObject) && MemberSetterGenerator.ContainsMember(targetName, outputType, outputObject))
                {
                    Type targetType = ConvertorGeneratorHelper.GetMemberType(members[targetName]);

                    LocalBuilder memberValue = gen.DeclareLocal(targetType, "memberValue");

                    MemberGetterGenerator.GetMemberValue(gen, inputObjectArg, sourceName, ref memberValue);

                    MemberSetterGenerator.SetMemberValue(gen, outputObjectArg, targetName, memberValue);
                }
            }
            gen.Ldarg(outputObjectArg);
            MemberSetterGenerator.EndSetMembers(gen, outputObjectArg);
            return (ConvertHandler)gen.EndMethod();
        }
Example #8
0
        public void GetMemberValue(CodeGenerator generator, ArgBuilder targetObject, string memberName, ref LocalBuilder memberValue)
        {
            LocalBuilder tempLocal = generator.DeclareLocal(typeof(object), "dataColumn");
            Type targetType = memberValue.LocalType;
            Type originalType = ConvertorGeneratorHelper.GetOriginalType(targetType);

            generator.Ldarg(targetObject);
            generator.Load(memberName);
            generator.Call(typeof(DataRow).GetMethod("get_Item", new Type[] { typeof(string) }));
            generator.Stloc(tempLocal);

            generator.Ldloc(tempLocal);
            generator.LoadMember(typeof(DBNull).GetField("Value", BindingFlags.Static | BindingFlags.Public));
            generator.If(Cmp.EqualTo);
            generator.LoadDefaultValue(targetType);
            generator.Stloc(memberValue);
            generator.Else();
            generator.Ldloc(tempLocal);

            generator.InternalILGenerator.Emit(OpCodes.Isinst, targetType);
            generator.InternalILGenerator.Emit(OpCodes.Ldnull);
            generator.InternalILGenerator.Emit(OpCodes.Cgt_Un);
            generator.Load(true);
            generator.If(Cmp.EqualTo);
            generator.Ldloc(tempLocal);
            if (targetType.IsValueType)
            {
                generator.UnboxAny(targetType);
            }
            generator.Stloc(memberValue);
            generator.Else();
            if (targetType == typeof(Guid))
            {
                generator.Ldloc(tempLocal);
                generator.InternalILGenerator.Emit(OpCodes.Isinst, typeof(string));
                generator.InternalILGenerator.Emit(OpCodes.Ldnull);
                generator.InternalILGenerator.Emit(OpCodes.Cgt_Un);
                generator.Load(true);
                generator.If(Cmp.EqualTo);
                generator.Ldloc(tempLocal);
                generator.New(typeof(Guid).GetConstructor(new Type[] { typeof(string) }));
                generator.Stloc(memberValue);
            }
            else
            {
                generator.Ldloc(tempLocal);
                generator.InternalILGenerator.Emit(OpCodes.Isinst, typeof(IConvertible));
                generator.InternalILGenerator.Emit(OpCodes.Ldnull);
                generator.InternalILGenerator.Emit(OpCodes.Cgt_Un);
                generator.Load(true);
                generator.If(Cmp.EqualTo);
                generator.Ldloc(tempLocal);
                generator.Load(originalType);
                generator.Call(typeof(Convert).GetMethod("ChangeType", new Type[] { typeof(object), typeof(Type) }));
                if (targetType.IsValueType)
                {
                    generator.UnboxAny(targetType);
                }
                generator.Stloc(memberValue);
            }
            generator.Else();
            generator.LoadDefaultValue(targetType);
            generator.Stloc(memberValue);
            generator.EndIf();
            generator.EndIf();
            generator.EndIf();
        }
Example #9
0
        public void GetMemberValue(CodeGenerator generator, ArgBuilder targetObject, string memberName, ref LocalBuilder memberValue)
        {
            MethodInfo getMethod;
            bool mustBeUnBox = false;

            switch (Type.GetTypeCode(memberValue.LocalType))
            {
                case TypeCode.Boolean:
                    getMethod = typeof(IDataRecord).GetMethod("GetBoolean");
                    break;
                case TypeCode.Byte:
                    getMethod = typeof(IDataRecord).GetMethod("GetByte");
                    break;
                case TypeCode.Char:
                    getMethod = typeof(IDataRecord).GetMethod("GetChar");
                    break;
                case TypeCode.DateTime:
                    getMethod = typeof(IDataRecord).GetMethod("GetDateTime");
                    break;
                case TypeCode.Decimal:
                    getMethod = typeof(IDataRecord).GetMethod("GetDecimal");
                    break;
                //Teddy 2008-2-2: commented the lines below, because for some database, return data type of float or real could always be System.Single or System.Double
                //case TypeCode.Double:
                //    getMethod = typeof(IDataRecord).GetMethod("GetDouble");
                //    break;
                //case TypeCode.Single:
                //    getMethod = typeof(IDataRecord).GetMethod("GetFloat");
                //    break;
                case TypeCode.Int16:
                    getMethod = typeof(IDataRecord).GetMethod("GetInt16");
                    break;
                case TypeCode.Int32:
                    getMethod = typeof(IDataRecord).GetMethod("GetInt32");
                    break;
                case TypeCode.Int64:
                    getMethod = typeof(IDataRecord).GetMethod("GetInt64");
                    break;
                case TypeCode.String:
                    getMethod = typeof(IDataRecord).GetMethod("GetString");
                    break;
                default:
                    getMethod = typeof(IDataRecord).GetMethod("GetValue");
                    mustBeUnBox = true;
                    break;
            }
            if (memberValue.LocalType == typeof(Guid))
            {
                getMethod = typeof(IDataRecord).GetMethod("GetGuid");
                mustBeUnBox = false;
            }
            if (memberValue.LocalType.IsEnum)
            {
                getMethod = typeof(IDataRecord).GetMethod("GetValue");
                mustBeUnBox = true;
            }

            generator.Ldarg(targetObject);
            generator.Load(memberName);
            generator.Call(typeof(IDataRecord).GetMethod("GetOrdinal"));
            LocalBuilder fieldOrdinalLoc = generator.DeclareLocal(typeof(int));
            generator.Stloc(fieldOrdinalLoc);
            generator.Ldarg(targetObject);
            generator.Ldloc(fieldOrdinalLoc);
            generator.Call(typeof(IDataRecord).GetMethod("IsDBNull"));
            generator.IfNot();
            generator.Ldarg(targetObject);
            generator.Ldloc(fieldOrdinalLoc);
            generator.Call(getMethod);

            //Teddy 2008-2-2: added the  code section below to convert the object to the memberValue.LocalType
            if (!memberValue.LocalType.IsEnum && getMethod == typeof(IDataRecord).GetMethod("GetValue"))
            {
                generator.Load(Type.GetTypeCode(memberValue.LocalType));
                generator.Call(typeof(Convert).GetMethod("ChangeType", BindingFlags.Instance | BindingFlags.Public | BindingFlags.Static, null, new Type[] { typeof(object), typeof(TypeCode) }, null));
            }

            if (memberValue.LocalType.IsValueType && mustBeUnBox)
            {
                generator.UnboxAny(memberValue.LocalType);
            }
            generator.Else();
            generator.LoadDefaultValue(memberValue.LocalType);
            generator.EndIf();
            generator.Stloc(memberValue);
        }
Example #10
0
        private static void LoadParameters(CodeGenerator gen, ParameterInfo[] pis, bool isMethodStatic)
        {
            Check.Require(gen, "gen");

            if (pis != null)
            {
                for (int i = 0; i < pis.Length; ++i)
                {
                    if (isMethodStatic)
                    {
                        gen.Ldarg(0);
                    }
                    else
                    {
                        gen.Ldarg(1);
                    }
                    gen.Ldc(i);

                    Type srcType = pis[i].ParameterType;
                    string str = srcType.ToString();
                    if (str.EndsWith("&"))
                    {
                        srcType = CommonUtils.GetType(str.Substring(0, str.Length - 1));
                    }

                    if (str.EndsWith("&")) //ref or out param
                    {
                        if (srcType.IsValueType && (pis[i].Attributes & ParameterAttributes.Out) != ParameterAttributes.Out) //ref value param
                        {
                            gen.Ldelem(typeof(object));
                            gen.Unbox(srcType);
                        }
                        else
                        {
                            if (srcType.IsValueType && srcType != typeof(object)) //out value param
                            {
                                gen.LoadDefaultValue(srcType);
                                gen.Box(srcType);
                                gen.Stelem(typeof(object));

                                if (isMethodStatic)
                                {
                                    gen.Ldarg(0);
                                }
                                else
                                {
                                    gen.Ldarg(1);
                                }
                                gen.Ldc(i);
                                gen.Ldelem(typeof(object));
                                gen.Unbox(srcType);
                            }
                            else //ref or out class param
                            {
                                gen.Ldelema(typeof(object));
                            }
                        }
                    }
                    else
                    {
                        gen.Ldelem(typeof(object));

                        if (srcType.IsValueType)
                        {
                            gen.UnboxAny(srcType);
                        }
                        else if (srcType != typeof(object))
                        {
                            gen.Castclass(srcType);
                        }
                    }
                }
            }
        }
Example #11
0
        /// <summary>
        /// Do Get Static Field Set Delegate
        /// </summary>
        /// <param name="targetModule"></param>
        /// <param name="fieldInfo"></param>
        /// <returns></returns>
        protected static StaticDynamicMethodProxyHandler DoGetStaticFieldSetDelegate(
            Module targetModule,
            FieldInfo fieldInfo
            )
        {
            Check.Require(targetModule, "targetModule");
            Check.Require(fieldInfo, "fieldInfo");
            Check.Require(fieldInfo.IsStatic, "fieldInfo MUST be static here.");

            CodeGenerator gen = new CodeGenerator(targetModule);
            gen.BeginMethod("dm" + Guid.NewGuid().ToString("N"), typeof(StaticDynamicMethodProxyHandler));
            gen.Ldarg(0);
            gen.Ldc(0);
            gen.Ldelem(typeof(object));
            if (fieldInfo.FieldType.IsValueType)
                gen.UnboxAny(fieldInfo.FieldType);
            gen.StoreMember(fieldInfo);
            gen.Load(null);

            return (StaticDynamicMethodProxyHandler)gen.EndMethod();
        }
Example #12
0
        /// <summary>
        /// Do GetMethodDelegate
        /// </summary>
        /// <param name="targetModule"></param>
        /// <param name="genericMethodInfo"></param>
        /// <param name="genericParameterTypes"></param>
        /// <returns></returns>
        protected static DynamicMethodProxyHandler DoGetMethodDelegate(
            Module targetModule,
            MethodInfo genericMethodInfo,
            params Type[] genericParameterTypes)
        {
            #region Check preconditions

            Check.Require(targetModule, "targetModule");
            Check.Require(genericMethodInfo, "genericMethodInfo");
            Check.Require((genericParameterTypes == null && genericMethodInfo.GetGenericArguments().Length == 0) ||
                genericParameterTypes.Length == genericMethodInfo.GetGenericArguments().Length,
                "The number of generic type parameter of genericMethodInfo and the input types must equal!");
            Check.Require(!genericMethodInfo.IsStatic, "genericMethodInfo must not be static here!");

            #endregion

            //Create a dynamic method proxy delegate used to call the specified methodinfo
            CodeGenerator gen = new CodeGenerator(targetModule);
            gen.BeginMethod("dm" + Guid.NewGuid().ToString("N"), typeof(DynamicMethodProxyHandler));
            MethodInfo makeGenericMethodInfo = MakeMethodGeneric(genericMethodInfo, genericParameterTypes);
            gen.Ldarg(0);
            LoadParameters(gen, makeGenericMethodInfo.GetParameters(), false);
            gen.Call(makeGenericMethodInfo);
            CastValueToObject(gen, makeGenericMethodInfo.ReturnType);

            return (DynamicMethodProxyHandler)gen.EndMethod();
        }
Example #13
0
        /// <summary>
        /// Do Get Field Get Delegate
        /// </summary>
        /// <param name="targetModule"></param>
        /// <param name="fieldInfo"></param>
        /// <returns></returns>
        protected static DynamicMethodProxyHandler DoGetFieldGetDelegate(
            Module targetModule,
            FieldInfo fieldInfo
            )
        {
            Check.Require(targetModule, "targetModule");
            Check.Require(fieldInfo, "fieldInfo");
            Check.Require(!fieldInfo.IsStatic, "fieldInfo could not be static.");

            CodeGenerator gen = new CodeGenerator(targetModule);
            gen.BeginMethod("dm" + Guid.NewGuid().ToString("N"), typeof(DynamicMethodProxyHandler));
            gen.Ldarg(0);
            gen.LoadMember(fieldInfo);
            CastValueToObject(gen, fieldInfo.FieldType);

            return (DynamicMethodProxyHandler)gen.EndMethod();
        }
Example #14
0
 public void SetMemberValue(CodeGenerator generator, ArgBuilder targetObject, string memberName, LocalBuilder memberValue)
 {
     MemberInfo memberInfo = ConvertorGeneratorHelper.GetMemberInfo(targetObject.ArgType, memberName);
     if (memberInfo != null)
     {
         generator.Ldarg(targetObject);
         generator.Ldloc(memberValue);
         generator.StoreMember(memberInfo);
     }
 }