WCF 多个客户端阻塞问题！

Question

我似乎遇到了 WCF 阻塞问题。

假设我有两个用户，每个用户都使用 net.tcp 创建了自己的在 WCF 主机上公开的类实例，其端点类似于“net.tcp://localhost:32000/SymHost/”。该类是 PerSession 上下文，并发性是可重入的。该类公开了两个方法 Alive()，它们立即返回 true 布尔值，以及我插入的 AliveWait，它在返回 true 之前执行 Thread.Sleep 4 秒（测试目的）。

现在客户端 1 调用 AliveWait() ，在此期间他被阻止，这很公平，但是如果客户端 2 在其自己的实例上调用 Alive()，他必须等到客户端 1 的调用返回 - 这种行为不是我想要的会预料到吗？我希望客户端 2 能够像什么都没发生一样继续运行，或者这是否与它们共享相同的端点有关？

谁能解释一下发生了什么以及我如何确保客户端 2 可以不间断地调用自己的实例？

非常感谢任何帮助！

Answer 1

我发现那是什么了！我忘记在 Test 类的 ServiceBehaviour 中将 UseSynchronizationContext 设置为 false。默认为 true，这会同步服务上的所有调用以在同一线程上运行！因此，来自其他客户端的任何后续呼叫都只是排队！

Answer 2

向我们展示服务等级！仅从你的描述来看，无法判断到底是怎么回事。

我不期望客户端 2 被客户端 1 阻止 - 在每个会话场景中，两个客户端都应该获得自己的、完全独立的服务类实例。这就是为什么我们需要查看我们正在处理的代码类型......通常，这种设置不应该有任何问题。

Answer 3

这正是我的想法！所以这里是一些源代码（经过一些复制和粘贴之后...）：

-- 合约定义

[ServiceContract(CallbackContract = typeof(IAliveCallback))]
public interface IAlive 
{
    [OperationContract]
    bool Validate();

    [OperationContract]
    string AliveWait(int i);    // test test
}

-- 在我的 Alive 类中实现合约

[ServiceBehavior(InstanceContextMode = InstanceContextMode.PerSession, ConcurrencyMode = ConcurrencyMode.Single)]
public class Alive : SymHostBase, IAlive
{
    private readonly static string _ID = "Alive";
    private static int _MaxAliveWaitSeconds = 5;

    public bool Validate()
    {
        return true;
    }

    public string AliveWait(int i)
    {
        Thread.Sleep(i * 1000);
        return string.Format("I waited {0} seconds", i);
    }

...
...
}

-- 然后在 Host 应用程序上它看起来像这样...

        string s = string.Format("net.tcp://localhost:{0}/Host/", port);
        Uri tcpAddr = new Uri(s);
        Uri[] baseAddress = { tcpAddr };

        int MaxBuffer = 64;     // 64 Mb
        int bufferSize = MaxBuffer * 1024 * 1024;   // 67108864

        NetTcpBinding tcpBinding = new NetTcpBinding(SecurityMode.None, true);
        tcpBinding.MaxBufferPoolSize = bufferSize; // 64 Mb
        tcpBinding.MaxBufferSize = bufferSize;
        tcpBinding.MaxReceivedMessageSize = bufferSize;
        tcpBinding.TransferMode = TransferMode.Buffered;
        tcpBinding.ReaderQuotas.MaxArrayLength = bufferSize;
        tcpBinding.ReaderQuotas.MaxBytesPerRead = bufferSize;
        tcpBinding.ReaderQuotas.MaxStringContentLength = bufferSize;

        tcpBinding.MaxConnections = 100;
        //tcpBinding.ReceiveTimeout = new TimeSpan(20, 0, 0);
        tcpBinding.SendTimeout = new TimeSpan(0, 0, 5);     
        tcpBinding.ReliableSession.Enabled = true;
        tcpBinding.ReliableSession.InactivityTimeout = new TimeSpan(7, 0, 0, 0);    // 7 days


        _HostAlive = new ServiceHost(typeof(Alive), baseAddress);
        _HostAlive.AddServiceEndpoint(typeof(IAlive), tcpBinding, "alive");      // tcpBinding


        ServiceThrottlingBehavior throttle = _HostAlive.Description.Behaviors.Find<ServiceThrottlingBehavior>();
        if (throttle == null)
        {
            throttle = new ServiceThrottlingBehavior();
            host.Description.Behaviors.Add(throttle);
        }
        throttle.MaxConcurrentCalls = 1000;         // default 16
        throttle.MaxConcurrentInstances = 1000;     // default 26
        throttle.MaxConcurrentSessions = 1000;      // default 10 

        // open the host - bring it into life!
        host.Open();