サイレント catch を解消してテキスト比較フォールバックと .NET 判定失敗の診断性を改善

Author: Widthdom

CHANGELOG.md

@@ -14,6 +14,7 @@ The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.1.0/),
 - Moved aggregated `MD5Mismatch` console warnings into `ProgramRunner`, kept `ReportGenerateService` report-only, and updated related docs and automated tests.
 - Replaced one-off `string.Format(...)` usage with interpolated strings, removed broad `#region` usage, and deleted now-unused format/message constants.
 - Updated the developer and testing guides to reflect the current source-style expectations and latest passing test count.
+- Made `.NET` executable detection distinguish `NotDotNetExecutable` from detection failure, log a warning for non-fatal detection failures, and let chunk-parallel text-diff exceptions bubble to the existing sequential fallback path instead of silently returning `false`.
 
 ### [1.2.2] - 2026-03-14
 
@@ -210,6 +211,7 @@ The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.1.0/),
 - 集約後の `MD5Mismatch` コンソール警告を `ProgramRunner` に移し、`ReportGenerateService` はレポート専用の責務に整理しました。あわせて関連ドキュメントと自動テストを更新しました。
 - 単発利用の `string.Format(...)` を補間文字列へ置き換え、広範な `#region` 利用をやめ、不要になった書式・メッセージ定数を削除しました。
 - 開発ガイドとテストガイドを更新し、現在のソースコード方針と最新の通過テスト件数を反映しました。
+- `.NET` 実行可能判定で `NotDotNetExecutable` と判定失敗を区別するようにし、致命ではない判定失敗は warning を残して継続するようにしました。あわせて並列テキスト比較の例外は `false` に潰さず、既存の逐次比較フォールバック経路へ伝播させるようにしました。
 
 ### [1.2.2] - 2026-03-14
 

FolderDiffIL4DotNet.Tests/Services/FileDiffServiceTests.cs

@@ -1,6 +1,7 @@
 using System;
 using System.Collections.Generic;
 using System.IO;
+using System.Linq;
 using System.Threading.Tasks;
 using FolderDiffIL4DotNet.Models;
 using FolderDiffIL4DotNet.Services;
@@ -89,20 +90,75 @@ public async Task FilesAreEqualAsync_WhenPrimaryTextDiffThrows_LogsWarningAndFal
 
                 Assert.False(areEqual);
                 Assert.Equal(FileDiffResultLists.DiffDetailResult.TextMismatch, resultLists.FileRelativePathToDiffDetailDictionary[fileRelativePath]);
-                var warningLog = Assert.Single(logger.Entries, entry => entry.LogLevel == AppLogLevel.Warning);
+                var warningLog = Assert.Single(logger.Entries, entry => entry.LogLevel == AppLogLevel.Warning && entry.Message.Contains("Falling back to sequential text diff", StringComparison.Ordinal));
                 Assert.Contains("Falling back to sequential text diff", warningLog.Message);
                 Assert.IsType<IOException>(warningLog.Exception);
+                Assert.Contains(logger.Entries, entry => entry.LogLevel == AppLogLevel.Warning && entry.Message.Contains("Failed to detect whether 'sample.txt' is a .NET executable", StringComparison.Ordinal));
             }
             finally
             {
                 exclusiveLockStream?.Dispose();
             }
         }
 
