Exemple #1
0
        private MethodGenerator ExplicitlyImplementedInterfaceMethodGenerator(
            MetaMethod method,
            ClassEmitter @class,
            OverrideMethodDelegate overrideMethod
            )
        {
            var @delegate   = GetDelegateType(method, @class);
            var contributor = GetContributor(@delegate, method);
            var invocation  = new InheritanceInvocationTypeGenerator(
                targetType,
                method,
                null,
                contributor
                )
                              .Generate(@class, namingScope)
                              .BuildType();

            return(new MethodWithInvocationGenerator(
                       method,
                       @class.GetField("__interceptors"),
                       invocation,
                       (c, m) => new TypeTokenExpression(targetType),
                       overrideMethod,
                       contributor
                       ));
        }
        protected override MethodGenerator GetMethodGenerator(MetaMethod method, ClassEmitter @class,
                                                              OverrideMethodDelegate overrideMethod)
        {
            if (methodsToSkip.Contains(method.Method))
            {
                return(null);
            }

            if (!method.Proxyable)
            {
                return(new MinimialisticMethodGenerator(method,
                                                        overrideMethod));
            }

            if (ExplicitlyImplementedInterfaceMethod(method))
            {
                return(ExplicitlyImplementedInterfaceMethodGenerator(method, @class, overrideMethod));
            }

            var invocation = GetInvocationType(method, @class);

            GetTargetExpressionDelegate getTargetTypeExpression = (c, m) => new TypeTokenExpression(targetType);

            return(new MethodWithInvocationGenerator(method,
                                                     @class.GetField("__interceptors"),
                                                     invocation,
                                                     getTargetTypeExpression,
                                                     getTargetTypeExpression,
                                                     overrideMethod,
                                                     null));
        }
        protected override void CustomizeGetObjectData(
            CodeBuilder codebuilder,
            ArgumentReference serializationInfo,
            ArgumentReference streamingContext,
            ClassEmitter emitter
            )
        {
            var targetField = emitter.GetField("__target");

            codebuilder.AddStatement(
                new MethodInvocationExpression(
                    serializationInfo,
                    SerializationInfoMethods.AddValue_Object,
                    new LiteralStringExpression("__targetFieldType"),
                    new LiteralStringExpression(
                        targetField.Reference.FieldType.AssemblyQualifiedName
                        )
                    )
                );

            codebuilder.AddStatement(
                new MethodInvocationExpression(
                    serializationInfo,
                    SerializationInfoMethods.AddValue_Object,
                    new LiteralStringExpression("__theInterface"),
                    new LiteralStringExpression(targetType.AssemblyQualifiedName)
                    )
                );
        }
Exemple #4
0
        protected override MethodGenerator GetMethodGenerator(
            MetaMethod method,
            ClassEmitter @class,
            OverrideMethodDelegate overrideMethod
            )
        {
            if (!method.Proxyable)
            {
                return(new ForwardingMethodGenerator(
                           method,
                           overrideMethod,
                           (c, i) => fields[i.DeclaringType]
                           ));
            }

            var invocation = GetInvocationType(method, @class);

            return(new MethodWithInvocationGenerator(
                       method,
                       @class.GetField("__interceptors"),
                       invocation,
                       getTargetExpression,
                       overrideMethod,
                       null
                       ));
        }
Exemple #5
0
        protected override MethodGenerator GetMethodGenerator(MetaMethod method, ClassEmitter @class,
                                                              ProxyGenerationOptions options,
                                                              OverrideMethodDelegate overrideMethod)
        {
            if (methodsToSkip.Contains(method.Method))
            {
                return(null);
            }

            if (!method.Proxyable)
            {
                return(new MinimialisticMethodGenerator(method,
                                                        overrideMethod));
            }

            if (IsDirectlyAccessible(method) == false)
            {
                return(IndirectlyCalledMethodGenerator(method, @class, options, overrideMethod));
            }

            var invocation = GetInvocationType(method, @class, options);

            return(new MethodWithInvocationGenerator(method,
                                                     @class.GetField("__interceptors"),
                                                     invocation,
                                                     (c, m) => c.GetField("__target").ToExpression(),
                                                     overrideMethod,
                                                     null));
        }
