private FieldReference CreateTargetField(ClassEmitter emitter) { var targetField = emitter.CreateField("__target", targetType); #if FEATURE_SERIALIZATION emitter.DefineCustomAttributeFor<XmlIgnoreAttribute>(targetField); #endif return targetField; }
private FieldReference CreateTargetField(ClassEmitter emitter) { var targetField = emitter.CreateField("__target", targetType); #if !SILVERLIGHT emitter.DefineCustomAttributeFor<XmlIgnoreAttribute>(targetField); #endif return targetField; }
protected FieldReference BuildMethodInterceptorsField(ClassEmitter @class, MethodInfo method, INamingScope namingScope) { var methodInterceptors = @class.CreateField( namingScope.GetUniqueName(string.Format("interceptors_{0}", method.Name)), typeof(IInterceptor[]), false); #if !SILVERLIGHT @class.DefineCustomAttributeFor<XmlIgnoreAttribute>(methodInterceptors); #endif return methodInterceptors; }
protected void CreateSelectorField(ClassEmitter emitter) { if (ProxyGenerationOptions.Selector == null) { return; } emitter.CreateField("__selector", typeof(IInterceptorSelector)); return; }
protected void CreateInterceptorsField(ClassEmitter emitter) { var interceptorsField = emitter.CreateField("__interceptors", typeof (IInterceptor[])); #if !SILVERLIGHT emitter.DefineCustomAttributeFor<XmlIgnoreAttribute>(interceptorsField); #endif }
public void CreateFieldWithAttributes() { ClassEmitter emitter = new ClassEmitter(generator.ProxyBuilder.ModuleScope, "Foo", typeof (object), Type.EmptyTypes); emitter.CreateField("myField", typeof (string), FieldAttributes.FamANDAssem | FieldAttributes.InitOnly); Type t = emitter.BuildType(); FieldInfo field = t.GetField("myField", BindingFlags.NonPublic | BindingFlags.Instance); Assert.IsNotNull(field); Assert.AreEqual(FieldAttributes.FamANDAssem | FieldAttributes.InitOnly, field.Attributes); }
private void CreateFields(ClassEmitter emitter, Type proxyTargetType) { base.CreateFields(emitter); targetField = emitter.CreateField("__target", proxyTargetType); emitter.DefineCustomAttributeFor<XmlIgnoreAttribute>(targetField); }
private FieldReference BuildTargetField(ClassEmitter @class, Type type) { var name = "__mixin_" + type.FullName.Replace(".", "_"); return @class.CreateField(namingScope.GetUniqueName(name), type); }
/// <summary> /// Builds the adapter. /// </summary> /// <returns></returns> public Type Build() { //Setup emitter ClassEmitter classEmitter = new ClassEmitter(ModuleScope, OriginalObject.Name + "Adapter", typeof(AdapterBase), new Type[] { }, TypeAttributes.Class, true); //Add a field to hold a reference to the original object that is being adapter. FieldReference adaptedObjectReference = classEmitter.CreateField("_Original", OriginalObject); //Add a constructor that accepts a reference to the original object and //assigns that reference to the field. ArgumentReference parameter = new ArgumentReference(OriginalObject); ConstructorEmitter constructor = classEmitter.CreateConstructor(parameter); constructor.CodeBuilder.AddStatement( new AssignStatement(adaptedObjectReference, new ReferenceExpression(parameter))); constructor.CodeBuilder.AddStatement(new ReturnStatement()); //For each method, walk the pipeline foreach (MethodInfo method in OriginalObject.GetMethods()) { AdapterBuilderStageContext context = new AdapterBuilderStageContext(OriginalObject, classEmitter, adaptedObjectReference, method); WalkPipeline(context); } //build the type return classEmitter.BuildType(); }
protected void CreateInterceptorsField(ClassEmitter emitter) { var interceptorsField = emitter.CreateField("__interceptors", typeof(IInterceptor[])); #if FEATURE_SERIALIZATION emitter.DefineCustomAttributeFor<XmlIgnoreAttribute>(interceptorsField); #endif }
private void CreateFields(ClassEmitter emitter, Type proxyTargetType) { base.CreateFields(emitter); targetField = emitter.CreateField("__target", proxyTargetType); #if FEATURE_SERIALIZATION emitter.DefineCustomAttributeFor<XmlIgnoreAttribute>(targetField); #endif }
protected FieldReference[] AddMixinFields(ClassEmitter emitter) { List<FieldReference> mixins = new List<FieldReference>(); foreach (Type type in ProxyGenerationOptions.MixinData.MixinInterfacesAndPositions.Keys) { FieldReference fieldReference = emitter.CreateField("__mixin_" + type.FullName.Replace(".", "_"), type); interface2MixinFieldReference[type] = fieldReference; mixins.Add(fieldReference); } return mixins.ToArray(); }
protected MethodEmitter ImplementProxiedMethod( Type targetType, MethodEmitter methodEmitter, MethodInfo method, ClassEmitter emitter, NestedClassEmitter invocationImpl, FieldReference interceptorsField, Reference targetRef, ConstructorVersion version, MethodInfo methodOnTarget) { CheckNotGenericTypeDefinition(targetType, "targetType"); methodEmitter.CopyParametersAndReturnTypeFrom(method, emitter); TypeReference[] dereferencedArguments = IndirectReference.WrapIfByRef(methodEmitter.Arguments); Type iinvocation = invocationImpl.TypeBuilder; Trace.Assert(method.IsGenericMethod == iinvocation.IsGenericTypeDefinition); bool isGenericInvocationClass = false; Type[] genericMethodArgs = new Type[0]; if (method.IsGenericMethod) { // bind generic method arguments to invocation's type arguments genericMethodArgs = methodEmitter.MethodBuilder.GetGenericArguments(); iinvocation = iinvocation.MakeGenericType(genericMethodArgs); isGenericInvocationClass = true; } Expression typeTokenFieldExp = typeTokenField.ToExpression(); Expression methodInfoTokenExp; string tokenFieldName; if (method2TokenField.ContainsKey(method)) // Token is in the cache { FieldReference methodTokenField = method2TokenField[method]; tokenFieldName = methodTokenField.Reference.Name; methodInfoTokenExp = methodTokenField.ToExpression(); } else { // Not in the cache: generic method MethodInfo genericMethod = method.MakeGenericMethod(genericMethodArgs); // Need random suffix added to the name, so that we don't end up with duplicate field names for // methods with the same name, but different generic parameters tokenFieldName = string.Format("{0}_{1}_{2}", genericMethod.Name, genericMethodArgs.Length, Guid.NewGuid().ToString("N")); methodInfoTokenExp = new MethodTokenExpression(genericMethod); } LocalReference invocationImplLocal = methodEmitter.CodeBuilder.DeclareLocal(iinvocation); // TODO: Initialize iinvocation instance with ordinary arguments and in and out arguments Expression interceptors = interceptorsField.ToExpression(); // Create the field to store the selected interceptors for this method if an InterceptorSelector is specified FieldReference methodInterceptors = null; if (proxyGenerationOptions.Selector != null) { // If no interceptors are returned, should we invoke the base.Method directly? Looks like we should not. methodInterceptors = emitter.CreateField(string.Format("{0}_interceptors", tokenFieldName), typeof(IInterceptor[])); } ConstructorInfo constructor = invocationImpl.Constructors[0].ConstructorBuilder; if (isGenericInvocationClass) { constructor = TypeBuilder.GetConstructor(iinvocation, constructor); } NewInstanceExpression newInvocImpl; if (version == ConstructorVersion.WithTargetMethod) { Expression methodOnTargetTokenExp; if (method2TokenField.ContainsKey(methodOnTarget)) // Token is in the cache { methodOnTargetTokenExp = method2TokenField[methodOnTarget].ToExpression(); } else { // Not in the cache: generic method methodOnTargetTokenExp = new MethodTokenExpression(methodOnTarget.MakeGenericMethod(genericMethodArgs)); } if (methodInterceptors == null) { newInvocImpl = //actual contructor call new NewInstanceExpression(constructor, targetRef.ToExpression(), interceptors, typeTokenFieldExp, methodOnTargetTokenExp, methodInfoTokenExp, new ReferencesToObjectArrayExpression(dereferencedArguments), SelfReference.Self.ToExpression()); } else { MethodInvocationExpression methodInvocationExpression = new MethodInvocationExpression(proxyGenerationOptionsField, proxyGenerationOptions_Selector); methodInvocationExpression.VirtualCall = true; newInvocImpl = //actual contructor call new NewInstanceExpression(constructor, targetRef.ToExpression(), interceptors, typeTokenFieldExp, methodOnTargetTokenExp, methodInfoTokenExp, new ReferencesToObjectArrayExpression(dereferencedArguments), SelfReference.Self.ToExpression(), methodInvocationExpression, new AddressOfReferenceExpression(methodInterceptors)); } } else { if (methodInterceptors == null) { newInvocImpl = new NewInstanceExpression(constructor, targetRef.ToExpression(), interceptors, typeTokenFieldExp, methodInfoTokenExp, new ReferencesToObjectArrayExpression(dereferencedArguments), SelfReference.Self.ToExpression()); } else { MethodInvocationExpression methodInvocationExpression = new MethodInvocationExpression(proxyGenerationOptionsField, proxyGenerationOptions_Selector); methodInvocationExpression.VirtualCall = true; newInvocImpl = new NewInstanceExpression(constructor, targetRef.ToExpression(), interceptors, typeTokenFieldExp, methodInfoTokenExp, new ReferencesToObjectArrayExpression(dereferencedArguments), SelfReference.Self.ToExpression(), methodInvocationExpression, new AddressOfReferenceExpression(methodInterceptors)); } } methodEmitter.CodeBuilder.AddStatement(new AssignStatement(invocationImplLocal, newInvocImpl)); if (method.ContainsGenericParameters) { EmitLoadGenricMethodArguments(methodEmitter, method.MakeGenericMethod(genericMethodArgs), invocationImplLocal); } methodEmitter.CodeBuilder.AddStatement( new ExpressionStatement(new MethodInvocationExpression(invocationImplLocal, Constants.AbstractInvocationProceed))); CopyOutAndRefParameters(dereferencedArguments, invocationImplLocal, method, methodEmitter); if (method.ReturnType != typeof(void)) { // Emit code to return with cast from ReturnValue MethodInvocationExpression getRetVal = new MethodInvocationExpression(invocationImplLocal, typeof(AbstractInvocation).GetMethod("get_ReturnValue")); methodEmitter.CodeBuilder.AddStatement( new ReturnStatement(new ConvertExpression(methodEmitter.ReturnType, getRetVal))); } else { methodEmitter.CodeBuilder.AddStatement(new ReturnStatement()); } return methodEmitter; }
private void CreateFields(ClassEmitter emitter, Type proxyTargetType) { base.CreateFields(emitter); targetField = emitter.CreateField("__target", proxyTargetType); #if SILVERLIGHT #warning XmlIncludeAttribute is in silverlight, do we want to explore this? #else emitter.DefineCustomAttributeFor<XmlIgnoreAttribute>(targetField); #endif }