C# ITransition类代码示例

 public IArc AddArc(IPlace place, ITransition transition)
 {
     IArc arc=new Arc(version++,place,transition);
     this.arcs.Add(arc);
     this.graph.AddEdge(arc);
     return arc;
 }

 public Factory(Gateway.Event.IMediator eventMediator, ITransition transition, Command.Endpoint.IFactory commandEndpointFactory, Packet.Endpoint.IFactory packetEndpointFactory)
 {
     _eventMediator = eventMediator;
     _transition = transition;
     _commandEndpointFactory = commandEndpointFactory;
     _packetEndpointFactory = packetEndpointFactory;
 }

        public Connecting(ITransition transition, Command.Endpoint.IFactory commandEndpointFactory, Context.IConnection context)
        {
            _transition = transition;
            _commandEndpointFactory = commandEndpointFactory;

            _context = context;
        }

 public Arc(int id,ITransition transition,IPlace place)
     : base(id,transition,place)
 {
     this.place=place;
     this.transition=transition;
     this.isInputArc=false;
 }

 public IArc AddArc(ITransition transition, IPlace place)
 {
     IArc arc = new Arc(this.version++, transition, place);
     this.arcs.Add(arc);
     this.graph.AddEdge(transition, place);
     return arc;
 }

 public Listening(Gateway.Event.IMediator eventMediator, ITransition transition, Packet.Endpoint.IFactory packetEndpointFactory, Context.IListen context)
 {
     _eventMediator = eventMediator;
     _transition = transition;
     _packetEndpointFactory = packetEndpointFactory;
     _context = context;
 }

 public Arc(int id, ITransition transition, IPlace place)
     : base(id, transition, place)
 {
     this.annotation = new IdentityExpression();
     this.place = place;
     this.transition = transition;
     this.isInputArc = false;
 }

 void transitionManager1_AfterTransitionEnds(ITransition transition, System.EventArgs e) {
     if(!IsHandleCreated) return;
     var method = new MethodInvoker(() => {
       //  bottomPanelBase1.Enabled = true;
     //    var moduleControl = viewModel.SelectedModule as DevExpress.DevAV.Modules.BaseModuleControl;
       //  if(moduleControl != null) moduleControl.OnTransitionCompleted();
     });
     if(InvokeRequired) BeginInvoke(method);
     else method();
 }

        public void DoTransition(object newContent, ITransition transition)
        {
            if(newContent == null)
            {
                Children.Clear();
                return;
            }

            UIElement view;

            if(ContentTemplate != null)
            {
                var template = ContentTemplate.LoadContent();
                var fe = template as FrameworkElement;

                if(fe != null)
                    fe.DataContext = newContent;

                view = template as UIElement;
            }
            else view = newContent as UIElement;

            if(view == null) return;

            if (Children.Contains(view))
            {
                Children.Clear();
                Children.Add(view);
                return;
            }

            if(Children.Count > 0)
            {
                if(transition.RequiresNewContentTopmost)
                {
                    Children.Add(view);
                    transition.BeginTransition(this, Children[0], view);
                }
                else
                {
                    Children.Insert(0, view);
                    transition.BeginTransition(this, Children[1], view);
                }
            }
            else
            {
                Children.Add(view);
                TransitionEnded(transition, null, view);
            }
        }

        /// <summary>
        /// Initializes a new instance of the <see cref="TransitionMutableCore"/> class.
        /// </summary>
        /// <param name="transitionType">
        /// The transition type. 
        /// </param>
        public TransitionMutableCore(ITransition transitionType)
            : base(transitionType)
        {
            this._conditions = new List<ITextTypeWrapperMutableObject>();
            this._targetStep = transitionType.TargetStep.Id;
            if (transitionType.Condition != null)
            {
                foreach (ITextTypeWrapper textTypeWrapper in transitionType.Condition)
                {
                    this._conditions.Add(new TextTypeWrapperMutableCore(textTypeWrapper));
                }
            }

            this._localId = transitionType.LocalId;
        }

        /// <summary>
        /// Starts the specified transition.
        /// </summary>
        /// <param name="previousContent"></param>
        /// <param name="newContent"></param>
        /// <param name="transition"></param>
        public void DoTransition(UIElement previousContent, UIElement newContent, ITransition transition)
        {
            Children.Clear();
            Children.Add(previousContent);

            if (transition.RequiresNewContentTopmost)
            {
                if (newContent != null) Children.Add(newContent);
                transition.BeginTransition(this, Children.Cast<UIElement>().First(), Children.Cast<UIElement>().Last());
            }
            else
            {
                if (newContent != null) Children.Insert(0, newContent);
                transition.BeginTransition(this, Children.Cast<UIElement>().Last(), Children.Cast<UIElement>().First());
            }
        }

        public virtual void ChangeState(ITransition transition)
        {
            if (transition == null)
            {
                throw new ArgumentNullException(nameof(transition), "Cannot change state with a null transition");
            }

            var oldState = this.State;
            var newState = this.GetDestinationState(transition);

            if (newState == null)
            {
                throw new InvalidTransitionException(oldState, transition);
            }

            FireChanging(newState);

            // Exit old State
            try
            {
                State.Exit(transition);
            }
            catch (Exception e)
            {
                throw new StateFailedToExitException(oldState, transition, e);
            }

            // Change State
            State = newState;

            // Enter new State
            try
            {
                State.Enter(transition);
            }
            catch (Exception e)
            {
                throw new StateFailedToEnterException(oldState, transition, newState, e);
            }

            FireChanged();

            State.Action(this);
        }

 public abstract bool IsTransitionAllowed(ITransition transition);

        /// <summary>
        /// Handles the Navigating event of the frame, the immediate way to
        /// begin a transition out before the new page has loaded or had its
        /// layout pass.
        /// </summary>
        /// <param name="sender">The source object.</param>
        /// <param name="e">The event arguments.</param>
        private void OnNavigating(object sender, NavigatingCancelEventArgs e)
        {
            _isForwardNavigation = e.NavigationMode != NavigationMode.Back;

            var oldElement = Content as UIElement;
            if (oldElement == null)
            {
                return;
            }

            FlipPresenters();

            TransitionElement oldTransitionElement = null;
            NavigationOutTransition navigationOutTransition = null;
            ITransition oldTransition = null;

            navigationOutTransition = TransitionService.GetNavigationOutTransition(oldElement);

            if (navigationOutTransition != null)
            {
                oldTransitionElement = _isForwardNavigation ? navigationOutTransition.Forward : navigationOutTransition.Backward;
            }
            if (oldTransitionElement != null)
            {
                oldTransition = oldTransitionElement.GetTransition(oldElement);
            }
            if (oldTransition != null)
            {
                EnsureStoppedTransition(oldTransition);

                _storedNavigationOutTransition = navigationOutTransition;
                _storedOldTransition = oldTransition;
                oldTransition.Completed += OnExitTransitionCompleted;

                _performingExitTransition = true;

                PerformTransition(navigationOutTransition, _oldContentPresenter, oldTransition);

                PrepareContentPresenterForCompositor(_oldContentPresenter);
            }
            else
            {
                _readyToTransitionToNewContent = true;
            }
        }

 /// <summary>
 /// Performs a transition when given the appropriate components,
 /// includes calling the appropriate start event and ensuring opacity
 /// on the content presenter.
 /// </summary>
 /// <param name="navigationTransition">The navigation transition.</param>
 /// <param name="presenter">The content presenter.</param>
 /// <param name="transition">The transition instance.</param>
 private static void PerformTransition(NavigationTransition navigationTransition, ContentPresenter presenter, ITransition transition)
 {
     if (navigationTransition != null)
     {
         navigationTransition.OnBeginTransition();
     }
     if (presenter != null && presenter.Opacity != 1)
     {
         presenter.Opacity = 1;
     }
     if (transition != null)
     {
         transition.Begin();
     }
 }