public TypeDefinition(string @namespace, string name, TypeAttributes attributes, TypeReference baseType, uint fieldList, uint methodList) : base(new MetaDataRow((uint)attributes, 0U, 0U, 0U, fieldList, methodList)) { this._namespace = @namespace; this._name = name; this._baseType = baseType; }
public virtual TypeDefinition ResolveType(TypeReference typeRef) { LWin32 targetAssembly = null; typeRef = typeRef.GetElementType(); if (typeRef.IsNested) { var declaringType = ResolveType(typeRef.DeclaringType); foreach (var nestedClass in declaringType.NestedClasses) { if (nestedClass.Class != null && TypeRefsAreEqual(nestedClass.Class, typeRef)) { return nestedClass.Class; } } } else { if (typeRef.ResolutionScope is AssemblyDefinition) { targetAssembly = typeRef.ResolutionScope.NETHeader.ParentAssembly; } else if (typeRef.ResolutionScope is AssemblyReference) { targetAssembly = AssemblyResolver.Resolve(typeRef.ResolutionScope as AssemblyReference); } if (targetAssembly == null) { return null; } var typesTable = targetAssembly.NETHeader.TablesHeap.GetTable(MetaDataTableType.TypeDef); foreach (TypeDefinition member in typesTable.Members) { if (TypeRefsAreEqual(member, typeRef)) { return member; } } } return null; }
public override void ClearCache() { _owner = null; _constraint = null; }
public VariableDefinition(string name, int index, TypeReference type) { Index = index; VariableType = type; Name = name; }
public GenericInstanceType(TypeReference typeRef) : base(typeRef) { }
public ByReferenceType(TypeReference typeRef) : base(typeRef) { }
public ArrayType(TypeReference typeRef, int rank, ArrayDimension[] dimensions) : base(typeRef) { Rank = rank; Dimensions = dimensions; }
public CustomModifierType(TypeReference modifierType, TypeReference baseType, bool isRequired) : base(baseType) { ModifierType = modifierType; IsRequired = isRequired; }
public FieldReference(string name, TypeReference declaringType, uint signature) : base(new MetaDataRow(0U, 0U, signature)) { this._name = name; this._declaringType = declaringType; }
public override void LoadCache() { _addmethod = AddMethod; _removemethod = RemoveMethod; _name = Name; _eventType = EventType; }
public EventDefinition(string name, EventAttributes attributes, TypeReference eventType) : base(new MetaDataRow((ushort)attributes, 0U, 0U)) { this._name = name; this._eventType = eventType; }
public override void ClearCache() { _addmethod = null; _removemethod = null; _name = null; _eventType = null; }
public override void LoadCache() { base.LoadCache(); _methodRange = MemberRange.CreateRange<MethodDefinition>(this, 5, NETHeader.TablesHeap.GetTable(MetaDataTableType.Method, false)); _methodRange.LoadCache(); _fieldRange = MemberRange.CreateRange<FieldDefinition>(this, 4, NETHeader.TablesHeap.GetTable(MetaDataTableType.Field, false)); _fieldRange.LoadCache(); _propertyMap = PropertyMap; _eventMap = EventMap; _nestedClasses = NestedClasses; _interfaces = Interfaces; _decltype = DeclaringType as TypeDefinition; _genericparams = GenericParameters; _baseType = BaseType; }
public bool IsBasedOn(TypeReference typeRef) { return BaseType != null && BaseType.FullName == typeRef.FullName; }
public TypeReference[] ReadGenericArguments() { uint number = NETGlobals.ReadCompressedUInt32(this); var genericArguments = new TypeReference[number]; for (int i = 0; i < number; i++) genericArguments[i] = ReadTypeReference(); return genericArguments; }
public override void ClearCache() { _customAttributes = null; _declaringType = null; _pinvokeimpl = null; }
public object ReadCustomAttributeArgumentElement(TypeReference paramType) { if (paramType._elementType == ElementType.None) { // TODO: convert string to type ref: if (paramType.FullName == "System.Type") return ReadUtf8String(); var resolvedTypeDef = paramType.Resolve(); if (resolvedTypeDef != null) { var enumType = resolvedTypeDef.GetEnumType(); if (enumType != null) return ReadCustomAttributeArgumentElement(enumType); } return null; } else { if (paramType._elementType == ElementType.String) return ReadUtf8String(); return ReadPrimitiveValue(paramType._elementType); } }
public override void LoadCache() { _pinvokeimpl = PInvokeImplementation; _customAttributes = CustomAttributes; _declaringType = DeclaringType; }
public ArrayType(TypeReference typeRef) : this(typeRef, 0, null) { }
public InterfaceImplementation(TypeDefinition @class, TypeReference @interface) : base(new MetaDataRow(@class.TableIndex, 0U)) { this._class = @class; this._interface = @interface; }
protected virtual bool TypeRefsAreEqual(TypeReference reference1, TypeReference reference2) { if (reference1 == null || reference2 == null) return false; if ((reference1.Name != reference2.Name) || (reference1.Namespace != reference2.Namespace)) return false; if (reference1.HasGenericParameters != reference2.HasGenericParameters) return false; if (reference1.HasGenericParameters && reference2.HasGenericParameters) { if (reference1.GenericParameters.Length != reference2.GenericParameters.Length) return false; //for (int i = 0; i < reference1.GenericParameters.Length; i++) //{ // if (!GenericParamsAreEqual(reference1.GenericParameters[i], reference2.GenericParameters[i])) // return false; //} } return true; }
public override void ClearCache() { _class = null; _interface = null; }
public PointerType(TypeReference typeRef) : base(typeRef) { }
public override void LoadCache() { _class = Class; _interface = Interface; }
public VariableDefinition(int index, TypeReference type) { Index = index; VariableType = type; Name = ""; }
public PinnedType(TypeReference typeRef) : base(typeRef) { }
public GenericParamConstraint(GenericParameter owner, TypeReference constraint) : base(new MetaDataRow(owner.TableIndex, 0U)) { this._owner = owner; this._constraint = constraint; }
public object ReadCustomAttributeArgumentValue(TypeReference paramType) { if (!paramType.IsArray || !(paramType as ArrayType).IsVector) return ReadCustomAttributeArgumentElement(paramType); // throw new NotImplementedException("Array constructor values are not supported yet."); ushort elementcount = this.ReadUInt16(); object[] elements = new object[elementcount]; for (int i = 0; i < elementcount; i++) elements[i] = ReadCustomAttributeArgumentElement((paramType as ArrayType).OriginalType); return elements; }
public override void LoadCache() { _owner = Owner; _constraint = Constraint; }
public override void ClearCache() { base.ClearCache(); _methodRange = null; _fieldRange = null; _propertyMap = null; _eventMap = null; _nestedClasses = null; _interfaces = null; _decltype = null; _genericparams = null; _baseType = null; }