C#创建安全的栈(Stack)存储结构

在C#中，用于存储的结构较多，如：DataTable，DataSet，List，Dictionary，Stack等结构，各种结构采用的存储的方式存在差异，效率也必然各有优缺点。现在介绍一种后进先出的数据结构。

谈到存储结构，我们在项目中使用的较多。对于Task存储结构，栈与队列是类似的结构，在使用的时候采用不同的方法。C#中栈（Stack）是编译期间就分配好的内存空间，因此你的代码中必须就栈的大小有明确的定义；堆是程序运行期间动态分配的内存空间，你可以根据程序的运行情况确定要分配的堆内存的大小。

在C#中，栈通常保存着我们代码执行的步骤。C#中的引用类型存储在栈中，在程序运行的时候，每个线程(Thread)都会维护一个自己的专属线程堆栈。当一个方法被调用的时候，主线程开始在所属程序集的元数据中，查找被调用方法，然后通过JIT即时编译并把结果（一般是本地CPU指令）放在栈顶。CPU通过总线从栈顶取指令，驱动程序以执行下去。

以上对栈这个数据结构进行了一个简单的介绍，现在看一下C#实现栈结构的底层方法：

    /// <summary>
    /// 初始化 <see cref="T:System.Collections.Generic.Stack`1"/> 类的新实例，该实例为空并且具有默认初始容量。
    /// </summary>
    [__DynamicallyInvokable]
    public Stack();
    /// <summary>
    /// 初始化 <see cref="T:System.Collections.Generic.Stack`1"/> 类的新实例，该实例为空，具有指定的初始容量或默认的初始容量（其中较大的一个）。
    /// </summary>
    /// <param name="capacity"><see cref="T:System.Collections.Generic.Stack`1"/> 可包含的初始元素数。</param><exception cref="T:System.ArgumentOutOfRangeException"><paramref name="capacity"/> is less than zero.</exception>
    [__DynamicallyInvokable]
    public Stack(int capacity);
    /// <summary>
    /// 初始化 <see cref="T:System.Collections.Generic.Stack`1"/> 类的新实例，该实例包含从指定集合复制的元素并且具有足够的容量来容纳所复制的元素。
    /// </summary>
    /// <param name="collection">从中复制元素的集合。</param><exception cref="T:System.ArgumentNullException"><paramref name="collection"/> is null.</exception>
    [__DynamicallyInvokable]
    public Stack(IEnumerable<T> collection);

以上是对stack的部分方法的介绍，由于在操作数据存储的同时，会考虑到线程的安全性。

进程作为操作系统执行程序的基本单位，拥有应用程序的资源，进程包含线程，进程的资源被线程共享，线程不拥有资源。线程分为前台线程和后台线程，通过Thread类新建线程默认为前台线程。当所有前台线程关闭时，所有的后台线程也会被直接终止，不会抛出异常。

