private void Window_Loaded(object sender, RoutedEventArgs e)
{
// Open the config file and get the connection string
Configuration config =
ConfigurationManager.OpenExeConfiguration
(ConfigurationUserLevel.None);
ConnectionStringsSection css =
(ConnectionStringsSection)config.GetSection("connectionStrings");
_connectionString =
css.ConnectionStrings["LeadResponse"].ConnectionString;
_instanceStore = new SqlWorkflowInstanceStore(_connectionString);
InstanceView view = _instanceStore.Execute
(_instanceStore.CreateInstanceHandle(),
new CreateWorkflowOwnerCommand(),
TimeSpan.FromSeconds(30));
_instanceStore.DefaultInstanceOwner = view.InstanceOwner;
// Create the DBExtension
_dbExtension = new DBExtension(_connectionString);
// Create a service to handle incoming requests
LoadExistingLeads();
SetupHost();
}
private void Window_Loaded(object sender, RoutedEventArgs e)
{
// Open the config file and get the connection string
Configuration config = ConfigurationManager.OpenExeConfiguration(ConfigurationUserLevel.None);
ConnectionStringsSection css = (ConnectionStringsSection)config.GetSection("connectionStrings");
_connectionString = css.ConnectionStrings["LeadGenerator"].ConnectionString;
_dbExtension = new DBExtension(_connectionString);
_instanceStore = new SqlWorkflowInstanceStore(_connectionString);
InstanceView view = _instanceStore.Execute(_instanceStore.CreateInstanceHandle(), new CreateWorkflowOwnerCommand(), TimeSpan.FromSeconds(30));
_instanceStore.DefaultInstanceOwner = view.InstanceOwner;
// Set up the tracking participants
CreateTrackingParticipant();
CreateETWTrackingParticipant();
CreateSqlTrackingParticipant();
LoadExistingLeads();
}
/// <summary>
/// Creates a test host
/// </summary>
/// <param name="instanceStore">
/// The instance store.
/// </param>
/// <returns>
/// The test host
/// </returns>
private static WorkflowApplicationTest<ActivityWithDelay> CreateTestHost(InstanceStore instanceStore)
{
var host = WorkflowApplicationTest.Create(new ActivityWithDelay());
Debug.Assert(host != null, "host != null");
host.InstanceStore = instanceStore;
host.PersistableIdle += args => PersistableIdleAction.Unload;
return host;
}
internal InstanceHandle(InstanceStore store, InstanceOwner owner)
{
this.thisLock = new object();
this.Version = -1L;
this.Store = store;
this.Owner = owner;
this.View = new InstanceView(owner);
this.IsValid = true;
}
internal InstanceHandle(InstanceStore store, InstanceOwner owner)
{
this.thisLock = new object();
this.Version = -1L;
this.Store = store;
this.Owner = owner;
this.View = new InstanceView(owner);
this.IsValid = true;
}
internal InstanceHandle(InstanceStore store, InstanceOwner owner)
{
Fx.Assert(store != null, "Shouldn't be possible.");
Version = -1;
Store = store;
Owner = owner;
View = new InstanceView(owner);
IsValid = true;
}
internal InstanceHandle(InstanceStore store, InstanceOwner owner)
{
Fx.Assert(store != null, "Shouldn't be possible.");
Version = -1;
Store = store;
Owner = owner;
View = new InstanceView(owner);
IsValid = true;
}
internal PersistenceProviderDirectory(InstanceStore store, InstanceOwner owner, IDictionary<XName, InstanceValue> instanceMetadataChanges, WorkflowDefinitionProvider workflowDefinitionProvider, WorkflowServiceHost serviceHost,
DurableConsistencyScope consistencyScope, int maxInstances)
: this(workflowDefinitionProvider, serviceHost, consistencyScope, maxInstances)
{
Fx.Assert(store != null, "InstanceStore must be specified on PPD.");
Fx.Assert(owner != null, "InstanceOwner must be specified on PPD.");
this.store = store;
this.owner = owner;
this.InstanceMetadataChanges = instanceMetadataChanges;
}
// Creates and configures a new instance of WorkflowApplication
private static WorkflowApplication CreateWorkflowApplication(Activity rootActivity, InstanceStore store, XName wfHostTypeName)
{
WorkflowApplication wfApp = new WorkflowApplication(rootActivity);
wfApp.InstanceStore = store;
Dictionary<XName, object> wfScope = new Dictionary<XName, object>
{
{ WorkflowHostTypePropertyName, wfHostTypeName }
};
// Add the WorkflowHostType value to workflow application so that it stores this data in the instance store when persisted
wfApp.AddInitialInstanceValues(wfScope);
// This statement is optional (see the comments in AbsoluteDelay.CacheMetadata details for more info).
// wfApp.Extensions.Add<DurableTimerExtension>(() => new DurableTimerExtension());
// For demonstration purposes the workflow is unloaded as soon as it is idle (and able to persist)
wfApp.PersistableIdle = delegate(WorkflowApplicationIdleEventArgs idleArgs)
{
Console.WriteLine("Workflow unloading...");
return PersistableIdleAction.Unload;
};
// Configure some tracing and synchronization for the other WorkflowApplication events
wfApp.Unloaded = delegate(WorkflowApplicationEventArgs eargs)
{
if (!workflowCompleted)
{
Console.WriteLine("Workflow unloaded");
}
else
{
Console.WriteLine("Workflow unloaded after completing");
}
workflowUnloadedEvent.Set();
};
wfApp.Completed = delegate
{
Console.WriteLine("Workflow completed");
workflowCompleted = true;
};
wfApp.Aborted = delegate(WorkflowApplicationAbortedEventArgs abortArgs)
{
Console.WriteLine("Workflow aborted (expected in this sample)");
};
return wfApp;
}
static WorkflowApplication CreateWorkflowApplication(AccumulatorActivity activity, InstanceStore instanceStore)
{
var application = new WorkflowApplication(activity);
application.InstanceStore = instanceStore;
application.Completed = new Action<WorkflowApplicationCompletedEventArgs>((e) =>
{
_result = (int)e.Outputs["Sum"];
_more = false;
_event.Set();
});
application.PersistableIdle = new Func<WorkflowApplicationIdleEventArgs, PersistableIdleAction>((e) => PersistableIdleAction.Unload);
application.Extensions.Add(new Notification(NotifySum));
return application;
}
internal InstanceHandle(InstanceStore store, InstanceOwner owner, Guid instanceId)
{
Fx.Assert(store != null, "Shouldn't be possible here either.");
Fx.Assert(instanceId != Guid.Empty, "Should be validating this.");
Version = -1;
Store = store;
Owner = owner;
Id = instanceId;
View = new InstanceView(owner, instanceId);
IsValid = true;
if (Fx.Trace.IsEtwProviderEnabled)
{
eventTraceActivity = new EventTraceActivity(instanceId);
}
}
/// <summary>
/// 创建工作流
/// </summary>
/// <param name="parameters">传入的参数</param>
/// <returns>获取工作流实例的Id值</returns>
public string Create(IDictionary<string, object> parameters)
{
_instanceStore = new SqlWorkflowInstanceStore(connectionString);
InstanceView view = _instanceStore.Execute
(_instanceStore.CreateInstanceHandle(),
new CreateWorkflowOwnerCommand(),
TimeSpan.FromSeconds(30));
_instanceStore.DefaultInstanceOwner = view.InstanceOwner;
WorkflowApplication i = new WorkflowApplication(ActivityXamlServices.Load(path), parameters);
i.InstanceStore = _instanceStore;
i.PersistableIdle = (waiea) => PersistableIdleAction.Unload;
i.Run();
return i.Id.ToString();
}
// Configure a Default Owner for the instance store so instances can be re-loaded from WorkflowApplication
private static InstanceHandle CreateInstanceStoreOwner(InstanceStore store, XName wfHostTypeName)
{
InstanceHandle ownerHandle = store.CreateInstanceHandle();
CreateWorkflowOwnerCommand ownerCommand = new CreateWorkflowOwnerCommand()
{
InstanceOwnerMetadata =
{
{ WorkflowHostTypePropertyName, new InstanceValue(wfHostTypeName) }
}
};
store.DefaultInstanceOwner = store.Execute(ownerHandle, ownerCommand, TimeSpan.FromSeconds(30)).InstanceOwner;
return ownerHandle;
}
internal InstanceHandle(InstanceStore store, InstanceOwner owner, Guid instanceId)
{
Fx.Assert(store != null, "Shouldn't be possible here either.");
Fx.Assert(instanceId != Guid.Empty, "Should be validating this.");
Version = -1;
Store = store;
Owner = owner;
Id = instanceId;
View = new InstanceView(owner, instanceId);
IsValid = true;
if (Fx.Trace.IsEtwProviderEnabled)
{
eventTraceActivity = new EventTraceActivity(instanceId);
}
}
/// <summary>
/// 加载工作流
/// </summary>
/// <param name="id">工作流的唯一标示</param>
/// <param name="bookMark">标签名称</param>
/// <param name="ids">恢复指定名称的书签的时候，传入的参数</param>
/// <returns>工作流的加载的状态</returns>
public string Load(string id, object inputs = null)
{
_instanceStore = new SqlWorkflowInstanceStore(connectionString);
InstanceView view = _instanceStore.Execute
(_instanceStore.CreateInstanceHandle(),
new CreateWorkflowOwnerCommand(),
TimeSpan.FromSeconds(30));
_instanceStore.DefaultInstanceOwner = view.InstanceOwner;
WorkflowApplication i = new WorkflowApplication(ActivityXamlServices.Load(path));
i.InstanceStore = _instanceStore;
i.PersistableIdle = (waiea) => PersistableIdleAction.Unload;
i.Load(new Guid(id));
return i.ResumeBookmark(bookMark, inputs).GetString();
}
private static void WaitForRunnableInstance(InstanceStore store, InstanceHandle ownerHandle)
{
IEnumerable<InstancePersistenceEvent> events = store.WaitForEvents(ownerHandle, TimeSpan.MaxValue);
bool foundRunnable = false;
// Loop through the persistence events looking for the HasRunnableWorkflow event (in this sample, it corresponds with
// the workflow instance whose timer has expired and is ready to be resumed by the host).
foreach (InstancePersistenceEvent persistenceEvent in events)
{
if (persistenceEvent.Equals(HasRunnableWorkflowEvent.Value))
{
foundRunnable = true;
break;
}
}
if (!foundRunnable)
{
throw new ApplicationException("Unexpected: No runnable instances found in the instance store");
}
}
/// <summary>
/// Opens the host
/// </summary>
/// <param name="workflowServiceFile">
/// The workflow service file.
/// </param>
/// <param name="serviceUri">
/// The service URI.
/// </param>
/// <param name="instanceStore">
/// The instance Store.
/// </param>
/// <param name="behaviors">
/// The behaviors.
/// </param>
/// <returns>
/// The workflow service host
/// </returns>
public static WorkflowServiceTestHost Open(
string workflowServiceFile, Uri serviceUri, InstanceStore instanceStore, params IServiceBehavior[] behaviors)
{
Contract.Requires(!string.IsNullOrWhiteSpace(workflowServiceFile));
if (string.IsNullOrWhiteSpace(workflowServiceFile))
{
throw new ArgumentNullException("workflowServiceFile");
}
Contract.Requires(serviceUri != null);
if (serviceUri == null)
{
throw new ArgumentNullException("serviceUri");
}
return Open((WorkflowService)XamlServices.Load(workflowServiceFile), serviceUri, instanceStore, behaviors);
}
internal WorkflowApplication CreateWorkflowApplication(AccumulatorActivity activity, InstanceStore instanceStore)
{
var application = new WorkflowApplication(activity);
application.InstanceStore = instanceStore;
application.Unloaded = new Action<WorkflowApplicationEventArgs>((e) =>
{
this.Suspended = true;
this.SyncEvent.Set();
});
application.Completed = new Action<WorkflowApplicationCompletedEventArgs>((e) =>
{
this.Sum = (int)e.Outputs["Sum"];
this.Completed = true;
this.SyncEvent.Set();
});
application.PersistableIdle = new Func<WorkflowApplicationIdleEventArgs, PersistableIdleAction>((e) => PersistableIdleAction.Unload);
application.Extensions.Add(new Notification(NotifySum));
this.Suspended = false;
return application;
}
/// <summary>
/// The open.
/// </summary>
/// <param name="xamlReader">
/// The XAML reader.
/// </param>
/// <param name="serviceUri">
/// The service URI.
/// </param>
/// <param name="instanceStore">
/// The instance Store.
/// </param>
/// <param name="behaviors">
/// The behaviors.
/// </param>
/// <returns>
/// An opened WorkflowServiceTestHost
/// </returns>
public static WorkflowServiceTestHost Open(
XamlReader xamlReader, Uri serviceUri, InstanceStore instanceStore, params IServiceBehavior[] behaviors)
{
Contract.Requires(xamlReader != null);
if (xamlReader == null)
{
throw new ArgumentNullException("xamlReader");
}
Contract.Requires(serviceUri != null);
if (serviceUri == null)
{
throw new ArgumentNullException("serviceUri");
}
return Open((WorkflowService)XamlServices.Load(xamlReader), serviceUri, instanceStore, behaviors);
}
/// <summary>
/// Opens the host
/// </summary>
/// <param name="workflowService">
/// The workflow service.
/// </param>
/// <param name="serviceEndpoint">
/// The service endpoint.
/// </param>
/// <param name="instanceStore">
/// The instance Store.
/// </param>
/// <param name="behaviors">
/// The behaviors.
/// </param>
/// <returns>
/// The workflow service host
/// </returns>
public static WorkflowServiceTestHost Open(
WorkflowService workflowService,
EndpointAddress serviceEndpoint,
InstanceStore instanceStore,
params IServiceBehavior[] behaviors)
{
Contract.Requires(workflowService != null);
if (workflowService == null)
{
throw new ArgumentNullException("workflowService");
}
Contract.Requires(serviceEndpoint != null);
if (serviceEndpoint == null)
{
throw new ArgumentNullException("serviceEndpoint");
}
return Open(workflowService, serviceEndpoint.Uri, instanceStore, behaviors);
}
private static void SetupInstanceStore()
{
instanceStore =
new SqlWorkflowInstanceStore(@"Data Source=.\SQLEXPRESS;Initial Catalog=SampleInstanceStore;Integrated Security=True;Asynchronous Processing=True");
InstanceHandle handle = instanceStore.CreateInstanceHandle();
InstanceView view = instanceStore.Execute(handle, new CreateWorkflowOwnerCommand(), TimeSpan.FromSeconds(30));
handle.Free();
instanceStore.DefaultInstanceOwner = view.InstanceOwner;
}
public DefaultWorkflowApplicationHostInstanceStore(InstanceStore instanceStore)
{
if(instanceStore == null) throw new ArgumentNullException("instanceStore");
_instanceStore = instanceStore;
}
internal PersistenceProviderDirectory(InstanceStore store, InstanceOwner owner, IDictionary<XName, InstanceValue> instanceMetadataChanges, Activity workflowDefinition, WorkflowServiceHost serviceHost, DurableConsistencyScope consistencyScope, int maxInstances) : this(workflowDefinition, serviceHost, consistencyScope, maxInstances)
{
this.store = store;
this.owner = owner;
this.InstanceMetadataChanges = instanceMetadataChanges;
}
/// <summary>
/// The open.
/// </summary>
/// <param name="xmlReader">
/// The xml reader.
/// </param>
/// <param name="serviceEndpoint">
/// The service endpoint.
/// </param>
/// <param name="instanceStore">
/// The instance Store.
/// </param>
/// <param name="behaviors">
/// The behaviors.
/// </param>
/// <returns>
/// An opened WorkflowServiceTestHost
/// </returns>
public static WorkflowServiceTestHost Open(
XmlReader xmlReader,
EndpointAddress serviceEndpoint,
InstanceStore instanceStore,
params IServiceBehavior[] behaviors)
{
Contract.Requires(xmlReader != null);
if (xmlReader == null)
{
throw new ArgumentNullException("xmlReader");
}
Contract.Requires(serviceEndpoint != null);
if (serviceEndpoint == null)
{
throw new ArgumentNullException("serviceEndpoint");
}
return Open((WorkflowService)XamlServices.Load(xmlReader), serviceEndpoint, instanceStore, behaviors);
}
public void Open()
{
this.instanceStore = new SqlWorkflowInstanceStore(connectionString);
CreateWorkflowOwnerCommand createWorkflowOwnerCommand = new CreateWorkflowOwnerCommand();
InstanceHandle handle = this.instanceStore.CreateInstanceHandle();
try
{
this.instanceStore.BeginExecute(handle, createWorkflowOwnerCommand, TimeSpan.FromSeconds(30), OnInstanceStoreEndExecute, null);
}
catch (InstancePersistenceException persistenceException)
{
WriteException(persistenceException, "An error has occured setting up the InstanceStore");
}
}
/// <summary>
/// Opens the host
/// </summary>
/// <param name="workflowService">
/// The workflow service.
/// </param>
/// <param name="serviceUri">
/// The service URI.
/// </param>
/// <param name="instanceStore">
/// The instance Store.
/// </param>
/// <param name="behaviors">
/// The behaviors.
/// </param>
/// <returns>
/// The workflow service host
/// </returns>
public static WorkflowServiceTestHost Open(
WorkflowService workflowService,
Uri serviceUri,
InstanceStore instanceStore,
params IServiceBehavior[] behaviors)
{
Contract.Requires(workflowService != null);
Contract.Requires(serviceUri != null);
if (workflowService == null)
{
throw new ArgumentNullException("workflowService");
}
if (serviceUri == null)
{
throw new ArgumentNullException("serviceUri");
}
var workflowServiceTestHost = new WorkflowServiceTestHost(workflowService, serviceUri);
if (instanceStore != null)
{
workflowServiceTestHost.InstanceStore = instanceStore;
}
if (behaviors != null)
{
Debug.Assert(workflowServiceTestHost.Host != null, "workflowServiceTestHost.Host != null");
Debug.Assert(
workflowServiceTestHost.Host.Description != null, "workflowServiceTestHost.Host.Description != null");
Debug.Assert(
workflowServiceTestHost.Host.Description.Behaviors != null,
"workflowServiceTestHost.Host.Description.Behaviors != null");
foreach (var serviceBehavior in behaviors)
{
workflowServiceTestHost.Host.Description.Behaviors.Add(serviceBehavior);
}
}
workflowServiceTestHost.Open();
return workflowServiceTestHost;
}