Nullable corrections for DiscUtils.Core

LTRData · LTRData · commit 30d3f5ae9a03 · 2025-11-04T04:12:04.000+01:00
diff --git a/Library/DiscUtils.Core/Compression/BZip2Randomizer.cs b/Library/DiscUtils.Core/Compression/BZip2Randomizer.cs
@@ -25,12 +25,13 @@
 //
 
 using System;
+using System.Collections.Immutable;
 
 namespace DiscUtils.Compression;
 
 internal class BZip2Randomizer : DataBlockTransform
 {
-    private static readonly int[] RandomVals =
+    private static readonly ImmutableArray<int> RandomVals = ImmutableArray.Create(
     [
         619, 720, 127, 481, 931, 816, 813, 233, 566, 247,
         985, 724, 205, 454, 863, 491, 741, 242, 949, 214,
@@ -84,7 +85,7 @@ internal class BZip2Randomizer : DataBlockTransform
         920, 176, 193, 713, 857, 265, 203, 50, 668, 108,
         645, 990, 626, 197, 510, 357, 358, 850, 858, 364,
         936, 638
-    ];
+    ]);
 
     protected override bool BuffersMustNotOverlap => false;
 
diff --git a/Library/DiscUtils.Core/Compression/LZNT1.cs b/Library/DiscUtils.Core/Compression/LZNT1.cs
@@ -29,6 +29,7 @@
 //
 
 using System;
+using System.Collections.Immutable;
 using DiscUtils.Streams;
 
 namespace DiscUtils.Compression;
@@ -50,7 +51,7 @@ internal sealed class LZNT1 : BlockCompressor
     // we assume each block is 4KB on decode also.
     private const int FixedBlockSize = 0x1000;
 
-    private static readonly byte[] _compressionBits = CalcCompressionBits();
+    private static readonly ImmutableArray<byte> _compressionBits = CalcCompressionBits();
 
     public LZNT1()
     {
@@ -298,13 +299,13 @@ public override int Decompress(ReadOnlySpan<byte> source, Span<byte> decompresse
         return destIdx;
     }
 
-    private static byte[] CalcCompressionBits()
+    private static ImmutableArray<byte> CalcCompressionBits()
     {
-        var result = StreamUtilities.GetUninitializedArray<byte>(4096);
+        var result = ImmutableArray.CreateBuilder<byte>(4096);
         byte offsetBits = 0;
 
         var y = 0x10;
-        for (var x = 0; x < result.Length; x++)
+        for (var x = 0; x < 4096; x++)
         {
             result[x] = (byte)(4 + offsetBits);
             if (x == y)
@@ -314,6 +315,6 @@ private static byte[] CalcCompressionBits()
             }
         }
 
-        return result;
+        return result.ToImmutable();
     }
 }
diff --git a/Library/DiscUtils.Core/Compression/LzxStream.cs b/Library/DiscUtils.Core/Compression/LzxStream.cs
@@ -21,6 +21,7 @@
 //
 
 using System;
+using System.Collections.Immutable;
 using System.Diagnostics.CodeAnalysis;
 using System.IO;
 using System.Threading;
@@ -36,10 +37,10 @@ namespace DiscUtils.Compression;
 /// <remarks>This is not a general purpose LZX decompressor - it makes
 /// simplifying assumptions, such as being able to load the entire stream
 /// contents into memory..</remarks>
