public SerializedMetadata(
     MetadataSizes sizes,
     BlobBuilder stringHeap,
     ImmutableArray<int> stringMap)
 {
     Sizes = sizes;
     StringHeap = stringHeap;
     StringMap = stringMap;
 }

        internal SerializedMetadata GetSerializedMetadata(ImmutableArray<int> externalRowCounts, int metadataVersionByteCount, bool isStandaloneDebugMetadata)
        {
            var stringHeapBuilder = new HeapBlobBuilder(_stringHeapCapacity);
            var stringMap = SerializeStringHeap(stringHeapBuilder, _strings, _stringHeapStartOffset);

            Debug.Assert(HeapIndex.UserString == 0);
            Debug.Assert((int)HeapIndex.String == 1);
            Debug.Assert((int)HeapIndex.Blob == 2);
            Debug.Assert((int)HeapIndex.Guid == 3);

            var heapSizes = ImmutableArray.Create(
                _userStringBuilder.Count,
                stringHeapBuilder.Count,
                _blobHeapSize,
                _guidBuilder.Count);

            var sizes = new MetadataSizes(GetRowCounts(), externalRowCounts, heapSizes, metadataVersionByteCount, isStandaloneDebugMetadata);

            return new SerializedMetadata(sizes, stringHeapBuilder, stringMap);
        }

 private void SerializeCustomDebugInformationTable(BlobBuilder writer, MetadataSizes metadataSizes)
 {
     // Note: we can sort the table at this point since no other table can reference its rows via RowId or CodedIndex (which would need updating otherwise).
     // OrderBy performs a stable sort, so multiple attributes with the same parent and kind will be sorted in the order they were added to the table.
     foreach (CustomDebugInformationRow row in _customDebugInformationTable.OrderBy((x, y) =>
     {
         int result = (int)x.Parent - (int)y.Parent;
         return (result != 0) ? result : MetadataTokens.GetHeapOffset(x.Kind) - MetadataTokens.GetHeapOffset(y.Kind);
     }))
     {
         writer.WriteReference(row.Parent, metadataSizes.HasCustomDebugInformationSize);
         writer.WriteReference((uint)GetHeapOffset(row.Kind), metadataSizes.GuidIndexSize);
         writer.WriteReference((uint)GetHeapOffset(row.Value), metadataSizes.BlobIndexSize);
     }
 }

 private void SerializeImportScopeTable(BlobBuilder writer, MetadataSizes metadataSizes)
 {
     foreach (var row in _importScopeTable)
     {
         writer.WriteReference(row.Parent, metadataSizes.ImportScopeIndexSize);
         writer.WriteReference((uint)GetHeapOffset(row.Imports), metadataSizes.BlobIndexSize);
     }
 }

 private void SerializeLocalVariableTable(BlobBuilder writer, MetadataSizes metadataSizes)
 {
     foreach (var row in _localVariableTable)
     {
         writer.WriteUInt16(row.Attributes);
         writer.WriteUInt16(row.Index);
         writer.WriteReference((uint)GetHeapOffset(row.Name), metadataSizes.StringIndexSize);
     }
 }

 private void SerializeMethodDebugInformationTable(BlobBuilder writer, MetadataSizes metadataSizes)
 {
     foreach (var row in _methodDebugInformationTable)
     {
         writer.WriteReference(row.Document, metadataSizes.DocumentIndexSize);
         writer.WriteReference((uint)GetHeapOffset(row.SequencePoints), metadataSizes.BlobIndexSize);
     }
 }

 private void SerializeMethodSpecTable(BlobBuilder writer, MetadataSizes metadataSizes)
 {
     foreach (MethodSpecRow methodSpec in _methodSpecTable)
     {
         writer.WriteReference(methodSpec.Method, metadataSizes.MethodDefOrRefCodedIndexSize);
         writer.WriteReference((uint)GetHeapOffset(methodSpec.Instantiation), metadataSizes.BlobIndexSize);
     }
 }

        private void SerializeGenericParamTable(BlobBuilder writer, MetadataSizes metadataSizes)
        {
#if DEBUG
            for (int i = 1; i < _genericParamTable.Count; i++)
            {
                Debug.Assert(
                    _genericParamTable[i - 1].Owner < _genericParamTable[i].Owner ||
                    _genericParamTable[i - 1].Owner == _genericParamTable[i].Owner && _genericParamTable[i - 1].Number < _genericParamTable[i].Number);
            }
#endif            
            foreach (GenericParamRow genericParam in _genericParamTable)
            {
                writer.WriteUInt16(genericParam.Number);
                writer.WriteUInt16(genericParam.Flags);
                writer.WriteReference(genericParam.Owner, metadataSizes.TypeOrMethodDefCodedIndexSize);
                writer.WriteReference((uint)GetHeapOffset(genericParam.Name), metadataSizes.StringIndexSize);
            }
        }

        private void SerializeMethodImplTable(BlobBuilder writer, MetadataSizes metadataSizes)
        {
#if DEBUG
            for (int i = 1; i < _methodImplTable.Count; i++)
            {
                Debug.Assert(_methodImplTable[i - 1].Class <= _methodImplTable[i].Class);
            }
#endif
            foreach (MethodImplRow methodImpl in _methodImplTable)
            {
                writer.WriteReference(methodImpl.Class, metadataSizes.TypeDefIndexSize);
                writer.WriteReference(methodImpl.MethodBody, metadataSizes.MethodDefOrRefCodedIndexSize);
                writer.WriteReference(methodImpl.MethodDecl, metadataSizes.MethodDefOrRefCodedIndexSize);
            }
        }

 private void SerializeMethodSemanticsTable(BlobBuilder writer, MetadataSizes metadataSizes)
 {
     // Note: we can sort the table at this point since no other table can reference its rows via RowId or CodedIndex (which would need updating otherwise).
     // OrderBy performs a stable sort, so multiple attributes with the same parent will be sorted in the order they were added to the table.
     var ordered = _methodSemanticsTableNeedsSorting ? (IEnumerable<MethodSemanticsRow>)_methodSemanticsTable.OrderBy((x, y) => (int)x.Association - (int)y.Association) : _methodSemanticsTable;
     
     foreach (MethodSemanticsRow methodSemantic in ordered)
     {
         writer.WriteUInt16(methodSemantic.Semantic);
         writer.WriteReference(methodSemantic.Method, metadataSizes.MethodDefIndexSize);
         writer.WriteReference(methodSemantic.Association, metadataSizes.HasSemanticsCodedIndexSize);
     }
 }

 private void SerializePropertyTable(BlobBuilder writer, MetadataSizes metadataSizes)
 {
     foreach (PropertyRow property in _propertyTable)
     {
         writer.WriteUInt16(property.PropFlags);
         writer.WriteReference((uint)GetHeapOffset(property.Name), metadataSizes.StringIndexSize);
         writer.WriteReference((uint)GetHeapOffset(property.Type), metadataSizes.BlobIndexSize);
     }
 }

 private void SerializePropertyMapTable(BlobBuilder writer, MetadataSizes metadataSizes)
 {
     foreach (PropertyMapRow propertyMap in _propertyMapTable)
     {
         writer.WriteReference(propertyMap.Parent, metadataSizes.TypeDefIndexSize);
         writer.WriteReference(propertyMap.PropertyList, metadataSizes.PropertyDefIndexSize);
     }
 }

 private void SerializeEventTable(BlobBuilder writer, MetadataSizes metadataSizes)
 {
     foreach (EventRow eventRow in _eventTable)
     {
         writer.WriteUInt16(eventRow.EventFlags);
         writer.WriteReference((uint)GetHeapOffset(eventRow.Name), metadataSizes.StringIndexSize);
         writer.WriteReference(eventRow.EventType, metadataSizes.TypeDefOrRefCodedIndexSize);
     }
 }

 private void SerializeEventMapTable(BlobBuilder writer, MetadataSizes metadataSizes)
 {
     foreach (EventMapRow eventMap in _eventMapTable)
     {
         writer.WriteReference(eventMap.Parent, metadataSizes.TypeDefIndexSize);
         writer.WriteReference(eventMap.EventList, metadataSizes.EventDefIndexSize);
     }
 }

 private void SerializeStandAloneSigTable(BlobBuilder writer, MetadataSizes metadataSizes)
 {
     foreach (StandaloneSigRow row in _standAloneSigTable)
     {
         writer.WriteReference((uint)GetHeapOffset(row.Signature), metadataSizes.BlobIndexSize);
     }
 }

 private void SerializeManifestResourceTable(BlobBuilder writer, MetadataSizes metadataSizes)
 {
     foreach (ManifestResourceRow manifestResource in _manifestResourceTable)
     {
         writer.WriteUInt32(manifestResource.Offset);
         writer.WriteUInt32(manifestResource.Flags);
         writer.WriteReference((uint)GetHeapOffset(manifestResource.Name), metadataSizes.StringIndexSize);
         writer.WriteReference(manifestResource.Implementation, metadataSizes.ImplementationCodedIndexSize);
     }
 }

        private void SerializeNestedClassTable(BlobBuilder writer, MetadataSizes metadataSizes)
        {
#if DEBUG
            for (int i = 1; i < _nestedClassTable.Count; i++)
            {
                Debug.Assert(_nestedClassTable[i - 1].NestedClass <= _nestedClassTable[i].NestedClass);
            }
#endif
            foreach (NestedClassRow nestedClass in _nestedClassTable)
            {
                writer.WriteReference(nestedClass.NestedClass, metadataSizes.TypeDefIndexSize);
                writer.WriteReference(nestedClass.EnclosingClass, metadataSizes.TypeDefIndexSize);
            }
        }

 private void SerializeModuleRefTable(BlobBuilder writer, MetadataSizes metadataSizes)
 {
     foreach (ModuleRefRow moduleRef in _moduleRefTable)
     {
         writer.WriteReference((uint)GetHeapOffset(moduleRef.Name), metadataSizes.StringIndexSize);
     }
 }

        private void SerializeGenericParamConstraintTable(BlobBuilder writer, MetadataSizes metadataSizes)
        {
#if DEBUG
            for (int i = 1; i < _genericParamConstraintTable.Count; i++)
            {
                Debug.Assert(_genericParamConstraintTable[i - 1].Owner <= _genericParamConstraintTable[i].Owner);
            }
#endif
            foreach (GenericParamConstraintRow genericParamConstraint in _genericParamConstraintTable)
            {
                writer.WriteReference(genericParamConstraint.Owner, metadataSizes.GenericParamIndexSize);
                writer.WriteReference(genericParamConstraint.Constraint, metadataSizes.TypeDefOrRefCodedIndexSize);
            }
        }

 private void SerializeTypeSpecTable(BlobBuilder writer, MetadataSizes metadataSizes)
 {
     foreach (TypeSpecRow typeSpec in _typeSpecTable)
     {
         writer.WriteReference((uint)GetHeapOffset(typeSpec.Signature), metadataSizes.BlobIndexSize);
     }
 }