private static Expression ImplementBaseGetObjectDataCall(MethodBodyContextBase ctx) { ConstructorInfo baseConstructor = ctx.DeclaringType.BaseType.GetConstructor( BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Instance, null, CallingConventions.Any, new[] { typeof(SerializationInfo), typeof(StreamingContext) }, null); if (baseConstructor == null || !IsPublicOrProtected(baseConstructor)) { string message = string.Format( "No public or protected deserialization constructor in type {0} - serialization is not supported.", ctx.DeclaringType.BaseType.FullName); return(Expression.Throw(Expression.New(s_invalidOperationExceptionConstructor, Expression.Constant(message)))); } MethodInfo baseGetObjectDataMethod = ctx.DeclaringType.BaseType.GetMethod("GetObjectData", BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Instance); if (baseGetObjectDataMethod == null || !IsPublicOrProtected(baseGetObjectDataMethod)) { string message = string.Format("No public or protected GetObjectData in type {0} - serialization is not supported.", ctx.DeclaringType.BaseType.FullName); return(Expression.Throw(Expression.New(s_invalidOperationExceptionConstructor, Expression.Constant(message)))); } return(ctx.DelegateToBase(baseGetObjectDataMethod)); }
private Expression CreateBaseCallToMixinStatement(MethodBodyContextBase ctx, MethodDefinition target) { var mixin = (MixinDefinition)target.DeclaringClass; var baseCallMethod = GetMixinMethodToCall(mixin.MixinIndex, target); var mixinReference = GetMixinReference(mixin, baseCallMethod.DeclaringType); return(ctx.DelegateTo(mixinReference, baseCallMethod)); }
private Expression CreateBaseCallStatement(MethodBodyContextBase ctx, MethodDefinition target) { if (target.DeclaringClass == _targetClassDefinition) { return(CreateBaseCallToTargetClassStatement(ctx, target)); } else { return(CreateBaseCallToMixinStatement(ctx, target)); } }
public void SetUp() { _declaringType = MutableTypeObjectMother.Create(); _isStatic = BooleanObjectMother.GetRandomBoolean(); _parameters = new[] { Expression.Parameter(typeof(string)) }; _genericParameters = new[] { ReflectionObjectMother.GetSomeGenericParameter() }; _returnType = ReflectionObjectMother.GetSomeType(); _baseMethod = ReflectionObjectMother.GetSomeMethod(); _context = new TestableMethodBodyContextBase( _declaringType, _isStatic, _parameters.AsOneTime(), _genericParameters.AsOneTime(), _returnType, _baseMethod); }
public Expression CreateInitializingDelegation( MethodBodyContextBase ctx, MethodInfo initializationMethod, Expression instance, MethodInfo methodToCall) { ArgumentUtility.CheckNotNull("ctx", ctx); ArgumentUtility.CheckNotNull("initializationMethod", initializationMethod); ArgumentUtility.CheckNotNull("instance", instance); ArgumentUtility.CheckNotNull("methodToCall", methodToCall); // <CreateInitialization> // instance<GenericParameters>.MethodToCall(<parameters>); return(Expression.Block( CreateInitialization(ctx.DeclaringType, initializationMethod), ctx.DelegateTo(instance, methodToCall))); }
public Expression CreateBaseCallToNextInChain(MethodBodyContextBase ctx, MethodDefinition methodDefinitionOnTarget) { Assertion.IsTrue(methodDefinitionOnTarget.DeclaringClass == _targetClassDefinition); var expressions = new List <Expression>(); var returnLabel = Expression.Label(ctx.ReturnType); for (int potentialDepth = 0; potentialDepth < _targetClassDefinition.Mixins.Count; ++potentialDepth) { var nextInChain = GetNextInChain(methodDefinitionOnTarget, potentialDepth); var baseCallIfDepthMatches = AddBaseCallToTargetIfDepthMatches(ctx, nextInChain, potentialDepth, returnLabel); expressions.Add(baseCallIfDepthMatches); } var baseCall = CreateBaseCallToTarget(ctx, methodDefinitionOnTarget); expressions.Add(Expression.Label(returnLabel, baseCall)); return(Expression.Block(expressions)); }
public Expression CreateBaseCallToTarget(MethodBodyContextBase ctx, MethodDefinition target) { return(CreateBaseCallStatement(ctx, target)); }
private Expression AddBaseCallToTargetIfDepthMatches(MethodBodyContextBase ctx, MethodDefinition target, int requestedDepth, LabelTarget returnLabel) { return(Expression.IfThen( Expression.Equal(_depthField, Expression.Constant(requestedDepth)), Expression.Return(returnLabel, CreateBaseCallStatement(ctx, target)))); }
private Expression CreateBaseCallToTargetClassStatement(MethodBodyContextBase ctx, MethodDefinition target) { var baseCallMethod = _targetTypeForNextCall.GetBaseCallMethod(target.MethodInfo); return(ctx.DelegateTo(_thisField, baseCallMethod)); }