C# CodeGenerator.EndMethod方法代码示例

 internal JsonFormatClassWriterDelegate GenerateClassWriter(ClassDataContract classContract)
 {
     _ilg = new CodeGenerator();
     bool memberAccessFlag = classContract.RequiresMemberAccessForWrite(null, JsonGlobals.JsonSerializationPatterns);
     try
     {
         BeginMethod(_ilg, "Write" + DataContract.SanitizeTypeName(classContract.StableName.Name) + "ToJson", typeof(JsonFormatClassWriterDelegate), memberAccessFlag);
     }
     catch (SecurityException securityException)
     {
         if (memberAccessFlag)
         {
             classContract.RequiresMemberAccessForWrite(securityException, JsonGlobals.JsonSerializationPatterns);
         }
         else
         {
             throw;
         }
     }
     InitArgs(classContract.UnderlyingType);
     _memberNamesArg = _ilg.GetArg(4);
     WriteClass(classContract);
     return (JsonFormatClassWriterDelegate)_ilg.EndMethod();
 }

 internal JsonFormatClassWriterDelegate GenerateClassWriter(ClassDataContract classContract)
 {
     ilg = new CodeGenerator();
     bool memberAccessFlag = classContract.RequiresMemberAccessForWrite(null);
     try
     {
         BeginMethod(ilg, "Write" + classContract.StableName.Name + "ToJson", typeof(JsonFormatClassWriterDelegate), memberAccessFlag);
     }
     catch (SecurityException securityException)
     {
         if (memberAccessFlag && securityException.PermissionType.Equals(typeof(ReflectionPermission)))
         {
             classContract.RequiresMemberAccessForWrite(securityException);
         }
         else
         {
             throw;
         }
     }
     InitArgs(classContract.UnderlyingType);
     memberNamesArg = ilg.GetArg(4);
     DemandSerializationFormatterPermission(classContract);
     DemandMemberAccessPermission(memberAccessFlag);
     if (classContract.IsReadOnlyContract)
     {
         ThrowIfCannotSerializeReadOnlyTypes(classContract);
     }
     WriteClass(classContract);
     return (JsonFormatClassWriterDelegate)ilg.EndMethod();
 }

 public JsonFormatGetOnlyCollectionReaderDelegate GenerateGetOnlyCollectionReader(CollectionDataContract collectionContract)
 {
     ilg = GenerateCollectionReaderHelper(collectionContract, true /*isGetOnlyCollection*/);
     ReadGetOnlyCollection(collectionContract);
     return (JsonFormatGetOnlyCollectionReaderDelegate)ilg.EndMethod();
 }

        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();
        }

            public JsonFormatClassReaderDelegate GenerateClassReader(ClassDataContract classContract)
            {
                ilg = new CodeGenerator();
                bool memberAccessFlag = classContract.RequiresMemberAccessForRead(null);
                try
                {
                    BeginMethod(ilg, "Read" + classContract.StableName.Name + "FromJson", typeof(JsonFormatClassReaderDelegate), memberAccessFlag);
                }
                catch (SecurityException securityException)
                {
                    if (memberAccessFlag && securityException.PermissionType.Equals(typeof(ReflectionPermission)))
                    {
                        classContract.RequiresMemberAccessForRead(securityException);
                    }
                    else
                    {
                        throw;
                    }
                }
                InitArgs();
                DemandSerializationFormatterPermission(classContract);
                DemandMemberAccessPermission(memberAccessFlag);
                CreateObject(classContract);
                ilg.Call(contextArg, XmlFormatGeneratorStatics.AddNewObjectMethod, objectLocal);
                InvokeOnDeserializing(classContract);
                if (classContract.IsISerializable)
                    ReadISerializable(classContract);
                else
                    ReadClass(classContract);
                if (Globals.TypeOfIDeserializationCallback.IsAssignableFrom(classContract.UnderlyingType))
                    ilg.Call(objectLocal, JsonFormatGeneratorStatics.OnDeserializationMethod, null);
                InvokeOnDeserialized(classContract);
                if (!InvokeFactoryMethod(classContract))
                {
                    ilg.Load(objectLocal);
                    // Do a conversion back from DateTimeOffsetAdapter to DateTimeOffset after deserialization.
                    // DateTimeOffsetAdapter is used here for deserialization purposes to bypass the ISerializable implementation
                    // on DateTimeOffset; which does not work in partial trust.

                    if (classContract.UnderlyingType == Globals.TypeOfDateTimeOffsetAdapter)
                    {
                        ilg.ConvertValue(objectLocal.LocalType, Globals.TypeOfDateTimeOffsetAdapter);
                        ilg.Call(XmlFormatGeneratorStatics.GetDateTimeOffsetMethod);
                        ilg.ConvertValue(Globals.TypeOfDateTimeOffset, ilg.CurrentMethod.ReturnType);
                    }
                    else
                    {
                        ilg.ConvertValue(objectLocal.LocalType, ilg.CurrentMethod.ReturnType);
                    }
                }
                return (JsonFormatClassReaderDelegate)ilg.EndMethod();
            }

 public JsonFormatCollectionReaderDelegate GenerateCollectionReader(CollectionDataContract collectionContract)
 {
     ilg = GenerateCollectionReaderHelper(collectionContract, false /*isGetOnlyCollection*/);
     ReadCollection(collectionContract);
     ilg.Load(objectLocal);
     ilg.ConvertValue(objectLocal.LocalType, ilg.CurrentMethod.ReturnType);
     return (JsonFormatCollectionReaderDelegate)ilg.EndMethod();
 }

            public JsonFormatClassReaderDelegate GenerateClassReader(ClassDataContract classContract)
            {
                _ilg = new CodeGenerator();
                bool memberAccessFlag = classContract.RequiresMemberAccessForRead(null);
                try
                {
                    BeginMethod(_ilg, "Read" + DataContract.SanitizeTypeName(classContract.StableName.Name) + "FromJson", typeof(JsonFormatClassReaderDelegate), memberAccessFlag);
                }
                catch (SecurityException securityException)
                {
                    if (memberAccessFlag)
                    {
                        classContract.RequiresMemberAccessForRead(securityException);
                    }
                    else
                    {
                        throw;
                    }
                }
                InitArgs();
                CreateObject(classContract);
                _ilg.Call(_contextArg, XmlFormatGeneratorStatics.AddNewObjectMethod, _objectLocal);
                InvokeOnDeserializing(classContract);
                if (classContract.IsISerializable)
                    ReadISerializable(classContract);
                else
                    ReadClass(classContract);

                if (Globals.TypeOfIDeserializationCallback.IsAssignableFrom(classContract.UnderlyingType))
                {
                    _ilg.Call(_objectLocal, JsonFormatGeneratorStatics.OnDeserializationMethod, null);
                }

                InvokeOnDeserialized(classContract);
                if (!InvokeFactoryMethod(classContract))
                {
                    _ilg.Load(_objectLocal);
                    // Do a conversion back from DateTimeOffsetAdapter to DateTimeOffset after deserialization.
                    // DateTimeOffsetAdapter is used here for deserialization purposes to bypass the ISerializable implementation
                    // on DateTimeOffset; which does not work in partial trust.

                    if (classContract.UnderlyingType == Globals.TypeOfDateTimeOffsetAdapter)
                    {
                        _ilg.ConvertValue(_objectLocal.LocalType, Globals.TypeOfDateTimeOffsetAdapter);
                        _ilg.Call(XmlFormatGeneratorStatics.GetDateTimeOffsetMethod);
                        _ilg.ConvertValue(Globals.TypeOfDateTimeOffset, _ilg.CurrentMethod.ReturnType);
                    }
                    //Copy the KeyValuePairAdapter<K,T> to a KeyValuePair<K,T>. 
                    else if (classContract.IsKeyValuePairAdapter)
                    {
                        _ilg.Call(classContract.GetKeyValuePairMethodInfo);
                        _ilg.ConvertValue(Globals.TypeOfKeyValuePair.MakeGenericType(classContract.KeyValuePairGenericArguments), _ilg.CurrentMethod.ReturnType);
                    }
                    else
                    {
                        _ilg.ConvertValue(_objectLocal.LocalType, _ilg.CurrentMethod.ReturnType);
                    }
                }
                return (JsonFormatClassReaderDelegate)_ilg.EndMethod();
            }

 internal JsonFormatCollectionWriterDelegate GenerateCollectionWriter(CollectionDataContract collectionContract)
 {
     _ilg = new CodeGenerator();
     bool memberAccessFlag = collectionContract.RequiresMemberAccessForWrite(null);
     try
     {
         BeginMethod(_ilg, "Write" + DataContract.SanitizeTypeName(collectionContract.StableName.Name) + "ToJson", typeof(JsonFormatCollectionWriterDelegate), memberAccessFlag);
     }
     catch (SecurityException securityException)
     {
         if (memberAccessFlag)
         {
             collectionContract.RequiresMemberAccessForWrite(securityException);
         }
         else
         {
             throw;
         }
     }
     InitArgs(collectionContract.UnderlyingType);
     WriteCollection(collectionContract);
     return (JsonFormatCollectionWriterDelegate)_ilg.EndMethod();
 }

        /// <summary>
        /// Do GetStaticMethodDelegate
        /// </summary>
        /// <param name="targetModule"></param>
        /// <param name="genericMethodInfo"></param>
        /// <param name="genericParameterTypes"></param>
        /// <returns></returns>
        protected static StaticDynamicMethodProxyHandler DoGetStaticMethodDelegate(
            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 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(StaticDynamicMethodProxyHandler));
            MethodInfo makeGenericMethodInfo = MakeMethodGeneric(genericMethodInfo, genericParameterTypes);
            LoadParameters(gen, makeGenericMethodInfo.GetParameters(), true);
            gen.Call(makeGenericMethodInfo);
            CastValueToObject(gen, makeGenericMethodInfo.ReturnType);

            return (StaticDynamicMethodProxyHandler)gen.EndMethod();
        }

        /// <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();
        }

        /// <summary>
        /// Do Get Static Field Get Delegate
        /// </summary>
        /// <param name="targetModule"></param>
        /// <param name="fieldInfo"></param>
        /// <returns></returns>
        protected static StaticDynamicMethodProxyHandler DoGetStaticFieldGetDelegate(
            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.LoadMember(fieldInfo);
            CastValueToObject(gen, fieldInfo.FieldType);

            return (StaticDynamicMethodProxyHandler)gen.EndMethod();
        }