WCF命名管道结合WPF实现大文件复制时的超时问题求助

核心问题在于请求-响应模式的WCF操作绑定了长时任务：CheckPackages作为带返回值的OperationContract，WCF会等待整个方法执行完成才返回响应，但内部包含大文件复制这类耗时操作，远超WCF默认（或自定义设置的）超时阈值。即使实现了单向回调推送进度，主请求的响应仍未返回，WCF依然会判定超时。

一、重构WCF接口设计（根本解决超时） #

将长时任务拆分为单向启动+回调通知模式，避免主请求等待任务完成：

1. 修改服务与回调接口 #

[ServiceContract(CallbackContract = typeof(ICopierCallbackService))]
public interface ICopierService
{        
    // 单向操作：启动检查+复制任务，立即返回给客户端
    [OperationContract(IsOneWay = true)]
    void StartCheckPackages();

    // 可选：查询任务当前状态（短耗时操作，不会超时）
    [OperationContract]
    Task<PackageCheckStatus> GetCheckPackagesStatus();
}

[ServiceContract]   
public interface ICopierCallbackService
{
    [OperationContract(IsOneWay = true)]
    void GetTime(string time);

    [OperationContract(IsOneWay = true)]
    void ReportCopyProgress(string source, string destination, int progress);

    // 新增：通知客户端任务完成，返回最终结果
    [OperationContract(IsOneWay = true)]
    void CheckPackagesCompleted(List<Package> packages, bool success, string errorMessage);
}

// 新增任务状态类
public class PackageCheckStatus
{
    public bool IsRunning { get; set; }
    public bool IsSuccess { get; set; }
    public string ErrorMessage { get; set; }
}

2. 服务端异步处理长时任务 #

将复制逻辑放到后台线程池执行，避免阻塞WCF请求处理线程：

public class CopierService : ICopierService
{
    // 跟踪活跃任务与对应回调对象
    private readonly ConcurrentDictionary<ICopierCallbackService, Task> _activeTasks = new();

    public void StartCheckPackages()
    {
        var callback = OperationContext.Current.GetCallbackChannel<ICopierCallbackService>();
        
        // 后台执行任务，立即返回
        _activeTasks[callback] = Task.Run(async () =>
        {
            List<Package> result = null;
            bool success = true;
            string error = null;
            try
            {
                Root root = await ApiHandler.FetchClientPackages(_Settings.Hostname);
                List<Package> packages = root.Data.Packages;

                DirectoryInfo directoryInfo = new DirectoryInfo(_Settings.LocalPackagesRealPath);
                FileInfo[] files = directoryInfo.GetFiles("*.txt");
                packages = await AdjustPackage(files, packages);

                await CopyIcons(callback);
                result = packages;
            }
            catch (Exception ex)
            {
                success = false;
                error = ex.Message;
                System.Diagnostics.Debug.WriteLine($"任务执行失败: {ex.Message}");
            }
            finally
            {
                // 通知客户端任务完成
                callback.CheckPackagesCompleted(result, success, error);
                _activeTasks.TryRemove(callback, out _);
            }
        });
    }

    public async Task<PackageCheckStatus> GetCheckPackagesStatus()
    {
        var callback = OperationContext.Current.GetCallbackChannel<ICopierCallbackService>();
        if (_activeTasks.TryGetValue(callback, out var task))
        {
            return new PackageCheckStatus
            {
                IsRunning = !task.IsCompleted,
                IsSuccess = task.IsCompletedSuccessfully,
                ErrorMessage = task.Exception?.InnerException.Message
            };
        }
        return new PackageCheckStatus { IsRunning = false };
    }

    // 原CopyDirectoryInternalAsync等复制方法保留，继续通过回调推送进度
}

3. 客户端调整调用逻辑 #

不再等待返回值，通过事件接收进度和完成通知：

public class ServiceClient : ICopierCallbackService
{
    private ICopierService _serviceProxy;
    private DuplexChannelFactory<ICopierService> _duplexChannelFactory;
    private const string NamedPipeAddress = "net.pipe://localhost/service";
    
    public event EventHandler<CopyProgressEventArgs> CopyProgressChanged;
    public event EventHandler<CheckPackagesCompletedEventArgs> CheckPackagesCompleted;

    public ServiceClient()
    {
        var binding = new NetNamedPipeBinding(NetNamedPipeSecurityMode.None)
        {
            OpenTimeout = TimeSpan.FromSeconds(30),
            ReceiveTimeout = TimeSpan.FromMinutes(30),
            MaxReceivedMessageSize = 1024 * 1024 * 10
        };
        _duplexChannelFactory = new DuplexChannelFactory<ICopierService>(this, binding, new EndpointAddress(NamedPipeAddress));
        _serviceProxy = _duplexChannelFactory.CreateChannel();
    }

    // 启动任务，立即返回
    public void StartCheckPackages()
    {
        _serviceProxy.StartCheckPackages();
    }

    public void ReportCopyProgress(string source, string destination, int progress)
    {
        CopyProgressChanged?.Invoke(this, new CopyProgressEventArgs(source, destination, progress));
    }

    public void CheckPackagesCompleted(List<Package> packages, bool success, string errorMessage)
    {
        CheckPackagesCompleted?.Invoke(this, new CheckPackagesCompletedEventArgs(packages, success, errorMessage));
    }

    // 查询任务状态
    public async Task<PackageCheckStatus> GetCheckPackagesStatus()
    {
        return await _serviceProxy.GetCheckPackagesStatus();
    }
}

// 新增任务完成事件类
public class CheckPackagesCompletedEventArgs : EventArgs
{
    public List<Package> Packages { get; set; }
    public bool Success { get; set; }
    public string ErrorMessage { get; set; }

    public CheckPackagesCompletedEventArgs(List<Package> packages, bool success, string errorMessage)
    {
        Packages = packages;
        Success = success;
        ErrorMessage = errorMessage;
    }
}

二、优化命名管道配置（辅助提升稳定性） #

调整NetNamedPipeBinding参数，适配长时回调场景：

var binding = new NetNamedPipeBinding(NetNamedPipeSecurityMode.None)
{
    OpenTimeout = TimeSpan.FromSeconds(30),          // 通道打开超时
    SendTimeout = TimeSpan.FromMinutes(5),           // 单向操作发送超时
    ReceiveTimeout = TimeSpan.FromMinutes(30),       // 回调通道接收超时
    MaxReceivedMessageSize = 1024 * 1024 * 10,       // 最大接收消息大小（10MB）
    MaxBufferSize = 1024 * 1024 * 10,
    MaxBufferPoolSize = 1024 * 1024 * 20
};

三、后台任务兼容性处理 #

后台任务（CIFS共享检查、状态记录）使用Task异步机制完全兼容，只需注意两点：

• 用Task.Run将任务放到线程池执行，避免阻塞WCF服务线程
• 若需与WCF服务交互，使用线程安全集合（如ConcurrentDictionary）管理回调对象

1. gRPC（推荐） #

• 支持双向流式通信，天然适配长时任务的进度推送与结果返回，无需拆分接口
• 基于HTTP/2，性能优异，.NET生态支持完善，跨平台兼容
• 可直接定义流式服务，客户端启动任务后持续接收进度，最终获取结果

2. SignalR（本地WebSocket） #

• 基于WebSocket的实时双向通信框架，WPF客户端可直接使用Microsoft.AspNetCore.SignalR.Client
• 配置简单，适合实时状态更新场景，无需手动管理通道超时

3. 内存映射文件（高性能场景） #

• 适合极高性能的本地IPC，支持大数据传输
• 需要自行实现消息序列化、进度通知逻辑，复杂度较高

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