Exemple #6
0
        private Expression SetMethodInterceptors(ClassEmitter @class, INamingScope namingScope, MethodEmitter emitter, Expression proxiedMethodTokenExpression)
        {
            var selector = @class.GetField("__selector");

            if (selector == null)
            {
                return(null);
            }


            var methodInterceptorsField = BuildMethodInterceptorsField(@class, MethodToOverride, namingScope);

            var emptyInterceptors  = new NewArrayExpression(0, typeof(IInterceptor));
            var selectInterceptors = new MethodInvocationExpression(selector, InterceptorSelectorMethods.SelectInterceptors,
                                                                    new MethodInvocationExpression(null,
                                                                                                   TypeUtilMethods.GetTypeOrNull,
                                                                                                   getTargetExpression(@class, MethodToOverride)),
                                                                    proxiedMethodTokenExpression, interceptors.ToExpression())
            {
                VirtualCall = true
            };

            emitter.CodeBuilder.AddExpression(
                new IfNullExpression(methodInterceptorsField,
                                     new AssignStatement(methodInterceptorsField,
                                                         new NullCoalescingOperatorExpression(selectInterceptors, emptyInterceptors))));

            return(methodInterceptorsField.ToExpression());
        }
Exemple #7
0
        private MethodGenerator IndirectlyCalledMethodGenerator(
            MetaMethod method,
            ClassEmitter proxy,
            OverrideMethodDelegate overrideMethod,
            bool skipInterceptors = false
            )
        {
            var @delegate   = GetDelegateType(method, proxy);
            var contributor = GetContributor(@delegate, method);
            var invocation  = new CompositionInvocationTypeGenerator(
                targetType,
                method,
                null,
                false,
                contributor
                )
                              .Generate(proxy, namingScope)
                              .BuildType();

            return(new MethodWithInvocationGenerator(
                       method,
                       skipInterceptors ? NullExpression.Instance : proxy.GetField("__interceptors"),
                       invocation,
                       (c, m) => c.GetField("__target"),
                       overrideMethod,
                       contributor
                       ));
        }
        private Expression[] GetCtorArguments(ClassEmitter @class, INamingScope namingScope,
                                              Expression proxiedMethodTokenExpression, TypeReference[] dereferencedArguments)
        {
            var selector = @class.GetField("__selector");

            if (selector != null)
            {
                return(new[]
                {
                    getTargetExpression(@class, MethodToOverride),
                    SelfReference.Self.ToExpression(),
                    interceptors.ToExpression(),
                    proxiedMethodTokenExpression,
                    new ReferencesToObjectArrayExpression(dereferencedArguments),
                    selector.ToExpression(),
                    new AddressOfReferenceExpression(BuildMethodInterceptorsField(@class, MethodToOverride, namingScope))
                });
            }
            return(new[]
            {
                getTargetExpression(@class, MethodToOverride),
                SelfReference.Self.ToExpression(),
                interceptors.ToExpression(),
                proxiedMethodTokenExpression,
                new ReferencesToObjectArrayExpression(dereferencedArguments)
            });
        }
        public void Generate(ClassEmitter emitter)
        {
            var interceptorsField = emitter.GetField("__interceptors");
            var targetReference   = getTargetReference();

            var dynProxyGetTarget = emitter.CreateMethod(nameof(IProxyTargetAccessor.DynProxyGetTarget), typeof(object));

            dynProxyGetTarget.CodeBuilder.AddStatement(
                new ReturnStatement(new ConvertExpression(typeof(object), targetType, targetReference)));

            var dynProxySetTarget = emitter.CreateMethod(nameof(IProxyTargetAccessor.DynProxySetTarget), typeof(void), typeof(object));

            // we can only change the target of the interface proxy
            if (targetReference is FieldReference targetField)
            {
                dynProxySetTarget.CodeBuilder.AddStatement(
                    new AssignStatement(targetField,
                                        new ConvertExpression(targetField.FieldBuilder.FieldType, dynProxySetTarget.Arguments[0])));
            }
            else
            {
                dynProxySetTarget.CodeBuilder.AddStatement(
                    new ThrowStatement(typeof(InvalidOperationException), "Cannot change the target of the class proxy."));
            }

            dynProxySetTarget.CodeBuilder.AddStatement(new ReturnStatement());

            var getInterceptors = emitter.CreateMethod(nameof(IProxyTargetAccessor.GetInterceptors), typeof(IInterceptor[]));

            getInterceptors.CodeBuilder.AddStatement(
                new ReturnStatement(interceptorsField));
        }
        public override void Generate(ClassEmitter @class, ProxyGenerationOptions options)
        {
            var interceptors = @class.GetField("__interceptors");

            ImplementProxyTargetAccessor(@class, interceptors);
            foreach (var attribute in targetType.GetNonInheritableAttributes())
            {
                @class.DefineCustomAttribute(attribute);
            }
        }
