Beispiel #1
0
        private void AddDummyType(TypeDefinitionTable typeTable, FieldDefinitionTable fieldTable, MethodDefinitionTable methodTable, TypeDefinition type)
        {
            // Add dummy type.
            var typeRow = new MetadataRow <TypeAttributes, uint, uint, uint, uint, uint>
            {
                Column1 = type.Attributes,
                Column2 = _parentBuffer.StringStreamBuffer.GetStringOffset(type.Name),
                Column3 = _parentBuffer.StringStreamBuffer.GetStringOffset(type.Namespace),
                Column4 = 0, // BaseType
                Column5 = _fieldList,
                Column6 = _methodList
            };

            typeTable.Add(typeRow);
            _members.Add(type, typeRow.MetadataToken);

            // Add dummy fields.
            foreach (var field in type.Fields)
            {
                AddDummyField(fieldTable, field);
            }

            _fieldList += (uint)type.Fields.Count;

            // Add dummy methods.
            foreach (var method in type.Methods)
            {
                AddDummyMethod(methodTable, method);
            }

            _methodList += (uint)type.Methods.Count;
        }
Beispiel #2
0
        private void AddDummyField(FieldDefinitionTable fieldTable, FieldDefinition field)
        {
            var fieldRow = new MetadataRow <FieldAttributes, uint, uint>
            {
                Column1 = field.Attributes,
                Column2 = _parentBuffer.StringStreamBuffer.GetStringOffset(field.Name),
                Column3 = 0 // Signature.
            };

            fieldTable.Add(fieldRow);
            _members.Add(field, fieldRow.MetadataToken);
        }
Beispiel #3
0
        private void FinalizeTypeRow(TypeDefinition type, MetadataRow <TypeAttributes, uint, uint, uint, uint, uint> typeRow, FieldDefinitionTable fieldTable,
                                     MethodDefinitionTable methodTable)
        {
            // Add base type.
            if (type.BaseType != null)
            {
                var baseToken = GetTypeToken(type.BaseType);
                typeRow.Column4 = _tableStream.GetIndexEncoder(CodedIndex.TypeDefOrRef).EncodeToken(baseToken);
            }

            // Finalize fields.
            foreach (var field in type.Fields)
            {
                var fieldRow = fieldTable[(int)(GetNewToken(field).Rid - 1)];
                FinalizeFieldRow(field, fieldRow);
            }

            // Finalize methods.
            foreach (var method in type.Methods)
            {
                var methodRow = methodTable[(int)(GetNewToken(method).Rid - 1)];
                FinalizeMethodRow(method, methodRow);
            }

            // Add nested classes.
            foreach (var nestedClass in type.NestedClasses)
            {
                AddNestedClass(nestedClass);
            }

            // Add interfaces.
            foreach (var @interface in type.Interfaces)
            {
                AddInterface(@interface);
            }

            // Add method implementations.
            foreach (var implementation in type.MethodImplementations)
            {
                AddImplementation(implementation);
            }

            // Add class layout if present.
            if (type.ClassLayout != null)
            {
                AddClassLayout(type.ClassLayout);
            }

            // Add property map if present.
            if (type.PropertyMap != null)
            {
                AddPropertyMap(type.PropertyMap);
            }

            // Add event map if present.
            if (type.EventMap != null)
            {
                AddEventMap(type.EventMap);
            }

            AddGenericParmeters(type);
            AddCustomAttributes(type);
            AddSecurityDeclarations(type);
        }