Memory leaks 信号器自定义ScaleoutMessageBus内存泄漏

我实现了简单的ScaleoutMessageBus。我重写Send方法并将消息发送到所有配置的节点。它可以工作，但当系统处于重载状态时，w3wp进程的内存会增长。当我创建转储时，我看到几乎所有内存都保存在信号器消息对象中。有人知道我做错了什么吗

谢谢

马丁

更新添加的ScaleOutBus类

公共类ScaleoutMessageBus:Microsoft.AspNet.signal.Messaging.ScaleoutMessageBus
{
私有静态long sNextId=long.MinValue；
私有只读列表ProxiseSendPointName；
私有静态只读对象锁=新对象（）；
/// 
///初始化类的新实例。
/// 
///解析程序。
///配置。
公共ScaleoutMessageBus（IDependencyResolver解析器，ScaleoutConfiguration配置）
：base（解析器，配置）
{
ProxiseEndPointName=新列表（config.NodeEndpoints）；
开放（0）；
}
接收到私有void（int streamIndex，长id，字节[]数据）
{
ScaleoutMessage message=ScaleoutMessage.FromBytes（数据）；
var uid=未选中（（ulong）id）；
锁（锁）
{
OnReceived（流索引、uid、消息）；
}
}
/// 
///发送指定的流索引。
/// 
///流的索引。
///这些信息。
/// 
受保护的覆盖任务发送（int streamIndex、IList消息）
{
var messageToSend=新的ScaleoutMessage（消息）；
var bytesToSend=messageToSend.ToBytes（）；
返回Task.Factory.StartNew（（）=>
{
Parallel.ForEach（proxiesEndpointName.Where（s=>！String.IsNullOrEmpty），s=>
{
尝试
{
var proxy=new ChannelProxyWrapper.GetTransparentProxy（）；
Send（streamIndex，bytesToSend）；
}
捕获（例外情况除外）
{
LogHelper.WriteException（例如，TraceEventType.Warning，“无法向节点{0}”发送消息）；
}
});
});
}
/// 
///发送指定的流索引。
/// 
///流的索引。
///数据。
public void Send（int streamIndex，字节[]数据）
{
长id=联锁增量（参考sNextId）；
接收（流索引、id、数据）；
}
}

您应该显示代码，否则很难帮助。您应该显示代码，否则很难帮助。您应该显示代码，否则很难帮助。

public class ScaleoutMessageBus : Microsoft.AspNet.SignalR.Messaging.ScaleoutMessageBus
      {
        private static long sNextId = long.MinValue;
        private readonly List<string> proxiesEndpointName;
        private static readonly object Lock = new object();

        /// <summary>
        ///   Initializes a new instance of the <see cref="ScaleoutMessageBus" /> class.
        /// </summary>
        /// <param name="resolver">The resolver.</param>
        /// <param name="config">The configuration.</param>
        public ScaleoutMessageBus(IDependencyResolver resolver, ScaleoutConfiguration config)
          : base(resolver, config)
        {
          proxiesEndpointName = new List<string>(config.NodeEndpoints);
          Open(0);
        }

        private void Received(int streamIndex, long id, byte[] data)
        {
          ScaleoutMessage message = ScaleoutMessage.FromBytes(data);
          var uid = unchecked((ulong)id);
          lock (Lock)
          {
            OnReceived(streamIndex, uid, message);
          }
        }

        /// <summary>
        /// Sends the specified stream index.
        /// </summary>
        /// <param name="streamIndex">Index of the stream.</param>
        /// <param name="messages">The messages.</param>
        /// <returns></returns>
        protected override Task Send(int streamIndex, IList<Message> messages)
        {
          var messageToSend = new ScaleoutMessage(messages);
          var bytesToSend = messageToSend.ToBytes();
          return Task.Factory.StartNew(() =>
          {
            Parallel.ForEach(proxiesEndpointName.Where(s => !String.IsNullOrEmpty(s)), s =>
            {
              try
              {
                var proxy = new ChannelProxyWrapper<IBackplaneService>(s).GetTransparentProxy();
                proxy.Send(streamIndex, bytesToSend);
              }
              catch (Exception ex)
              {
                LogHelper.WriteException(ex, TraceEventType.Warning, "Cannot send message to node {0}", s);
              }
            });
          });
        }


        /// <summary>
        /// Sends the specified stream index.
        /// </summary>
        /// <param name="streamIndex">Index of the stream.</param>
        /// <param name="data">The data.</param>
        public void Send(int streamIndex, byte[] data)
        {
          long id = Interlocked.Increment(ref sNextId);
          Received(streamIndex, id, data);
        }
      }