public virtual void Generate(ClassEmitter @class, ProxyGenerationOptions options)
{
foreach (var method in methods)
{
if (!method.Standalone)
{
continue;
}
ImplementMethod(method,
@class,
options,
@class.CreateMethod);
}
foreach (var property in properties)
{
ImplementProperty(@class, property, options);
}
foreach (var @event in events)
{
ImplementEvent(@class, @event, options);
}
}
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);
}
private Type GetInvocationType(MetaMethod method, ClassEmitter @class, ProxyGenerationOptions options)
{
var scope = @class.ModuleScope;
Type[] invocationInterfaces;
if (canChangeTarget)
{
invocationInterfaces = new[] { typeof(IInvocation), typeof(IChangeProxyTarget) };
}
else
{
invocationInterfaces = new[] { typeof(IInvocation) };
}
var key = new CacheKey(method.Method, CompositionInvocationTypeGenerator.BaseType, invocationInterfaces, null);
// no locking required as we're already within a lock
var invocation = scope.GetFromCache(key);
if (invocation != null)
{
return invocation;
}
invocation = new CompositionInvocationTypeGenerator(method.Method.DeclaringType,
method,
method.Method,
canChangeTarget,
null)
.Generate(@class, options, namingScope).BuildType();
scope.RegisterInCache(key, invocation);
return invocation;
}
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 (ExplicitlyImplementedInterfaceMethod(method))
{
#if SILVERLIGHT
return null;
#else
return ExplicitlyImplementedInterfaceMethodGenerator(method, @class, options, overrideMethod);
#endif
}
var invocation = GetInvocationType(method, @class, options);
return new MethodWithInvocationGenerator(method,
@class.GetField("__interceptors"),
invocation,
(c, m) => new TypeTokenExpression(targetType),
overrideMethod,
null);
}
public Expression[] GetConstructorInvocationArguments(Expression[] arguments, ClassEmitter proxy)
{
var allArguments = new Expression[arguments.Length + 1];
allArguments[0] = new ReferenceExpression(BuildDelegateToken(proxy));
Array.Copy(arguments, 0, allArguments, 1, arguments.Length);
return allArguments;
}
private FieldReference CreateTargetField(ClassEmitter emitter)
{
var targetField = emitter.CreateField("__target", targetType);
#if !SILVERLIGHT
emitter.DefineCustomAttributeFor<XmlIgnoreAttribute>(targetField);
#endif
return targetField;
}
public virtual void Generate(ClassEmitter @class, ProxyGenerationOptions options)
{
var interceptors = @class.GetField("__interceptors");
ImplementProxyTargetAccessor(@class, interceptors);
foreach (var attribute in targetType.GetNonInheritableAttributes())
{
@class.DefineCustomAttribute(attribute);
}
}
protected override MethodEmitter BuildProxiedMethodBody(MethodEmitter emitter, ClassEmitter @class,
ProxyGenerationOptions options, INamingScope namingScope)
{
var targetReference = getTargetReference(@class, MethodToOverride);
emitter.CodeBuilder.AddStatement(
new ExpressionStatement(
new IfNullExpression(targetReference, IfNull(emitter.ReturnType), IfNotNull(targetReference))));
return emitter;
}
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 override MethodGenerator GetMethodGenerator(MetaMethod method, ClassEmitter @class,
ProxyGenerationOptions options,
OverrideMethodDelegate overrideMethod)
{
if (!method.Proxyable)
{
return new OptionallyForwardingMethodGenerator(method, overrideMethod, getTargetReference);
}
return base.GetMethodGenerator(method, @class, options, overrideMethod);
}
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);
}
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));
}
protected override MethodEmitter BuildProxiedMethodBody(MethodEmitter emitter, ClassEmitter @class,
ProxyGenerationOptions options, INamingScope namingScope)
{
var targetReference = getTargetReference(@class, MethodToOverride);
var arguments = ArgumentsUtil.ConvertToArgumentReferenceExpression(MethodToOverride.GetParameters());
emitter.CodeBuilder.AddStatement(new ReturnStatement(
new MethodInvocationExpression(
targetReference,
MethodToOverride,
arguments) { VirtualCall = true }));
return emitter;
}
public override void Generate(ClassEmitter @class, ProxyGenerationOptions options)
{
foreach (var @interface in interfaces)
{
fields[@interface] = BuildTargetField(@class, @interface);
}
foreach (var emptyInterface in empty)
{
fields[emptyInterface] = BuildTargetField(@class, emptyInterface);
}
base.Generate(@class, options);
}
private FieldReference BuildDelegateToken(ClassEmitter proxy)
{
var callback = proxy.CreateStaticField(namingScope.GetUniqueName("callback_" + method.Method.Name), delegateType);
var createDelegate = new MethodInvocationExpression(
null,
DelegateMethods.CreateDelegate,
new TypeTokenExpression(delegateType),
NullExpression.Instance,
new MethodTokenExpression(method.MethodOnTarget));
var bindDelegate = new AssignStatement(callback, new ConvertExpression(delegateType, createDelegate));
proxy.ClassConstructor.CodeBuilder.AddStatement(bindDelegate);
return callback;
}
protected override MethodEmitter BuildProxiedMethodBody(MethodEmitter emitter, ClassEmitter @class,
ProxyGenerationOptions options, INamingScope namingScope)
{
InitOutParameters(emitter, MethodToOverride.GetParameters());
if (emitter.ReturnType == typeof(void))
{
emitter.CodeBuilder.AddStatement(new ReturnStatement());
}
else
{
emitter.CodeBuilder.AddStatement(new ReturnStatement(new DefaultValueExpression(emitter.ReturnType)));
}
return emitter;
}
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);
}
private Type GetInvocationType(MetaMethod method, ClassEmitter emitter, ProxyGenerationOptions options)
{
var scope = emitter.ModuleScope;
var key = new CacheKey(method.Method, CompositionInvocationTypeGenerator.BaseType, null, null);
// no locking required as we're already within a lock
var invocation = scope.GetFromCache(key);
if (invocation != null)
{
return invocation;
}
invocation = new CompositionInvocationTypeGenerator(method.Method.DeclaringType,
method,
method.Method,
false,
null)
.Generate(emitter, options, namingScope)
.BuildType();
scope.RegisterInCache(key, invocation);
return invocation;
}
private MethodGenerator IndirectlyCalledMethodGenerator(MetaMethod method, ClassEmitter proxy,
ProxyGenerationOptions options,
OverrideMethodDelegate overrideMethod)
{
var @delegate = GetDelegateType(method, proxy, options);
var contributor = GetContributor(@delegate, method);
var invocation = new CompositionInvocationTypeGenerator(targetType, method, null, false, contributor)
.Generate(proxy, options, namingScope)
.BuildType();
return new MethodWithInvocationGenerator(method,
proxy.GetField("__interceptors"),
invocation,
(c, m) => c.GetField("__target").ToExpression(),
overrideMethod,
contributor);
}
private Type BuildInvocationType(MetaMethod method, ClassEmitter @class, ProxyGenerationOptions options)
{
if (!method.HasTarget)
{
return new InheritanceInvocationTypeGenerator(targetType,
method,
null, null)
.Generate(@class, options, namingScope)
.BuildType();
}
return new CompositionInvocationTypeGenerator(method.Method.DeclaringType,
method,
method.Method,
false,
null)
.Generate(@class, options, namingScope)
.BuildType();
}
protected virtual Type Init(string typeName, out ClassEmitter emitter, Type proxyTargetType,
out FieldReference interceptorsField, IEnumerable<Type> interfaces)
{
var baseType = ProxyGenerationOptions.BaseTypeForInterfaceProxy;
emitter = BuildClassEmitter(typeName, baseType, interfaces);
CreateFields(emitter, proxyTargetType);
CreateTypeAttributes(emitter);
interceptorsField = emitter.GetField("__interceptors");
return baseType;
}
private void ImplementMethod(MetaMethod method, ClassEmitter @class, ProxyGenerationOptions options,
OverrideMethodDelegate overrideMethod)
{
{
var generator = GetMethodGenerator(method, @class, options, overrideMethod);
if (generator == null)
{
return;
}
var proxyMethod = generator.Generate(@class, options, namingScope);
foreach (var attribute in method.Method.GetNonInheritableAttributes())
{
proxyMethod.DefineCustomAttribute(attribute);
}
}
}
protected abstract MethodGenerator GetMethodGenerator(MetaMethod method, ClassEmitter @class, ProxyGenerationOptions options, OverrideMethodDelegate overrideMethod);
private void ImplementProperty(ClassEmitter emitter, MetaProperty property, ProxyGenerationOptions options)
{
property.BuildPropertyEmitter(emitter);
if (property.CanRead)
{
ImplementMethod(property.Getter, emitter, options, property.Emitter.CreateGetMethod);
}
if (property.CanWrite)
{
ImplementMethod(property.Setter, emitter, options, property.Emitter.CreateSetMethod);
}
}
private void ImplementEvent(ClassEmitter emitter, MetaEvent @event, ProxyGenerationOptions options)
{
@event.BuildEventEmitter(emitter);
ImplementMethod(@event.Adder, emitter, options, @event.Emitter.CreateAddMethod);
ImplementMethod(@event.Remover, emitter, options, @event.Emitter.CreateRemoveMethod);
}
protected override MethodEmitter BuildProxiedMethodBody(MethodEmitter emitter, ClassEmitter @class, ProxyGenerationOptions options, INamingScope namingScope)
{
var invocationType = invocation;
Trace.Assert(MethodToOverride.IsGenericMethod == invocationType.IsGenericTypeDefinition);
var genericArguments = Type.EmptyTypes;
var constructor = invocation.GetConstructors()[0];
Expression proxiedMethodTokenExpression;
if (MethodToOverride.IsGenericMethod)
{
// bind generic method arguments to invocation's type arguments
genericArguments = emitter.MethodBuilder.GetGenericArguments();
invocationType = invocationType.MakeGenericType(genericArguments);
constructor = TypeBuilder.GetConstructor(invocationType, constructor);
// Not in the cache: generic method
proxiedMethodTokenExpression = new MethodTokenExpression(MethodToOverride.MakeGenericMethod(genericArguments));
}
else
{
var proxiedMethodToken = @class.CreateStaticField(namingScope.GetUniqueName("token_" + MethodToOverride.Name), typeof(MethodInfo));
@class.ClassConstructor.CodeBuilder.AddStatement(new AssignStatement(proxiedMethodToken, new MethodTokenExpression(MethodToOverride)));
proxiedMethodTokenExpression = proxiedMethodToken.ToExpression();
}
var methodInterceptors = SetMethodInterceptors(@class, namingScope, emitter, proxiedMethodTokenExpression);
var dereferencedArguments = IndirectReference.WrapIfByRef(emitter.Arguments);
var hasByRefArguments = HasByRefArguments(emitter.Arguments);
var arguments = GetCtorArguments(@class, proxiedMethodTokenExpression, dereferencedArguments, methodInterceptors);
var ctorArguments = ModifyArguments(@class, arguments);
var invocationLocal = emitter.CodeBuilder.DeclareLocal(invocationType);
emitter.CodeBuilder.AddStatement(new AssignStatement(invocationLocal,
new NewInstanceExpression(constructor, ctorArguments)));
if (MethodToOverride.ContainsGenericParameters)
{
EmitLoadGenricMethodArguments(emitter, MethodToOverride.MakeGenericMethod(genericArguments), invocationLocal);
}
if (hasByRefArguments)
{
emitter.CodeBuilder.AddStatement(new TryStatement());
}
var proceed = new ExpressionStatement(new MethodInvocationExpression(invocationLocal, InvocationMethods.Proceed));
emitter.CodeBuilder.AddStatement(proceed);
if (hasByRefArguments)
{
emitter.CodeBuilder.AddStatement(new FinallyStatement());
}
GeneratorUtil.CopyOutAndRefParameters(dereferencedArguments, invocationLocal, MethodToOverride, emitter);
if (hasByRefArguments)
{
emitter.CodeBuilder.AddStatement(new EndExceptionBlockStatement());
}
if (MethodToOverride.ReturnType != typeof(void))
{
// Emit code to return with cast from ReturnValue
var getRetVal = new MethodInvocationExpression(invocationLocal, InvocationMethods.GetReturnValue);
emitter.CodeBuilder.AddStatement(new ReturnStatement(new ConvertExpression(emitter.ReturnType, getRetVal)));
}
else
{
emitter.CodeBuilder.AddStatement(new ReturnStatement());
}
return emitter;
}
private void CreateFields(ClassEmitter emitter, Type proxyTargetType)
{
base.CreateFields(emitter);
targetField = emitter.CreateField("__target", proxyTargetType);
#if !SILVERLIGHT
emitter.DefineCustomAttributeFor<XmlIgnoreAttribute>(targetField);
#endif
}
private Expression[] ModifyArguments(ClassEmitter @class, Expression[] arguments)
{
if (contributor == null)
{
return arguments;
}
return contributor.GetConstructorInvocationArguments(arguments, @class);
}
private Expression[] GetCtorArguments(ClassEmitter @class, Expression proxiedMethodTokenExpression, TypeReference[] dereferencedArguments, Expression methodInterceptors)
{
return new[]
{
getTargetExpression(@class, MethodToOverride),
SelfReference.Self.ToExpression(),
methodInterceptors ?? interceptors.ToExpression(),
proxiedMethodTokenExpression,
new ReferencesToObjectArrayExpression(dereferencedArguments)
};
}
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();
}