-internal class LzxStream : ReadOnlyCompatibilityStream
+public class LzxStream : ReadOnlyCompatibilityStream
 {
-    private static readonly uint[] _positionSlots;
-    private static readonly uint[] _extraBits;
+    private static readonly ImmutableArray<uint> _positionSlots;
+    private static readonly ImmutableArray<uint> _extraBits;
     private HuffmanTree? _alignedOffsetTree;
 
     private readonly LzxBitStream _bitStream;
@@ -59,23 +60,27 @@ internal class LzxStream : ReadOnlyCompatibilityStream
 
     static LzxStream()
     {
-        _positionSlots = new uint[50];
-        _extraBits = new uint[50];
+        var positionSlots = ImmutableArray.CreateBuilder<uint>(50);
+        var extraBits = ImmutableArray.CreateBuilder<uint>(50);
 
         uint numBits = 0;
-        _positionSlots[1] = 1;
+        positionSlots[1] = 1;
+        
         for (var i = 2; i < 50; i += 2)
         {
-            _extraBits[i] = numBits;
-            _extraBits[i + 1] = numBits;
-            _positionSlots[i] = _positionSlots[i - 1] + (uint)(1 << (int)_extraBits[i - 1]);
-            _positionSlots[i + 1] = _positionSlots[i] + (uint)(1 << (int)numBits);
+            extraBits[i] = numBits;
+            extraBits[i + 1] = numBits;
+            positionSlots[i] = positionSlots[i - 1] + (uint)(1 << (int)extraBits[i - 1]);
+            positionSlots[i + 1] = positionSlots[i] + (uint)(1 << (int)numBits);
 
             if (numBits < 17)
             {
                 numBits++;
             }
         }
+
+        _positionSlots = positionSlots.ToImmutable();
+        _extraBits = extraBits.ToImmutable();
     }
 
     public LzxStream(Stream stream, int windowBits, int fileSize)
@@ -285,7 +290,7 @@ private void DecodeCompressedBlock(BlockType blockType, int blockSize)
                 }
                 else
                 {
-                    var extra = (int)_extraBits[positionSlot];
+                    var extra = (int)_extraBits[(int)positionSlot];
 
                     uint formattedOffset;
 
@@ -304,13 +309,13 @@ private void DecodeCompressedBlock(BlockType blockType, int blockSize)
                             verbatimBits = _bitStream.Read(extra);
                         }
 
-                        formattedOffset = _positionSlots[positionSlot] + verbatimBits + alignedBits;
+                        formattedOffset = _positionSlots[(int)positionSlot] + verbatimBits + alignedBits;
                     }
                     else
                     {
                         var verbatimBits = extra > 0 ? _bitStream.Read(extra) : 0;
 
-                        formattedOffset = _positionSlots[positionSlot] + verbatimBits;
+                        formattedOffset = _positionSlots[(int)positionSlot] + verbatimBits;
                     }
 
                     matchOffset = formattedOffset - 2;
diff --git a/Library/DiscUtils.Core/CoreCompat/EncodingHelper.cs b/Library/DiscUtils.Core/CoreCompat/EncodingHelper.cs
@@ -1,4 +1,5 @@
-﻿using System.Text;
+﻿using System;
+using System.Text;
 
 namespace DiscUtils.CoreCompat;
 
@@ -20,11 +21,9 @@ public static void RegisterEncodings()
 #endif
     }
 
-    private static readonly char[] _invalidFileNameChars = ['\\', '/', '*', '?', ':'];
-
     public static string SanitizeFileName(this string fileName)
     {
-        foreach (var c in _invalidFileNameChars)
+        foreach (var c in stackalloc char[] { '\\', '/', '*', '?', ':' })
         {
             fileName = fileName.Replace(c, '_');
         }
diff --git a/Library/DiscUtils.Core/DiscUtils.Core.csproj b/Library/DiscUtils.Core/DiscUtils.Core.csproj
@@ -12,6 +12,10 @@
   </ItemGroup>
   <ItemGroup Condition="'$(TargetFramework.CompareTo(`net461`))' &lt; 0">
     <PackageReference Include="System.ValueTuple" Version="4.5.*" />
+    <PackageReference Include="System.Collections.Immutable" Version="1.*" />
+  </ItemGroup>
+  <ItemGroup Condition="'$(TargetFramework.CompareTo(`net461`))' &gt;= 0">
+    <PackageReference Include="System.Collections.Immutable" Version="*" />
   </ItemGroup>
   <ItemGroup Condition="'$(TargetFramework.CompareTo(`net5`))' &gt;= 0">
     <PackageReference Include="System.Text.Encoding.CodePages" Version="9.0.*" />
diff --git a/Library/DiscUtils.Core/DiskImageBuilder.cs b/Library/DiscUtils.Core/DiskImageBuilder.cs
@@ -112,7 +112,7 @@ private static void InitializeMaps()
             var attr = type.GetCustomAttribute<VirtualDiskFactoryAttribute>(false);
             if (attr != null)
             {
-                var factory = (VirtualDiskFactory)Activator.CreateInstance(type);
+                var factory = (VirtualDiskFactory)Activator.CreateInstance(type)!;
                 typeMap.Add(attr.Type, factory);
             }
         }
