跟踪workflow instance 状态

场景是这样的:
1.workflowruntime启动了持久化和监听服务
2.workfllowruntime创建多个实例,并启动,一些会长时间延时,一些会中途暂停,会不同的执行状态(业务状态)
3.另有一winform控制台,有个表格,刷新显示每个实例的信息,包括业务状态--比如创建,运行,挂起等
4.通过workflowruntime.GetLoadedWorkflows()方法取得所有实例,但却没有办法得到正确的业务状态

当然,当将实例unload,再load后(实例回写到数据库),通过SqlTrackingQuery查询得到SqlTrackingWorkflowInstance.Status是可以.可是实际上,不可能一刷新实例表格就要将实例unload.所以,在想有没有办法在workflowruntime平台上,获取实例的业务状态.
决定自己写个类,解决这个问题,思路如下:
1.在宿主中构建Dictionary<Guid, TrackingStatus>,用于维护instance状态
2.预订workflowruntime与instance相关的事件
3.在事件处理方法中更新instance对应的trackingstatus
4.定义event WorkflowStatusChangeEventHandler WorkflowStatusChanged事件,以便状态变化时处理

两个类:

TrackingStatus
1

using System;
2

using System.Collections.Generic;
3

using System.Text;
4

using System.Workflow;
6

using System.Workflow.Runtime;
7

using System.Workflow.Runtime.Hosting;
8

using System.Workflow.Runtime.Tracking;
9

using System.Workflow.Activities;
10

using System.Workflow.ComponentModel;
11

namespace WFDebugger
13

{
14

public class TrackingStatus
15

{
16

private WorkflowInstance instance;
17

private WorkflowStatus status;
18

private DateTime lasteventtime;
19

public TrackingStatus(WorkflowInstance instance, WorkflowStatus status, System.DateTime eventtime)
21

{
22

if (instance == null || eventtime == null)
23

{
24

throw(new ArgumentNullException("instance|status|eventtime"));
25

}
26

this.instance = instance;
27

this.status = status;
28

this.lasteventtime = eventtime;
29

}
30

public TrackingStatus(WorkflowInstance instance, WorkflowStatus status)
32

{
33

if (instance == null)
34

{
35

throw (new ArgumentNullException("instance|status|eventtime"));
36

}
37

this.instance = instance;
38

this.status = status;
39

this.lasteventtime = DateTime.Now;
40

}
41

public WorkflowInstance Instance
43

{
44

get
45

{
46

return instance;
47

}
48

}
49

public WorkflowStatus Status
51

{
52

get
53

{
54

return status;
55

}
56

}
57

public DateTime LastEventTime
59

{
60

get
61

{
62

return lasteventtime;
63

}
64

}
65

public void ChangeStatus(WorkflowStatus status, DateTime eventtime)
67

{
68

if (!TryChangeStatus(status, eventtime,new TimeSpan(0,0,10)))
69

{
70

throw(new Exception("can't lock variable"));
71

}
72

}
73

public void ChangeStatus(WorkflowStatus status)
75

{
76

ChangeStatus(status, DateTime.Now);
77

}
78

public bool TryChangeStatus(WorkflowStatus status, DateTime eventtime,TimeSpan timeout)
80

{
81

if (System.Threading.Monitor.TryEnter(this.status, timeout))
82

{
83

this.status = status;
84

lasteventtime = eventtime;
85

return true;
86

}
87

else
88

{
89

return false;
90

}
91

}
92

public bool TryChangeStatus(WorkflowStatus status, TimeSpan timeout)
93

{
94

return TryChangeStatus(status,DateTime.Now, timeout);
95

}
96

}
97

}
98

TrackingWorkflowEvent
1

using System;
2

using System.Collections;
3

using System.Collections.Generic;
4

using System.Data;
5

using System.Workflow;
7

using System.Workflow.Runtime;
8

using System.Workflow.Runtime.Hosting;
9

