示例#1
0
        public static int WaitAny(object[] waitHandles, TimeSpan timeout)
        {
            if (waitHandles == null)
            {
                throw new ArgumentNullException("waitHandles");
            }
            if (waitHandles.Length == 0)
            {
                throw new ArgumentException("Empty waitHandles should not be passed in.");
            }
            int num = -1;
            List <WaitHandle> list = new List <WaitHandle>(waitHandles.Length);

            ManualOneShotEvent.ManualOneShotInfo[] array = new ManualOneShotEvent.ManualOneShotInfo[waitHandles.Length];
            try
            {
                for (int i = 0; i < waitHandles.Length; i++)
                {
                    object obj = waitHandles[i];
                    if (obj == null)
                    {
                        throw new ArgumentNullException("An array element of waitHandles should not be null.");
                    }
                    array[i] = new ManualOneShotEvent.ManualOneShotInfo();
                    if (obj is ManualOneShotEvent)
                    {
                        ManualOneShotEvent.ManualOneShotInfo manualOneShotInfo = array[i];
                        ManualOneShotEvent manualOneShotEvent = obj as ManualOneShotEvent;
                        manualOneShotInfo.IsManualOneShotEvent = true;
                        manualOneShotInfo.ManualOneShotEvent   = manualOneShotEvent;
                        ManualOneShotEvent.IncrementResult incrementResult = manualOneShotEvent.IncrementRefCountIfNecessary();
                        if (incrementResult == ManualOneShotEvent.IncrementResult.NotIncrementedShuttingDown)
                        {
                            manualOneShotInfo.IsClosed = true;
                        }
                        else if (incrementResult == ManualOneShotEvent.IncrementResult.NotIncrementedAlreadySignaled)
                        {
                            manualOneShotInfo.IsPreSignaled = true;
                        }
                        else
                        {
                            manualOneShotInfo.IsWaitRegistered = true;
                            list.Add(manualOneShotEvent.m_firstEventCompleted);
                        }
                    }
                    else
                    {
                        if (!(obj is WaitHandle))
                        {
                            throw new ArgumentException("An object of type {0} was passed in to the array. It must be either of type ManualOneShotEvent or WaitHandle.", obj.GetType().ToString());
                        }
                        list.Add(obj as WaitHandle);
                    }
                }
                if (array.All((ManualOneShotEvent.ManualOneShotInfo info) => info.IsManualOneShotEvent && info.IsClosed))
                {
                    ManualOneShotEvent.Tracer.TraceError(0L, "ManualOneShotEvent.WaitAny(): Every event is a ManualOneShotEvent and is already closed! Returning WaitTimeout.");
                    return(258);
                }
                if (array.Any((ManualOneShotEvent.ManualOneShotInfo info) => info.IsManualOneShotEvent && info.IsPreSignaled))
                {
                    int num2 = -1;
                    for (int j = 0; j < array.Length; j++)
                    {
                        ManualOneShotEvent.ManualOneShotInfo manualOneShotInfo2 = array[j];
                        if (manualOneShotInfo2.IsManualOneShotEvent && manualOneShotInfo2.IsPreSignaled && num2 == -1)
                        {
                            num2 = j;
                        }
                        if (manualOneShotInfo2.IsManualOneShotEvent && manualOneShotInfo2.IsWaitRegistered)
                        {
                            manualOneShotInfo2.ManualOneShotEvent.DecrementRefCountAndCloseIfNecessary();
                            manualOneShotInfo2.IsWaitUnregistered = true;
                        }
                    }
                    return(num2);
                }
                num = WaitHandle.WaitAny(list.ToArray(), timeout);
            }
            finally
            {
                foreach (ManualOneShotEvent.ManualOneShotInfo manualOneShotInfo3 in array)
                {
                    if (manualOneShotInfo3 != null && manualOneShotInfo3.IsManualOneShotEvent && manualOneShotInfo3.IsWaitRegistered && !manualOneShotInfo3.IsWaitUnregistered)
                    {
                        manualOneShotInfo3.ManualOneShotEvent.DecrementRefCountAndCloseIfNecessary();
                        manualOneShotInfo3.IsWaitUnregistered = true;
                    }
                }
            }
            if (num == 258)
            {
                ManualOneShotEvent.Tracer.TraceError <TimeSpan>(0L, "ManualOneShotEvent.WaitAny(): Wait timed out after {0}!", timeout);
                return(num);
            }
            ManualOneShotEvent.Tracer.TraceDebug <int>(0L, "ManualOneShotEvent.WaitAny(): Event with *internal* index {0} was signaled.", num);
            int num3 = -1;
            int num4 = 0;

            for (int l = 0; l < array.Length; l++)
            {
                ManualOneShotEvent.ManualOneShotInfo manualOneShotInfo4 = array[l];
                if (!manualOneShotInfo4.IsManualOneShotEvent || !manualOneShotInfo4.IsClosed)
                {
                    num4++;
                }
                if (num == num4 - 1)
                {
                    num3 = l;
                    break;
                }
            }
            ManualOneShotEvent.Tracer.TraceDebug <int>(0L, "ManualOneShotEvent.WaitAny(): Event with index {0} was signaled. Returning {0}.", num3);
            return(num3);
        }
        private void InternalInvoke(Action invokableAction, Action foregroundAction, TimeSpan invokeTimeout, bool sendWatsonReportNoThrow, object cancelEvent)
        {
            ExTraceGlobals.ClusterTracer.TraceDebug((long)this.GetHashCode(), "InternalInvoke calling BeginInvoke");
            IAsyncResult result          = invokableAction.BeginInvoke(new AsyncCallback(this.CompletionCallback), invokableAction);
            DateTime     utcNow          = DateTime.UtcNow;
            WaitHandle   asyncWaitHandle = result.AsyncWaitHandle;
            bool         flag            = true;
            bool         flag2           = false;

            try
            {
                if (foregroundAction != null)
                {
                    foregroundAction();
                }
                flag2 = true;
                TimeSpan timeSpan = DateTime.UtcNow.Subtract(utcNow);
                TimeSpan timeout;
                if (invokeTimeout == InvokeWithTimeout.InfiniteTimeSpan)
                {
                    timeout = invokeTimeout;
                }
                else if (timeSpan < invokeTimeout)
                {
                    timeout = invokeTimeout.Subtract(timeSpan);
                }
                else
                {
                    timeout = TimeSpan.Zero;
                }
                int num = 1;
                if (cancelEvent != null)
                {
                    num = 2;
                }
                object[] array = new object[num];
                array[0] = asyncWaitHandle;
                if (cancelEvent != null)
                {
                    array[1] = cancelEvent;
                }
                int  num2  = ManualOneShotEvent.WaitAny(array, timeout);
                bool flag3 = false;
                bool flag4 = false;
                if (num2 == 258)
                {
                    flag3 = true;
                }
                else if (num2 == 1)
                {
                    flag4 = true;
                }
                if (flag3 || flag4)
                {
                    if (flag3 && sendWatsonReportNoThrow)
                    {
                        if (this.m_asyncRefCount == 1)
                        {
                            flag3 = false;
                        }
                    }
                    else if (Interlocked.Decrement(ref this.m_asyncRefCount) == 0)
                    {
                        flag3 = false;
                        flag4 = false;
                    }
                }
                if (flag3)
                {
                    TimeoutException ex = new TimeoutException(Strings.OperationTimedOut(invokeTimeout.ToString()));
                    if (!sendWatsonReportNoThrow)
                    {
                        flag = false;
                        throw ex;
                    }
                    this.SendWatsonReport <TimeoutException>(ex);
                    invokableAction.EndInvoke(result);
                }
                else
                {
                    if (flag4)
                    {
                        OperationAbortedException ex2 = new OperationAbortedException();
                        flag = false;
                        throw ex2;
                    }
                    invokableAction.EndInvoke(result);
                }
            }
            finally
            {
                if (!flag2)
                {
                    if (Interlocked.Decrement(ref this.m_asyncRefCount) > 0)
                    {
                        flag = false;
                    }
                    else
                    {
                        Exception ex3 = this.RunOperation(delegate
                        {
                            invokableAction.EndInvoke(result);
                        });
                        if (ex3 != null)
                        {
                            ExTraceGlobals.ClusterTracer.TraceError <Exception>((long)this.GetHashCode(), "EndInvoke() has thrown an exception after the foreground thread threw an exception. Exception: {0}", ex3);
                        }
                    }
                }
                if (flag && asyncWaitHandle != null)
                {
                    asyncWaitHandle.Close();
                }
            }
        }