C#: Apply a bunch of VS suggestions

Marlamin · Marlamin · commit 7f5b928c7b57 · 2026-03-12T01:34:04.000+01:00
diff --git a/code/C#/DBDefsLib/BDBDReader.cs b/code/C#/DBDefsLib/BDBDReader.cs
@@ -136,7 +136,7 @@ public static Dictionary<string, TableInfo> Read(Stream stream, string tableName
                         var numCols = bin.ReadInt32();
                         versionDefinition.definitions = new Definition[numCols];
 
-                        for(int vc = 0; vc < numCols; vc++)
+                        for (int vc = 0; vc < numCols; vc++)
                         {
                             var flags = bin.ReadByte();
                             var size = bin.ReadByte();
diff --git a/code/C#/DBDefsLib/DBDEnumReader.cs b/code/C#/DBDefsLib/DBDEnumReader.cs
@@ -74,7 +74,7 @@ public EnumDefinition Read(Stream stream, MetaType metaType)
                     if (!long.TryParse(valueStr, out entry.value))
                         throw new Exception($"Line {lineNumber}: Invalid enum value '{valueStr}'");
                 }
-                
+
                 // This way the name can have spaces
                 var remainingLine = line[(valueStr.Length)..].TrimStart();
                 if (!string.IsNullOrEmpty(remainingLine))
diff --git a/code/C#/DBDefsLib/DBDEnumWriter.cs b/code/C#/DBDefsLib/DBDEnumWriter.cs
@@ -49,9 +49,7 @@ public void Save(EnumDefinition enumDefinition, string filePath)
                     sb.Append($" {entry.name}");
 
                 if (!string.IsNullOrEmpty(entry.comment))
-                {
                     sb.Append($" // {entry.comment}");
-                }
 
                 sb.AppendLine();
             }
diff --git a/code/C#/DBDefsLib/DBDMReader.cs b/code/C#/DBDefsLib/DBDMReader.cs
@@ -28,7 +28,7 @@ public List<MappingDefinition> Read(Stream stream)
                     continue;
 
                 var mappingDefinition = new MappingDefinition();
-                var split =  line.Split(' ', StringSplitOptions.RemoveEmptyEntries);
+                var split = line.Split(' ', StringSplitOptions.RemoveEmptyEntries);
 
                 // Comment available in mapping line, we handle split differently here as well
                 if (line.Contains("//"))
