环形缓存(C#版)

想了一想，既然连厌恶的android平台都测试了环形缓存，不能冷落了windows。

C#源码：

/// <summary>
/// 环形缓冲区
/// 一. 写数据:
///     1. push: 当数据已写满时返回false，否则可以正常写入返回true
///     2. pushNoCaseFull: 不管缓冲区是否已写满或当前位置数据是否已读取过，都会写入，不关心读/写指针位置
/// 二. 读数据:
///     1. pull: 当缓冲区已读空或还未写入过数据时，返回null
///             另外一个重载方法可以对指定位置进行读取，此方法不会影响读指针位置
///     2. pullNoCaseEmpty: 不管当前位置的数据有没有读过，即可以重复读，不关心读/写指针位置,不会影响读指针位置
///             另外一个重载方法可以对指定位置进行读取，此方法不会影响读指针位置
///     3. pullBack: 反相读取数据，返回数据情况与pull相同
///     4. pullBackNoCaseEmpty: 反相读取数据，返回数据情况与pullNoCaseEmpty相同
/// 三. 是否已写满:
///     isFull: 如果写之前关心是否已满，调用此方法
/// 四. 是否已读空:
///     isEmpty: 读数据之前关心是否已读空，调用此方法
/// </summary>
/// <typeparam name="T">需要存储的类型</typeparam>
/// 

public class RingBuffer<T>
{
    private static byte INVALID = 0;// 无效数据
    private static byte WRITED = 1;// 数据写过
    private static byte READED = 2;// 数据读过

    private int mCapacity = 0;
    private List<Node> mDataBuf = null;
    private int mReader = 0;
    private int mWriter = 0;


    private class Node
    {
        public T @object = default(T);
        public byte flag = INVALID;

        public Node(T @object, byte flag)
        {
            this.@object = @object;
            this.flag = flag;
        }
    }


    public RingBuffer(int capacity)
    {
        mCapacity = capacity;
        mDataBuf = new List<Node>(capacity);
    }

    /// <summary>
    /// 当数据已写满时返回false，否则可以正常写入返回true
    /// </summary>
    /// <param name="object">被压入的数据</param>
    /// <returns>写入成功, false:缓冲区已满</returns>
    public Boolean Push(T @object)
    {
        lock(this)
        {
            int size = mDataBuf.Count;

            if (mWriter < mCapacity)
            {
            }
            else if (mWriter >= mCapacity)// 写到尾部
            {
                mWriter = 0;
            }

            if (mCapacity > size)// 无效数据(未写过数据)
            {
                Node node = new Node(@object, WRITED);
                mDataBuf.Add(node);
                mWriter++;
            }
            else
            {
                try
                {
                    Node