接下来看一下ReaderWriterLockSlim类：

  /// <summary>
  /// 表示用于管理资源访问的锁定状态，可实现多线程读取或进行独占式写入访问。
  /// </summary>
  [__DynamicallyInvokable]
  [HostProtection(SecurityAction.LinkDemand, ExternalThreading = true, Synchronization = true)]
  [HostProtection(SecurityAction.LinkDemand, MayLeakOnAbort = true)]
  public class ReaderWriterLockSlim : IDisposable
  {
    /// <summary>
    /// 使用默认属性值初始化 <see cref="T:System.Threading.ReaderWriterLockSlim"/> 类的新实例。
    /// </summary>
    [__DynamicallyInvokable]
    public ReaderWriterLockSlim();
    /// <summary>
    /// 在指定锁定递归策略的情况下初始化 <see cref="T:System.Threading.ReaderWriterLockSlim"/> 类的新实例。
    /// </summary>
    /// <param name="recursionPolicy">枚举值之一，用于指定锁定递归策略。</param>
    [__DynamicallyInvokable]
    public ReaderWriterLockSlim(LockRecursionPolicy recursionPolicy);
    /// <summary>
    /// 尝试进入读取模式锁定状态。
    /// </summary>
    /// <exception cref="T:System.Threading.LockRecursionException"><see cref="P:System.Threading.ReaderWriterLockSlim.RecursionPolicy"/> 属性是 <see cref="F:System.Threading.LockRecursionPolicy.NoRecursion"/> 和当前的线程已进入读取的模式。- 或 -当它已经包含写入锁时，当前线程可能不会获取读的锁定。- 或 -递归数将超出该计数器的容量。此限制是很大的应用程序应永远不会遇到它。</exception><exception cref="T:System.ObjectDisposedException"><see cref="T:System.Threading.ReaderWriterLockSlim"/> 对象已被释放。</exception>
    [__DynamicallyInvokable]
    public void EnterReadLock();
    /// <summary>
    /// 尝试进入读取模式锁定状态，可以选择超时时间。
    /// </summary>
    /// 
    /// <returns>
    /// 如果调用线程已进入读取模式，则为 true；否则为 false。
    /// </returns>
    /// <param name="timeout">等待的间隔；或为 -1 毫秒，表示无限期等待。</param><exception cref="T:System.Threading.LockRecursionException"><see cref="P:System.Threading.ReaderWriterLockSlim.RecursionPolicy"/> 属性是 <see cref="F:System.Threading.LockRecursionPolicy.NoRecursion"/> 和当前的线程已进入该锁。- 或 -递归数将超出该计数器的容量。限制为应用程序应永远不会遇到它太大。</exception><exception cref="T:System.ArgumentOutOfRangeException">值 <paramref name="timeout"/> 为负数，但它不等于-1 毫秒为单位），这是唯一允许的值为负。- 或 -值 <paramref name="timeout"/> 大于 <see cref="F:System.Int32.MaxValue"/> 毫秒为单位）。</exception><exception cref="T:System.ObjectDisposedException"><see cref="T:System.Threading.ReaderWriterLockSlim"/> 对象已被释放。</exception>
    [__DynamicallyInvokable]
    public bool TryEnterReadLock(TimeSpan timeout);
    /// <summary>
    /// 尝试进入读取模式锁定状态，可以选择整数超时时间。
    /// </summary>
    /// 
    /// <returns>
    /// 如果调用线程已进入读取模式，则为 true；否则为 false。
    /// </returns>
    /// <param name="millisecondsTimeout">等待的毫秒数，或为 -1 (<see cref="F:System.Threading.Timeout.Infinite"/>)，表示无限期等待。</param><exception cref="T:System.Threading.LockRecursionException"><see cref="P:System.Threading.ReaderWriterLockSlim.RecursionPolicy"/> 属性是 <see cref="F:System.Threading.LockRecursionPolicy.NoRecursion"/> 和当前的线程已进入该锁。- 或 -递归数将超出该计数器的容量。限制为应用程序应永远不会遇到它太大。</exception><exception cref="T:System.ArgumentOutOfRangeException">值 <paramref name="millisecondsTimeout"/> 为负数，但它不是等于 <see cref="F:System.Threading.Timeout.Infinite"/> (-1)，这是唯一允许的值为负。</exception><exception cref="T:System.ObjectDisposedException"><see cref="T:System.Threading.ReaderWriterLockSlim"/> 对象已被释放。</exception>
    [__DynamicallyInvokable]
    public bool TryEnterReadLock(int millisecondsTimeout);
    /// <summary>
    /// 尝试进入写入模式锁定状态。
    /// </summary>
    /// <exception cref="T:System.Threading.LockRecursionException"><see cref="P:System.Threading.ReaderWriterLockSlim.RecursionPolicy"/> 属性是 <see cref="F:System.Threading.LockRecursionPolicy.NoRecursion"/> 和当前的线程已在任何模式下进入该锁。- 或 -当前线程已进入读取的模式，因此尝试进入锁定状态写模式，则会创建导致死锁的可能性。- 或 -递归数将超出该计数器的容量。限制为应用程序应永远不会遇到它太大。</exception><exception cref="T:System.ObjectDisposedException"><see cref="T:System.Threading.ReaderWriterLockSlim"/> 对象已被释放。</exception>
    [__DynamicallyInvokable]
    public void EnterWriteLock();
    /// <summary>
    /// 尝试进入写入模式锁定状态，可以选择超时时间。
    /// </summary>
    /// 
    /// <returns>
    /// 如果调用线程已进入写入模式，则为 true；否则为 false。
    /// </returns>
    /// <param name="timeout">等待的间隔；或为 -1 毫秒，表示无限期等待。</param><exception cref="T:System.Threading.LockRecursionException"><see cref="P:System.Threading.ReaderWriterLockSlim.RecursionPolicy"/> 属性是 <see cref="F:System.Threading.LockRecursionPolicy.NoRecursion"/> 和当前的线程已进入该锁。- 或 -当前线程最初在读取模式中，输入该锁，因此尝试进入写入模式会创建导致死锁的可能性。- 或 -递归数将超出该计数器的容量。限制为应用程序应永远不会遇到它太大。</exception><exception cref="T:System.ArgumentOutOfRangeException">值 <paramref name="timeout"/> 为负数，但它不等于-1 毫秒为单位），这是唯一允许的值为负。- 或 -值 <paramref name="timeout"/> 大于 <see cref="F:System.Int32.MaxValue"/> 毫秒为单位）。</exception><exception cref="T:System.ObjectDisposedException"><see cref="T:System.Threading.ReaderWriterLockSlim"/> 对象已被释放。</exception>
    [__DynamicallyInvokable]
    public bool TryEnterWriteLock(TimeSpan timeout);
    /// <summary>
    /// 尝试进入写入模式锁定状态，可以选择超时时间。
    /// </summary>
    /// 
    /// <returns>
    /// 如果调用线程已进入写入模式，则为 true；否则为 false。
    /// </returns>
    /// <param name="millisecondsTimeout">等待的毫秒数，或为 -1 (<see cref="F:System.Threading.Timeout.Infinite"/>)，表示无限期等待。</param><exception cref="T:System.Threading.LockRecursionException"><see cref="P:System.Threading.ReaderWriterLockSlim.RecursionPolicy"/> 属性是 <see cref="F:System.Threading.LockRecursionPolicy.NoRecursion"/> 和当前的线程已进入该锁。- 或 -当前线程最初在读取模式中，输入该锁，因此尝试进入写入模式会创建导致死锁的可能性。- 或 -递归数将超出该计数器的容量。限制为应用程序应永远不会遇到它太大。</exception><exception cref="T:System.ArgumentOutOfRangeException">值 <paramref name="millisecondsTimeout"/> 为负数，但它不是等于 <see cref="F:System.Threading.Timeout.Infinite"/> (-1)，这是唯一允许的值为负。</exception><exception cref="T:System.ObjectDisposedException"><see cref="T:System.Threading.ReaderWriterLockSlim"/> 对象已被释放。</exception>
    [__DynamicallyInvokable]
    public bool TryEnterWriteLock(int millisecondsTimeout);
    /// <summary>
    /// 尝试进入可升级模式锁定状态。
    /// </summary>
    /// <exception cref="T:System.Threading.LockRecursionException"><see cref="P:System.Threading.ReaderWriterLockSlim.RecursionPolicy"/> 属性是 <see cref="F:System.Threading.LockRecursionPolicy.NoRecursion"/> 和当前的线程已在任何模式下进入该锁。- 或 -当前线程已进入读取的模式，因此尝试进入可升级模式将有死锁的可能性。- 或 -递归数将超出该计数器的容量。限制为应用程序应永远不会遇到它太大。</exception><exception cref="T:System.ObjectDisposedException"><see cref="T:System.Threading.ReaderWriterLockSlim"/> 对象已被释放。</exception>
    [__DynamicallyInvokable]
    public void EnterUpgradeableReadLock();
    /// <summary>
    /// 尝试进入可升级模式锁定状态，可以选择超时时间。
    /// </summary>
    /// 
    /// <returns>
    /// 如果调用线程已进入可升级模式，则为 true；否则为 false。
    /// </returns>
    /// <param name="timeout">等待的间隔；或为 -1 毫秒，表示无限期等待。</param><exception cref="T:System.Threading.LockRecursionException"><see cref="P:System.Threading.ReaderWriterLockSlim.RecursionPolicy"/> 属性是 <see cref="F:System.Threading.LockRecursionPolicy.NoRecursion"/> 和当前的线程已进入该锁。- 或 -当前线程最初在读取模式中，输入该锁，因此尝试进入可升级模式会创建导致死锁的可能性。- 或 -递归数将超出该计数器的容量。限制为应用程序应永远不会遇到它太大。</exception><exception cref="T:System.ArgumentOutOfRangeException">值 <paramref name="timeout"/> 为负数，但它不等于-1 毫秒为单位），这是唯一允许的值为负。- 或 -值 <paramref name="timeout"/> 大于 <see cref="F:System.Int32.MaxValue"/> 毫秒为单位）。</exception><exception cref="T:System.ObjectDisposedException"><see cref="T:System.Threading.ReaderWriterLockSlim"/> 对象已被释放。</exception>
    [__DynamicallyInvokable]
    public bool TryEnterUpgradeableReadLock(TimeSpan timeout);
    /// <summary>
    /// 尝试进入可升级模式锁定状态，可以选择超时时间。
    /// </summary>
    /// 
    /// <returns>
    /// 如果调用线程已进入可升级模式，则为 true；否则为 false。
    /// </returns>
    /// <param name="millisecondsTimeout">等待的毫秒数，或为 -1 (<see cref="F:System.Threading.Timeout.Infinite"/>)，表示无限期等待。</param><exception cref="T:System.Threading.LockRecursionException"><see cref="P:System.Threading.ReaderWriterLockSlim.RecursionPolicy"/> 属性是 <see cref="F:System.Threading.LockRecursionPolicy.NoRecursion"/> 和当前的线程已进入该锁。- 或 -当前线程最初在读取模式中，输入该锁，因此尝试进入可升级模式会创建导致死锁的可能性。- 或 -递归数将超出该计数器的容量。限制为应用程序应永远不会遇到它太大。</exception><exception cref="T:System.ArgumentOutOfRangeException">值 <paramref name="millisecondsTimeout"/> 为负数，但它不是等于 <see cref="F:System.Threading.Timeout.Infinite"/> (-1)，这是唯一允许的值为负。</exception><exception cref="T:System.ObjectDisposedException"><see cref="T:System.Threading.ReaderWriterLockSlim"/> 对象已被释放。</exception>
    [__DynamicallyInvokable]
    public bool TryEnterUpgradeableReadLock(int millisecondsTimeout);
    /// <summary>
    /// 减少读取模式的递归计数，并在生成的计数为 0（零）时退出读取模式。
    /// </summary>
    /// <exception cref="T:System.Threading.SynchronizationLockException">在读取模式中，当前线程不已进入该锁。</exception>
    [__DynamicallyInvokable]
    public void ExitReadLock();
    /// <summary>
    /// 减少写入模式的递归计数，并在生成的计数为 0（零）时退出写入模式。
    /// </summary>
    /// <exception cref="T:System.Threading.SynchronizationLockException">当前线程不已进入写入模式的锁定。</exception>
    [__DynamicallyInvokable]
    public void ExitWriteLock();
    /// <summary>
    /// 减少可升级模式的递归计数，并在生成的计数为 0（零）时退出可升级模式。
    /// </summary>
    /// <exception cref="T:System.Threading.SynchronizationLockException">当前线程不已进入可升级模式的锁定。</exception>
    [__DynamicallyInvokable]
    public void ExitUpgradeableReadLock();
    /// <summary>
    /// 释放 <see cref="T:System.Threading.ReaderWriterLockSlim"/> 类的当前实例所使用的所有资源。
    /// </summary>
    /// <exception cref="T:System.Threading.SynchronizationLockException"><see cref="P:System.Threading.ReaderWriterLockSlim.WaitingReadCount"/> 是大于零。- 或 -<see cref="P:System.Threading.ReaderWriterLockSlim.WaitingUpgradeCount"/> 是大于零。- 或 -<see cref="P:System.Threading.ReaderWriterLockSlim.WaitingWriteCount"/> 是大于零。</exception><filterpriority>2</filterpriority>
    [__DynamicallyInvokable]
    public void Dispose();
    /// <summary>
    /// 获取一个值，该值指示当前线程是否已进入读取模式的锁定状态。
    /// </summary>
    /// 
    /// <returns>
    /// 如果当前线程已进入读取模式，则为 true；否则为 false。
    /// </returns>
    /// <filterpriority>2</filterpriority>
    [__DynamicallyInvokable]
    public bool IsReadLockHeld { [__DynamicallyInvokable] get; }
    /// <summary>
    /// 获取一个值，该值指示当前线程是否已进入可升级模式的锁定状态。
    /// </summary>
    /// 
    /// <returns>
    /// 如果当前线程已进入可升级模式，则为 true；否则为 false。
    /// </returns>
    /// <filterpriority>2</filterpriority>
    [__DynamicallyInvokable]
    public bool IsUpgradeableReadLockHeld { [__DynamicallyInvokable] get; }
    /// <summary>
    /// 获取一个值，该值指示当前线程是否已进入写入模式的锁定状态。
    /// </summary>
    /// 
    /// <returns>
    /// 如果当前线程已进入写入模式，则为 true；否则为 false。
    /// </returns>
    /// <filterpriority>2</filterpriority>
    [__DynamicallyInvokable]
    public bool IsWriteLockHeld { [__DynamicallyInvokable] get; }
    /// <summary>
    /// 获取一个值，该值指示当前 <see cref="T:System.Threading.ReaderWriterLockSlim"/> 对象的递归策略。
    /// </summary>
    /// 
    /// <returns>
    /// 枚举值之一，用于指定锁定递归策略。
    /// </returns>
    [__DynamicallyInvokable]
    public LockRecursionPolicy RecursionPolicy { [__DynamicallyInvokable] get; }
    /// <summary>
    /// 获取已进入读取模式锁定状态的独有线程的总数。
    /// </summary>
    /// 
    /// <returns>
    /// 已进入读取模式锁定状态的独有线程的数量。
    /// </returns>
    [__DynamicallyInvokable]
    public int CurrentReadCount { [__DynamicallyInvokable] get; }
    /// <summary>
    /// 获取当前线程进入读取模式锁定状态的次数，用于指示递归。
    /// </summary>
    /// 
    /// <returns>
    /// 如果当前线程未进入读取模式，则为 0（零）；如果线程已进入读取模式但却不是以递归方式进入的，则为 1；或者如果线程已经以递归方式进入锁定模式 n - 1 次，则为 n。
    /// </returns>
    /// <filterpriority>2</filterpriority>
    [__DynamicallyInvokable]
    public int RecursiveReadCount { [__DynamicallyInvokable] get; }
    /// <summary>
    /// 获取当前线程进入可升级模式锁定状态的次数，用于指示递归。
    /// </summary>
    /// 
    /// <returns>
    /// 如果当前线程没有进入可升级模式，则为 0；如果线程已进入可升级模式却不是以递归方式进入的，则为 1；或者如果线程已经以递归方式进入可升级模式 n - 1 次，则为 n。
    /// </returns>
    /// <filterpriority>2</filterpriority>
    [__DynamicallyInvokable]
    public int RecursiveUpgradeCount { [__DynamicallyInvokable] get; }
    /// <summary>
    /// 获取当前线程进入写入模式锁定状态的次数，用于指示递归。
    /// </summary>
    /// 
    /// <returns>
    /// 如果当前线程没有进入写入模式，则为 0；如果线程已进入写入模式却不是以递归方式进入的，则为 1；或者如果线程已经以递归方式进入写入模式 n - 1 次，则为 n。
    /// </returns>
    /// <filterpriority>2</filterpriority>
    [__DynamicallyInvokable]
    public int RecursiveWriteCount { [__DynamicallyInvokable] get; }
    /// <summary>
    /// 获取等待进入读取模式锁定状态的线程总数。
    /// </summary>
    /// 
    /// <returns>
    /// 等待进入读取模式的线程总数。
    /// </returns>
    /// <filterpriority>2</filterpriority>
    [__DynamicallyInvokable]
    public int WaitingReadCount { [__DynamicallyInvokable] get; }
    /// <summary>
    /// 获取等待进入可升级模式锁定状态的线程总数。
    /// </summary>
    /// 
    /// <returns>
    /// 等待进入可升级模式的线程总数。
    /// </returns>
    /// <filterpriority>2</filterpriority>
    [__DynamicallyInvokable]
    public int WaitingUpgradeCount { [__DynamicallyInvokable] get; }
    /// <summary>
    /// 获取等待进入写入模式锁定状态的线程总数。
    /// </summary>
    /// 
    /// <returns>
    /// 等待进入写入模式的线程总数。
    /// </returns>
    /// <filterpriority>2</filterpriority>
    [__DynamicallyInvokable]
    public int WaitingWriteCount { [__DynamicallyInvokable] get; }
  }

