protected override MethodGenerator GetMethodGenerator(MetaMethod method, ClassEmitter @class,
ProxyGenerationOptions options,
OverrideMethodDelegate overrideMethod)
{
if (!method.Proxyable)
{
return new ForwardingMethodGenerator(method,
overrideMethod,
(c, m) => c.GetField("__target"));
}
var targetMethod = options.ProxyEffectiveType == null ? method.Method : InvocationHelper.GetMethodOnType(proxyTargetType, method.Method);
if (targetMethod == null)
{
return new MinimialisticMethodGenerator(method, overrideMethod);
}
var invocation = GetInvocationType(method, targetMethod, @class, options);
return new MethodWithInvocationGenerator(method,
@class.GetField("__interceptors"),
invocation,
(c, m) => c.GetField("__target").ToExpression(),
overrideMethod,
null);
}
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);
}
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);
}
// 重载 InterfaceProxyWithTargetInterfaceContributor 中的方法，以指定使用扩展的 InvocationType 生成方法执行类
protected override MethodGenerator GetMethodGenerator(MetaMethod method, ClassEmitter @class, ProxyGenerationOptions options, OverrideMethodDelegate overrideMethod)
{
if (!method.Proxyable)
{
return new MinimialisticMethodGenerator(method, overrideMethod);
}
return new MethodWithInvocationGenerator(method, @class.GetField("__interceptors"), this.GetInvocationType(method, @class, options), this.getTargetExpression, overrideMethod, null);
}
// 重载 InterfaceProxyWithTargetInterfaceContributor 中的方法，以指定使用扩展的 InvocationType 生成方法执行类
protected override MethodGenerator GetMethodGenerator(MetaMethod method, ClassEmitter @class, ProxyGenerationOptions options, OverrideMethodDelegate overrideMethod)
{
if (!method.Proxyable)
{
return new ForwardingMethodGenerator(method, overrideMethod, (c, m) => c.GetField("__target"));
}
return new MethodWithInvocationGenerator(method, @class.GetField("__interceptors"), this.GetInvocationType(method, @class, options), (c, m) => c.GetField("__target").ToExpression(), overrideMethod, null);
}
/// <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);
}
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.GetTypeInfo().GetNonInheritableAttributes())
{
@class.DefineCustomAttribute(attribute.Builder);
}
}
protected override void CreateFields(ClassEmitter emitter)
{
base.CreateFields(emitter);
var interceptorsField = emitter.GetField(InterceptorsFieldName);
if (interceptorsField != null)
{
emitter.DefineCustomAttributeFor<IgnoreDataMemberAttribute>(interceptorsField);
CreateMetadataProperty(emitter, interceptorsField);
}
}
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 targetType.GetNonInheritableAttributes())
{
@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);
}
protected override MethodGenerator GetMethodGenerator(MetaMethod method, ClassEmitter @class, ProxyGenerationOptions options, CreateMethodDelegate createMethod)
{
if (!method.Proxyable)
{
return new MinimialisticMethodGenerator(method,
createMethod);
}
var invocation = GetInvocationType(method, @class, options);
return new MethodWithInvocationGenerator(method,
@class.GetField("__interceptors"),
invocation,
getTargetExpression,
createMethod);
}
public override void Generate(ClassEmitter @class, ProxyGenerationOptions options)
{
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);
}
}
protected override void CustomizeGetObjectData(AbstractCodeBuilder codebuilder, ArgumentReference serializationInfo, ArgumentReference streamingContext, ClassEmitter emitter)
{
var targetField = emitter.GetField("__target");
codebuilder.AddStatement(new ExpressionStatement(
new MethodInvocationExpression(serializationInfo, SerializationInfoMethods.AddValue_Object,
new ConstReference("__targetFieldType").ToExpression(),
new ConstReference(
targetField.Reference.FieldType.AssemblyQualifiedName).
ToExpression())));
codebuilder.AddStatement(new ExpressionStatement(
new MethodInvocationExpression(serializationInfo, SerializationInfoMethods.AddValue_Object,
new ConstReference("__theInterface").ToExpression(),
new ConstReference(targetType.AssemblyQualifiedName).
ToExpression())));
}
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);
}
protected override Expression GetTargetReferenceExpression(ClassEmitter emitter)
{
Reference target = emitter.GetField("__target");
return (target ?? SelfReference.Self).ToExpression();
}
private MethodGenerator ExplicitlyImplementedInterfaceMethodGenerator(MetaMethod method, ClassEmitter @class,
ProxyGenerationOptions options,
OverrideMethodDelegate overrideMethod)
{
var @delegate = GetDelegateType(method, @class, options);
var contributor = GetContributor(@delegate, method);
var invocation = new InheritanceInvocationTypeGenerator(targetType, method, null, contributor)
.Generate(@class, options, namingScope)
.BuildType();
return new MethodWithInvocationGenerator(method,
@class.GetField("__interceptors"),
invocation,
(c, m) => new TypeTokenExpression(targetType),
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)
};
}
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;
}
protected override Expression GetTargetReferenceExpression(ClassEmitter emitter)
{
return emitter.GetField("__target").ToExpression();
}
protected override MethodGenerator GetMethodGenerator(MetaMethod method, ClassEmitter @class,
ProxyGenerationOptions options,
OverrideMethodDelegate overrideMethod)
{
if (!method.Proxyable)
{
return new ForwardingMethodGenerator(method,
overrideMethod,
(c, i) => fields[i.DeclaringType]);
}
var invocation = GetInvocationType(method, @class, options);
return new MethodWithInvocationGenerator(method,
@class.GetField("__interceptors"),
invocation,
getTargetExpression,
overrideMethod,
null);
}
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);
}
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());
}
private Reference GetTarget(ClassEmitter @class, MethodInfo method)
{
return new AsTypeReference(@class.GetField("__target"), method.DeclaringType);
}
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();
}