Exemple #11
0
        public virtual void Generate(ClassEmitter @class, ProxyGenerationOptions options)
        {
            var interceptors = @class.GetField("__interceptors");

            ImplementGetObjectData(@class);
            ImplementProxyTargetAccessor(@class, interceptors);
            foreach (var attribute in targetType.GetTypeInfo().GetNonInheritableAttributes())
            {
                @class.DefineCustomAttribute(attribute.Builder);
            }
        }
Exemple #12
0
        /// <summary>
        /// Generates the class defined by the provided class emitter.
        /// </summary>
        /// <param name="class">
        /// The <see cref="Castle.DynamicProxy.Generators.Emitters.ClassEmitter"/>
        /// being used to build the target type.
        /// </param>
        /// <param name="options">The options to use during proxy generation.</param>
        /// <exception cref="System.ArgumentNullException">
        /// Thrown if <paramref name="class" /> is <see langword="null" />.
        /// </exception>
        /// <remarks>
        /// <para>
        /// This overridden version of the method does everything that the base
        /// <see cref="Castle.DynamicProxy.Contributors.ProxyInstanceContributor.Generate"/>
        /// method does but it skips the part where it checks for non-inherited
        /// attributes and copies them over from the proxy target.
        /// </para>
        /// </remarks>
        public override void Generate(ClassEmitter @class, ProxyGenerationOptions options)
        {
            if (@class == null)
            {
                throw new ArgumentNullException("class");
            }
            FieldReference field = @class.GetField("__interceptors");

            this.ImplementGetObjectData(@class);
            this.ImplementProxyTargetAccessor(@class, field);
        }
        protected virtual Type Init(string typeName, out ClassEmitter emitter, Type proxyTargetType, out FieldReference interceptorsField, IEnumerable <Type> interfaces)
        {
            Type baseType = ProxyGenerationOptions.BaseTypeForInterfaceProxy;

            emitter = BuildClassEmitter(typeName, baseType, interfaces);

            CreateFields(emitter, proxyTargetType);
            CreateTypeAttributes(emitter);

            interceptorsField = emitter.GetField("__interceptors");
            return(baseType);
        }
Exemple #14
0
        public virtual void Generate(ClassEmitter @class, ProxyGenerationOptions options)
        {
            var interceptors = @class.GetField("__interceptors");

//#if FEATURE_SERIALIZATION
            ImplementGetObjectData(@class);
//#endif
            ImplementProxyTargetAccessor(@class, interceptors);
            foreach (var attribute in targetType.GetNonInheritableAttributes())
            {
                @class.DefineCustomAttribute(attribute);
            }
        }
Exemple #15
0
        protected override void CreateFields(ClassEmitter emitter)
        {
            base.CreateFields(emitter);

            var interceptorsField = emitter.GetField(InterceptorsFieldName);

            if (interceptorsField != null)
            {
                emitter.DefineCustomAttributeFor <IgnoreDataMemberAttribute>(interceptorsField);

                CreateMetadataProperty(emitter, interceptorsField);
            }
        }
Exemple #16
0
        public virtual void Generate(ClassEmitter @class, ProxyGenerationOptions options)
        {
            var interceptors = @class.GetField("__interceptors");

#if !SILVERLIGHT
            ImplementGetObjectData(@class);
#endif
            ImplementProxyTargetAccessor(@class, interceptors);
            foreach (var attribute in AttributeUtil.GetNonInheritableAttributes(targetType))
            {
                @class.DefineCustomAttribute(attribute);
            }
        }
        protected override MethodGenerator GetMethodGenerator(MetaMethod method, ClassEmitter @class,
                                                              ProxyGenerationOptions options,
                                                              OverrideMethodDelegate overrideMethod)
        {
            var invocation = GetInvocationType(method, @class, options);

            return(new MethodWithInvocationGenerator(method,
                                                     @class.GetField("__interceptors"),
                                                     invocation,
                                                     (c, m) => c.GetField("__target").ToExpression(),
                                                     overrideMethod,
                                                     null));
        }
