protected void ImplementProxyTargetAccessor(ClassEmitter emitter, FieldReference interceptorsField)
{
var dynProxyGetTarget = emitter.CreateMethod("DynProxyGetTarget", typeof(object));
dynProxyGetTarget.CodeBuilder.AddStatement(
new ReturnStatement(new ConvertExpression(typeof(object), targetType, GetTargetReferenceExpression(emitter))));
var getInterceptors = emitter.CreateMethod("GetInterceptors", typeof(IInterceptor[]));
getInterceptors.CodeBuilder.AddStatement(
new ReturnStatement(interceptorsField));
}
public void StaticMethodArguments ()
{
ClassEmitter emitter = new ClassEmitter (generator.ProxyBuilder.ModuleScope, "Foo", typeof (List<object>), Type.EmptyTypes);
MethodEmitter methodEmitter = emitter.CreateMethod ("StaticMethod", MethodAttributes.Public | MethodAttributes.Static,
typeof (string), typeof (string));
methodEmitter.CodeBuilder.AddStatement (new ReturnStatement (methodEmitter.Arguments[0]));
Type t = emitter.BuildType ();
Assert.AreEqual ("five", t.GetMethod ("StaticMethod").Invoke (null, new object[] { "five" }));
}
public void InstanceMethodArguments ()
{
ClassEmitter emitter = new ClassEmitter (generator.ProxyBuilder.ModuleScope, "Foo", typeof (List<object>), Type.EmptyTypes);
MethodEmitter methodEmitter = emitter.CreateMethod ("InstanceMethod", MethodAttributes.Public,
typeof (string), typeof (string));
methodEmitter.CodeBuilder.AddStatement (new ReturnStatement (methodEmitter.Arguments[0]));
Type t = emitter.BuildType ();
object instance = Activator.CreateInstance (t);
Assert.AreEqual ("six", t.GetMethod ("InstanceMethod").Invoke (instance, new object[] { "six" }));
}
private MethodBuilder CreateCallbackMethod(ClassEmitter emitter, MethodInfo methodInfo, MethodInfo methodOnTarget)
{
var targetMethod = methodOnTarget ?? methodInfo;
var callBackMethod = emitter.CreateMethod(namingScope.GetUniqueName(methodInfo.Name + "_callback"), targetMethod);
if (targetMethod.IsGenericMethod)
targetMethod = targetMethod.MakeGenericMethod(callBackMethod.GenericTypeParams);
var exps = new Expression[callBackMethod.Arguments.Length];
for (var i = 0; i < callBackMethod.Arguments.Length; i++)
{
exps[i] = callBackMethod.Arguments[i].ToExpression();
}
// invocation on base class
callBackMethod.CodeBuilder.AddStatement(
new ReturnStatement(
new MethodInvocationExpression(SelfReference.Self,
targetMethod,
exps)));
return callBackMethod.MethodBuilder;
}
public void UsingClassEmitterForInterfaces()
{
ClassEmitter emitter = new ClassEmitter(generator.ProxyBuilder.ModuleScope, "IFoo", null, Type.EmptyTypes,
TypeAttributes.Interface | TypeAttributes.Abstract | TypeAttributes.Public, false);
emitter.CreateMethod("MyMethod", MethodAttributes.Public | MethodAttributes.Abstract | MethodAttributes.Virtual,
typeof(void), Type.EmptyTypes);
Type t = emitter.BuildType();
Assert.IsTrue(t.IsInterface);
MethodInfo method = t.GetMethod("MyMethod");
Assert.IsNotNull(method);
}
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 ConstReference(typeof(ProxyObjectReference).AssemblyQualifiedName).ToExpression(),
new ConstReference(1).ToExpression(),
new ConstReference(0).ToExpression())));
getObjectData.CodeBuilder.AddStatement(
new ExpressionStatement(
new MethodInvocationExpression(
info,
SerializationInfoMethods.SetType,
typeLocal.ToExpression())));
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 ConstReference(interfaces[i].AssemblyQualifiedName).ToExpression()));
}
getObjectData.CodeBuilder.AddStatement(
new ExpressionStatement(
new MethodInvocationExpression(
info,
SerializationInfoMethods.AddValue_Object,
new ConstReference("__interfaces").ToExpression(),
interfacesLocal.ToExpression())));
getObjectData.CodeBuilder.AddStatement(
new ExpressionStatement(
new MethodInvocationExpression(
info,
SerializationInfoMethods.AddValue_Object,
new ConstReference("__baseType").ToExpression(),
new ConstReference(emitter.BaseType.AssemblyQualifiedName).ToExpression())));
getObjectData.CodeBuilder.AddStatement(
new ExpressionStatement(
new MethodInvocationExpression(
info,
SerializationInfoMethods.AddValue_Object,
new ConstReference("__proxyGenerationOptions").ToExpression(),
emitter.GetField("proxyGenerationOptions").ToExpression())));
getObjectData.CodeBuilder.AddStatement(
new ExpressionStatement(
new MethodInvocationExpression(info,
SerializationInfoMethods.AddValue_Object,
new ConstReference("__proxyTypeId").ToExpression(),
new ConstReference(proxyTypeId).ToExpression())));
CustomizeGetObjectData(getObjectData.CodeBuilder, info, getObjectData.Arguments[1], emitter);
getObjectData.CodeBuilder.AddStatement(new ReturnStatement());
}
protected MethodBuilder CreateCallbackMethod(ClassEmitter emitter, MethodInfo methodInfo, MethodInfo methodOnTarget)
{
MethodInfo targetMethod = methodOnTarget != null ? methodOnTarget : methodInfo;
if (targetMethod.IsAbstract)
return null;
// MethodBuild creation
MethodAttributes atts = MethodAttributes.Family;
String name = methodInfo.Name + "_callback_" + ++callbackCounter;
MethodEmitter callBackMethod = emitter.CreateMethod(name, atts);
callBackMethod.CopyParametersAndReturnTypeFrom(targetMethod, emitter);
// Generic definition
if (targetMethod.IsGenericMethod)
{
targetMethod = targetMethod.MakeGenericMethod(callBackMethod.GenericTypeParams);
}
// Parameters exp
Expression[] exps = new Expression[callBackMethod.Arguments.Length];
for(int i = 0; i < callBackMethod.Arguments.Length; i++)
{
exps[i] = callBackMethod.Arguments[i].ToExpression();
}
// invocation on base class
callBackMethod.CodeBuilder.AddStatement(
new ReturnStatement(new MethodInvocationExpression(GetProxyTargetReference(), targetMethod, exps)));
return callBackMethod.MethodBuilder;
}
protected MethodEmitter CreateProxiedMethod(
Type targetType,
MethodInfo method,
ClassEmitter emitter,
NestedClassEmitter invocationImpl,
FieldReference interceptorsField,
Reference targetRef,
ConstructorVersion version,
MethodInfo methodOnTarget)
{
CheckNotGenericTypeDefinition(targetType, "targetType");
MethodAttributes atts = ObtainMethodAttributes(method);
MethodEmitter methodEmitter = emitter.CreateMethod(method.Name, atts);
return
ImplementProxiedMethod(targetType,
methodEmitter,
method,
emitter,
invocationImpl,
interceptorsField,
targetRef,
version,
methodOnTarget);
}
protected virtual void ImplementGetObjectData(ClassEmitter emitter, FieldReference interceptorsField,
Type[] interfaces)
{
if (interfaces == null)
{
interfaces = new Type[0];
}
Type[] get_type_args = new Type[] {typeof(String), typeof(bool), typeof(bool)};
Type[] key_and_object = new Type[] {typeof(String), typeof(Object)};
MethodInfo addValueMethod = typeof(SerializationInfo).GetMethod("AddValue", key_and_object);
ArgumentReference arg1 = new ArgumentReference(typeof(SerializationInfo));
ArgumentReference arg2 = new ArgumentReference(typeof(StreamingContext));
MethodEmitter getObjectData = emitter.CreateMethod("GetObjectData",
typeof(void), arg1, arg2);
LocalReference typeLocal = getObjectData.CodeBuilder.DeclareLocal(typeof(Type));
getObjectData.CodeBuilder.AddStatement(new AssignStatement(
typeLocal,
new MethodInvocationExpression(null,
typeof(Type).GetMethod("GetType",
get_type_args),
new ConstReference(
typeof(ProxyObjectReference).
AssemblyQualifiedName).ToExpression(),
new ConstReference(1).ToExpression(),
new ConstReference(0).ToExpression())));
getObjectData.CodeBuilder.AddStatement(new ExpressionStatement(
new MethodInvocationExpression(
arg1, typeof(SerializationInfo).GetMethod("SetType"),
typeLocal.ToExpression())));
getObjectData.CodeBuilder.AddStatement(new ExpressionStatement(
new MethodInvocationExpression(arg1, addValueMethod,
new ConstReference("__interceptors").
ToExpression(),
interceptorsField.ToExpression())));
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(arg1, addValueMethod,
new ConstReference("__interfaces").
ToExpression(),
interfacesLocal.ToExpression())));
getObjectData.CodeBuilder.AddStatement(new ExpressionStatement(
new MethodInvocationExpression(arg1, addValueMethod,
new ConstReference("__baseType").
ToExpression(),
new ConstReference (emitter.BaseType.AssemblyQualifiedName).ToExpression())));
getObjectData.CodeBuilder.AddStatement(new ExpressionStatement(
new MethodInvocationExpression(arg1, addValueMethod,
new ConstReference("__proxyGenerationOptions").
ToExpression(),
proxyGenerationOptionsField.ToExpression())));
CustomizeGetObjectData(getObjectData.CodeBuilder, arg1, arg2);
getObjectData.CodeBuilder.AddStatement(new ReturnStatement());
}
protected void ImplementProxyTargetAccessor(Type targetType, ClassEmitter emitter, FieldReference interceptorsField)
{
MethodAttributes attributes = MethodAttributes.Virtual | MethodAttributes.Public;
MethodEmitter DynProxyGetTarget =
emitter.CreateMethod("DynProxyGetTarget", attributes, typeof (object));
DynProxyGetTarget.CodeBuilder.AddStatement(
new ReturnStatement(new ConvertExpression(typeof (object), targetType, GetProxyTargetReference().ToExpression())));
MethodEmitter GetInterceptors =
emitter.CreateMethod("GetInterceptors", attributes, typeof (IInterceptor[]));
GetInterceptors.CodeBuilder.AddStatement(
new ReturnStatement(interceptorsField)
);
}
private MethodBuilder CreateCallbackMethod(ClassEmitter emitter, MethodInfo methodInfo, MethodInfo methodOnTarget)
{
MethodInfo targetMethod = methodOnTarget ?? methodInfo;
// MethodBuild creation
MethodEmitter callBackMethod = emitter.CreateMethod(namingScope.GetUniqueName(methodInfo.Name + "_callback"));
callBackMethod.CopyParametersAndReturnTypeFrom(targetMethod, emitter);
// Generic definition
if (targetMethod.IsGenericMethod)
{
targetMethod = targetMethod.MakeGenericMethod(callBackMethod.GenericTypeParams);
}
// Parameters exp
Expression[] exps = new Expression[callBackMethod.Arguments.Length];
for (int i = 0; i < callBackMethod.Arguments.Length; i++)
{
exps[i] = callBackMethod.Arguments[i].ToExpression();
}
// invocation on base class
callBackMethod.CodeBuilder.AddStatement(
new ReturnStatement(new MethodInvocationExpression(SelfReference.Self, targetMethod, exps)));
return callBackMethod.MethodBuilder;
}
