C# 分组相同的WCF请求

如果WCF服务收到相同的请求，则意味着在所有参数上都有相同的MD5，我要阻止除第一个请求之外的所有请求，直到处理完成并通知所有等待的客户端

---

最好的方法是什么？我有一个类似于信道接收器的东西，也许有一个芬兰的实现来归档这个？

首先，我正在考虑一个哈希表的自定义实现，以便在开始一个新的请求处理之前保持对MD %s的处理和查找。

< P>我不确定什么是WCF体系结构的“最佳”适合，但是您应该考虑将您设置为单机，因为您可能正在执行许多同步步骤。你想在这里做什么

像这样的怎么样？显然，您需要对字典本身进行一些同步，但至少这是一个开始

private IDictionary<string, RequestToken> RequestTokens = 
   new Dictionary<string, RequestToken>();

public MyResponse MyMethod(MyRequest request)
{
   // get the MD5 for the request
   var md5 = GetMD5Hash(request);

   // check if another thread is processing/has processed an identical request
   RequestToken token;
   if (RequestTokens.TryGetValue(md5, out token))
   {
      // if the token exists already then wait till we can acquire the lock
      // which indicates the processing has finished and a response is ready
      // for us to reuse
      lock (token.Sync)
      {
         return token.Response;
      }
   }
   else
   {
      var token = new Token(md5);
      lock (token.Sync)
      {
         RequestTokens.Add(md5, token);

         // do processing here..
         var response = ....

         token.Response = response;

         return response;
      }
   }
}

private class RequestToken
{
   private readonly object _sync = new object();

   public RequestToken(string md5)
   {
      MD5 = md5;
   }

   public string MD5 { get; private set; }

   public object Sync { get { return _sync; } }

   public MyResponse Response { get; set; }
}

专用IDictionary请求令牌=
新字典（）；
公共MyResponse MyMethod（MyRequest-request）
{
//获取请求的MD5
var md5=GetMD5Hash（请求）；
//检查另一个线程是否正在处理/已处理相同的请求
请求令牌；
if（RequestTokens.TryGetValue（md5，out令牌））
{
//如果令牌已经存在，则等待我们获得锁
//这表示处理已完成，响应已准备就绪
//供我们重复使用
锁（token.Sync）
{
返回token.Response；
}
}
其他的
{
var令牌=新令牌（md5）；
锁（token.Sync）
{
Add（md5，token）；
//在这里进行处理。。
var响应=。。。。
响应=响应；
返回响应；
}
}
}
私有类请求令牌
{
私有只读对象_sync=新对象（）；
公共请求令牌（字符串md5）
{
MD5=MD5；
}
公共字符串MD5{get；private set；}
公共对象同步{get{return\u Sync；}}
公共MyResponse响应{get；set；}
}

对我来说，这是我想从我的业务逻辑中抽象出来的东西，我个人将使用PostSharp并编写一个小属性来处理所有这些

---

我编写了一个属性，它在基于请求的缓存响应行中执行类似的操作，但没有同步步骤，因此您可能可以查看我所做的操作，并相应地修改它以实现您的目标。

是的。这是合乎逻辑的。我感兴趣的问题是如何有效地阻止线程以及钩住哪个事件。也许有一种聪明的方法可以完美地融入WCF架构。假设这是一个极其昂贵的操作，需要一个复杂的、跨请求的协调系统，这是正确的吗？是的。一个请求需要几秒钟才能完成，并且无法缓存。这是最简单的方法，可以肯定有效。但这正是我想要阻止的。我正在寻找一种高效的方法，能够每秒处理1000个或更多请求。在第一个请求完成之前，您真的需要使用相同的MD5校验和阻止所有后续请求吗？这种同步显然会影响到您可以通过服务推送多少并发性。此外，您很可能需要跨多台计算机进行扩展，以便能够每秒处理1000多个请求，尤其是在您的操作非常昂贵的情况下。而要在机器上做你想做的事情，又是另一件怪事！我不想横穿机器。我认为这是低效的。我知道，由于调用我的服务的第三方系统设计糟糕，多个呼叫（>100）同时击中了我。