diff --git a/Library/DiscUtils.Core/FileTransport.cs b/Library/DiscUtils.Core/FileTransport.cs
@@ -36,7 +36,7 @@ internal sealed class FileTransport : VirtualDiskTransport
     public override bool IsRawDisk => false;
 
     [MemberNotNull(nameof(_path), nameof(_extraInfo))]
-    public override void Connect(Uri uri, string username, string password)
+    public override void Connect(Uri uri, string? username, string? password)
     {
         _path = uri.LocalPath;
         _extraInfo = uri.Fragment.TrimStart('#');
diff --git a/Library/DiscUtils.Core/Internal/Crc32.cs b/Library/DiscUtils.Core/Internal/Crc32.cs
@@ -21,15 +21,16 @@
 //
 
 using System;
+using System.Collections.Immutable;
 
 namespace DiscUtils.Internal;
 
 internal abstract class Crc32
 {
-    protected readonly uint[] Table;
+    protected readonly ImmutableArray<uint> Table;
     protected uint _value;
 
-    protected Crc32(uint[] table)
+    protected Crc32(ImmutableArray<uint> table)
     {
         Table = table;
         _value = 0xFFFFFFFF;
diff --git a/Library/DiscUtils.Core/Internal/Crc32BigEndian.cs b/Library/DiscUtils.Core/Internal/Crc32BigEndian.cs
@@ -21,6 +21,7 @@
 //
 
 using System;
+using System.Collections.Immutable;
 
 namespace DiscUtils.Internal;
 
@@ -29,16 +30,18 @@ namespace DiscUtils.Internal;
 /// </summary>
 internal sealed class Crc32BigEndian : Crc32
 {
-    private static readonly uint[][] Tables;
+    private static readonly ImmutableArray<ImmutableArray<uint>> Tables;
 
     static Crc32BigEndian()
     {
-        Tables = new uint[4][];
+        var tables = ImmutableArray.CreateBuilder<ImmutableArray<uint>>(4);
 
-        Tables[(int)Crc32Algorithm.Common] = CalcTable(0x04C11DB7);
-        Tables[(int)Crc32Algorithm.Castagnoli] = CalcTable(0x1EDC6F41);
-        Tables[(int)Crc32Algorithm.Koopman] = CalcTable(0x741B8CD7);
-        Tables[(int)Crc32Algorithm.Aeronautical] = CalcTable(0x814141AB);
+        tables[(int)Crc32Algorithm.Common] = CalcTable(0x04C11DB7);
+        tables[(int)Crc32Algorithm.Castagnoli] = CalcTable(0x1EDC6F41);
+        tables[(int)Crc32Algorithm.Koopman] = CalcTable(0x741B8CD7);
+        tables[(int)Crc32Algorithm.Aeronautical] = CalcTable(0x814141AB);
+
+        Tables = tables.ToImmutable();
     }
 
     public Crc32BigEndian(Crc32Algorithm algorithm)
@@ -59,9 +62,9 @@ public override void Process(ReadOnlySpan<byte> buffer)
         _value = Process(Table, _value, buffer);
     }
 
-    private static uint[] CalcTable(uint polynomial)
+    private static ImmutableArray<uint> CalcTable(uint polynomial)
     {
-        var table = new uint[256];
+        var table = ImmutableArray.CreateBuilder<uint>(256);
 
         for (uint i = 0; i < 256; ++i)
         {
@@ -79,20 +82,20 @@ private static uint[] CalcTable(uint polynomial)
                 }
             }
 
-            table[i] = crc;
+            table[(int)i] = crc;
         }
 
-        return table;
+        return table.ToImmutable();
     }
 
-    private static uint Process(uint[] table, uint accumulator, ReadOnlySpan<byte> buffer)
+    private static uint Process(ImmutableArray<uint> table, uint accumulator, ReadOnlySpan<byte> buffer)
     {
         var value = accumulator;
 
         for (var i = 0; i < buffer.Length; ++i)
         {
             var b = buffer[i];
-            value = table[(value >> 24) ^ b] ^ (value << 8);
+            value = table[(int)((value >> 24) ^ b)] ^ (value << 8);
         }
 
         return value;
diff --git a/Library/DiscUtils.Core/Internal/Crc32LittleEndian.cs b/Library/DiscUtils.Core/Internal/Crc32LittleEndian.cs
@@ -21,6 +21,7 @@
 //
 
 using System;
+using System.Collections.Immutable;
 
 namespace DiscUtils.Internal;
 
@@ -29,16 +30,18 @@ namespace DiscUtils.Internal;
 /// </summary>
 internal sealed class Crc32LittleEndian : Crc32
 {
-    private static readonly uint[][] Tables;
+    private static readonly ImmutableArray<ImmutableArray<uint>> Tables;
 
     static Crc32LittleEndian()
     {
-        Tables = new uint[4][];
+        var tables = ImmutableArray.CreateBuilder<ImmutableArray<uint>>(4);
 
-        Tables[(int)Crc32Algorithm.Common] = CalcTable(0xEDB88320);
-        Tables[(int)Crc32Algorithm.Castagnoli] = CalcTable(0x82F63B78);
-        Tables[(int)Crc32Algorithm.Koopman] = CalcTable(0xEB31D82E);
-        Tables[(int)Crc32Algorithm.Aeronautical] = CalcTable(0xD5828281);
+        tables[(int)Crc32Algorithm.Common] = CalcTable(0xEDB88320);
+        tables[(int)Crc32Algorithm.Castagnoli] = CalcTable(0x82F63B78);
+        tables[(int)Crc32Algorithm.Koopman] = CalcTable(0xEB31D82E);
+        tables[(int)Crc32Algorithm.Aeronautical] = CalcTable(0xD5828281);
+
+        Tables = tables.ToImmutable();
     }
 
     public Crc32LittleEndian(Crc32Algorithm algorithm)
@@ -59,9 +62,9 @@ public override void Process(ReadOnlySpan<byte> buffer)
         _value = Process(Table, _value, buffer);
     }
 
-    private static uint[] CalcTable(uint polynomial)
+    private static ImmutableArray<uint> CalcTable(uint polynomial)
     {
-        var table = new uint[256];
+        var table = ImmutableArray.CreateBuilder<uint>(256);
 
         table[0] = 0;
         for (uint i = 0; i <= 255; ++i)
@@ -80,13 +83,13 @@ private static uint[] CalcTable(uint polynomial)
                 }
             }
 
-            table[i] = crc;
+            table[(int)i] = crc;
         }
 
