个人中心
文章发布
退出
作者热门文章
- ubuntu12.04环境下使用kvm ioctl接口实现最简单的虚拟机
- Ubuntu 通过无线网络安装Ubuntu Server启动系统后连接无线网络的方法
- 在Ubuntu上搭建网桥的方法
- ubuntu 虚拟机上网方式及相关配置详解
29
4
CFSDN坚持开源创造价值，我们致力于搭建一个资源共享平台，让每一个IT人在这里找到属于你的精彩世界.
这篇CFSDN的博客文章C#创建安全的栈(Stack)存储结构由作者收集整理，如果你对这篇文章有兴趣，记得点赞哟.
在C#中，用于存储的结构较多，如：DataTable，DataSet，List，Dictionary，Stack等结构，各种结构采用的存储的方式存在差异，效率也必然各有优缺点。现在介绍一种后进先出的数据结构.
谈到存储结构，我们在项目中使用的较多。对于Task存储结构，栈与队列是类似的结构，在使用的时候采用不同的方法。C#中栈（Stack）是编译期间就分配好的内存空间，因此你的代码中必须就栈的大小有明确的定义；堆是程序运行期间动态分配的内存空间，你可以根据程序的运行情况确定要分配的堆内存的大小.
在C#中，栈通常保存着我们代码执行的步骤。C#中的引用类型存储在栈中，在程序运行的时候，每个线程(Thread)都会维护一个自己的专属线程堆栈。当一个方法被调用的时候，主线程开始在所属程序集的元数据中，查找被调用方法，然后通过JIT即时编译并把结果（一般是本地CPU指令）放在栈顶。CPU通过总线从栈顶取指令，驱动程序以执行下去.
以上对栈这个数据结构进行了一个简单的介绍，现在看一下C#实现栈结构的底层方法:
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
|
/// <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类:
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
|
/// <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:
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
|
/// <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两个接口进行细致的了解.
以上就是本文的全部内容，希望对大家的学习有所帮助，也希望大家多多支持我.
最后此篇关于C#创建安全的栈(Stack)存储结构的文章就讲到这里了,如果你想了解更多关于C#创建安全的栈(Stack)存储结构的内容请搜索CFSDN的文章或继续浏览相关文章，希望大家以后支持我的博客！ 。
29
4
0
我目前正在尝试基于哈希表构建字典。逻辑是:有一个名为 HashTable 的结构，其中包含以下内容: HashFunc HashFunc; PrintFunc PrintEntry; CompareF
如果我有一个指向结构/对象的指针，并且该结构/对象包含另外两个指向其他对象的指针，并且我想删除“包含这两个指针的对象而不破坏它所持有的指针”——我该怎么做这样做吗？ 指向对象 A 的指针(包含指向对象
像这样的代码 package main import "fmt" type Hello struct { ID int Raw string } type World []*Hell
我有一个采用以下格式的 CSV: Module, Topic, Sub-topic 它需要能够导入到具有以下格式的 MySQL 数据库中: CREATE TABLE `modules` ( `id
通常我使用类似的东西 copy((uint8_t*)&POD, (uint8_t*)(&POD + 1 ), back_inserter(rawData)); copy((uint8_t*)&PODV
错误 : 联合只能在具有兼容列类型的表上执行。 结构(层:字符串，skyward_number:字符串，skyward_points:字符串)<> 结构(skyward_number:字符串，层:字符
我有一个指向结构的指针数组，我正在尝试使用它们进行 while 循环。我对如何准确初始化它并不完全有信心，但我一直这样做: Entry *newEntry = malloc(sizeof(Entry)
我正在学习 C，我的问题可能很愚蠢，但我很困惑。在这样的函数中: int afunction(somevariables) { if (someconditions)
我现在正在做一项编程作业，我并没有真正完全掌握链接，因为我们还没有涉及它。但是我觉得我需要它来做我想做的事情，因为数组还不够 我创建了一个结构，如下 struct node { float coef;
给定以下代码片段: #include #include #define MAX_SIZE 15 typedef struct{ int touchdowns; int intercepti
struct contact list[3]; int checknullarray() { for(int x=0;x<10;x++) { if(strlen(con
这个问题在这里已经有了答案: 关闭 11 年前。 Possible Duplicate: Empty “for” loop in Facebook ajax what does AJAX call
我刚刚在反射器中浏览了一个文件，并在结构构造函数中看到了这个: this = new Binder.SyntaxNodeOrToken(); 我以前从未见过该术语。有人能解释一下这个赋值在 C# 中的
我经常使用字符串常量，例如: DICT_KEY1 = 'DICT_KEY1' DICT_KEY2 = 'DICT_KEY2' ... 很多时候我不介意实际的文字是什么，只要它们是独一无二的并且对人类读
我是 C 的新手，我不明白为什么下面的代码不起作用: typedef struct{ uint8_t a; uint8_t* b; } test_struct; test_struct
您能否制作一个行为类似于内置类之一的结构，您可以在其中直接分配值而无需调用属性？ 前任: RoundedDouble count; count = 5; 而不是使用 RoundedDouble cou
这是我的代码: #include typedef struct { const char *description; float value; int age; } swag
在创建嵌套列表时，我认为 R 具有对列表元素有用的命名结构。我有一个列表列表，并希望应用包含在任何列表中的每个向量的函数。 lapply这样做但随后剥离了列表的命名结构。我该怎么办 lapply嵌套列
我正在做一个用于学习目的的个人组织者，我从来没有使用过 XML，所以我不确定我的解决方案是否是最好的。这是我附带的 XML 文件的基本结构:
我是新来的 nosql概念，所以当我开始学习时 PouchDB ，我找到了这个转换表。我的困惑是，如何PouchDB如果可以说我有多个表，是否意味着我需要创建多个数据库？因为根据我在 pouchdb
我是一名优秀的程序员,十分优秀！