C# Action.ThrowIfNull方法代码示例

        public MessageInputHandler(WorldInstance worldInstance, MessageRendererState messageRendererState, TimeSpan totalTime, Action<IXnaGameTime> messageClosingDelegate)
        {
            worldInstance.ThrowIfNull("worldInstance");
            messageRendererState.ThrowIfNull("messageRendererState");
            messageClosingDelegate.ThrowIfNull("messageClosingDelegate");

            _worldInstance = worldInstance;
            _messageRendererState = messageRendererState;
            _messageClosingDelegate = messageClosingDelegate;
            _answerKeyboardStateHelper = new KeyboardStateHelper(
                KeyDown,
                null,
                null,
                TextAdventure.Xna.Constants.MessageRenderer.Input.AcceptKey,
                TextAdventure.Xna.Constants.MessageRenderer.Input.NextAnswerKey,
                TextAdventure.Xna.Constants.MessageRenderer.Input.PreviousAnswerKey);
            _scrollKeyboardStateHelper = new KeyboardStateHelper(
                _scrollKeyboardRepeatHelper,
                TextAdventure.Xna.Constants.MessageRenderer.Input.ScrollUpKey,
                TextAdventure.Xna.Constants.MessageRenderer.Input.ScrollDownKey,
                TextAdventure.Xna.Constants.MessageRenderer.Input.HomeKey,
                TextAdventure.Xna.Constants.MessageRenderer.Input.EndKey,
                TextAdventure.Xna.Constants.MessageRenderer.Input.PageUpKey,
                TextAdventure.Xna.Constants.MessageRenderer.Input.PageDownKey);
            _scrollKeyboardRepeatHelper.InitialInterval = TextAdventure.Xna.Constants.MessageRenderer.Input.ScrollKeyboardInterval;
            _scrollKeyboardRepeatHelper.RepeatingInterval = TextAdventure.Xna.Constants.MessageRenderer.Input.ScrollKeyboardInterval;
        }

        /// <summary>
        /// Invokes asynchronously the specified action for this control.
        /// </summary>
        /// <param name="control">The control.</param>
        /// <param name="action">The action.</param>
        public static void BeginInvoke(Control control, Action action)
        {
            control.ThrowIfNull("control");
            action.ThrowIfNull("action");
            if (!control.Created || control.IsDisposed || !control.IsHandleCreated) return;

            control.BeginInvoke(action);
        }

        public CssCommentaryInterpreter(Action<Int32, Int32> onOpen, Action<String, Int32, Int32> onClose)
        {
            onOpen.ThrowIfNull("onOpen");
            onClose.ThrowIfNull("onClose");

            this.onOpen = onOpen;
            this.onClose = onClose;
        }

        public ReactiveCommand(
			Action<object> execute,
			Func<object, bool> canExecute,
			params INotifyPropertyChanged[] canExecuteNotifiers)
        {
            _execute = execute.ThrowIfNull();
            _canExecute = canExecute.ThrowIfNull();
            _canExecuteNotifiers = canExecuteNotifiers;

            _canExecuteNotifiers.ForEach(x => x.SubscribeWeakly(this, (c, s, e) => c.NotifyCanExecuteChanged()));
        }

 public WeakAction(Action action)
 {
     action.ThrowIfNull("action");
     _method = action.GetMethodInfo();
     if (action.GetMethodInfo().IsStatic)
     {
         _staticAction = action;
     }
     if (action.Target != null)
     {
         _actionTargetReference = new WeakReference(action.Target);
     }
 }

        public MessageFadeOutAndScaleUpdater(MessageRendererState messageRendererState, TimeSpan totalTime, Action completeDelegate)
        {
            messageRendererState.ThrowIfNull("messageRendererState");
            completeDelegate.ThrowIfNull("completeDelegate");
            if (totalTime < TimeSpan.Zero)
            {
                throw new ArgumentOutOfRangeException("totalTime");
            }

            _messageRendererState = messageRendererState;
            _completeDelegate = completeDelegate;
            _timedLerpHelper = new TimedLerpHelper(totalTime, TextAdventure.Xna.Constants.MessageRenderer.FadeOutDuration, 1f, 0f);
        }

        public TimerHelper(TimeSpan startTotalTime, TimeSpan duration, Action completedDelegate)
        {
            completedDelegate.ThrowIfNull("completedDelegate");
            if (startTotalTime < TimeSpan.Zero)
            {
                throw new ArgumentOutOfRangeException("startTotalTime");
            }
            if (duration < TimeSpan.Zero)
            {
                throw new ArgumentOutOfRangeException("duration");
            }

            _duration = duration;
            _startTotalTime = startTotalTime;
            _completedDelegate = completedDelegate;
        }

        /// <summary>
        /// Invokes the specified action for this control.
        /// </summary>
        /// <param name="control">The control.</param>
        /// <param name="action">The action.</param>
        public static void Invoke(Control control, Action action)
        {
            control.ThrowIfNull("control");
            action.ThrowIfNull("action");
            if (!control.Created || control.IsDisposed || !control.IsHandleCreated) return;

            try
            {
                control.Invoke(action);
            }
            catch (ObjectDisposedException ex)
            {
                logger.LogError("Control {0} disposed while trying to process an Invoke on it".InvariantFormat(control.Name));
                logger.LogException(ex);
            }
            catch (InvalidOperationException ioe)
            {
                logger.LogError("Invalid operation exception triggered by {0} control while trying to invoke".InvariantFormat(control.Name));
                logger.LogException(ioe);
            }
        }

 private void Transaction(Action<IDbConnection, IDbTransaction> action)
 {
     action.ThrowIfNull("action");
     using(var conn = this.GetConnection()) {
         using(var tx = conn.BeginTransaction()) {
             try {
                 action(conn, tx);
                 tx.Commit();
             } catch {
                 tx.Rollback();
                 throw;
             }
         }
     }
 }

 public RelayCommand(Action<object> execute, Predicate<object> canExecute)
 {
     this.execute = execute.ThrowIfNull();
     this.canExecute = canExecute;
 }

 public RelayCommand(Action<object> execute, Predicate<object> canExecute)
 {
     execute.ThrowIfNull("execute");
     _execute = execute; _canExecute = canExecute;
 }

 /// <summary>
 /// Creates a new DelegateAuthenticator.
 /// </summary>
 /// <param name="modifyRequest">Delegate used to modify the webrequest.</param>
 public DelegateAuthenticator(Action<HttpWebRequest> modifyRequest)
 {
     modifyRequest.ThrowIfNull("modifyRequest");
     ModifyRequestDelegate = modifyRequest;
 }

        /// <summary>
        /// Initializes a new instance of the <see cref="Disposable"/> class.
        /// </summary>
        /// <param name="action">The action.</param>
        public OnDisposeAction(Action action)
        {
            action.ThrowIfNull("action");

            Action = action;
        }

 public Command(Action<object> action, Predicate<object> canExecute)
 {
     this.action = action.ThrowIfNull("Command : action null");
     this.canExecute = canExecute.ThrowIfNull("Command : canExecute null");
 }

 public Command(Action<object> action, Predicate<object> canExecute = null)
 {
     this.action = action.ThrowIfNull("Command : action null");
     this.canExecute = canExecute;
     this.isEnabled = true;
 }