| public Unregister ( System waitObject ) : bool | ||
| waitObject | System | |
| return | bool | |
internal static async Task <bool> WaitOneAsync(
this WaitHandle handle, int millisecondsTimeout, CancellationToken cancellationToken = default)
{
var tcs = new TaskCompletionSource <bool>();
using var tokenRegistration =
cancellationToken.Register(state => ((TaskCompletionSource <bool>)state !).TrySetCanceled(), tcs);
RegisteredWaitHandle?registeredHandle = null;
try
{
registeredHandle = ThreadPool.RegisterWaitForSingleObject(
handle,
(state, timedOut) => ((TaskCompletionSource <bool>)state !).TrySetResult(!timedOut),
state: tcs,
millisecondsTimeout,
executeOnlyOnce: true);
return(await tcs.Task);
}
finally
{
registeredHandle?.Unregister(null);
}
}
internal static void CleanEventVars(ref RegisteredWaitHandle waitHandle,
ref SafeCollabEvent safeEvent,
ref AutoResetEvent firedEvent)
{
if (waitHandle != null){
waitHandle.Unregister(null);
waitHandle = null;
}
if ((safeEvent != null) && (!safeEvent.IsInvalid)){
safeEvent.Dispose();
}
if (firedEvent != null){
firedEvent.Close();
firedEvent = null;
}
}
internal void StartAsyncResolve()
{
//------------------------------------------
//Check for disposal
//------------------------------------------
if (m_Disposed) throw new ObjectDisposedException(this.GetType().FullName);
//------------------------------------------
//First wire up a callback
//------------------------------------------
m_RegisteredWaitHandle = ThreadPool.RegisterWaitForSingleObject(m_EndPointInfoAvailableEvent, //Event that triggers the callback
new WaitOrTimerCallback(EndPointInfoAvailableCallback), //callback to be called
null, //state to be passed
-1, //Timeout - aplicable only for timers not for events
false //call us everytime the event is set not just one time
);
//------------------------------------------
//Now call the native API to start the resolution
//process save the handle for later
//------------------------------------------
Int32 result = UnsafeP2PNativeMethods.PeerPnrpStartResolve(m_PeerName.ToString(),
m_Cloud.InternalName,
(UInt32)m_MaxRecords,
m_EndPointInfoAvailableEvent.SafeWaitHandle,
out m_SafePeerNameEndResolve);
if (result != 0)
{
if (!m_SafePeerNameEndResolve.IsInvalid && !m_SafePeerNameEndResolve.IsClosed)
{
m_SafePeerNameEndResolve.Dispose();
}
m_RegisteredWaitHandle.Unregister(null);
m_RegisteredWaitHandle = null;
PeerToPeerException ex = PeerToPeerException.CreateFromHr(SR.GetString(SR.Pnrp_CouldNotStartNameResolution), result);
Logging.P2PTraceSource.TraceEvent(TraceEventType.Error, m_TraceEventId,
"Exception occurred while starting async resolve");
throw ex;
}
//------------------------------------------
//Create an async operation with the given
//user state
//------------------------------------------
m_AsyncOp = AsyncOperationManager.CreateOperation(m_userState);
Logging.P2PTraceSource.TraceEvent(TraceEventType.Information, m_TraceEventId,
"Successfully started the async resolve. The native handle is {0}", m_SafePeerNameEndResolve.DangerousGetHandle());
}
private static void UnregisterTimeout(
WaitHandle waitHandle, RegisteredWaitHandle timeoutHandle)
{
timeoutHandle.Unregister(waitHandle);
}