-        return table;
+        return table.ToImmutable();
     }
 
-    private static uint Process(uint[] table, uint accumulator, ReadOnlySpan<byte> buffer)
+    private static uint Process(ImmutableArray<uint> table, uint accumulator, ReadOnlySpan<byte> buffer)
     {
         var value = accumulator;
 
@@ -95,7 +98,7 @@ private static uint Process(uint[] table, uint accumulator, ReadOnlySpan<byte> b
             var b = buffer[i];
 
             var temp1 = (value >> 8) & 0x00FFFFFF;
-            var temp2 = table[(value ^ b) & 0xFF];
+            var temp2 = table[(int)((value ^ b) & 0xFF)];
             value = temp1 ^ temp2;
         }
 
diff --git a/Library/DiscUtils.Core/Internal/VirtualDiskTransport.cs b/Library/DiscUtils.Core/Internal/VirtualDiskTransport.cs
@@ -35,7 +35,7 @@ public void Dispose()
         GC.SuppressFinalize(this);
     }
 
-    public abstract void Connect(Uri uri, string username, string password);
+    public abstract void Connect(Uri uri, string? username, string? password);
 
     public abstract VirtualDisk OpenDisk(FileAccess access);
 
diff --git a/Library/DiscUtils.Core/Partitions/GptEntry.cs b/Library/DiscUtils.Core/Partitions/GptEntry.cs
@@ -22,6 +22,7 @@
 
 using System;
 using System.Collections.Generic;
