C# Action.Invoke方法代码示例

 private void When(Action when)
 {
     using (_mocks.Playback())
     {
         when.Invoke();
     }
 }

 private void Given(Action given)
 {
     using (_mocks.Record())
     {
         given.Invoke();
     }
 }

 public static void WriteElementBlock(this XmlWriter xmlWriter, string localName, string ns, Action<XmlWriter> action)
 {
     xmlWriter.WriteStartElement(localName, ns);
     action.Invoke(xmlWriter);
     xmlWriter.WriteEndElement();
     xmlWriter.Flush();
 }

        /// <summary>
        /// Performs configuration for <see cref="GlobalConfiguration.Configuration"/> and ensures that it is
        /// initialized.
        /// </summary>
        /// <param name="configurationCallback">The callback that will perform the configuration.</param>
        public static void Configure(Action<HttpConfiguration> configurationCallback)
        {
            if (configurationCallback == null)
            {
                throw new ArgumentNullException("configurationCallback");
            }

            configurationCallback.Invoke(Configuration);
            Configuration.EnsureInitialized();
        }

 private void Then(Action then)
 {
     _mocks.ReplayAll();
     then.Invoke();
 }

        private static void TestExceptionFilter(ApiController controller, Exception expectedException,
            Action<HttpConfiguration> configure)
        {
            // Arrange
            Exception actualException = null;
            IHttpRouteData routeData = new HttpRouteData(new HttpRoute());

            using (HttpRequestMessage request = new HttpRequestMessage())
            using (HttpConfiguration configuration = new HttpConfiguration())
            using (HttpResponseMessage response = new HttpResponseMessage())
            {
                HttpControllerContext context = new HttpControllerContext(configuration, routeData, request);
                HttpControllerDescriptor controllerDescriptor = new HttpControllerDescriptor(configuration,
                    "Ignored", controller.GetType());
                context.Controller = controller;
                context.ControllerDescriptor = controllerDescriptor;

                if (configure != null)
                {
                    configure.Invoke(configuration);
                }

                Mock<IExceptionFilter> spy = new Mock<IExceptionFilter>();
                spy.Setup(f => f.ExecuteExceptionFilterAsync(It.IsAny<HttpActionExecutedContext>(),
                    It.IsAny<CancellationToken>())).Returns<HttpActionExecutedContext, CancellationToken>(
                    (c, i) =>
                    {
                        actualException = c.Exception;
                        c.Response = response;
                        return Task.FromResult<object>(null);
                    });

                configuration.Filters.Add(spy.Object);

                // Act
                HttpResponseMessage ignore = controller.ExecuteAsync(context, CancellationToken.None).Result;
            }

            // Assert
            Assert.Same(expectedException, actualException);
        }

 private static IAuthenticationFilter CreateAuthenticationFilterChallenge(
     Action<HttpAuthenticationChallengeContext, CancellationToken> challenge)
 {
     Mock<IAuthenticationFilter> mock = new Mock<IAuthenticationFilter>();
     mock.Setup(f => f.AuthenticateAsync(It.IsAny<HttpAuthenticationContext>(), It.IsAny<CancellationToken>()))
         .Returns(() => Task.FromResult<object>(null));
     mock.Setup(f => f.ChallengeAsync(It.IsAny<HttpAuthenticationChallengeContext>(),
         It.IsAny<CancellationToken>()))
         .Callback<HttpAuthenticationChallengeContext, CancellationToken>((c, t) =>
         {
             challenge.Invoke(c, t);
         })
         .Returns(() => Task.FromResult<object>(null));
     return mock.Object;
 }

 private static IHostPrincipalService CreatePrincipalService(
     Action<IPrincipal, HttpRequestMessage> setCurrentPrincipal)
 {
     Mock<IHostPrincipalService> mock = new Mock<IHostPrincipalService>();
     mock.Setup(s => s.GetCurrentPrincipal(It.IsAny<HttpRequestMessage>())).Returns(CreateDummyPrincipal());
     mock.Setup(s => s.SetCurrentPrincipal(It.IsAny<IPrincipal>(), It.IsAny<HttpRequestMessage>()))
         .Callback<IPrincipal, HttpRequestMessage>((p, r) => { setCurrentPrincipal.Invoke(p, r); });
     return mock.Object;
 }

 IEnumerator DelayAction(Action act, float delay)
 {
     yield return new WaitForSeconds(delay);
     act.Invoke();
 }

        public static void HandleException(bool exceptionDefaultOrBeforeAwait, bool exceptionAfterAwait, Action action)
        {
            bool hasException = false;

            SetExceptionInjection(exceptionDefaultOrBeforeAwait, exceptionAfterAwait);
            try
            {
                action.Invoke();
            }
            catch (Exception ex)
            {
                hasException = true;
                Debug.WriteLine("Exception: {0}", ex.Message);
            }

            AssertTransactionNull();
            Assert.Equal<bool>(hasException, true);
            ResetExceptionInjection();
        }

        private async void HandleSendAsyncCompletion(Task task, TimeSpan timeout, Action<object> callback, object state)
        {
            try
            {
                await task;
            }
            catch (Exception)
            {
                _pendingWritingMessageException = WebSocketHelper.CreateExceptionOnTaskFailure(task, timeout,
                    WebSocketHelper.SendOperation);
            }
            finally
            {
                if (WcfEventSource.Instance.WebSocketAsyncWriteStopIsEnabled())
                {
                    WcfEventSource.Instance.WebSocketAsyncWriteStop(WebSocket.GetHashCode());
                }

                callback.Invoke(state);
            }
        }

 private async void HandleCloseOutputAsyncCompletion(Task task, TimeSpan timeout, Action<object> callback, object state)
 {
     try
     {
         await task;
     }
     catch (Exception)
     {
         _pendingWritingMessageException = WebSocketHelper.CreateExceptionOnTaskFailure(task, timeout, WebSocketHelper.CloseOperation);
     }
     finally
     {
         callback.Invoke(state);
     }
 }

            public async void WriteEndOfMessageAsync(Action<object> callback, object state)
            {
                if (WcfEventSource.Instance.WebSocketAsyncWriteStartIsEnabled())
                {
                    // TODO: Open bug about not emitting the hostname/port
                    WcfEventSource.Instance.WebSocketAsyncWriteStart(
                        _webSocket.GetHashCode(),
                        0,
                        string.Empty);
                }

                var timeoutHelper = new TimeoutHelper(_closeTimeout);
                var cancelTokenTask = timeoutHelper.GetCancellationTokenAsync();
                try
                {
                    var cancelToken = await cancelTokenTask;
                    await _webSocket.SendAsync(new ArraySegment<byte>(Array.Empty<byte>(), 0, 0), _outgoingMessageType, true, cancelToken);

                    if (WcfEventSource.Instance.WebSocketAsyncWriteStopIsEnabled())
                    {
                        WcfEventSource.Instance.WebSocketAsyncWriteStop(_webSocket.GetHashCode());
                    }
                }
                catch (Exception ex)
                {
                    if (Fx.IsFatal(ex))
                    {
                        throw;
                    }

                    if (cancelTokenTask.Result.IsCancellationRequested)
                    {
                        throw Fx.Exception.AsError(
                            new TimeoutException(InternalSR.TaskTimedOutError(timeoutHelper.OriginalTimeout)));
                    }

                    throw WebSocketHelper.ConvertAndTraceException(ex, timeoutHelper.OriginalTimeout,
                        WebSocketHelper.SendOperation);
                }
                finally
                {
                    callback.Invoke(state);
                }
            }

        private void OnDesignPanelFirstTimeActivated(Action<XRDesignPanel> handler)
        {
            DesignMdiController.DesignPanelLoaded += (sender1, designLoadedArgs) =>
            {
                var designPanel = (XRDesignPanel)sender1;

                EventHandler activated = null;
                activated = (sender2, emptyArgs) =>
                {
                    // remove handler after the first time it is activated
                    designLoadedArgs.DesignerHost.Activated -= activated;
                    handler.Invoke(designPanel);
                };

                designLoadedArgs.DesignerHost.Activated += activated;
            };
        }

 /// <summary>
 /// Invoke in UI thread.
 /// </summary>
 public void BeginInvoke(Action a)
 {
     a.Invoke();
 }