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两个接口进行细致的了解。

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

(0)

相关推荐

  • C#使用foreach语句遍历堆栈(Stack)的方法

    本文实例讲述了C#使用foreach语句遍历堆栈(Stack)的方法.分享给大家供大家参考.具体如下: using System; using System.Collections; public class StacksW3 { static void Main(string[] args) { Stack a = new Stack(10); int x = 0; a.Push(x); x++; a.Push(x); foreach (int y in a) { Console.WriteL

  • C#数据结构之堆栈(Stack)实例详解

    本文实例讲述了C#数据结构之堆栈(Stack).分享给大家供大家参考,具体如下: 堆栈(Stack)最明显的特征就是"先进后出",本质上讲堆栈也是一种线性结构,符合线性结构的基本特点:即每个节点有且只有一个前驱节点和一个后续节点. 相对前面学习过的顺序表.链表不同的地方在于:Stack把所有操作限制在"只能在线性结构的某一端"进行,而不能在中间插入或删除元素.下面是示意图: 从示意图中可以看出,堆栈有二种实现方式:基于数组的顺序堆栈实现.类似链表的链式堆栈实现 先抽

  • 解析c#在未出现异常情况下查看当前调用堆栈的解决方法

    C#查看堆栈通常是在异常处理中,出现异常之后通过异常的堆栈可以很方便的得到出现这个错误的代码调用路径.这个很有用,是否可以在没有异常出现时使用这种方法排查一些非异常错误呢?答案是肯定的.起因:论坛发帖子有几个途径,有可能是新闻系统直接导入的帖子,也有可能是抓取的帖子,还有可能是用户通过正常途径发表.但是这两天出了一个问题,有些帖子的HasImage属性不对.通过几种方法做调试都不能重现问题,没有办法,只有在程序中添加回复的地方添加日志程序来记录堆栈,从而追踪到是哪个途径发帖出现了问题.代码: 复

  • C#数据结构与算法揭秘五 栈和队列

    这节我们讨论了两种好玩的数据结构,栈和队列. 老样子,什么是栈, 所谓的栈是栈(Stack)是操作限定在表的尾端进行的线性表.表尾由于要进行插入.删除等操作,所以,它具有特殊的含义,把表尾称为栈顶(Top) ,另一端是固定的,叫栈底(Bottom) .当栈中没有数据元素时叫空栈(Empty Stack).这个类似于送饭的饭盒子,上层放的是红烧肉,中层放的水煮鱼,下层放的鸡腿.你要把这些菜取出来,这就引出来了栈的特点先进后出(First in last out).   具体叙述,加下图. 栈通常记

  • 浅谈C#中堆和栈的区别(附上图解)

    线程堆栈:简称栈 Stack 托管堆: 简称堆 Heap 使用.Net框架开发程序的时候,我们无需关心内存分配问题,因为有GC这个大管家给我们料理一切.如果我们写出如下两段代码: 代码段1: public int AddFive(int pValue) { int result; result = pValue + 5; return result; } 代码段2: public class MyInt { public int MyValue; } public MyInt AddFive(i

  • c#二进制逆序方法详解

    原题 一个整数,可以表示为二进制的形式,请给出尽可能多的方法对二进制进行逆序操作. 例如:10000110 11011000的逆序为 00011011 01100001 分析 题目中说是一个整数,对它的二进制进行逆序.并不是一个01字符串,或者01的数组.那么我们该如何解决这个问题呢?方法还是比较多的,有的中规中矩.有的非常巧妙.我们要掌握中规中规的方法,见识更多的巧妙的方法.慢慢的,能够举一反三,在遇到新的问题时,能够有灵思妙想. 最直接的方法 直接的方法,很容易想到:有如下代码: 复制代码

  • c#栈变化规则图解示例(栈的生长与消亡)

    栈的变化规则:1.方法调用会导致栈的生长,具体包括两个步骤:一.插入方法返回地址(下图中的Fn:):二.将实际参数按值(可以使用ref或out修饰)拷贝并插入到栈中(可以使用虚参数访问).2.遇到局部变量定义会向栈中插入局部变量.3.遇到return语句会导致栈消亡,一直消亡到方法返回地址,并把return的返回值设置到方法返回地址中.4.这里先不考虑中括号导致的栈的消亡. 复制代码 代码如下: using System;using System.Collections.Generic;usin

  • C#递归实现将一整数逆序后放入一数组中

    本文实例讲述了C#递归实现将一整数逆序后放入一数组中的方法,分享给大家供大家参考.具体实现方法如下: 复制代码 代码如下: static void Main(string[] args) {     int m = 1236578;     int[] ms = new int[m.ToString().Length];     Rev(m.ToString().Length, m, ref ms);     for (int i = 0; i < m.ToString().Length; i+

  • C#实现用栈求逆序的方法示例

    本文实例讲述了C#实现用栈求逆序的方法.分享给大家供大家参考,具体如下: 用栈求逆序 using System; using System.Collections.Generic; using System.Linq; using System.Text; using System.Collections; namespace CSharp { class Program { static void Main(string[] args) { Stack stk = new Stack();//

  • C#使用Object类实现栈的方法详解

    本文实例讲述了C#使用Object类实现栈的方法.分享给大家供大家参考,具体如下: Stack类的代码: using System; using System.Collections.Generic; using System.Linq; using System.Text; namespace 使用Object类实现后进先出队列 { class Stack { private Object[] _items; public Object[] Items { get { return this.

  • C#栈和堆的区别浅谈

    理解堆与栈对于理解.NET中的内存管理.垃圾回收.错误和异常.调试与日志有很大的帮助.垃圾回收的机制使程序员从复杂的内存管理中解脱出来,虽然绝大多数的C#程序并不需要程序员手动管理内存,但这并不代表程序员就无需了解分配的对象是如何被回收的,在一些特殊的场合仍需要程序员手动进行内存管理. 在32位的处理器上,每个进程的虚拟内存为4GB,.NET会在这4GB的内存块中开辟出3块内存,分别作为栈.托管堆.和非托管堆 堆(heap): 堆是从下往上分配,所以已用的空间在自由空间下面,C#中所有引用类型的

  • 一看就懂:图解C#中的值类型、引用类型、栈、堆、ref、out

    C# 的类型系统可分为两种类型,一是值类型,一是引用类型,这个每个C#程序员都了解.还有托管堆,栈,ref,out等等概念也是每个C#程序员都会接触到的概念,也是C#程序员面试经常考到的知识,随便搜搜也有无数的文章讲解相关的概念,貌似没写一篇值类型,引用类型相关博客的不是好的C#程序员.我也凑个热闹,试图彻底讲明白相关的概念. 程序执行的原理 要彻底搞明白那一堆概念及其它们之间的关系似乎并不是一件容易的事,这是因为大部分C#程序员并不了解托管堆(简称"堆")和线程栈(简称"栈

随机推荐