メインコンテンツへスキップ
見出し画像

🔰C#プロプログラマーへの道💻第0003講|【Core】環境情報を集める診断サービスを作る

    【プロローグ】

    ミライ「前回、診断画面を作りました。でも、診断開始ボタンを押しても何も起きません。」
    神崎先生「はい。受付カウンターは完成しましたが、検査をする人がまだいません。」
    ミライ「今回は、SDKやPostgreSQLを実際に調べる処理を作るのですね。」
    神崎先生「そのとおりです。ただし、診断処理をMainWindowへ直接書いてはいけません。」
    ミライ「画面のボタンを押して動かすのに、画面へ書かないのですか。」
    神崎先生「診断するのは画面ではありません。画面は依頼を出し、結果を表示するだけです。」
    ミライ「診断を担当する専用の部品を作るのですね。」
    神崎先生「それが今回の診断サービスです。画面は受付、診断サービスは検査室です。受付係に血液検査までさせると、病院の組織図が急に不安になります。」

    【前回から今回へのつながり】

    第0001講では、開発環境診断ツールの利用者、利用場面、完成条件を決めました。
    第0002講では、WPFで次の画面部品を作りました。
    ・PostgreSQL接続先の入力欄
    ・.NET SDKの診断結果欄
    ・IDEの診断結果欄
    ・PostgreSQL接続の診断結果欄
    ・Windows情報の診断結果欄
    ・作業フォルダーの診断結果欄
    ・診断開始ボタン
    しかし、表示されている「未診断」は固定された文字でした。
    今回は、画面から独立したEnvironmentDiagnostic.Coreプロジェクトを追加し、次の診断を実行するC#の部品を作ります。
    ・.NET 10 SDKが導入されているか確認する
    ・Visual Studioが導入されているか確認する
    ・Windowsと.NETの実行環境を取得する
    ・作業フォルダーへ書き込めるか確認する
    ・PostgreSQLへ接続できるか確認する
    ・すべての結果を一つの診断報告へまとめる
    ・WPFの診断開始ボタンから呼び出して結果を表示する
    今回から、画面に固定されていた「未診断」が、本物の診断結果へ変わります。

    【今回作るもの】

    今回作る中心部品は、EnvironmentDiagnosticServiceです。
    このサービスは、WPFのButtonやTextBlockを知りません。
    受け取るものはPostgreSQLの接続設定です。
    返すものは、五つの診断結果をまとめたEnvironmentDiagnosticReportです。
    処理の流れは次のようになります。
    1.利用者がWPF画面の「診断を開始」を押す
    2.WPFがPostgreSQLの入力内容を読み取る
    3.WPFが診断サービスへ接続設定を渡す
    4.診断サービスがSDK、IDE、DB、Windows、フォルダーを調べる
    5.診断サービスが一つの診断報告を返す
    6.WPFが診断報告を画面へ表示する
    ミライ「診断サービスの中には、画面の色を変える処理を書かないのですか。」
    神崎先生「書きません。緑色や赤色を決めるのは画面の仕事です。診断サービスは、正常、注意、異常という事実だけを返します。」

    【Coreとは何か】

    質問:今回のCoreは何を表していますか。
    回答:画面から独立し、アプリの中心となる処理を置くプロジェクトです。
    今回のソリューションには、次の二つのプロジェクトが存在することになります。
    ・EnvironmentDiagnostic.Desktop:WPFの画面を担当する
    ・EnvironmentDiagnostic.Core:環境診断の処理を担当する
    Coreプロジェクトでは、次のものを使用しません。
    ・Window
    ・Button
    ・TextBlock
    ・Brushes
    ・MessageBox
    これらはWPF固有の部品だからです。
    一方、次のものはCoreへ置けます。
    ・診断状態
    ・診断結果
    ・データベース接続設定
    ・診断報告
    ・環境情報を集める処理
    Coreを画面から独立させることで、後からWPF、Blazor、テストプログラムなど、複数の入口から同じ診断処理を呼び出せます。


    【1|Coreプロジェクトを追加する】

    1.クラスライブラリを追加する

    Visual Studioのソリューションエクスプローラーで、ソリューションEnvironmentDiagnosticを右クリックします。
    次の順番で選択します。
    1.追加
    2.新しいプロジェクト
    3.クラスライブラリ
    プロジェクト名を次のようにします。

    EnvironmentDiagnostic.Core

    フレームワークは、Desktopプロジェクトと同じ.NET 10.0を選択します。
    質問:なぜ、もう一つWPFプロジェクトを作らないのですか。
    回答:Coreには画面が必要ないからです。クラスライブラリは、他のプロジェクトから利用するC#の部品を作るためのプロジェクトです。

    2.Class1.csを削除する

    プロジェクト作成時に生成されたClass1.csは使用しません。
    ソリューションエクスプローラーでClass1.csを右クリックし、削除します。

    3.一度ビルドする

    メニューから次の操作を行います。

    ビルド → ソリューションのビルド

    エラーがなければ、Coreプロジェクトの追加は成功です。

    【2|PostgreSQL接続用のNpgsqlを追加する】

    PostgreSQLへC#から接続するため、Npgsqlを追加します。
    EnvironmentDiagnostic.Coreを右クリックし、次の順番で選択します。
    1.NuGetパッケージの管理
    2.参照
    3.検索欄へNpgsqlと入力
    4.Npgsqlを選択
    5.安定版をインストール
    パッケージのバージョンは更新されるため、特別な理由がなければ、その時点の安定版を選択します。
    Npgsqlでは、接続文字列からデータソースを作り、非同期でPostgreSQLへ接続できます。接続文字列の項目には、ホスト、ポート、データベース名、利用者名、パスワード、タイムアウトなどがあります。Npgsql Documentation
    ミライ「接続文字列を自分で文字列連結してもよいですか。」
    神崎先生「動く場合はありますが、今回はNpgsqlConnectionStringBuilderを使います。」
    ミライ「なぜですか。」
    神崎先生「値の区切りや特殊文字を、接続文字列の規則に従って扱ってくれるからです。接続文字列は、手作りの数珠ではありません。」

    【3|診断状態を作る】

    EnvironmentDiagnostic.Coreを右クリックし、次のファイルを追加します。

    DiagnosticState.cs

    内容を次のようにします。

    namespace EnvironmentDiagnostic.Core;
    public enum DiagnosticState
    {
        Success,
        Warning,
        Error
    }

    質問:なぜ状態を文字列で保存しないのですか。
    回答:文字列では、Success、success、正常、成功など、同じ意味の表記が増える可能性があるからです。
    enumを使うと、使用できる状態を次の三つへ限定できます。
    ・Success:正常
    ・Warning:注意
    ・Error:異常
    ミライ「未診断は必要ありませんか。」
    神崎先生「未診断は画面を開いた直後の状態です。今回の診断サービスは、実行後の結果を返すため、三つで足ります。」

    【4|一件分の診断結果を作る】

    次のファイルを追加します。

    DiagnosticResult.cs

    内容を次のようにします。

    namespace EnvironmentDiagnostic.Core;
    public sealed record DiagnosticResult(
        DiagnosticState State,
        string Message)
    {
        public static DiagnosticResult Success(string message)
            => new(DiagnosticState.Success, message);
        public static DiagnosticResult Warning(string message)
            => new(DiagnosticState.Warning, message);
        public static DiagnosticResult Error(string message)
            => new(DiagnosticState.Error, message);
    }

    質問:DiagnosticResultには何が入りますか。
    回答:診断状態と、利用者へ伝える説明が入ります。
    たとえば、SDKが見つかった場合は次のような結果になります。

    State   :Success
    Message :.NET 10 SDKを検出しました。

    PostgreSQLへ接続できなかった場合は、次のような結果になります。

    State   :Error
    Message :PostgreSQLへ接続できません。

    質問:classではなくrecordを使うのはなぜですか。
    回答:今回は、診断結果という一まとまりのデータを表すことが主な目的だからです。
    recordは、処理を大量に抱える部品よりも、意味のあるデータを表す部品に適しています。
    Success、Warning、Errorというメソッドは、診断結果を読みやすく作るために用意しています。

    DiagnosticResult.Success("SDKを検出しました。")

    この一行で、正常状態と説明をまとめて作れます。

    【5|PostgreSQL接続設定を作る】

    次のファイルを追加します。

    DatabaseConnectionSettings.cs

    内容を次のようにします。

    namespace EnvironmentDiagnostic.Core;
    public sealed record DatabaseConnectionSettings(
        string Host,
        int Port,
        string Database,
        string Username,
        string Password);

    この部品は、WPF画面へ入力された次の値を診断サービスへ渡します。
    ・サーバー名
    ・ポート番号
    ・データベース名
    ・利用者名
    ・パスワード
    ミライ「パスワードも診断報告へ保存するのですか。」
    神崎先生「保存しません。パスワードは接続確認の間だけ使います。」
    ミライ「接続設定には入るけれど、診断結果には入れないのですね。」
    神崎先生「その区別が重要です。鍵を使って扉を開けても、検査報告書へ鍵の刻み方まで印刷してはいけません。」

    【6|五つの結果をまとめる診断報告を作る】

    次のファイルを追加します。

    EnvironmentDiagnosticReport.cs

    内容を次のようにします。

    namespace EnvironmentDiagnostic.Core;
    public sealed record EnvironmentDiagnosticReport(
        string MachineName,
        DateTimeOffset CheckedAt,
        DiagnosticResult Sdk,
        DiagnosticResult Ide,
        DiagnosticResult Database,
        DiagnosticResult OperatingSystem,
        DiagnosticResult WorkFolder);

    この診断報告には、次の情報がまとまります。
    ・診断したコンピューター名
    ・診断した日時
    ・SDKの診断結果
    ・IDEの診断結果
    ・PostgreSQLの診断結果
    ・Windowsの診断結果
    ・作業フォルダーの診断結果
    質問:なぜ結果を個別に返さず、一つの報告へまとめるのですか。
    回答:後から表示、保存、送信するときに、一回分の診断を一つのデータとして扱えるからです。
    第0004講では、このEnvironmentDiagnosticReportをJSONへ保存します。
    診断報告にはパスワードが含まれていません。したがって、次回JSONへ変換しても、パスワードは保存されません。

    【7|診断サービスを作る】

    次のファイルを追加します。

    EnvironmentDiagnosticService.cs

    内容を次のようにします。

    using System.Diagnostics;
    using System.Runtime.InteropServices;
    using Npgsql;
    namespace EnvironmentDiagnostic.Core;
    public sealed class EnvironmentDiagnosticService
    {
        public async Task<EnvironmentDiagnosticReport> RunAsync(
            DatabaseConnectionSettings databaseSettings,
            CancellationToken cancellationToken = default)
        {
            DiagnosticResult sdkResult =
                await CheckSdkAsync(cancellationToken);
            DiagnosticResult ideResult =
                await CheckIdeAsync(cancellationToken);
            DiagnosticResult databaseResult =
                await CheckDatabaseAsync(
                    databaseSettings,
                    cancellationToken);
            DiagnosticResult operatingSystemResult =
                CheckOperatingSystem();
            DiagnosticResult workFolderResult =
                await CheckWorkFolderAsync(cancellationToken);
            return new EnvironmentDiagnosticReport(
                Environment.MachineName,
                DateTimeOffset.Now,
                sdkResult,
                ideResult,
                databaseResult,
                operatingSystemResult,
                workFolderResult);
        }
        private static async Task<DiagnosticResult> CheckSdkAsync(
            CancellationToken cancellationToken)
        {
            try
            {
                ProcessOutput process = await RunProcessAsync(
                    "dotnet",
                    new[] { "--list-sdks" },
                    cancellationToken);
                if (process.ExitCode != 0)
                {
                    string detail =
                        string.IsNullOrWhiteSpace(process.Error)
                            ? $"終了コード:{process.ExitCode}"
                            : process.Error;
                    return DiagnosticResult.Error(
                        $".NET SDKを確認できません。{detail}");
                }
                string[] sdkLines = process.Output.Split(
                    Environment.NewLine,
                    StringSplitOptions.RemoveEmptyEntries |
                    StringSplitOptions.TrimEntries);
                if (sdkLines.Length == 0)
                {
                    return DiagnosticResult.Error(
                        ".NET SDKが見つかりません。");
                }
                bool hasDotNet10 = Array.Exists(
                    sdkLines,
                    line => line.StartsWith(
                        "10.",
                        StringComparison.Ordinal));
                string latestSdk = sdkLines[^1];
                if (!hasDotNet10)
                {
                    return DiagnosticResult.Warning(
                        $"{sdkLines.Length}個のSDKを検出しましたが、" +
                        $".NET 10 SDKは見つかりません。最新候補:{latestSdk}");
                }
                return DiagnosticResult.Success(
                    $"{sdkLines.Length}個のSDKを検出しました。" +
                    $".NET 10を利用できます。最新候補:{latestSdk}");
            }
            catch (OperationCanceledException)
            {
                throw;
            }
            catch (Exception ex)
            {
                return DiagnosticResult.Error(
                    $".NET SDKの確認中に問題が発生しました。{ex.Message}");
            }
        }
        private static async Task<DiagnosticResult> CheckIdeAsync(
            CancellationToken cancellationToken)
        {
            try
            {
                string programFilesX86 =
                    Environment.GetFolderPath(
                        Environment.SpecialFolder.ProgramFilesX86);
                if (string.IsNullOrWhiteSpace(programFilesX86))
                {
                    return DiagnosticResult.Warning(
                        "Visual Studioの確認先を取得できません。");
                }
                string vsWherePath = Path.Combine(
                    programFilesX86,
                    "Microsoft Visual Studio",
                    "Installer",
                    "vswhere.exe");
                if (!File.Exists(vsWherePath))
                {
                    return DiagnosticResult.Warning(
                        "Visual Studioを確認するvswhere.exeが見つかりません。" +
                        ".NET SDKとコマンド操作で開発できる場合があります。");
                }
                ProcessOutput process = await RunProcessAsync(
                    vsWherePath,
                    new[]
                    {
                        "-latest",
                        "-products",
                        "*",
                        "-property",
                        "displayName"
                    },
                    cancellationToken);
                if (process.ExitCode != 0)
                {
                    return DiagnosticResult.Warning(
                        $"Visual Studioを確認できません。" +
                        $"終了コード:{process.ExitCode}");
                }
                if (string.IsNullOrWhiteSpace(process.Output))
                {
                    return DiagnosticResult.Warning(
                        "Visual Studioのインストールを確認できません。" +
                        ".NET SDKとコマンド操作で開発できる場合があります。");
                }
                return DiagnosticResult.Success(
                    $"{process.Output}を検出しました。");
            }
            catch (OperationCanceledException)
            {
                throw;
            }
            catch (Exception ex)
            {
                return DiagnosticResult.Warning(
                    $"IDEの確認中に問題が発生しました。{ex.Message}");
            }
        }
        private static async Task<DiagnosticResult> CheckDatabaseAsync(
            DatabaseConnectionSettings settings,
            CancellationToken cancellationToken)
        {
            if (string.IsNullOrWhiteSpace(settings.Host))
            {
                return DiagnosticResult.Error(
                    "PostgreSQLのサーバー名を入力してください。");
            }
            if (settings.Port is < 1 or > 65535)
            {
                return DiagnosticResult.Error(
                    "ポート番号は1から65535の範囲で入力してください。");
            }
            if (string.IsNullOrWhiteSpace(settings.Database))
            {
                return DiagnosticResult.Error(
                    "データベース名を入力してください。");
            }
            if (string.IsNullOrWhiteSpace(settings.Username))
            {
                return DiagnosticResult.Error(
                    "利用者名を入力してください。");
            }
            try
            {
                var connectionStringBuilder =
                    new NpgsqlConnectionStringBuilder
                    {
                        Host = settings.Host,
                        Port = settings.Port,
                        Database = settings.Database,
                        Username = settings.Username,
                        Password = settings.Password,
                        Timeout = 5,
                        CommandTimeout = 5,
                        Pooling = false,
                        ApplicationName = "EnvironmentDiagnostic"
                    };
                await using var dataSource =
                    NpgsqlDataSource.Create(
                        connectionStringBuilder.ConnectionString);
                await using var command =
                    dataSource.CreateCommand(
                        "SHOW server_version");
                object? version =
                    await command.ExecuteScalarAsync(
                        cancellationToken);
                string versionText =
                    Convert.ToString(version) ?? "不明";
                if (string.IsNullOrWhiteSpace(versionText))
                {
                    versionText = "不明";
                }
                return DiagnosticResult.Success(
                    $"{settings.Host}:{settings.Port}/" +
                    $"{settings.Database}へ接続できました。" +
                    $"PostgreSQL:{versionText}");
            }
            catch (OperationCanceledException)
            {
                throw;
            }
            catch (PostgresException ex)
            {
                return DiagnosticResult.Error(
                    $"PostgreSQLが接続を拒否しました。" +
                    $"SQLSTATE:{ex.SqlState} {ex.MessageText}");
            }
            catch (NpgsqlException ex)
            {
                return DiagnosticResult.Error(
                    $"PostgreSQLへ接続できません。{ex.Message}");
            }
            catch (Exception ex)
            {
                return DiagnosticResult.Error(
                    $"DB接続の確認中に問題が発生しました。{ex.Message}");
            }
        }
        private static DiagnosticResult CheckOperatingSystem()
        {
            string osDescription =
                RuntimeInformation.OSDescription.Trim();
            string osArchitecture =
                RuntimeInformation.OSArchitecture.ToString();
            string framework =
                RuntimeInformation.FrameworkDescription;
            string message =
                $"{osDescription}/{osArchitecture}/{framework}";
            if (!RuntimeInformation.IsOSPlatform(
                    OSPlatform.Windows))
            {
                return DiagnosticResult.Warning(
                    $"Windows以外で実行されています。{message}");
            }
            return DiagnosticResult.Success(message);
        }
        private static async Task<DiagnosticResult>
            CheckWorkFolderAsync(
                CancellationToken cancellationToken)
        {
            string localAppData =
                Environment.GetFolderPath(
                    Environment.SpecialFolder.LocalApplicationData);
            if (string.IsNullOrWhiteSpace(localAppData))
            {
                return DiagnosticResult.Error(
                    "ローカルアプリケーションデータの場所を取得できません。");
            }
            string workFolder = Path.Combine(
                localAppData,
                "EnvironmentDiagnostic");
            string testFilePath = Path.Combine(
                workFolder,
                $".write-test-{Guid.NewGuid():N}.tmp");
            try
            {
                Directory.CreateDirectory(workFolder);
                await File.WriteAllTextAsync(
                    testFilePath,
                    "write-test",
                    cancellationToken);
                File.Delete(testFilePath);
                return DiagnosticResult.Success(
                    $"書き込みと削除に成功しました。{workFolder}");
            }
            catch (OperationCanceledException)
            {
                throw;
            }
            catch (UnauthorizedAccessException ex)
            {
                return DiagnosticResult.Error(
                    $"作業フォルダーへ書き込む権限がありません。{ex.Message}");
            }
            catch (Exception ex)
            {
                return DiagnosticResult.Error(
                    $"作業フォルダーを使用できません。{ex.Message}");
            }
            finally
            {
                try
                {
                    if (File.Exists(testFilePath))
                    {
                        File.Delete(testFilePath);
                    }
                }
                catch
                {
                }
            }
        }
        private static async Task<ProcessOutput> RunProcessAsync(
            string fileName,
            string[] arguments,
            CancellationToken cancellationToken)
        {
            var startInfo = new ProcessStartInfo
            {
                FileName = fileName,
                RedirectStandardOutput = true,
                RedirectStandardError = true,
                UseShellExecute = false,
                CreateNoWindow = true
            };
            foreach (string argument in arguments)
            {
                startInfo.ArgumentList.Add(argument);
            }
            using var process = new Process
            {
                StartInfo = startInfo
            };
            if (!process.Start())
            {
                throw new InvalidOperationException(
                    $"{fileName}を開始できません。");
            }
            var outputTask =
                process.StandardOutput.ReadToEndAsync(
                    cancellationToken);
            var errorTask =
                process.StandardError.ReadToEndAsync(
                    cancellationToken);
            try
            {
                await process.WaitForExitAsync(
                    cancellationToken);
            }
            catch (OperationCanceledException)
            {
                try
                {
                    if (!process.HasExited)
                    {
                        process.Kill(
                            entireProcessTree: true);
                    }
                }
                catch
                {
                }
                throw;
            }
            string output = await outputTask;
            string error = await errorTask;
            return new ProcessOutput(
                process.ExitCode,
                output.Trim(),
                error.Trim());
        }
        private sealed record ProcessOutput(
            int ExitCode,
            string Output,
            string Error);
    }

    【8|診断サービスを一つずつ読み解く】

    RunAsyncは五つの診断をまとめる

    RunAsyncは、診断サービスの入口です。

    public async Task<EnvironmentDiagnosticReport> RunAsync(...)

    質問:なぜEnvironmentDiagnosticReportを直接返さず、Task<EnvironmentDiagnosticReport>を返すのですか。
    回答:SDK確認、DB接続、ファイル書き込みなど、完了まで待つ必要がある処理を含んでいるからです。
    awaitを使用すると、DBから応答を待っている間、WPF画面を固めずに待機できます。
    今回は、処理の流れを追いやすくするため、五つの診断を順番に実行しています。
    後の講義では、互いに独立した診断を同時に実行して、診断時間を短縮できます。

    SDKはdotnetコマンドで確認する

    SDKの確認では、内部で次のコマンドを実行しています。

    dotnet --list-sdks

    このコマンドの出力から、導入済みSDKの一覧を取得します。
    次のような出力が得られます。

    8.0.414 [C:\Program Files\dotnet\sdk]
    10.0.100 [C:\Program Files\dotnet\sdk]

    処理では、SDKが一つもない場合を異常とします。
    SDKは存在しても.NET 10が見つからない場合は、注意とします。
    .NET 10が見つかった場合は、正常とします。

    Processは外部プログラムを実行する

    ProcessStartInfoには、実行するプログラム名や、結果をどのように受け取るかを設定します。

    RedirectStandardOutput = true
    RedirectStandardError = true
    UseShellExecute = false
    CreateNoWindow = true

    ・RedirectStandardOutput:通常の実行結果をC#で受け取る
    ・RedirectStandardError:エラー内容をC#で受け取る
    ・UseShellExecute:Windowsのシェルを経由せず直接実行する
    ・CreateNoWindow:コマンド画面を別に表示しない
    WaitForExitAsyncは、外部プログラムの終了を非同期で待つためのAPIです。キャンセル用のCancellationTokenも渡せます。Microsoft Learn

    IDEがなくても直ちに異常とはしない

    Visual Studioの確認には、Visual Studio Installerと同じ場所にあるvswhere.exeを使用します。
    Visual Studioが見つかれば正常です。
    見つからない場合は異常ではなく、注意を返します。
    質問:なぜ異常ではないのですか。
    回答:.NET SDKがあれば、コマンドと別のエディターを使ってC#を開発できるからです。
    必須のものがない場合は異常、代替手段がある場合は注意とします。

    PostgreSQL接続は失敗してもアプリを終了させない

    PostgreSQL診断では、最初に入力内容を確認します。
    ・サーバー名が空ではないか
    ・ポート番号が1から65535の範囲か
    ・データベース名が空ではないか
    ・利用者名が空ではないか
    入力に問題がなければ、Npgsqlで接続し、次のSQLを実行します。

    SHOW server_version

    これにより、単にポートが開いているだけでなく、PostgreSQLへ接続し、命令を実行できたことまで確認します。
    接続に失敗しても、例外をそのままWPFへ投げません。
    DiagnosticResult.Errorへ変換して返します。
    ミライ「エラーを隠しているのですか。」
    神崎先生「隠しているのではありません。利用者が扱える診断結果へ翻訳しています。」

    Windows情報はRuntimeInformationから取得する

    Windows情報の確認では、次の値を使用しています。
    ・OSDescription:OSを説明する文字列
    ・OSArchitecture:OSのCPUアーキテクチャ
    ・FrameworkDescription:実行中の.NET
    RuntimeInformationは、OSや.NETランタイムに関する情報を提供します。OSDescriptionは利用者への表示に使用できますが、その文字列を分解して厳密な判定へ使うことは推奨されていません。Microsoft Learn
    そのため、Windowsかどうかの判定には次のメソッドを使用しています。

    RuntimeInformation.IsOSPlatform(OSPlatform.Windows)

    作業フォルダーは実際に書いて確かめる

    フォルダーが存在するだけでは、書き込めるとは限りません。
    そこで、次の手順を実行します。
    1.LocalApplicationData内に作業フォルダーを作る
    2.一時的なテストファイルを書き込む
    3.書き込んだテストファイルを削除する
    4.すべて成功すれば正常を返す
    使用する場所は、次のような利用者ごとのフォルダーです。

    C:\Users\利用者名\AppData\Local\EnvironmentDiagnostic

    テストファイル名にはGuidを使用し、他の実行と重なりにくくしています。

    $".write-test-{Guid.NewGuid():N}.tmp"

    finallyでは、途中で問題が起きた場合にも、残ったテストファイルの削除を試みます。

    【9|Coreプロジェクトをビルドする】

    ここまで入力したら、ソリューションをビルドします。

    ビルド → ソリューションのビルド

    エラーが出た場合は、次の点を確認します。
    ・五つのファイルがEnvironmentDiagnostic.Coreにある
    ・すべての名前空間がEnvironmentDiagnostic.Coreになっている
    ・NpgsqlがCoreプロジェクトへインストールされている
    ・ファイル名と型名の大文字、小文字が一致している
    ・.NET 10.0を対象にしている
    ここでは、まだWPF画面は変化しません。
    診断サービスは完成しましたが、Desktopプロジェクトがその存在を知らないからです。

    【10|DesktopからCoreを参照する】

    ソリューションエクスプローラーで、EnvironmentDiagnostic.Desktopを右クリックします。
    次の順番で操作します。
    1.追加
    2.プロジェクト参照
    3.EnvironmentDiagnostic.Coreへチェックを付ける
    4.OKを押す
    質問:なぜプロジェクト参照が必要ですか。
    回答:DesktopプロジェクトからCoreプロジェクトの型やメソッドを使用するためです。
    依存する方向は次のようになります。

    Desktop → Core

    CoreからDesktopは参照しません。
    質問:なぜ逆向きの参照を作らないのですか。
    回答:CoreをWPFから独立させるためです。
    画面はCoreを知っていますが、Coreは画面を知りません。

    【11|診断開始ボタンへClickイベントを設定する】

    MainWindow.xamlを開きます。
    第0002講で作ったbtnRunDiagnosticを探します。
    現在は、次のようになっています。

    <Button x:Name="btnRunDiagnostic"
            Grid.Column="1"
            Width="170"
            Height="46"
            Content="診断を開始"
            Background="#2563EB"
            Foreground="White"
            FontSize="15"
            FontWeight="SemiBold" />

    Clickを追加します。

    <Button x:Name="btnRunDiagnostic"
            Grid.Column="1"
            Width="170"
            Height="46"
            Content="診断を開始"
            Click="RunDiagnostic_Click"
            Background="#2563EB"
            Foreground="White"
            FontSize="15"
            FontWeight="SemiBold" />

    追加した行は、次の一行です。

    Click="RunDiagnostic_Click"

    これにより、ボタンを押したときに、C#側のRunDiagnostic_Clickが呼び出されます。

    【12|診断対象のTextBlockを確認する】

    第0002講の演習を行っている場合は、次のTextBlockがすでにあります。

    <TextBlock x:Name="txtDiagnosticTarget"
               Margin="0,8,0,0"
               Text="診断対象:このコンピューター"
               FontSize="14"
               FontWeight="SemiBold"
               Foreground="#2563EB" />

    まだ追加していない場合は、画面上部の見出しを入れたStackPanel内へ追加してください。
    診断後、この文字を実際のコンピューター名へ変更します。

    【13|WPFから診断サービスを呼び出す】

    MainWindow.xaml.csを開き、内容を次のようにします。

    using System.Windows;
    using System.Windows.Controls;
    using System.Windows.Media;
    using EnvironmentDiagnostic.Core;
    namespace EnvironmentDiagnostic.Desktop;
    public partial class MainWindow : Window
    {
        private readonly EnvironmentDiagnosticService
            _diagnosticService = new();
        public MainWindow()
        {
            InitializeComponent();
        }
        private async void RunDiagnostic_Click(
            object sender,
            RoutedEventArgs e)
        {
            btnRunDiagnostic.IsEnabled = false;
            btnRunDiagnostic.Content = "診断中...";
            txtLastChecked.Text = "診断を実行しています。";
            try
            {
                int port =
                    int.TryParse(
                        txtDbPort.Text,
                        out int parsedPort)
                        ? parsedPort
                        : 0;
                var databaseSettings =
                    new DatabaseConnectionSettings(
                        txtDbHost.Text.Trim(),
                        port,
                        txtDbName.Text.Trim(),
                        txtDbUser.Text.Trim(),
                        pwdDbPassword.Password);
                EnvironmentDiagnosticReport report =
                    await _diagnosticService.RunAsync(
                        databaseSettings);
                ShowResult(
                    report.Sdk,
                    txtSdkStatus,
                    txtSdkMessage);
                ShowResult(
                    report.Ide,
                    txtIdeStatus,
                    txtIdeMessage);
                ShowResult(
                    report.Database,
                    txtDbStatus,
                    txtDbMessage);
                ShowResult(
                    report.OperatingSystem,
                    txtOsStatus,
                    txtOsMessage);
                ShowResult(
                    report.WorkFolder,
                    txtFolderStatus,
                    txtFolderMessage);
                txtDiagnosticTarget.Text =
                    $"診断対象:{report.MachineName}";
                txtLastChecked.Text =
                    $"最終診断:" +
                    $"{report.CheckedAt:yyyy/MM/dd HH:mm:ss}";
            }
            catch (Exception ex)
            {
                MessageBox.Show(
                    $"診断を完了できませんでした。\n{ex.Message}",
                    "開発環境診断",
                    MessageBoxButton.OK,
                    MessageBoxImage.Error);
            }
            finally
            {
                btnRunDiagnostic.IsEnabled = true;
                btnRunDiagnostic.Content = "診断を開始";
            }
        }
        private static void ShowResult(
            DiagnosticResult result,
            TextBlock statusText,
            TextBlock messageText)
        {
            statusText.Text = result.State switch
            {
                DiagnosticState.Success => "正常",
                DiagnosticState.Warning => "注意",
                DiagnosticState.Error => "異常",
                _ => "不明"
            };
            Brush color = result.State switch
            {
                DiagnosticState.Success => Brushes.ForestGreen,
                DiagnosticState.Warning => Brushes.DarkOrange,
                DiagnosticState.Error => Brushes.Firebrick,
                _ => Brushes.DimGray
            };
            statusText.Foreground = color;
            messageText.Text = result.Message;
            messageText.Foreground = color;
        }
    }

    【14|WPF側の処理を読み解く】

    診断サービスを一つだけ保持する

    次の行で、診断サービスを作っています。

    private readonly EnvironmentDiagnosticService
        _diagnosticService = new();

    readonlyを付けることで、MainWindowの動作中に別の診断サービスへ入れ替えないことを示します。

    async voidが許される場所

    Clickイベントは、次のようになっています。

    private async void RunDiagnostic_Click(...)

    通常の非同期メソッドでは、async Taskを使用します。
    ただし、WPFのClickイベントハンドラーは戻り値を受け取らない形式になっているため、ここではasync voidを使用します。
    async voidを一般的な業務処理へ広げず、画面イベントの入口に限定します。
    診断サービス側は、次のようにTaskを返しています。

    public async Task<EnvironmentDiagnosticReport> RunAsync(...)

    診断中はボタンを無効にする

    診断を開始すると、次の処理を行います。

    btnRunDiagnostic.IsEnabled = false;
    btnRunDiagnostic.Content = "診断中...";

    これにより、診断中にボタンを何度も押して、同じ処理が重複して始まることを防ぎます。
    処理の最後では、finallyを使用して元へ戻します。

    finally
    {
        btnRunDiagnostic.IsEnabled = true;
        btnRunDiagnostic.Content = "診断を開始";
    }

    診断に成功しても失敗しても、finallyは実行されます。

    ポート番号をintへ変換する

    TextBoxから取得した値は文字列です。
    そこで、int.TryParseを使って整数へ変換しています。

    int port =
        int.TryParse(txtDbPort.Text, out int parsedPort)
            ? parsedPort
            : 0;

    変換できた場合は、その値を使用します。
    変換できなかった場合は0を渡します。
    Core側では、ポート番号が1から65535の範囲にあるか確認します。
    ミライ「WPF側でエラーメッセージを出さないのですか。」
    神崎先生「WPFは文字列を数値へ変換するだけです。ポート番号として正しいかを判断するのはCoreです。」
    ミライ「そうすれば、Blazorから呼び出した場合も同じ検証を使えますね。」
    神崎先生「そのとおりです。」

    パスワードはPasswordプロパティから受け取る

    TextBoxはTextプロパティを使用しますが、PasswordBoxはPasswordプロパティを使用します。

    pwdDbPassword.Password

    この値はDatabaseConnectionSettingsへ渡されますが、診断報告へは入りません。

    ShowResultで表示処理を共通化する

    五つの診断結果について、状態と説明を表示する処理は共通です。
    そこで、ShowResultメソッドへまとめています。
    正常の場合は、次の表示になります。
    ・表示文字:正常
    ・表示色:緑
    注意の場合は、次の表示になります。
    ・表示文字:注意
    ・表示色:オレンジ
    異常の場合は、次の表示になります。
    ・表示文字:異常
    ・表示色:赤
    質問:この色の処理をCoreへ入れてはいけませんか。
    回答:入れません。色はWPF画面の表現だからです。
    CoreはSuccess、Warning、Errorだけを返します。
    WPFはそれを緑、オレンジ、赤へ変換します。
    将来のBlazor画面では、同じ状態をHTMLとCSSで別の見た目へ変換できます。

    【15|実行して診断する】

    プロジェクトを保存し、WPFアプリを実行します。
    PostgreSQLの接続先へ、現在の環境に合った値を入力します。
    一般的なローカル環境の例は次のとおりです。

    サーバー名:localhost
    ポート番号:5432
    データベース名:postgres
    利用者名:postgres
    パスワード:設定したパスワード

    「診断を開始」を押します。
    処理中はボタンの文字が次のように変わります。

    診断中...

    診断が終わると、五つの結果が更新されます。
    想定される表示例は次のとおりです。

    .NET SDK    正常
    IDE      正常
    PostgreSQL接続 正常
    Windows情報  正常
    作業フォルダー 正常

    最終診断日時とコンピューター名も更新されます。

    診断対象:DESKTOP-EXAMPLE
    最終診断:2026/10/03 23:45:12

    【16|PostgreSQLが異常でも、ほかの診断は成功する】

    PostgreSQLが導入されていない場合や、サービスが停止している場合は、DB接続だけが異常になります。

    .NET SDK    正常
    IDE      正常
    PostgreSQL接続 異常
    Windows情報  正常
    作業フォルダー 正常

    ミライ「一件でも異常なら、途中で診断を中止したほうがよいのではありませんか。」
    神崎先生「診断ツールでは、可能な限り最後まで調べるほうが役立ちます。」
    ミライ「DBへ接続できなくても、SDKやフォルダーの結果は確認できるからですね。」
    神崎先生「はい。一人が遅刻したからといって、出席簿そのものを閉じてはいけません。」
    各診断メソッドは、発生した問題をDiagnosticResultへ変換します。
    そのため、一つの項目が異常でも、ほかの項目の診断を続けられます。

    【17|診断結果とプログラムの失敗を区別する】

    ここは重要です。
    PostgreSQLへ接続できないことは、診断ツールにとって必ずしもプログラムの失敗ではありません。
    診断ツールの目的は、接続できるかどうかを調べることです。
    したがって、接続できなかった場合でも、次の状態になれば診断処理自体は成功しています。
    ・アプリが終了しない
    ・PostgreSQLだけが「異常」と表示される
    ・接続できなかった理由が表示される
    ・ほかの診断結果も表示される
    一方、診断サービス全体が予想外の理由で動けなかった場合は、WPF側のcatchでメッセージを表示します。
    「診断対象が異常だった」と「診断プログラムが壊れた」は別の出来事です。

    【18|意図的に異常を発生させる】

    診断ツールは、正常時だけ確認しても完成とはいえません。
    次の操作を行い、異常を正しく表示できるか確認します。

    ポート番号へ文字を入力する

    ポート番号を次のように変更します。

    abc

    診断すると、WPF側で整数へ変換できないため、Coreへ0が渡されます。
    Coreは次の異常を返します。

    ポート番号は1から65535の範囲で入力してください。

    存在しないポート番号を入力する

    次のような値へ変更します。

    5433

    PostgreSQLがそのポートで待機していなければ、DB接続は異常になります。
    ほかの診断は続けられます。

    パスワードを間違える

    パスワードを意図的に変更します。
    PostgreSQLから認証エラーが返れば、DB接続が異常になります。

    PostgreSQLを停止する

    PostgreSQLのサービスを停止して診断すると、接続できないことが表示されます。
    確認後は、サービスを元へ戻します。

    【19|今回の設計で守った境界】

    今回のコードは、次のように役割を分けています。

    Desktopの役割

    ・TextBoxから入力を読み取る
    ・診断サービスを呼び出す
    ・診断結果を画面へ表示する
    ・状態に応じて表示色を変える
    ・診断中のボタンを無効にする

    Coreの役割

    ・入力内容を検証する
    ・SDKを確認する
    ・IDEを確認する
    ・PostgreSQLへ接続する
    ・Windows情報を取得する
    ・フォルダーへ書き込めるか確認する
    ・診断結果を一つの報告へまとめる

    Coreが担当しないもの

    ・WPFのTextBlock
    ・WPFのButton
    ・文字の色
    ・MessageBox
    ・画面上の配置
    画面に関係する処理と、診断そのものを分けることが、DesktopとWebで共通利用する第一歩です。

    【20|パスワードを守る】

    今回、パスワードについて次のルールを守っています。
    ・XAMLへ初期パスワードを書かない
    ・パスワードを診断報告へ入れない
    ・パスワードを診断メッセージへ入れない
    ・パスワードを画面へ再表示しない
    ・パスワードをJSONへ保存しない
    ・接続文字列を自分で文字列連結しない
    DatabaseConnectionSettingsには一時的にパスワードが入ります。
    しかし、戻り値のEnvironmentDiagnosticReportにはパスワードのプロパティがありません。
    次回、診断報告をJSONへ保存しても、パスワードは含まれません。

    【21|よくあるエラー】

    Npgsqlが見つからない

    次のようなエラーが表示される場合があります。

    型または名前空間の名前 'Npgsql' が見つかりません

    NpgsqlがEnvironmentDiagnostic.Coreへインストールされているか確認します。
    Desktopだけへインストールしても、Coreからは使用できません。

    EnvironmentDiagnostic.Coreが見つからない

    次の行でエラーになる場合があります。

    using EnvironmentDiagnostic.Core;

    DesktopプロジェクトからCoreプロジェクトへのプロジェクト参照を確認します。

    RunDiagnostic_Clickが見つからない

    XAMLの次の名前を確認します。

    Click="RunDiagnostic_Click"

    C#側のメソッド名も、完全に同じである必要があります。

    private async void RunDiagnostic_Click(...)

    大文字と小文字も区別されます。

    txtDiagnosticTargetが存在しない

    第0002講の演習を行っていない場合に発生します。
    MainWindow.xamlへ、x:Name="txtDiagnosticTarget"を持つTextBlockを追加します。

    PostgreSQLだけ異常になる

    これは、プログラムのエラーとは限りません。
    次の内容を確認します。
    ・PostgreSQLが起動しているか
    ・サーバー名が正しいか
    ・ポート番号が正しいか
    ・データベース名が存在するか
    ・利用者名が正しいか
    ・パスワードが正しいか

    Visual Studioが注意になる

    vswhere.exeが見つからない場合や、Visual Studioのインストールを確認できない場合は注意になります。
    .NET SDKが正常なら、コマンド操作や別のIDEでC#を開発できる可能性があります。

    診断中に画面が固まる

    awaitを削除して同期的に待機していないか確認します。
    次のような書き方へ変更してはいけません。

    EnvironmentDiagnosticReport report =
        _diagnosticService
            .RunAsync(databaseSettings)
            .Result;

    今回は、次のようにawaitします。

    EnvironmentDiagnosticReport report =
        await _diagnosticService.RunAsync(
            databaseSettings);

    【22|演習】

    Windows情報の診断メッセージへ、コンピューター名も追加してください。
    現在は、次の情報を表示しています。
    ・OSの説明
    ・OSのアーキテクチャ
    ・.NETの説明
    完成後は、次のような内容を表示します。

    Microsoft Windows 11/X64/.NET 10.0.x/コンピューター:DESKTOP-EXAMPLE

    条件は次のとおりです。
    ・変更するのはCheckOperatingSystemだけにする
    ・Environment.MachineNameを使用する
    ・WPF側のコードは変更しない

    【演習の解答】

    CheckOperatingSystemを次のように変更します。

    private static DiagnosticResult CheckOperatingSystem()
    {
        string osDescription =
            RuntimeInformation.OSDescription.Trim();
        string osArchitecture =
            RuntimeInformation.OSArchitecture.ToString();
        string framework =
            RuntimeInformation.FrameworkDescription;
        string machineName =
            Environment.MachineName;
        string message =
            $"{osDescription}/{osArchitecture}/{framework}/" +
            $"コンピューター:{machineName}";
        if (!RuntimeInformation.IsOSPlatform(
                OSPlatform.Windows))
        {
            return DiagnosticResult.Warning(
                $"Windows以外で実行されています。{message}");
        }
        return DiagnosticResult.Success(message);
    }

    【解答を一つずつ読み解く】

    質問:コンピューター名はどこから取得していますか。
    回答:Environment.MachineNameから取得しています。
    質問:なぜMainWindow.xaml.csを変更しないのですか。
    回答:Windows情報を集めることは、画面ではなく診断サービスの仕事だからです。
    質問:Coreを変更したのにWPF画面へ反映されるのはなぜですか。
    回答:WPFはCoreから返されたDiagnosticResult.Messageを、そのまま結果欄へ表示しているからです。
    ミライ「Coreを直せば、後から作るBlazor側にも同じ内容が返るのですね。」
    神崎先生「はい。それが共通部品を作る効果です。」

    【今回完成したもの】

    今回、次の部品を完成させました。
    ・DiagnosticState:正常、注意、異常を表す
    ・DiagnosticResult:一件分の状態と説明を表す
    ・DatabaseConnectionSettings:DB接続に必要な値を渡す
    ・EnvironmentDiagnosticReport:一回分の診断結果をまとめる
    ・EnvironmentDiagnosticService:五つの環境診断を実行する
    ・RunDiagnostic_Click:WPFからサービスを呼び出す
    ・ShowResult:診断結果を文字と色へ変換する
    第0002講では、診断結果を受け取るための空の画面を作りました。
    第0003講では、その画面へ実際の診断結果が表示されるようになりました。
    画面が診断するのではなく、画面から独立したサービスが診断し、画面は結果を表示する構造が完成しました。

    【今回、コードを書いて身につけたこと】

    ・クラスライブラリをソリューションへ追加する方法
    ・DesktopからCoreを参照する方法
    ・enumで使用可能な状態を限定する方法
    ・recordで意味のあるデータを表す方法
    ・Taskとasync、awaitで待ち時間のある処理を扱う方法
    ・Processで外部コマンドを実行する方法
    ・RuntimeInformationでOSと.NETの情報を取得する方法
    ・一時ファイルを使って書き込み権限を確認する方法
    ・NpgsqlでPostgreSQLへ接続する方法
    ・例外を利用者向けの診断結果へ変換する方法
    ・一項目の異常で診断全体を終了させない考え方
    ・WPF固有の表示処理とCoreの診断処理を分ける方法
    ・パスワードを診断報告へ含めない設計

    【3つの覚えるべきこと】

    1.質問:CoreプロジェクトへWPFのTextBlockやButtonを入れないのはなぜですか。
    回答:診断処理を画面から独立させ、WPF、Blazor、テストなどから共通利用できるようにするためです。
    2.質問:PostgreSQLへ接続できなかったとき、アプリを終了させないのはなぜですか。
    回答:接続できないこと自体が診断結果であり、ほかの診断を続ける必要があるからです。
    3.質問:パスワードをEnvironmentDiagnosticReportへ入れないのはなぜですか。
    回答:次回、診断報告をJSONへ保存するときに、パスワードが保存されることを防ぐためです。

    【次回予告】

    次回は、第0004講「【Data】診断履歴をJSONへ保存する」です。
    今回作ったEnvironmentDiagnosticReportを、利用者ごとの作業フォルダーへJSON形式で保存します。
    次回は、次の部品を作ります。
    ・診断報告をJSONへ変換する
    ・診断日時を含むファイル名を作る
    ・診断履歴用フォルダーへ保存する
    ・保存済みのJSONを読み込む
    ・パスワードが保存されていないことを確認する
    ・途中で失敗しても壊れた履歴を残さない
    今回作った診断サービスが「調べる部品」なら、次回作るData部品は「記録する部品」です。

    あなたへのおすすめ