readonly Type[] _argumentTypes;     //Представляет объявления типов для классов, интерфейсов, массивов, значений, перечислений параметров, определений универсальных типов и открытых или закрытых сконструированных универсальных типов.
                                                //Type является корнем функции System.Reflection и является основным способом доступа к метаданным. Члены Type используются для получения сведений об объявлении типа, о членах типа (таких как конструкторы, методы, поля, свойства и события класса), а также о модуле и сборке, в которой развернут класс.
            /// <summary>
            /// Create a configured trigger.
            /// Создает настроенный триггер.
            /// </summary>
            /// <param name="underlyingTrigger">Trigger represented by this trigger configuration. Триггер, представленный этой конфигурацией триггера.</param>
            /// <param name="argumentTypes">The argument types expected by the trigger. Типы аргументов, ожидаемые триггером.</param>
            public ATriggerWithParameters(TTriger underlyingTrigger, params Type[] argumentTypes) 
            {
                SEnforce.ArgumentNotNull(argumentTypes, "argumentTypes");

                _underlyingTrigger = underlyingTrigger;
                _argumentTypes = argumentTypes;
            }
 void ExecuteExitActions(Transition transition)
 {
     SEnforce.ArgumentNotNull(transition, "transtion");
     foreach (var action in _exitActions)
     {
         action(transition);
     }
 }
 void ExecuteEntryActions(Transition transition, object[] entryArgs)
 {
     SEnforce.ArgumentNotNull(transition, "transtion");
     SEnforce.ArgumentNotNull(entryArgs, "entryArgs");
     foreach (var action in _entryActions)
     {
         action(transition, entryArgs);
     }
 }
 public void AddEntryAction(TTrigger trigger, Action <Transition, object[]> action)
 {
     SEnforce.ArgumentNotNull(action, "action");
     _entryActions.Add((t, args) =>
     {
         if (t.Trigger.Equals(trigger))
         {
             action(t, args);
         }
     });
 }
 public void Exit(Transition transition)
 {
     SEnforce.ArgumentNotNull(transition, "transition");
     if (transition.IsReentry)
     {
         ExecuteExitActions(transition);
     }
     else if (!Includes(transition.Destination))
     {
         ExecuteExitActions(transition);
         if (_superstate != null)
         {
             _superstate.Exit(transition);
         }
     }
 }
            public void Enter(Transition transition, params object[] entryArgs)
            {
                SEnforce.ArgumentNotNull(transition, "transtion");
                if (transition.IsReentry)
                {
                    ExecuteEntryActions(transition, entryArgs);
                }
                else if (!Includes(transition.Source))
                {
                    if (_superstate != null)
                    {
                        _superstate.Enter(transition, entryArgs);
                    }

                    ExecuteEntryActions(transition, entryArgs);
                }
            }
        public static object Unpack(object[] args, Type argType, int index)
        {
            SEnforce.ArgumentNotNull(args, "args");

            if (args.Length <= index)
            {
                throw new ArgumentException(
                          string.Format(RParameterConversionResources.ArgOfTypeRequiredInPosition, argType, index));
            }

            var arg = args[index];

            if (arg != null && !argType.IsAssignableFrom(arg.GetType()))
            {
                throw new ArgumentException(
                          string.Format(RParameterConversionResources.WrongArgType, index, arg.GetType(), argType));
            }

            return(arg);
        }
 public void AddExitAction(Action <Transition> action)
 {
     _exitActions.Add(SEnforce.ArgumentNotNull(action, "action"));
 }
 public void AddEntryAction(Action <Transition, object[]> action)
 {
     _entryActions.Add(SEnforce.ArgumentNotNull(action, "action"));
 }
 public void AddSubstate(StateRepresentation substate)
 {
     SEnforce.ArgumentNotNull(substate, "substate");
     _substates.Add(substate);
 }
            /// <summary>
            /// Ensure that the supplied arguments are compatible with those configured for this triger.
            /// Убедитесь, что предоставленные аргументы совместимы с аргументами, настроенными для этого триггера.
            /// </summary>
            /// <param name="args"></param>
            public void ValidateParameters(object[] args) 
            {
                SEnforce.ArgumentNotNull(args, "args");

                SParameterConversion.Validate(args, _argumentTypes);
            }