Fix

Author: Your Name

README.md

@@ -6,22 +6,31 @@ It runs in the background, periodically refreshes the lists, and re-checks proxi
 
 ## Quick Start
 
+Typical usage:
+
 ```csharp
 using InfiniteProxy;
 
-var client = new InfiniteProxyClient(new InfiniteProxyOptions
+var client = new InfiniteProxyClient();
+
+// This starts the background scraping + checking and waits until
+// at least one working proxy is available.
+await client.WaitUntilReadyAsync();
+
+var proxy = client.GetRandom(ProxyType.Http)!;
+
+// Use it with HttpClient
+var handler = new HttpClientHandler
 {
-    ProxyTypes = [ProxyType.Http, ProxyType.Socks5],
-    FetchInterval = TimeSpan.FromMinutes(5),
-    CheckTimeout = TimeSpan.FromSeconds(10),
-    ConnectTimeout = TimeSpan.FromSeconds(6)
-});
+    Proxy = new WebProxy(proxy.Host, proxy.Port),
+    UseProxy = true
+};
+using var http = new HttpClient(handler);
 
-var first = await client.StartAsync();
-Console.WriteLine($"Ready: {first}");
+var html = await http.GetStringAsync("https://example.com");
 ```
 
-After `StartAsync` returns you have at least one working proxy and the scanner continues running.
+After `WaitUntilReadyAsync()` returns, the pool has at least one good proxy and the scanner continues running in the background.
 
 ## Using a Proxy + Handling Failures
 

examples/QuickStart/Program.cs

@@ -13,10 +13,12 @@
 client.ProxyRemoved += (_, e) => Console.WriteLine($"[-] {e.Proxy}");
 
 Console.WriteLine("Starting InfiniteProxy background scanner...");
-Console.WriteLine("Waiting for the first working proxy...\n");
+Console.WriteLine("Waiting until at least one working proxy is available...\n");
 
-var first = await client.StartAsync();
-Console.WriteLine($"\nFirst proxy ready: {first}");
+await client.WaitUntilReadyAsync();
+
+var proxy = client.GetRandom(ProxyType.Http)!;
+Console.WriteLine($"First proxy ready: {proxy}");
 Console.WriteLine($"Pool size: {client.WorkingCount}");
 
 var fastest = client.GetFastest();

src/InfiniteProxy/InfiniteProxyClient.cs

@@ -92,14 +92,29 @@ public event EventHandler<ProxyRemovedEventArgs>? ProxyRemoved
     }
 
     /// <summary>
-    /// Starts the 24/7 background scanner and completes once at least one working proxy is available.
+    /// Starts the background scanner and returns the first working proxy once one is available.
+    /// This is a convenience method on top of <see cref="WaitUntilReadyAsync"/>.
     /// </summary>
     /// <param name="cancellationToken">Cancel waiting for the first proxy. The scanner keeps running unless <see cref="StopAsync"/> is called.</param>
     /// <returns>The first validated proxy endpoint.</returns>
     public async Task<ProxyEndpoint> StartAsync(CancellationToken cancellationToken = default)
+    {
+        await WaitUntilReadyAsync(cancellationToken).ConfigureAwait(false);
+        return _pool.GetRandom()!;
+    }
+
+    /// <summary>
+    /// Ensures the background scraping and checking loop is running,
+    /// then completes once at least one working proxy is available.
+    /// 
+    /// This is the recommended method when you just want to wait until the client
+    /// has at least one good proxy before proceeding.
+    /// </summary>
+    public async Task WaitUntilReadyAsync(CancellationToken cancellationToken = default)
     {
         ObjectDisposedException.ThrowIf(_disposed == 1, this);
 
+        // Start the constant scraping + validation background loop (only once)
         if (Interlocked.CompareExchange(ref _started, 1, 0) == 0)
         {
             _cts = new CancellationTokenSource();
@@ -108,23 +123,24 @@ public async Task<ProxyEndpoint> StartAsync(CancellationToken cancellationToken
 
         if (_pool.Count > 0)
         {
-            return _pool.GetRandom()!;
+            return;
         }
 
-        var waitTcs = new TaskCompletionSource<ProxyEndpoint>(TaskCreationOptions.RunContinuationsAsynchronously);
+        // Wait until the background scanner adds the first valid proxy
+        var waitTcs = new TaskCompletionSource<bool>(TaskCreationOptions.RunContinuationsAsynchronously);
         EventHandler<ProxyAddedEventArgs>? handler = null;
-        handler = (_, args) => waitTcs.TrySetResult(args.Proxy);
+        handler = (_, _) => waitTcs.TrySetResult(true);
         _pool.ProxyAdded += handler;
 
         try
         {
             await using var registration = cancellationToken.Register(static state =>
             {
-                var tcs = (TaskCompletionSource<ProxyEndpoint>)state!;
+                var tcs = (TaskCompletionSource<bool>)state!;
                 tcs.TrySetCanceled();
             }, waitTcs).ConfigureAwait(false);
 
-            return await waitTcs.Task.ConfigureAwait(false);
+            await waitTcs.Task.ConfigureAwait(false);
         }
         finally
         {