+using System.Collections.Immutable;
 using System.Text;
 using DiscUtils.Streams;
 
@@ -45,7 +46,7 @@ public GptEntry()
 
     public string FriendlyPartitionType => GetFriendlyPartitionType(PartitionType);
 
-    private static readonly Dictionary<Guid, string> _friendlyPartitionTypeNames = new()
+    private static readonly ImmutableDictionary<Guid, string> _friendlyPartitionTypeNames = new Dictionary<Guid, string>
     {
         { new Guid("00000000-0000-0000-0000-000000000000"), "Unused" },
         { new Guid("024DEE41-33E7-11D3-9D69-0008C781F39F"), "MBR Partition Scheme" },
@@ -95,7 +96,7 @@ public GptEntry()
         { new Guid("2E0A753D-9E48-43B0-8337-B15192CB1B5E"), "ChromeOS" },
         { new Guid("09845860-705F-4BB5-B16C-8A8A099CAF52"), "ChromeOS miniOS" },
         { new Guid("3F0F8318-F146-4E6B-8222-C28C8F02E0D5"), "ChromeOS hibernate" }
-    };
+    }.ToImmutableDictionary();
 
     public static string GetFriendlyPartitionType(Guid type)
         => _friendlyPartitionTypeNames.TryGetValue(type, out var name)
diff --git a/Library/DiscUtils.Core/PhysicalVolumeInfo.cs b/Library/DiscUtils.Core/PhysicalVolumeInfo.cs
diff --git a/Library/DiscUtils.Core/VirtualDisk.cs b/Library/DiscUtils.Core/VirtualDisk.cs
diff --git a/Library/DiscUtils.Core/WindowsSecurity/AccessControl/ObjectAce.cs b/Library/DiscUtils.Core/WindowsSecurity/AccessControl/ObjectAce.cs
diff --git a/Library/DiscUtils.Core/WindowsSecurity/SecurityIdentifier.cs b/Library/DiscUtils.Core/WindowsSecurity/SecurityIdentifier.cs
diff --git a/Library/DiscUtils.Core/WindowsSecurity/WellKnownAccount.cs b/Library/DiscUtils.Core/WindowsSecurity/WellKnownAccount.cs

Original file line number	Diff line number	Diff line change
`@@ -29,6 +29,7 @@`
`29`	`29`	`//`
`30`	`30`
`31`	`31`	`using System;`
	`32`	`+using System.Collections.Immutable;`
`32`	`33`	`using DiscUtils.Streams;`
`33`	`34`
`34`	`35`	`namespace DiscUtils.Compression;`
`@@ -50,7 +51,7 @@ internal sealed class LZNT1 : BlockCompressor`
`50`	`51`	`// we assume each block is 4KB on decode also.`
`51`	`52`	`private const int FixedBlockSize = 0x1000;`
`52`	`53`
`53`		`- private static readonly byte[] _compressionBits = CalcCompressionBits();`
	`54`	`+ private static readonly ImmutableArray<byte> _compressionBits = CalcCompressionBits();`
`54`	`55`
`55`	`56`	`public LZNT1()`
`56`	`57`	`{`
`@@ -298,13 +299,13 @@ public override int Decompress(ReadOnlySpan<byte> source, Span<byte> decompresse`
`298`	`299`	`return destIdx;`
`299`	`300`	`}`
`300`	`301`
`301`		`- private static byte[] CalcCompressionBits()`
	`302`	`+ private static ImmutableArray<byte> CalcCompressionBits()`
