diff --git a/src/AsmResolver.DotNet/Builder/DotNetDirectoryBuffer.MemberTree.cs b/src/AsmResolver.DotNet/Builder/DotNetDirectoryBuffer.MemberTree.cs
index 8e2e2ee27..617253eef 100644
--- a/src/AsmResolver.DotNet/Builder/DotNetDirectoryBuffer.MemberTree.cs
+++ b/src/AsmResolver.DotNet/Builder/DotNetDirectoryBuffer.MemberTree.cs
@@ -132,6 +132,9 @@ public void DefineTypes(IEnumerable<TypeDefinition> types)
             var typeDefTable = Metadata.TablesStream.GetTable<TypeDefinitionRow>(TableIndex.TypeDef);
             var nestedClassTable = Metadata.TablesStream.GetSortedTable<TypeDefinition, NestedClassRow>(TableIndex.NestedClass);
 
+            if (types is ICollection<TypeDefinition> collection)
+                typeDefTable.EnsureCapacity(typeDefTable.Count + collection.Count);
+
             foreach (var type in types)
             {
                 // At this point, we might not have added all type defs/refs/specs yet, so we cannot determine
@@ -177,6 +180,8 @@ public void DefineTypes(IEnumerable<TypeDefinition> types)
         public void DefineFields(IEnumerable<FieldDefinition> fields)
         {
             var table = Metadata.TablesStream.GetTable<FieldDefinitionRow>(TableIndex.Field);
+            if (fields is ICollection<FieldDefinition> collection)
+                table.EnsureCapacity(table.Count + collection.Count);
 
             foreach (var field in fields)
             {
@@ -197,6 +202,8 @@ public void DefineFields(IEnumerable<FieldDefinition> fields)
         public void DefineMethods(IEnumerable<MethodDefinition> methods)
         {
             var table = Metadata.TablesStream.GetTable<MethodDefinitionRow>(TableIndex.Method);
+            if (methods is ICollection<MethodDefinition> collection)
+                table.EnsureCapacity(table.Count + collection.Count);
 
             foreach (var method in methods)
             {
@@ -227,6 +234,8 @@ public void DefineMethods(IEnumerable<MethodDefinition> methods)
         public void DefineParameters(IEnumerable<ParameterDefinition> parameters)
         {
             var table = Metadata.TablesStream.GetTable<ParameterDefinitionRow>(TableIndex.Param);
+            if (parameters is ICollection<ParameterDefinition> collection)
+                table.EnsureCapacity(table.Count + collection.Count);
 
             foreach (var parameter in parameters)
             {
@@ -247,6 +256,8 @@ public void DefineParameters(IEnumerable<ParameterDefinition> parameters)
         public void DefineProperties(IEnumerable<PropertyDefinition> properties)
         {
             var table = Metadata.TablesStream.GetTable<PropertyDefinitionRow>(TableIndex.Property);
+            if (properties is ICollection<PropertyDefinition> collection)
+                table.EnsureCapacity(table.Count + collection.Count);
 
             foreach (var property in properties)
             {
@@ -267,6 +278,8 @@ public void DefineProperties(IEnumerable<PropertyDefinition> properties)
         public void DefineEvents(IEnumerable<EventDefinition> events)
         {
             var table = Metadata.TablesStream.GetTable<EventDefinitionRow>(TableIndex.Event);
+            if (events is ICollection<EventDefinition> collection)
+                table.EnsureCapacity(table.Count + collection.Count);
 
             foreach (var @event in events)
             {
@@ -299,6 +312,17 @@ public void FinalizeTypes()
             uint propertyList = 1;
             uint eventList = 1;
 
+            tablesStream.GetTable<FieldPointerRow>(TableIndex.FieldPtr)
+                .EnsureCapacity(tablesStream.GetTable<FieldDefinitionRow>(TableIndex.Field).Count);
+            tablesStream.GetTable<MethodPointerRow>(TableIndex.MethodPtr)
+                .EnsureCapacity(tablesStream.GetTable<MethodDefinitionRow>(TableIndex.Method).Count);
+            tablesStream.GetTable<ParameterPointerRow>(TableIndex.ParamPtr)
+                .EnsureCapacity(tablesStream.GetTable<ParameterDefinitionRow>(TableIndex.Param).Count);
+            tablesStream.GetTable<PropertyPointerRow>(TableIndex.PropertyPtr)
+                .EnsureCapacity(tablesStream.GetTable<PropertyDefinitionRow>(TableIndex.Property).Count);
+            tablesStream.GetTable<EventPointerRow>(TableIndex.EventPtr)
+                .EnsureCapacity(tablesStream.GetTable<EventDefinitionRow>(TableIndex.Event).Count);
+
             for (uint rid = 1; rid <= typeDefTable.Count; rid++)
             {
                 var typeToken = new MetadataToken(TableIndex.TypeDef, rid);
diff --git a/src/AsmResolver.DotNet/Builder/Metadata/Tables/DistinctMetadataTableBuffer.cs b/src/AsmResolver.DotNet/Builder/Metadata/Tables/DistinctMetadataTableBuffer.cs
index 2fba58233..2a7ecdef5 100644
--- a/src/AsmResolver.DotNet/Builder/Metadata/Tables/DistinctMetadataTableBuffer.cs
+++ b/src/AsmResolver.DotNet/Builder/Metadata/Tables/DistinctMetadataTableBuffer.cs
@@ -44,6 +44,16 @@ public TRow this[uint rid]
             }
         }
 
+        /// <inheritdoc />
+        public void EnsureCapacity(int capacity)
+        {
+            _underlyingBuffer.EnsureCapacity(capacity);
+
+#if NETSTANDARD2_1_OR_GREATER
+            _entries.EnsureCapacity(capacity);
+#endif
+        }
+
         /// <inheritdoc />
         public ref TRow GetRowRef(uint rid) => ref _underlyingBuffer.GetRowRef(rid);
 
diff --git a/src/AsmResolver.DotNet/Builder/Metadata/Tables/IMetadataTableBuffer.cs b/src/AsmResolver.DotNet/Builder/Metadata/Tables/IMetadataTableBuffer.cs
index bcf1b8bfd..66a6c1836 100644
--- a/src/AsmResolver.DotNet/Builder/Metadata/Tables/IMetadataTableBuffer.cs
+++ b/src/AsmResolver.DotNet/Builder/Metadata/Tables/IMetadataTableBuffer.cs
@@ -44,6 +44,12 @@ TRow this[uint rid]
             set;
         }
 
+        /// <summary>
+        /// Ensures the capacity of the table buffer is at least the provided amount of elements.
+        /// </summary>
+        /// <param name="capacity">The number of elements to store.</param>
+        void EnsureCapacity(int capacity);
+
         /// <summary>
         /// Gets or sets a reference to a row in the metadata table.
         /// </summary>
diff --git a/src/AsmResolver.DotNet/Builder/Metadata/Tables/UnsortedMetadataTableBuffer.cs b/src/AsmResolver.DotNet/Builder/Metadata/Tables/UnsortedMetadataTableBuffer.cs
index e94a81d44..8e9d4395f 100644
--- a/src/AsmResolver.DotNet/Builder/Metadata/Tables/UnsortedMetadataTableBuffer.cs
+++ b/src/AsmResolver.DotNet/Builder/Metadata/Tables/UnsortedMetadataTableBuffer.cs
@@ -36,6 +36,13 @@ public virtual TRow this[uint rid]
             set => _entries[(int) (rid - 1)] = value;
         }
 
+        /// <inheritdoc />
+        public void EnsureCapacity(int capacity)
+        {
+            if (_entries.Capacity < capacity)
+                _entries.Capacity = capacity;
+        }
+
         /// <inheritdoc />
         public ref TRow GetRowRef(uint rid) => ref _entries.GetElementRef((int)(rid - 1));
 
@@ -49,6 +56,9 @@ public virtual MetadataToken Add(in TRow row)
         /// <inheritdoc />
         public void FlushToTable()
         {
+            if (_table.Capacity < _entries.Count)
+                _table.Capacity = _entries.Count;
+
             foreach (var row in _entries)
                 _table.Add(row);
         }
diff --git a/src/AsmResolver.DotNet/Collections/MethodSemanticsCollection.cs b/src/AsmResolver.DotNet/Collections/MethodSemanticsCollection.cs
index 0310136af..35cfefda3 100644
--- a/src/AsmResolver.DotNet/Collections/MethodSemanticsCollection.cs
+++ b/src/AsmResolver.DotNet/Collections/MethodSemanticsCollection.cs
@@ -20,6 +20,16 @@ public MethodSemanticsCollection(IHasSemantics owner)
         {
         }
 
+        /// <summary>
+        /// Creates a new instance of the <see cref="MethodSemanticsCollection"/> class.
+        /// </summary>
+        /// <param name="owner">The owner of the collection.</param>
+        /// <param name="capacity">The initial number of elements the collection can store.</param>
+        public MethodSemanticsCollection(IHasSemantics owner, int capacity)
+            : base(owner, capacity)
+        {
+        }
+
         internal bool ValidateMembership
         {
             get;
diff --git a/src/AsmResolver.DotNet/Serialized/SerializedGenericParameter.cs b/src/AsmResolver.DotNet/Serialized/SerializedGenericParameter.cs
index 841c47adc..3d876c1d5 100644
--- a/src/AsmResolver.DotNet/Serialized/SerializedGenericParameter.cs
+++ b/src/AsmResolver.DotNet/Serialized/SerializedGenericParameter.cs
@@ -58,10 +58,11 @@ public SerializedGenericParameter(ModuleReaderContext context, MetadataToken tok
         /// <inheritdoc />
         protected override IList<GenericParameterConstraint> GetConstraints()
         {
-            var result = new OwnedCollection<GenericParameter, GenericParameterConstraint>(this);
-
             var module = _context.ParentModule;
-            foreach (uint rid in module.GetGenericParameterConstraints(MetadataToken))
+            var rids = module.GetGenericParameterConstraints(MetadataToken);
+            var result = new OwnedCollection<GenericParameter, GenericParameterConstraint>(this, rids.Count);
+
+            foreach (uint rid in rids)
             {
                 var constraintToken = new MetadataToken(TableIndex.GenericParamConstraint, rid);
                 result.Add((GenericParameterConstraint) module.LookupMember(constraintToken));
diff --git a/src/AsmResolver.DotNet/Serialized/SerializedMethodDefinition.cs b/src/AsmResolver.DotNet/Serialized/SerializedMethodDefinition.cs
index ed4ed367c..c35f28b9e 100644
--- a/src/AsmResolver.DotNet/Serialized/SerializedMethodDefinition.cs
+++ b/src/AsmResolver.DotNet/Serialized/SerializedMethodDefinition.cs
@@ -81,9 +81,10 @@ protected override IList<SecurityDeclaration> GetSecurityDeclarations() =>
         /// <inheritdoc />
         protected override IList<ParameterDefinition> GetParameterDefinitions()
         {
-            var result = new OwnedCollection<MethodDefinition, ParameterDefinition>(this);
+            var parameterRange = _context.ParentModule.GetParameterRange(MetadataToken.Rid);
+            var result = new OwnedCollection<MethodDefinition, ParameterDefinition>(this, parameterRange.Count);
 
-            foreach (var token in _context.ParentModule.GetParameterRange(MetadataToken.Rid))
+            foreach (var token in parameterRange)
             {
                 if (_context.ParentModule.TryLookupMember(token, out var member) && member is ParameterDefinition parameter)
                     result.Add(parameter);
@@ -108,9 +109,10 @@ protected override IList<ParameterDefinition> GetParameterDefinitions()
         /// <inheritdoc />
         protected override IList<GenericParameter> GetGenericParameters()
         {
-            var result = new OwnedCollection<IHasGenericParameters, GenericParameter>(this);
+            var rids = _context.ParentModule.GetGenericParameters(MetadataToken);
+            var result = new OwnedCollection<IHasGenericParameters, GenericParameter>(this, rids.Count);
 
-            foreach (uint rid in _context.ParentModule.GetGenericParameters(MetadataToken))
+            foreach (uint rid in rids)
             {
                 if (_context.ParentModule.TryLookupMember(new MetadataToken(TableIndex.GenericParam, rid), out var member)
                     && member is GenericParameter genericParameter)
diff --git a/src/AsmResolver.DotNet/Serialized/SerializedModuleDefinition.Metadata.cs b/src/AsmResolver.DotNet/Serialized/SerializedModuleDefinition.Metadata.cs
index f7e13d09f..e81e548aa 100644
--- a/src/AsmResolver.DotNet/Serialized/SerializedModuleDefinition.Metadata.cs
+++ b/src/AsmResolver.DotNet/Serialized/SerializedModuleDefinition.Metadata.cs
@@ -59,7 +59,7 @@ private OneToManyRelation<uint, uint> InitializeTypeDefinitionTree()
             return typeDefTree;
         }
 
-        internal IEnumerable<uint> GetNestedTypeRids(uint enclosingTypeRid)
+        internal ICollection<uint> GetNestedTypeRids(uint enclosingTypeRid)
         {
             EnsureTypeDefinitionTreeInitialized();
             return _typeDefTree.GetValues(enclosingTypeRid);
@@ -107,8 +107,8 @@ private void InitializeMethodSemantics()
             var semanticsTable = tablesStream.GetTable<MethodSemanticsRow>(TableIndex.MethodSemantics);
             var encoder = tablesStream.GetIndexEncoder(CodedIndex.HasSemantics);
 
-            var semantics = new OneToManyRelation<MetadataToken, uint>();
-            var semanticMethods = new Dictionary<uint, MetadataToken>();
+            var semantics = new OneToManyRelation<MetadataToken, uint>(semanticsTable.Count);
+            var semanticMethods = new Dictionary<uint, MetadataToken>(semanticsTable.Count);
             for (int i = 0; i < semanticsTable.Count; i++)
             {
                 var methodSemanticsRow = semanticsTable[i];
@@ -123,7 +123,7 @@ private void InitializeMethodSemantics()
             Interlocked.CompareExchange(ref _semanticMethods, semanticMethods, null);
         }
 
-        internal IEnumerable<uint> GetMethodSemantics(MetadataToken owner)
+        internal ICollection<uint> GetMethodSemantics(MetadataToken owner)
         {
             EnsureMethodSemanticsInitialized();
             return _semantics.GetValues(owner);
@@ -155,7 +155,7 @@ private OneToOneRelation<MetadataToken, uint> GetConstants()
             var constantTable = tablesStream.GetTable<ConstantRow>(TableIndex.Constant);
             var encoder = tablesStream.GetIndexEncoder(CodedIndex.HasConstant);
 
-            var constants = new OneToOneRelation<MetadataToken, uint>();
+            var constants = new OneToOneRelation<MetadataToken, uint>(constantTable.Count);
             for (int i = 0; i < constantTable.Count; i++)
             {
                 var ownerToken = encoder.DecodeIndex(constantTable[i].Parent);
@@ -199,7 +199,7 @@ private OneToManyRelation<MetadataToken, uint> InitializeCustomAttributes()
             var attributeTable = tablesStream.GetTable<CustomAttributeRow>(TableIndex.CustomAttribute);
             var encoder = tablesStream.GetIndexEncoder(CodedIndex.HasCustomAttribute);
 
-            var customAttributes = new OneToManyRelation<MetadataToken, uint>();
+            var customAttributes = new OneToManyRelation<MetadataToken, uint>(attributeTable.Count);
             for (int i = 0; i < attributeTable.Count; i++)
             {
                 var ownerToken = encoder.DecodeIndex(attributeTable[i].Parent);
@@ -228,9 +228,10 @@ internal MetadataToken GetCustomAttributeOwner(uint attributeRid)
         internal IList<CustomAttribute> GetCustomAttributeCollection(IHasCustomAttribute owner)
         {
             EnsureCustomAttributesInitialized();
-            var result = new OwnedCollection<IHasCustomAttribute, CustomAttribute>(owner);
+            var rids = _customAttributes.GetValues(owner.MetadataToken);
+            var result = new OwnedCollection<IHasCustomAttribute, CustomAttribute>(owner, rids.Count);
 
-            foreach (uint rid in _customAttributes.GetValues(owner.MetadataToken))
+            foreach (uint rid in rids)
             {
                 var attribute = (CustomAttribute) LookupMember(new MetadataToken(TableIndex.CustomAttribute, rid));
                 result.Add(attribute);
@@ -252,7 +253,7 @@ private OneToManyRelation<MetadataToken, uint> InitializeSecurityDeclarations()
             var declarationTable = tablesStream.GetTable<SecurityDeclarationRow>(TableIndex.DeclSecurity);
             var encoder = tablesStream.GetIndexEncoder(CodedIndex.HasDeclSecurity);
 
-            var securityDeclarations = new OneToManyRelation<MetadataToken, uint>();
+            var securityDeclarations = new OneToManyRelation<MetadataToken, uint>(declarationTable.Count);
             for (int i = 0; i < declarationTable.Count; i++)
             {
                 var ownerToken = encoder.DecodeIndex(declarationTable[i].Parent);
@@ -272,9 +273,10 @@ internal MetadataToken GetSecurityDeclarationOwner(uint attributeRid)
         internal IList<SecurityDeclaration> GetSecurityDeclarationCollection(IHasSecurityDeclaration owner)
         {
             EnsureSecurityDeclarationsInitialized();
-            var result = new OwnedCollection<IHasSecurityDeclaration, SecurityDeclaration>(owner);
+            var rids = _securityDeclarations.GetValues(owner.MetadataToken);
+            var result = new OwnedCollection<IHasSecurityDeclaration, SecurityDeclaration>(owner, rids.Count);
 
-            foreach (uint rid in _securityDeclarations.GetValues(owner.MetadataToken))
+            foreach (uint rid in rids)
             {
                 var attribute = (SecurityDeclaration) LookupMember(new MetadataToken(TableIndex.DeclSecurity, rid));
                 result.Add(attribute);
@@ -296,7 +298,7 @@ private OneToManyRelation<MetadataToken, uint> InitializeGenericParameters()
             var parameterTable = tablesStream.GetTable<GenericParameterRow>(TableIndex.GenericParam);
             var encoder = tablesStream.GetIndexEncoder(CodedIndex.TypeOrMethodDef);
 
-            var genericParameters = new OneToManyRelation<MetadataToken, uint>();
+            var genericParameters = new OneToManyRelation<MetadataToken, uint>(parameterTable.Count);
             for (int i = 0; i < parameterTable.Count; i++)
             {
                 var ownerToken = encoder.DecodeIndex(parameterTable[i].Owner);
@@ -331,7 +333,7 @@ private OneToManyRelation<MetadataToken, uint> InitializeGenericParameterConstra
             var tablesStream = DotNetDirectory.Metadata!.GetStream<TablesStream>();
             var constraintTable = tablesStream.GetTable<GenericParameterConstraintRow>(TableIndex.GenericParamConstraint);
 
-            var constraints = new OneToManyRelation<MetadataToken, uint>();
+            var constraints = new OneToManyRelation<MetadataToken, uint>(constraintTable.Count);
             for (int i = 0; i < constraintTable.Count; i++)
             {
                 var ownerToken = new MetadataToken(TableIndex.GenericParam, constraintTable[i].Owner);
@@ -366,7 +368,7 @@ private OneToManyRelation<MetadataToken, uint> InitializeInterfaces()
             var tablesStream = DotNetDirectory.Metadata!.GetStream<TablesStream>();
             var interfaceImplTable = tablesStream.GetTable<InterfaceImplementationRow>(TableIndex.InterfaceImpl);
 
-            var interfaces = new OneToManyRelation<MetadataToken, uint>();
+            var interfaces = new OneToManyRelation<MetadataToken, uint>(interfaceImplTable.Count);
             for (int i = 0; i < interfaceImplTable.Count; i++)
             {
                 var ownerToken = new MetadataToken(TableIndex.TypeDef, interfaceImplTable[i].Class);
@@ -401,7 +403,7 @@ private OneToManyRelation<MetadataToken, uint> InitializeMethodImplementations()
             var tablesStream = DotNetDirectory.Metadata!.GetStream<TablesStream>();
             var methodImplTable = tablesStream.GetTable<MethodImplementationRow>(TableIndex.MethodImpl);
 
-            var methodImplementations = new OneToManyRelation<MetadataToken, uint>();
+            var methodImplementations = new OneToManyRelation<MetadataToken, uint>(methodImplTable.Count);
             for (int i = 0; i < methodImplTable.Count; i++)
             {
                 var ownerToken = new MetadataToken(TableIndex.TypeDef, methodImplTable[i].Class);
@@ -430,7 +432,7 @@ private OneToOneRelation<MetadataToken, uint> InitializeClassLayouts()
             var tablesStream = DotNetDirectory.Metadata!.GetStream<TablesStream>();
             var layoutTable = tablesStream.GetTable<ClassLayoutRow>(TableIndex.ClassLayout);
 
-            var layouts = new OneToOneRelation<MetadataToken, uint>();
+            var layouts = new OneToOneRelation<MetadataToken, uint>(layoutTable.Count);
             for (int i = 0; i < layoutTable.Count; i++)
             {
                 var ownerToken = new MetadataToken(TableIndex.TypeDef, layoutTable[i].Parent);
@@ -460,7 +462,7 @@ private OneToOneRelation<MetadataToken, uint> InitializeImplementationMaps()
             var mapTable = tablesStream.GetTable<ImplementationMapRow>(TableIndex.ImplMap);
             var encoder = tablesStream.GetIndexEncoder(CodedIndex.TypeOrMethodDef);
 
-            var maps = new OneToOneRelation<MetadataToken, uint>();
+            var maps = new OneToOneRelation<MetadataToken, uint>(mapTable.Count);
             for (int i = 0; i < mapTable.Count; i++)
             {
                 var ownerToken = encoder.DecodeIndex(mapTable[i].MemberForwarded);
@@ -495,7 +497,7 @@ private OneToOneRelation<MetadataToken, uint> InitializeFieldRvas()
             var tablesStream = DotNetDirectory.Metadata!.GetStream<TablesStream>();
             var rvaTable = tablesStream.GetTable<FieldRvaRow>(TableIndex.FieldRva);
 
-            var rvas = new OneToOneRelation<MetadataToken, uint>();
+            var rvas = new OneToOneRelation<MetadataToken, uint>(rvaTable.Count);
             for (int i = 0; i < rvaTable.Count; i++)
             {
                 var ownerToken = new MetadataToken(TableIndex.Field, rvaTable[i].Field);
@@ -525,7 +527,7 @@ private OneToOneRelation<MetadataToken, uint> InitializeFieldMarshals()
             var marshalTable = tablesStream.GetTable<FieldMarshalRow>(TableIndex.FieldMarshal);
             var encoder = tablesStream.GetIndexEncoder(CodedIndex.HasFieldMarshal);
 
-            var marshals = new OneToOneRelation<MetadataToken, uint>();
+            var marshals = new OneToOneRelation<MetadataToken, uint>(marshalTable.Count);
             for (int i = 0; i < marshalTable.Count; i++)
             {
                 var ownerToken = encoder.DecodeIndex(marshalTable[i].Parent);
@@ -571,7 +573,7 @@ private OneToOneRelation<MetadataToken, uint> InitializeFieldLayouts()
             var tablesStream = DotNetDirectory.Metadata!.GetStream<TablesStream>();
             var layoutTable = tablesStream.GetTable<FieldLayoutRow>(TableIndex.FieldLayout);
 
-            var fieldLayouts = new OneToOneRelation<MetadataToken, uint>();
+            var fieldLayouts = new OneToOneRelation<MetadataToken, uint>(layoutTable.Count);
             for (int i = 0; i < layoutTable.Count; i++)
             {
                 var ownerToken = new MetadataToken(TableIndex.Field, layoutTable[i].Field);
diff --git a/src/AsmResolver.DotNet/Serialized/SerializedModuleDefinition.cs b/src/AsmResolver.DotNet/Serialized/SerializedModuleDefinition.cs
index e147de1e8..5ed4f0d4a 100644
--- a/src/AsmResolver.DotNet/Serialized/SerializedModuleDefinition.cs
+++ b/src/AsmResolver.DotNet/Serialized/SerializedModuleDefinition.cs
@@ -204,12 +204,18 @@ protected override IList<TypeDefinition> GetTopLevelTypes()
         {
             EnsureTypeDefinitionTreeInitialized();
 
-            var types = new OwnedCollection<ModuleDefinition, TypeDefinition>(this);
-
             var typeDefTable = ReaderContext.Metadata
                 .GetStream<TablesStream>()
                 .GetTable<TypeDefinitionRow>(TableIndex.TypeDef);
 
+            int nestedTypeCount = ReaderContext.Metadata
+                .GetStream<TablesStream>()
+                .GetTable(TableIndex.NestedClass)
+                .Count;
+
+            var types = new OwnedCollection<ModuleDefinition, TypeDefinition>(this,
+                typeDefTable.Count - nestedTypeCount);
+
             for (int i = 0; i < typeDefTable.Count; i++)
             {
                 uint rid = (uint) i + 1;
@@ -226,12 +232,12 @@ protected override IList<TypeDefinition> GetTopLevelTypes()
         /// <inheritdoc />
         protected override IList<AssemblyReference> GetAssemblyReferences()
         {
-            var result = new OwnedCollection<ModuleDefinition, AssemblyReference>(this);
-
             var table = ReaderContext.Metadata
                 .GetStream<TablesStream>()
                 .GetTable<AssemblyReferenceRow>(TableIndex.AssemblyRef);
 
+            var result = new OwnedCollection<ModuleDefinition, AssemblyReference>(this, table.Count);
+
             // Don't use the member factory here, this method may be called before the member factory is initialized.
             for (int i = 0; i < table.Count; i++)
             {
@@ -245,12 +251,12 @@ protected override IList<AssemblyReference> GetAssemblyReferences()
         /// <inheritdoc />
         protected override IList<ModuleReference> GetModuleReferences()
         {
-            var result = new OwnedCollection<ModuleDefinition, ModuleReference>(this);
-
             var table = ReaderContext.Metadata
                 .GetStream<TablesStream>()
                 .GetTable(TableIndex.ModuleRef);
 
+            var result = new OwnedCollection<ModuleDefinition, ModuleReference>(this, table.Count);
+
             for (int i = 0; i < table.Count; i++)
             {
                 var token = new MetadataToken(TableIndex.ModuleRef, (uint) i + 1);
@@ -264,12 +270,12 @@ protected override IList<ModuleReference> GetModuleReferences()
         /// <inheritdoc />
         protected override IList<FileReference> GetFileReferences()
         {
-            var result = new OwnedCollection<ModuleDefinition, FileReference>(this);
-
             var table = ReaderContext.Metadata
                 .GetStream<TablesStream>()
                 .GetTable(TableIndex.File);
 
+            var result = new OwnedCollection<ModuleDefinition, FileReference>(this, table.Count);
+
             for (int i = 0; i < table.Count; i++)
             {
                 var token = new MetadataToken(TableIndex.File, (uint) i + 1);
@@ -283,12 +289,12 @@ protected override IList<FileReference> GetFileReferences()
         /// <inheritdoc />
         protected override IList<ManifestResource> GetResources()
         {
-            var result = new OwnedCollection<ModuleDefinition, ManifestResource>(this);
-
             var table = ReaderContext.Metadata
                 .GetStream<TablesStream>()
                 .GetTable(TableIndex.ManifestResource);
 
+            var result = new OwnedCollection<ModuleDefinition, ManifestResource>(this, table.Count);
+
             for (int i = 0; i < table.Count; i++)
             {
                 var token = new MetadataToken(TableIndex.ManifestResource, (uint) i + 1);
@@ -302,12 +308,12 @@ protected override IList<ManifestResource> GetResources()
         /// <inheritdoc />
         protected override IList<ExportedType> GetExportedTypes()
         {
-            var result = new OwnedCollection<ModuleDefinition, ExportedType>(this);
-
             var table = ReaderContext.Metadata
                 .GetStream<TablesStream>()
                 .GetTable(TableIndex.ExportedType);
 
+            var result = new OwnedCollection<ModuleDefinition, ExportedType>(this, table.Count);
+
             for (int i = 0; i < table.Count; i++)
             {
                 var token = new MetadataToken(TableIndex.ExportedType, (uint) i + 1);
@@ -350,12 +356,11 @@ protected override IList<ExportedType> GetExportedTypes()
 
             if (assemblyTable.Count > 0)
             {
-                var assembly = new SerializedAssemblyDefinition(
+                return new SerializedAssemblyDefinition(
                     ReaderContext,
                     new MetadataToken(TableIndex.Assembly, 1),
                     assemblyTable[0],
                     this);
-                return assembly;
             }
 
             return null;
diff --git a/src/AsmResolver.DotNet/Serialized/SerializedPropertyDefinition.cs b/src/AsmResolver.DotNet/Serialized/SerializedPropertyDefinition.cs
index 9739939fd..b1f1fa227 100644
--- a/src/AsmResolver.DotNet/Serialized/SerializedPropertyDefinition.cs
+++ b/src/AsmResolver.DotNet/Serialized/SerializedPropertyDefinition.cs
@@ -1,5 +1,6 @@
 using System;
 using System.Collections.Generic;
+using System.Linq;
 using AsmResolver.DotNet.Signatures;
 using AsmResolver.DotNet.Collections;
 using AsmResolver.PE.DotNet.Metadata;
@@ -70,11 +71,13 @@ public SerializedPropertyDefinition(ModuleReaderContext context, MetadataToken t
         /// <inheritdoc />
         protected override IList<MethodSemantics> GetSemantics()
         {
-            var result = new MethodSemanticsCollection(this);
+            var module = _context.ParentModule;
+            var rids = module.GetMethodSemantics(MetadataToken);
+
+            var result = new MethodSemanticsCollection(this, rids.Count);
             result.ValidateMembership = false;
 
-            var module = _context.ParentModule;
-            foreach (uint rid in module.GetMethodSemantics(MetadataToken))
+            foreach (uint rid in rids)
             {
                 var semanticsToken = new MetadataToken(TableIndex.MethodSemantics, rid);
                 result.Add((MethodSemantics) module.LookupMember(semanticsToken));
diff --git a/src/AsmResolver.DotNet/Serialized/SerializedTypeDefinition.cs b/src/AsmResolver.DotNet/Serialized/SerializedTypeDefinition.cs
index 9b87e76e3..2ee5afe6b 100644
--- a/src/AsmResolver.DotNet/Serialized/SerializedTypeDefinition.cs
+++ b/src/AsmResolver.DotNet/Serialized/SerializedTypeDefinition.cs
@@ -1,5 +1,6 @@
 using System;
 using System.Collections.Generic;
+using System.Linq;
 using AsmResolver.Collections;
 using AsmResolver.DotNet.Collections;
 using AsmResolver.PE.DotNet.Metadata;
@@ -67,9 +68,9 @@ public SerializedTypeDefinition(ModuleReaderContext context, MetadataToken token
         /// <inheritdoc />
         protected override IList<TypeDefinition> GetNestedTypes()
         {
-            var result = new OwnedCollection<TypeDefinition, TypeDefinition>(this);
-
             var rids = _context.ParentModule.GetNestedTypeRids(MetadataToken.Rid);
+            var result = new OwnedCollection<TypeDefinition, TypeDefinition>(this, rids.Count);
+
             foreach (uint rid in rids)
             {
                 var nestedType = (TypeDefinition) _context.ParentModule.LookupMember(new MetadataToken(TableIndex.TypeDef, rid));
@@ -107,7 +108,7 @@ protected override IList<EventDefinition> GetEvents() =>
         private IList<TMember> CreateMemberCollection<TMember>(MetadataRange range)
             where TMember : class, IMetadataMember, IOwnedCollectionElement<TypeDefinition>
         {
-            var result = new OwnedCollection<TypeDefinition, TMember>(this);
+            var result = new OwnedCollection<TypeDefinition, TMember>(this, range.Count);
 
             foreach (var token in range)
                 result.Add((TMember) _context.ParentModule.LookupMember(token));
@@ -126,9 +127,10 @@ protected override IList<SecurityDeclaration> GetSecurityDeclarations() =>
         /// <inheritdoc />
         protected override IList<GenericParameter> GetGenericParameters()
         {
-            var result = new OwnedCollection<IHasGenericParameters, GenericParameter>(this);
+            var rids = _context.ParentModule.GetGenericParameters(MetadataToken);
+            var result = new OwnedCollection<IHasGenericParameters, GenericParameter>(this, rids.Count);
 
-            foreach (uint rid in _context.ParentModule.GetGenericParameters(MetadataToken))
+            foreach (uint rid in rids)
             {
                 if (_context.ParentModule.TryLookupMember(new MetadataToken(TableIndex.GenericParam, rid), out var member)
                     && member is GenericParameter genericParameter)
@@ -143,9 +145,9 @@ protected override IList<GenericParameter> GetGenericParameters()
         /// <inheritdoc />
         protected override IList<InterfaceImplementation> GetInterfaces()
         {
-            var result = new OwnedCollection<TypeDefinition, InterfaceImplementation>(this);
-
             var rids = _context.ParentModule.GetInterfaceImplementationRids(MetadataToken);
+            var result = new OwnedCollection<TypeDefinition, InterfaceImplementation>(this, rids.Count);
+
             foreach (uint rid in rids)
             {
                 if (_context.ParentModule.TryLookupMember(new MetadataToken(TableIndex.InterfaceImpl, rid), out var member)
@@ -161,13 +163,13 @@ protected override IList<InterfaceImplementation> GetInterfaces()
         /// <inheritdoc />
         protected override IList<MethodImplementation> GetMethodImplementations()
         {
-            var result = new List<MethodImplementation>();
-
             var tablesStream = _context.Metadata.GetStream<TablesStream>();
             var table = tablesStream.GetTable<MethodImplementationRow>(TableIndex.MethodImpl);
             var encoder = tablesStream.GetIndexEncoder(CodedIndex.MethodDefOrRef);
 
             var rids = _context.ParentModule.GetMethodImplementationRids(MetadataToken);
+            var result = new List<MethodImplementation>(rids.Count);
+
             foreach (uint rid in rids)
             {
                 var row = table.GetByRid(rid);
diff --git a/src/AsmResolver.DotNet/Signatures/CustomAttributeSignature.cs b/src/AsmResolver.DotNet/Signatures/CustomAttributeSignature.cs
index 1676016d9..15d4834fb 100644
--- a/src/AsmResolver.DotNet/Signatures/CustomAttributeSignature.cs
+++ b/src/AsmResolver.DotNet/Signatures/CustomAttributeSignature.cs
@@ -12,6 +12,8 @@ namespace AsmResolver.DotNet.Signatures
     /// </summary>
     public class CustomAttributeSignature : ExtendableBlobSignature
     {
+        private readonly List<CustomAttributeArgument> _fixedArguments;
+        private readonly List<CustomAttributeNamedArgument> _namedArguments;
         private const ushort CustomAttributeSignaturePrologue = 0x0001;
 
         /// <summary>
@@ -35,18 +37,20 @@ public class CustomAttributeSignature : ExtendableBlobSignature
 
             // Read fixed arguments.
             var parameterTypes = ctor.Signature?.ParameterTypes ?? Array.Empty<TypeSignature>();
+            result._fixedArguments.Capacity = parameterTypes.Count;
             for (int i = 0; i < parameterTypes.Count; i++)
             {
                 var argument = CustomAttributeArgument.FromReader(context, parameterTypes[i], ref reader);
-                result.FixedArguments.Add(argument);
+                result._fixedArguments.Add(argument);
             }
 
             // Read named arguments.
             ushort namedArgumentCount = reader.ReadUInt16();
+            result._namedArguments.Capacity = namedArgumentCount;
             for (int i = 0; i < namedArgumentCount; i++)
             {
                 var argument = CustomAttributeNamedArgument.FromReader(context, ref reader);
-                result.NamedArguments.Add(argument);
+                result._namedArguments.Add(argument);
             }
 
             return result;
@@ -73,25 +77,19 @@ public CustomAttributeSignature(IEnumerable<CustomAttributeArgument> fixedArgume
         /// </summary>
         public CustomAttributeSignature(IEnumerable<CustomAttributeArgument> fixedArguments, IEnumerable<CustomAttributeNamedArgument> namedArguments)
         {
-            FixedArguments = new List<CustomAttributeArgument>(fixedArguments);
-            NamedArguments = new List<CustomAttributeNamedArgument>(namedArguments);
+            _fixedArguments = new List<CustomAttributeArgument>(fixedArguments);
+            _namedArguments = new List<CustomAttributeNamedArgument>(namedArguments);
         }
 
         /// <summary>
         /// Gets a collection of fixed arguments that are passed onto the constructor of the attribute.
         /// </summary>
-        public IList<CustomAttributeArgument> FixedArguments
-        {
-            get;
-        }
+        public IList<CustomAttributeArgument> FixedArguments => _fixedArguments;
 
         /// <summary>
         /// Gets a collection of values that are assigned to fields and/or members of the attribute class.
         /// </summary>
-        public IList<CustomAttributeNamedArgument> NamedArguments
-        {
-            get;
-        }
+        public IList<CustomAttributeNamedArgument> NamedArguments => _namedArguments;
 
         /// <inheritdoc />
         public override string ToString()
diff --git a/src/AsmResolver.DotNet/Signatures/GenericInstanceMethodSignature.cs b/src/AsmResolver.DotNet/Signatures/GenericInstanceMethodSignature.cs
index 2e6286418..291a07c25 100644
--- a/src/AsmResolver.DotNet/Signatures/GenericInstanceMethodSignature.cs
+++ b/src/AsmResolver.DotNet/Signatures/GenericInstanceMethodSignature.cs
@@ -21,14 +21,14 @@ public class GenericInstanceMethodSignature : CallingConventionSignature, IGener
             }
 
             var attributes = (CallingConventionAttributes) reader.ReadByte();
-            var result = new GenericInstanceMethodSignature(attributes);
 
             if (!reader.TryReadCompressedUInt32(out uint count))
             {
                 context.ReaderContext.BadImage("Invalid number of type arguments in generic method signature.");
-                return result;
+                return new GenericInstanceMethodSignature(attributes);
             }
 
+            var result = new GenericInstanceMethodSignature(attributes, (int) count);
             for (int i = 0; i < count; i++)
                 result.TypeArguments.Add(TypeSignature.FromReader(context, ref reader));
 
@@ -44,6 +44,17 @@ public GenericInstanceMethodSignature(CallingConventionAttributes attributes)
         {
         }
 
+        /// <summary>
+        /// Creates a new instantiation signature for a generic method.
+        /// </summary>
+        /// <param name="attributes">The attributes.</param>
+        /// <param name="capacity">The initial number of elements that the <see cref="TypeArguments"/> property can store.</param>
+        public GenericInstanceMethodSignature(CallingConventionAttributes attributes, int capacity)
+            : base(attributes)
+        {
+            TypeArguments = new List<TypeSignature>(capacity);
+        }
+
         /// <summary>
         /// Creates a new instantiation signature for a generic method with the provided type arguments.
         /// </summary>
diff --git a/src/AsmResolver.DotNet/Signatures/MethodSignature.cs b/src/AsmResolver.DotNet/Signatures/MethodSignature.cs
index 67d530c14..818452aa6 100644
--- a/src/AsmResolver.DotNet/Signatures/MethodSignature.cs
+++ b/src/AsmResolver.DotNet/Signatures/MethodSignature.cs
@@ -20,8 +20,10 @@ public class MethodSignature : MethodSignatureBase
         /// <returns>The method signature.</returns>
         public static MethodSignature FromReader(in BlobReadContext context, ref BinaryStreamReader reader)
         {
-            var result = new MethodSignature((CallingConventionAttributes) reader.ReadByte(),
-                context.ReaderContext.ParentModule.CorLibTypeFactory.Void, Enumerable.Empty<TypeSignature>());
+            var result = new MethodSignature(
+                (CallingConventionAttributes) reader.ReadByte(),
+                context.ReaderContext.ParentModule.CorLibTypeFactory.Void,
+                Enumerable.Empty<TypeSignature>());
 
             // Generic parameter count.
             if (result.IsGeneric)
diff --git a/src/AsmResolver.DotNet/Signatures/MethodSignatureBase.cs b/src/AsmResolver.DotNet/Signatures/MethodSignatureBase.cs
index 4e58f029a..191bc2710 100644
--- a/src/AsmResolver.DotNet/Signatures/MethodSignatureBase.cs
+++ b/src/AsmResolver.DotNet/Signatures/MethodSignatureBase.cs
@@ -10,28 +10,27 @@ namespace AsmResolver.DotNet.Signatures
     /// </summary>
     public abstract class MethodSignatureBase : MemberSignature
     {
+        private readonly List<TypeSignature> _parameterTypes;
+
         /// <summary>
         /// Initializes the base of a method signature.
         /// </summary>
-        /// <param name="attributes"></param>
-        /// <param name="memberReturnType"></param>
-        /// <param name="parameterTypes"></param>
+        /// <param name="attributes">The attributes associated to the signature.</param>
+        /// <param name="memberReturnType">The return type of the member.</param>
+        /// <param name="parameterTypes">The types of all (non-sentinel) parameters.</param>
         protected MethodSignatureBase(
             CallingConventionAttributes attributes,
             TypeSignature memberReturnType,
             IEnumerable<TypeSignature> parameterTypes)
             : base(attributes, memberReturnType)
         {
-            ParameterTypes = new List<TypeSignature>(parameterTypes);
+            _parameterTypes = new List<TypeSignature>(parameterTypes);
         }
 
         /// <summary>
         /// Gets an ordered list of types indicating the types of the parameters that this member defines.
         /// </summary>
-        public IList<TypeSignature> ParameterTypes
-        {
-            get;
-        }
+        public IList<TypeSignature> ParameterTypes => _parameterTypes;
 
         /// <summary>
         /// Gets or sets the type of the value that this member returns.
@@ -120,6 +119,7 @@ protected void ReadParametersAndReturnType(in BlobReadContext context, ref Binar
             ReturnType = TypeSignature.FromReader(context, ref reader);
 
             // Parameter types.
+            _parameterTypes.Capacity = (int) parameterCount;
             bool sentinel = false;
             for (int i = 0; i < parameterCount; i++)
             {
diff --git a/src/AsmResolver.DotNet/Signatures/Types/ArrayTypeSignature.cs b/src/AsmResolver.DotNet/Signatures/Types/ArrayTypeSignature.cs
index 193142038..e81140d88 100644
--- a/src/AsmResolver.DotNet/Signatures/Types/ArrayTypeSignature.cs
+++ b/src/AsmResolver.DotNet/Signatures/Types/ArrayTypeSignature.cs
@@ -87,7 +87,7 @@ public IList<ArrayDimension> Dimensions
                 return signature;
             }
 
-            var sizes = new List<uint>();
+            var sizes = new List<uint>((int) numSizes);
             for (int i = 0; i < numSizes; i++)
             {
                 if (!reader.TryReadCompressedUInt32(out uint size))
@@ -106,7 +106,7 @@ public IList<ArrayDimension> Dimensions
                 return signature;
             }
 
-            var loBounds = new List<uint>();
+            var loBounds = new List<uint>((int) numLoBounds);
             for (int i = 0; i < numLoBounds; i++)
             {
                 if (!reader.TryReadCompressedUInt32(out uint bound))
diff --git a/src/AsmResolver.DotNet/Signatures/Types/FunctionPointerTypeSignature.cs b/src/AsmResolver.DotNet/Signatures/Types/FunctionPointerTypeSignature.cs
index ff2acc2c8..1fe273fa5 100644
--- a/src/AsmResolver.DotNet/Signatures/Types/FunctionPointerTypeSignature.cs
+++ b/src/AsmResolver.DotNet/Signatures/Types/FunctionPointerTypeSignature.cs
@@ -47,7 +47,7 @@ public MethodSignature Signature
 
         /// <inheritdoc />
         public override ITypeDefOrRef? GetUnderlyingTypeDefOrRef() =>
-            Signature?.ReturnType?.Module?.CorLibTypeFactory.IntPtr.Type;
+            Signature.ReturnType.Module?.CorLibTypeFactory.IntPtr.Type;
 
         /// <inheritdoc />
         public override bool IsImportedInModule(ModuleDefinition module) => Signature.IsImportedInModule(module);
diff --git a/src/AsmResolver.DotNet/Signatures/Types/GenericInstanceTypeSignature.cs b/src/AsmResolver.DotNet/Signatures/Types/GenericInstanceTypeSignature.cs
index 7ed057d8b..e05310b12 100644
--- a/src/AsmResolver.DotNet/Signatures/Types/GenericInstanceTypeSignature.cs
+++ b/src/AsmResolver.DotNet/Signatures/Types/GenericInstanceTypeSignature.cs
@@ -10,6 +10,8 @@ namespace AsmResolver.DotNet.Signatures.Types
     /// </summary>
     public class GenericInstanceTypeSignature : TypeSignature, IGenericArgumentsProvider
     {
+        private readonly List<TypeSignature> _typeArguments;
+
         internal new static GenericInstanceTypeSignature FromReader(in BlobReadContext context, ref BinaryStreamReader reader)
         {
             var genericType = TypeSignature.FromReader(context, ref reader);
@@ -21,8 +23,9 @@ public class GenericInstanceTypeSignature : TypeSignature, IGenericArgumentsProv
                 return signature;
             }
 
+            signature._typeArguments.Capacity = (int) count;
             for (int i = 0; i < count; i++)
-                signature.TypeArguments.Add(TypeSignature.FromReader(context, ref reader));
+                signature._typeArguments.Add(TypeSignature.FromReader(context, ref reader));
 
             return signature;
         }
@@ -53,7 +56,7 @@ private GenericInstanceTypeSignature(ITypeDefOrRef genericType, bool isValueType
             IEnumerable<TypeSignature> typeArguments)
         {
             GenericType = genericType;
-            TypeArguments = new List<TypeSignature>(typeArguments);
+            _typeArguments = new List<TypeSignature>(typeArguments);
             IsValueType = isValueType;
         }
 
@@ -72,10 +75,7 @@ public ITypeDefOrRef GenericType
         /// <summary>
         /// Gets a collection of type arguments used to instantiate the generic type.
         /// </summary>
-        public IList<TypeSignature> TypeArguments
-        {
-            get;
-        }
+        public IList<TypeSignature> TypeArguments => _typeArguments;
 
         /// <inheritdoc />
         public override string? Name
diff --git a/src/AsmResolver.PE/DotNet/Metadata/Tables/MetadataTable.cs b/src/AsmResolver.PE/DotNet/Metadata/Tables/MetadataTable.cs
index 2b8f01739..94983d7d9 100644
--- a/src/AsmResolver.PE/DotNet/Metadata/Tables/MetadataTable.cs
+++ b/src/AsmResolver.PE/DotNet/Metadata/Tables/MetadataTable.cs
@@ -88,6 +88,15 @@ protected RefList<TRow> Rows
         /// <inheritdoc cref="ICollection{T}.Count" />
         public virtual int Count => Rows.Count;
 
+        /// <summary>
+        /// Gets or sets the total number of rows that the underlying array can store.
+        /// </summary>
+        public int Capacity
+        {
+            get => Rows.Capacity;
+            set => Rows.Capacity = value;
+        }
+
         /// <inheritdoc />
         public bool IsReadOnly => false; // TODO: it might be necessary later to make this configurable.
 
diff --git a/src/AsmResolver/Collections/LazyList.cs b/src/AsmResolver/Collections/LazyList.cs
index 90b584a75..0dd0cc0ce 100644
--- a/src/AsmResolver/Collections/LazyList.cs
+++ b/src/AsmResolver/Collections/LazyList.cs
@@ -12,7 +12,24 @@ namespace AsmResolver.Collections
     [DebuggerDisplay("Count = {" + nameof(Count) + "}")]
     public abstract class LazyList<TItem> : IList<TItem>
     {
-        private readonly List<TItem> _items = new();
+        private readonly List<TItem> _items;
+
+        /// <summary>
+        /// Creates a new, empty, uninitialized list.
+        /// </summary>
+        public LazyList()
+        {
+            _items = new List<TItem>();
+        }
+
+        /// <summary>
+        /// Creates a new, empty, uninitialized list.
+        /// </summary>
+        /// <param name="capacity">The initial number of elements the list can store.</param>
+        public LazyList(int capacity)
+        {
+            _items = new List<TItem>(capacity);
+        }
 
         /// <inheritdoc />
         public TItem this[int index]
@@ -39,6 +56,15 @@ public virtual int Count
             }
         }
 
+        /// <summary>
+        /// Gets or sets the total number of elements the list can contain before it has to resize its internal buffer.
+        /// </summary>
+        public int Capacity
+        {
+            get => _items.Capacity;
+            set => _items.Capacity = value;
+        }
+
         /// <inheritdoc />
         public bool IsReadOnly => false;
 
diff --git a/src/AsmResolver/Collections/OneToManyRelation.cs b/src/AsmResolver/Collections/OneToManyRelation.cs
index 570768c7e..30df87146 100644
--- a/src/AsmResolver/Collections/OneToManyRelation.cs
+++ b/src/AsmResolver/Collections/OneToManyRelation.cs
@@ -11,8 +11,27 @@ public sealed class OneToManyRelation<TKey, TValue>
         where TKey : notnull
         where TValue : notnull
     {
-        private readonly Dictionary<TKey, ICollection<TValue>> _memberLists = new();
-        private readonly Dictionary<TValue, TKey> _memberOwners = new();
+        private readonly Dictionary<TKey, ICollection<TValue>> _memberLists;
+        private readonly Dictionary<TValue, TKey> _memberOwners;
+
+        /// <summary>
+        /// Creates a new, empty one-to-many relation mapping.
+        /// </summary>
+        public OneToManyRelation()
+        {
+            _memberLists = new Dictionary<TKey, ICollection<TValue>>();
+            _memberOwners = new Dictionary<TValue, TKey>();
+        }
+
+        /// <summary>
+        /// Creates a new, empty one-to-many relation mapping.
+        /// </summary>
+        /// <param name="capacity">The initial number of elements the relation can store.</param>
+        public OneToManyRelation(int capacity)
+        {
+            _memberLists = new Dictionary<TKey, ICollection<TValue>>(capacity);
+            _memberOwners = new Dictionary<TValue, TKey>(capacity);
+        }
 
         /// <summary>
         /// Registers a relation between two objects.
diff --git a/src/AsmResolver/Collections/OneToOneRelation.cs b/src/AsmResolver/Collections/OneToOneRelation.cs
index 881915925..dbefc7bcc 100644
--- a/src/AsmResolver/Collections/OneToOneRelation.cs
+++ b/src/AsmResolver/Collections/OneToOneRelation.cs
@@ -11,8 +11,27 @@ public sealed class OneToOneRelation<TKey, TValue>
         where TKey : notnull
         where TValue : notnull
     {
-        private readonly Dictionary<TKey, TValue> _keyToValue = new();
-        private readonly Dictionary<TValue, TKey> _valueToKey = new();
+        private readonly Dictionary<TKey, TValue> _keyToValue;
+        private readonly Dictionary<TValue, TKey> _valueToKey;
+
+        /// <summary>
+        /// Creates a new, empty one-to-one mapping.
+        /// </summary>
+        public OneToOneRelation()
+        {
+            _keyToValue = new Dictionary<TKey, TValue>();
+            _valueToKey = new Dictionary<TValue, TKey>();
+        }
+
+        /// <summary>
+        /// Creates a new, empty one-to-one mapping.
+        /// </summary>
+        /// <param name="capacity">The initial number of elements the relation can store.</param>
+        public OneToOneRelation(int capacity)
+        {
+            _keyToValue = new Dictionary<TKey, TValue>(capacity);
+            _valueToKey = new Dictionary<TValue, TKey>(capacity);
+        }
 
         /// <summary>
         /// Registers a one-to-one relation between two objects.
diff --git a/src/AsmResolver/Collections/OwnedCollection.cs b/src/AsmResolver/Collections/OwnedCollection.cs
index 82a7d6b33..6facee7e8 100644
--- a/src/AsmResolver/Collections/OwnedCollection.cs
+++ b/src/AsmResolver/Collections/OwnedCollection.cs
@@ -26,6 +26,17 @@ public OwnedCollection(TOwner owner)
             Owner = owner ?? throw new ArgumentNullException(nameof(owner));
         }
 
+        /// <summary>
+        /// Creates a new empty collection that is owned by an object.
+        /// </summary>
+        /// <param name="owner">The owner of the collection.</param>
+        /// <param name="capacity">The initial number of elements the collection can store.</param>
+        public OwnedCollection(TOwner owner, int capacity)
+            : base(capacity)
+        {
+            Owner = owner ?? throw new ArgumentNullException(nameof(owner));
+        }
+
         /// <summary>
         /// Gets the owner of the collection.
         /// </summary>
diff --git a/src/AsmResolver/Collections/RefList.cs b/src/AsmResolver/Collections/RefList.cs
index f454fe6ff..4fa091140 100644
--- a/src/AsmResolver/Collections/RefList.cs
+++ b/src/AsmResolver/Collections/RefList.cs
@@ -46,9 +46,23 @@ public RefList(int capacity)
         public int Count => _count;
 
         /// <summary>
-        /// Gets the capacity of the underlying array.
+        /// Gets or sets the total number of elements that the underlying array can store.
         /// </summary>
-        public int Capacity => _items.Length;
+        public int Capacity
+        {
+            get => _items.Length;
+            set
+            {
+                if (value == _items.Length)
+                    return;
+
+                if (value < _count)
+                    throw new ArgumentException("Capacity must be equal or larger than the current number of elements in the list.");
+
+                EnsureCapacity(value);
+                IncrementVersion();
+            }
+        }
 
         /// <summary>
         /// Gets a number indicating the current version of the list.
@@ -127,7 +141,7 @@ public ref T GetElementRef(int index, out int version)
         /// <param name="item">The element.</param>
         public void Add(in T item)
         {
-            EnsureEnoughCapacity(_count + 1);
+            EnsureCapacity(_count + 1);
             _items[_count] = item;
             _count++;
             IncrementVersion();
@@ -194,7 +208,7 @@ public bool Remove(in T item)
         /// <param name="item">The element to insert.</param>
         public void Insert(int index, in T item)
         {
-            EnsureEnoughCapacity(_count + 1);
+            EnsureCapacity(_count + 1);
 
             if (index < _count)
                 Array.Copy(_items, index, _items, index + 1, _count - index);
@@ -246,7 +260,7 @@ private void AssertIsValidIndex(int index)
                 throw new IndexOutOfRangeException();
         }
 
-        private void EnsureEnoughCapacity(int requiredCount)
+        private void EnsureCapacity(int requiredCount)
         {
             if (_items.Length >= requiredCount)
                 return;
diff --git a/test/AsmResolver.Tests/Collections/RefListTest.cs b/test/AsmResolver.Tests/Collections/RefListTest.cs
index 8c7b5f201..5f7c0adae 100644
--- a/test/AsmResolver.Tests/Collections/RefListTest.cs
+++ b/test/AsmResolver.Tests/Collections/RefListTest.cs
@@ -1,3 +1,4 @@
+using System;
 using AsmResolver.Collections;
 using Xunit;
 
@@ -11,6 +12,47 @@ public void EmptyList()
             Assert.Empty(new RefList<int>());
         }
 
+        [Fact]
+        public void SetCapacityToCount()
+        {
+            var list = new RefList<int>
+            {
+                1,
+                2,
+                3
+            };
+
+            list.Capacity = 3;
+            Assert.True(list.Capacity >= 3);
+        }
+
+        [Fact]
+        public void SetCapacityToLargerThanCount()
+        {
+            var list = new RefList<int>
+            {
+                1,
+                2,
+                3
+            };
+
+            list.Capacity = 6;
+            Assert.True(list.Capacity >= 6);
+        }
+
+        [Fact]
+        public void SetCapacityToSmallerThanCountShouldThrow()
+        {
+            var list = new RefList<int>
+            {
+                1,
+                2,
+                3
+            };
+
+            Assert.Throws<ArgumentException>(() => list.Capacity = 2);
+        }
+
         [Fact]
         public void AddItemShouldUpdateVersion()
         {