static void Main(string[] args)
{
AutoResetEvent syncEvent = new AutoResetEvent(false);
IDictionary<string, object> input = new Dictionary<string, object>()
{
{"Number1", 123},
{"Number2", 456}
};
IDictionary<string, object> output = null;
WorkflowApplication wfApp = new WorkflowApplication(new Workflow1(), input);
wfApp.Completed = delegate(WorkflowApplicationCompletedEventArgs e)
{
Console.WriteLine("Workflow thread id:" + Thread.CurrentThread.ManagedThreadId);
output = e.Outputs;
syncEvent.Set();
};
wfApp.Run();
syncEvent.WaitOne();
Console.WriteLine(output["Result"].ToString());
Console.WriteLine("Host thread id:" + Thread.CurrentThread.ManagedThreadId);
WorkflowInvoker.Invoke(new Workflow1());
Console.WriteLine("Presione una letra para continuar...");
Console.ReadKey();
}
static void Main(string[] args)
{
WorkflowApplication wfApplication = new WorkflowApplication(new Activity1());
SqlWorkflowInstanceStore instanceStore = new SqlWorkflowInstanceStore(ConfigurationManager.ConnectionStrings["ZhuangBPM"].ToString());
wfApplication.InstanceStore = instanceStore;
InstanceView view = instanceStore.Execute(instanceStore.CreateInstanceHandle(), new CreateWorkflowOwnerCommand(), TimeSpan.FromSeconds(30));
instanceStore.DefaultInstanceOwner = view.InstanceOwner;
wfApplication.PersistableIdle = (e) => {
System.Console.WriteLine("persistableIdle:{0}", e.InstanceId);
return PersistableIdleAction.Unload;
};
wfApplication.Run();
Console.ReadKey();
}
static void Main(string[] args)
{
var process = new WorkflowApplication(new Process());
process.Run();
System.Console.ReadKey();
}
static void Main(string[] args)
{
AutoResetEvent syncEvent = new AutoResetEvent(false);
// create the workflow app and add handlers for the Idle and Completed actions
WorkflowApplication app = new WorkflowApplication(new Sequence1());
app.Idle = delegate(WorkflowApplicationIdleEventArgs e)
{
syncEvent.Set();
};
app.Completed = delegate(WorkflowApplicationCompletedEventArgs e)
{
syncEvent.Set();
};
// start the application
app.Run();
syncEvent.WaitOne();
// read some text from the console and resume the readText bookmark (created in the first WaitForInput activity)
string text = Console.ReadLine();
app.ResumeBookmark("readText", text);
syncEvent.WaitOne();
// read some text from the console, convert it to number, and resume the readNumber bookmark (created in the second WaitForInput activity)
int number = ReadNumberFromConsole();
app.ResumeBookmark("readNumber", number);
syncEvent.WaitOne();
Console.WriteLine("");
Console.WriteLine("Press [ENTER] to exit...");
Console.ReadLine();
}
static void Main(string[] args)
{
_event = new AutoResetEvent(false);
bool more = true;
int result = 0;
var activity = new AccumulatorActivity();
var accumulator = new WorkflowApplication(activity);
accumulator.Completed = new Action<WorkflowApplicationCompletedEventArgs>((e) =>
{
result = (int)e.Outputs["Sum"];
more = false;
_event.Set();
});
accumulator.Extensions.Add(new Notification(NotifySum));
accumulator.Run();
while (more)
{
Console.Write("Enter number: ");
int number = int.Parse(Console.ReadLine());
accumulator.ResumeBookmark("GetNumber", number);
_event.WaitOne();
}
Console.WriteLine("Result is " + result);
}
protected override void LoadAndExecute()
{
MemoryStream ms = new MemoryStream(ASCIIEncoding.Default.GetBytes(this.workflowDesigner.Text));
DynamicActivity workflowToRun = ActivityXamlServices.Load(ms) as DynamicActivity;
WorkflowInspectionServices.CacheMetadata(workflowToRun);
this.workflowApplication = new WorkflowApplication(workflowToRun);
this.workflowApplication.Extensions.Add(this.output);
this.workflowApplication.Completed = this.WorkflowCompleted;
this.workflowApplication.OnUnhandledException = this.WorkflowUnhandledException;
this.workflowApplication.Aborted = this.WorkflowAborted;
this.workflowApplication.Extensions.Add(this.InitialiseVisualTrackingParticipant(workflowToRun));
try
{
this.running = true;
this.workflowApplication.Run();
}
catch (Exception e)
{
this.output.WriteLine(ExceptionHelper.FormatStackTrace(e));
StatusViewModel.SetStatusText(Resources.ExceptionInDebugStatus, this.workflowName);
}
}
public static WorkflowApplication createInstance(string xamlString, Dictionary<string, object> dictionary, TrackingParticipant tracking)
{
WorkflowApplication instance = null;
DynamicActivity dynamicActivity = tool.activityByXaml(xamlString) as DynamicActivity;
if (dictionary != null)
{
instance = new WorkflowApplication(dynamicActivity, dictionary);
}
else
{
instance = new WorkflowApplication(dynamicActivity);
}
instance.Aborted = aborted;
instance.Completed = completed;
instance.OnUnhandledException = onUnhandledException;
instance.PersistableIdle = persistableIdle;
instance.Unloaded = unloaded;
if (tracking != null)
{
instance.Extensions.Add(tracking);
}
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);
}
}
static void Main(string[] args)
{
TrackingProfile fileTrackingProfile = new TrackingProfile();
fileTrackingProfile.Queries.Add(new WorkflowInstanceQuery
{
States = { "*" }
});
fileTrackingProfile.Queries.Add(new ActivityStateQuery()
{
States = {
ActivityStates.Executing,
ActivityStates.Closed
}
});
FileTrackingParticipant fileTrackingParticipant = new FileTrackingParticipant();
fileTrackingParticipant.TrackingProfile = fileTrackingProfile;
AutoResetEvent waitHandler = new AutoResetEvent(false);
WorkflowApplication wfapp = new WorkflowApplication(new Workflow1());
wfapp.Unloaded = (wfAppEventArg) => { waitHandler.Set(); };
wfapp.Extensions.Add(fileTrackingParticipant);
wfapp.Run();
waitHandler.WaitOne();
}
public static void RunCheckCheck(Guid id, ReviewCheckCheck Form)
{
SqlWorkflowInstanceStore instanceStore = new SqlWorkflowInstanceStore(@"server=.\SQLEXPRESS;database=aspnetdb;uid=sa;pwd=123456");
WorkflowApplication application2 = new WorkflowApplication(new DocumentPublish());
application2.InstanceStore = instanceStore;
application2.Completed = (workflowApplicationCompletedEventArgs) =>
{
Console.WriteLine("\nWorkflowApplication has Completed in the {0} state.", workflowApplicationCompletedEventArgs.CompletionState);
instanceUnloaded.Set();
};
application2.PersistableIdle = (e) =>
{
instanceUnloaded.Set();
return PersistableIdleAction.Unload;
};
application2.Unloaded = (workflowApplicationEventArgs) =>
{
Console.WriteLine("WorkflowApplication has Unloaded\n");
instanceUnloaded.Set();
};
application2.Load(id);
application2.ResumeBookmark("WaitCheckingChecking", Form);
instanceUnloaded.WaitOne();
Console.ReadLine();
}
static void Interact(WorkflowApplication application)
{
IList<BookmarkInfo> bookmarks = application.GetBookmarks();
while (true)
{
Console.Write("Bookmarks:");
foreach (BookmarkInfo info in bookmarks)
{
Console.Write(" '" + info.BookmarkName + "'");
}
Console.WriteLine();
Console.WriteLine("Enter the name of the bookmark to resume");
string bookmarkName = Console.ReadLine();
if (bookmarkName != null && !bookmarkName.Equals(string.Empty))
{
Console.WriteLine("Enter the payload for the bookmark '{0}'", bookmarkName);
string bookmarkPayload = Console.ReadLine();
BookmarkResumptionResult result = application.ResumeBookmark(bookmarkName, bookmarkPayload);
if (result == BookmarkResumptionResult.Success)
{
return;
}
else
{
Console.WriteLine("BookmarkResumptionResult: " + result);
}
}
}
}
/*
* Enable Analytic and Debug Logs:
* Event Viewer -> Applications and Services Logs ->
* Microsoft -> Windows -> Application Server-Applications
* Right-click "Application Server-Applications" -> select View ->
* Show Analytic and Debug Logs -> Refresh
* */
static void Main(string[] args)
{
//Tracking Configuration
TrackingProfile trackingProfile = new TrackingProfile();
trackingProfile.Queries.Add(new WorkflowInstanceQuery
{
States = { "*" }
});
trackingProfile.Queries.Add(new ActivityStateQuery
{
States = { "*" }
});
trackingProfile.Queries.Add(new CustomTrackingQuery
{
ActivityName = "*",
Name = "*"
});
EtwTrackingParticipant etwTrackingParticipant =
new EtwTrackingParticipant();
etwTrackingParticipant.TrackingProfile = trackingProfile;
// Run workflow app "Workflow1.xaml"
AutoResetEvent waitHandler = new AutoResetEvent(false);
WorkflowApplication wfApp =
new WorkflowApplication(new Workflow1());
wfApp.Completed = (arg) => { waitHandler.Set(); };
wfApp.Extensions.Add(etwTrackingParticipant);
wfApp.Run();
waitHandler.WaitOne();
}
public override void Start()
{
if (IsRunning)
{
return;
}
using (var stream = new MemoryStream(Encoding.Default.GetBytes(Xaml)))
{
workflowApplication = new WorkflowApplication(ActivityXamlServices.Load(stream));
}
workflowApplication.Extensions.Add(OutputWriter);
workflowApplication.Completed += OnWorkflowCompleted;
workflowApplication.Aborted += OnWorkflowAborted;
workflowApplication.OnUnhandledException += OnWorkflowUnhandledException;
try
{
OnExecutingStateChanged(new WorkflowExecutingStateEventArgs(true));
workflowApplication.Run();
}
catch (Exception e)
{
OutputWriter.WriteLine(e.StackTrace);
OnExecutingStateChanged(new WorkflowExecutingStateEventArgs(false));
}
}
// 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);
XmlWorkflowInstanceStore store = new XmlWorkflowInstanceStore(instance.Id);
instance.InstanceStore = store;
instance.PersistableIdle += OnIdleAndPersistable;
instance.Completed += OnWorkflowCompleted;
instance.Idle += OnIdle;
//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;
}
private static void Main(string[] args)
{
const int workflowCompleted = 0;
const int workflowIdle = 1;
var syncEvents = new[]
{
new AutoResetEvent(false),
new AutoResetEvent(false),
};
var wfApp = new WorkflowApplication(new TestReadLine());
string bookmarkName = string.Empty;
bool workflowComplete = false;
// Signal the main thread we are done
wfApp.Completed = (e) => syncEvents[workflowCompleted].Set();
// When the host detects an idle
wfApp.Idle = (e) =>
{
// Search the bookmarks
foreach (
var bi in
e.Bookmarks.Where(
bi => bi.BookmarkName == "FirstName" || bi.BookmarkName == "LastName"))
{
Console.WriteLine("Found bookmark {0}", bi.BookmarkName);
// For FirstName or LastName bookmarks prompt with a readline
bookmarkName = bi.BookmarkName;
syncEvents[workflowIdle].Set();
}
};
wfApp.Run();
while (!workflowComplete)
{
// Wait for events
switch (WaitHandle.WaitAny(syncEvents, TimeSpan.FromSeconds(5)))
{
case WaitHandle.WaitTimeout:
Console.WriteLine("Sorry you took too long");
wfApp.Terminate("Timeout");
break;
case workflowCompleted:
workflowComplete = true;
break;
case workflowIdle:
Console.WriteLine("Reading response for bookmark {0}", bookmarkName);
// Resume with the response from the user
wfApp.ResumeBookmark(bookmarkName, Console.ReadLine());
break;
}
}
Console.WriteLine("Sample Completed - press any key to exit");
Console.ReadKey(true);
}
private static void ProcessHandler(int userId)
{
//获取待处理的流程
DbContext dbcontext = new DbContext();
var lst = dbcontext.FlowInfo.Where(x => x.RowState == RowStates.正常)
.Where(x => x.HandlerId == userId)
.ToList();
if (lst.Count <= 0)
{
Console.WriteLine("没有待处理的流程");
return;
}
int indexTMP = 0;
lst.ForEach(x => Console.WriteLine(string.Format("索引：{0}，流程ID：{1}，处理人ID：{2}，处理人：{3}，表单：{4}",
indexTMP++, x.WFInstanceId, x.HandlerId, x.HandlerName, x.FlowContext)));
Console.WriteLine("请输入流程索引");
int index = Convert.ToInt32(Console.ReadLine());
Console.WriteLine("请输入审批意见");
Console.WriteLine(string.Format("{0}---{1}", (int)HandlerOptions.意, HandlerOptions.意.ToString()));
Console.WriteLine(string.Format("{0}---{1}", (int)HandlerOptions.驳回, HandlerOptions.驳回.ToString()));
HandlerOptions opt = (HandlerOptions)Convert.ToInt32(Console.ReadLine());
//组织表单数据
var formData = Newtonsoft.Json.Linq.JObject.Parse(lst[index].FlowContext);
formData["HandlerOption"] = Newtonsoft.Json.Linq.JToken.FromObject(opt);//demo,这个键写死
//启动流程
System.Activities.WorkflowApplication wfa = new System.Activities.WorkflowApplication(new LeaveFlow());
InitWF(wfa);
wfa.Load(lst[index].WFInstanceId);
wfa.ResumeBookmark(lst[index].BookmarkName, formData);
}
public void AnyActivityInstanceStateFindsClosed()
{
// Arrange
var activity = new AddToNumOrThrow();
dynamic args = new WorkflowArguments();
args.Num = 2;
var host = new WorkflowApplication(activity, args);
var tracking = new ListTrackingParticipant();
host.Extensions.Add(tracking);
try
{
host.RunEpisode();
// Act
var any = tracking.Records.Any(ActivityInstanceState.Closed);
// Assert
Assert.IsTrue(any);
}
finally
{
tracking.Trace();
}
}
// 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();
}
// single interaction with the user. The user enters a string in the console and that
// string is used to resume the ReadLine activity bookmark
static void Interact(WorkflowApplication application, AutoResetEvent resetEvent)
{
Console.WriteLine("Workflow is ready for input");
Console.WriteLine("Special commands: 'unload', 'exit'");
bool done = false;
while (!done)
{
Console.Write("> ");
string s = Console.ReadLine();
if (s.Equals("unload"))
{
try
{
// attempt to unload will fail if the workflow is idle within a NoPersistZone
application.Unload(TimeSpan.FromSeconds(5));
done = true;
}
catch (TimeoutException e)
{
Console.WriteLine(e.Message);
}
}
else if (s.Equals("exit"))
{
application.ResumeBookmark("inputBookmark", s);
done = true;
}
else
{
application.ResumeBookmark("inputBookmark", s);
}
}
resetEvent.WaitOne();
}
/// <summary>
/// Adds a new WorkflowApplication to the cache
/// </summary>
/// <param name="application">
/// The application.
/// </param>
/// <returns>
/// The WorkflowApplication that was added or updated
/// </returns>
public WorkflowApplication Add(WorkflowApplication application)
{
Debug.Assert(this.dictionary != null, "dictionary != null");
var observer = new WorkflowApplicationObserver(application) { Aborted = this.Aborted };
return this.dictionary.AddOrUpdate(
application.Id, guid => application, (guid, workflowApplication) => application);
}
public void WorkflowArgumentsCanPassToWorkflowApplication()
{
// Arrange
var activity = new ArgTest();
dynamic input = new WorkflowArguments();
dynamic output = null;
var completed = new AutoResetEvent(false);
// Act
input.Num1 = 2;
input.Num2 = 3;
var host = new WorkflowApplication(activity, input);
host.Completed += args =>
{
output = WorkflowArguments.FromDictionary(args.Outputs);
completed.Set();
};
host.Run();
// Wait for complete
Assert.IsTrue(completed.WaitOne(1000));
// Assert
Assert.AreEqual(5, output.Result);
}
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(
}
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);
// Used to inform primary thread to wait!
AutoResetEvent waitHandle = new AutoResetEvent(false);
// Pass to the workflow.
WorkflowApplication app = new WorkflowApplication(new Workflow1(), wfArgs);
// Hook up an event with this app.
// When I’m done, notifiy other thread I’m done,
// and print a message.
app.Completed = (completedArgs) =>
{
waitHandle.Set();
Console.WriteLine("The workflow is done!");
};
// Start the workflow!
app.Run();
// Wait until I am notified the workflow is done.
waitHandle.WaitOne();
Console.WriteLine("Thanks for playing");
}
public void Run()
{
this.workflowDesigner.Flush();
MemoryStream ms = new MemoryStream(ASCIIEncoding.Default.GetBytes(this.workflowDesigner.Text));
DynamicActivity activityToRun = ActivityXamlServices.Load(ms) as DynamicActivity;
this.workflowApplication = new WorkflowApplication(activityToRun);
this.workflowApplication.Extensions.Add(this.output);
this.workflowApplication.Completed = this.WorkflowCompleted;
this.workflowApplication.Aborted = this.WorkflowAborted;
this.workflowApplication.OnUnhandledException = this.WorkflowUnhandledException;
StatusViewModel.SetStatusText(Resources.RunningStatus, this.workflowName);
try
{
this.running = true;
this.workflowApplication.Run();
}
catch (Exception e)
{
this.output.WriteLine(ExceptionHelper.FormatStackTrace(e));
StatusViewModel.SetStatusText(Resources.ExceptionStatus, this.workflowName);
this.running = false;
}
}
static void LoadAndCompleteInstance()
{
string input = Console.ReadLine();
WorkflowApplication application = new WorkflowApplication(activity);
application.InstanceStore = instanceStore;
application.Completed = (workflowApplicationCompletedEventArgs) =>
{
Console.WriteLine("\nWorkflowApplication has Completed in the {0} state.", workflowApplicationCompletedEventArgs.CompletionState);
};
application.Unloaded = (workflowApplicationEventArgs) =>
{
Console.WriteLine("WorkflowApplication has Unloaded\n");
instanceUnloaded.Set();
};
application.Load(id);
//this resumes the bookmark setup by readline
application.ResumeBookmark(readLineBookmark, input);
instanceUnloaded.WaitOne();
}
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 ;
}
}
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();
}
}
internal WorkflowApplicationUnhandledExceptionEventArgs(WorkflowApplication application, Exception exception, Activity exceptionSource, string exceptionSourceInstanceId)
: base(application)
{
this.UnhandledException = exception;
this.ExceptionSource = exceptionSource;
this.ExceptionSourceInstanceId = exceptionSourceInstanceId;
}
/// <summary>
/// 第一步，统一入口，各种流程，请假流程，采购流程，调薪流程，
/// </summary>
/// <returns></returns>
private static HzWorkFlowContext StartAppliaction()
{
System.Xaml.XamlXmlReaderSettings st = new System.Xaml.XamlXmlReaderSettings()
{
LocalAssembly = System.Reflection.Assembly.GetExecutingAssembly()
};
System.Activities.Activity act = null;
using (var reader = new System.Xaml.XamlXmlReader(workflowName, st)) {
act = System.Activities.XamlIntegration.ActivityXamlServices.Load(reader);
}
HzWorkFlowContext context = new HzWorkFlowContext();
context.CreateDateTime = DateTime.Now;
context.Creator = "eeroom";
//formdata由页面表单json提交而来，这里只是为了测试
context.FormData = Newtonsoft.Json.JsonConvert.SerializeObject(new QinJiaFormdata()
{
Category = 3,
Days = 5
});
var dict = new Dictionary <string, object>();
//对应活动的入参
dict.Add("hzWorkFlowContext", context);
var wfa = new System.Activities.WorkflowApplication(act, dict);
ConfigWfa(wfa);
wfa.Run();
return(context);
}
public WorkflowService(
IUsersService users
)
{
_users = users;
T = NullLocalizer.Instance;
Logger = NullLogger.Instance;
SqlWorkflowInstanceStore store = new SqlWorkflowInstanceStore(_users.ApplicationConnectionString);
_wfApp = new WorkflowApplication(new XODB.Workflow.AssignResponsibility());
_wfApp.InstanceStore = store;
XName wfHostTypeName = XName.Get("XODB", _users.ApplicationID.ToString());
Dictionary<XName, object> wfScope = new Dictionary<XName, object> { { workflowHostTypePropertyName, wfHostTypeName } };
_wfApp.AddInitialInstanceValues(wfScope);
_wfApp.Extensions.Add(new ResponsibilityExtension());
List<XName> variantProperties = new List<XName>()
{
ResponsibilityExtension.xNS.GetName("CompanyID"),
ResponsibilityExtension.xNS.GetName("ContactID")
};
store.Promote("Responsibility", variantProperties, null);
InstanceHandle handle = store.CreateInstanceHandle(null);
var cmd = new CreateWorkflowOwnerCommand
{
InstanceOwnerMetadata =
{
{workflowHostTypePropertyName, new InstanceValue(wfHostTypeName)}
}
};
InstanceOwner owner = store.Execute(handle, cmd, TimeSpan.MaxValue).InstanceOwner;
store.DefaultInstanceOwner = owner;
handle.Free();
_wfApp.PersistableIdle = delegate(WorkflowApplicationIdleEventArgs e)
{
return PersistableIdleAction.Persist;
};
_wfApp.Completed = delegate(WorkflowApplicationCompletedEventArgs e)
{
if (System.Diagnostics.Debugger.IsAttached)
{
foreach (var item in e.Outputs)
{
System.Diagnostics.Debug.WriteLine("Variable:{0} has value: {1}", item.Key, item.Value);
}
}
};
var trackingParticipant = new TrackingHelper.DebugTrackingParticipant
{
TrackingProfile = TrackingHelper.SimpleProfile
};
_wfApp.Extensions.Add(trackingParticipant);
}
internal WorkflowApplicationCompletedEventArgs(WorkflowApplication application, Exception terminationException, ActivityInstanceState completionState, IDictionary<string, object> outputs)
: base(application)
{
Fx.Assert(ActivityUtilities.IsCompletedState(completionState), "event should only fire for completed activities");
this.terminationException = terminationException;
this.completionState = completionState;
this.outputs = outputs;
}
//end
protected void btnEdit_ServerClick(object sender, EventArgs e)
{
if (((this.txtName.Value.Length == 0) || (this.uploadurl.Value.Length == 0)) || (this.selWorkFlow.SelectedValue.Length == 0))
{
MessageBox.Show(this, "请您填写完整的信息");
}
else
{
Model.SelectRecord selectRecord = new Model.SelectRecord("WorkFlow", "", "*", "where id='" + this.selWorkFlow.SelectedValue + "'");
DataTable table = BLL.SelectRecord.SelectRecordData(selectRecord).Tables[0];
string content = File.ReadAllText(System.Web.HttpContext.Current.Request.MapPath("../") + table.Rows[0]["URL"].ToString());
//ziyunhx add 2013-8-5 workflow Persistence
//old code
//WorkFlowTracking.instance = engineManager.createInstance(content, null, null);
//WorkFlowTracking.instance.Run();
//new code
instance = engineManager.createInstance(content, null, null);
if (instanceStore == null)
{
instanceStore = new SqlWorkflowInstanceStore(SqlHelper.strconn);
view = instanceStore.Execute(instanceStore.CreateInstanceHandle(), new CreateWorkflowOwnerCommand(), TimeSpan.FromSeconds(30));
instanceStore.DefaultInstanceOwner = view.InstanceOwner;
}
instance.InstanceStore = instanceStore;
instance.Run();
//end
Model.Document documents = new Model.Document
{
ID = id.Trim(),
Name = this.txtName.Value.Trim(),
URL = this.uploadurl.Value.Trim(),
Remark = this.txtReMark.Value.Trim(),
WID = this.selWorkFlow.SelectedValue,
WStep = "0",
Result = "0",
UID = this.Session["admin"].ToString(),
//ziyunhx add 2013-8-5 workflow Persistence
//old code
//FlowInstranceID = WorkFlowTracking.instance.Id,
//new code
FlowInstranceID = instance.Id,
//end
};
if (BLL.Document.DocumentUpdate(documents) == 1)
{
UserOperatingManager.InputUserOperating(this.Session["admin"].ToString(), "工作流管理", "编辑工作流" + documents.Name + "的信息成功");
MessageBox.ShowAndRedirect(this, "编辑公文成功！", "/document/DocumentList.aspx");
}
else
{
UserOperatingManager.InputUserOperating(this.Session["admin"].ToString(), "工作流管理", "编辑工作流" + documents.Name + "的信息失败");
MessageBox.Show(this, "编辑工作流失败");
}
}
}
//第一步以后，后续所有流程步骤的入口
private static void ApproveOp(bool op, Guid workflowId, HzWorkFlowContext hzwfContext)
{
System.Xaml.XamlXmlReaderSettings st = new System.Xaml.XamlXmlReaderSettings()
{
LocalAssembly = System.Reflection.Assembly.GetExecutingAssembly()
};
System.Activities.Activity act = null;
using (var reader = new System.Xaml.XamlXmlReader(workflowName, st)) {
act = System.Activities.XamlIntegration.ActivityXamlServices.Load(reader);
}
var wfa = new System.Activities.WorkflowApplication(act);
ConfigWfa(wfa);
wfa.Load(workflowId);
wfa.ResumeBookmark(bookmark, op);
}
public static Dictionary <XName, InstanceValue> GenerateInitialData(WorkflowApplication instance)
{
var data = new Dictionary <XName, InstanceValue>(10);
data[WorkflowNamespace.Bookmarks] = new InstanceValue(instance.Controller.GetBookmarks(), InstanceValueOptions.WriteOnly | InstanceValueOptions.Optional);
data[WorkflowNamespace.LastUpdate] = new InstanceValue(DateTime.UtcNow, InstanceValueOptions.WriteOnly | InstanceValueOptions.Optional);
foreach (var mappedVariable in instance.Controller.GetMappedVariables())
{
data[WorkflowNamespace.VariablesPath.GetName(mappedVariable.Key)] = new InstanceValue(mappedVariable.Value, InstanceValueOptions.WriteOnly | InstanceValueOptions.Optional);
}
Fx.AssertAndThrow(instance.Controller.State != WorkflowInstanceState.Aborted, "Cannot generate data for an aborted instance.");
if (instance.Controller.State != WorkflowInstanceState.Complete)
{
data[WorkflowNamespace.Workflow] = new InstanceValue(instance.Controller.PrepareForSerialization());
data[WorkflowNamespace.Status] = new InstanceValue(instance.Controller.State == WorkflowInstanceState.Idle ? "Idle" : "Executing", InstanceValueOptions.WriteOnly);
}
else
{
data[WorkflowNamespace.Workflow] = new InstanceValue(instance.Controller.PrepareForSerialization(), InstanceValueOptions.Optional);
var completionState = instance.Controller.GetCompletionState(out var outputs, out var completionException);
if (completionState == ActivityInstanceState.Faulted)
{
data[WorkflowNamespace.Status] = new InstanceValue("Faulted", InstanceValueOptions.WriteOnly);
data[WorkflowNamespace.Exception] = new InstanceValue(completionException, InstanceValueOptions.WriteOnly | InstanceValueOptions.Optional);
}
else if (completionState == ActivityInstanceState.Closed)
{
data[WorkflowNamespace.Status] = new InstanceValue("Closed", InstanceValueOptions.WriteOnly);
if (outputs != null)
{
foreach (var output in outputs)
{
data[WorkflowNamespace.OutputPath.GetName(output.Key)] = new InstanceValue(output.Value, InstanceValueOptions.WriteOnly | InstanceValueOptions.Optional);
}
}
}
else
{
Fx.AssertAndThrow(completionState == ActivityInstanceState.Canceled, "Cannot be executing when WorkflowState was completed.");
data[WorkflowNamespace.Status] = new InstanceValue("Canceled", InstanceValueOptions.WriteOnly);
}
}
return(data);
}
/// <summary>
/// Runs the specified instance.
/// </summary>
/// <param name="instance">The instance.</param>
/// <returns><c>true</c> if XXXX, <c>false</c> otherwise.</returns>
public bool Run(WorkflowApplication instance)
{
IAsyncResult?result = null;
if (instance.Controller.HasPendingTrackingRecords)
{
instance.EventData.NextCallback = this.Stage1Callback;
result = instance.Controller.BeginFlushTrackingRecords(ActivityDefaults.TrackingTimeout, EventFrameCallback, instance.EventData);
if (!result.CompletedSynchronously)
{
return(false);
}
}
return(this.OnStage1Complete(result, instance, true));
}
public LoadAsyncResult(WorkflowApplication application, PersistenceManager persistenceManager,
IDictionary <XName, InstanceValue> values,
DynamicUpdateMap updateMap,
TimeSpan timeout,
AsyncCallback callback, object state)
: base(callback, state)
{
this.application = application;
this.persistenceManager = persistenceManager;
this.values = values;
this.timeoutHelper = new TimeoutHelper(timeout);
this.updateMap = updateMap;
this.Initialize();
}
private static void Start(int userId, string userName)
{
DbContext dbcontext = new DbContext();
FlowInfo fl = new FlowInfo()
{
Id = DateTime.Now.Ticks,
CreatedTime = DateTime.Now,
CreatorId = userId,
CreatorName = userName,
FlowGroupName = "开始",
FlowNo = Guid.NewGuid(),
FlowNoParent = Guid.Empty,
FlowResult = FlowResults.None,
FlowState = FlowStates.未提交,
HandlerId = userId,
HandlerName = userName,
HandlerOption = HandlerOptions.新建,
NodeType = NodeTypes.单人审批,
HandlerTime = DateTime.Now,
PreviousHandlerId = -1,
PreviousHandlerName = string.Empty,
PreviousHandlerTime = DateTime.Now,
RowState = RowStates.正常,
WFInstanceId = Guid.Empty,
};
LeaveInput input = new LeaveInput();
Console.WriteLine("请输入请假的小时数");
input.Hours = int.Parse(Console.ReadLine());
Console.WriteLine("请输入请假理由");
input.Remark = Console.ReadLine();
fl.FlowContext = Newtonsoft.Json.JsonConvert.SerializeObject(input);
Dictionary <string, object> dict = new Dictionary <string, object>();
dict.Add("flowInfo", fl);
System.Activities.WorkflowApplication wfa = new System.Activities.WorkflowApplication(new LeaveFlow(), dict);
fl.WFInstanceId = wfa.Id;
InitWF(wfa);
dbcontext.FlowInfo.Add(fl);
dbcontext.SaveChanges();
wfa.Run();
}
public bool Run(WorkflowApplication instance)
{
IAsyncResult result = null;
if (instance.Controller.TrackingEnabled)
{
instance.Controller.Track(new WorkflowInstanceRecord(instance.Id, instance.WorkflowDefinition.DisplayName, WorkflowInstanceStates.Idle, instance.DefinitionIdentity));
instance.EventData.NextCallback = this.Stage1Callback;
result = instance.Controller.BeginFlushTrackingRecords(ActivityDefaults.TrackingTimeout, EventFrameCallback, instance.EventData);
if (!result.CompletedSynchronously)
{
return(false);
}
}
return(this.OnStage1Complete(result, instance, true));
}
private static IDictionary <string, object> Invoke(Activity workflow, TimeSpan timeout, WorkflowInstanceExtensionManager extensions)
{
if (workflow == null)
{
throw FxTrace.Exception.ArgumentNull(nameof(workflow));
}
TimeoutHelper.ThrowIfNegativeArgument(timeout);
var outputs = WorkflowApplication.Invoke(workflow, null, extensions, timeout);
if (outputs == null)
{
return(ActivityUtilities.EmptyParameters);
}
else
{
return(outputs);
}
}
public bool Run(WorkflowApplication instance, Exception exception, Activity exceptionSource, string exceptionSourceInstanceId)
{
IAsyncResult result = null;
if (instance.Controller.HasPendingTrackingRecords)
{
instance.EventData.NextCallback = this.Stage1Callback;
instance.EventData.UnhandledException = exception;
instance.EventData.UnhandledExceptionSource = exceptionSource;
instance.EventData.UnhandledExceptionSourceInstance = exceptionSourceInstanceId;
result = instance.Controller.BeginFlushTrackingRecords(ActivityDefaults.TrackingTimeout, EventFrameCallback, instance.EventData);
if (!result.CompletedSynchronously)
{
return(false);
}
}
return(this.OnStage1Complete(result, instance, exception, exceptionSource, exceptionSourceInstanceId));
}
private Guid correlate(WorkflowApplication wfApp)
{
//TODO: da completare
if (wfApp.InstanceStore is IStoreCorrelation)
{
var scorrelation = (wfApp.InstanceStore as IStoreCorrelation);
//if (scorrelation.Correlation != null
// && scorrelation.Correlation.WorkflowId != Guid.Empty)
//{
// return scorrelation.Correlation.WorkflowId;
//}
//else if(scorrelation.Correlation != null
// && scorrelation.Correlation.CorrelationId != Guid.Empty
// && scorrelation.Correlation.WorkflowId == Guid.Empty)
//{
// return scorrelation.Correlation.WorkflowId;
//}
}
return(Guid.Empty);
}
private void InternalInvokeAsync(IDictionary <string, object> inputs, TimeSpan timeout, object userState)
{
var context = new AsyncInvokeContext(userState, this);
if (userState != null)
{
AddToPendingInvokes(context);
}
Exception error = null;
var completedSynchronously = false;
try
{
if (invokeCallback == null)
{
invokeCallback = Fx.ThunkCallback(new AsyncCallback(InvokeCallback));
}
context.Operation.OperationStarted();
var result = WorkflowApplication.BeginInvoke(this.workflow, inputs, this.extensions, timeout, SynchronizationContext.Current, context, invokeCallback, context);
if (result.CompletedSynchronously)
{
context.Outputs = this.EndInvoke(result);
completedSynchronously = true;
}
}
catch (Exception e)
{
if (Fx.IsFatal(e))
{
throw;
}
error = e;
}
if (error != null || completedSynchronously)
{
PostInvokeCompletedAndRemove(context, error);
}
}
/// <summary>
/// Initializes a new instance of the <see cref="InvokeAsyncResult"/> class.
/// </summary>
/// <param name="activity">The activity.</param>
/// <param name="inputs">The inputs.</param>
/// <param name="extensions">The extensions.</param>
/// <param name="timeout">The timeout.</param>
/// <param name="syncContext">The synchronize context.</param>
/// <param name="invokeContext">The invoke context.</param>
/// <param name="callback">The callback.</param>
/// <param name="state">The state.</param>
public InvokeAsyncResult(
Activity activity,
IDictionary <string, object> inputs,
WorkflowInstanceExtensionManager extensions,
TimeSpan timeout,
SynchronizationContext syncContext,
AsyncInvokeContext invokeContext,
AsyncCallback callback,
object state)
: base(callback, state)
{
if (activity == null)
{
throw new ArgumentNullException(nameof(activity));
}
this.completionWaiter = new AsyncWaitHandle();
syncContext ??= SynchronousSynchronizationContext.Value;
this.instance = WorkflowApplication.StartInvoke(activity, inputs, extensions, syncContext, new Action(this.OnInvokeComplete), invokeContext);
if (this.completionWaiter.WaitAsync(WaitCompleteCallback, this, timeout))
{
var completeSelf = this.OnWorkflowCompletion();
if (completeSelf)
{
if (this.completionException != null)
{
throw FxTrace.Exception.AsError(this.completionException);
}
else
{
this.Complete(true);
}
}
}
}
private RunAsyncResult(WorkflowApplication instance, bool isUserRun, AsyncCallback callback, object state)
: base(instance, callback, state) => this.isUserRun = isUserRun;
private bool OnStage1Complete(IAsyncResult lastResult, WorkflowApplication instance, bool isStillSync) => this.OnStage1Complete(lastResult, instance, instance.EventData.UnhandledException, instance.EventData.UnhandledExceptionSource, instance.EventData.UnhandledExceptionSourceInstance);
private void setWFEvents(WorkflowApplication wf)
{
wf.Idle = delegate(WorkflowApplicationIdleEventArgs e)
{
Console.WriteLine("Workflow idled");
s_idleEvent.Set();
//s_syncEvent.Set();
};
wf.Completed = delegate(WorkflowApplicationCompletedEventArgs e)
{
Console.WriteLine("Workflow completed with state {0}.", e.CompletionState.ToString());
if (e.TerminationException != null)
{
exception = e.TerminationException;
Console.WriteLine("TerminationException = {0}; {1}", e.TerminationException.GetType().ToString(), e.TerminationException.Message);
}
s_completedEvent?.Set();
//s_syncEvent.Set();
invokeMode = WorkflowInvokeMode.None;
};
wf.Unloaded = delegate(WorkflowApplicationEventArgs e)
{
Console.WriteLine("Workflow unloaded");
if (this.invokeMode == WorkflowInvokeMode.Run)
{
this.invokeMode = WorkflowInvokeMode.ResumeBookmark;
}
else
{
this.invokeMode = WorkflowInvokeMode.None;
}
s_unloadedEvent.Set();
//s_syncEvent.Set();
};
wf.PersistableIdle = delegate(WorkflowApplicationIdleEventArgs e)
{
if (instanceStore != null)
{
return(PersistableIdleAction.Unload);
}
return(PersistableIdleAction.None);
};
wf.Aborted = e =>
{
this.exception = e.Reason;
//throw e.Reason;
//syncEvent.Set();
s_syncEvent?.Set();
};
//wfApp.Idle = e => { /*syncEvent.Set();*/ };
//wfApp.PersistableIdle = e => { return PersistableIdleAction.Unload; };
//wfApp.OnUnhandledException = e => { return UnhandledExceptionAction.Terminate; };
}
private bool OnStage1Complete(IAsyncResult lastResult, WorkflowApplication application, bool isStillSync)
{
if (lastResult != null)
{
application.Controller.EndFlushTrackingRecords(lastResult);
}
IAsyncResult result = null;
if (application.RaiseIdleEvent())
{
if (application.Controller.IsPersistable && application.persistenceManager != null)
{
var persistableIdleHandler = application.PersistableIdle;
if (persistableIdleHandler != null)
{
var action = PersistableIdleAction.None;
application.handlerThreadId = Thread.CurrentThread.ManagedThreadId;
try
{
application.isInHandler = true;
action = persistableIdleHandler(new WorkflowApplicationIdleEventArgs(application));
}
finally
{
application.isInHandler = false;
}
if (TD.WorkflowApplicationPersistableIdleIsEnabled())
{
TD.WorkflowApplicationPersistableIdle(application.Id.ToString(), action.ToString());
}
if (action != PersistableIdleAction.None)
{
var operation = PersistenceOperation.Unload;
if (action == PersistableIdleAction.Persist)
{
operation = PersistenceOperation.Save;
}
else if (action != PersistableIdleAction.Unload)
{
throw FxTrace.Exception.AsError(new InvalidOperationException(SR.InvalidIdleAction));
}
application.EventData.NextCallback = this.Stage2Callback;
result = application.BeginInternalPersist(operation, ActivityDefaults.InternalSaveTimeout, true, EventFrameCallback, application.EventData);
if (!result.CompletedSynchronously)
{
return(false);
}
}
}
else
{
// Trace the default action
if (TD.WorkflowApplicationPersistableIdleIsEnabled())
{
TD.WorkflowApplicationPersistableIdle(application.Id.ToString(), PersistableIdleAction.None.ToString());
}
}
}
}
return(this.OnStage2Complete(result, application, isStillSync));
}
public void EndAbandon(IAsyncResult asyncResult)
{
WorkflowApplication.EndDiscardInstance(asyncResult);
}
public override bool CanRun(WorkflowApplication instance) => (this.ActionId != instance.actionCount && instance.Controller.State == WorkflowInstanceState.Idle) || instance.Controller.State == WorkflowInstanceState.Complete;
internal WorkflowApplicationIdleEventArgs(WorkflowApplication application)
: base(application)
{
}
private IAsyncResult BeginInvoke(Activity workflow, TimeSpan timeout, WorkflowInstanceExtensionManager extensions, AsyncCallback callback, object state)
{
TimeoutHelper.ThrowIfNegativeArgument(timeout);
return(WorkflowApplication.BeginInvoke(workflow, null, extensions, timeout, null, null, callback, state));
}
private TResponse ContinueWorkflow_todelete <TRequest, TResponse>(TRequest request, string OperationName)
{
TimeSpan timeOut = TimeSpan.FromMinutes(1);
Action waitOne = delegate()
{
s_syncEvent = null;
if (instanceStore != null)
{
s_syncEvent = s_unloadedEvent;
s_unloadedEvent.WaitOne();
}
else
{
s_syncEvent = s_idleEvent;
s_idleEvent.WaitOne();
}
};
WorkflowInstanceContext instanceContext = new WorkflowInstanceContext()
{
Request = request,
Response = default(TResponse)
};
invokeMode = WorkflowInvokeMode.ResumeBookmark;
WorkflowApplication wfApp = null;
Guid wfId = Guid.Empty;
while (invokeMode != WorkflowInvokeMode.None)
{
if (invokeMode == WorkflowInvokeMode.Run)
{
wfApp = createWorkflowApplication(instanceContext);
wfId = wfApp.Id;
resetEvents();
wfApp.Run(timeOut);
waitOne();
}
else if (invokeMode == WorkflowInvokeMode.ResumeBookmark)
{
wfApp = createWorkflowApplication(instanceContext);
resetEvents();
this.WorkflowId = (wfApp.InstanceStore as IStoreCorrelation).Correlation.CorrelationId;
wfApp.Load(this.WorkflowId, timeOut);
var isWaiting = wfApp.GetBookmarks().FirstOrDefault(b => b.BookmarkName == OperationName);
if (isWaiting != null)
{
wfApp.ResumeBookmark(OperationName, "bookmark data", timeOut);
waitOne();
}
else
{
throw new Exception($"Bookmark {OperationName} missing on workflow with id {wfApp.Id}");
}
}
}
;
TResponse response = default(TResponse);
try
{
response = (TResponse)instanceContext.Response;
}
catch
{
}
return(response);
}
public void createApp(Activity activity)
{
//var xh = new XamlHelper(workflow.xaml);
//extraextension.updateProfile(xh.Variables.ToArray(), xh.ArgumentNames.ToArray());
TrackingParticipant = new WorkflowTrackingParticipant();
TrackingParticipant.OnVisualTracking += Participant_OnVisualTracking;
if (string.IsNullOrEmpty(InstanceId))
{
// Remove unknown Parameters, if we don't the workflow will fail
foreach (var param in Parameters.ToList())
{
var allowed = Workflow.Parameters.Where(x => x.name == param.Key).FirstOrDefault();
if (allowed == null || allowed.direction == workflowparameterdirection.@out)
{
Parameters.Remove(param.Key);
}
}
// Ensure Type
foreach (var wfparam in Workflow.Parameters)
{
if (Parameters.ContainsKey(wfparam.name) && wfparam.type == "System.Int32")
{
if (Parameters[wfparam.name] != null)
{
Parameters[wfparam.name] = int.Parse(Parameters[wfparam.name].ToString());
}
}
else if (Parameters.ContainsKey(wfparam.name) && wfparam.type == "System.Boolean")
{
if (Parameters[wfparam.name] != null)
{
Parameters[wfparam.name] = bool.Parse(Parameters[wfparam.name].ToString());
}
}
}
wfApp = new System.Activities.WorkflowApplication(activity, Parameters);
wfApp.Extensions.Add(TrackingParticipant);
foreach (var t in Plugins.WorkflowExtensionsTypes)
{
try
{
var ext = (ICustomWorkflowExtension)Activator.CreateInstance(t);
ext.Initialize(RobotInstance.instance, Workflow, this);
wfApp.Extensions.Add(ext);
}
catch (Exception ex)
{
Log.Error("error init " + t.Name + ": " + ex.ToString());
}
}
if (Workflow.Serializable)
{
//if (Config.local.localstate)
//{
// if (!System.IO.Directory.Exists(System.IO.Directory.GetCurrentDirectory() + "\\state")) System.IO.Directory.CreateDirectory(System.IO.Directory.GetCurrentDirectory() + "\\state");
// wfApp.InstanceStore = new Store.XMLFileInstanceStore(System.IO.Directory.GetCurrentDirectory() + "\\state");
//}
//else
//{
// wfApp.InstanceStore = new Store.OpenFlowInstanceStore();
//}
wfApp.InstanceStore = new Store.OpenFlowInstanceStore();
}
addwfApphandlers(wfApp);
}
else
{
wfApp = new System.Activities.WorkflowApplication(activity);
wfApp.Extensions.Add(TrackingParticipant);
foreach (var t in Plugins.WorkflowExtensionsTypes)
{
try
{
var ext = (ICustomWorkflowExtension)Activator.CreateInstance(t);
ext.Initialize(RobotInstance.instance, Workflow, this);
wfApp.Extensions.Add(ext);
}
catch (Exception ex)
{
Log.Error("error init " + t.Name + ": " + ex.ToString());
}
}
addwfApphandlers(wfApp);
if (Workflow.Serializable || !Workflow.Serializable)
{
//if (Config.local.localstate)
//{
// if (!System.IO.Directory.Exists(System.IO.Directory.GetCurrentDirectory() + "\\state")) System.IO.Directory.CreateDirectory(System.IO.Directory.GetCurrentDirectory() + "\\state");
// wfApp.InstanceStore = new Store.XMLFileInstanceStore(System.IO.Directory.GetCurrentDirectory() + "\\state");
//}
//else
//{
// wfApp.InstanceStore = new Store.OpenFlowInstanceStore();
//}
wfApp.InstanceStore = new Store.OpenFlowInstanceStore();
}
wfApp.Load(new Guid(InstanceId));
}
state = "loaded";
}
private CancelAsyncResult(WorkflowApplication instance, AsyncCallback callback, object state)
: base(instance, callback, state)
{
}
public TResponse Execute2 <TRequest, TResponse>(TRequest request)
{
resetEvents();
Action <WorkflowApplication> setWFEvents = delegate(WorkflowApplication wf)
{
wf.Idle = delegate(WorkflowApplicationIdleEventArgs e)
{
Console.WriteLine("Workflow idled");
s_idleEvent.Set();
};
wf.Completed = delegate(WorkflowApplicationCompletedEventArgs e)
{
Console.WriteLine("Workflow completed with state {0}.", e.CompletionState.ToString());
if (e.TerminationException != null)
{
Console.WriteLine("TerminationException = {0}; {1}", e.TerminationException.GetType().ToString(), e.TerminationException.Message);
}
s_completedEvent.Set();
};
wf.Unloaded = delegate(WorkflowApplicationEventArgs e)
{
Console.WriteLine("Workflow unloaded");
s_unloadedEvent.Set();
};
wf.PersistableIdle = delegate(WorkflowApplicationIdleEventArgs e)
{
if (instanceStore != null)
{
return(PersistableIdleAction.Unload);
}
return(PersistableIdleAction.None);
};
};
Action waitOne = delegate()
{
if (instanceStore != null)
{
s_unloadedEvent.WaitOne();
}
else
{
s_idleEvent.WaitOne();
}
};
TResponse respnse = default(TResponse);
Dictionary <string, object> inputs = new Dictionary <string, object>();
inputs.Add("Request", request);
WorkflowApplication wfApp = new WorkflowApplication(this.workflow, inputs);
setWFEvents(wfApp);
wfApp.Run();
waitOne();
return(respnse);
}
internal WorkflowApplicationAbortedEventArgs(WorkflowApplication application, Exception reason)
: base(application)
{
this.Reason = reason;
}
public virtual bool CanRun(WorkflowApplication instance) => true;
public UnloadOrPersistAsyncResult(WorkflowApplication instance, TimeSpan timeout, PersistenceOperation operation,
bool isWorkflowThread, bool isInternalPersist, AsyncCallback callback, object state)
: base(callback, state)
{
this.instance = instance;
this.timeoutHelper = new TimeoutHelper(timeout);
this.operation = operation;
this.isInternalPersist = isInternalPersist;
this.isUnloaded = (operation == PersistenceOperation.Unload || operation == PersistenceOperation.Complete);
this.OnCompleting = UnloadOrPersistAsyncResult.completeCallback;
bool completeSelf;
var success = false;
// Save off the current transaction in case we have an async operation before we end
// up creating the WorkflowPersistenceContext and create it on another thread. Do a
// blocking dependent clone that we will complete when we are completed.
//
// This will throw TransactionAbortedException by design, if the transaction is
// already rolled back.
var currentTransaction = Transaction.Current;
if (currentTransaction != null)
{
this.dependentTransaction = currentTransaction.DependentClone(DependentCloneOption.BlockCommitUntilComplete);
}
try
{
if (isWorkflowThread)
{
Fx.Assert(this.instance.Controller.IsPersistable, "The runtime won't schedule this work item unless we've passed the guard");
// We're an internal persistence on the workflow thread which means that we
// are passed the guard already, we have the lock, and we know we aren't detached.
completeSelf = this.InitializeProvider();
success = true;
}
else
{
this.instanceOperation = new RequiresPersistenceOperation();
try
{
if (this.instance.WaitForTurnAsync(this.instanceOperation, this.timeoutHelper.RemainingTime(), waitCompleteCallback, this))
{
completeSelf = this.ValidateState();
}
else
{
completeSelf = false;
}
success = true;
}
finally
{
if (!success)
{
this.NotifyOperationComplete();
}
}
}
}
finally
{
// If we had an exception, we need to complete the dependent transaction.
if (!success)
{
if (this.dependentTransaction != null)
{
this.dependentTransaction.Complete();
}
}
}
if (completeSelf)
{
this.Complete(true);
}
}
private TerminateAsyncResult(WorkflowApplication instance, Exception reason, AsyncCallback callback, object state)
: base(instance, callback, state) => this.reason = reason;
internal WorkflowApplicationEventArgs(WorkflowApplication application)
{
this.Owner = application;
}