/// <summary> /// Prepare this state for use in a live railway. /// Make sure all relevant connections to other state objects are resolved. /// Check the IsReadyForUse property afterwards if it has succeeded. /// </summary> internal void PrepareForUse(IStateUserInterface ui, IStatePersistence statePersistence) { if (!readyForUse) { readyForUse = TryPrepareForUse(ui, statePersistence); } }
/// <summary> /// Prepare this state for use in a live railway. /// Make sure all relevant connections to other state objects are resolved. /// </summary> /// <returns>True if the entity is now ready for use in a live railway, false otherwise.</returns> protected override bool TryPrepareForUse(IStateUserInterface ui, IStatePersistence statePersistence) { if (!base.TryPrepareForUse(ui, statePersistence)) { return(false); } var splb = lb as SerialPortLocoBuffer; if (splb != null) { var portNames = SerialPort.GetPortNames(); if (!portNames.Contains(splb.PortName)) { var portName = ui.ChooseComPortName(this); if (portNames.Contains(portName)) { // Now we have an available port name splb.PortName = portName; } else { // No available port name provided, we cannot be used. return(false); } } } return(true); }
/// <summary> /// Prepare this state for use in a live railway. /// Make sure all relevant connections to other state objects are resolved. /// </summary> /// <returns>True if the entity is now ready for use in a live railway, false otherwise.</returns> protected override bool TryPrepareForUse(IStateUserInterface ui, IStatePersistence statePersistence) { if (!base.TryPrepareForUse(ui, statePersistence)) { return(false); } var portNames = SerialPort.GetPortNames(); if (!portNames.Contains(Entity.ComPortName)) { var portName = ui.ChooseComPortName(this); if (portNames.Contains(portName)) { // Now we have an available port name client.PortName = portName; } else { // No available port name provided, we cannot be used. return(false); } } // Request for status, this triggers the open process. PostWorkerAction(() => client.Status()); return(true); }
/// <summary> /// Returns an instance of <see cref="Microsoft.ApplicationBlocks.UIProcess.IStatePersistence"/> /// for the given <see cref="Microsoft.ApplicationBlocks.UIProcess.StatePersistenceProviderSettings"/>. /// </summary> /// <param name="providerSettings">The settings for state persistence.</param> /// <returns>The instance of IStatePersistence. It gets this from the internal cache, if possible.</returns> public static IStatePersistence Create(StatePersistenceProviderSettings providerSettings) { string statePersistenceKey = providerSettings.Type + "," + providerSettings.Assembly; IStatePersistence spp = (IStatePersistence)_statePersistenceCache[statePersistenceKey]; if (spp == null) { try { // now create instance based on that type info spp = (IStatePersistence)GenericFactory.Create(providerSettings); // pass in parameters to spp init method. this is where spp's find data they need such as // connection strings, etc. spp.Init(providerSettings.AdditionalAttributes); } catch (Exception e) { throw new UIPException(Resource.ResourceManager.FormatMessage(Resource.Exceptions.RES_ExceptionCantCreateStatePersistenceProvider, providerSettings.Type) + UIPException.GetFirstExceptionMessage(e), e); } // lock collection lock (_statePersistenceCache.SyncRoot) _statePersistenceCache[statePersistenceKey] = spp; } // return it return(spp); }
/// <summary> /// Loads the state for a given task identifier. /// </summary> /// <param name="taskId">The task identifier (a GUID associated with the task).</param> /// <returns>The state.</returns> public static State Load(Guid taskId) { State state = null; if (UIPConfiguration.Config.IsStateCacheEnabled) { state = StateCache.LoadFromCache(taskId); if (state == null) { //State is not there in the cache, so a new state will be created here IStatePersistence spp = StatePersistenceFactory.Create( ); state = Load(spp, taskId); StateCache.PutStateInCache(state, false); } } else { //The cache is disabled, so a new one is created IStatePersistence spp = StatePersistenceFactory.Create( ); state = Load(spp, taskId); } return(state); }
/// <summary> /// Prepare this state for use in a live railway. /// Make sure all relevant connections to other state objects are resolved. /// </summary> /// <returns>True if the entity is now ready for use in a live railway, false otherwise.</returns> protected override bool TryPrepareForUse(IStateUserInterface ui, IStatePersistence statePersistence) { if (!base.TryPrepareForUse(ui, statePersistence)) { return(false); } try { client = new MqttClient(Entity.HostName); client.MqttMsgPublishReceived += onMqttMsgPublishReceived; client.MqttMsgPublished += onMqttMsgPublished; client.ConnectionClosed += onMqttConnectionClosed; // Power on client.Connect(clientID); // Subscribe to topics var topics = getSubscribeTopics(); var qos = topics.Select(x => MqttMsgBase.QOS_LEVEL_AT_LEAST_ONCE).ToArray(); client.Subscribe(topics, qos); } catch (Exception ex) { Log.Error("Failed to connect to MQTT server: " + ex); return(false); } return(true); }
/// <summary> /// Prepare this state for use in a live railway. /// Make sure all relevant connections to other state objects are resolved. /// </summary> /// <returns>True if the entity is now ready for use in a live railway, false otherwise.</returns> protected override bool TryPrepareForUse(IStateUserInterface ui, IStatePersistence statePersistence) { // Resolve command station var cs = RailwayState.SelectCommandStation(Entity); if (cs == null) { return(false); } cs.AddInput(this); // Resolve destination blocks var routes = RailwayState.RouteStates.Where(x => x.Contains(this)); destinationBlocks = routes.Select(x => x.To).ToList(); if (Entity.Block != null) { var blockState = RailwayState.BlockStates[Entity.Block]; if ((blockState != null) && (!destinationBlocks.Contains(blockState))) { destinationBlocks.Add(blockState); } } return(true); }
/// <summary> /// Prepare this state for use in a live railway. /// Make sure all relevant connections to other state objects are resolved. /// </summary> /// <returns>True if the entity is now ready for use in a live railway, false otherwise.</returns> protected override bool TryPrepareForUse(IStateUserInterface ui, IStatePersistence statePersistence) { // Do not change the order of initialization commandStationStates.Cast <EntityState>().Foreach(x => x.PrepareForUse(ui, statePersistence)); locStates.Cast <EntityState>().Foreach(x => x.PrepareForUse(ui, statePersistence)); junctionStates.Cast <EntityState>().Foreach(x => x.PrepareForUse(ui, statePersistence)); signalStates.Cast <EntityState>().Foreach(x => x.PrepareForUse(ui, statePersistence)); blockStates.Cast <EntityState>().Foreach(x => x.PrepareForUse(ui, statePersistence)); blockGroupStates.Cast <EntityState>().Foreach(x => x.PrepareForUse(ui, statePersistence)); routeStates.Cast <EntityState>().Foreach(x => x.PrepareForUse(ui, statePersistence)); sensorStates.Cast <EntityState>().Foreach(x => x.PrepareForUse(ui, statePersistence)); outputStates.Cast <EntityState>().Foreach(x => x.PrepareForUse(ui, statePersistence)); // Wrap up blockStates.Cast <BlockState>().Foreach(x => x.FinalizePrepare()); routeStates.Cast <RouteState>().Foreach(x => x.FinalizePrepare()); // Attach power event foreach (var csState in commandStationStates) { csState.Power.ActualChanged += (s, _) => power.OnActualChanged(); } return(true); }
/// <summary> /// Prepare this state for use in a live railway. /// Make sure all relevant connections to other state objects are resolved. /// </summary> /// <returns>True if the entity is now ready for use in a live railway, false otherwise.</returns> protected override bool TryPrepareForUse(IStateUserInterface ui, IStatePersistence statePersistence) { if (!base.TryPrepareForUse(ui, statePersistence)) { return(false); } return(true); }
/// <summary> /// Prepare this state for use in a live railway. /// Make sure all relevant connections to other state objects are resolved. /// </summary> /// <returns>True if the entity is now ready for use in a live railway, false otherwise.</returns> protected override bool TryPrepareForUse(IStateUserInterface ui, IStatePersistence statePersistence) { if (!base.TryPrepareForUse(ui, statePersistence)) { return(false); } RailwayState.ModelTime.ActualChanged += (s, _) => OnTimeChanged(); return(true); }
/// <summary> /// Prepare this state for use in a live railway. /// Make sure all relevant connections to other state objects are resolved. /// </summary> /// <returns>True if the entity is now ready for use in a live railway, false otherwise.</returns> protected override bool TryPrepareForUse(IStateUserInterface ui, IStatePersistence statePersistence) { blocks.Clear(); var myBlockEntities = Entity.Module.Blocks.Where(x => x.BlockGroup == Entity); blocks.AddRange(myBlockEntities.Select(x => RailwayState.BlockStates[x])); return(true); }
/// <summary> /// Prepare this state for use in a live railway. /// Make sure all relevant connections to other state objects are resolved. /// </summary> /// <returns>True if the entity is now ready for use in a live railway, false otherwise.</returns> protected override bool TryPrepareForUse(IStateUserInterface ui, IStatePersistence statePersistence) { if (!base.TryPrepareForUse(ui, statePersistence)) { return(false); } CommandStation.AddInput(busyInput); return(true); }
/// <summary> /// Prepare this state for use in a live railway. /// Make sure all relevant connections to other state objects are resolved. /// </summary> /// <returns>True if the entity is now ready for use in a live railway, false otherwise.</returns> protected override bool TryPrepareForUse(IStateUserInterface ui, IStatePersistence statePersistence) { var stream = Entity.Sound; if (stream != null) { sound = ui.SoundPlayer.Create(stream); } return(true); }
/// <summary> /// Default ctor /// </summary> internal AppState(IStateUserInterface ui, MainForm mainForm) { Application.ThreadException += (s, x) => OnErrorPowerDown(x.Exception); Application.Idle += (s, x) => OnApplicationIdle(); this.ui = ui; this.mainForm = mainForm; var persistence = new StatePersistence(); statePersistence = persistence; server = new Core.Server.Impl.Server(); }
/// <summary> /// Prepare this state for use in a live railway. /// Make sure all relevant connections to other state objects are resolved. /// </summary> /// <returns>True if the entity is now ready for use in a live railway, false otherwise.</returns> protected override bool TryPrepareForUse(IStateUserInterface ui, IStatePersistence statePersistence) { if (Entity.Loc != null) { loc = RailwayState.LocStates[Entity.Loc]; if (loc == null) { return(false); } } return(true); }
/// <summary> /// Prepare this state for use in a live railway. /// Make sure all relevant connections to other state objects are resolved. /// </summary> /// <returns>True if the entity is now ready for use in a live railway, false otherwise.</returns> protected override bool TryPrepareForUse(IStateUserInterface ui, IStatePersistence statePersistence) { if (!base.TryPrepareForUse(ui, statePersistence)) { return(false); } try { discoveryBroadcaster.Start(); } catch (Exception ex) { Log.Error("Failed to start discovery broadcaster: " + ex); return(false); } try { localWorkerService = new LocalWorkerServiceImpl(this, Log); grpcServer = new Server { Services = { LocalWorkerService.BindService(localWorkerService) }, Ports = { new ServerPort("0.0.0.0", Entity.APIPort, ServerCredentials.Insecure) } }; grpcServer.Start(); } catch (Exception ex) { Log.Error("Failed to start GRPC server: " + ex); return(false); } try { client = new MqttClient(Entity.HostName); client.MqttMsgPublishReceived += onMqttMsgPublishReceived; client.MqttMsgPublished += onMqttMsgPublished; client.ConnectionClosed += onMqttConnectionClosed; // Power on client.Connect(clientID); // Subscribe to topics var topics = getSubscribeTopics(); var qos = topics.Select(x => MqttMsgBase.QOS_LEVEL_AT_LEAST_ONCE).ToArray(); client.Subscribe(topics, qos); } catch (Exception ex) { Log.Error("Failed to connect to MQTT server: " + ex); return(false); } return(true); }
/// <summary> /// Prepare this state for use in a live railway. /// Make sure all relevant connections to other state objects are resolved. /// </summary> /// <returns>True if the entity is now ready for use in a live railway, false otherwise.</returns> protected override bool TryPrepareForUse(IStateUserInterface ui, IStatePersistence statePersistence) { var cs = RailwayState.SelectCommandStation(Entity); if (cs == null) { return(false); } this.statePersistence = statePersistence; cs.AddLoc(this); commandStation = cs; return(true); }
/// <summary> /// Creates the default State object, loading it from the persistence provider. /// </summary> /// <returns>Default state instance of type specified in the configuration file.</returns> public static State Create() { IStatePersistence spp = StatePersistenceFactory.Create(); ObjectTypeSettings typeSettings = UIPConfiguration.Config.DefaultState; State state = Create(spp, typeSettings); if (UIPConfiguration.Config.IsStateCacheEnabled) { StateCache.PutStateInCache(state, true); } return(state); }
/// <summary> /// Uses the task ID to explicitly load the state from the provided IStatePersistence instance. /// Note that this overload does not attempt to fetch from the cache. /// </summary> /// <param name="statePersistenceProvider"></param> /// <param name="taskId"></param> /// <returns></returns> internal static State Load(IStatePersistence statePersistenceProvider, Guid taskId) { State state = statePersistenceProvider.Load(taskId); if (state != null) { state.Accept(statePersistenceProvider); } else { throw new UIPException(Resource.ResourceManager.FormatMessage(Resource.Exceptions.RES_ExceptionTaskNotFound, taskId)); } return(state); }
/// <summary> /// Creates a State object, loading it from persistence provider. /// </summary> /// <param name="navigatorName">Name of the navigator.</param> /// <returns>State instance of the type specified in the configuration file.</returns> public static State Create(string navigatorName) { // Create a State persistence provider to be used by the state object IStatePersistence spp = StatePersistenceFactory.Create(navigatorName); ObjectTypeSettings typeSettings = UIPConfiguration.Config.GetStateSettings(navigatorName); State state = Create(spp, typeSettings); //Check if the cache is enabled if (UIPConfiguration.Config.IsStateCacheEnabled) { StateCache.PutStateInCache(state, navigatorName, true); } return(state); }
/// <summary> /// Prepare this state for use in a live railway. /// Make sure all relevant connections to other state objects are resolved. /// </summary> /// <returns>True if the entity is now ready for use in a live railway, false otherwise.</returns> protected override bool TryPrepareForUse(IStateUserInterface ui, IStatePersistence statePersistence) { if (!base.TryPrepareForUse(ui, statePersistence)) { return(false); } var cs = SelectCommandStation(); if (cs == null) { return(false); } cs.AddJunction(this); commandStation = cs; RailwayState.Power.ActualChanged += OnPowerActualChanged; return(true); }
public void StartAndStopRunner() { WindsorContainer windsorContainer = new WindsorContainer(@"SampleConfigurations\ProjectPilot.config.xml"); windsorContainer.Kernel.ComponentCreated += new Castle.MicroKernel.ComponentInstanceDelegate(Kernel_ComponentCreated); windsorContainer.Kernel.ComponentModelCreated += new Castle.MicroKernel.ComponentModelDelegate(Kernel_ComponentModelCreated); windsorContainer.Kernel.ComponentRegistered += new Castle.MicroKernel.ComponentDataDelegate(Kernel_ComponentRegistered); windsorContainer.Kernel.DependencyResolving += new Castle.MicroKernel.DependencyDelegate(Kernel_DependencyResolving); windsorContainer.Kernel.HandlerRegistered += new Castle.MicroKernel.HandlerDelegate(Kernel_HandlerRegistered); WindsorContainerGraphs.GenerateDependencyGraph(windsorContainer, "graph.dot"); IStatePersistence mockStatePersistence = MockRepository.GenerateMock <IStatePersistence>(); // prepare test history data RevisionControlHistoryData data; using (Stream stream = File.OpenRead(@"..\..\..\Data\Samples\svn-log.xml")) { data = SubversionHistoryFacility.LoadHistory(stream); } IRevisionControlHistoryFacility mockRcsHistoryFacility = MockRepository.GenerateMock <IRevisionControlHistoryFacility>(); mockRcsHistoryFacility.Stub(action => action.FetchHistory()).Return(data); windsorContainer.Kernel.AddComponentInstance("RcsHistoryFacility", typeof(IRevisionControlHistoryFacility), mockRcsHistoryFacility); using (IRunner runner = windsorContainer.Resolve <IRunner>()) { Project[] projects = windsorContainer.Kernel.ResolveServices <Project>(); IProjectRegistry projectRegistry = windsorContainer.Resolve <IProjectRegistry>(); Assert.AreEqual(1, projectRegistry.ProjectsCount); Project project = projectRegistry.GetProject("projectpilot"); Assert.IsNotNull(project); Assert.AreEqual(1, project.ModulesCount); IProjectModule module = project.GetModule("RevisionControlStats"); runner.Start(); Thread.Sleep(5000); } }
/// <summary> /// Prepare this state for use in a live railway. /// Make sure all relevant connections to other state objects are resolved. /// </summary> /// <returns>True if the entity is now ready for use in a live railway, false otherwise.</returns> protected override bool TryPrepareForUse(IStateUserInterface ui, IStatePersistence statePersistence) { var index = 0; while (index < actions.Count) { var x = (EntityState)actions[index]; x.PrepareForUse(ui, statePersistence); if (!x.IsReadyForUse) { actions.RemoveAt(index); } else { index++; } } return(actions.Any()); }
/// <summary> /// Prepare this state for use in a live railway. /// Make sure all relevant connections to other state objects are resolved. /// </summary> /// <returns>True if the entity is now ready for use in a live railway, false otherwise.</returns> protected override bool TryPrepareForUse(IStateUserInterface ui, IStatePersistence statePersistence) { // Load state this.statePersistence = statePersistence; bool closed; if (statePersistence.TryGetBlockState(RailwayState, this, out closed)) { Closed.Requested = closed; } junctions.Clear(); var myJunctionEntities = Entity.Module.Junctions.Where(x => x.Block == Entity); junctions.AddRange(myJunctionEntities.Select(x => RailwayState.JunctionStates[x])); var groupEntity = Entity.BlockGroup; blockGroup = (groupEntity != null) ? RailwayState.BlockGroupStates[groupEntity] : null; return(true); }
/// <summary> /// Prepare this state for use in a live railway. /// Make sure all relevant connections to other state objects are resolved. /// </summary> /// <returns>True if the entity is now ready for use in a live railway, false otherwise.</returns> protected override bool TryPrepareForUse(IStateUserInterface ui, IStatePersistence statePersistence) { var fromBlock = routes[0].From as IBlock; if (fromBlock == null) { return(false); } from = RailwayState.BlockStates[fromBlock]; var lastRoute = routes[routes.Length - 1]; var toBlock = lastRoute.To as IBlock; if (toBlock == null) { return(false); } to = RailwayState.BlockStates[toBlock]; destinationReachedTrigger.PrepareForUse(ui, statePersistence); foreach (var route in routes) { foreach (var item in route.CrossingJunctions) { var junctionState = RailwayState.JunctionStates[item.Junction]; var state = item.Accept(Default <JunctionWithStateBuilder> .Instance, junctionState); if (state == null) { return(false); } crossingJunctions.Add(state); hasNonStraightSwitches |= state.IsNonStraight; } } events.ForEach(x => x.PrepareForUse(ui, statePersistence)); permissions.PrepareForUse(ui, statePersistence); return(true); }
/// <summary> /// Creates a State object, loading it from persistence provider. /// </summary> /// <param name="spp">The state persistence provider.</param> /// <param name="typeSettings">The state settings.</param> /// <returns>A state instance of the type specified in the configuration file.</returns> internal static State Create(IStatePersistence spp, ObjectTypeSettings typeSettings) { State state = null; Guid taskId = Guid.Empty; if (typeSettings == null) { throw new UIPException(Resource.ResourceManager.FormatMessage(Resource.Exceptions.RES_ExceptionStateConfigNotFound, "")); } // set the arguments used by the State object constructor object[] args = { spp }; try { // pass to Base class' reflection code // DON'T look for this State in Cache, "CREATE" semantics in this class // demand that we create it freshly... // UNLIKE other Factories, State is stateful and we don't recycle in Create; // instead if the consuming class wishes a Cached entry, they might get it // from Load() methods instead... state = (State)GenericFactory.Create(typeSettings, args); } catch (Exception e) { throw new ConfigurationException(Resource.ResourceManager.FormatMessage(Resource.Exceptions.RES_ExceptionCantCreateState, typeSettings.Type), e); } // create a new Task id taskId = Guid.NewGuid(); // store the task id into the state object state.TaskId = taskId; // return it return(state); }
/// <summary> /// Initialize all items /// </summary> /// <returns>True if there are assignment options</returns> internal bool Initialize(IRailwayState railwayState, IStatePersistence statePersistence) { this.railwayState = railwayState; lvLocs.BeginUpdate(); lvLocs.Items.Clear(); foreach (var locState in railwayState.LocStates.Where(x => (x.CurrentBlock.Actual == null)).OrderBy(x => x.Description)) { BlockSide currentBlockEnterSide; IBlockState blockState; LocDirection locDirection; if (statePersistence.TryGetLocState(railwayState, locState, out blockState, out currentBlockEnterSide, out locDirection)) { var item = new Item(locState, blockState, currentBlockEnterSide, locDirection); lvLocs.Items.Add(item); } } lvLocs.EndUpdate(); UpdateButtonState(); return(lvLocs.Items.Count > 0); }
/// <summary> /// Prepare this state for use in a live railway. /// Make sure all relevant connections to other state objects are resolved. /// </summary> /// <returns>True if the entity is now ready for use in a live railway, false otherwise.</returns> protected override bool TryPrepareForUse(IStateUserInterface ui, IStatePersistence statePersistence) { // Resolve block. var entity = Entity; block = (entity.Block != null) ? RailwayState.BlockStates[entity.Block] : null; if (block == null) { return(false); } // Resolve command station var cs = RailwayState.SelectCommandStation(Entity); if (cs == null) { return(false); } commandStation = cs; commandStation.AddSignal(this); return(true); }
/// <summary> /// Prepare this state for use in a live railway. /// Make sure all relevant connections to other state objects are resolved. /// </summary> /// <returns>True if the entity is now ready for use in a live railway, false otherwise.</returns> protected override bool TryPrepareForUse(IStateUserInterface ui, IStatePersistence statePersistence) { if (!base.TryPrepareForUse(ui, statePersistence)) { return(false); } /*var portNames = SerialPort.GetPortNames(); * if (!portNames.Contains(Entity.ComPortName)) * { * var portName = ui.ChooseComPortName(this); * if (portNames.Contains(portName)) * { * // Now we have an available port name * sender.PortName = portName; * } * else * { * // No available port name provided, we cannot be used. * return false; * } * }*/ return(true); }
/// <summary> /// Prepare this state for use in a live railway. /// Make sure all relevant connections to other state objects are resolved. /// </summary> /// <returns>True if the entity is now ready for use in a live railway, false otherwise.</returns> protected override bool TryPrepareForUse(IStateUserInterface ui, IStatePersistence statePersistence) { return(true); }
/// <summary> /// Constructor. /// </summary> /// <param name="statePersistenceProvider">A valid state persistence provider.</param> public State(IStatePersistence statePersistenceProvider) { this.Accept(statePersistenceProvider); }
/// <summary> /// The visitor pattern for StatePersistence. /// </summary> /// <param name="statePersistence">A valid state persistence provider object.</param> public void Accept(IStatePersistence statePersistence) { this._stateVisitor = statePersistence; }
/// <summary> /// Constructor. /// </summary> /// <param name="taskId">A task identifier (a GUID associated with the task).</param> /// <param name="navigationGraph">A valid navigation graph name.</param> /// <param name="currentView">The current view in the navigation graph.</param> /// <param name="navigateValue">Used by the controller to determine which view is next.</param> /// <param name="statePersistence">A valid state persistence provider.</param> public State(Guid taskId, string navigationGraph, string currentView, string navigateValue, IStatePersistence statePersistence) { this._taskId = taskId; this._navigationGraph = navigationGraph; this._currentView = currentView; this._navigateValue = navigateValue; this.Accept(statePersistence); }
/// <summary> /// Creates a State object, loading it from persistence provider. /// </summary> /// <param name="spp">The state persistence provider.</param> /// <param name="typeSettings">The state settings.</param> /// <returns>A state instance of the type specified in the configuration file.</returns> internal static State Create(IStatePersistence spp, ObjectTypeSettings typeSettings) { State state = null; Guid taskId = Guid.Empty; if (typeSettings == null) throw new Exception(string.Format("ExceptionStateConfigNotFound")); // set the arguments used by the State object constructor object[] args = { spp }; try { // pass to Base class' reflection code // DON'T look for this State in Cache, "CREATE" semantics in this class // demand that we create it freshly... // UNLIKE other Factories, State is stateful and we don't recycle in Create; // instead if the consuming class wishes a Cached entry, they might get it // from Load() methods instead... state = (State)GenericFactory.Create(typeSettings, args); } catch (Exception e) { throw new ConfigurationErrorsException(string.Format("ExceptionCantCreateState: {0} - {1}.", typeSettings.Type, e.Message)); } // create a new Task id taskId = Guid.NewGuid(); // store the task id into the state object state.TaskId = taskId; // return it return state; }
/// <summary> /// Uses the task ID to explicitly load the state from the provided IStatePersistence instance. /// Note that this overload does not attempt to fetch from the cache. /// </summary> /// <param name="statePersistenceProvider"></param> /// <param name="taskId"></param> /// <returns></returns> internal static State Load(IStatePersistence statePersistenceProvider, Guid taskId) { State state = statePersistenceProvider.Load(taskId); if (state != null) state.Accept(statePersistenceProvider); else throw new Exception(string.Format("ExceptionTaskNotFound: {0}.", taskId)); return state; }