protected override IAsyncResult BeginExecute(AsyncCodeActivityContext context, AsyncCallback callback, object state)
{
Func<Int32, List<SalesOrderDetail>> asyncWork = orderId => RetrieveOrderDetail(orderId);
context.UserState = asyncWork;
return asyncWork.BeginInvoke(SalesOrderId.Get(context), callback, state);
}
internal sealed override void InternalExecute(System.Activities.ActivityInstance instance, ActivityExecutor executor, BookmarkManager bookmarkManager)
{
AsyncOperationContext asyncContext = executor.SetupAsyncOperationBlock(instance);
instance.IncrementBusyCount();
AsyncCodeActivityContext context = new AsyncCodeActivityContext(asyncContext, instance, executor);
bool flag = false;
try
{
IAsyncResult result = this.BeginExecute(context, OnExecuteComplete, asyncContext);
if (result == null)
{
throw FxTrace.Exception.AsError(new InvalidOperationException(System.Activities.SR.BeginExecuteMustNotReturnANullAsyncResult));
}
if (!object.ReferenceEquals(result.AsyncState, asyncContext))
{
throw FxTrace.Exception.AsError(new InvalidOperationException(System.Activities.SR.BeginExecuteMustUseProvidedStateAsAsyncResultState));
}
if (result.CompletedSynchronously)
{
this.EndExecute(context, result);
asyncContext.CompleteOperation();
}
flag = true;
}
finally
{
context.Dispose();
if (!flag)
{
asyncContext.CancelOperation();
}
}
}
protected override sealed IAsyncResult BeginExecute(AsyncCodeActivityContext context, AsyncCallback callback, object state)
{
var cts = new CancellationTokenSource();
context.UserState = cts;
var tcs = new TaskCompletionSource<bool>(state);
ExecuteAsync(context, cts.Token).ContinueWith(t =>
{
if (t.IsFaulted)
{
tcs.TrySetResult(false);
tcs.TrySetException(t.Exception.InnerExceptions);
}
else if (t.IsCanceled)
{
tcs.TrySetResult(false);
tcs.TrySetCanceled();
}
else tcs.TrySetResult(true);
if (callback != null)
callback(tcs.Task);
});
return tcs.Task;
}
protected override IAsyncResult BeginExecute(AsyncCodeActivityContext context, AsyncCallback callback, object state) {
MailMessage mail = new MailMessage();
mail.To.Add(ToAddress.Get(context));
mail.From = new MailAddress(FromAddress.Get(context));
mail.Subject = Subject.Get(context);
mail.Body = Body.Get(context);
mail.IsBodyHtml = true;
SmtpClient smtp = new SmtpClient() ;
Action action = () => {
ManualResetEvent manualResetEvent = new ManualResetEvent(false);
smtp.SendCompleted += (o, args) => {
manualResetEvent.Set();
Debug.WriteLine("Send Mail Completed");
};
smtp.SendAsync(mail, null);
manualResetEvent.WaitOne(TimeSpan.FromSeconds(30));
};
context.UserState = action;
return action.BeginInvoke(callback, state);
}
protected override sealed void Cancel(AsyncCodeActivityContext context)
{
if (context.UserState is CancellationTokenSource)
{
var cts = (CancellationTokenSource)context.UserState;
cts.Cancel();
}
}
protected override IAsyncResult BeginExecute(AsyncCodeActivityContext context, AsyncCallback callback, object state)
{
var message = Message.Get(context);
var MarkAsReadDelegate = new Action<EmailMessage>(MarkAsRead);
context.UserState = MarkAsReadDelegate;
return MarkAsReadDelegate.BeginInvoke(message, callback, state);
}
protected override IAsyncResult BeginExecute(AsyncCodeActivityContext context, AsyncCallback callback, object state)
{
Action<SalesOrderDetail, String> asyncWork =
(sale, desc) => DisplayInventory(sale, desc);
context.UserState = asyncWork;
return asyncWork.BeginInvoke(
SalesDetail.Get(context), Description.Get(context),
callback, state);
}
protected override void EndExecute(AsyncCodeActivityContext context, IAsyncResult result)
{
List<SalesOrderDetail> orderDetail =((Func<Int32, List<SalesOrderDetail>>)context.UserState).EndInvoke(result);
if (orderDetail != null)
{
OrderDetail.Set(context, orderDetail);
}
}
protected override IAsyncResult BeginExecute(AsyncCodeActivityContext activityContext, AsyncCallback callback, object state)
{
var period = DelayPeriod.Get(activityContext);
var cancelable = Cancelable.Get(activityContext);
Guid workflowInstanceGuid = activityContext.WorkflowInstanceId;
string activityInstanceId = activityContext.ActivityInstanceId;
return EnqueueAsync(_ => OnAsyncExecute(workflowInstanceGuid, activityInstanceId, period, cancelable), callback, state);
}
protected override IAsyncResult BeginExecute(
AsyncCodeActivityContext context, AsyncCallback callback, object state)
{
this.InitializeSmtpClient(context);
this.mailCompletionSource = new TaskCompletionSource<bool>(state);
this.workflowCallback = callback;
this.SendMailAsync(this.CreateMailMessage(context));
return this.mailCompletionSource.Task;
}
/// <summary>
/// When implemented in a derived class and using the specified execution context, callback method, and user state, enqueues an asynchronous activity in a run-time workflow.
/// </summary>
/// <returns>
/// The object that saves variable information for an instance of an asynchronous activity.
/// </returns>
/// <param name="context">Information that defines the execution environment for the <see cref="T:System.Activities.AsyncCodeActivity"/>.</param><param name="callback">The method to be called after the asynchronous activity and completion notification have occurred.</param><param name="state">An object that saves variable information for an instance of an asynchronous activity.</param>
protected override IAsyncResult BeginExecute(
AsyncCodeActivityContext context, AsyncCallback callback, object state)
{
var sleep = this.Sleep.Get(context);
Action action = () => Thread.Sleep(sleep);
context.UserState = action;
return action.BeginInvoke(callback, state);
}
/// <summary>
/// The begin execute.
/// </summary>
/// <param name="context">
/// The context.
/// </param>
/// <param name="callback">
/// The callback.
/// </param>
/// <param name="state">
/// The state.
/// </param>
/// <returns>
/// The System.IAsyncResult.
/// </returns>
protected override IAsyncResult BeginExecute(
AsyncCodeActivityContext context, AsyncCallback callback, object state)
{
var token = context.GetExtension<ActivityCancellationToken>();
var notify = context.GetExtension<SpinNotify>();
Action<ActivityCancellationToken, SpinNotify> action = this.DoSpinWait;
context.UserState = action;
return action.BeginInvoke(token, notify, callback, state);
}
protected override IAsyncResult BeginExecute(AsyncCodeActivityContext context, AsyncCallback callback, object state)
{
var hc = new HttpClient();
var task = hc
.PostAsync(context.GetValue(网址), context.GetValue(Http内容))
.ToApm(callback, state);
task.ContinueWith(q =>
hc.Dispose()
);
return task;
}
protected override IAsyncResult BeginExecute(AsyncCodeActivityContext context, AsyncCallback callback, object state)
{
string tempFileName = Path.GetTempFileName();
Console.WriteLine("Writing to file: " + tempFileName);
FileStream file = File.Open(tempFileName, FileMode.Create);
context.UserState = file;
byte[] bytes = UnicodeEncoding.Unicode.GetBytes("123456789");
return file.BeginWrite(bytes, 0, bytes.Length, callback, state);
}
/// <summary>
/// When implemented in a derived class and using the specified execution context, callback method, and user state, enqueues an asynchronous activity in a run-time workflow.
/// </summary>
/// <returns>
/// The object that saves variable information for an instance of an asynchronous activity.
/// </returns>
/// <param name="context">Information that defines the execution environment for the <see cref="T:System.Activities.AsyncCodeActivity"/>.</param><param name="callback">The method to be called after the asynchronous activity and completion notification have occurred.</param><param name="state">An object that saves variable information for an instance of an asynchronous activity.</param>
protected override IAsyncResult BeginExecute(
AsyncCodeActivityContext context, AsyncCallback callback, object state)
{
return
((Action<string, RegistrationData, Guid, int>)LoadTemplate).BeginInvoke(
this.Data.Get(context).EmailTemplates.ElementAt(this.EmailTemplateIndex.Get(context)),
this.Data.Get(context),
context.WorkflowInstanceId,
this.EmailTemplateIndex.Get(context),
callback,
state);
}
internal sealed override void InternalCancel(System.Activities.ActivityInstance instance, ActivityExecutor executor, BookmarkManager bookmarkManager)
{
AsyncOperationContext context;
if (executor.TryGetPendingOperation(instance, out context))
{
using (AsyncCodeActivityContext context2 = new AsyncCodeActivityContext(context, instance, executor))
{
context.HasCalledAsyncCodeActivityCancel = true;
this.Cancel(context2);
}
}
}
protected override IAsyncResult BeginExecute(AsyncCodeActivityContext context, AsyncCallback callback, object state)
{
var provider = Provider.Get(context);
Action work = () =>
{
provider.Reinitialize();
};
context.UserState = work;
return work.BeginInvoke(callback, state);
}
public IAsyncResult BeginExecuteMethod(AsyncCodeActivityContext context, AsyncCallback callback, object state)
{
object target = null;
if (!this.MethodIsStatic)
{
target = this.targetObject.Get(context);
if (target == null)
{
throw FxTrace.Exception.ArgumentNull("TargetObject");
}
}
return this.BeginMakeMethodCall(context, target, callback, state);
}
protected override IAsyncResult BeginExecute(AsyncCodeActivityContext activityContext, AsyncCallback callback, object state)
{
QueryPartitionBase querypartition = QueryPartition.Get(activityContext);
using (var context = querypartition.Query.CreateContext(this, activityContext, ConnectionMode.AutoOpen, TransactionMode.AutoCommit))
{
querypartition.PrepareCopyResultset(context);
}
Guid workflowInstanceGuid = activityContext.WorkflowInstanceId;
string activityInstanceId = activityContext.ActivityInstanceId;
return EnqueueAsync(_ => OnAsyncExecute(workflowInstanceGuid, activityInstanceId, querypartition), callback, state);
}
protected override IAsyncResult BeginExecute(AsyncCodeActivityContext context, AsyncCallback callback, object state)
{
sourceConnection =
new SqlConnection(connectionStringOrigem.Get(context));
sourceConnection.Open();
commandSourceData = new SqlCommand(Query.Get(context), sourceConnection);
var task =
commandSourceData.BeginExecuteReader(callback, state, System.Data.CommandBehavior.Default);
return task;
}
protected override IAsyncResult BeginExecute(AsyncCodeActivityContext context, AsyncCallback callback, object state)
{
if (Application.Current == null)
{
throw new InvalidOperationException("Must have an application");
}
DispatcherSynchronizationContext syncContext = new DispatcherSynchronizationContext(Application.Current.Dispatcher);
object dataContext = context.DataContext;
Action showDelegate = () => syncContext.Send(Show, dataContext);
context.UserState = showDelegate;
return showDelegate.BeginInvoke(callback, state);
}
/// <summary>
/// Cancels the execution of the activity.
/// </summary>
/// <param name="context"></param>
/// <remarks>
/// This method cancels all registered runnin cancelable tasks before marking the
/// activity canceled.
/// </remarks>
protected override void Cancel(AsyncCodeActivityContext context)
{
string id = String.Format("{0}_{1}", context.WorkflowInstanceId.ToString(), context.ActivityInstanceId);
if (cancelableTasks.ContainsKey(id))
{
cancelableTasks[id].Cancel();
}
// This is absolutely important here:
context.MarkCanceled();
base.Cancel(context);
}
protected override void EndExecute(AsyncCodeActivityContext context, IAsyncResult result)
{
FileStream file = (FileStream)context.UserState;
try
{
file.EndWrite(result);
file.Flush();
}
finally
{
file.Close();
}
}
protected override IAsyncResult BeginExecute(AsyncCodeActivityContext context, AsyncCallback callback, object state)
{
DependentTransaction dependentTran = null;
if (Transaction.Current != null)
{
dependentTran = Transaction.Current.DependentClone(
DependentCloneOption.BlockCommitUntilComplete);
}
Action<DependentTransaction, SalesOrderDetail> asyncWork =(dt, sale) => UpdateInventory(dt, sale);
context.UserState = asyncWork;
return asyncWork.BeginInvoke(dependentTran, SalesDetail.Get(context), callback, state);
}
protected override IAsyncResult BeginExecute(AsyncCodeActivityContext activityContext, AsyncCallback callback, object state)
{
var query = Query.Get(activityContext);
var tableReference = TableReference.Get(activityContext);
string connectionString, sql;
using (Context context = query.CreateContext(this, activityContext, ConnectionMode.AutoOpen, TransactionMode.AutoCommit))
{
query.InitializeQueryObject(context, activityContext.GetExtension<IScheduler>(), false);
query.PrepareComputeTableStatistics(context, tableReference, out connectionString, out sql);
}
Guid workflowInstanceGuid = activityContext.WorkflowInstanceId;
string activityInstanceId = activityContext.ActivityInstanceId;
return EnqueueAsync(_ => OnAsyncExecute(workflowInstanceGuid, activityInstanceId, query, tableReference, connectionString, sql), callback, state);
}
protected override IAsyncResult BeginExecute(AsyncCodeActivityContext activityContext, AsyncCallback callback, object state)
{
Guid sourcefileguid = SourceFileGuid.Get(activityContext);
Guid destinationdatabaseinstanceguid = DestinationDatabaseInstanceGuid.Get(activityContext);
FileCopyDirection filecopydirection = FileCopyDirection.Get(activityContext);
string sourcefilename, destinationfilename;
string hostname;
// Load files
using (Context context = ContextManager.Instance.CreateContext(this, activityContext, ConnectionMode.AutoOpen, TransactionMode.AutoCommit))
{
// Load destination database instance
DatabaseInstance di = new DatabaseInstance(context);
di.Guid = destinationdatabaseinstanceguid;
di.Load();
di.LoadFileGroups(false);
EntityGuid.Set(activityContext, di.Guid);
// Load database instance from the schema database
DatabaseInstanceFile df;
DatabaseInstanceFile sf = new DatabaseInstanceFile(context);
sf.Guid = sourcefileguid;
sf.Load();
EntityGuidFrom.Set(activityContext, sourcefileguid);
sourcefilename = sf.GetFullUncFilename();
DatabaseInstanceFileGroup fg = di.FileGroups[sf.DatabaseInstanceFileGroup.Name];
fg.LoadFiles(false);
df = fg.Files[sf.Name];
EntityGuidTo.Set(activityContext, df.Guid);
destinationfilename = df.GetFullUncFilename();
DatabaseInstanceFile ssf = filecopydirection == Jhu.Graywulf.Registry.FileCopyDirection.Push ? sf : df;
hostname = ssf.DatabaseInstanceFileGroup.DatabaseInstance.ServerInstance.Machine.HostName.ResolvedValue;
}
Guid workflowInstanceGuid = activityContext.WorkflowInstanceId;
string activityInstanceId = activityContext.ActivityInstanceId;
return EnqueueAsync(_ => OnAsyncExecute(workflowInstanceGuid, activityInstanceId, hostname, sourcefilename, destinationfilename), callback, state);
}
/// <summary>
/// Begin async execute
/// </summary>
/// <param name="context">
/// The context.
/// </param>
/// <param name="callback">
/// The callback.
/// </param>
/// <param name="state">
/// The state.
/// </param>
/// <returns>
/// An IAsync result
/// </returns>
protected override IAsyncResult BeginExecute(AsyncCodeActivityContext context, AsyncCallback callback, object state)
{
var stub = context.GetExtension<IMessagingStub>();
if (stub == null)
{
throw new InvalidOperationException("Cannot locate extension of type IMessagingStub");
}
if (this.Content is SendParametersContent)
{
{
var parametersContent = this.Content as SendParametersContent;
this.Send(stub, parametersContent.Parameters.ToDictionary(pair => pair.Key, pair => parametersContent.Parameters[pair.Key].Get(context)));
}
}
else if (this.Content is SendMessageContent)
{
var messageContent = this.Content as SendMessageContent;
this.Send(stub, messageContent.Message.Get(context));
}
else
{
this.Send(stub, null);
}
var task = Task.Factory.StartNew(
_ =>
{
// Allow for subclasses to provide different implementations based on the activity
// They can override GetImplementation to provide it
var implementation = stub.GetImplementation(this);
if (implementation != null)
{
implementation();
}
},
state);
if (callback != null)
{
task.ContinueWith(_ => callback(task));
}
return task;
}
protected override IAsyncResult BeginExecute(AsyncCodeActivityContext activityContext, AsyncCallback callback, object state)
{
QueryPartitionBase querypartition = (QueryPartitionBase)QueryPartition.Get(activityContext);
TableReference remotetable = null;
SourceQueryParameters source;
using (Context context = querypartition.Query.CreateContext(this, activityContext, ConnectionMode.AutoOpen, TransactionMode.AutoCommit))
{
remotetable = querypartition.RemoteTableReferences[RemoteTable.Get(activityContext)];
source = querypartition.PrepareCopyRemoteTable(remotetable);
}
Guid workflowInstanceGuid = activityContext.WorkflowInstanceId;
string activityInstanceId = activityContext.ActivityInstanceId;
return EnqueueAsync(_ => OnAsyncExecute(workflowInstanceGuid, activityInstanceId, querypartition, remotetable, source), callback, state);
}
protected override void EndExecute(AsyncCodeActivityContext context, IAsyncResult result)
{
try
{
((Task)result).Wait();
}
catch (AggregateException ex)
{
if (ex.InnerException is OperationCanceledException)
{
// This is a normal way of operation
}
else
{
throw;
}
}
}
protected override IAsyncResult BeginExecute(AsyncCodeActivityContext activityContext, AsyncCallback callback, object state)
{
var export = Parameters.Get(activityContext);
// TODO: try to generalize connection string loading logic and move this from here
// Use connection string of the database instance, if only database instance name is supplied
if (export.Source.Dataset is GraywulfDataset)
{
// Load database instace and get connection string to make it cached
using (var context = ContextManager.Instance.CreateContext(this, activityContext, ConnectionMode.AutoOpen, TransactionMode.AutoCommit))
{
var gwds = (GraywulfDataset)export.Source.Dataset;
gwds.Context = context;
gwds.DatabaseInstance.Value.GetConnectionString();
}
}
Guid workflowInstanceGuid = activityContext.WorkflowInstanceId;
string activityInstanceId = activityContext.ActivityInstanceId;
return EnqueueAsync(_ => OnAsyncExecute(workflowInstanceGuid, activityInstanceId, export), callback, state);
}
protected abstract void EndExecute(AsyncCodeActivityContext context, IAsyncResult result);
public Transaction GetCurrentTransaction(AsyncCodeActivityContext context)
{
return(GetCurrentTransactionCore(context));
}
void IAsyncCodeActivity.FinishExecution(AsyncCodeActivityContext context, IAsyncResult result)
{
TResult local = this.EndExecute(context, result);
base.Result.Set(context, local);
}
void IAsyncCodeActivity.FinishExecution(AsyncCodeActivityContext context, IAsyncResult result)
{
this.EndExecute(context, result);
}
protected abstract IAsyncResult BeginExecute(AsyncCodeActivityContext context, AsyncCallback callback, object state);
// called on the Cancel and Abort paths to allow cleanup of outstanding async work
protected virtual void Cancel(AsyncCodeActivityContext context)
{
}
public Transaction GetCurrentTransaction(AsyncCodeActivityContext context)
{
throw new NotImplementedException();
}