Exemple #18
0
        protected override MethodGenerator GetMethodGenerator(
            MetaMethod method,
            ClassEmitter @class,
            OverrideMethodDelegate overrideMethod
            )
        {
            if (method.Ignore)
            {
                return(null);
            }

            var methodIsDirectlyAccessible = IsDirectlyAccessible(method);

            if (!method.Proxyable)
            {
                if (methodIsDirectlyAccessible)
                {
                    return(new ForwardingMethodGenerator(
                               method,
                               overrideMethod,
                               (c, m) => c.GetField("__target")
                               ));
                }
                else
                {
                    return(IndirectlyCalledMethodGenerator(
                               method,
                               @class,
                               overrideMethod,
                               skipInterceptors: true
                               ));
                }
            }

            if (!methodIsDirectlyAccessible)
            {
                return(IndirectlyCalledMethodGenerator(method, @class, overrideMethod));
            }

            var invocation = GetInvocationType(method, @class);

            return(new MethodWithInvocationGenerator(
                       method,
                       @class.GetField("__interceptors"),
                       invocation,
                       (c, m) => c.GetField("__target"),
                       overrideMethod,
                       null
                       ));
        }
Exemple #19
0
        protected override MethodGenerator GetMethodGenerator(MetaMethod method, ClassEmitter @class, ProxyGenerationOptions options, OverrideMethodDelegate overrideMethod)
        {
            if (!method.Proxyable)
            {
                return(new MinimialisticMethodGenerator(method, overrideMethod));
            }

            var invocation = GetInvocationType(method, @class, options);

            return(new MethodWithInvocationGenerator(method,
                                                     @class.GetField("__interceptors"),
                                                     invocation,
                                                     getTargetExpression,
                                                     overrideMethod,
                                                     null));
        }
        protected override MethodGenerator GetMethodGenerator(MetaMethod method, ClassEmitter @class, ProxyGenerationOptions options, CreateMethodDelegate createMethod)
        {
            if (!method.Proxyable)
            {
                return(new ForwardingMethodGenerator(method,
                                                     createMethod,
                                                     (c, m) => c.GetField("__target")));
            }

            var invocation = GetInvocationType(method, @class, options);

            return(new MethodWithInvocationGenerator(method,
                                                     @class.GetField("__interceptors"),
                                                     invocation,
                                                     (c, m) => c.GetField("__target").ToExpression(),
                                                     createMethod));
        }
        public override void Generate(ClassEmitter @class)
        {
            var interceptors = @class.GetField("__interceptors");

#if FEATURE_SERIALIZATION
            if (implementISerializable)
            {
                ImplementGetObjectData(@class);
                Constructor(@class);
            }
#endif
            ImplementProxyTargetAccessor(@class, interceptors);
            foreach (var attribute in targetType.GetNonInheritableAttributes())
            {
                @class.DefineCustomAttribute(attribute.Builder);
            }
        }
        public override void Generate(ClassEmitter @class, ProxyGenerationOptions options)
        {
            var interceptors = @class.GetField("__interceptors");

#if !SILVERLIGHT
            if (implementISerializable)
            {
                ImplementGetObjectData(@class);
                Constructor(@class);
            }
#endif
            ImplementProxyTargetAccessor(@class, interceptors);
            foreach (var attribute in targetType.GetNonInheritableAttributes())
            {
                @class.DefineCustomAttribute(attribute);
            }
        }
        private void ImplementChangeProxyTarget(AbstractTypeEmitter invocation, ClassEmitter @class)
        {
            var changeInvocationTarget = invocation.CreateMethod("ChangeProxyTarget", typeof(void), new[] { typeof(object) });

            changeInvocationTarget.CodeBuilder.AddStatement(
                new ExpressionStatement(
                    new ConvertExpression(@class.TypeBuilder, new FieldReference(InvocationMethods.ProxyObject).ToExpression())));

            var field = @class.GetField("__target");

            changeInvocationTarget.CodeBuilder.AddStatement(
                new AssignStatement(
                    new FieldReference(field.Reference)
            {
                OwnerReference = null
            },
                    new ConvertExpression(field.Fieldbuilder.FieldType, changeInvocationTarget.Arguments[0].ToExpression())));

            changeInvocationTarget.CodeBuilder.AddStatement(new ReturnStatement());
        }
