如何使用SignalR实现WCF服务与Windows服务的通信

Alright, let's break down how to get your Windows Service and WCF Service talking reliably via SignalR, with instant data pushes from WCF to Windows Service. Here's a step-by-step approach that addresses your coupling and stability concerns:

1. Core Architecture Overview #

We'll set up your Windows Service to host a SignalR Hub server (since it's a long-running background process, this is ideal for stability). Your WCF Service will act as a SignalR client, connecting to this Hub to push data whenever it has new information. The Hub will then pass that data directly to your Windows Service's business logic.

2. Step 1: Set Up SignalR Hub in Your Windows Service #

First, add the necessary NuGet packages to your Windows Service project:

Install-Package Microsoft.AspNet.SignalR.SelfHost
Install-Package Microsoft.Owin.Hosting

Create the SignalR Hub Class #

This hub will define the method your WCF service calls to push data:

using Microsoft.AspNet.SignalR;

namespace POCWindowsService.SignalR
{
    public class DataPushHub : Hub
    {
        // Method called by WCF client to send data to Windows Service
        public void PushData(string payload)
        {
            // Directly invoke your Windows Service's processing logic
            // We'll use a static instance for tight coupling (see below)
            TestService.Instance.HandleIncomingData(payload);
        }
    }
}

Host SignalR in Your Windows Service #

Update your Windows Service code to start/stop the SignalR server, and expose a static instance for the Hub to access:

using Microsoft.Owin.Hosting;
using Owin;
using POCWindowsService.SignalR;

namespace POCWindowsService
{
    public partial class TestService : ServiceBase
    {
        // Static instance for Hub to reference (thread-safe handling included)
        public static TestService Instance { get; private set; }
        private IDisposable _signalRServer;
        private readonly object _dataLock = new object();

        public TestService()
        {
            InitializeComponent();
            Instance = this;
        }

        protected override void OnStart(string[] args)
        {
            // Start SignalR on a fixed port (adjust as needed)
            const string signalRUrl = "http://localhost:8080";
            _signalRServer = WebApp.Start<Startup>(signalRUrl);
        }

        protected override void OnStop()
        {
            // Clean up SignalR server on service stop
            _signalRServer?.Dispose();
        }

        // Method to process data from SignalR (thread-safe)
        public void HandleIncomingData(string payload)
        {
            lock (_dataLock)
            {
                // Add your business logic here: save to DB, trigger workflows, etc.
                // Example:
                // Logger.Log($"Received data: {payload}");
            }
        }
    }

    // OWIN startup configuration for SignalR
    public class Startup
    {
        public void Configuration(IAppBuilder app)
        {
            // Map SignalR to the root path
            app.MapSignalR();
        }
    }
}

3. Step 2: Integrate SignalR Client into Your WCF Service #

Add the SignalR client NuGet package to your WCF project:

Install-Package Microsoft.AspNet.SignalR.Client

Connect WCF Service to the SignalR Hub #

Update your WCF service to maintain a persistent SignalR connection, with automatic reconnection for stability:

using Microsoft.AspNet.SignalR.Client;
using System.Threading;

namespace YourWcfServiceNamespace
{
    public class YourWcfService : IYourWcfContract
    {
        private HubConnection _hubConnection;
        private IHubProxy _dataPushProxy;

        public YourWcfService()
        {
            // Initialize connection to the Windows Service's SignalR Hub
            _hubConnection = new HubConnection("http://localhost:8080");
            _dataPushProxy = _hubConnection.CreateHubProxy("DataPushHub");

            // Start connection with automatic retry on failure
            EstablishConnection();

            // Set up reconnection logic if the connection drops
            _hubConnection.Closed += () =>
            {
                Thread.Sleep(5000); // Wait 5 seconds before retrying
                EstablishConnection();
            };
        }

        private void EstablishConnection()
        {
            _hubConnection.Start().ContinueWith(task =>
            {
                if (task.IsFaulted)
                {
                    // Log the failure (use your preferred logging framework)
                    // Logger.Error("Failed to connect to SignalR Hub", task.Exception);
                }
                else
                {
                    // Logger.Info("Connected to SignalR Hub successfully");
                }
            });
        }

        // Example WCF method that triggers a data push to Windows Service
        public void ProcessAndPushData(string newData)
        {
            // Your existing WCF business logic here...

            // Push data to Windows Service if connected
            if (_hubConnection.State == ConnectionState.Connected)
            {
                _dataPushProxy.Invoke("PushData", newData).ContinueWith(task =>
                {
                    if (task.IsFaulted)
                    {
                        // Log push failure
                        // Logger.Error("Failed to push data to Windows Service", task.Exception);
                    }
                });
            }
            else
            {
                // Optional: Cache data locally and retry when connection is restored
                // Cache.AddToQueue(newData);
            }
        }

        // Clean up connection when WCF service instance is disposed
        public void Dispose()
        {
            _hubConnection?.Stop();
            _hubConnection?.Dispose();
        }
    }
}

4. Critical Stability & Coupling Notes #

• Port Permissions: Ensure your Windows Service's runtime account has permission to listen on the SignalR port. Run this command in an elevated command prompt:

  netsh http add urlacl url=http://+:8080/ user=NT SERVICE\TestService
  

  (Replace TestService with your actual Windows Service name)
• Thread Safety: The lock statement in HandleIncomingData ensures your Windows Service's logic isn't corrupted by concurrent SignalR calls. Adjust based on your specific workload.
• Looser Coupling (Optional): If you don't want a static instance, use a dependency injection container (like Autofac) to inject your Windows Service instance into the SignalR Hub. This makes testing easier.
• Logging: Add comprehensive logging to both services to debug connection issues, failed pushes, and data processing errors.
• Connection Resilience: The reconnection logic in the WCF client ensures it automatically reconnects if the SignalR connection drops (e.g., Windows Service restarts temporarily).

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