fix: update samples to ProbeAllProfilesAsync / explicit OpenAndConnectAsync

- HighLevelSample: add ProbeAllProfilesAsync probe step before OpenAndConnectAsync
- QueuedSample: replace ResolveProfileAsync with ProbeAllProfilesAsync + FirstOrDefault
- Cli: change autoProfileCache / WarmAutoProfileAsync / ResolveAutoProfileAsync to use
  SlmpProfileProbeResult and ProbeAllProfilesAsync

Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>

Author: fa-yoshinobu

samples/PlcComm.Slmp.Cli/Program.cs

@@ -4,7 +4,7 @@
 using System.Collections.Concurrent;
 using PlcComm.Slmp;
 
-var autoProfileCache = new ConcurrentDictionary<string, Lazy<Task<SlmpProfileRecommendation>>>(StringComparer.Ordinal);
+var autoProfileCache = new ConcurrentDictionary<string, Lazy<Task<SlmpProfileProbeResult>>>(StringComparer.Ordinal);
 var autoProfileLogged = new ConcurrentDictionary<string, byte>(StringComparer.Ordinal);
 
 string GetOption(IReadOnlyList<string> args, string name, string defaultValue)
@@ -43,17 +43,18 @@ string BuildAutoProfileKey(string host, int port, SlmpTransportMode transport, S
     return $"{host}:{port}:{transport}:{target.Network:X2}:{target.Station:X2}:{target.ModuleIo:X4}:{target.Multidrop:X2}";
 }
 
-async Task<SlmpProfileRecommendation> ResolveAutoProfileAsync(string host, int port, SlmpTransportMode transport, SlmpTargetAddress target)
+async Task<SlmpProfileProbeResult> ResolveAutoProfileAsync(string host, int port, SlmpTransportMode transport, SlmpTargetAddress target)
 {
     using var probeClient = new SlmpClient(host, port, transport)
     {
         TargetAddress = target,
     };
-    await probeClient.OpenAsync().ConfigureAwait(false);
-    return await probeClient.ResolveProfileAsync().ConfigureAwait(false);
+    var results = await probeClient.ProbeAllProfilesAsync().ConfigureAwait(false);
+    return results.FirstOrDefault(r => r.Success)
+        ?? throw new SlmpError($"Could not detect PLC profile at {host}:{port}");
 }
 
-async Task<SlmpProfileRecommendation?> WarmAutoProfileAsync(IReadOnlyList<string> args, SlmpTargetAddress target)
+async Task<SlmpProfileProbeResult?> WarmAutoProfileAsync(IReadOnlyList<string> args, SlmpTargetAddress target)
 {
     var host = GetOption(args, "--host", "192.168.250.100");
     var port = int.Parse(GetOption(args, "--port", "1025"), CultureInfo.InvariantCulture);
@@ -69,10 +70,10 @@ async Task<SlmpProfileRecommendation> ResolveAutoProfileAsync(string host, int p
     var autoKey = BuildAutoProfileKey(host, port, transport, target);
     var lazyProfile = autoProfileCache.GetOrAdd(
         autoKey,
-        _ => new Lazy<Task<SlmpProfileRecommendation>>(() => ResolveAutoProfileAsync(host, port, transport, target))
+        _ => new Lazy<Task<SlmpProfileProbeResult>>(() => ResolveAutoProfileAsync(host, port, transport, target))
     );
 
-    SlmpProfileRecommendation profile;
+    SlmpProfileProbeResult profile;
     try
     {
         profile = await lazyProfile.Value.ConfigureAwait(false);

samples/PlcComm.Slmp.HighLevelSample/Program.cs

@@ -19,25 +19,29 @@
 var port = args.Length > 1 ? int.Parse(args[1]) : 1025;
 
 // -------------------------------------------------------------------------
-// 1. OpenAndConnectAsync  (recommended entry point)
+// 1. Probe + OpenAndConnectAsync  (recommended entry point)
 //
-// Auto-detects the optimal frame type (3E or 4E) and PLC series (iQ-R / Q/L)
-// by probing four candidate combinations in order:
-//   (4E, iQ-R) -> (3E, Q/L) -> (3E, iQ-R) -> (4E, Q/L)
+// ProbeAllProfilesAsync tries all 4 frame/compat combinations in order:
+//   (4E, iQ-R) -> (4E, Q/L) -> (3E, Q/L) -> (3E, iQ-R)
+// and returns results for each so you can pick or present them to the user.
 //
-// Returns a QueuedSlmpClient - a thread-safe wrapper that serializes all
-// requests through a SemaphoreSlim, so multiple concurrent Tasks can share
-// one TCP connection without interleaving protocol frames.
-//
-// Throws SlmpError when no candidate succeeded (e.g. wrong port, PLC offline).
+// OpenAndConnectAsync then opens a QueuedSlmpClient with explicit settings.
+// QueuedSlmpClient is a thread-safe wrapper that serializes all requests
+// through a SemaphoreSlim, so multiple concurrent Tasks can share one TCP
+// connection without interleaving protocol frames.
 //
 // port options:
 //   1025  iQ-R / iQ-F Ethernet module SLMP port (default)
 //   5000  GX Works3 / GX Works2 simulation port
 //   5007  Q/L series Ethernet module SLMP port
 // -------------------------------------------------------------------------
-Console.WriteLine($"Connecting to {host}:{port} ...");
-await using var queuedClient = await SlmpClient.OpenAndConnectAsync(host, port);
+Console.WriteLine($"Probing {host}:{port} ...");
+using var probeOnly = new SlmpClient(host, port);
+var probeResults = await probeOnly.ProbeAllProfilesAsync();
+var best = probeResults.FirstOrDefault(r => r.Success)
+    ?? throw new SlmpError($"Could not connect to {host}:{port} - check host, port, and PLC power");
+Console.WriteLine($"[ProbeAllProfilesAsync] using {best.Label}  model={best.ModelName ?? "unknown"}");
+await using var queuedClient = await SlmpClient.OpenAndConnectAsync(host, port, best.FrameType, best.CompatibilityMode);
 Console.WriteLine($"[OpenAndConnectAsync] frame={queuedClient.FrameType}  series={queuedClient.CompatibilityMode}");
 
 // All extension methods target SlmpClient; access it via InnerClient.

samples/PlcComm.Slmp.QueuedSample/Program.cs

@@ -18,7 +18,9 @@
 };
 await using var queuedClient = new QueuedSlmpClient(rawClient);
 
-var profile = await queuedClient.ResolveProfileAsync().ConfigureAwait(false);
+var probeResults = await rawClient.ProbeAllProfilesAsync().ConfigureAwait(false);
+var profile = probeResults.FirstOrDefault(r => r.Success)
+    ?? throw new SlmpError("Could not detect PLC profile - check host, port, and PLC power");
 queuedClient.FrameType = profile.FrameType;
 queuedClient.CompatibilityMode = profile.CompatibilityMode;
 await queuedClient.OpenAsync().ConfigureAwait(false);