以上是对Stack和线程的相关知识的浅述，现在介绍一下线程安全的Stack：

    /// <summary>
    /// 表示对象的后进先出线程安全集合(栈结构)
    /// </summary>
    /// <typeparam name="T"></typeparam>
    public class TStack<T> : IEnumerable<T>, ICollection
    {
        /// <summary>
        /// 内部堆栈
        /// </summary>
        private readonly Stack<T> _mStack;

        /// <summary>
        /// 锁访问堆栈(用于管理资源访问的锁定状态，可实现多线程读取或进行独占式写入访问。)
        /// </summary>
        private readonly ReaderWriterLockSlim _lockStack = new ReaderWriterLockSlim();

        /// <summary>
        /// 仅用于SyncRoot属性
        /// </summary>
        private readonly object _objSyncRoot = new object();

        // Variables
        /// <summary>
        /// 初始化一个新的实例 <see cref="TStack{T}"/> class.
        /// </summary>
        public TStack()
        {
            _mStack = new Stack<T>();
        }

        /// <summary>
        /// 初始化一个新的实例 <see cref="TStack{T}"/> class.
        /// </summary>
        /// <param name="col">
        /// 开始集合
        /// </param>
        public TStack(IEnumerable<T> col)
        {
            _mStack = new Stack<T>(col);
        }

        // Init
        /// <summary>
        /// 获取枚举器
        /// </summary>
        public IEnumerator<T> GetEnumerator()
        {
            Stack<T> localStack = null;

            // 初始化枚举器
            _lockStack.PerformUsingReadLock(() =>
            {
                // 创建一个m_tlist副本
                localStack = new Stack<T>(_mStack);
            });

            // 获取枚举器
            foreach (T item in localStack)
                yield return item;
        }

        /// <summary>
        /// 获取枚举器
        /// </summary>
        IEnumerator IEnumerable.GetEnumerator()
        {
            Stack<T> localStack = null;

            // 初始化枚举器
            _lockStack.PerformUsingReadLock(() =>
            {
                // 创建一个m_TList的副本
                localStack = new Stack<T>(_mStack);
            });

            // 获取枚举器
            foreach (T item in localStack)
                yield return item;
        }

        /// <summary>
        /// 复制到一个数组
        /// </summary>
        /// <param name="array"></param>
        /// <param name="index"></param>
        public void CopyTo(Array array, int index)
        {
            _lockStack.PerformUsingReadLock(() => _mStack.ToArray().CopyTo(array, index));
        }

        /// <summary>
        ///堆栈中的项目数
        /// </summary>
        public int Count
        {
            get
            {
                return _lockStack.PerformUsingReadLock(() => _mStack.Count);
            }
        }

        /// <summary>
        /// 总为真
        /// </summary>
        public bool IsSynchronized
        {
            get { return true; }
        }

        /// <summary>
        ///同步根
        /// </summary>
        public object SyncRoot
        {
            get { return _objSyncRoot; }
        }

        /// <summary>
        ///清除集合
        /// </summary>
        public void Clear()
        {
            _lockStack.PerformUsingWriteLock(() => _mStack.Clear());
        }

        // Clear
        /// <summary>
        ///如果项目在堆栈中，则为true
        /// </summary>
        /// <param name="item"></param>
        /// <returns></returns>
        public bool Contains(T item)
        {
            return _lockStack.PerformUsingReadLock(() => _mStack.Contains(item));
        }

        // 包含
        /// <summary>
        /// 返回堆栈中的顶部项，而不从堆栈中删除它
        /// </summary>
        /// <returns></returns>
        public T Peek()
        {
            return _lockStack.PerformUsingReadLock(() => _mStack.Peek());
        }

        // Peek
        /// <summary>
        ///删除并返回堆栈中的顶部项目
        /// </summary>
        /// <returns></returns>
        public T Pop()
        {
            return _lockStack.PerformUsingWriteLock(() => _mStack.Pop());
        }

        // Pop
        /// <summary>
        /// 将一个项目插入堆栈
        /// </summary>
        /// <param name="item"></param>
        public void Push(T item)
        {
            _lockStack.PerformUsingWriteLock(() => _mStack.Push(item));
        }

        // Push
        /// <summary>
        ///将堆栈转换为数组
        /// </summary>
        /// <returns></returns>
        public T[] ToArray()
        {
            return _lockStack.PerformUsingReadLock(() => _mStack.ToArray());
        }

        // ToArray
        /// <summary>
        /// 将容量设置为堆栈中实际的元素数量
        /// </summary>
        public void TrimExcess()
        {
            _lockStack.PerformUsingWriteLock(() => _mStack.TrimExcess());
        }
    }

