public void Run()
{
wfHostTypeName = XName.Get("Version" + Guid.NewGuid().ToString(),
typeof(Workflow1).FullName);
this.instanceStore = SetupSqlpersistenceStore();
this.instanceHandle = CreateInstanceStoreOwnerHandle(
instanceStore, wfHostTypeName);
WorkflowApplication wfApp = CreateWorkflowApp();
wfApp.Run();
while (true)
{
this.waitHandler.WaitOne();
if (completed)
{
break;
}
WaitForRunnableInstance(this.instanceHandle);
wfApp = CreateWorkflowApp();
try
{
wfApp.LoadRunnableInstance();
waitHandler.Reset();
wfApp.Run();
}
catch (InstanceNotReadyException)
{
Console.WriteLine("Handled expected InstanceNotReadyException, retrying...");
}
}
Console.WriteLine("workflow completed.");
}
static void Main(string[] args)
{
InstanceStore store = CreateInstanceStore();
WorkflowApplication wfApp = SetupInstance(store);
Guid instanceId = wfApp.Id;
wfApp.Run();
//wait for the wf to unload itself
unloadedHandle.WaitOne(5000);
Thread.Sleep(1000);
wfApp = SetupInstance(store);
wfApp.Load(instanceId);
wfApp.Run();
//wait for the wf to unload itself
unloadedHandle.WaitOne(5000);
Thread.Sleep(1000);
wfApp = SetupInstance(store);
wfApp.Load(instanceId);
wfApp.Run();
//wait for the wf to unload itself
unloadedHandle.WaitOne(5000);
Thread.Sleep(5000);
wfApp = SetupInstance(store);
wfApp.Load(instanceId);
wfApp.Run();
waitHandle.WaitOne(10000);
}
static void Main(string[] args)
{
SqlWorkflowInstanceStore store = new SqlWorkflowInstanceStore(persistenceConn);
// Create a unique name that is used to associate instances in the instance store hosts that can load them. This is needed to prevent a Workflow host from loading
// instances that have different implementations. The unique name should change whenever the implementation of the workflow changes to prevent workflow load exceptions.
// For the purposes of the demo we create a unique name every time the program is run.
XName wfHostTypeName = XName.Get("Version" + Guid.NewGuid().ToString(), typeof(Workflow1).FullName);
// Create an InstanceStore owner that is associated with the workflow type
InstanceHandle ownerHandle = CreateInstanceStoreOwner(store, wfHostTypeName);
// Create a WorkflowApplication instance to start a new workflow
WorkflowApplication wfApp = CreateWorkflowApplication(new Workflow1(), store, wfHostTypeName);
// This will create the workflow and execute it until the delay is executed, the workflow goes idle, and is unloaded
wfApp.Run();
// This loop handles re-loading workflows that have been unloaded due to durable timers
while (true)
{
// Wait for workflow to unload
workflowUnloadedEvent.WaitOne();
// Break the loop once the workflow has completed
if (workflowCompleted)
{
break;
}
// Wait for a timer registered by the delay to expire and the workflow instance to become "runnable" again
WaitForRunnableInstance(store, ownerHandle);
// Create a new WorkflowApplication instance to host the re-loaded workflow
wfApp = CreateWorkflowApplication(new Workflow1(), store, wfHostTypeName);
try
{
// Re-load the runnable workflow instance and run it
wfApp.LoadRunnableInstance();
workflowUnloadedEvent.Reset();
wfApp.Run();
}
catch (InstanceNotReadyException)
{
Console.WriteLine("Handled expected InstanceNotReadyException, retrying...");
}
}
Console.WriteLine("Sample finished, hit enter to close");
Console.ReadLine();
}
public bool LoadAndRun(Guid id)
{
var app2 = new WorkflowApplication(new WaitForSignalOrDelayWorkflow())
{
Completed = e =>
{
if (e.CompletionState == ActivityInstanceState.Closed)
{
System.Runtime.Caching.MemoryCache.Default.Add(id.ToString(), e.Outputs, DateTimeOffset.MaxValue);//Save outputs at the end of the workflow.
}
},
Unloaded = e =>
{
System.Diagnostics.Debug.WriteLine("Unloaded in LoadAndRun.");
},
InstanceStore = WFDefinitionStore.Instance.Store,
};
try
{
app2.Load(id);
app2.Run();
}
catch (System.Runtime.DurableInstancing.InstanceNotReadyException ex)
{
System.Diagnostics.Trace.TraceWarning(ex.Message);
return(false);
}
System.Runtime.Caching.MemoryCache.Default.Add(id.ToString() + "Instance", app2, DateTimeOffset.MaxValue);//Keep the reference to a running instance
return(true);
}
static void Main(string[] args)
{
Console.WriteLine("***** Welcome to this amazing WF application *****");
// Get data from user, to pass to workflow.
Console.Write("Please enter the data to pass the workflow: ");
string wfData = Console.ReadLine();
// Package up the data as a dictionary.
Dictionary <string, object> wfArgs = new Dictionary <string, object>();
wfArgs.Add("MessageToShow", wfData);
AutoResetEvent waitHandle = new AutoResetEvent(false);
// Pass to the workflow.
WorkflowApplication app = new WorkflowApplication(new Workflow1(), wfArgs);
// Hook up an event with this app.
app.Completed = (completedArgs) => {
waitHandle.Set();
Console.WriteLine("The workflow is done!");
};
// Start the workflow!
app.Run();
// Wait until we are notified the workflow is done.
waitHandle.WaitOne();
Console.WriteLine("Thanks for playing");
}
public void Run()
{
Guid id;
Guid.TryParse(DataTransferObject.ParentInstanceID, out id);
ID = DataTransferObject.ResourceID;
ParentID = DataTransferObject.ParentID;
WorkspaceID = DataTransferObject.WorkspaceID;
// handle queuing
WaitForSlot();
// abort the execution - no space at the inn
if (!ExecutableServiceRepository.Instance.DoesQueueHaveSpace())
{
_instance.Abort();
}
else
{
ExecutableServiceRepository.Instance.Add(this);
// here is space at the inn ;)
var wfappUtils = new WfApplicationUtils();
if (DataTransferObject.IsDebugMode())
{
ErrorResultTO invokeErrors;
wfappUtils.DispatchDebugState(DataTransferObject, StateType.Start, AllErrors.HasErrors(), AllErrors.MakeDisplayReady(), out invokeErrors, null, true);
AllErrors.MergeErrors(invokeErrors);
}
_previousNumberOfSteps = DataTransferObject.NumberOfSteps;
DataTransferObject.NumberOfSteps = 0;
_instance.Run();
}
}
static void Main(string[] args)
{
Console.WriteLine("Press [ENTER] to start the client once the service is running.");
Console.ReadLine();
Console.WriteLine("Starting the client");
Console.WriteLine();
//Start the client
AutoResetEvent syncEvent = new AutoResetEvent(false);
WorkflowApplication app = new WorkflowApplication(ClientWorkflow());
app.Completed = delegate(WorkflowApplicationCompletedEventArgs e)
{
Console.WriteLine("Completed");
syncEvent.Set();
};
app.Aborted = delegate(WorkflowApplicationAbortedEventArgs e)
{
Console.WriteLine("Aborted");
syncEvent.Set();
};
app.OnUnhandledException = delegate(WorkflowApplicationUnhandledExceptionEventArgs e)
{
Console.WriteLine("UnhandledException: " + e.UnhandledException);
return(UnhandledExceptionAction.Abort);
};
app.Run();
syncEvent.WaitOne();
Console.WriteLine("Press [ENTER] to exit");
Console.ReadLine();
}
/// <summary>
/// 创建工作流
/// </summary>
/// <param name="flow"></param>
/// <returns></returns>
public static Guid CreateWorkflow(string OrderOID)
{
InstanceHandle instanceHandle = InstanceStoreObj.CreateInstanceHandle();
InstanceView view = InstanceStoreObj.Execute(instanceHandle, new CreateWorkflowOwnerCommand(), TimeSpan.FromSeconds(30));
InstanceStoreObj.DefaultInstanceOwner = view.InstanceOwner;
IDictionary <string, object> input = new Dictionary <string, object>
{
{ "OrderOID", OrderOID }
};
//WorkflowApplication application = new WorkflowApplication(new AuthFlow(),input);
WorkflowApplication application = new WorkflowApplication(new WorkflowService.OrderFlow.OrderFlow(), input);
application.InstanceStore = InstanceStoreObj;
application.PersistableIdle = (e) =>
{
return(PersistableIdleAction.Unload);
};
application.Unloaded = (e) =>
{
//PersistableIdleAction.Unload;
};
application.Run();
var deleteOwnerCmd = new DeleteWorkflowOwnerCommand();
//InstanceStoreObj.Execute(instanceHandle, deleteOwnerCmd, TimeSpan.FromSeconds(30));
InstanceStoreObj = null;
return(application.Id);
}
private static void Main()
{
// Получить от пользователя данные для передачи рабочему потоку
Console.Write("Please enter the data to pass the workflow: ");
var wfData = Console.ReadLine();
// Упаковать данные в словарь
var wfArgs = new Dictionary <string, object> {
{ "MessageToShow", wfData }
};
// Использовать для информирования первичного потока о необходимости ожидания
var waitHandle = new AutoResetEvent(false);
// Передать словарь рабочему потоку
Activity activity = new FirstWorkflow();
var wfApp = new WorkflowApplication(activity, wfArgs)
{
Completed = args =>
{
waitHandle.Set();
Console.WriteLine("The workflow is done!");
}
};
// Запустить рабочий поток
wfApp.Run();
// Ждем сигнал о завершении
waitHandle.WaitOne();
Console.WriteLine("Exit");
}
static void Run()
{
AutoResetEvent applicationUnloaded = new AutoResetEvent(false);
WorkflowApplication application = new WorkflowApplication(workflow);
application.InstanceStore = instanceStore;
SetupApplication(application, applicationUnloaded);
StepCountExtension stepCountExtension = new StepCountExtension();
application.Extensions.Add(stepCountExtension);
application.Run();
Guid id = application.Id;
applicationUnloaded.WaitOne();
while (stepCountExtension.CurrentCount < totalSteps)
{
application = new WorkflowApplication(workflow);
application.InstanceStore = instanceStore;
SetupApplication(application, applicationUnloaded);
stepCountExtension = new StepCountExtension();
application.Extensions.Add(stepCountExtension);
application.Load(id);
string input = Console.ReadLine();
application.ResumeBookmark(echoPromptBookmark, input);
applicationUnloaded.WaitOne();
}
}
public static IDictionary <string, object> RunWorkflow(WorkflowApplication instance)
{
ManualResetEvent mre = new ManualResetEvent(false);
Exception workflowException = null;
IDictionary <string, object> outputs = null;
instance.Completed = delegate(WorkflowApplicationCompletedEventArgs e)
{
if (e.TerminationException != null)
{
workflowException = e.TerminationException;
}
outputs = e.Outputs;
mre.Set();
};
instance.Run();
mre.WaitOne();
if (workflowException != null)
{
throw workflowException;
}
return(outputs);
}
static void Main(string[] args)
{
var connStr = @"Data Source=.\sqlexpress;Initial Catalog=WorkflowInstanceStore;Integrated Security=True;Pooling=False";
SqlWorkflowInstanceStore instanceStore = new SqlWorkflowInstanceStore(connStr);
Workflow1 w = new Workflow1();
//instanceStore.
//IDictionary<string, object> xx=WorkflowInvoker.Invoke(new Workflow1());
//ICollection<string> keys=xx.Keys;
WorkflowApplication a = new WorkflowApplication(w);
a.InstanceStore = instanceStore;
a.GetBookmarks();
//a.ResumeBookmark("Final State", new object());
a.Run();
//a.ResumeBookmark(
//a.Persist();
//a.Unload();
//Guid id = a.Id;
//WorkflowApplication b = new WorkflowApplication(w);
//b.InstanceStore = instanceStore;
//b.Load(id);
//WorkflowApplication a=new WorkflowApplication(
}
public void EmbraceWithCustomSequence()
{
int result = 0;
// Definition der Ausführung
CustomSequence activity = new CustomSequence()
{
Activities =
{
new SayHelloActivity()
{
Message = "Ausführung in einer kombinierten Sequenz"
}
}
};
WorkflowApplication workflowApplication = new WorkflowApplication(activity);
ManualResetEvent workflowDone = new ManualResetEvent(false);
workflowApplication.Completed += delegate(WorkflowApplicationCompletedEventArgs args)
{
workflowDone.Set();
};
workflowApplication.Aborted += delegate(WorkflowApplicationAbortedEventArgs args)
{
workflowDone.Set();
};
// Ausführen und warten
workflowApplication.Run();
workflowDone.WaitOne();
}
static void Main()
{
bool completed = false;
AutoResetEvent idleOrCompletedEvent = new AutoResetEvent(false);
Activity workflow = CreateWorkflow();
WorkflowApplication application = new WorkflowApplication(workflow);
application.Idle += delegate(WorkflowApplicationIdleEventArgs e)
{
idleOrCompletedEvent.Set();
};
application.Completed += delegate(WorkflowApplicationCompletedEventArgs e)
{
completed = true;
idleOrCompletedEvent.Set();
};
application.Run();
while (true)
{
idleOrCompletedEvent.WaitOne();
if (!completed)
{
Interact(application);
}
else
{
break;
}
}
}
public static void Main(string[] args)
{
application = new WorkflowApplication(CreateWF());
// Notify when the workflow completes.
ManualResetEvent completedEvent = new ManualResetEvent(false);
application.Completed += delegate(WorkflowApplicationCompletedEventArgs e)
{
completedEvent.Set();
};
// Run the workflow.
application.Run();
// Get user input from the console and send it to the workflow instance.
// This is done in a separate thread in order to not block current execution.
ThreadPool.QueueUserWorkItem(ReadName);
// Wait until the workflow completes.
completedEvent.WaitOne();
Console.WriteLine("Workflow completed. Waiting 10 seconds before exiting...");
Thread.Sleep(10000);
}
// resume execution of a workflow instance
static void RunWorkflow(WorkflowApplication application, AutoResetEvent resetEvent)
{
application.Completed = delegate(WorkflowApplicationCompletedEventArgs e)
{
Console.WriteLine("Workflow completed in state " + e.CompletionState);
if (e.TerminationException != null)
{
Console.WriteLine("Termination exception: " + e.TerminationException);
}
Console.WriteLine("-------------------------------");
Console.WriteLine("- Input has been written to {0}\\out.txt", Environment.CurrentDirectory);
Console.WriteLine("-------------------------------");
resetEvent.Set();
};
application.Unloaded = delegate(WorkflowApplicationEventArgs e)
{
Console.WriteLine("Workflow unloaded");
resetEvent.Set();
};
application.Run();
}
object GenericInvoke(params object[] args)
{
if (args.Length != this.parameters.Length)
{
throw new ArgumentException("Wrong number of arguments");
}
SymbolResolver symbolResolver = environmentProvider();
for (int i = 0; i < this.parameters.Length; i++)
{
ParameterInfo parameter = this.parameters[i];
if (!parameter.IsOut)
{
symbolResolver.Add(parameter.Name, args[i]);
}
}
if (this.returnType != typeof(void))
{
symbolResolver.Add(Argument.ResultValue, new ValueHolder <object>());
}
WorkflowApplication application = new WorkflowApplication(this.Activity, new Dictionary <string, object>());
application.SynchronizationContext = SynchronizationContext.Current;
application.Extensions.Add(symbolResolver);
application.Completed = OnWorkflowCompleted;
application.Aborted = OnWorkflowAborted;
application.Run();
return(null);
}
public Guid Run(Activity activity, IDictionary <string, object> args = null)
{
var unloadedSignal = new AutoResetEvent(false);
var app = new WorkflowApplication(activity, args ?? new Dictionary <string, object>())
{
InstanceStore = _store,
PersistableIdle = eventArgs => PersistableIdleAction.Unload,
Aborted = obj =>
{
unloadedSignal.Set();
Trace.TraceError("abort");
},
OnUnhandledException = (a) =>
{
Trace.TraceError($"exception:{a.UnhandledException.Message}");
return(UnhandledExceptionAction.Cancel);
},
Unloaded = a => unloadedSignal.Set(),
};
app.Run();
unloadedSignal.WaitOne();
return(app.Id);
}
// creates a workflow application, binds parameters, links extensions and run it
public WorkflowApplication CreateAndRun(RequestForProposal rfp)
{
// input parameters for the WF program
IDictionary <string, object> inputs = new Dictionary <string, object>();
inputs.Add("Rfp", rfp);
// create and run the WF instance
Activity wf = new PurchaseProcessWorkflow();
WorkflowApplication instance = new WorkflowApplication(wf, inputs)
{
PersistableIdle = OnIdleAndPersistable,
Completed = OnWorkflowCompleted,
Idle = OnIdle
};
XmlWorkflowInstanceStore store = new XmlWorkflowInstanceStore(instance.Id);
instance.InstanceStore = store;
//Create the persistence Participant and add it to the workflow instance
XmlPersistenceParticipant xmlPersistenceParticipant = new XmlPersistenceParticipant(instance.Id);
instance.Extensions.Add(xmlPersistenceParticipant);
// add a tracking participant
instance.Extensions.Add(new SaveAllEventsToTestFileTrackingParticipant());
// add instance to the host list of running instances
this.instances.Add(instance.Id, instance);
// continue executing this instance
instance.Run();
return(instance);
}
protected override void StartInternal()
{
DynamicActivity activity;
using (var stream = new MemoryStream(Encoding.Default.GetBytes(WorkflowDesigner.Text)))
{
activity = ActivityXamlServices.Load(stream) as DynamicActivity;
}
if (activity == null)
{
return;
}
WorkflowInspectionServices.CacheMetadata(activity);
workflowApplication = new WorkflowApplication(activity);
workflowApplication.Extensions.Add(OutputWriter);
workflowApplication.Extensions.Add(InitialiseVisualTrackingParticipant(activity));
workflowApplication.Completed += Completed;
workflowApplication.OnUnhandledException += OnUnhandledException;
workflowApplication.Aborted += Aborted;
try
{
workflowApplication.Run();
OnRunningStateChanged(new WorkflowExecutingStateEventArgs(true));
}
catch (Exception e)
{
OutputWriter.WriteLine(e.StackTrace);
}
}
public void SetParametersToNull()
{
string wfName = "TerminatingWorkflow";
string exceptionMessage = string.Format(ErrorStrings.OneOfTwoPropertiesMustBeSet, "Reason", "Exception", "TerminateWorkflow", wfName);
try
{
TerminateWorkflow terminate = new TerminateWorkflow()
{
DisplayName = wfName,
Exception = null,
Reason = null
};
WorkflowApplication instance = new WorkflowApplication(terminate);
instance.Run();
}
catch (Exception e)
{
if (e.GetType() != typeof(InvalidWorkflowException))
{
throw new TestCaseFailedException("Exception is incorrect");
}
}
}
public Boolean Start(ILog data)
{
Variable <ILog> log = new Variable <ILog>("log", data);
this.workflow = new Sequence
{
Activities =
{
new Caller()
{
BookmarkName = "Caller"
},
new NewOpen()
{
BookmarkName = "NewOpen"
},
}
};
WorkflowApplication wfApp = new WorkflowApplication(workflow);
AutoResetEvent idleEvent = new AutoResetEvent(false);
wfApp.Idle = (WorkflowApplicationIdleEventArgs e) => { idleEvent.Set(); };
wfApp.Run();
BookmarkResumptionResult result = wfApp.ResumeBookmark("NewOpen", data);
idleEvent.WaitOne();
return(result == BookmarkResumptionResult.Success);
}
/// <summary>
/// Creates a new Workflow Application instance and executes the Current Workflow
/// </summary>
private void CmdWorkflowRun(object sender, ExecutedRoutedEventArgs e)
{
//get workflow source from designer
CustomWfDesigner.Instance.Flush();
MemoryStream workflowStream = new MemoryStream(ASCIIEncoding.Default.GetBytes(CustomWfDesigner.Instance.Text));
ActivityXamlServicesSettings settings = new ActivityXamlServicesSettings()
{
CompileExpressions = true
};
DynamicActivity activityExecute = ActivityXamlServices.Load(workflowStream, settings) as DynamicActivity;
//configure workflow application
consoleExecutionLog.Text = String.Empty;
consoleOutput.Text = String.Empty;
_executionLog = new CustomTrackingParticipant();
_wfApp = new WorkflowApplication(activityExecute);
_wfApp.Extensions.Add(_executionLog);
_wfApp.Completed = WfExecutionCompleted;
//execute
_wfApp.Run();
//enable timer for real-time logging
_timer.Start();
}
private void StartWorkFlow()
{
WorkflowApplication wfApp = InitiateWorkFlow();
ServiceLocator.Instance.CurrentWorkFlow = wfApp;
Action action = () => StartWorkFlow();
wfApp.Completed = delegate(WorkflowApplicationCompletedEventArgs ev)
{
ReadOutputs(NextWorkFlow, ev);
Dispatcher.Invoke(action); //call startworkflow() through main thread
};
wfApp.Aborted = delegate(WorkflowApplicationAbortedEventArgs ev)
{
NextWorkFlow = "LoginWorkFlow";
Dispatcher.Invoke(action); //call startworkflow() through main thread
};
wfApp.OnUnhandledException = delegate(WorkflowApplicationUnhandledExceptionEventArgs ev)
{
Dispatcher.Invoke(action); //call startworkflow() through main thread
Console.WriteLine(ev.UnhandledException.ToString());
return(UnhandledExceptionAction.Terminate);
};
wfApp.Idle = delegate(WorkflowApplicationIdleEventArgs ev)
{
//nothing. workflow is waiting screen input, service call, or db call
};
wfApp.Run();
}
protected void Button1_Click(object sender, EventArgs e)
{
//设置参数
Dictionary <string, object> para = new Dictionary <string, object>();
CrowdTask task = new CrowdTask(TextBox1.Text, TextBox2.Text);
para.Add("task", task);
//启动工作流
WorkflowApplication crowdsourcing = new WorkflowApplication(new mainTask1(), para);
task.taskType = TaskType.mainTask;
crowdsourcing.Run();
task.taskWorkflowId = crowdsourcing.Id.ToString();
try
{
crowdTaskService = new CrowdTaskService();
int result = crowdTaskService.insert(task);
if (result == 1)
{
//插入成功，保存对应的工作流实例
MyWorkflowInstance.setWorkflowApplication(crowdsourcing.Id.ToString(), crowdsourcing);
crowdTaskService.mainTaskSetCrowdTaskMainTaskIdByWorkflowId(crowdsourcing.Id.ToString());
Server.Transfer("viewMyTask.aspx?workflowId=" + task.taskWorkflowId);
}
}
catch (Exception exception)
{
throw exception;
}
}
public void RunTest()
{
Sequence workflow = new Sequence
{
Activities =
{
new InvokeMyWorkflowExtensionActivity()
}
};
_completedEvent = new AutoResetEvent(false);
MyWorkflowExtension myExtension = new MyWorkflowExtension();
WorkflowApplication wfApp = new WorkflowApplication(workflow);
wfApp.Completed = delegate(WorkflowApplicationCompletedEventArgs e)
{
_terminationException = e.TerminationException;
_completedEvent.Set();
};
wfApp.Extensions.Add(myExtension);
Assert.True(!myExtension.ExtensionMethodInvoked);
wfApp.Run();
_completedEvent.WaitOne(TimeSpan.FromSeconds(2));
Assert.True(myExtension.ExtensionMethodInvoked);
}
private void btnStart_Click(object sender, EventArgs e)
{
SqlWorkflowInstanceStore store = new SqlWorkflowInstanceStore(connectionString);
WorkflowApplication wfApp = new WorkflowApplication(
new StateMoneyActivity1xaml(),
new Dictionary <string, object>()
{
{ "InBookMarkName", this.txtBookMarkName.Text }
});
wfApp.InstanceStore = store;
wfApp.Idle += OnWfAppIdel;
wfApp.OnUnhandledException += OnWfAppException;
wfApp.Unloaded = a => { Console.WriteLine("工作流卸载了..."); };
wfApp.Aborted = a => { Console.WriteLine("Aborted"); };
//启用序列化必须使用此方法。
wfApp.PersistableIdle = a => { return(PersistableIdleAction.Unload); };
wfApp.Run();//启动工作流
this.txtAppId.Text = wfApp.Id.ToString();
WFApp = wfApp;
//wfApp.ResumeBookmark();
}
public Sequential()
{
_completedEvent = new AutoResetEvent(false);
_idleEvent = new AutoResetEvent(false);
_failedEvent = new AutoResetEvent(false);
_wfApp = new WorkflowApplication(new SequentialNumberGuess(),
new Dictionary <string, object>()
{
{ "GuessNumber", ActualGuess }
});
_wfApp.Completed = (WorkflowApplicationCompletedEventArgs e) =>
{
_isComplete = true;
_completedEvent.Set();
};
_wfApp.Aborted = (WorkflowApplicationAbortedEventArgs e) =>
{
_failedEvent.Set();
};
_wfApp.OnUnhandledException = (WorkflowApplicationUnhandledExceptionEventArgs e) =>
{
Console.WriteLine(e.UnhandledException.ToString());
return(UnhandledExceptionAction.Terminate);
};
_wfApp.Idle = (WorkflowApplicationIdleEventArgs e) =>
{
_idleEvent.Set();
};
_wfApp.Run();
}
static void Main(string[] args)
{
var fileTrackingProfile = new TrackingProfile();
fileTrackingProfile.Queries.Add(new WorkflowInstanceQuery
{
States = { "*" }
});
fileTrackingProfile.Queries.Add(new ActivityStateQuery
{
States = { ActivityStates.Executing, ActivityStates.Closed }
});
var fileTrackingParticipaint = new FileTrackingParticipant();
fileTrackingParticipaint.TrackingProfile = fileTrackingProfile;
var waitHandler = new AutoResetEvent(initialState: false);
var wfApp = new WorkflowApplication(new Workflow1());
wfApp.Unloaded = (wfAppEventArg) => { waitHandler.Set(); };
wfApp.Extensions.Add(fileTrackingParticipaint);
wfApp.Run();
waitHandler.WaitOne();
}
public void OutputEqualsInput()
{
string value = "Hans Mustermann";
SayHelloActivity activity = new SayHelloActivity()
{
Name = new InArgument <string>(context => value)
};
WorkflowApplication workflowApplication = new WorkflowApplication(activity);
string result = null;
ManualResetEvent workflowDone = new ManualResetEvent(false);
workflowApplication.Completed += delegate(WorkflowApplicationCompletedEventArgs args)
{
result = args.Outputs["Result"].ToString();
workflowDone.Set();
};
workflowApplication.Aborted += delegate(WorkflowApplicationAbortedEventArgs args)
{
workflowDone.Set();
};
// Ausführen und warten
workflowApplication.Run();
workflowDone.WaitOne();
Assert.Equal($"Hallo {value}", result);
}