`302`	`303`	`{`
`303`		`- var result = StreamUtilities.GetUninitializedArray<byte>(4096);`
	`304`	`+ var result = ImmutableArray.CreateBuilder<byte>(4096);`
`304`	`305`	`byte offsetBits = 0;`
`305`	`306`
`306`	`307`	`var y = 0x10;`
`307`		`- for (var x = 0; x < result.Length; x++)`
	`308`	`+ for (var x = 0; x < 4096; x++)`
`308`	`309`	`{`
`309`	`310`	`result[x] = (byte)(4 + offsetBits);`
`310`	`311`	`if (x == y)`
`@@ -314,6 +315,6 @@ private static byte[] CalcCompressionBits()`
`314`	`315`	`}`
`315`	`316`	`}`
`316`	`317`
`317`		`- return result;`
	`318`	`+ return result.ToImmutable();`
`318`	`319`	`}`
`319`	`320`	`}`
Original file line number	Diff line number	Diff line change
`@@ -21,6 +21,7 @@`
`21`	`21`	`//`
`22`	`22`
`23`	`23`	`using System;`
	`24`	`+using System.Collections.Immutable;`
`24`	`25`	`using System.Diagnostics.CodeAnalysis;`
`25`	`26`	`using System.IO;`
`26`	`27`	`using System.Threading;`
`@@ -36,10 +37,10 @@ namespace DiscUtils.Compression;`
`36`	`37`	`/// <remarks>This is not a general purpose LZX decompressor - it makes`
`37`	`38`	`/// simplifying assumptions, such as being able to load the entire stream`
`38`	`39`	`/// contents into memory..</remarks>`
`39`		`-internal class LzxStream : ReadOnlyCompatibilityStream`
	`40`	`+public class LzxStream : ReadOnlyCompatibilityStream`
`40`	`41`	`{`
`41`		`- private static readonly uint[] _positionSlots;`
`42`		`- private static readonly uint[] _extraBits;`
	`42`	`+ private static readonly ImmutableArray<uint> _positionSlots;`
	`43`	`+ private static readonly ImmutableArray<uint> _extraBits;`
`43`	`44`	`private HuffmanTree? _alignedOffsetTree;`
`44`	`45`
`45`	`46`	`private readonly LzxBitStream _bitStream;`
`@@ -59,23 +60,27 @@ internal class LzxStream : ReadOnlyCompatibilityStream`
`59`	`60`
`60`	`61`	`static LzxStream()`
`61`	`62`	`{`
`62`		`- _positionSlots = new uint[50];`
`63`		`- _extraBits = new uint[50];`
	`63`	`+ var positionSlots = ImmutableArray.CreateBuilder<uint>(50);`
	`64`	`+ var extraBits = ImmutableArray.CreateBuilder<uint>(50);`
`64`	`65`
`65`	`66`	`uint numBits = 0;`
`66`		`- _positionSlots[1] = 1;`
	`67`	`+ positionSlots[1] = 1;`
	`68`	`+`
`67`	`69`	`for (var i = 2; i < 50; i += 2)`
`68`	`70`	`{`
`69`		`- _extraBits[i] = numBits;`
`70`		`- _extraBits[i + 1] = numBits;`
`71`		`- _positionSlots[i] = _positionSlots[i - 1] + (uint)(1 << (int)_extraBits[i - 1]);`
`72`		`- _positionSlots[i + 1] = _positionSlots[i] + (uint)(1 << (int)numBits);`
	`71`	`+ extraBits[i] = numBits;`
	`72`	`+ extraBits[i + 1] = numBits;`
	`73`	`+ positionSlots[i] = positionSlots[i - 1] + (uint)(1 << (int)extraBits[i - 1]);`
	`74`	`+ positionSlots[i + 1] = positionSlots[i] + (uint)(1 << (int)numBits);`
`73`	`75`
`74`	`76`	`if (numBits < 17)`
`75`	`77`	`{`
`76`	`78`	`numBits++;`
`77`	`79`	`}`
`78`	`80`	`}`
	`81`	`+`
	`82`	`+ _positionSlots = positionSlots.ToImmutable();`
	`83`	`+ _extraBits = extraBits.ToImmutable();`