以上的操作方法继承了IEnumerable<T>, ICollection两个接口。有兴趣的，可以对IEnumerable<T>, ICollection两个接口进行细致的了解。

时间： 2024-03-30 03:36:54

C#创建安全的栈(Stack)存储结构的相关文章

C#创建安全的字典(Dictionary)存储结构

在上面介绍过栈(Stack)的存储结构,接下来介绍另一种存储结构字典(Dictionary). 字典(Dictionary)里面的每一个元素都是一个键值对(由二个元素组成:键和值) 键必须是唯一的,而值不需要唯一的,键和值都可以是任何类型.字典(Dictionary)是常用于查找和排序的列表. 接下来看一下Dictionary的部分方法和类的底层实现代码: 1.Add:将指定的键和值添加到字典中. public void Add(TKey key, TValue value) {        

07.栈(一)栈的存储结构及操作

一.栈 1.栈(stack):是限定仅在表尾进行插入和删除操作的线性表.其中,允许插入和删除的一端被称为栈顶(top),另一端被称为栈底(bottom),不含任何数据元素的栈被称为空栈.栈又被称为后进先出(Last In First Out)的线性表,简称LIFO结构. 栈的插入操作为进栈,栈的删除操作为出栈. 2.栈的抽象数据类型 ADT 栈(stack) Data 同线性表.元素具有相同类型,相邻元素具有前驱和后继关系. Operation InitStack(*S):初始化操作,建立一个空

栈的存储结构和常见操作（c 语言实现）

俗话说得好,线性表(尤其是链表)是一切数据结构和算法的基础,很多复杂甚至是高级的数据结构和算法,细节处,除去数学和计算机程序基础的知识,大量的都在应用线性表. 一.栈 其实本质还是线性表:限定仅在表尾进行插入或删除操作. 俗称:后进先出 (LIFO=last in first out结构),也可说是先进后出(FILO). 同样的,栈也分为顺序和链式两大类.其实和线性表大同小异,只不过限制在表尾进行操作的线性表的特殊表现形式. 1.顺序栈:利用一组地址连续的存储单元依次存放自栈底到栈顶的数据元素,

C++ vector,list,dequeue,stack 存储结构浅析

vector适用:对象数量变化少,简单对象,随机访问元素频繁. list适用:对象数量变化大,对象复杂,插入和删除频繁. 最大的区别是,list是双向的,而vector是单向的. 因此在实际使用时,如何选择这三个容器中哪一个,应根据你的需要而定,一般应遵循下面的原则: 1.如果你需要高效的随即存取,而不在乎插入和删除的效率,使用vector:7 2.如果你需要大量的插入和删除,而不关心随即存取,则应使用list: 3.如果你需要随即存取,而且关心两端数据的插入和删除,则应使用deque. vec

二叉树的链式存储结构----二叉链表

头文件:head.h #include<string.h> #include<ctype.h> #include<malloc.h> /* malloc()等 */ #include<limits.h> /* INT_MAX等 */ #include<stdio.h> /* EOF(=^Z或F6),NULL */ #include<stdlib.h> /* atoi() */ #include<io.h> /* eof()

栈的顺序存储结构及及其实现

由于栈是线性结构的一种,所以,栈也可以通过顺序存储结构实现. 因为,线性表的顺序存储结构是通过数组实现的,所以,栈的顺序存储结构也通过数组实现.不可避免的,要设置栈的最大存储空间.因为,栈只允许在栈顶进行元素的插入与删除操作,所以需要一个指向栈顶的变量top.那么栈的存储结构: typedef int SElemType; typedef struct{     SElemType data[MAXSIZE];     int top; }SqStack; 接着,就是插入一个新的元素e,也就是进

Java栈之链式栈存储结构实现

一.链栈 采用单链表来保存栈中所有元素,这种链式结构的栈称为链栈. 二.栈的链式存储结构实现 1 package com.ietree.basic.datastructure.stack; 2 3 /** 4 * 链栈 5 * 6 * Created by ietree 7 * 2017/4/29 8 */ 9 public class LinkStack<T> { 10 11 // 定义一个内部类Node,Node实例代表链栈的节点 12 private class Node { 13 14

栈及栈的链式存储结构(栈链)

栈:线性结构,后进先出.栈(Stack)是一种特殊的线性表(顺序表,链表)只在表尾进行删除和插入操作. 注意:对于栈来说,表尾称为栈的栈顶(top),表头称为栈底(bottom). 栈也是线性结构的一种特例.与队列不同,他只有一个口,只能从这里读或者写数据,这个口称为栈顶(top).栈是一种先进后出的数据结构.先进来的元素会放入栈底,而后进来的元素被放在它的上面,最后进来的元素的上面的位置,称为栈顶. 栈所提供的操作比一般的线性表要少很多,只提供:初始化.销毁.判断是否为空.求栈的长度.清空栈.

栈的两种存储结构

内容:栈的两种存储结构 栈的特点: 在固定一端进行插入删除,在栈顶进行 链式存储结构(不带头结点): class StackNode { public: int data; StackNode *next; StackNode():next(NULL){} }; class StackLine { public: StackNode *top; int count; StackLine():top(NULL),count(0){} //无初始化函数因为无需头结点 void pop(StackLi