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
|
// Licensed to the .NET Foundation under one or more agreements.
// The .NET Foundation licenses this file to you under the MIT license.
// See the LICENSE file in the project root for more information.
//
/*=============================================================================
**
**
**
** Purpose: Base class for representing Events
**
**
=============================================================================*/
using System;
using System.Runtime.InteropServices;
using Microsoft.Win32.SafeHandles;
using System.IO;
using System.Diagnostics;
namespace System.Threading
{
public partial class EventWaitHandle : WaitHandle
{
public EventWaitHandle(bool initialState, EventResetMode mode)
{
VerifyMode(mode);
bool createdNew;
CreateEventCore(initialState, mode, null, out createdNew);
}
public EventWaitHandle(bool initialState, EventResetMode mode, string name)
{
VerifyNameForCreate(name);
VerifyMode(mode);
bool createdNew;
CreateEventCore(initialState, mode, name, out createdNew);
}
public EventWaitHandle(bool initialState, EventResetMode mode, string name, out bool createdNew)
{
VerifyNameForCreate(name);
VerifyMode(mode);
CreateEventCore(initialState, mode, name, out createdNew);
}
private static void VerifyMode(EventResetMode mode)
{
if (mode != EventResetMode.AutoReset && mode != EventResetMode.ManualReset)
{
throw new ArgumentException(SR.Argument_InvalidFlag, nameof(mode));
}
}
public static EventWaitHandle OpenExisting(string name)
{
EventWaitHandle result;
switch (OpenExistingWorker(name, out result))
{
case OpenExistingResult.NameNotFound:
throw new WaitHandleCannotBeOpenedException();
case OpenExistingResult.NameInvalid:
throw new WaitHandleCannotBeOpenedException(SR.Format(SR.Threading_WaitHandleCannotBeOpenedException_InvalidHandle, name));
case OpenExistingResult.PathNotFound:
throw new IOException(SR.Format(SR.IO_PathNotFound_Path, name));
default:
return result;
}
}
public static bool TryOpenExisting(string name, out EventWaitHandle result)
{
return OpenExistingWorker(name, out result) == OpenExistingResult.Success;
}
public bool Reset()
{
// The field value is modifiable via <see cref="SafeWaitHandle"/>, save it locally to ensure that ref modification
// is done on the same instance
SafeWaitHandle waitHandle = _waitHandle;
if (waitHandle == null)
{
ThrowInvalidHandleException();
}
waitHandle.DangerousAddRef();
try
{
return ResetCore(_waitHandle.DangerousGetHandle());
}
finally
{
waitHandle.DangerousRelease();
}
}
public bool Set()
{
// The field value is modifiable via the public <see cref="WaitHandle.SafeWaitHandle"/> property, save it locally
// to ensure that one instance is used in all places in this method
SafeWaitHandle waitHandle = _waitHandle;
if (waitHandle == null)
{
ThrowInvalidHandleException();
}
waitHandle.DangerousAddRef();
try
{
return SetCore(waitHandle.DangerousGetHandle());
}
finally
{
waitHandle.DangerousRelease();
}
}
internal static bool Set(IntPtr handle)
{
return SetCore(handle);
}
}
}
|