Exemple #24
0
        protected override MethodGenerator GetMethodGenerator(MetaMethod method, ClassEmitter @class, ProxyGenerationOptions options, CreateMethodDelegate createMethod)
        {
            if (methodsToSkip.Contains(method.Method))
            {
                return(null);
            }

            if (!method.Proxyable)
            {
                return(new MinimialisticMethodGenerator(method,
                                                        createMethod));
            }

            var invocation = GetInvocationType(method, @class, options);

            return(new MethodWithInvocationGenerator(method,
                                                     @class.GetField("__interceptors"),
                                                     invocation,
                                                     (c, m) => new TypeTokenExpression(targetType),
                                                     createMethod));
        }
        private void ImplementChangeProxyTarget(AbstractTypeEmitter invocation, ClassEmitter @class)
        {
#if !NETFX_CORE
            var changeInvocationTarget = invocation.CreateMethod("ChangeProxyTarget", typeof(void), new[] { typeof(object) });
            changeInvocationTarget.CodeBuilder.AddStatement(
                new ExpressionStatement(
                    new ConvertExpression(@class.TypeBuilder,
                                          new FieldReference(InvocationMethods.ProxyObject.AsFieldInfo()).ToExpression())));

            var field = @class.GetField("__target");
            changeInvocationTarget.CodeBuilder.AddStatement(
                new AssignStatement(
                    new FieldReference(field.Reference)
            {
                OwnerReference = null
            },
                    new ConvertExpression(field.Fieldbuilder.FieldType, changeInvocationTarget.Arguments[0].ToExpression())));

            changeInvocationTarget.CodeBuilder.AddStatement(new ReturnStatement());
#else
            throw new NotImplementedException("This operation has not been implemented.");
#endif
        }
Exemple #26
0
 private Reference GetTarget(ClassEmitter @class, MethodInfo method)
 {
     return(new AsTypeReference(@class.GetField("__target"), method.DeclaringType));
 }
Exemple #27
0
        protected void ImplementGetObjectData(ClassEmitter emitter)
        {
            var getObjectData = emitter.CreateMethod(
                "GetObjectData",
                typeof(void),
                new[] { typeof(SerializationInfo), typeof(StreamingContext) }
                );
            var info = getObjectData.Arguments[0];

            var typeLocal = getObjectData.CodeBuilder.DeclareLocal(typeof(Type));

            getObjectData.CodeBuilder.AddStatement(
                new AssignStatement(
                    typeLocal,
                    new MethodInvocationExpression(
                        null,
                        TypeMethods.StaticGetType,
                        new LiteralStringExpression(
                            typeof(ProxyObjectReference).AssemblyQualifiedName
                            ),
                        new LiteralBoolExpression(true),
                        new LiteralBoolExpression(false)
                        )
                    )
                );

            getObjectData.CodeBuilder.AddStatement(
                new MethodInvocationExpression(info, SerializationInfoMethods.SetType, typeLocal)
                );

            foreach (var field in emitter.GetAllFields())
            {
                if (field.Reference.IsStatic)
                {
                    continue;
                }
                if (field.Reference.IsNotSerialized)
                {
                    continue;
                }
                AddAddValueInvocation(info, getObjectData, field);
            }

            var interfacesLocal = getObjectData.CodeBuilder.DeclareLocal(typeof(string[]));

            getObjectData.CodeBuilder.AddStatement(
                new AssignStatement(
                    interfacesLocal,
                    new NewArrayExpression(interfaces.Length, typeof(string))
                    )
                );

            for (var i = 0; i < interfaces.Length; i++)
            {
                getObjectData.CodeBuilder.AddStatement(
                    new AssignArrayStatement(
                        interfacesLocal,
                        i,
                        new LiteralStringExpression(interfaces[i].AssemblyQualifiedName)
                        )
                    );
            }

            getObjectData.CodeBuilder.AddStatement(
                new MethodInvocationExpression(
                    info,
                    SerializationInfoMethods.AddValue_Object,
                    new LiteralStringExpression("__interfaces"),
                    interfacesLocal
                    )
                );

            getObjectData.CodeBuilder.AddStatement(
                new MethodInvocationExpression(
                    info,
                    SerializationInfoMethods.AddValue_Object,
                    new LiteralStringExpression("__baseType"),
                    new LiteralStringExpression(emitter.BaseType.AssemblyQualifiedName)
                    )
                );

            getObjectData.CodeBuilder.AddStatement(
                new MethodInvocationExpression(
                    info,
                    SerializationInfoMethods.AddValue_Object,
                    new LiteralStringExpression("__proxyGenerationOptions"),
                    emitter.GetField("proxyGenerationOptions")
                    )
                );

            getObjectData.CodeBuilder.AddStatement(
                new MethodInvocationExpression(
                    info,
                    SerializationInfoMethods.AddValue_Object,
                    new LiteralStringExpression("__proxyTypeId"),
                    new LiteralStringExpression(proxyTypeId)
                    )
                );

            CustomizeGetObjectData(
                getObjectData.CodeBuilder,
                info,
                getObjectData.Arguments[1],
                emitter
                );

            getObjectData.CodeBuilder.AddStatement(new ReturnStatement());
        }
 protected override Reference GetTargetReference(ClassEmitter emitter)
 {
     return(emitter.GetField("__target"));
 }
