C#环形缓冲区（队列）完全实现

公司项目中经常设计到串口通信，tcp通信，而且大多都是实时的大数据的传输，然后大家都知道协议通讯肯定涉及到什么，封包、拆包、粘包、校验……什么鬼的概念一大堆，说简单点儿就是要一个高效率可复用的缓存区。按照码农的惯性思维就是去百度、谷歌搜索看有没有现成的东西可以直接拿来用，然而我并没有找到，好吧不是很难的东西自己实现一个呗。开扯…… 

为什么要用环形队列？
环形队列是在实际编程极为有用的数据结构,它有如下特点：
它是一个首尾相连的fifo的数据结构，采用数组的线性空间,数据组织简单。能很快知道队列是否满为空。能以很快速度的来存取数据。
因为有简单高效的原因，甚至在硬件都实现了环形队列。 

c#完全实现（可直接使用）
鄙人新手这份代码肯定有不足之处，望大家指出交流，涉及到的多线程同步问题请调用者完成，不废话直接上代码。

 public class ringbuffermanager
{
  public byte[] buffer { get; set; } // 存放内存的数组
  public int datacount { get; set; } // 写入数据大小
  public int datastart { get; set; } // 数据起始索引
  public int dataend { get; set; }  // 数据结束索引
  public ringbuffermanager(int buffersize)
  {
    datacount = 0; datastart = 0; dataend = 0;
    buffer = new byte[buffersize];
  }

  public byte this[int index]
  {
    get
    {
      if (index >= datacount) throw new exception("环形缓冲区异常，索引溢出");
      if (datastart + index < buffer.length)
      {
        return buffer[datastart + index];
      }
      else 
      {
        return buffer[(datastart + index) - buffer.length];
      }
    }
  }

  public int getdatacount() // 获得当前写入的字节数
  {
    return datacount;
  }

  public int getreservecount() // 获得剩余的字节数
  {
    return buffer.length - datacount;
  }

  public void clear()
  {
    datacount = 0;
  }

  public void clear(int count) // 清空指定大小的数据
  {
    if (count >= datacount) // 如果需要清理的数据大于现有数据大小，则全部清理
    {
      datacount = 0;
      datastart = 0;
      dataend = 0;
    }
    else
    {
      if (datastart + count >= buffer.length)
      {
        datastart = (datastart + count) - buffer.length;
      }
      else 
      {
        datastart += count;
      }
      datacount -= count;
    }
  }

  public void writebuffer(byte[] buffer, int offset, int count)
  {
    int32 reservecount = buffer.length - datacount;
    if (reservecount >= count)             // 可用空间够使用
    {
      if (dataend + count < buffer.length)      // 数据没到结尾
      {
        array.copy(buffer, offset, buffer, dataend, count);
        dataend += count;
        datacount += count;
      }
      else      // 数据结束索引超出结尾 循环到开始
      {
        system.diagnostics.debug.writeline("缓存重新开始....");
        int32 overflowindexlength = (dataend + count) - buffer.length;   // 超出索引长度
        int32 endpushindexlength = count - overflowindexlength;       // 填充在末尾的数据长度
        array.copy(buffer, offset, buffer, dataend, endpushindexlength);
        dataend = 0;
        offset += endpushindexlength;
        datacount += endpushindexlength;
        if (overflowindexlength != 0)
        {
          array.copy(buffer, offset, buffer, dataend, overflowindexlength);
        }
        dataend += overflowindexlength;                   // 结束索引
        datacount += overflowindexlength;                  // 缓存大小
      }
    }
    else 
    {
      // 缓存溢出，不处理
    }
  }

  public void readbuffer(byte[] targetbytes,int32 offset, int32 count) 
  {
    if (count > datacount) throw new exception("环形缓冲区异常，读取长度大于数据长度");
    int32 tempdatastart = datastart;
    if (datastart + count < buffer.length)
    {
      array.copy(buffer, datastart, targetbytes, offset, count);
    }
    else 
    {
      int32 overflowindexlength = (datastart + count) - buffer.length;  // 超出索引长度
      int32 endpushindexlength = count - overflowindexlength;       // 填充在末尾的数据长度
      array.copy(buffer, datastart, targetbytes, offset, endpushindexlength);
      
      offset += endpushindexlength;
      
      if (overflowindexlength != 0)
      {
        array.copy(buffer, 0, targetbytes, offset, overflowindexlength);
      }
    }
  }


  public void writebuffer(byte[] buffer)
  {
    writebuffer(buffer, 0, buffer.length);
  }

}

调用实例
生产

 int len = sconn.receive(receivebuffer, 0, receivebuffer.length, socketflags.none, out se);
if (len <= 0) throw new exception("disconnect..");
if (len > 0)
{
  lock (lockreceivebuffer)
  {
    while (len + receivebuffermanager.datacount > max_buffer_len)    // 缓存溢出处理
    {
      monitor.wait(lockreceivebuffer,10000);
    }
    receivebuffermanager.writebuffer(receivebuffer, 0, len);
    monitor.pulseall(lockreceivebuffer);
  }
} 

消费

 lock (lockreceivebuffer)
{
  freame_byte = new byte[framelen];
  receivebuffermanager.readbuffer(freame_byte, 0, framelen);
  receivebuffermanager.clear(framelen);
｝ 

验证 
tcp大数据连续测试一周没出现问题内存问题。

以上就是本文的全部内容，希望对大家的学习有所帮助，也希望大家多多支持。