static void Main()
{
CreateRoles();
using (WorkflowRuntime workflowRuntime = new WorkflowRuntime())
{
workflowRuntime.StartRuntime();
// Load the workflow type.
Type type = typeof(PurchaseOrderWorkflow);
ExternalDataExchangeService dataService = new ExternalDataExchangeService();
workflowRuntime.AddService(dataService);
poImpl = new StartPurchaseOrder();
dataService.AddService(poImpl);
workflowRuntime.WorkflowCompleted += OnWorkflowCompleted;
workflowRuntime.WorkflowTerminated += OnWorkflowTerminated;
WorkflowInstance instance = workflowRuntime.CreateWorkflow(type);
workflowInstanceId = instance.InstanceId;
instance.Start();
SendPORequestMessage();
waitHandle.WaitOne();
workflowRuntime.StopRuntime();
}
}
static void Main()
{
using (WorkflowRuntime workflowRuntime = new WorkflowRuntime())
{
try
{
// Start the engine.
workflowRuntime.StartRuntime();
// Load the workflow type.
Type type = typeof(Microsoft.Samples.Workflow.Synchronized.SynchronizedActivityWorkflow);
workflowRuntime.WorkflowCompleted += OnWorkflowCompleted;
workflowRuntime.WorkflowTerminated += OnWorkflowTerminated;
workflowRuntime.ServicesExceptionNotHandled += OnExceptionNotHandled;
workflowRuntime.CreateWorkflow(type).Start();
waitHandle.WaitOne();
}
catch (Exception e)
{
Console.WriteLine("Exception \n\t Source: {0} \n\t Message: {1}", e.Source, e.Message);
}
finally
{
workflowRuntime.StopRuntime();
Console.WriteLine("\nWorkflow runtime stopped, program exiting... \n");
}
}
}
static void Main()
{
using (WorkflowRuntime workflowRuntime = new WorkflowRuntime())
{
try
{
const string connectString = "Initial Catalog=SqlPersistenceService;Data Source=localhost;Integrated Security=SSPI;";
workflowRuntime.AddService(new SqlWorkflowPersistenceService(connectString));
workflowRuntime.WorkflowCompleted += OnWorkflowCompleted;
workflowRuntime.WorkflowTerminated += OnWorkflowTerminated;
workflowRuntime.WorkflowAborted += OnWorkflowAborted;
workflowRuntime.StartRuntime();
Type type = typeof(Compensation.PurchaseOrder);
workflowRuntime.CreateWorkflow(type).Start();
waitHandle.WaitOne();
}
catch (Exception ex)
{
if (ex.InnerException != null)
Console.WriteLine(ex.InnerException.Message);
else
Console.WriteLine(ex.Message);
}
finally
{
workflowRuntime.StopRuntime();
}
}
}
public void Pipeline_CC_Workflow_Should_Send_Acknowledgment_Email_To_Customer() {
Order order = GetTestOrder();
using (WorkflowRuntime workflowRuntime = new WorkflowRuntime()) {
AutoResetEvent waitHandle = new AutoResetEvent(false);
workflowRuntime.WorkflowCompleted += delegate(object sender, WorkflowCompletedEventArgs e) { waitHandle.Set(); };
workflowRuntime.WorkflowTerminated += delegate(object sender, WorkflowTerminatedEventArgs e) {
Debug.WriteLine(e.Exception.Message);
waitHandle.Set();
};
WorkflowInstance instance = workflowRuntime.CreateWorkflow(
typeof(Commerce.Pipelines.SubmitOrderWorkflow), GetParams(order));
instance.Start();
waitHandle.WaitOne();
//execution should be finished
//check the mailers
TestMailerService mailer = _mailerService as TestMailerService;
Assert.IsTrue(mailer.SentMail.Count > 0);
//the first email should be to the customer
Assert.AreEqual(MailerType.CustomerOrderReceived, mailer.SentMail[0].MailType);
}
}
static void Main(string[] args)
{
using (WorkflowRuntime workflowRuntime = new WorkflowRuntime())
{
// Add ChannelManager
ChannelManagerService channelmgr = new ChannelManagerService();
workflowRuntime.AddService(channelmgr);
AutoResetEvent waitHandle = new AutoResetEvent(false);
workflowRuntime.WorkflowCompleted += delegate(object sender, WorkflowCompletedEventArgs e) { Console.WriteLine("WorkflowCompleted: " + e.WorkflowInstance.InstanceId.ToString()); waitHandle.Set(); };
workflowRuntime.WorkflowTerminated += delegate(object sender, WorkflowTerminatedEventArgs e) { Console.WriteLine("WorkflowTerminated: " + e.Exception.Message); waitHandle.Set(); };
while (true)
{
WorkflowInstance instance = workflowRuntime.CreateWorkflow(typeof(Microsoft.WorkflowServices.Samples.SequentialCalculatorClient));
Console.WriteLine("Start SequentialCalculatorClient.");
instance.Start();
waitHandle.WaitOne();
Console.ForegroundColor = ConsoleColor.Green;
Console.WriteLine("Do another calculation? (Y)");
Console.ForegroundColor = ConsoleColor.Red;
Console.WriteLine("Press <enter> to exit.");
Console.ResetColor();
string input = Console.ReadLine();
if (input.Length == 0 || input[0] != 'Y')
break;
waitHandle.Reset();
}
}
}
static void Main()
{
using (WorkflowRuntime workflowRuntime = new WorkflowRuntime())
{
try
{
// engine will unload workflow instance when it is idle
workflowRuntime.AddService(new FilePersistenceService(true));
workflowRuntime.WorkflowCreated += OnWorkflowCreated;
workflowRuntime.WorkflowCompleted += OnWorkflowCompleted;
workflowRuntime.WorkflowIdled += OnWorkflowIdle;
workflowRuntime.WorkflowUnloaded += OnWorkflowUnload;
workflowRuntime.WorkflowLoaded += OnWorkflowLoad;
workflowRuntime.WorkflowTerminated += OnWorkflowTerminated;
workflowRuntime.ServicesExceptionNotHandled += OnExceptionNotHandled;
workflowRuntime.CreateWorkflow(typeof(PersistenceServiceWorkflow)).Start();
waitHandle.WaitOne();
}
catch (Exception e)
{
Console.WriteLine("Exception \n\t Source: {0} \n\t Message: {1}", e.Source, e.Message);
}
finally
{
workflowRuntime.StopRuntime();
Console.WriteLine("Workflow runtime stopped, program exiting... \n");
}
}
}
static void Main()
{
// Create the WorkflowRuntime
using (WorkflowRuntime workflowRuntime = new WorkflowRuntime())
{
// Set up the WorkflowRuntime events so that the host gets notified when the workflow
// completes and terminates
workflowRuntime.WorkflowCompleted += new EventHandler<WorkflowCompletedEventArgs>(OnWorkflowCompleted);
workflowRuntime.WorkflowTerminated += new EventHandler<WorkflowTerminatedEventArgs>(OnWorkflowTerminated);
// Load the workflow type
Type type = typeof(ThrowWorkflow);
//Start the workflow and wait for it to complete
workflowRuntime.CreateWorkflow(type).Start();
Console.WriteLine("Workflow Started.");
waitHandle.WaitOne();
Console.WriteLine("Workflow Completed.");
workflowRuntime.StopRuntime();
}
}
static void Main()
{
string connectionString = "Initial Catalog=SqlPersistenceService;Data Source=localhost;Integrated Security=SSPI;";
using (WorkflowRuntime workflowRuntime = new WorkflowRuntime())
{
ExternalDataExchangeService dataService = new ExternalDataExchangeService();
workflowRuntime.AddService(dataService);
dataService.AddService(expenseService);
workflowRuntime.AddService(new SqlWorkflowPersistenceService(connectionString));
workflowRuntime.StartRuntime();
workflowRuntime.WorkflowCompleted += OnWorkflowCompleted;
workflowRuntime.WorkflowTerminated += OnWorkflowTerminated;
workflowRuntime.WorkflowIdled += OnWorkflowIdled;
workflowRuntime.WorkflowAborted += OnWorkflowAborted;
Type type = typeof(Microsoft.Samples.Workflow.CancelWorkflow.SampleWorkflow);
WorkflowInstance workflowInstance = workflowRuntime.CreateWorkflow(type);
workflowInstance.Start();
waitHandle.WaitOne();
workflowRuntime.StopRuntime();
}
}
static void Main()
{
using (WorkflowRuntime workflowRuntime = new WorkflowRuntime())
{
// Create our local service and add it to the workflow runtime's list of services
ExternalDataExchangeService dataService = new ExternalDataExchangeService();
workflowRuntime.AddService(dataService);
VotingServiceImpl votingService = new VotingServiceImpl();
dataService.AddService(votingService);
// Start up the runtime and hook the creation and completion events
workflowRuntime.StartRuntime();
workflowRuntime.WorkflowCompleted += OnWorkflowCompleted;
workflowRuntime.WorkflowTerminated += OnWorkflowTerminated;
workflowRuntime.WorkflowStarted += OnWorkflowStarted;
// Create the workflow's parameters collection
Dictionary<string, object> parameters = new Dictionary<string, object>();
parameters.Add("Alias", "Jim");
// Create and start the workflow
Type type = typeof(HostCommunication.VotingServiceWorkflow);
workflowRuntime.CreateWorkflow(type, parameters).Start();
waitHandle.WaitOne();
// Cleanly stop the runtime and all services
workflowRuntime.StopRuntime();
}
}
internal DebugController(WorkflowRuntime serviceContainer, string hostName)
{
if (serviceContainer == null)
{
throw new ArgumentNullException("serviceContainer");
}
try
{
this.programPublisher = new ProgramPublisher();
}
catch
{
return;
}
this.serviceContainer = serviceContainer;
this.programId = Guid.Empty;
this.controllerConduit = null;
this.channel = null;
this.isZombie = false;
this.hostName = hostName;
AppDomain.CurrentDomain.ProcessExit += new EventHandler(this.OnDomainUnload);
AppDomain.CurrentDomain.DomainUnload += new EventHandler(this.OnDomainUnload);
this.serviceContainer.Started += new EventHandler<WorkflowRuntimeEventArgs>(this.Start);
this.serviceContainer.Stopped += new EventHandler<WorkflowRuntimeEventArgs>(this.Stop);
}
static void Main()
{
// Start the engine.
using (WorkflowRuntime workflowRuntime = new WorkflowRuntime())
{
workflowRuntime.StartRuntime();
// Load the workflow type.
Type type = typeof(SuspendAndTerminateWorkflow);
workflowRuntime.WorkflowCompleted += OnWorkflowCompletion;
workflowRuntime.WorkflowSuspended += OnWorkflowSuspend;
workflowRuntime.WorkflowResumed += OnWorkflowResume;
workflowRuntime.WorkflowTerminated += OnWorkflowTerminate;
WorkflowInstance workflowInstance = workflowRuntime.CreateWorkflow(type);
workflowInstance.Start();
waitHandle.WaitOne();
if (workflowSuspended)
{
Console.WriteLine("\r\nResuming Workflow Instance");
workflowInstance.Resume();
waitHandle.WaitOne();
}
workflowRuntime.StopRuntime();
}
}
static void Main()
{
// Start the engine.
using (WorkflowRuntime workflowRuntime = new WorkflowRuntime())
{
workflowRuntime.StartRuntime();
// Load the workflow type.
Type type = typeof(IfElseWorkflow);
workflowRuntime.WorkflowCompleted += OnWorkflowCompleted;
workflowRuntime.WorkflowTerminated += OnWorkflowTerminated;
// The "OrderValueParameter" parameter is used to determine which branch of the IfElse should be executed
// a value less than 10,000 will execute branch 1 - Get Manager Approval; any other value will execute branch 2 - Get VP Approval
Dictionary<string, object> parameters = new Dictionary<string, object>();
parameters.Add("OrderValue", 14000);
WorkflowInstance workflow = workflowRuntime.CreateWorkflow(type, parameters);
workflow.Start();
waitHandle.WaitOne();
workflowRuntime.StopRuntime();
}
}
public Mainform()
{
InitializeComponent();
this.runtime = new WorkflowRuntime();
runtime.WorkflowCompleted += new EventHandler<WorkflowCompletedEventArgs>(runtime_WorkflowCompleted);
// Set up runtime to unload workflow instance from memory to file using FilePersistenceService
FilePersistenceService filePersistence = new FilePersistenceService(true);
runtime.AddService(filePersistence);
// Add document approval service
ExternalDataExchangeService dataService = new ExternalDataExchangeService();
runtime.AddService(dataService);
documentService = new DocumentApprovalService(this);
dataService.AddService(documentService);
// Search for workflows that have previously been persisted to file, and load into the listview control.
// These workflows will be reloaded by the runtime when events are raised against them.
LoadWorkflowData();
// Start the runtime
runtime.StartRuntime();
}
protected override void Init()
{
Kernel.ComponentRegistered += Kernel_ComponentRegistered;
_runtime = new WorkflowRuntime();
Kernel.AddComponentInstance("workflowruntime", _runtime);
}
static void Main(string[] args)
{
using(WorkflowRuntime workflowRuntime = new WorkflowRuntime())
{
AutoResetEvent waitHandle = new AutoResetEvent(false);
workflowRuntime.WorkflowCompleted += delegate(object sender, WorkflowCompletedEventArgs e)
{
Console.WriteLine("Workflow completed.");
waitHandle.Set();
};
workflowRuntime.WorkflowTerminated += delegate(object sender, WorkflowTerminatedEventArgs e)
{
Console.WriteLine(e.Exception.Message);
waitHandle.Set();
};
WorkflowInstance instance = workflowRuntime.CreateWorkflow(typeof(StateInitialization.SampleWorkflow));
Console.WriteLine("Starting workflow.");
instance.Start();
waitHandle.WaitOne();
workflowRuntime.StopRuntime();
}
}
/// <summary>
/// 创建工作流运行时
/// </summary>
/// <param name="IsPer">是否使用持久化</param>
/// <returns></returns>
public static WorkflowRuntime CreateWorkFlowRuntime(bool IsPer)
{
try
{
WorkflowRuntime WfRuntime = new WorkflowRuntime();
if (IsPer)
{
ConnectionStringSettings defaultConnectionString = ConfigurationManager.ConnectionStrings["OracleConnection"];
WfRuntime.AddService(new AdoPersistenceService(defaultConnectionString, true, TimeSpan.FromSeconds(0), TimeSpan.FromSeconds(0)));
WfRuntime.AddService(new AdoTrackingService(defaultConnectionString));
WfRuntime.AddService(new AdoWorkBatchService());
}
FlowEvent ExternalEvent = new FlowEvent();
ExternalDataExchangeService objService = new ExternalDataExchangeService();
WfRuntime.AddService(objService);
objService.AddService(ExternalEvent);
ManualWorkflowSchedulerService scheduleService = new ManualWorkflowSchedulerService();
WfRuntime.AddService(scheduleService);
TypeProvider typeProvider = new TypeProvider(null);
WfRuntime.AddService(typeProvider);
WfRuntime.StartRuntime();
return WfRuntime;
}
catch (Exception ex)
{
LogHelper.WriteLog("CreateWorkFlowRuntime异常信息 ：" + ex.ToString());
throw new Exception(ex.Message);
}
}
static void Main()
{
orderService = new OrderServiceImpl();
// Start the workflow runtime engine.
using (WorkflowRuntime workflowRuntime = new WorkflowRuntime())
{
ExternalDataExchangeService dataService = new ExternalDataExchangeService();
workflowRuntime.AddService(dataService);
dataService.AddService(orderService);
workflowRuntime.StartRuntime();
// Listen for the workflow events
workflowRuntime.WorkflowCompleted += OnWorkflowCompleted;
workflowRuntime.WorkflowTerminated += OnWorkflowTerminated;
workflowRuntime.WorkflowIdled += OnWorkflowIdled;
// Start the workflow and wait for it to complete
Type type = typeof(PurchaseOrderWorkflow);
workflowRuntime.CreateWorkflow(type).Start();
waitHandle.WaitOne();
// Stop the workflow runtime engine.
workflowRuntime.StopRuntime();
}
}
static void Main()
{
try
{
waitHandle = new AutoResetEvent(false);
CreateAndInsertTrackingProfile();
using (WorkflowRuntime runtime = new WorkflowRuntime())
{
SqlTrackingService trackingService = new SqlTrackingService(connectionString);
runtime.AddService(trackingService);
runtime.StartRuntime();
runtime.WorkflowCompleted += OnWorkflowCompleted;
runtime.WorkflowTerminated += OnWorkflowTerminated;
runtime.WorkflowAborted += OnWorkflowAborted;
WorkflowInstance instance = runtime.CreateWorkflow(typeof(BankMachineWorkflow));
instance.Start();
waitHandle.WaitOne();
runtime.StopRuntime();
OutputTrackedData(instance.InstanceId);
}
}
catch (Exception ex)
{
if (ex.InnerException != null)
Console.WriteLine(ex.InnerException.Message);
else
Console.WriteLine(ex.Message);
}
}
static void Main()
{
// Create WorkflowRuntime
using (WorkflowRuntime workflowRuntime = new WorkflowRuntime())
{
// Add ConsoleTrackingService
workflowRuntime.AddService(new ConsoleTrackingService());
// Subscribe to Workflow Completed WorkflowRuntime Event
workflowRuntime.WorkflowCompleted += OnWorkflowCompleted;
// Subscribe to Workflow Terminated WorkflowRuntime Event
workflowRuntime.WorkflowTerminated += OnWorkflowTerminated;
// Start WorkflowRuntime
workflowRuntime.StartRuntime();
// Execute the SampleWorkflow Workflow
Console.WriteLine("Executing the workflow...");
workflowRuntime.CreateWorkflow(typeof(SimplePolicyWorkflow)).Start();
// Wait for the Workflow Completion
waitHandle.WaitOne();
// Stop Runtime
workflowRuntime.StopRuntime();
}
}
static void Main()
{
using (WorkflowRuntime workflowRuntime = new WorkflowRuntime())
{
try
{
// Start the engine
workflowRuntime.StartRuntime();
// Subscribe to events
workflowRuntime.WorkflowCompleted += OnWorkflowCompleted;
workflowRuntime.WorkflowTerminated += OnWorkflowTerminated;
workflowRuntime.WorkflowIdled += OnWorkflowIdled;
workflowRuntime.ServicesExceptionNotHandled += OnServicesExceptionNotHandled;
// Start PO approval workflow with purchase less than $1000
System.Int32 poAmount = 750;
Type workflowType = typeof(Microsoft.Samples.Workflow.DynamicUpdateFromHost.DynamicUpdateWorkflow);
Dictionary<string, object> inputParameters = new Dictionary<string, object>();
inputParameters.Add("Amount", poAmount);
workflowRuntime.CreateWorkflow(workflowType, inputParameters).Start();
waitHandle.WaitOne();
}
catch (Exception e)
{
Console.WriteLine("Exception \n\t Source: {0} \n\t Message: {1}", e.Source, e.Message);
}
finally
{
workflowRuntime.StopRuntime();
Console.WriteLine("Workflow runtime stopped, program exiting... \n");
}
}
}
static void Main()
{
using (WorkflowRuntime workflowRuntime = new WorkflowRuntime())
{
try
{
// A workflow is always run asychronously; the main thread waits on this event so the program
// doesn't exit before the workflow completes
workflowRuntime.AddService(new SqlWorkflowPersistenceService("Initial Catalog=SqlPersistenceService;Data Source=localhost;Integrated Security=SSPI;"));
// Listen for the workflow events
workflowRuntime.WorkflowCompleted += OnWorkflowCompleted;
workflowRuntime.WorkflowTerminated += OnWorkflowTerminated;
workflowRuntime.WorkflowAborted += OnWorkflowAborted;
// Create an instance of the workflow
Type type = typeof(NestedExceptionsWorkflow);
workflowRuntime.CreateWorkflow(type).Start();
Console.WriteLine("Workflow Started.\n");
// Wait for the event to be signaled
waitHandle.WaitOne();
}
catch (Exception ex)
{
Console.WriteLine("Source: {0}\nMessage: {1}", ex.Source, ex.Message);
}
finally
{
workflowRuntime.StopRuntime();
Console.WriteLine("\nWorkflow Complete.");
}
}
}
/////////////////////////////////////////////////////////////////////////////
/////////////////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////////////////////
public MainForm()
{
InitializeComponent();
#region UI define
GenerateButtons();
GenerateAcctions();
#endregion
#region Bankomats Init
currentAccountCulture = CultureInfo.CurrentCulture;
#endregion
#region IniT Workflow
workflowRuntime = new WorkflowRuntime();
ExternalDataExchangeService des = new ExternalDataExchangeService();
workflowRuntime.AddService(des);
des.AddService(this);
workflowRuntime.StartRuntime();
workflowRuntime.WorkflowCompleted += OnWorkflowCompleted;
workflowRuntime.WorkflowTerminated += new EventHandler<WorkflowTerminatedEventArgs>(workflowRuntime_WorkflowTerminated);
Type type = typeof(BankomatWorkflowLibrary.BankomatsWorkflow);
workflowInstance = workflowRuntime.CreateWorkflow(type);
workflowInstance.Start();
#endregion
}
public static WorkflowRuntime Init()
{
WorkflowRuntime workflowRuntime;
// Running in local mode, create an return new runtime
if( HttpContext.Current == null )
workflowRuntime = new WorkflowRuntime();
else
{
// running in web mode, runtime is initialized only once per
// application
if( HttpContext.Current.Application["WorkflowRuntime"] == null )
workflowRuntime = new WorkflowRuntime();
else
return HttpContext.Current.Application["WorkflowRuntime"] as WorkflowRuntime;
}
var manualService = new ManualWorkflowSchedulerService();
workflowRuntime.AddService(manualService);
var syncCallService = new Activities.CallWorkflowService();
workflowRuntime.AddService(syncCallService);
workflowRuntime.StartRuntime();
// on web mode, store the runtime in application context so that
// it is initialized only once. On dekstop mode, ignore
if( null != HttpContext.Current )
HttpContext.Current.Application["WorkflowRuntime"] = workflowRuntime;
return workflowRuntime;
}
static void Main()
{
try
{
waitHandle = new AutoResetEvent(false);
DataAccess.CreateAndInsertTrackingProfile();
using (WorkflowRuntime runtime = new WorkflowRuntime())
{
SqlTrackingService trackingService = new SqlTrackingService(DataAccess.connectionString);
/*
* Set partitioning settings on Sql Tracking Service and database
*/
//Turn on PartitionOnCompletion setting-- Default is false
trackingService.PartitionOnCompletion = true;
//Set partition interval-- Default is 'm' (monthly)
DataAccess.SetPartitionInterval('d');
runtime.AddService(trackingService);
runtime.StartRuntime();
runtime.WorkflowCompleted += delegate(object sender, WorkflowCompletedEventArgs e)
{
waitHandle.Set();
};
runtime.WorkflowTerminated += delegate(object sender, WorkflowTerminatedEventArgs e)
{
Console.WriteLine(e.Exception.Message);
waitHandle.Set();
};
WorkflowInstance instance = runtime.CreateWorkflow(typeof(SimpleWorkflow));
instance.Start();
waitHandle.WaitOne();
runtime.StopRuntime();
DataAccess.GetWorkflowTrackingEvents(instance.InstanceId);
Console.WriteLine("\nDone running the workflow.");
/*
* Show tracking partition information and tables
*/
DataAccess.ShowTrackingPartitionInformation();
DataAccess.ShowPartitionTableInformation();
}
}
catch (Exception ex)
{
if (ex.InnerException != null)
Console.WriteLine(ex.InnerException.Message);
else
Console.WriteLine(ex.Message);
}
}
public void ThereCanBeOnlyOne () {
CustomPersistenceService cp1 = new CustomPersistenceService ();
CustomPersistenceService cp2 = new CustomPersistenceService ();
WorkflowRuntime wr = new WorkflowRuntime ();
wr.AddService (cp1);
wr.AddService (cp2);
}
public void NoCorrelationParameter ()
{
SampleService1 sample = new SampleService1 ();
WorkflowRuntime workflow = new WorkflowRuntime ();
ExternalDataExchangeService data_change = new ExternalDataExchangeService ();
workflow.AddService (data_change);
data_change.AddService (sample);
}
public static WorkflowRuntime GetWorkflowRuntime(this Controller controller) {
if (wfRuntime == null) {
lock (padlock) {
wfRuntime = new WorkflowRuntime();
}
}
return wfRuntime;
}
internal WorkflowInstance (Guid guid, WorkflowRuntime runtime, Activity root_activity)
{
this.guid = guid;
this.runtime = runtime;
this.root_activity = root_activity;
subscription_collection = new TimerEventSubscriptionCollection ();
queuing_service = new WorkflowQueuingService ();
}
public JobWorkflow()
{
InitializeComponent();
this.workflowRuntime = new WorkflowRuntime();
this.workflowRuntime.StartRuntime();
workflowRuntime.WorkflowCompleted += new EventHandler<WorkflowCompletedEventArgs> (workflowRuntime_WorkflowCompleted);
}
static void Main(string[] args)
{
WorkflowRuntime workflowRuntime = new WorkflowRuntime();
workflowRuntime.WorkflowCompleted += workflowRuntime_WorkflowCompleted;
workflowRuntime.WorkflowTerminated += workflowRuntime_WorkflowTerminated;
WorkflowInstance instance = workflowRuntime.CreateWorkflow(typeof(WorkflowMain));
instance.Start();
waitHandle.WaitOne();
}
private async Task <bool> ProjectHasAuthors(ProcessInstance processInstance, WorkflowRuntime runtime, string actionParameter, CancellationToken token)
{
using (var scope = ServiceProvider.CreateScope())
{
var productRepository = scope.ServiceProvider.GetRequiredService <IJobRepository <Product, Guid> >();
var product = await GetProductForProcess(processInstance, productRepository);
var authorsRepository = scope.ServiceProvider.GetRequiredService <IJobRepository <Author> >();
var authors = await authorsRepository.Get()
.Where(a => a.ProjectId == product.ProjectId)
.ToListAsync();
return((authors != null) && authors.Count > 0);
}
}
/// <summary>
/// Start the workflow runtime
/// </summary>
private void InitializeWorkflowRuntime()
{
_workflowRuntime = new WorkflowRuntime();
_workflowRuntime.WorkflowCompleted
+= delegate(object sender, WorkflowCompletedEventArgs e)
{
_waitHandle.Set();
};
_workflowRuntime.WorkflowTerminated
+= delegate(object sender, WorkflowTerminatedEventArgs e)
{
Console.WriteLine(e.Exception.Message);
_waitHandle.Set();
};
}
public static void Detach()
{
WorkflowRuntime workflowRuntime = AppDomain.CurrentDomain.GetData(WorkflowRuntimeName) as WorkflowRuntime;
if (workflowRuntime != null)
{
lock (AppDomain.CurrentDomain.FriendlyName)
{
if (workflowRuntime != null)
{
workflowRuntime.StopRuntime();
}
}
}
}
/// <summary>
/// Diposes the workflow runtime.
/// </summary>
public void DisposeRuntime()
{
// dispose runtime
if (_workflowRuntime != null)
{
_workflowRuntime.Dispose();
}
_workflowRuntime = null;
if (_waitHandle != null)
{
_waitHandle.Close();
}
_waitHandle = null;
_instance = null;
}
/// <summary>
/// Gets the workflow runtime.
/// </summary>
/// <returns>The runtime</returns>
/// <externalUnit/>
/// <revision revisor="dev14" date="8/6/2009" version="1.0.14.30">
/// Member Created
/// </revision>
public static WorkflowRuntime GetWorkflowRuntime()
{
lock (syncRoot)
{
// if the instance of the runtime does not exist yet, create it
if (workflowRuntime == null)
{
workflowRuntime = new WorkflowRuntime();
workflowRuntime.StartRuntime();
}
// return the singleton instance of the workflow
return(workflowRuntime);
}
}
private static void DumpStateMachine(WorkflowRuntime runtime, Guid instanceID)
{
var instance =
new StateMachineWorkflowInstance(runtime, instanceID);
Console.WriteLine("Workflow ID: {0}", instanceID);
Console.WriteLine("Current State: {0}",
instance.CurrentStateName);
Console.WriteLine("Possible Transitions: {0}",
instance.PossibleStateTransitions.Count);
foreach (string name in instance.PossibleStateTransitions)
{
Console.WriteLine("\t{0}", name);
}
}
public void FillInbox(Guid processId, WorkflowRuntime workflowRuntime)
{
var newActors = workflowRuntime.GetAllActorsForDirectCommandTransitions(processId);
var processIdBytes = processId.ToByteArray();
foreach (var newActor in newActors)
{
var newInboxItem = new WorkflowInbox()
{
Id = Guid.NewGuid().ToByteArray(), IdentityId = newActor, ProcessId = processIdBytes
};
_sampleContext.WorkflowInboxes.Add(newInboxItem);
}
_sampleContext.SaveChanges();
}
private async Task ApiRequestAsync(ProcessInstance process, WorkflowRuntime runtime, string parameters, CancellationToken cancellationToken, JObject entity)
{
var source = Util.FindAutoMapExpression(parameters, entity);
if (Util.TryDeserializeObject(source, out ApiRequestDtoInput apiRequestDtoInput))
{
var responce = Helpers.ApiRequestAsync(apiRequestDtoInput, cancellationToken);
var jtokenResult = JsonConvert.DeserializeObject <JToken>(await responce);
entity.Add(apiRequestDtoInput.AttributeSuccessName, jtokenResult);
}
else
{
throw new Exception($"Can not Deserialize or are missed some input parameters");
}
}
/// <summary>
/// 激发事件到一下状态，并获取状态代码
/// </summary>
/// <param name="WfRuntime"></param>
/// <param name="instance"></param>
/// <param name="CurrentStateName"></param>
/// <param name="xml"></param>
/// <returns></returns>
public static string GetNextStateByEvent(WorkflowRuntime WfRuntime, WorkflowInstance instance, string CurrentStateName, string xml)
{
try
{
if (!WfRuntime.IsStarted)
{
WfRuntime.StartRuntime();
}
WfRuntime.WorkflowCompleted += delegate(object sender, WorkflowCompletedEventArgs e)
{
instance = null;
};
StateMachineWorkflowInstance workflowinstance = new StateMachineWorkflowInstance(WfRuntime, instance.InstanceId);
ManualWorkflowSchedulerService scheduleService = WfRuntime.GetService(typeof(ManualWorkflowSchedulerService)) as ManualWorkflowSchedulerService;
scheduleService.RunWorkflow(workflowinstance.InstanceId);
workflowinstance.SetState(CurrentStateName);
FlowDataType.FlowData FlowData = new FlowDataType.FlowData();
FlowData.xml = xml;
scheduleService.RunWorkflow(instance.InstanceId);
WfRuntime.GetService <FlowEvent>().OnDoFlow(instance.InstanceId, FlowData);//激发流程引擎流转到下一状态
scheduleService.RunWorkflow(instance.InstanceId);
//while (true)
//{
// string stateName = workflowinstance.CurrentStateName;
// if (stateName != null && stateName.ToUpper().IndexOf("START") == -1)
// {
// break;
// }
//}
//System.Threading.Thread.Sleep(1000);
if (instance == null)
{
return("EndFlow");
}
StateMachineWorkflowInstance workflowinstance1 = new StateMachineWorkflowInstance(WfRuntime, instance.InstanceId);
return(workflowinstance1.CurrentStateName);
//return GetNextState(WfRuntime, instance, CurrentStateName);
}
catch (Exception ex)
{
LogHelper.WriteLog("GetNextStateByEvent异常信息 ：" + ex.ToString());
throw new Exception(ex.Message);
}
}
static void Main()
{
// Create WorkflowRuntime
using (WorkflowRuntime workflowRuntime = new WorkflowRuntime())
{
try
{
// Add SqlTrackingService
SqlTrackingService sqlTrackingService = new SqlTrackingService(connectionString);
sqlTrackingService.IsTransactional = false;
workflowRuntime.AddService(sqlTrackingService);
// Subscribe to Workflow Suspended WorkflowRuntime Event
workflowRuntime.WorkflowSuspended += OnWorkflowSuspended;
// Subscribe to Workflow Terminated WorkflowRuntime Event
workflowRuntime.WorkflowTerminated += OnWorkflowTerminated;
// Start WorkflowRuntime
workflowRuntime.StartRuntime();
// Execute the ExceptionWorkflow Workflow
WriteTitle("Executing the exception workflow");
WorkflowInstance exceptionWorkflowInstance = workflowRuntime.CreateWorkflow(typeof(ExceptionWorkflow));
exceptionWorkflowInstance.Start();
waitHandle.WaitOne();
QueryAndWriteTrackingInformationToConsole(exceptionWorkflowInstance.InstanceId, TrackingWorkflowEvent.Exception);
QueryAndWriteTrackingInformationToConsole(exceptionWorkflowInstance.InstanceId, TrackingWorkflowEvent.Terminated);
// Execute the SuspendedWorkflow Workflow
WriteTitle("Executing the suspended workflow");
WorkflowInstance suspendedWorkflowInstance = workflowRuntime.CreateWorkflow(typeof(SuspendedWorkflow));
suspendedWorkflowInstance.Start();
waitHandle.WaitOne();
QueryAndWriteTrackingInformationToConsole(suspendedWorkflowInstance.InstanceId, TrackingWorkflowEvent.Suspended);
// Stop Runtime
workflowRuntime.StopRuntime();
}
catch (Exception e)
{
Console.WriteLine("Encountered an exception. Exception Source: {0}, Exception Message: {1} ", e.Source, e.Message);
}
finally
{
workflowRuntime.StopRuntime();
}
}
}
/// <summary>
/// Stops this instance.
/// </summary>
public static void StopRuntime()
{
if (WorkflowRuntime != null)
{
WorkflowRuntime.StopRuntime();
WorkflowRuntime.WorkflowCompleted -= new EventHandler <WorkflowCompletedEventArgs>(WorkflowRuntime_WorkflowCompleted);
WorkflowRuntime.WorkflowTerminated -= new EventHandler <WorkflowTerminatedEventArgs>(WorkflowRuntime_WorkflowTerminated);
WorkflowRuntime.WorkflowSuspended -= new EventHandler <WorkflowSuspendedEventArgs>(WorkflowRuntime_WorkflowSuspended);
WorkflowRuntime.WorkflowResumed -= new EventHandler <WorkflowEventArgs>(WorkflowRuntime_WorkflowResumed);
WorkflowRuntime.Dispose();
WorkflowRuntime = null;
}
}
public static ApprovalHistoryItem FromDB(WorkflowRuntime runtime, WorkflowApprovalHistory historyItem)
{
return(new ApprovalHistoryItem()
{
Id = historyItem.Id,
ProcessId = historyItem.ProcessId,
IdentityId = historyItem.IdentityId,
AllowedTo = HelperParser.SplitWithTrim(historyItem.AllowedTo, ","),
TransitionTime = runtime.ToRuntimeTime(historyItem.TransitionTime),
Sort = historyItem.Sort,
InitialState = historyItem.InitialState,
DestinationState = historyItem.DestinationState,
TriggerName = historyItem.TriggerName,
Commentary = historyItem.Commentary,
});
}
void IExtension <ServiceHostBase> .Attach(ServiceHostBase owner)
{
// When this Extension is attached within the Service Host, create a
// new instance of the WorkflowServiceContainer
workflowRuntime = new WorkflowRuntime(workflowServicesConfig);
workflowRuntime.ServicesExceptionNotHandled +=
new EventHandler <ServicesExceptionNotHandledEventArgs>(
workflowRuntime_ServicesExceptionNotHandled);
ExternalDataExchangeService exSvc = new ExternalDataExchangeService();
workflowRuntime.AddService(exSvc);
// Start the services associated with the container
workflowRuntime.StartRuntime();
}
//
// IsOwner
//
public IEnumerable <string> ProjectOwnerGet(ProcessInstance processInstance, WorkflowRuntime runtime, string parameter)
{
using (var scope = ServiceProvider.CreateScope())
{
var productRepository = scope.ServiceProvider.GetRequiredService <IJobRepository <Product, Guid> >();
var product = productRepository.Get()
.Where(p => p.Id == processInstance.ProcessId)
.Include(p => p.Project)
.ThenInclude(p => p.Owner)
.FirstOrDefault();
var workflowUserId = product?.Project.Owner.WorkflowUserId;
return(workflowUserId.HasValue ? new List <string> {
workflowUserId.Value.ToString()
} : new List <string>());
}
}
static void Main(string[] args)
{
WorkflowRuntime workflowRuntime = new WorkflowRuntime();
AutoResetEvent waitHandle = new AutoResetEvent(false);
workflowRuntime.WorkflowCompleted += delegate(object sender, WorkflowCompletedEventArgs e) { waitHandle.Set(); };
workflowRuntime.WorkflowTerminated += OnWorkflowTerminated;
workflowRuntime.WorkflowSuspended += OnWorkflowSuspended;
WorkflowInstance instance = workflowRuntime.CreateWorkflow(typeof(CDelaySuspendTerminateSequential.Workflow1));
instance.Start();
waitHandle.WaitOne();
}
public void RunningSimpleWorkflow()
{
WorkflowRuntime runtime = _container.Resolve <WorkflowRuntime>();
ManualResetEvent finished = new ManualResetEvent(false);
runtime.WorkflowCompleted += delegate(object sender, WorkflowCompletedEventArgs e) { finished.Set(); };
runtime.WorkflowTerminated += delegate(object sender, WorkflowTerminatedEventArgs e) { finished.Set(); };
WorkflowInstance workflow = runtime.CreateWorkflow(typeof(SimpleWorkflow));
workflow.Start();
bool isFinished = finished.WaitOne(TimeSpan.FromSeconds(1), false);
Assert.IsTrue(isFinished, "Workflow must finish in less than a second");
}
public static Activity Create()
{
var openSesameProgram = new Sequence();
var printKey = new PrintKey();
var read = new ReadLine();
var printGreeting = new PrintGreeting();
WorkflowRuntime.Bind(printKey.Key, printGreeting.Key);
WorkflowRuntime.Bind(read.Text, printGreeting.Input);
openSesameProgram.Add(printKey);
openSesameProgram.Add(read);
openSesameProgram.Add(printGreeting);
return(openSesameProgram);
}
private void SetEntityAttribute(ProcessInstance process, WorkflowRuntime runtime, string parameters, JObject entity)
{
var source = Util.FindAutoMapExpression(parameters, entity);
if (Util.TryDeserializeObject(source, out ApiRequestDtoInput apiRequestDtoInput))
{
apiRequestDtoInput.UrlAddress = apiRequestDtoInput.UrlAddress + EngineConstants.SetEntityAttributeEndpoint;
var responce = Helpers.ApiRequest(apiRequestDtoInput);
var jtokenResult = JsonConvert.DeserializeObject <JToken>(responce);
entity.Add(apiRequestDtoInput.AttributeSuccessName, jtokenResult);
}
else
{
throw new Exception($"Can not Deserialize or are missed some input parameters");
}
}
public WorkflowProductService(
IJobRepository <Product, Guid> productRepository,
IJobRepository <UserTask> taskRepository,
IJobRepository <User> userRepository,
IJobRepository <ProductTransition> productTransitionRepository,
SendNotificationService sendNotificationService,
WorkflowRuntime runtime
)
{
ProductRepository = productRepository;
TaskRepository = taskRepository;
UserRepository = userRepository;
ProductTransitionRepository = productTransitionRepository;
SendNotificationService = sendNotificationService;
Runtime = runtime;
}
public static WorkflowRuntime CreateDefaultRuntime()
{
WorkflowRuntime workflowRuntime = new WorkflowRuntime();
var manualService = new ManualWorkflowSchedulerService();
workflowRuntime.AddService(manualService);
var syncCallService = new Activities.CallWorkflowService();
workflowRuntime.AddService(syncCallService);
workflowRuntime.StartRuntime();
return(workflowRuntime);
}
public void ComponentsProvidedByConfiguration()
{
WorkflowRuntime runtime = _container.Resolve <WorkflowRuntime>();
WorkflowInstance instance = runtime.CreateWorkflow(typeof(CreateNameWorkflow));
instance.Start();
ManualWorkflowSchedulerService scheduler = _container.Resolve <ManualWorkflowSchedulerService>();
scheduler.RunWorkflow(instance.InstanceId);
TestingExternalData testingExternalData = (TestingExternalData)_container.Resolve <ITestingExternalData>();
Assert.AreEqual("You are \"{0} {1}\".", testingExternalData.FullNameFormat, "Format must have been provided by config");
Assert.AreEqual("You are \"hello world\".", testingExternalData.MostRecentFullName, "Full name must have been set by workflow execution");
}
public Register()
{
InitializeComponent();
// Get Connection Strings from Application Settings
Properties.Settings settings = Properties.Settings.Default;
registrationConnectionString = settings.ClassRegistrationConnectionString;
trackingConnectionString = settings.ClassRegistrationTrackingConnectionString;
// Get workflow runtime from application object
workflowRuntime = Application.Current.Properties["WorkflowRuntime"] as WorkflowRuntime;
if (workflowRuntime == null)
{
InitializeWorkflowRuntime();
}
}
static void Main()
{
try
{
// Create the WorkflowRuntime
using (WorkflowRuntime workflowRuntime = new WorkflowRuntime())
{
// Add the SqlWorkflowPersistenceService service
WorkflowPersistenceService persistenceService =
new SqlWorkflowPersistenceService(
"Initial Catalog=SqlPersistenceService;Data Source=localhost;Integrated Security=SSPI;",
false,
new TimeSpan(1, 0, 0),
new TimeSpan(0, 0, 5));
workflowRuntime.AddService(persistenceService);
// Set up the WorkflowRuntime event handlers
workflowRuntime.WorkflowCompleted += OnWorkflowCompleted;
workflowRuntime.WorkflowIdled += OnWorkflowIdled;
workflowRuntime.WorkflowPersisted += OnWorkflowPersisted;
workflowRuntime.WorkflowUnloaded += OnWorkflowUnloaded;
workflowRuntime.WorkflowLoaded += OnWorkflowLoaded;
workflowRuntime.WorkflowTerminated += OnWorkflowTerminated;
workflowRuntime.WorkflowAborted += OnWorkflowAborted;
// Load the workflow type
Type type = typeof(PersistenceServicesWorkflow);
// Create an instance of the workflow
Console.WriteLine("Workflow Started.");
workflowRuntime.CreateWorkflow(type).Start();
// Wait for the event to be signaled
waitHandle.WaitOne();
// Stop the runtime
workflowRuntime.StopRuntime();
Console.WriteLine("Program Complete.");
}
}
catch (Exception exception)
{
Console.WriteLine("Application exception occurred: " + exception.Message);
}
}
static void Main(string[] args)
{
try
{
// The program passes the one and only argument into the workflow
// as the order amount.
if (args.Length < 1)
{
Console.WriteLine("Usage: SequentialWorkflowWithParameters [amount]");
return;
}
// Create the WorkflowRuntime
using (WorkflowRuntime workflowRuntime = new WorkflowRuntime())
{
Console.WriteLine("Runtime Started.");
// Listen for the workflow events
workflowRuntime.WorkflowCompleted += OnWorkflowCompleted;
workflowRuntime.WorkflowTerminated += OnWorkflowTerminated;
// Set up the parameters
// "amount" is an "in" parameter and specifies the order amount.
// If the amount is < 500 the status is "approved"; "rejected" otherwise.
Dictionary <string, object> parameters = new Dictionary <string, object>();
parameters.Add("Amount", Convert.ToInt32(args[0], CultureInfo.InvariantCulture));
// Get the workflow type
Type type = typeof(SequentialWorkflow);
// Create and start an instance of the workflow
workflowRuntime.CreateWorkflow(type, parameters).Start();
Console.WriteLine("Workflow Started.");
// Wait for the event to be signaled
waitHandle.WaitOne();
workflowRuntime.StopRuntime();
Console.WriteLine("Program Complete.");
}
}
catch (Exception exception)
{
Console.WriteLine("Exception occurred: " + exception.Message);
}
}
static void Main()
{
using (WorkflowRuntime workflowRuntime = new WorkflowRuntime())
{
workflowRuntime.StartRuntime();
workflowRuntime.WorkflowCompleted += OnWorkflowCompleted;
workflowRuntime.WorkflowTerminated += OnWorkflowTerminated;
Type type = typeof(SendEmailWorkflow);
workflowRuntime.CreateWorkflow(type).Start();
waitHandle.WaitOne();
workflowRuntime.StopRuntime();
}
}
public void ServicesAreUsedByWorkflows()
{
_container.AddComponent("explodingtracking.service", typeof(ExplodingTrackingService));
WorkflowRuntime runtime = _container.Resolve <WorkflowRuntime>();
ManualResetEvent finished = new ManualResetEvent(false);
runtime.WorkflowCompleted += delegate(object sender, WorkflowCompletedEventArgs e) { finished.Set(); };
runtime.WorkflowTerminated += delegate(object sender, WorkflowTerminatedEventArgs e) { finished.Set(); };
WorkflowInstance workflow = runtime.CreateWorkflow(typeof(SimpleWorkflow));
workflow.Start();
bool isFinished = finished.WaitOne(TimeSpan.FromSeconds(1), false);
}
public void CreateGetWorkflow()
{
Guid guid1 = Guid.NewGuid();
Guid guid2 = Guid.NewGuid();
WorkflowRuntime wr = new WorkflowRuntime();
Assert.AreEqual(false, wr.IsStarted, "C1#1");
WorkflowInstance wi1 = wr.CreateWorkflow(typeof(SequentialWorkflowActivity), null, guid1);
Assert.AreEqual(wi1.InstanceId, guid1, "C1#2");
Assert.AreEqual(true, wr.IsStarted, "C1#3");
WorkflowInstance wi2 = wr.CreateWorkflow(typeof(SequenceActivity), null, guid2);
Assert.AreEqual(wi2.InstanceId, guid2, "C1#4");
}
/// <summary>
/// 建立虚拟流程实例
/// </summary>
/// <param name="WfRuntime"></param>
/// <param name="xmlFileName"></param>
/// <returns></returns>
public static WorkflowInstance CreateWorkflowInstance(WorkflowRuntime WfRuntime, string xmlFileName)
{
try
{
WorkflowInstance instance;
string Xml = AppDomain.CurrentDomain.BaseDirectory + "\\" + xmlFileName;
XmlReader reader = XmlReader.Create(Xml);
instance = WfRuntime.CreateWorkflow(reader);
instance.Start();
return(instance);
}
catch (Exception ex)
{
LogHelper.WriteLog("CreateWorkflowInstance异常信息 ：" + ex.ToString());
throw new Exception(ex.Message);
}
}
private void DoInitialize(int delayedTime)
{
if (_workflowRuntime != null)
{
return;
}
using (GlobalInitializerFacade.CoreNotLockedScope)
using (_resourceLocker.Locker)
{
if (_workflowRuntime != null)
{
return;
}
Log.LogVerbose(LogTitleColored, "----------========== Initializing Workflows (Delayed: {0}) ==========----------", delayedTime);
int startTime = Environment.TickCount;
_resourceLocker.ResetInitialization();
_workflowRuntime = InitializeWorkflowRuntime();
InitializeFormsWorkflowRuntime();
if (!_workflowRuntime.IsStarted)
{
_workflowRuntime.StartRuntime();
}
DeleteOldWorkflows();
_fileWorkflowPersistenceService.ListenToDynamicallyAddedWorkflows(OnNewWorkflowFileAdded);
LoadPersistedWorkflows();
LoadPersistedFormData();
int endTime = Environment.TickCount;
Log.LogVerbose(LogTitleColored, "----------========== Done initializing Workflows ({0} ms ) ==========----------", endTime - startTime);
foreach (Action action in _actionToRunWhenInitialized)
{
action();
}
}
}
public override void ExecuteUnderTransaction(JobExecutionContext context)
{
logger.Info("Start ChargingOrderJob....");
var paymentUrlProvider = context.JobDetail.JobDataMap["PaymentUrlProvider"].ToString();
var backupPaymentUrlProvider = context.JobDetail.JobDataMap["BackupPaymentUrlProvider"].ToString();
var orderService = (IOrderService)ServiceLocator.Current.GetService(typeof(IOrderService));
if (orderService == null)
{
throw new NullReferenceException("orderService must not be null");
}
var orders = orderService.GetOrdersByStatus(OrderStatusEnum.Verified);
using (var workflowRuntime = new WorkflowRuntime())
{
workflowRuntime.AddService(new TerminateHelperService());
using (var manager = new WorkflowRuntimeManager(workflowRuntime))
{
manager.MessageEvent += manager_MessageEvent;
for (var i = 0; i < orders.Count; i++)
{
var wfArguments = new Dictionary <string, object> {
{ "OrderId", orders[i].Id },
{ "PaymentProviderUrl", paymentUrlProvider },
{ "BackupPaymentProviderUrl", backupPaymentUrlProvider }
};
var wrapper = manager.StartWorkflow(typeof(ChargingOrderWorkflow), wfArguments);
var testWait = manager.WaitOne(wrapper.Id, 30000);
if (wrapper.Exception != null)
{
logger.Error(wrapper.Exception.Message);
}
}
manager.WaitAll(300000);
manager.ClearAllWorkflows();
}
}
}