@@ -113,7 +113,7 @@ public List<MappingDefinition> Read(string file, bool validate = false)
             if (validate)
             {
                 var metaDirectory = Path.GetDirectoryName(file);
-                foreach(var mapping in mappingDefinition)
+                foreach (var mapping in mappingDefinition)
                 {
                     if (mapping.meta == MetaType.COLOR)
                         continue;
diff --git a/code/C#/DBDefsLib/DBDReader.cs b/code/C#/DBDefsLib/DBDReader.cs
@@ -23,7 +23,7 @@ public DBDefinition Read(Stream stream, bool validate = false)
             if (lines[0].StartsWith("COLUMNS"))
             {
                 lineNumber++;
-                while (lineNumber < lines.Count())
+                while (lineNumber < lines.Count)
                 {
                     var line = lines[lineNumber++];
 
@@ -38,13 +38,13 @@ public DBDefinition Read(Stream stream, bool validate = false)
                     var validTypes = new List<string> { "uint", "int", "float", "string", "locstring" };
 
                     // Check if line has a space in case someone didn't assign a type to a column name
-                    if (!line.Contains(" "))
+                    if (!line.Contains(' '))
                     {
                         throw new Exception("Line " + line + " does not contain a space between type and column name!");
                     }
 
                     // Read line up to space (end of type) or < (foreign key)
-                    var type = line.Substring(0, line.IndexOfAny(new char[] { ' ', '<' }));
+                    var type = line[..line.IndexOfAny([' ', '<'])];
 
                     // Check if type is valid, throw exception if not!
                     if (!validTypes.Contains(type))
@@ -61,7 +61,7 @@ public DBDefinition Read(Stream stream, bool validate = false)
                     if (line.StartsWith(type + "<"))
                     {
                         // Read foreign key info between < and > without < and > in result, then split on :: to separate table and field
-                        var foreignKey = line.Substring(line.IndexOf('<') + 1, line.IndexOf('>') - line.IndexOf('<') - 1).Split(new string[] { "::" }, StringSplitOptions.None);
+                        var foreignKey = line.Substring(line.IndexOf('<') + 1, line.IndexOf('>') - line.IndexOf('<') - 1).Split(["::"], StringSplitOptions.None);
 
                         // There should only be 2 values in foreignKey (table and col)
                         if (foreignKey.Length != 2)
@@ -80,7 +80,7 @@ public DBDefinition Read(Stream stream, bool validate = false)
                     // If there's only one space on the line at the same locaiton as the first one, assume a simple line like "uint ID", this can be better
                     if (line.LastIndexOf(' ') == line.IndexOf(' '))
                     {
-                        name = line.Substring(line.IndexOf(' ') + 1);
+                        name = line[(line.IndexOf(' ') + 1)..];
                     }
                     else
                     {
@@ -94,10 +94,10 @@ public DBDefinition Read(Stream stream, bool validate = false)
                     }
 
                     // If name ends in ? it's unverified
-                    if (name.EndsWith("?"))
+                    if (name.EndsWith('?'))
                     {
                         columnDefinition.verified = false;
-                        name = name.Remove(name.Length - 1);
+                        name = name[..^1];
                     }
                     else
                     {
@@ -107,20 +107,16 @@ public DBDefinition Read(Stream stream, bool validate = false)
                     /* COMMENT READING */
                     if (line.Contains("//"))
                     {
-                        columnDefinition.comment = line.Substring(line.IndexOf("//") + 2).Trim();
+                        columnDefinition.comment = line[(line.IndexOf("//") + 2)..].Trim();
                     }
 
                     // Add to dictionary
-                    if (columnDefinitionDictionary.ContainsKey(name))
+                    if (!columnDefinitionDictionary.TryAdd(name, columnDefinition))
                     {
                         Console.ForegroundColor = ConsoleColor.Red;
                         Console.WriteLine("Collision with existing column name while adding new column name! Skipping..");
                         Console.ResetColor();
                     }
-                    else
-                    {
-                        columnDefinitionDictionary.Add(name, columnDefinition);
-                    }
                 }
             }
             else
@@ -144,41 +140,43 @@ public DBDefinition Read(Stream stream, bool validate = false)
 
                 if (string.IsNullOrWhiteSpace(line))
                 {
-                    if (builds.Count != 0 || buildRanges.Count != 0 || layoutHashes.Count != 0) {
+                    if (builds.Count != 0 || buildRanges.Count != 0 || layoutHashes.Count != 0)
+                    {
                         versionDefinitions.Add(
                             new VersionDefinitions()
                             {
-                                builds = builds.ToArray(),
-                                buildRanges = buildRanges.ToArray(),
-                                layoutHashes = layoutHashes.ToArray(),
+                                builds = [.. builds],
+                                buildRanges = [.. buildRanges],
+                                layoutHashes = [.. layoutHashes],
                                 comment = comment,
-                                definitions = definitions.ToArray()
+                                definitions = [.. definitions]
                             }
                         );
                     }
-                    else if (definitions.Count != 0 || !string.IsNullOrWhiteSpace(comment)) {
+                    else if (definitions.Count != 0 || !string.IsNullOrWhiteSpace(comment))
+                    {
                         throw new Exception("No BUILD or LAYOUT, but non-empty lines/'definitions'.");
                     }
 
-                    definitions = new List<Definition>();
-                    layoutHashes = new List<string>();
+                    definitions = [];
+                    layoutHashes = [];
                     comment = "";
-                    builds = new List<Build>();
-                    buildRanges = new List<BuildRange>();
+                    builds = [];
+                    buildRanges = [];
                 }
 
                 if (line.StartsWith("LAYOUT"))
                 {
-                    var splitLayoutHashes = line.Remove(0, 7).Split(new string[] { ", " }, StringSplitOptions.None);
+                    var splitLayoutHashes = line[7..].Split([", "], StringSplitOptions.None);
                     layoutHashes.AddRange(splitLayoutHashes);
                 }
 
                 if (line.StartsWith("BUILD"))
                 {
-                    var splitBuilds = line.Remove(0, 6).Split(new string[] { ", " }, StringSplitOptions.None);
+                    var splitBuilds = line[6..].Split([", "], StringSplitOptions.None);
                     foreach (var splitBuild in splitBuilds)
                     {
-                        if (splitBuild.Contains("-"))
+                        if (splitBuild.Contains('-'))
                         {
                             var splitRange = splitBuild.Split('-');
                             buildRanges.Add(
@@ -195,20 +193,21 @@ public DBDefinition Read(Stream stream, bool validate = false)
 
                 if (line.StartsWith("COMMENT"))
                 {
-                    comment = line.Substring(7).Trim();
+                    comment = line[7..].Trim();
                 }
 
                 if (!line.StartsWith("LAYOUT") && !line.StartsWith("BUILD") && !line.StartsWith("COMMENT") && !string.IsNullOrWhiteSpace(line))
                 {
-                    var definition = new Definition();
-
-                    // Default to everything being inline
-                    definition.isNonInline = false;
+                    var definition = new Definition
+                    {
+                        // Default to everything being inline
+                        isNonInline = false
+                    };
 
-                    if (line.Contains("$"))
+                    if (line.Contains('$'))
                     {
-                        var annotationStart = line.IndexOf("$");
-                        var annotationEnd = line.IndexOf("$", 1);
+                        var annotationStart = line.IndexOf('$');
+                        var annotationEnd = line.IndexOf('$', 1);
 
                         var annotations = new List<string>(line.Substring(annotationStart + 1, annotationEnd - annotationStart - 1).Split(','));
 
@@ -230,7 +229,7 @@ public DBDefinition Read(Stream stream, bool validate = false)
                         line = line.Remove(annotationStart, annotationEnd + 1);
                     }
 
-                    if (line.Contains("<"))
+                    if (line.Contains('<'))
                     {
                         var size = line.Substring(line.IndexOf('<') + 1, line.IndexOf('>') - line.IndexOf('<') - 1);
 
@@ -248,16 +247,20 @@ public DBDefinition Read(Stream stream, bool validate = false)
                         line = line.Remove(line.IndexOf('<'), line.IndexOf('>') - line.IndexOf('<') + 1);
                     }
 
-                    if (line.Contains("["))
+                    if (line.Contains('['))
                     {
-                        int.TryParse(line.Substring(line.IndexOf('[') + 1, line.IndexOf(']') - line.IndexOf('[') - 1), out definition.arrLength);
+                        if (!int.TryParse(line.AsSpan(line.IndexOf('[') + 1, line.IndexOf(']') - line.IndexOf('[') - 1), out definition.arrLength))
+                        {
+                            throw new Exception("Invalid array length format.");
+                        }
+
                         line = line.Remove(line.IndexOf('['), line.IndexOf(']') - line.IndexOf('[') + 1);
                     }
 
                     if (line.Contains("//"))
                     {
-                        definition.comment = line.Substring(line.IndexOf("//") + 2).Trim();
-                        line = line.Remove(line.IndexOf("//")).Trim();
+                        definition.comment = line[(line.IndexOf("//") + 2)..].Trim();
+                        line = line[..line.IndexOf("//")].Trim();
                     }
 
                     definition.name = line;
@@ -281,19 +284,21 @@ public DBDefinition Read(Stream stream, bool validate = false)
 
                 if (lines.Count == (i + 1))
                 {
-                    if (builds.Count != 0 || buildRanges.Count != 0 || layoutHashes.Count != 0) {
+                    if (builds.Count != 0 || buildRanges.Count != 0 || layoutHashes.Count != 0)
+                    {
                         versionDefinitions.Add(
                             new VersionDefinitions()
                             {
-                                builds = builds.ToArray(),
-                                buildRanges = buildRanges.ToArray(),
-                                layoutHashes = layoutHashes.ToArray(),
+                                builds = [.. builds],
+                                buildRanges = [.. buildRanges],
+                                layoutHashes = [.. layoutHashes],
                                 comment = comment,
-                                definitions = definitions.ToArray()
+                                definitions = [.. definitions]
                             }
                         );
                     }
-                    else if (definitions.Count != 0 || !string.IsNullOrWhiteSpace(comment)) {
+                    else if (definitions.Count != 0 || !string.IsNullOrWhiteSpace(comment))
+                    {
                         throw new Exception("No BUILD or LAYOUT, but non-empty lines/'definitions'.");
                     }
                 }
@@ -438,7 +443,7 @@ public DBDefinition Read(Stream stream, bool validate = false)
             return new DBDefinition
             {
                 columnDefinitions = columnDefinitionDictionary,
-                versionDefinitions = versionDefinitions.ToArray()
+                versionDefinitions = [.. versionDefinitions]
             };
         }
 
diff --git a/code/C#/DBDefsLib/DBDWriter.cs b/code/C#/DBDefsLib/DBDWriter.cs
@@ -86,12 +86,13 @@ public void Save(DBDefinition definition, string target, bool sort = false)
                         for (var b = 0; b < versionDefinition.builds.Length; b++)
                         {
                             var major = versionDefinition.builds[b].expansion + "." + versionDefinition.builds[b].major + "." + versionDefinition.builds[b].minor;
-                            if (!buildsByMajor.ContainsKey(major))
+                            if (!buildsByMajor.TryGetValue(major, out List<Build> builds))
                             {
-                                buildsByMajor.Add(major, new List<Build>());
+                                builds = [];
+                                buildsByMajor.Add(major, builds);
                             }
 
-                            buildsByMajor[major].Add(versionDefinition.builds[b]);
+                            builds.Add(versionDefinition.builds[b]);
                         }
 
                         foreach (var buildList in buildsByMajor)
diff --git a/code/C#/DBDefsLib/Utils.cs b/code/C#/DBDefsLib/Utils.cs
@@ -77,7 +77,7 @@ public static string NormalizeColumn(string col, bool fixFirst = true)
 
                 if (cleaned.StartsWith(thingToUpperCase, StringComparison.CurrentCultureIgnoreCase))
                 {
-                    cleaned = thingToUpperCase + cleaned.Substring(thingToUpperCase.Length);
+                    cleaned = thingToUpperCase + cleaned[thingToUpperCase.Length..];
                 }
 
                 if (cleaned.EndsWith(thingToUpperCase, StringComparison.CurrentCultureIgnoreCase))
@@ -86,9 +86,9 @@ public static string NormalizeColumn(string col, bool fixFirst = true)
                 }
             }
 
-            if (cleaned.EndsWith("_"))
+            if (cleaned.EndsWith('_'))
             {
-                cleaned = cleaned.Substring(0, cleaned.Length - 1);
+                cleaned = cleaned[..^1];
             }
 
             if (fixFirst)
@@ -122,7 +122,7 @@ public static (List<Build> builds, List<BuildRange> buildRanges) ParseBuildQuali
             var buildRanges = new List<BuildRange>();
 
             var buildsPart = qualifier["BUILD ".Length..];
-            var parts = buildsPart.Split(new[] { ", " }, StringSplitOptions.RemoveEmptyEntries);
+            var parts = buildsPart.Split([", "], StringSplitOptions.RemoveEmptyEntries);
 
             foreach (var part in parts)
             {

Original file line number	Diff line number	Diff line change
`@@ -136,7 +136,7 @@ public static Dictionary<string, TableInfo> Read(Stream stream, string tableName`
`136`	`136`	`var numCols = bin.ReadInt32();`
`137`	`137`	`versionDefinition.definitions = new Definition[numCols];`
`138`	`138`
`139`		`- for(int vc = 0; vc < numCols; vc++)`
	`139`	`+ for (int vc = 0; vc < numCols; vc++)`
`140`	`140`	`{`
`141`	`141`	`var flags = bin.ReadByte();`
`142`	`142`	`var size = bin.ReadByte();`
Original file line number	Diff line number	Diff line change
`@@ -74,7 +74,7 @@ public EnumDefinition Read(Stream stream, MetaType metaType)`
`74`	`74`	`if (!long.TryParse(valueStr, out entry.value))`
`75`	`75`	`throw new Exception($"Line {lineNumber}: Invalid enum value '{valueStr}'");`
`76`	`76`	`}`
`77`		`-`
	`77`	`+`
`78`	`78`	`// This way the name can have spaces`
`79`	`79`	`var remainingLine = line[(valueStr.Length)..].TrimStart();`
`80`	`80`	`if (!string.IsNullOrEmpty(remainingLine))`
Original file line number	Diff line number	Diff line change
`@@ -49,9 +49,7 @@ public void Save(EnumDefinition enumDefinition, string filePath)`
`49`	`49`	`sb.Append($" {entry.name}");`
`50`	`50`
`51`	`51`	`if (!string.IsNullOrEmpty(entry.comment))`
`52`		`- {`
`53`	`52`	`sb.Append($" // {entry.comment}");`
`54`		`- }`
`55`	`53`
`56`	`54`	`sb.AppendLine();`
`57`	`55`	`}`
Original file line number	Diff line number	Diff line change
`@@ -23,7 +23,7 @@ public DBDefinition Read(Stream stream, bool validate = false)`
`23`	`23`	`if (lines[0].StartsWith("COLUMNS"))`
`24`	`24`	`{`
`25`	`25`	`lineNumber++;`
`26`		`- while (lineNumber < lines.Count())`
	`26`	`+ while (lineNumber < lines.Count)`
`27`	`27`	`{`
`28`	`28`	`var line = lines[lineNumber++];`
`29`	`29`
`@@ -38,13 +38,13 @@ public DBDefinition Read(Stream stream, bool validate = false)`
`38`	`38`	`var validTypes = new List<string> { "uint", "int", "float", "string", "locstring" };`
`39`	`39`
`40`	`40`	`// Check if line has a space in case someone didn't assign a type to a column name`
`41`		`- if (!line.Contains(" "))`
	`41`	`+ if (!line.Contains(' '))`
`42`	`42`	`{`
`43`	`43`	`throw new Exception("Line " + line + " does not contain a space between type and column name!");`
`44`	`44`	`}`
`45`	`45`
`46`	`46`	`// Read line up to space (end of type) or < (foreign key)`
`47`		`- var type = line.Substring(0, line.IndexOfAny(new char[] { ' ', '<' }));`
	`47`	`+ var type = line[..line.IndexOfAny([' ', '<'])];`
`48`	`48`
`49`	`49`	`// Check if type is valid, throw exception if not!`
`50`	`50`	`if (!validTypes.Contains(type))`
`@@ -61,7 +61,7 @@ public DBDefinition Read(Stream stream, bool validate = false)`
`61`	`61`	`if (line.StartsWith(type + "<"))`
`62`	`62`	`{`
`63`	`63`	`// Read foreign key info between < and > without < and > in result, then split on :: to separate table and field`
`64`		`- var foreignKey = line.Substring(line.IndexOf('<') + 1, line.IndexOf('>') - line.IndexOf('<') - 1).Split(new string[] { "::" }, StringSplitOptions.None);`
	`64`	`+ var foreignKey = line.Substring(line.IndexOf('<') + 1, line.IndexOf('>') - line.IndexOf('<') - 1).Split(["::"], StringSplitOptions.None);`
`65`	`65`
`66`	`66`	`// There should only be 2 values in foreignKey (table and col)`
`67`	`67`	`if (foreignKey.Length != 2)`
`@@ -80,7 +80,7 @@ public DBDefinition Read(Stream stream, bool validate = false)`
`80`	`80`	`// If there's only one space on the line at the same locaiton as the first one, assume a simple line like "uint ID", this can be better`
`81`	`81`	`if (line.LastIndexOf(' ') == line.IndexOf(' '))`
`82`	`82`	`{`
`83`		`- name = line.Substring(line.IndexOf(' ') + 1);`
	`83`	`+ name = line[(line.IndexOf(' ') + 1)..];`
`84`	`84`	`}`
`85`	`85`	`else`
`86`	`86`	`{`
`@@ -94,10 +94,10 @@ public DBDefinition Read(Stream stream, bool validate = false)`
`94`	`94`	`}`
`95`	`95`
`96`	`96`	`// If name ends in ? it's unverified`
`97`		`- if (name.EndsWith("?"))`
	`97`	`+ if (name.EndsWith('?'))`
`98`	`98`	`{`
`99`	`99`	`columnDefinition.verified = false;`
`100`		`- name = name.Remove(name.Length - 1);`
	`100`	`+ name = name[..^1];`
`101`	`101`	`}`
`102`	`102`	`else`
`103`	`103`	`{`
`@@ -107,20 +107,16 @@ public DBDefinition Read(Stream stream, bool validate = false)`
`107`	`107`	`/* COMMENT READING */`
`108`	`108`	`if (line.Contains("//"))`
`109`	`109`	`{`
`110`		`- columnDefinition.comment = line.Substring(line.IndexOf("//") + 2).Trim();`
	`110`	`+ columnDefinition.comment = line[(line.IndexOf("//") + 2)..].Trim();`
`111`	`111`	`}`
`112`	`112`
`113`	`113`	`// Add to dictionary`
`114`		`- if (columnDefinitionDictionary.ContainsKey(name))`
	`114`	`+ if (!columnDefinitionDictionary.TryAdd(name, columnDefinition))`
`115`	`115`	`{`
`116`	`116`	`Console.ForegroundColor = ConsoleColor.Red;`
`117`	`117`	`Console.WriteLine("Collision with existing column name while adding new column name! Skipping..");`
`118`	`118`	`Console.ResetColor();`
`119`	`119`	`}`
`120`		`- else`
`121`		`- {`
`122`		`- columnDefinitionDictionary.Add(name, columnDefinition);`
`123`		`- }`
`124`	`120`	`}`
`125`	`121`	`}`
`126`	`122`	`else`
`@@ -144,41 +140,43 @@ public DBDefinition Read(Stream stream, bool validate = false)`
`144`	`140`
`145`	`141`	`if (string.IsNullOrWhiteSpace(line))`
`146`	`142`	`{`
`147`		`- if (builds.Count != 0 \|\| buildRanges.Count != 0 \|\| layoutHashes.Count != 0) {`
	`143`	`+ if (builds.Count != 0 \|\| buildRanges.Count != 0 \|\| layoutHashes.Count != 0)`
	`144`	`+ {`
`148`	`145`	`versionDefinitions.Add(`
`149`	`146`	`new VersionDefinitions()`
`150`	`147`	`{`
`151`		`- builds = builds.ToArray(),`
`152`		`- buildRanges = buildRanges.ToArray(),`
`153`		`- layoutHashes = layoutHashes.ToArray(),`
	`148`	`+ builds = [.. builds],`
	`149`	`+ buildRanges = [.. buildRanges],`
	`150`	`+ layoutHashes = [.. layoutHashes],`
`154`	`151`	`comment = comment,`
`155`		`- definitions = definitions.ToArray()`
	`152`	`+ definitions = [.. definitions]`
`156`	`153`	`}`
`157`	`154`	`);`
`158`	`155`	`}`
`159`		`- else if (definitions.Count != 0 \|\| !string.IsNullOrWhiteSpace(comment)) {`
	`156`	`+ else if (definitions.Count != 0 \|\| !string.IsNullOrWhiteSpace(comment))`
	`157`	`+ {`
`160`	`158`	`throw new Exception("No BUILD or LAYOUT, but non-empty lines/'definitions'.");`
`161`	`159`	`}`
`162`	`160`
`163`		`- definitions = new List<Definition>();`
`164`		`- layoutHashes = new List<string>();`
	`161`	`+ definitions = [];`
	`162`	`+ layoutHashes = [];`
`165`	`163`	`comment = "";`
`166`		`- builds = new List<Build>();`
`167`		`- buildRanges = new List<BuildRange>();`
	`164`	`+ builds = [];`
	`165`	`+ buildRanges = [];`
`168`	`166`	`}`
`169`	`167`
`170`	`168`	`if (line.StartsWith("LAYOUT"))`
`171`	`169`	`{`
`172`		`- var splitLayoutHashes = line.Remove(0, 7).Split(new string[] { ", " }, StringSplitOptions.None);`
	`170`	`+ var splitLayoutHashes = line[7..].Split([", "], StringSplitOptions.None);`
`173`	`171`	`layoutHashes.AddRange(splitLayoutHashes);`
`174`	`172`	`}`
`175`	`173`
`176`	`174`	`if (line.StartsWith("BUILD"))`
`177`	`175`	`{`
`178`		`- var splitBuilds = line.Remove(0, 6).Split(new string[] { ", " }, StringSplitOptions.None);`
	`176`	`+ var splitBuilds = line[6..].Split([", "], StringSplitOptions.None);`
`179`	`177`	`foreach (var splitBuild in splitBuilds)`
`180`	`178`	`{`
`181`		`- if (splitBuild.Contains("-"))`
	`179`	`+ if (splitBuild.Contains('-'))`
`182`	`180`	`{`
`183`	`181`	`var splitRange = splitBuild.Split('-');`
`184`	`182`	`buildRanges.Add(`
`@@ -195,20 +193,21 @@ public DBDefinition Read(Stream stream, bool validate = false)`
`195`	`193`
`196`	`194`	`if (line.StartsWith("COMMENT"))`
`197`	`195`	`{`
`198`		`- comment = line.Substring(7).Trim();`
	`196`	`+ comment = line[7..].Trim();`
`199`	`197`	`}`
`200`	`198`
`201`	`199`	`if (!line.StartsWith("LAYOUT") && !line.StartsWith("BUILD") && !line.StartsWith("COMMENT") && !string.IsNullOrWhiteSpace(line))`
`202`	`200`	`{`
`203`		`- var definition = new Definition();`
`204`		`-`
`205`		`- // Default to everything being inline`
`206`		`- definition.isNonInline = false;`
	`201`	`+ var definition = new Definition`
	`202`	`+ {`
	`203`	`+ // Default to everything being inline`
	`204`	`+ isNonInline = false`
	`205`	`+ };`
`207`	`206`
`208`		`- if (line.Contains("$"))`
	`207`	`+ if (line.Contains('$'))`
`209`	`208`	`{`
`210`		`- var annotationStart = line.IndexOf("$");`
`211`		`- var annotationEnd = line.IndexOf("$", 1);`
	`209`	`+ var annotationStart = line.IndexOf('$');`
	`210`	`+ var annotationEnd = line.IndexOf('$', 1);`
`212`	`211`
`213`	`212`	`var annotations = new List<string>(line.Substring(annotationStart + 1, annotationEnd - annotationStart - 1).Split(','));`
`214`	`213`
`@@ -230,7 +229,7 @@ public DBDefinition Read(Stream stream, bool validate = false)`
`230`	`229`	`line = line.Remove(annotationStart, annotationEnd + 1);`
`231`	`230`	`}`
`232`	`231`
`233`		`- if (line.Contains("<"))`
	`232`	`+ if (line.Contains('<'))`
`234`	`233`	`{`
`235`	`234`	`var size = line.Substring(line.IndexOf('<') + 1, line.IndexOf('>') - line.IndexOf('<') - 1);`
`236`	`235`
`@@ -248,16 +247,20 @@ public DBDefinition Read(Stream stream, bool validate = false)`
`248`	`247`	`line = line.Remove(line.IndexOf('<'), line.IndexOf('>') - line.IndexOf('<') + 1);`
`249`	`248`	`}`
`250`	`249`
`251`		`- if (line.Contains("["))`
	`250`	`+ if (line.Contains('['))`
`252`	`251`	`{`
`253`		`- int.TryParse(line.Substring(line.IndexOf('[') + 1, line.IndexOf(']') - line.IndexOf('[') - 1), out definition.arrLength);`
	`252`	`+ if (!int.TryParse(line.AsSpan(line.IndexOf('[') + 1, line.IndexOf(']') - line.IndexOf('[') - 1), out definition.arrLength))`
	`253`	`+ {`
	`254`	`+ throw new Exception("Invalid array length format.");`
	`255`	`+ }`
	`256`	`+`
`254`	`257`	`line = line.Remove(line.IndexOf('['), line.IndexOf(']') - line.IndexOf('[') + 1);`
`255`	`258`	`}`
`256`	`259`
`257`	`260`	`if (line.Contains("//"))`
`258`	`261`	`{`
`259`		`- definition.comment = line.Substring(line.IndexOf("//") + 2).Trim();`
`260`		`- line = line.Remove(line.IndexOf("//")).Trim();`
	`262`	`+ definition.comment = line[(line.IndexOf("//") + 2)..].Trim();`
	`263`	`+ line = line[..line.IndexOf("//")].Trim();`
`261`	`264`	`}`
`262`	`265`
`263`	`266`	`definition.name = line;`
`@@ -281,19 +284,21 @@ public DBDefinition Read(Stream stream, bool validate = false)`
`281`	`284`
`282`	`285`	`if (lines.Count == (i + 1))`
`283`	`286`	`{`
`284`		`- if (builds.Count != 0 \|\| buildRanges.Count != 0 \|\| layoutHashes.Count != 0) {`
	`287`	`+ if (builds.Count != 0 \|\| buildRanges.Count != 0 \|\| layoutHashes.Count != 0)`
	`288`	`+ {`
`285`	`289`	`versionDefinitions.Add(`
`286`	`290`	`new VersionDefinitions()`
`287`	`291`	`{`
`288`		`- builds = builds.ToArray(),`
`289`		`- buildRanges = buildRanges.ToArray(),`
`290`		`- layoutHashes = layoutHashes.ToArray(),`
	`292`	`+ builds = [.. builds],`
	`293`	`+ buildRanges = [.. buildRanges],`
	`294`	`+ layoutHashes = [.. layoutHashes],`
`291`	`295`	`comment = comment,`
`292`		`- definitions = definitions.ToArray()`
	`296`	`+ definitions = [.. definitions]`
`293`	`297`	`}`
`294`	`298`	`);`
`295`	`299`	`}`
`296`		`- else if (definitions.Count != 0 \|\| !string.IsNullOrWhiteSpace(comment)) {`
	`300`	`+ else if (definitions.Count != 0 \|\| !string.IsNullOrWhiteSpace(comment))`
	`301`	`+ {`
`297`	`302`	`throw new Exception("No BUILD or LAYOUT, but non-empty lines/'definitions'.");`
`298`	`303`	`}`
`299`	`304`	`}`
`@@ -438,7 +443,7 @@ public DBDefinition Read(Stream stream, bool validate = false)`
`438`	`443`	`return new DBDefinition`
`439`	`444`	`{`
`440`	`445`	`columnDefinitions = columnDefinitionDictionary,`
`441`		`- versionDefinitions = versionDefinitions.ToArray()`
	`446`	`+ versionDefinitions = [.. versionDefinitions]`
`442`	`447`	`};`
`443`	`448`	`}`
`444`	`449`
Original file line number	Diff line number	Diff line change
`@@ -86,12 +86,13 @@ public void Save(DBDefinition definition, string target, bool sort = false)`
`86`	`86`	`for (var b = 0; b < versionDefinition.builds.Length; b++)`
`87`	`87`	`{`
`88`	`88`	`var major = versionDefinition.builds[b].expansion + "." + versionDefinition.builds[b].major + "." + versionDefinition.builds[b].minor;`
`89`		`- if (!buildsByMajor.ContainsKey(major))`
	`89`	`+ if (!buildsByMajor.TryGetValue(major, out List<Build> builds))`
`90`	`90`	`{`
`91`		`- buildsByMajor.Add(major, new List<Build>());`
	`91`	`+ builds = [];`
	`92`	`+ buildsByMajor.Add(major, builds);`
`92`	`93`	`}`
`93`	`94`
`94`		`- buildsByMajor[major].Add(versionDefinition.builds[b]);`
	`95`	`+ builds.Add(versionDefinition.builds[b]);`
`95`	`96`	`}`
`96`	`97`
`97`	`98`	`foreach (var buildList in buildsByMajor)`
Original file line number	Diff line number	Diff line change
`@@ -77,7 +77,7 @@ public static string NormalizeColumn(string col, bool fixFirst = true)`
`77`	`77`
`78`	`78`	`if (cleaned.StartsWith(thingToUpperCase, StringComparison.CurrentCultureIgnoreCase))`
`79`	`79`	`{`
`80`		`- cleaned = thingToUpperCase + cleaned.Substring(thingToUpperCase.Length);`
	`80`	`+ cleaned = thingToUpperCase + cleaned[thingToUpperCase.Length..];`
`81`	`81`	`}`
`82`	`82`
`83`	`83`	`if (cleaned.EndsWith(thingToUpperCase, StringComparison.CurrentCultureIgnoreCase))`
`@@ -86,9 +86,9 @@ public static string NormalizeColumn(string col, bool fixFirst = true)`
`86`	`86`	`}`
`87`	`87`	`}`
`88`	`88`
`89`		`- if (cleaned.EndsWith("_"))`
	`89`	`+ if (cleaned.EndsWith('_'))`
`90`	`90`	`{`
`91`		`- cleaned = cleaned.Substring(0, cleaned.Length - 1);`
	`91`	`+ cleaned = cleaned[..^1];`
`92`	`92`	`}`
`93`	`93`
`94`	`94`	`if (fixFirst)`
`@@ -122,7 +122,7 @@ public static (List<Build> builds, List<BuildRange> buildRanges) ParseBuildQuali`
`122`	`122`	`var buildRanges = new List<BuildRange>();`
`123`	`123`
`124`	`124`	`var buildsPart = qualifier["BUILD ".Length..];`
`125`		`- var parts = buildsPart.Split(new[] { ", " }, StringSplitOptions.RemoveEmptyEntries);`
	`125`	`+ var parts = buildsPart.Split([", "], StringSplitOptions.RemoveEmptyEntries);`
`126`	`126`
`127`	`127`	`foreach (var part in parts)`
`128`	`128`	`{`