using System.Workflow.Runtime.Tracking;
10

using System.Workflow.Activities;
11

using System.Workflow.ComponentModel;
12

using System.Collections.ObjectModel;
13

namespace WFDebugger
17

{
18

class TrackingWorkflowEvent:IDisposable
19

{
20

事件#region 事件
22

public delegate void WorkflowStatusChangeEventHandler(object sender, WorkflowStatusChangeEventArgs e);
23

public event WorkflowStatusChangeEventHandler WorkflowStatusChanged;
24

void RaiseWorkflowStatusChangeEvent(WorkflowRuntime runtime,WorkflowStatusChangeEventArgs e)
25

{
26

if (WorkflowStatusChanged != null)
27

{
28

WorkflowStatusChanged.Invoke(runtime, e);
29

}
30

}
31

#endregion
32

私有变量#region 私有变量
34

private WorkflowRuntime workflowruntime;
35

private SqlTrackingService trackingservice;
36

private SqlWorkflowPersistenceService persistenceService;
37

private bool initialized = false;
38

private bool tacked = false;
39

private Dictionary<Guid, TrackingStatus> dic = new Dictionary<Guid, TrackingStatus>();
41

#endregion
43

public TrackingWorkflowEvent(WorkflowRuntime workflowruntime)
45

{
46

if (workflowruntime != null)
47

{
48

this.workflowruntime = workflowruntime;
49

ReadOnlyCollection<SqlTrackingService> tcol = workflowruntime.GetAllServices<SqlTrackingService>();
50

if (tcol != null && tcol.Count > 0)
51

{
52

trackingservice = tcol[0];
53

}
54

else
55

{
56

throw (new Exception("Workflowruntime havn't TrackingService."));
57

}
58

ReadOnlyCollection<SqlWorkflowPersistenceService> pcol = workflowruntime.GetAllServices<SqlWorkflowPersistenceService>();
60

if (pcol != null && pcol.Count > 0)
61

{
62

persistenceService = pcol[0];
63

}
64

else
65

{
66

throw (new Exception("Workflowruntime havn't WorkflowPersistenceService."));
67

}
68

//runtime event
70

workflowruntimeStarted = new EventHandler<WorkflowRuntimeEventArgs>(workflowRuntime_Started);
71

workflowruntimeServicesExceptionNotHandled = new EventHandler<ServicesExceptionNotHandledEventArgs>(workflowRuntime_ServicesExceptionNotHandled);
72

workflowruntimeStopped = new EventHandler<WorkflowRuntimeEventArgs>(workflowRuntime_Stopped);
73

//instance event
75

workflowruntimeWorkflowCompleted = new EventHandler<WorkflowCompletedEventArgs>(workflowRuntime_WorkflowCompleted);
76

workflowruntimeWorkflowTerminated = new EventHandler<WorkflowTerminatedEventArgs>(workflowRuntime_WorkflowTerminated);
77

workflowruntimeWorkflowSuspended = new EventHandler<WorkflowSuspendedEventArgs>(workflowRuntime_WorkflowSuspended);
78

workflowruntimeWorkflowAborted = new EventHandler<WorkflowEventArgs>(workflowRuntime_WorkflowAborted);
79

workflowruntimeWorkflowResumed = new EventHandler<WorkflowEventArgs>(workflowRuntime_WorkflowResumed);
80

workflowruntimeWorkflowLoaded = new EventHandler<WorkflowEventArgs>(workflowRuntime_WorkflowLoaded);
81

workflowruntimeWorkflowIdled = new EventHandler<WorkflowEventArgs>(workflowRuntime_WorkflowIdled);
82

workflowruntimeWorkflowPersisted = new EventHandler<WorkflowEventArgs>(workflowRuntime_WorkflowPersisted);
83

workflowruntimeWorkflowUnloaded = new EventHandler<WorkflowEventArgs>(workflowRuntime_WorkflowUnloaded);
84

workflowruntimeWorkflowCreated = new EventHandler<WorkflowEventArgs>(workflowRuntime_WorkflowCreated);
85

workflowruntimeWorkflowStarted = new EventHandler<WorkflowEventArgs>(workflowRuntime_WorkflowStarted);
86

initialized = true;
88

}
89

else
90

{
91

throw (new ArgumentNullException("workflowruntime"));
92

}
93

}
94

私有方法#region 私有方法
96

private bool AddInstance(WorkflowInstance instance)
97

{
98

if (instance == null)
99

{
100

throw(new ArgumentNullException("instance"));
101

}
102

if (instance.WorkflowRuntime != workflowruntime)
103

{
104

throw (new Exception("different workflowruntime"));
105

}
106

SqlTrackingQuery sq = new SqlTrackingQuery(trackingservice.ConnectionString);
107

SqlTrackingWorkflowInstance sqi ;
108

if (sq.TryGetWorkflow(instance.InstanceId, out sqi))
109

{
110

dic.Add(instance.InstanceId, new TrackingStatus(instance, sqi.Status));
111

RaiseWorkflowStatusChangeEvent(workflowruntime, new WorkflowStatusChangeEventArgs(instance,sqi.Status));
112

return true;
113

}
114

else
115

return false;
116

}
117

private bool AddInstance(WorkflowInstance instance,WorkflowStatus status)
118

{
119

if (instance == null)
120

{
121

throw (new ArgumentNullException("instance"));
122

}
123

if (instance.WorkflowRuntime != workflowruntime)
124

{
125

throw (new Exception("different workflowruntime"));
126

}
127

dic.Add(instance.InstanceId, new TrackingStatus(instance, status));
128

RaiseWorkflowStatusChangeEvent(workflowruntime, new WorkflowStatusChangeEventArgs(instance, status));
129

return true;
130

}
131

132

private void RemoveInstance(WorkflowInstance instance)
133

{
134

if (instance == null)
135

{
136

throw (new ArgumentNullException("instance"));
137

}
138

if (instance.WorkflowRuntime != workflowruntime)
139

{
140

throw (new Exception("different workflowruntime"));
141

}
142

RemoveInstance(instance.InstanceId);
143

}
144

private void RemoveInstance(Guid instanceid)
145

{
146

//if (instanceid == null)
147

//{
148

// throw (new ArgumentNullException("instanceid"));
149

//}
150

if (dic.ContainsKey(instanceid))
151

{
152

dic.Remove(instanceid);
153

}
154

else
155

{
156

throw (new Exception("no found appointed instance"));
157

}
158

159

160

}
161

private bool ChangeStatus(WorkflowInstance instance, WorkflowStatus status)
162

{
163

if (instance == null)
164

{
165

throw (new ArgumentNullException("instance"));
166

}
167

//if (status == null)
168

//{
169

// throw (new ArgumentNullException("status"));
170

//}
171

if (dic.ContainsKey(instance.InstanceId))
172

{
173

TrackingStatus ts = dic[instance.InstanceId];
174

bool r = ts.TryChangeStatus(status,new TimeSpan(0,0,10));
175

RaiseWorkflowStatusChangeEvent(workflowruntime, new WorkflowStatusChangeEventArgs(instance, status));
176

return r;
177

}
178

else
179

{
180

return false;
181

//return AddInstance(instance, status);
182

}
183

184

185

}
186

#endregion
187

188

公开属性#region 公开属性
189

/**//// <summary>
190

/// 工作流环境
191

/// </summary>
192

public WorkflowRuntime WorkflowRuntime
193

{
194

get
195

{
196

return workflowruntime;
197

}
198

}
199

200

/**//// <summary>
201

/// 实例数量
202

/// </summary>
203

public int Count
204

{
205

get
206

{
207

return dic.Count;
208

}
209

}
210

211

/**//// <summary>
212

/// 是否在跟踪
213

/// </summary>
214

public bool IsOnTracking
215

{
216

get
217

{
218

return tacked;
219

}
220

}
221

/**//// <summary>
222

/// 是否初始化
223

/// </summary>
224

public bool Initialized
225

{
226

get
227

{
228

return initialized;
229

}
230

}
231

public WorkflowStatus GetWorkflowStatus(Guid instanceID)
232

{
233

//if (instanceID == null)
234

//{
235

// throw(new ArgumentNullException("instanceID"));
236

//}
237

if (dic.ContainsKey(instanceID))
238

{
239

return dic[instanceID].Status;
240

}
241

else
242

{
243

throw(new Exception("no found appointed instance"));
244

//return AddInstance(instance, status);
245

}
246

}
247

public WorkflowStatus GetWorkflowStatus(WorkflowInstance instance)
248

{
249

if (instance == null)
250

{
251

throw (new ArgumentNullException("instance"));
252

}
253

if (instance.WorkflowRuntime != workflowruntime)
254

{
255

throw (new Exception("different workflowruntime"));
256

}
257

return GetWorkflowStatus(instance.InstanceId);
258

}
259

260

#endregion
261

262

Runtime Event#region Runtime Event
263

264

事件句柄#region 事件句柄
265

//runtime event
266

EventHandler<WorkflowRuntimeEventArgs> workflowruntimeStarted;
267

EventHandler<ServicesExceptionNotHandledEventArgs> workflowruntimeServicesExceptionNotHandled;
268

EventHandler<WorkflowRuntimeEventArgs> workflowruntimeStopped;
269

270

//instance event
271

EventHandler<WorkflowCompletedEventArgs> workflowruntimeWorkflowCompleted;
272

EventHandler<WorkflowTerminatedEventArgs> workflowruntimeWorkflowTerminated;
273

EventHandler<WorkflowSuspendedEventArgs> workflowruntimeWorkflowSuspended;
274

EventHandler<WorkflowEventArgs> workflowruntimeWorkflowAborted;
275

EventHandler<WorkflowEventArgs> workflowruntimeWorkflowResumed;
276

EventHandler<WorkflowEventArgs> workflowruntimeWorkflowLoaded;
277

EventHandler<WorkflowEventArgs> workflowruntimeWorkflowIdled;
278

EventHandler<WorkflowEventArgs> workflowruntimeWorkflowPersisted;
279

EventHandler<WorkflowEventArgs> workflowruntimeWorkflowUnloaded;
280

EventHandler<WorkflowEventArgs> workflowruntimeWorkflowCreated;
281

EventHandler<WorkflowEventArgs> workflowruntimeWorkflowStarted;
282

283

public void TackEvent()
284

{
285

if (initialized && !tacked)
286

{
287

预定事件#region 预定事件
288

//runtime event
289

workflowruntime.Started += workflowruntimeStarted;
290

workflowruntime.ServicesExceptionNotHandled += workflowruntimeServicesExceptionNotHandled;
291

workflowruntime.Stopped += workflowruntimeStopped;
292

293

//instance event
294

workflowruntime.WorkflowCompleted += workflowruntimeWorkflowCompleted;
295

workflowruntime.WorkflowTerminated += workflowruntimeWorkflowTerminated;
296

workflowruntime.WorkflowSuspended += workflowruntimeWorkflowSuspended;
297

workflowruntime.WorkflowAborted += workflowruntimeWorkflowAborted;
298

workflowruntime.WorkflowResumed += workflowruntimeWorkflowResumed;
299

workflowruntime.WorkflowLoaded += workflowruntimeWorkflowLoaded;
300

workflowruntime.WorkflowIdled += workflowruntimeWorkflowIdled;
301

workflowruntime.WorkflowPersisted += workflowruntimeWorkflowPersisted;
302

workflowruntime.WorkflowUnloaded += workflowruntimeWorkflowUnloaded;
303

workflowruntime.WorkflowCreated += workflowruntimeWorkflowCreated;
304

workflowruntime.WorkflowStarted += workflowruntimeWorkflowStarted;
305

#endregion
306

tacked = true;
307

}
308

else
309

{
310

throw( new Exception("TrackingWorkflowEvent didn't initialized or TrackingInstanceEvent tacked event"));
311

}
312

}
313

314

public void UntackEvent()
315

{
316

if (initialized && tacked)
317

{
318

卸载事件#region 卸载事件
319

//runtime event
320

workflowruntime.Started -= workflowruntimeStarted;
321

workflowruntime.ServicesExceptionNotHandled -= workflowruntimeServicesExceptionNotHandled;
322

workflowruntime.Stopped -= workflowruntimeStopped;
323

324

//instance event
325

workflowruntime.WorkflowCompleted -= workflowruntimeWorkflowCompleted;
326

workflowruntime.WorkflowTerminated -= workflowruntimeWorkflowTerminated;
327

workflowruntime.WorkflowSuspended -= workflowruntimeWorkflowSuspended;
328

workflowruntime.WorkflowAborted -= workflowruntimeWorkflowAborted;
329

workflowruntime.WorkflowResumed -= workflowruntimeWorkflowResumed;
330

workflowruntime.WorkflowLoaded -= workflowruntimeWorkflowLoaded;
331

workflowruntime.WorkflowIdled -= workflowruntimeWorkflowIdled;
332

workflowruntime.WorkflowPersisted -= workflowruntimeWorkflowPersisted;
333

workflowruntime.WorkflowUnloaded -= workflowruntimeWorkflowUnloaded;
334

workflowruntime.WorkflowCreated -= workflowruntimeWorkflowCreated;
335

workflowruntime.WorkflowStarted -= workflowruntimeWorkflowStarted;
336

337

#endregion
338

339

tacked = false;
340

}
341

else
342

{
343

throw (new Exception("TrackingWorkflowEvent didn't initialized or TrackingInstanceEvent didn't tack event"));
344

}
345

}
346

347

#endregion
348

349

事件处理#region 事件处理
350

351

runtime event#region runtime event
352

void workflowRuntime_Started(object sender, WorkflowRuntimeEventArgs e)
353

{
354

Console.WriteLine("TrackingWorkflowEvent: Workflow runtime started(启动)\tDateTime(时间) : {1}.{2}", e.IsStarted, DateTime.Now, DateTime.Now.Millisecond);
355

}
356

357

void workflowRuntime_ServicesExceptionNotHandled(object sender, ServicesExceptionNotHandledEventArgs e)
358

{
359

Console.WriteLine("TrackingWorkflowEvent: Workflow runtime services exception not handled(异常)[{0}]\tDateTime(时间) : {1}.{2}", e.Exception, DateTime.Now, DateTime.Now.Millisecond);
360

}
361

362

void workflowRuntime_Stopped(object sender, WorkflowRuntimeEventArgs e)
363

{
364

dic.Clear();
365

Console.WriteLine("TrackingWorkflowEvent: Workflow runtime stopped(停止)\tDateTime(时间) : {1}.{2}", e.IsStarted, DateTime.Now, DateTime.Now.Millisecond);
366

}
367

#endregion runtime event
368

369

instance event#region instance event
370

void workflowRuntime_WorkflowCompleted(object sender, WorkflowCompletedEventArgs e)
371

{
372

ChangeStatus(e.WorkflowInstance, WorkflowStatus.Completed);
373

Console.WriteLine("TrackingWorkflowEvent: Workflow {0} \tcompleted(完成)\tDateTime(时间) : {1}.{2}", e.WorkflowInstance.InstanceId, DateTime.Now, DateTime.Now.Millisecond);
374

}
375

376

void workflowRuntime_WorkflowTerminated(object sender, WorkflowTerminatedEventArgs e)
377

{
378

ChangeStatus(e.WorkflowInstance, WorkflowStatus.Terminated);
379

Console.WriteLine("TrackingWorkflowEvent: Workflow {0} \tterminated(结束)\tDateTime(时间) : {1}.{2}\tmessage:{3}", e.WorkflowInstance.InstanceId, DateTime.Now, DateTime.Now.Millisecond, e.Exception.Message);
380

}
381

382

void workflowRuntime_WorkflowSuspended(object sender, WorkflowSuspendedEventArgs e)
383

{
384

ChangeStatus(e.WorkflowInstance, WorkflowStatus.Suspended);
385

Console.WriteLine("TrackingWorkflowEvent: Workflow {0} \tsuspended(暂停)\tDateTime(时间) : {1}.{2}\tmessage:{3}", e.WorkflowInstance.InstanceId, DateTime.Now, DateTime.Now.Millisecond, e.Error);
386

}
387

388

void workflowRuntime_WorkflowResumed(object sender, WorkflowEventArgs e)
389

{
390

ChangeStatus(e.WorkflowInstance, WorkflowStatus.Running);
391

Console.WriteLine("TrackingWorkflowEvent: Workflow {0} \tresumed(继续)\tDateTime(时间) : {1}.{2}", e.WorkflowInstance.InstanceId, DateTime.Now, DateTime.Now.Millisecond);
392

}
393

394

void workflowRuntime_WorkflowAborted(object sender, WorkflowEventArgs e)
395

{
396

ChangeStatus(e.WorkflowInstance, WorkflowStatus.Terminated);
397

Console.WriteLine("TrackingWorkflowEvent: Workflow {0} \taborted(中断)\tDateTime(时间) : {1}.{2}", e.WorkflowInstance.InstanceId, DateTime.Now, DateTime.Now.Millisecond);
398

}
399

400

void workflowRuntime_WorkflowIdled(object sender, WorkflowEventArgs e)
401

{
402

ChangeStatus(e.WorkflowInstance, WorkflowStatus.Running);
403

Console.WriteLine("TrackingWorkflowEvent: Workflow {0} \tidled(空闲)\tDateTime(时间) : {1}.{2}", e.WorkflowInstance.InstanceId, DateTime.Now, DateTime.Now.Millisecond);
404

}
405

406

void workflowRuntime_WorkflowUnloaded(object sender, WorkflowEventArgs e)
407

{
408

RemoveInstance(e.WorkflowInstance);
409

Console.WriteLine("TrackingWorkflowEvent: Workflow {0} \tunloaded(卸载)\tDateTime(时间) : {1}.{2}", e.WorkflowInstance.InstanceId, DateTime.Now, DateTime.Now.Millisecond);
410

}
411

412

void workflowRuntime_WorkflowPersisted(object sender, WorkflowEventArgs e)
413

{
414

Console.WriteLine("TrackingWorkflowEvent: Workflow {0} \tpersisted(持久)\tDateTime(时间) : {1}.{2}", e.WorkflowInstance.InstanceId, DateTime.Now, DateTime.Now.Millisecond);
415

}
416

417

void workflowRuntime_WorkflowLoaded(object sender, WorkflowEventArgs e)
418

{
419

AddInstance(e.WorkflowInstance);
420

Console.WriteLine("TrackingWorkflowEvent: Workflow {0} \tloaded(加载)\tDateTime(时间) : {1}.{2}", e.WorkflowInstance.InstanceId, DateTime.Now, DateTime.Now.Millisecond);
421

}
422

423

void workflowRuntime_WorkflowCreated(object sender, WorkflowEventArgs e)
424

{
425

AddInstance(e.WorkflowInstance, WorkflowStatus.Created);
426

Console.WriteLine("TrackingWorkflowEvent: Workflow {0} \tcreated(创建)\tDateTime(时间) : {1}.{2}", e.WorkflowInstance.InstanceId, DateTime.Now, DateTime.Now.Millisecond);
427

}
428

429

void workflowRuntime_WorkflowStarted(object sender, WorkflowEventArgs e)
430

{
431

ChangeStatus(e.WorkflowInstance, WorkflowStatus.Running);
432

Console.WriteLine("TrackingWorkflowEvent: Workflow {0} \tstarted(启动)\tDateTime(时间) : {1}.{2}", e.WorkflowInstance.InstanceId, DateTime.Now, DateTime.Now.Millisecond);
433

}
434

435

436

#endregion instance event
437

438

439

#endregion 事件处理
440

441

#endregion
442

443

IDisposable Members#region IDisposable Members
444

445

public void Dispose()
446

{
447

if (dic != null)
448

{
449

dic.Clear();
450

dic = null;
451

}
452

}
453

454

#endregion
455

}
456

457

}