+        [Fact]
+        public async Task FilesAreEqualAsync_WhenParallelTextDiffThrows_LogsWarningAndFallsBackToSequentialDiff()
+        {
+            var oldDir = Path.Combine(_rootDir, "old-parallel");
+            var newDir = Path.Combine(_rootDir, "new-parallel");
+            Directory.CreateDirectory(oldDir);
+            Directory.CreateDirectory(newDir);
+
+            const string fileRelativePath = "large.txt";
+            var oldFileAbsolutePath = Path.Combine(oldDir, fileRelativePath);
+            var newFileAbsolutePath = Path.Combine(newDir, fileRelativePath);
+            File.WriteAllText(oldFileAbsolutePath, new string('A', 2048));
+            File.WriteAllText(newFileAbsolutePath, new string('B', 2048));
+
+            var config = new ConfigSettings
+            {
+                TextFileExtensions = new List<string> { ".txt" },
+                IgnoredExtensions = new List<string>(),
+                ShouldOutputILText = false,
+                EnableILCache = false,
+                OptimizeForNetworkShares = false,
+                TextDiffParallelThresholdKilobytes = 1,
+                TextDiffChunkSizeKilobytes = 1
+            };
+
+            var logger = new TestLogger();
+            var resultLists = new FileDiffResultLists();
+            var executionContext = new DiffExecutionContext(
+                oldDir,
+                newDir,
+                Path.Combine(_rootDir, "report-parallel"),
+                optimizeForNetworkShares: false,
+                detectedNetworkOld: false,
+                detectedNetworkNew: false);
+
+            var ilTextOutputService = new ILTextOutputService(executionContext, logger);
+            var dotNetDisassembleService = new DotNetDisassembleService(config, ilCache: null, resultLists, logger, new DotNetDisassemblerCache(logger));
+            var ilOutputService = new ILOutputService(config, executionContext, ilTextOutputService, dotNetDisassembleService, ilCache: null, logger);
+            var service = new FileDiffService(config, ilOutputService, executionContext, resultLists, logger);
+
+            var areEqual = await service.FilesAreEqualAsync(fileRelativePath, maxParallel: 0);
+
+            Assert.False(areEqual);
+            Assert.Equal(FileDiffResultLists.DiffDetailResult.TextMismatch, resultLists.FileRelativePathToDiffDetailDictionary[fileRelativePath]);
+            var warningLog = Assert.Single(logger.Entries, entry => entry.LogLevel == AppLogLevel.Warning);
+            Assert.Contains("Falling back to sequential text diff", warningLog.Message);
+            Assert.IsType<ArgumentOutOfRangeException>(warningLog.Exception);
+        }
+
         private sealed class TestLogger : ILoggerService
         {
             private readonly Action<LogEntry> _onEntry;
 
+            public TestLogger()
+                : this(null)
+            {
+            }
+
             public TestLogger(Action<LogEntry> onEntry)
             {
                 _onEntry = onEntry;

FolderDiffIL4DotNet.Tests/Utils/DotNetDetectorTests.cs

@@ -61,6 +61,17 @@ public void IsDotNetExecutable_NonexistentFile_ReturnsFalse()
             Assert.False(DotNetDetector.IsDotNetExecutable(Path.Combine(_tempDir, "nonexistent.dll")));
         }
 
+        [Fact]
+        public void DetectDotNetExecutable_NonexistentFile_ReturnsFailedWithException()
+        {
+            var result = DotNetDetector.DetectDotNetExecutable(Path.Combine(_tempDir, "nonexistent.dll"));
+
+            Assert.Equal(DotNetExecutableDetectionStatus.Failed, result.Status);
+            Assert.False(result.IsDotNetExecutable);
+            Assert.True(result.IsFailure);
+            Assert.IsType<FileNotFoundException>(result.Exception);
+        }
+
         [Fact]
         public void IsDotNetExecutable_RandomBytes_ReturnsFalse()
         {
@@ -71,6 +82,19 @@ public void IsDotNetExecutable_RandomBytes_ReturnsFalse()
             Assert.False(DotNetDetector.IsDotNetExecutable(file));
         }
 
+        [Fact]
+        public void DetectDotNetExecutable_TextFile_ReturnsNotDotNet()
+        {
+            var file = CreateTempFile("plain.txt", "This is not a PE file");
+
+            var result = DotNetDetector.DetectDotNetExecutable(file);
+
+            Assert.Equal(DotNetExecutableDetectionStatus.NotDotNetExecutable, result.Status);
+            Assert.False(result.IsDotNetExecutable);
+            Assert.False(result.IsFailure);
+            Assert.Null(result.Exception);
+        }
+
         [Fact]
         public void IsDotNetExecutable_MinimalMZHeader_NoCLR_ReturnsFalse()
         {

README.md

@@ -108,7 +108,7 @@ Important details:
 - `Added`, `Removed`, `Unchanged`, and `Modified` are decided by relative path, not by file name alone.
 - IL comparison always ignores `// MVID:` lines, so build-specific assembly noise does not create false differences.
 - If `ShouldIgnoreILLinesContainingConfiguredStrings=true`, lines containing any configured ignore string are also skipped during IL comparison.
-- Text files may use different internal strategies depending on size and runtime mode, but the final result is still just text match or text mismatch.
+- Text files may use different internal strategies depending on size and runtime mode. If chunk-parallel comparison for a large local file throws, the run logs a warning and retries with sequential text comparison.
 - If IL comparison itself fails, the run stops instead of silently falling back to a weaker comparison.
 
 ## Configuration (`config.json`)
@@ -370,7 +370,7 @@ flowchart TD
 - `Added` / `Removed` / `Unchanged` / `Modified` は、ファイル名だけでなく相対パスを基準に決まります。
 - IL 比較では `// MVID:` 行を常に無視するため、ビルドごとの差分だけで別物扱いになりにくくしています。
 - `ShouldIgnoreILLinesContainingConfiguredStrings=true` の場合は、設定した文字列を含む行も IL 比較から除外します。
-- テキスト比較の内部実装はファイルサイズや実行モードで変わることがありますが、最終結果はテキスト一致か不一致です。
+- テキスト比較の内部実装はファイルサイズや実行モードで変わることがあります。大きいローカルファイルの並列比較で例外が出た場合は warning を記録し、逐次比較へフォールバックします。
 - IL 比較そのものに失敗した場合は、弱い比較へ黙って落とさず、その実行全体を停止します。
 
 ## 設定（`config.json`）

Services/FileDiffService.cs

@@ -121,7 +121,17 @@ public async Task<bool> FilesAreEqualAsync(string fileRelativePath, int maxParal
                 }
 
                 // 2) .NET アセンブリなら IL: IL 比較は行除外（MVID や設定文字列）などアセンブリ固有処理を伴うため別サービスに委譲。
-                if (DotNetDetector.IsDotNetExecutable(file1AbsolutePath))
+                var dotNetDetectionResult = DotNetDetector.DetectDotNetExecutable(file1AbsolutePath);
+                if (dotNetDetectionResult.IsFailure)
+                {
+                    _logger.LogMessage(
+                        AppLogLevel.Warning,
+                        $"Failed to detect whether '{fileRelativePath}' is a .NET executable. Skipping IL diff.",
+                        shouldOutputMessageToConsole: true,
+                        dotNetDetectionResult.Exception);
+                }
+
+                if (dotNetDetectionResult.IsDotNetExecutable)
                 {
                     try
                     {
@@ -200,83 +210,78 @@ public async Task<bool> FilesAreEqualAsync(string fileRelativePath, int maxParal
         /// <summary>
         /// サイズが閾値を超えるテキストファイルに対して高速化を目的に並列チャンク比較を行う実験的メソッド。
         /// 完全一致判定のみを行い、差分箇所の特定は行いません。
-        /// なお、本メソッドはエラーや引数不正が発生した場合でも例外を呼出し側へ送出せず、false を返します。
+        /// エラーや引数不正は呼び出し側へ送出し、呼び出し側で逐次比較へのフォールバック可否を判断します。
         /// </summary>
         /// <param name="file1AbsolutePath">ファイル1の絶対パス</param>
         /// <param name="file2AbsolutePath">ファイル2の絶対パス</param>
         /// <param name="largeFileSizeThresholdBytes">並列化閾値（バイト）。これ未満は逐次比較。</param>
         /// <param name="chunkSizeBytes">チャンクサイズ（バイト）。</param>
         /// <param name="maxParallel">最大並列度</param>
-        /// <returns>一致すれば true。エラーや引数不正時は false。</returns>
+        /// <returns>一致すれば true。不一致なら false。</returns>
+        /// <exception cref="ArgumentOutOfRangeException"><paramref name="maxParallel"/> が 0 以下の場合。</exception>
+        /// <exception cref="Exception">チャンク読み取りや比較準備で予期しない例外が発生した場合。</exception>
         private static async Task<bool> DiffTextFilesParallelAsync(string file1AbsolutePath, string file2AbsolutePath, long largeFileSizeThresholdBytes, int chunkSizeBytes, int maxParallel)
         {
-            try
+            var file1Info = new FileInfo(file1AbsolutePath);
+            var file2Info = new FileInfo(file2AbsolutePath);
+            // どちらかが存在しない、またはサイズが異なる場合は比較するまでもなく不一致。
+            if (!file1Info.Exists || !file2Info.Exists)
             {
-                var file1Info = new FileInfo(file1AbsolutePath);
-                var file2Info = new FileInfo(file2AbsolutePath);
-                // どちらかが存在しない、またはサイズが異なる場合は比較するまでもなく不一致。
-                if (!file1Info.Exists || !file2Info.Exists)
-                {
-                    return false;
-                }
-                if (file1Info.Length != file2Info.Length)
+                return false;
+            }
+            if (file1Info.Length != file2Info.Length)
+            {
+                return false;
+            }
+            // 小さいファイルは既存の逐次比較に委譲して余計なオーバーヘッドを避ける。
+            if (file1Info.Length < largeFileSizeThresholdBytes)
+            {
+                return await FileComparer.DiffTextFilesAsync(file1AbsolutePath, file2AbsolutePath);
+            }
+            if (maxParallel <= 0)
+            {
+                throw new ArgumentOutOfRangeException(nameof(maxParallel), maxParallel, Constants.ERROR_MAX_PARALLEL);
+            }
+
+            // 大きなファイルは固定サイズのチャンクに分割し、読み取り→比較を並列実行する。
+            int chunkCount = (int)((file1Info.Length + chunkSizeBytes - 1) / chunkSizeBytes);
+            var differences = 0;
+            await Parallel.ForEachAsync(Enumerable.Range(0, chunkCount), new ParallelOptions { MaxDegreeOfParallelism = maxParallel }, async (index, cancellationToken) =>
+            {
+                // 既に差分が見つかっていれば以降のチャンクは読む必要がない。
+                if (Volatile.Read(ref differences) != 0)
                 {
-                    return false;
+                    return;
                 }
-                // 小さいファイルは既存の逐次比較に委譲して余計なオーバーヘッドを避ける。
-                if (file1Info.Length < largeFileSizeThresholdBytes)
+                var buffer1 = new byte[chunkSizeBytes];
+                var buffer2 = new byte[chunkSizeBytes];
+                int read1, read2;
+                using (var file1Stream = new FileStream(file1AbsolutePath, FileMode.Open, FileAccess.Read, FileShare.Read))
+                using (var file2Stream = new FileStream(file2AbsolutePath, FileMode.Open, FileAccess.Read, FileShare.Read))
                 {
-                    return await FileComparer.DiffTextFilesAsync(file1AbsolutePath, file2AbsolutePath);
+                    file1Stream.Seek((long)index * chunkSizeBytes, SeekOrigin.Begin);
+                    file2Stream.Seek((long)index * chunkSizeBytes, SeekOrigin.Begin);
+                    read1 = await file1Stream.ReadAsync(buffer1.AsMemory(0, chunkSizeBytes), cancellationToken);
+                    read2 = await file2Stream.ReadAsync(buffer2.AsMemory(0, chunkSizeBytes), cancellationToken);
                 }
-                if (maxParallel <= 0)
+                // 同じオフセットのチャンクでも読み取りバイト数が異なれば即時不一致。
+                if (read1 != read2)
                 {
-                    throw new ArgumentOutOfRangeException(nameof(maxParallel), maxParallel, Constants.ERROR_MAX_PARALLEL);
+                    Interlocked.Exchange(ref differences, 1);
+                    return;
                 }
-
-                // 大きなファイルは固定サイズのチャンクに分割し、読み取り→比較を並列実行する。
-                int chunkCount = (int)((file1Info.Length + chunkSizeBytes - 1) / chunkSizeBytes);
-                var differences = 0;
-                await Parallel.ForEachAsync(Enumerable.Range(0, chunkCount), new ParallelOptions { MaxDegreeOfParallelism = maxParallel }, async (index, cancellationToken) =>
+                // チャンク内で1バイトでも異なれば不一致とし、他チャンクも打ち切る。
+                for (int i = 0; i < read1; i++)
                 {
-                    // 既に差分が見つかっていれば以降のチャンクは読む必要がない。
-                    if (Volatile.Read(ref differences) != 0)
-                    {
-                        return;
-                    }
-                    var buffer1 = new byte[chunkSizeBytes];
-                    var buffer2 = new byte[chunkSizeBytes];
-                    int read1, read2;
-                    using (var file1Stream = new FileStream(file1AbsolutePath, FileMode.Open, FileAccess.Read, FileShare.Read))
-                    using (var file2Stream = new FileStream(file2AbsolutePath, FileMode.Open, FileAccess.Read, FileShare.Read))
-                    {
-                        file1Stream.Seek((long)index * chunkSizeBytes, SeekOrigin.Begin);
-                        file2Stream.Seek((long)index * chunkSizeBytes, SeekOrigin.Begin);
-                        read1 = await file1Stream.ReadAsync(buffer1.AsMemory(0, chunkSizeBytes), cancellationToken);
-                        read2 = await file2Stream.ReadAsync(buffer2.AsMemory(0, chunkSizeBytes), cancellationToken);
-                    }
-                    // 同じオフセットのチャンクでも読み取りバイト数が異なれば即時不一致。
-                    if (read1 != read2)
+                    if (buffer1[i] != buffer2[i])
                     {
                         Interlocked.Exchange(ref differences, 1);
-                        return;
+                        break;
                     }
-                    // チャンク内で1バイトでも異なれば不一致とし、他チャンクも打ち切る。
-                    for (int i = 0; i < read1; i++)
-                    {
-                        if (buffer1[i] != buffer2[i])
-                        {
-                            Interlocked.Exchange(ref differences, 1);
-                            break;
-                        }
-                    }
-                });
-                // 差分フラグが立っていなければ完全一致。
-                return differences == 0;
-            }
-            catch
-            {
-                return false;
-            }
+                }
+            });
+            // 差分フラグが立っていなければ完全一致。
+            return differences == 0;
         }
 
         /// <summary>