mscorlib(4.0.0.0) API with additions
Interlocked.cs
1 using System.Runtime.CompilerServices;
2 using System.Runtime.ConstrainedExecution;
3 using System.Runtime.InteropServices;
4 using System.Security;
5 
6 namespace System.Threading
7 {
9  [__DynamicallyInvokable]
10  public static class Interlocked
11  {
16  [ReliabilityContract(Consistency.WillNotCorruptState, Cer.Success)]
17  [__DynamicallyInvokable]
18  public static int Increment(ref int location)
19  {
20  return Add(ref location, 1);
21  }
22 
27  [ReliabilityContract(Consistency.WillNotCorruptState, Cer.Success)]
28  [__DynamicallyInvokable]
29  public static long Increment(ref long location)
30  {
31  return Add(ref location, 1L);
32  }
33 
38  [ReliabilityContract(Consistency.WillNotCorruptState, Cer.Success)]
39  [__DynamicallyInvokable]
40  public static int Decrement(ref int location)
41  {
42  return Add(ref location, -1);
43  }
44 
49  [__DynamicallyInvokable]
50  public static long Decrement(ref long location)
51  {
52  return Add(ref location, -1L);
53  }
54 
60  [MethodImpl(MethodImplOptions.InternalCall)]
61  [ReliabilityContract(Consistency.WillNotCorruptState, Cer.Success)]
62  [SecuritySafeCritical]
63  [__DynamicallyInvokable]
64  public static extern int Exchange(ref int location1, int value);
65 
71  [MethodImpl(MethodImplOptions.InternalCall)]
72  [SecuritySafeCritical]
73  [__DynamicallyInvokable]
74  public static extern long Exchange(ref long location1, long value);
75 
81  [MethodImpl(MethodImplOptions.InternalCall)]
82  [SecuritySafeCritical]
83  [__DynamicallyInvokable]
84  public static extern float Exchange(ref float location1, float value);
85 
91  [MethodImpl(MethodImplOptions.InternalCall)]
92  [SecuritySafeCritical]
93  [__DynamicallyInvokable]
94  public static extern double Exchange(ref double location1, double value);
95 
101  [MethodImpl(MethodImplOptions.InternalCall)]
102  [ReliabilityContract(Consistency.WillNotCorruptState, Cer.Success)]
103  [SecuritySafeCritical]
104  [__DynamicallyInvokable]
105  public static extern object Exchange(ref object location1, object value);
106 
112  [MethodImpl(MethodImplOptions.InternalCall)]
113  [ReliabilityContract(Consistency.WillNotCorruptState, Cer.Success)]
114  [SecuritySafeCritical]
115  public static extern IntPtr Exchange(ref IntPtr location1, IntPtr value);
116 
123  [ReliabilityContract(Consistency.WillNotCorruptState, Cer.Success)]
124  [ComVisible(false)]
125  [SecuritySafeCritical]
126  [__DynamicallyInvokable]
127  public static T Exchange<T>(ref T location1, T value) where T : class
128  {
129  _Exchange(__makeref(location1), __makeref(value));
130  return value;
131  }
132 
133  [MethodImpl(MethodImplOptions.InternalCall)]
134  [ReliabilityContract(Consistency.WillNotCorruptState, Cer.Success)]
135  [SecuritySafeCritical]
136  private static extern void _Exchange(TypedReference location1, TypedReference value);
137 
144  [MethodImpl(MethodImplOptions.InternalCall)]
145  [ReliabilityContract(Consistency.WillNotCorruptState, Cer.Success)]
146  [SecuritySafeCritical]
147  [__DynamicallyInvokable]
148  public static extern int CompareExchange(ref int location1, int value, int comparand);
149 
156  [MethodImpl(MethodImplOptions.InternalCall)]
157  [SecuritySafeCritical]
158  [__DynamicallyInvokable]
159  public static extern long CompareExchange(ref long location1, long value, long comparand);
160 
167  [MethodImpl(MethodImplOptions.InternalCall)]
168  [SecuritySafeCritical]
169  [__DynamicallyInvokable]
170  public static extern float CompareExchange(ref float location1, float value, float comparand);
171 
178  [MethodImpl(MethodImplOptions.InternalCall)]
179  [SecuritySafeCritical]
180  [__DynamicallyInvokable]
181  public static extern double CompareExchange(ref double location1, double value, double comparand);
182 
189  [MethodImpl(MethodImplOptions.InternalCall)]
190  [ReliabilityContract(Consistency.WillNotCorruptState, Cer.Success)]
191  [SecuritySafeCritical]
192  [__DynamicallyInvokable]
193  public static extern object CompareExchange(ref object location1, object value, object comparand);
194 
201  [MethodImpl(MethodImplOptions.InternalCall)]
202  [ReliabilityContract(Consistency.WillNotCorruptState, Cer.Success)]
203  [SecuritySafeCritical]
204  public static extern IntPtr CompareExchange(ref IntPtr location1, IntPtr value, IntPtr comparand);
205 
213  [ReliabilityContract(Consistency.WillNotCorruptState, Cer.Success)]
214  [ComVisible(false)]
215  [SecuritySafeCritical]
216  [__DynamicallyInvokable]
217  public static T CompareExchange<T>(ref T location1, T value, T comparand) where T : class
218  {
219  _CompareExchange(__makeref(location1), __makeref(value), comparand);
220  return value;
221  }
222 
223  [MethodImpl(MethodImplOptions.InternalCall)]
224  [ReliabilityContract(Consistency.WillNotCorruptState, Cer.Success)]
225  [SecuritySafeCritical]
226  private static extern void _CompareExchange(TypedReference location1, TypedReference value, object comparand);
227 
228  [MethodImpl(MethodImplOptions.InternalCall)]
229  [ReliabilityContract(Consistency.WillNotCorruptState, Cer.Success)]
230  [SecuritySafeCritical]
231  internal static extern int CompareExchange(ref int location1, int value, int comparand, ref bool succeeded);
232 
233  [MethodImpl(MethodImplOptions.InternalCall)]
234  [ReliabilityContract(Consistency.WillNotCorruptState, Cer.Success)]
235  internal static extern int ExchangeAdd(ref int location1, int value);
236 
237  [MethodImpl(MethodImplOptions.InternalCall)]
238  internal static extern long ExchangeAdd(ref long location1, long value);
239 
245  [ReliabilityContract(Consistency.WillNotCorruptState, Cer.Success)]
246  [__DynamicallyInvokable]
247  public static int Add(ref int location1, int value)
248  {
249  return ExchangeAdd(ref location1, value) + value;
250  }
251 
257  [ReliabilityContract(Consistency.WillNotCorruptState, Cer.Success)]
258  [__DynamicallyInvokable]
259  public static long Add(ref long location1, long value)
260  {
261  return ExchangeAdd(ref location1, value) + value;
262  }
263 
267  [__DynamicallyInvokable]
268  public static long Read(ref long location)
269  {
270  return CompareExchange(ref location, 0L, 0L);
271  }
272 
275  [__DynamicallyInvokable]
276  public static void MemoryBarrier()
277  {
278  Thread.MemoryBarrier();
279  }
280  }
281 }
System.Threading.Interlocked.Read
static long Read(ref long location)
Returns a 64-bit value, loaded as an atomic operation.
Definition: Interlocked.cs:268
System.Threading.Thread.MemoryBarrier
static void MemoryBarrier()
Synchronizes memory access as follows: The processor executing the current thread cannot reorder inst...
System.Threading.Interlocked.Decrement
static long Decrement(ref long location)
Decrements the specified variable and stores the result, as an atomic operation.
Definition: Interlocked.cs:50
System
Definition: __Canon.cs:3
System.Threading.Interlocked.MemoryBarrier
static void MemoryBarrier()
Synchronizes memory access as follows: The processor that executes the current thread cannot reorder ...
Definition: Interlocked.cs:276
System.Threading.Interlocked.CompareExchange< T >
static T CompareExchange< T >(ref T location1, T value, T comparand)
Compares two instances of the specified reference type T for equality and, if they are equal,...
Definition: Interlocked.cs:217
System.Threading.Interlocked.Exchange< T >
static T Exchange< T >(ref T location1, T value)
Sets a variable of the specified type T to a specified value and returns the original value,...
Definition: Interlocked.cs:127
System.Threading.Interlocked.Exchange
static int Exchange(ref int location1, int value)
Sets a 32-bit signed integer to a specified value and returns the original value, as an atomic operat...
System.Runtime.ConstrainedExecution.Cer
Cer
Specifies a method's behavior when called within a constrained execution region.
Definition: Cer.cs:5
System.Threading.Interlocked.Add
static long Add(ref long location1, long value)
Adds two 64-bit integers and replaces the first integer with the sum, as an atomic operation.
Definition: Interlocked.cs:259
System.TypedReference
Describes objects that contain both a managed pointer to a location and a runtime representation of t...
Definition: TypedReference.cs:13
System.Threading.Interlocked.CompareExchange
static int CompareExchange(ref int location1, int value, int comparand)
Compares two 32-bit signed integers for equality and, if they are equal, replaces the first value.
System.Threading.Interlocked.Increment
static int Increment(ref int location)
Increments a specified variable and stores the result, as an atomic operation.
Definition: Interlocked.cs:18
System.IntPtr
A platform-specific type that is used to represent a pointer or a handle.
Definition: IntPtr.cs:14
System.Runtime.CompilerServices.MethodImplOptions
MethodImplOptions
Defines the details of how a method is implemented.
Definition: MethodImplOptions.cs:10
System.Runtime.ConstrainedExecution.Consistency
Consistency
Specifies a reliability contract.
Definition: Consistency.cs:5
System.Threading.Interlocked.Decrement
static int Decrement(ref int location)
Decrements a specified variable and stores the result, as an atomic operation.
Definition: Interlocked.cs:40
System.Threading.Interlocked.Add
static int Add(ref int location1, int value)
Adds two 32-bit integers and replaces the first integer with the sum, as an atomic operation.
Definition: Interlocked.cs:247
System.Threading.Interlocked.Increment
static long Increment(ref long location)
Increments a specified variable and stores the result, as an atomic operation.
Definition: Interlocked.cs:29
System.Threading.Interlocked
Provides atomic operations for variables that are shared by multiple threads.
Definition: Interlocked.cs:10
System.Threading.Thread
Creates and controls a thread, sets its priority, and gets its status.
Definition: Thread.cs:18