使用方便:

            trackingworkflowevent = new TrackingWorkflowEvent(workflowRuntime);     //创建
            trackingworkflowevent.TackEvent();                                                          //预订事件
            trackingworkflowevent.GetWorkflowStatus(instance);                                       //获取instance状态
            trackingworkflowevent.UntackEvent();                                                     //卸载事件
            trackingworkflowevent.Dispose();                                                             //消毁

转载于:https://www.cnblogs.com/net66/archive/2006/10/26/541184.html

跟踪workflow instance 状态相关推荐

连接跟踪TCP协议状态转换
在TCP报文处理函数nf_conntrack_tcp_packet中,根据连接的方向dir.索引index和旧的状态值,由tcp_conntracks全局数组来确定新的TCP状态. int nf_co ...
Magento后台订单跟踪 - 修改订单状态
我们可能有这样的一个需求,因为从一个订单生成到订单发货完成当中有一系列过程需要跟踪,比如订单确认,订单处理,订单发货等等一些跟踪状态,我们都需要去备注,这样客户在登录后台的时候很清晰的知道他们的订单当 ...
目标跟踪“Siamese Instance Search for Tracking”
使用siamese深度网络,no model updating, no occlusion detection, no combination of trackers, no geometric ma ...
linux 连接跟踪nf_conntrack 与 NAT和状态防火墙
本文主要记录对于连接跟踪以及其主要应用的NAT和状态iptables的学习内容连接跟踪什么是连接跟踪? 连接跟踪是Linux内核中引入的nf_conntrack 模块所实现的功能,同时支持IPv4 ...
目标跟踪：在视频序列中跟踪特定对象的位置和状态
目录 1. 概述 2. 数据准备 3. 特征提取 4. 卡尔曼滤波器 5. 目标跟踪 6. 改进和扩展 1. 概述在这个项目中,我们将使用预训练的 CNN 模型作为特征提取器,提取视频帧中的目标对象 ...
WEB服务器状态跟踪
状态跟踪 http协议是一种无状态的协议,当请求/响应完成后,连接会断开.服务器会认为每次请求的用户都是新用户,从而无法跟踪用户的状态.但是,在开发中,很多时候服务器需要跟踪用户的状态,从而进行一系列 ...
Microsoft Windows Workflow Foundation 入门：开发人员演练
有关向 Windows 平台添加工作流支持的初步知识 Microsoft Windows Workflow Foundation (WWF) 是一个可扩展框架,用于在 Windows 平台上开发工作流 ...
Windows workflow foundation入门
Microsoft Windows Workflow Foundation (WWF) 是一个可扩展框架,用于在 Windows 平台上开发工作流解决方案.作为即将问世的 Microsoft WinF ...
Microsoft Windows Workflow Foundation
Dino Esposito Solid Quality Learning 适用于: Microsoft Windows Workflow Foundation Microsoft Windows Vi ...

跟踪workflow instance 状态

跟踪workflow instance 状态相关推荐

最新文章

热门文章