`79`	`84`	`}`
`80`	`85`
`81`	`86`	`public LzxStream(Stream stream, int windowBits, int fileSize)`
`@@ -285,7 +290,7 @@ private void DecodeCompressedBlock(BlockType blockType, int blockSize)`
`285`	`290`	`}`
`286`	`291`	`else`
`287`	`292`	`{`
`288`		`- var extra = (int)_extraBits[positionSlot];`
	`293`	`+ var extra = (int)_extraBits[(int)positionSlot];`
`289`	`294`
`290`	`295`	`uint formattedOffset;`
`291`	`296`
`@@ -304,13 +309,13 @@ private void DecodeCompressedBlock(BlockType blockType, int blockSize)`
`304`	`309`	`verbatimBits = _bitStream.Read(extra);`
`305`	`310`	`}`
`306`	`311`
`307`		`- formattedOffset = _positionSlots[positionSlot] + verbatimBits + alignedBits;`
	`312`	`+ formattedOffset = _positionSlots[(int)positionSlot] + verbatimBits + alignedBits;`
`308`	`313`	`}`
`309`	`314`	`else`
`310`	`315`	`{`
`311`	`316`	`var verbatimBits = extra > 0 ? _bitStream.Read(extra) : 0;`
`312`	`317`
`313`		`- formattedOffset = _positionSlots[positionSlot] + verbatimBits;`
	`318`	`+ formattedOffset = _positionSlots[(int)positionSlot] + verbatimBits;`
`314`	`319`	`}`
`315`	`320`
`316`	`321`	`matchOffset = formattedOffset - 2;`
Original file line number	Diff line number	Diff line change
`@@ -1,4 +1,5 @@`
`1`		`-using System.Text;`
	`1`	`+using System;`
	`2`	`+using System.Text;`
`2`	`3`
`3`	`4`	`namespace DiscUtils.CoreCompat;`
`4`	`5`
`@@ -20,11 +21,9 @@ public static void RegisterEncodings()`
`20`	`21`	`#endif`
`21`	`22`	`}`
`22`	`23`
`23`		`- private static readonly char[] _invalidFileNameChars = ['\\', '/', '*', '?', ':'];`
`24`		`-`
`25`	`24`	`public static string SanitizeFileName(this string fileName)`
`26`	`25`	`{`
`27`		`- foreach (var c in _invalidFileNameChars)`
	`26`	`+ foreach (var c in stackalloc char[] { '\\', '/', '*', '?', ':' })`
`28`	`27`	`{`
`29`	`28`	`fileName = fileName.Replace(c, '_');`
`30`	`29`	`}`
Original file line number	Diff line number	Diff line change
`@@ -112,7 +112,7 @@ private static void InitializeMaps()`
`112`	`112`	`var attr = type.GetCustomAttribute<VirtualDiskFactoryAttribute>(false);`
`113`	`113`	`if (attr != null)`
`114`	`114`	`{`
`115`		`- var factory = (VirtualDiskFactory)Activator.CreateInstance(type);`
	`115`	`+ var factory = (VirtualDiskFactory)Activator.CreateInstance(type)!;`
`116`	`116`	`typeMap.Add(attr.Type, factory);`
`117`	`117`	`}`
`118`	`118`	`}`
Original file line number	Diff line number	Diff line change
`@@ -36,7 +36,7 @@ internal sealed class FileTransport : VirtualDiskTransport`
`36`	`36`	`public override bool IsRawDisk => false;`
`37`	`37`
`38`	`38`	`[MemberNotNull(nameof(_path), nameof(_extraInfo))]`
`39`		`- public override void Connect(Uri uri, string username, string password)`
	`39`	`+ public override void Connect(Uri uri, string? username, string? password)`
`40`	`40`	`{`
`41`	`41`	`_path = uri.LocalPath;`
`42`	`42`	`_extraInfo = uri.Fragment.TrimStart('#');`