咨询WCF服务中ServiceA阻塞轮询ServiceB状态的实现方案

Hey there! Let's work through this ServiceA polling requirement for your WCF setup. From what you described, you need ServiceA to block its method execution until ServiceB returns the expected state, polling at a configurable interval (default 1 second). Here's a practical, production-ready implementation tailored to your scenario:

First, we'll build a reusable polling utility that handles repeating calls to ServiceB's status endpoint, blocking until we get the desired state or hit a timeout.

1. Encapsulate a Generic Polling Method #

We can wrap this logic in a static utility class so it's easy to reuse across ServiceA's methods:

public static class PollingHelper
{
    /// <summary>
    /// Blocks and polls a target method until it returns the expected result or times out
    /// </summary>
    /// <typeparam name="T">Type of the returned state</typeparam>
    /// <param name="pollAction">Method to fetch the current state from ServiceB</param>
    /// <param name="predicate">Condition to check if state is acceptable</param>
    /// <param name="pollInterval">Time between polling attempts (default 1 second)</param>
    /// <param name="timeout">Maximum time to wait for expected state (default 30 seconds)</param>
    /// <returns>The expected state value</returns>
    /// <exception cref="TimeoutException">Thrown if expected state isn't received in time</exception>
    public static T PollUntil<T>(Func<T> pollAction, Func<T, bool> predicate, TimeSpan? pollInterval = null, TimeSpan? timeout = null)
    {
        var interval = pollInterval ?? TimeSpan.FromSeconds(1);
        var maxWaitTime = timeout ?? TimeSpan.FromSeconds(30);
        var startTime = DateTime.UtcNow;

        while (true)
        {
            // Check if we've exceeded the maximum wait time
            if (DateTime.UtcNow - startTime > maxWaitTime)
                throw new TimeoutException($"Timed out waiting for ServiceB state after {maxWaitTime.TotalSeconds} seconds");

            // Fetch current state from ServiceB
            var currentState = pollAction();

            // Exit loop if we've got the expected state
            if (predicate(currentState))
                return currentState;

            // Wait before next poll attempt
            Thread.Sleep(interval);
        }
    }

    // Async version (preferred for WCF to avoid blocking thread pool threads)
    public static async Task<T> PollUntilAsync<T>(Func<Task<T>> pollAction, Func<T, bool> predicate, TimeSpan? pollInterval = null, TimeSpan? timeout = null)
    {
        var interval = pollInterval ?? TimeSpan.FromSeconds(1);
        var maxWaitTime = timeout ?? TimeSpan.FromSeconds(30);
        var startTime = DateTime.UtcNow;

        while (true)
        {
            if (DateTime.UtcNow - startTime > maxWaitTime)
                throw new TimeoutException($"Timed out waiting for ServiceB state after {maxWaitTime.TotalSeconds} seconds");

            var currentState = await pollAction().ConfigureAwait(false);

            if (predicate(currentState))
                return currentState;

            await Task.Delay(interval).ConfigureAwait(false);
        }
    }
}

2. Integrate with ServiceA's WCF Calls #

Assuming you already have a ServiceB client proxy (e.g., ServiceBClient generated via WCF), here's how to use the polling helper in ServiceA:

Synchronous Blocking Version (For Scenarios Needing Immediate Block) #

public class ServiceA : IServiceA
{
    public void DoWorkAfterServiceBIsReady()
    {
        // Load config values from app.config/web.config instead of hardcoding!
        var pollInterval = TimeSpan.FromSeconds(1);
        var timeout = TimeSpan.FromMinutes(5);

        try
        {
            // Poll ServiceB until it returns "Ready" state
            var targetState = PollingHelper.PollUntil(
                pollAction: () => 
                {
                    // Create and dispose ServiceB client properly
                    using (var serviceBClient = new ServiceBClient())
                    {
                        return serviceBClient.GetCurrentState();
                    }
                },
                predicate: state => state == "Ready",
                pollInterval: pollInterval,
                timeout: timeout
            );

            // Proceed with ServiceA's business logic once ServiceB is ready
            Console.WriteLine($"ServiceB is ready with state: {targetState}");
            // TODO: Execute your post-ready business logic here
        }
        catch (TimeoutException ex)
        {
            Console.WriteLine($"Error: {ex.Message}");
            throw; // Re-throw or handle based on your business needs
        }
        catch (FaultException ex)
        {
            Console.WriteLine($"ServiceB call failed: {ex.Message}");
            throw;
        }
    }
}

Async Version (Recommended to Avoid Blocking ServiceA Threads) #

If ServiceA's methods are async-compatible, use this version to keep your thread pool free:

public class ServiceA : IServiceA
{
    public async Task DoWorkAfterServiceBIsReadyAsync()
    {
        var pollInterval = TimeSpan.FromSeconds(1);
        var timeout = TimeSpan.FromMinutes(5);

        try
        {
            var targetState = await PollingHelper.PollUntilAsync(
                pollAction: async () => 
                {
                    using (var serviceBClient = new ServiceBClient())
                    {
                        return await serviceBClient.GetCurrentStateAsync().ConfigureAwait(false);
                    }
                },
                predicate: state => state == "Ready",
                pollInterval: pollInterval,
                timeout: timeout
            );

            // Execute async post-ready logic
            await ExecutePostReadyLogicAsync().ConfigureAwait(false);
        }
        catch (TimeoutException ex)
        {
            Console.WriteLine($"Wait timed out: {ex.Message}");
            throw;
        }
        catch (FaultException ex)
        {
            Console.WriteLine($"ServiceB call failed: {ex.Message}");
            throw;
        }
    }

    private async Task ExecutePostReadyLogicAsync()
    {
        // Your async business logic here
        await Task.Delay(100).ConfigureAwait(false);
    }
}

3. Key Production Considerations #

• Reuse WCF Clients Wisely: If creating ServiceBClient instances frequently impacts performance, consider reusing instances—but add logic to check if the client is in a faulted state and recreate it if needed.
• Configurable Values: Store poll intervals and timeouts in your config file (e.g., appSettings in app.config) so you can adjust them without redeploying code.
• Retry on Transient Errors: Add retry logic inside the pollAction to handle temporary network blips or ServiceB downtime.
• Cancellation Support: Extend the polling methods with a CancellationToken to allow canceling the poll if needed (e.g., if ServiceA's request is aborted).

4. Quick Troubleshooting Note #

You mentioned earlier that underlying issues made code seem broken—here are two quick checks:

• Verify your WCF client binding settings (like operation timeouts, message size limits) are correctly configured to avoid silent failures when calling ServiceB.
• Ensure ServiceB's GetCurrentState method is thread-safe, since ServiceA will be calling it repeatedly.

内容的提问来源于stack exchange，提问作者tinonetic