概述

看了一个数据结构的教程，是用C++写的，可自己C#还是一个菜鸟，更别说C++了，但还是大胆尝试用C#将其中的环形队列的实现写出来，先上代码：

 1     public class MyQueue<T> : IDisposable

 2     {

 3         private T[] queue;

 4         private int length;

 5         private int capacity;

 6         private int head = 0;

 7         private int tail = 0;

 8

 9         public MyQueue(int capacity) {

10             this.capacity = capacity;

11             this.head = 0;

12             this.tail = 0;

13             this.length = 0;

14             this.queue = new T[capacity];

15         }

16

17         public void Clear() {

18             head = 0;

19             tail = 0;

20             length = 0;

21         }

22

23         public bool IsEmpty() {

24             return length == 0;

25         }

26

27         public bool IsFull() {

28             return length == capacity;

29         }

30

31         public int Length() {

32             return length;

33         }

34

35         public bool EnQueue(T node) {

36             if (!IsFull()) {

37                 queue[tail] = node;

38                 tail = (++tail) % capacity;

39                 length++;

40                 return true;

41             }

42             return false;

43         }

44

45         public T DeQueue() {

46             T node = default(T);

47             if (!IsEmpty()) {

48                 node = queue[head];

49                 head = (++head) % capacity;

50                 length--;

51             }

52             return node;

53         }

54

55         public void Traverse() {

56             for (int i = head; i < length + head; i++) {

57                 Console.WriteLine(queue[i % capacity]);

58                 Console.WriteLine($"前面还有{i - head}个");

59             }

60         }

61

62         public void Dispose() {

63             queue = null;

64         }

65     }

为了能够通用，所以用的是泛型来实现环形队列类。这里最重要的是进队(EnQueue)和出队(DeQueue)两个方法，进队或出队后头和尾的位置都要通过取模运算来获得，因为是环形队列嘛，你懂的。

一、简单类型队列

好了，测试下入队：

 1     class Program

 2     {

 3         static void Main(string[] args) {

 4             MyQueue<int> queue = new MyQueue<int>(4);

 5             queue.EnQueue(10);

 6             queue.EnQueue(16);

 7             queue.EnQueue(18);

 8             queue.EnQueue(12);

 9             queue.Traverse();

10             Console.Read();

11         }

12     }

显示结果：

再测试下出队：

 1     class Program

 2     {

 3         static void Main(string[] args) {

 4             MyQueue<int> queue = new MyQueue<int>(4);

 5             queue.EnQueue(10);

 6             queue.EnQueue(16);

 7             queue.EnQueue(18);

 8             queue.EnQueue(12);

 9             queue.Traverse();

10

11             Console.WriteLine("弹两个出去");

12             queue.DeQueue();

13             queue.DeQueue();

14             Console.WriteLine();

15             queue.Traverse();

16             Console.Read();

17         }

18     }

运行结果：

 

二、复杂类型队列

之前也说了，这个队列类是用的泛型写的，对应于C++的模板了，那就意味着任何类型都可以使用这个队列类，来测试个自定义的类试试，如下先定义一个Customer类：

 1     public class Customer

 2     {

 3         public string Name { get; set; }

 4

 5         public int Age { get; set; }

 6

 7         public void PringInfo() {

 8             Console.WriteLine("姓名:" + Name);

 9             Console.WriteLine("年龄:" + Age);

10             Console.WriteLine();

11         }

12     }

然后进行入队，如下：

 1     class Program

 2     {

 3         static void Main(string[] args) {

 4             MyQueue<Customer> queue = new MyQueue<Customer>(5);

 5             queue.EnQueue(new Customer() { Name = "宋小二", Age = 29 });

 6             queue.EnQueue(new Customer() { Name = "陈小三", Age = 28 });

 7             queue.EnQueue(new Customer() { Name = "王小四", Age = 26 });

 8             queue.EnQueue(new Customer() { Name = "朱小五", Age = 48 });

 9             for (int i = 0; i < queue.Length(); i++) {

10                 queue[i].PringInfo();

11             }

12             Console.Read();

13         }

14     }

上面的代码 queue[i].PringInfo();是通过索引来实现，所以我们得在队列类中实现索引，添加如下代码到MyQueue.cs类中，如下：

1         public T this[int index] {

2             get {

3                 return queue[index];

4             }

5         }

感觉用for循环来遍历还是不够好，想用foreach，那就给MyQueue类加个遍历接口，如下：

然后实现这个接口，如下：

 1         public IEnumerator<T> GetEnumerator() {

 2             foreach(T node in queue) {

 3                 if(node != null) {

 4                     yield return node;

 5                 }

 6             }

 7         }

 8

 9         IEnumerator IEnumerable.GetEnumerator() {

10             return GetEnumerator();

11         }

这样遍历的地方就可以改成foreach了，如下：

执行结果：

 
 
文2：

公司项目中经常设计到串口通信，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);

｝

【转】C#环形队列的相关教程结束。