Exemple #29
0
 protected override Expression GetTargetReferenceExpression(ClassEmitter emitter)
 {
     return(emitter.GetField("__target").ToExpression());
 }
Exemple #30
0
        protected void ImplementGetObjectData(ClassEmitter emitter)
        {
            var           serializationInfo = new ArgumentReference(typeof(SerializationInfo));
            var           streamingContext  = new ArgumentReference(typeof(StreamingContext));
            MethodEmitter getObjectData     = emitter.CreateMethod("GetObjectData", serializationInfo, streamingContext);

            LocalReference typeLocal = getObjectData.CodeBuilder.DeclareLocal(typeof(Type));

            getObjectData.CodeBuilder.AddStatement(
                new AssignStatement(
                    typeLocal,
                    new MethodInvocationExpression(
                        null,
                        TypeMethods.StaticGetType,
                        new ConstReference(typeof(ProxyObjectReference).AssemblyQualifiedName).ToExpression(),
                        new ConstReference(1).ToExpression(),
                        new ConstReference(0).ToExpression())));

            getObjectData.CodeBuilder.AddStatement(
                new ExpressionStatement(
                    new MethodInvocationExpression(
                        serializationInfo,
                        SerializationInfoMethods.SetType,
                        typeLocal.ToExpression())));

            foreach (var field in emitter.GetAllFields())
            {
                if (field.Reference.IsStatic)
                {
                    continue;
                }
                if (field.Reference.IsNotSerialized)
                {
                    continue;
                }
                AddAddValueInvocation(serializationInfo, getObjectData, field);
            }

            LocalReference interfacesLocal = getObjectData.CodeBuilder.DeclareLocal(typeof(string[]));

            getObjectData.CodeBuilder.AddStatement(
                new AssignStatement(
                    interfacesLocal,
                    new NewArrayExpression(interfaces.Length, typeof(string))));

            for (int i = 0; i < interfaces.Length; i++)
            {
                getObjectData.CodeBuilder.AddStatement(
                    new AssignArrayStatement(
                        interfacesLocal,
                        i,
                        new ConstReference(interfaces[i].AssemblyQualifiedName).ToExpression()));
            }

            getObjectData.CodeBuilder.AddStatement(
                new ExpressionStatement(
                    new MethodInvocationExpression(
                        serializationInfo,
                        SerializationInfoMethods.AddValue_Object,
                        new ConstReference("__interfaces").ToExpression(),
                        interfacesLocal.ToExpression())));

            getObjectData.CodeBuilder.AddStatement(
                new ExpressionStatement(
                    new MethodInvocationExpression(
                        serializationInfo,
                        SerializationInfoMethods.AddValue_Object,
                        new ConstReference("__baseType").ToExpression(),
                        new ConstReference(emitter.BaseType.AssemblyQualifiedName).ToExpression())));

            getObjectData.CodeBuilder.AddStatement(
                new ExpressionStatement(
                    new MethodInvocationExpression(
                        serializationInfo,
                        SerializationInfoMethods.AddValue_Object,
                        new ConstReference("__proxyGenerationOptions").ToExpression(),
                        emitter.GetField("proxyGenerationOptions").ToExpression())));



            getObjectData.CodeBuilder.AddStatement(
                new ExpressionStatement(
                    new MethodInvocationExpression(serializationInfo,
                                                   SerializationInfoMethods.AddValue_Object,
                                                   new ConstReference("__proxyTypeId").ToExpression(),
                                                   new ConstReference(proxyTypeId).ToExpression())));

            CustomizeGetObjectData(getObjectData.CodeBuilder, serializationInfo, streamingContext, emitter);

            getObjectData.CodeBuilder.AddStatement(new ReturnStatement());
        }