public MutableType( MutableType declaringType, Type baseType, string name, string @namespace, TypeAttributes attributes, IInterfaceMappingComputer interfaceMappingComputer, IMutableMemberFactory mutableMemberFactory) : base(name, @namespace, attributes, null, EmptyTypes) { // Base type may be null (for interfaces). // Declaring type may be null. ArgumentUtility.CheckNotNull("interfaceMappingComputer", interfaceMappingComputer); ArgumentUtility.CheckNotNull("mutableMemberFactory", mutableMemberFactory); SetDeclaringType(declaringType); SetBaseType(baseType); _interfaceMappingComputer = interfaceMappingComputer; _mutableMemberFactory = mutableMemberFactory; _allMethods = GetAllBaseMethods(baseType); _allMethodsIndex = new Dictionary <MethodInfo, int>(); for (int index = 0; index < _allMethods.Count; index++) { _allMethodsIndex.Add(MethodBaseDefinitionCache.GetBaseDefinition(_allMethods[index]), index); } _baseDefinitionsOfAbstractMethods = GetBaseDefinitionsOfAbstractMethods(baseType); }
public MutableEventInfo( MutableType declaringType, string name, EventAttributes attributes, MutableMethodInfo addMethod, MutableMethodInfo removeMethod, MutableMethodInfo raiseMethod) : base(declaringType, name, attributes, addMethod, removeMethod, raiseMethod) { }
public static void AddTypeInitialization(this MutableType declaringType, Expression typeInitialization) { ArgumentUtility.CheckNotNull("declaringType", declaringType); ArgumentUtility.CheckNotNull("typeInitialization", typeInitialization); if (declaringType.MutableTypeInitializer == null) { declaringType.AddTypeInitializer(ctx => typeInitialization); } else { declaringType.MutableTypeInitializer.SetBody(ctx => Expression.Block(ctx.PreviousBody, typeInitialization)); } }
public MutableConstructorInfo( MutableType declaringType, MethodAttributes attributes, IEnumerable <ParameterDeclaration> parameters, Expression body) : base(declaringType, attributes) { ArgumentUtility.CheckNotNull("parameters", parameters); ArgumentUtility.CheckNotNull("body", body); Assertion.IsTrue(body.Type == typeof(void)); var paras = parameters.ToList(); _parameters = paras.Select((p, i) => new MutableParameterInfo(this, i, p.Name, p.Type, p.Attributes)).ToList().AsReadOnly(); _parameterExpressions = paras.Select(p => p.Expression).ToList().AsReadOnly(); _body = body; }
public static MutableMethodInfo AddMethod( this MutableType declaringType, string name, MethodAttributes attributes = MethodAttributes.Public, Type returnType = null, IEnumerable <ParameterDeclaration> parameters = null, Func <MethodBodyCreationContext, Expression> bodyProvider = null) { ArgumentUtility.CheckNotNullOrEmpty("name", name); returnType = returnType ?? typeof(void); parameters = parameters ?? ParameterDeclaration.None; // Body provider may be null (for abstract methods). return(declaringType.AddMethod(name, attributes, GenericParameterDeclaration.None, ctx => returnType, ctx => parameters, bodyProvider)); }
public static MutableMethodInfo AddAbstractMethod( this MutableType declaringType, string name, MethodAttributes attributes = MethodAttributes.Public, Type returnType = null, IEnumerable <ParameterDeclaration> parameters = null) { ArgumentUtility.CheckNotNull("declaringType", declaringType); ArgumentUtility.CheckNotNullOrEmpty("name", name); returnType = returnType ?? typeof(void); parameters = parameters ?? ParameterDeclaration.None; var abstractAttributes = attributes.Set(MethodAttributes.Abstract | MethodAttributes.Virtual); return(declaringType.AddMethod(name, abstractAttributes, returnType, parameters, bodyProvider: null)); }
public static MutableMethodInfo AddMethod( this MutableType declaringType, string name, MethodAttributes attributes, MethodDeclaration methodDeclaration, Func <MethodBodyCreationContext, Expression> bodyProvider) { ArgumentUtility.CheckNotNull("declaringType", declaringType); ArgumentUtility.CheckNotNullOrEmpty("name", name); ArgumentUtility.CheckNotNull("methodDeclaration", methodDeclaration); // Body provider may be null (for abstract methods). var md = methodDeclaration; return(declaringType.AddMethod(name, attributes, md.GenericParameters, md.ReturnTypeProvider, md.ParameterProvider, bodyProvider)); }
public MutablePropertyInfo( MutableType declaringType, string name, PropertyAttributes attributes, MutableMethodInfo getMethod, MutableMethodInfo setMethod) : base(declaringType, name, attributes, getMethod, setMethod) { IEnumerable <ParameterInfo> indexParameters; if (getMethod != null) { indexParameters = getMethod.GetParameters(); } else { var setMethodParameters = setMethod.GetParameters(); indexParameters = setMethodParameters.Take(setMethodParameters.Length - 1); } _indexParameters = indexParameters.Select(p => new PropertyParameterInfoWrapper(this, p)).ToList().AsReadOnly(); }
public MutableMethodInfo( MutableType declaringType, string name, MethodAttributes attributes, ICollection <MutableGenericParameter> genericParameters, Type returnType, IEnumerable <ParameterDeclaration> parameters, MethodInfo baseMethod, Expression body) : base( declaringType, name, attributes, null, genericParameters.Cast <Type>()) { ArgumentUtility.CheckNotNull("returnType", returnType); ArgumentUtility.CheckNotNull("parameters", parameters); Assertion.IsTrue(baseMethod == null || (baseMethod.IsVirtual && attributes.IsSet(MethodAttributes.Virtual))); Assertion.IsTrue(body != null || attributes.IsSet(MethodAttributes.Abstract)); Assertion.IsTrue(body == null || returnType.IsTypePipeAssignableFrom(body.Type)); foreach (var genericParameter in genericParameters) { genericParameter.InitializeDeclaringMember(this); } var paras = parameters.ToList(); _genericParameters = genericParameters.ToList().AsReadOnly(); _returnParameter = new MutableParameterInfo(this, -1, null, returnType, ParameterAttributes.None); _parameters = paras.Select((p, i) => new MutableParameterInfo(this, i, p.Name, p.Type, p.Attributes)).ToList().AsReadOnly(); _parameterExpressions = paras.Select(p => p.Expression).ToList().AsReadOnly(); _baseMethod = baseMethod; _body = body; }
public MutableFieldInfo(MutableType declaringType, string name, Type type, FieldAttributes attributes) : base(declaringType, name, type, attributes) { }