Code:
/ 4.0 / 4.0 / untmp / DEVDIV_TFS / Dev10 / Releases / RTMRel / ndp / cdf / src / NetFx40 / System.ServiceModel.Activities / System / ServiceModel / Activities / WorkflowControlClient.cs / 1305376 / WorkflowControlClient.cs
//----------------------------------------------------------------
// Copyright (c) Microsoft Corporation. All rights reserved.
//---------------------------------------------------------------
namespace System.ServiceModel.Activities
{
using System.Collections.Generic;
using System.ComponentModel;
using System.Runtime;
using System.ServiceModel;
using System.ServiceModel.Channels;
using System.Threading;
using System.Transactions;
using SR2 = System.ServiceModel.Activities.SR;
public class WorkflowControlClient : ClientBase
{
BeginOperationDelegate onBeginAbandonDelegate;
EndOperationDelegate onEndAbandonDelegate;
SendOrPostCallback onAbandonCompleteDelegate;
BeginOperationDelegate onBeginCancelDelegate;
EndOperationDelegate onEndCancelDelegate;
SendOrPostCallback onCancelCompleteDelegate;
BeginOperationDelegate onBeginRunDelegate;
EndOperationDelegate onEndRunDelegate;
SendOrPostCallback onRunCompleteDelegate;
BeginOperationDelegate onBeginSuspendDelegate;
EndOperationDelegate onEndSuspendDelegate;
SendOrPostCallback onSuspendCompleteDelegate;
BeginOperationDelegate onBeginUnsuspendDelegate;
EndOperationDelegate onEndUnsuspendDelegate;
SendOrPostCallback onUnsuspendCompleteDelegate;
BeginOperationDelegate onBeginTerminateDelegate;
EndOperationDelegate onEndTerminateDelegate;
SendOrPostCallback onTerminateCompleteDelegate;
bool checkedBinding;
bool supportsTransactedInvoke;
public WorkflowControlClient()
: base()
{
}
public WorkflowControlClient(string endpointConfigurationName)
: base(endpointConfigurationName)
{
}
public WorkflowControlClient(string endpointConfigurationName, EndpointAddress remoteAddress)
: base(endpointConfigurationName, remoteAddress)
{
}
public WorkflowControlClient(string endpointConfigurationName, string remoteAddress)
: base(endpointConfigurationName, remoteAddress)
{
}
public WorkflowControlClient(Binding binding, EndpointAddress remoteAddress)
: base(binding, remoteAddress)
{
}
public WorkflowControlClient(WorkflowControlEndpoint workflowEndpoint)
: base(workflowEndpoint.Binding, workflowEndpoint.Address)
{
}
public event EventHandler AbandonCompleted;
public event EventHandler CancelCompleted;
public event EventHandler RunCompleted;
public event EventHandler SuspendCompleted;
public event EventHandler UnsuspendCompleted;
public event EventHandler TerminateCompleted;
bool SupportsTransactedInvoke
{
get
{
if (!this.checkedBinding)
{
foreach (BindingElement bindingElement in base.Endpoint.Binding.CreateBindingElements())
{
TransactionFlowBindingElement transactionFlowElement = bindingElement as TransactionFlowBindingElement;
if (transactionFlowElement != null)
{
this.supportsTransactedInvoke = true;
break;
}
}
this.checkedBinding = true;
}
return this.supportsTransactedInvoke;
}
}
bool IsTransactedInvoke
{
get
{
return this.SupportsTransactedInvoke && Transaction.Current != null;
}
}
[Fx.Tag.InheritThrows(FromDeclaringType = typeof(IWorkflowInstanceManagement), From = "Abandon")]
public void Abandon(Guid instanceId)
{
Abandon(instanceId, null);
}
[Fx.Tag.InheritThrows(From = "Abandon")]
public void Abandon(Guid instanceId, string reason)
{
base.Channel.Abandon(instanceId, reason);
}
[Fx.Tag.InheritThrows(From = "Abandon")]
public void AbandonAsync(Guid instanceId)
{
AbandonAsync(instanceId, null, null);
}
[Fx.Tag.InheritThrows(From = "Abandon")]
public void AbandonAsync(Guid instanceId, object userState)
{
AbandonAsync(instanceId, null, userState);
}
[Fx.Tag.InheritThrows(From = "Abandon")]
public void AbandonAsync(Guid instanceId, string reason)
{
AbandonAsync(instanceId, reason, null);
}
[Fx.Tag.InheritThrows(From = "Abandon")]
public void AbandonAsync(Guid instanceId, string reason, object userState)
{
if (this.onBeginAbandonDelegate == null)
{
this.onBeginAbandonDelegate = new BeginOperationDelegate(OnBeginAbandon);
this.onEndAbandonDelegate = new EndOperationDelegate(OnEndAbandon);
this.onAbandonCompleteDelegate = Fx.ThunkCallback(new SendOrPostCallback(OnAbandonCompleted));
}
base.InvokeAsync(this.onBeginAbandonDelegate, new object[] { instanceId, reason },
this.onEndAbandonDelegate, this.onAbandonCompleteDelegate, userState);
}
[Fx.Tag.InheritThrows(FromDeclaringType = typeof(IWorkflowInstanceManagement), From = "Cancel")]
public void Cancel(Guid instanceId)
{
if (this.IsTransactedInvoke)
{
base.Channel.TransactedCancel(instanceId);
}
else
{
base.Channel.Cancel((instanceId));
}
}
[Fx.Tag.InheritThrows(FromDeclaringType = typeof(IWorkflowInstanceManagement), From = "Cancel")]
public void CancelAsync(Guid instanceId)
{
this.CancelAsync(instanceId, null);
}
[Fx.Tag.InheritThrows(FromDeclaringType = typeof(IWorkflowInstanceManagement), From = "Cancel")]
public void CancelAsync(Guid instanceId, object userState)
{
if (this.onBeginCancelDelegate == null)
{
this.onBeginCancelDelegate = new BeginOperationDelegate(OnBeginCancel);
this.onEndCancelDelegate = new EndOperationDelegate(OnEndCancel);
this.onCancelCompleteDelegate = Fx.ThunkCallback(new SendOrPostCallback(OnCancelCompleted));
}
base.InvokeAsync(this.onBeginCancelDelegate, new object[] { instanceId },
this.onEndCancelDelegate, this.onCancelCompleteDelegate, userState);
}
[Fx.Tag.InheritThrows(FromDeclaringType = typeof(IWorkflowInstanceManagement), From = "Run")]
public void Run(Guid instanceId)
{
if (this.IsTransactedInvoke)
{
base.Channel.TransactedRun((instanceId));
}
else
{
base.Channel.Run((instanceId));
}
}
[Fx.Tag.InheritThrows(FromDeclaringType = typeof(IWorkflowInstanceManagement), From = "Run")]
public void RunAsync(Guid instanceId)
{
this.RunAsync(instanceId, null);
}
[Fx.Tag.InheritThrows(FromDeclaringType = typeof(IWorkflowInstanceManagement), From = "Run")]
public void RunAsync(Guid instanceId, object userState)
{
if (this.onBeginRunDelegate == null)
{
this.onBeginRunDelegate = new BeginOperationDelegate(OnBeginRun);
this.onEndRunDelegate = new EndOperationDelegate(OnEndRun);
this.onRunCompleteDelegate = Fx.ThunkCallback(new SendOrPostCallback(OnRunCompleted));
}
base.InvokeAsync(this.onBeginRunDelegate, new object[] { instanceId },
this.onEndRunDelegate, this.onRunCompleteDelegate, userState);
}
[Fx.Tag.InheritThrows(FromDeclaringType = typeof(IWorkflowInstanceManagement), From = "Suspend")]
public void Suspend(Guid instanceId)
{
Suspend(instanceId, SR2.DefaultSuspendReason);
}
[Fx.Tag.InheritThrows(From = "Suspend")]
public void Suspend(Guid instanceId, string reason)
{
if (this.IsTransactedInvoke)
{
base.Channel.TransactedSuspend(instanceId, reason);
}
else
{
base.Channel.Suspend(instanceId, reason);
}
}
[Fx.Tag.InheritThrows(From = "Suspend")]
public void SuspendAsync(Guid instanceId)
{
this.SuspendAsync(instanceId, SR2.DefaultSuspendReason);
}
[Fx.Tag.InheritThrows(From = "Suspend")]
public void SuspendAsync(Guid instanceId, string reason)
{
this.SuspendAsync(instanceId, reason, null);
}
[Fx.Tag.InheritThrows(From = "Suspend")]
public void SuspendAsync(Guid instanceId, object userState)
{
this.SuspendAsync(instanceId, SR2.DefaultSuspendReason, userState);
}
[Fx.Tag.InheritThrows(From = "Suspend")]
public void SuspendAsync(Guid instanceId, string reason, object userState)
{
if (this.onBeginSuspendDelegate == null)
{
this.onEndSuspendDelegate = new EndOperationDelegate(OnEndSuspend);
this.onSuspendCompleteDelegate = Fx.ThunkCallback(new SendOrPostCallback(OnSuspendCompleted));
this.onBeginSuspendDelegate = new BeginOperationDelegate(OnBeginSuspend);
}
base.InvokeAsync(this.onBeginSuspendDelegate, new object[] { instanceId, reason },
this.onEndSuspendDelegate, this.onSuspendCompleteDelegate, userState);
}
[Fx.Tag.InheritThrows(FromDeclaringType = typeof(IWorkflowInstanceManagement), From = "Unsuspend")]
public void Unsuspend(Guid instanceId)
{
if (this.IsTransactedInvoke)
{
base.Channel.TransactedUnsuspend(instanceId);
}
else
{
base.Channel.Unsuspend(instanceId);
}
}
[Fx.Tag.InheritThrows(From = "Unsuspend")]
public void UnsuspendAsync(Guid instanceId)
{
this.UnsuspendAsync(instanceId, null);
}
[Fx.Tag.InheritThrows(From = "Unsuspend")]
public void UnsuspendAsync(Guid instanceId, object userState)
{
if (this.onBeginUnsuspendDelegate == null)
{
this.onBeginUnsuspendDelegate = new BeginOperationDelegate(OnBeginUnsuspend);
this.onEndUnsuspendDelegate = new EndOperationDelegate(OnEndUnsuspend);
this.onUnsuspendCompleteDelegate = Fx.ThunkCallback(new SendOrPostCallback(OnUnsuspendCompleted));
}
base.InvokeAsync(this.onBeginUnsuspendDelegate, new object[] { instanceId },
this.onEndUnsuspendDelegate, this.onUnsuspendCompleteDelegate, userState);
}
[Fx.Tag.InheritThrows(FromDeclaringType = typeof(IWorkflowInstanceManagement), From = "Terminate")]
public void Terminate(Guid instanceId)
{
Terminate(instanceId, SR2.DefaultTerminationReason);
}
[Fx.Tag.InheritThrows(From = "Terminate")]
public void Terminate(Guid instanceId, string reason)
{
if (this.IsTransactedInvoke)
{
base.Channel.TransactedTerminate(instanceId, reason);
}
else
{
base.Channel.Terminate(instanceId, reason);
}
}
[Fx.Tag.InheritThrows(FromDeclaringType = typeof(IWorkflowInstanceManagement), From = "Terminate")]
public void TerminateAsync(Guid instanceId)
{
this.TerminateAsync(instanceId, SR2.DefaultTerminationReason);
}
[Fx.Tag.InheritThrows(From = "Terminate")]
public void TerminateAsync(Guid instanceId, string reason)
{
this.TerminateAsync(instanceId, reason, null);
}
[Fx.Tag.InheritThrows(From = "Terminate")]
public void TerminateAsync(Guid instanceId, object userState)
{
this.TerminateAsync(instanceId, SR2.DefaultTerminationReason, userState);
}
[Fx.Tag.InheritThrows(From = "Terminate")]
public void TerminateAsync(Guid instanceId, string reason, object userState)
{
if (this.onBeginTerminateDelegate == null)
{
this.onEndTerminateDelegate = new EndOperationDelegate(OnEndTerminate);
this.onTerminateCompleteDelegate = Fx.ThunkCallback(new SendOrPostCallback(OnTerminateCompleted));
this.onBeginTerminateDelegate = new BeginOperationDelegate(OnBeginTerminate);
}
base.InvokeAsync(this.onBeginTerminateDelegate, new object[] { instanceId, reason },
this.onEndTerminateDelegate, this.onTerminateCompleteDelegate, userState);
}
[Fx.Tag.InheritThrows(From = "Abandon")]
public IAsyncResult BeginAbandon(Guid instanceId, AsyncCallback callback, object state)
{
return BeginAbandon(instanceId, null, callback, state);
}
[Fx.Tag.InheritThrows(From = "Abandon")]
public IAsyncResult BeginAbandon(Guid instanceId, string reason, AsyncCallback callback, object state)
{
return base.Channel.BeginAbandon(instanceId, reason, callback, state);
}
[Fx.Tag.InheritThrows(From = "Abandon")]
public void EndAbandon(IAsyncResult result)
{
base.Channel.EndAbandon(result);
}
[Fx.Tag.InheritThrows(From = "Cancel")]
public IAsyncResult BeginCancel(Guid instanceId, AsyncCallback callback, object state)
{
return new CancelAsyncResult(base.Channel, this.IsTransactedInvoke, instanceId, callback, state);
}
[Fx.Tag.InheritThrows(From = "Cancel")]
public void EndCancel(IAsyncResult result)
{
CancelAsyncResult.End(result);
}
[Fx.Tag.InheritThrows(From = "Run")]
public IAsyncResult BeginRun(Guid instanceId, AsyncCallback callback, object state)
{
return new RunAsyncResult(base.Channel, this.IsTransactedInvoke, instanceId, callback, state);
}
[Fx.Tag.InheritThrows(From = "Run")]
public void EndRun(IAsyncResult result)
{
RunAsyncResult.End(result);
}
[Fx.Tag.InheritThrows(From = "Suspend")]
public IAsyncResult BeginSuspend(Guid instanceId, AsyncCallback callback, object state)
{
return BeginSuspend(instanceId, SR2.DefaultSuspendReason, callback, state);
}
[Fx.Tag.InheritThrows(From = "Suspend")]
public IAsyncResult BeginSuspend(Guid instanceId, string reason, AsyncCallback callback, object state)
{
return new SuspendAsyncResult(base.Channel, this.IsTransactedInvoke, instanceId, reason, callback, state);
}
[Fx.Tag.InheritThrows(From = "Suspend")]
public void EndSuspend(IAsyncResult result)
{
SuspendAsyncResult.End(result);
}
[Fx.Tag.InheritThrows(From = "Unsuspend")]
public IAsyncResult BeginUnsuspend(Guid instanceId, AsyncCallback callback, object state)
{
return new UnsuspendAsyncResult(base.Channel, this.IsTransactedInvoke, instanceId, callback, state);
}
[Fx.Tag.InheritThrows(From = "Unsuspend")]
public void EndUnsuspend(IAsyncResult result)
{
UnsuspendAsyncResult.End(result);
}
[Fx.Tag.InheritThrows(From = "Terminate")]
public IAsyncResult BeginTerminate(Guid instanceId, AsyncCallback callback, object state)
{
return BeginTerminate(instanceId, SR2.DefaultTerminationReason, callback, state);
}
[Fx.Tag.InheritThrows(From = "Terminate")]
public IAsyncResult BeginTerminate(Guid instanceId, string reason, AsyncCallback callback, object state)
{
return new TerminateAsyncResult(base.Channel, this.IsTransactedInvoke, instanceId, reason, callback, state);
}
[Fx.Tag.InheritThrows(From = "Terminate")]
public void EndTerminate(IAsyncResult result)
{
TerminateAsyncResult.End(result);
}
void OnAbandonCompleted(object state)
{
EventHandler abortCompleted = this.AbandonCompleted;
if (abortCompleted != null)
{
InvokeAsyncCompletedEventArgs e = (InvokeAsyncCompletedEventArgs)state;
abortCompleted(this,
new AsyncCompletedEventArgs(e.Error, e.Cancelled, e.UserState));
}
}
IAsyncResult OnBeginAbandon(object[] inputs, AsyncCallback callback, object state)
{
return this.BeginAbandon((Guid)inputs[0], (string)inputs[1], callback, state);
}
object[] OnEndAbandon(IAsyncResult result)
{
this.EndAbandon(result);
return null;
}
void OnCancelCompleted(object state)
{
EventHandler cancelCompleted = this.CancelCompleted;
if (cancelCompleted != null)
{
InvokeAsyncCompletedEventArgs e = (InvokeAsyncCompletedEventArgs)state;
cancelCompleted(this,
new AsyncCompletedEventArgs(e.Error, e.Cancelled, e.UserState));
}
}
IAsyncResult OnBeginCancel(object[] inputs, AsyncCallback callback, object state)
{
return this.BeginCancel((Guid)inputs[0], callback, state);
}
object[] OnEndCancel(IAsyncResult result)
{
this.EndCancel(result);
return null;
}
void OnRunCompleted(object state)
{
EventHandler runCompleted = this.RunCompleted;
if (runCompleted != null)
{
InvokeAsyncCompletedEventArgs e = (InvokeAsyncCompletedEventArgs)state;
runCompleted(this, new AsyncCompletedEventArgs(e.Error, e.Cancelled, e.UserState));
}
}
IAsyncResult OnBeginRun(object[] inputs, AsyncCallback callback, object state)
{
return this.BeginRun((Guid)inputs[0], callback, state);
}
object[] OnEndRun(IAsyncResult result)
{
this.EndRun(result);
return null;
}
void OnSuspendCompleted(object state)
{
EventHandler suspendCompleted = this.SuspendCompleted;
if (suspendCompleted != null)
{
InvokeAsyncCompletedEventArgs e = (InvokeAsyncCompletedEventArgs)state;
suspendCompleted(this, new AsyncCompletedEventArgs(e.Error, e.Cancelled, e.UserState));
}
}
IAsyncResult OnBeginSuspend(object[] inputs, AsyncCallback callback, object state)
{
return this.BeginSuspend((Guid)inputs[0], (string)inputs[1], callback, state);
}
object[] OnEndSuspend(IAsyncResult result)
{
this.EndSuspend(result);
return null;
}
void OnUnsuspendCompleted(object state)
{
EventHandler unsuspendCompleted = this.UnsuspendCompleted;
if (unsuspendCompleted != null)
{
InvokeAsyncCompletedEventArgs e = (InvokeAsyncCompletedEventArgs)state;
unsuspendCompleted(this, new AsyncCompletedEventArgs(e.Error, e.Cancelled, e.UserState));
}
}
IAsyncResult OnBeginUnsuspend(object[] inputs, AsyncCallback callback, object state)
{
return this.BeginUnsuspend((Guid)inputs[0], callback, state);
}
object[] OnEndUnsuspend(IAsyncResult result)
{
this.EndUnsuspend(result);
return null;
}
void OnTerminateCompleted(object state)
{
EventHandler terminateCompleted = this.TerminateCompleted;
if (terminateCompleted != null)
{
InvokeAsyncCompletedEventArgs e = (InvokeAsyncCompletedEventArgs)state;
terminateCompleted(this, new AsyncCompletedEventArgs(e.Error, e.Cancelled, e.UserState));
}
}
IAsyncResult OnBeginTerminate(object[] inputs, AsyncCallback callback, object state)
{
return this.BeginTerminate((Guid)inputs[0], (string)inputs[1], callback, state);
}
object[] OnEndTerminate(IAsyncResult result)
{
this.EndTerminate(result);
return null;
}
class CancelAsyncResult : AsyncResult
{
static AsyncCompletion handleEndCancel = new AsyncCompletion(HandleEndCancel);
bool isTransacted;
IWorkflowInstanceManagement channel;
public CancelAsyncResult(IWorkflowInstanceManagement channel, bool isTransacted, Guid instanceId,
AsyncCallback callback, object state)
: base(callback, state)
{
this.isTransacted = isTransacted;
this.channel = channel;
if (Cancel(instanceId))
{
this.Complete(true);
}
}
public static void End(IAsyncResult result)
{
AsyncResult.End(result);
}
bool Cancel(Guid instanceId)
{
IAsyncResult result;
AsyncCallback callback = this.PrepareAsyncCompletion(handleEndCancel);
if (this.isTransacted)
{
result = this.channel.BeginTransactedCancel(instanceId, callback, this);
}
else
{
result = this.channel.BeginCancel(instanceId, callback, this);
}
if (result.CompletedSynchronously)
{
return HandleEndCancel(result);
}
return false;
}
static bool HandleEndCancel(IAsyncResult result)
{
CancelAsyncResult thisPtr = (CancelAsyncResult)result.AsyncState;
if (thisPtr.isTransacted)
{
thisPtr.channel.EndTransactedCancel(result);
}
else
{
thisPtr.channel.EndCancel(result);
}
return true;
}
}
class RunAsyncResult : AsyncResult
{
static AsyncCompletion handleEndResume = new AsyncCompletion(HandleEndRun);
bool isTransacted;
IWorkflowInstanceManagement channel;
public RunAsyncResult(IWorkflowInstanceManagement channel, bool isTransacted, Guid instanceId,
AsyncCallback callback, object state)
: base(callback, state)
{
this.isTransacted = isTransacted;
this.channel = channel;
if (Run(instanceId))
{
this.Complete(true);
}
}
public static void End(IAsyncResult result)
{
AsyncResult.End(result);
}
bool Run(Guid instanceId)
{
IAsyncResult result;
AsyncCallback callback = this.PrepareAsyncCompletion(handleEndResume);
if (this.isTransacted)
{
result = this.channel.BeginTransactedRun(instanceId, callback, this);
}
else
{
result = this.channel.BeginRun(instanceId, callback, this);
}
if (result.CompletedSynchronously)
{
return HandleEndRun(result);
}
return false;
}
static bool HandleEndRun(IAsyncResult result)
{
RunAsyncResult thisPtr = (RunAsyncResult)result.AsyncState;
if (thisPtr.isTransacted)
{
thisPtr.channel.EndTransactedRun(result);
}
else
{
thisPtr.channel.EndRun(result);
}
return true;
}
}
class SuspendAsyncResult : AsyncResult
{
static AsyncCompletion handleEndSuspend = new AsyncCompletion(HandleEndSuspend);
bool isTransacted;
IWorkflowInstanceManagement channel;
public SuspendAsyncResult(IWorkflowInstanceManagement channel, bool isTransacted,
Guid instanceId, string reason, AsyncCallback callback, object state)
: base(callback, state)
{
this.isTransacted = isTransacted;
this.channel = channel;
if (Suspend(instanceId, reason))
{
this.Complete(true);
}
}
public static void End(IAsyncResult result)
{
AsyncResult.End(result);
}
bool Suspend(Guid instanceId, string reason)
{
IAsyncResult result;
AsyncCallback callback = this.PrepareAsyncCompletion(handleEndSuspend);
if (this.isTransacted)
{
result = this.channel.BeginTransactedSuspend(instanceId, reason, callback, this);
}
else
{
result = this.channel.BeginSuspend(instanceId, reason, callback, this);
}
if (result.CompletedSynchronously)
{
return HandleEndSuspend(result);
}
return false;
}
static bool HandleEndSuspend(IAsyncResult result)
{
SuspendAsyncResult thisPtr = (SuspendAsyncResult)result.AsyncState;
if (thisPtr.isTransacted)
{
thisPtr.channel.EndTransactedSuspend(result);
}
else
{
thisPtr.channel.EndSuspend(result);
}
return true;
}
}
class UnsuspendAsyncResult : AsyncResult
{
static AsyncCompletion handleEndUnsuspend = new AsyncCompletion(HandleEndUnsuspend);
bool isTransacted;
IWorkflowInstanceManagement channel;
public UnsuspendAsyncResult(IWorkflowInstanceManagement channel, bool isTransacted,
Guid instanceId, AsyncCallback callback, object state)
: base(callback, state)
{
this.isTransacted = isTransacted;
this.channel = channel;
if (Unsuspend(instanceId))
{
this.Complete(true);
}
}
public static void End(IAsyncResult result)
{
AsyncResult.End(result);
}
bool Unsuspend(Guid instanceId)
{
IAsyncResult result;
AsyncCallback callback = this.PrepareAsyncCompletion(handleEndUnsuspend);
if (this.isTransacted)
{
result = this.channel.BeginTransactedUnsuspend(instanceId, callback, this);
}
else
{
result = this.channel.BeginUnsuspend(instanceId, callback, this);
}
if (result.CompletedSynchronously)
{
return HandleEndUnsuspend(result);
}
return false;
}
static bool HandleEndUnsuspend(IAsyncResult result)
{
UnsuspendAsyncResult thisPtr = (UnsuspendAsyncResult)result.AsyncState;
if (thisPtr.isTransacted)
{
thisPtr.channel.EndTransactedUnsuspend(result);
}
else
{
thisPtr.channel.EndUnsuspend(result);
}
return true;
}
}
class TerminateAsyncResult : AsyncResult
{
static AsyncCompletion handleEndTerminate = new AsyncCompletion(HandleEndTerminate);
bool isTransacted;
IWorkflowInstanceManagement channel;
public TerminateAsyncResult(IWorkflowInstanceManagement channel, bool isTransacted,
Guid instanceId, string reason, AsyncCallback callback, object state)
: base(callback, state)
{
this.isTransacted = isTransacted;
this.channel = channel;
if (Terminate(instanceId, reason))
{
this.Complete(true);
}
}
public static void End(IAsyncResult result)
{
AsyncResult.End(result);
}
bool Terminate(Guid instanceId, string reason)
{
IAsyncResult result;
AsyncCallback callback = this.PrepareAsyncCompletion(handleEndTerminate);
if (this.isTransacted)
{
result = this.channel.BeginTransactedTerminate(instanceId, reason, callback, this);
}
else
{
result = this.channel.BeginTerminate(instanceId, reason, callback, this);
}
if (result.CompletedSynchronously)
{
return HandleEndTerminate(result);
}
return false;
}
static bool HandleEndTerminate(IAsyncResult result)
{
TerminateAsyncResult thisPtr = (TerminateAsyncResult)result.AsyncState;
if (thisPtr.isTransacted)
{
thisPtr.channel.EndTransactedTerminate(result);
}
else
{
thisPtr.channel.EndTerminate(result);
}
return true;
}
}
}
}
// File provided for Reference Use Only by Microsoft Corporation (c) 2007.
Link Menu
This book is available now!
Buy at Amazon US or
Buy at Amazon UK
- RandomNumberGenerator.cs
- WinInetCache.cs
- RangeValidator.cs
- PointAnimationUsingPath.cs
- ISAPIWorkerRequest.cs
- FrameworkContextData.cs
- ScaleTransform.cs
- DesignerHelpers.cs
- FixedMaxHeap.cs
- ISAPIRuntime.cs
- Enum.cs
- loginstatus.cs
- XomlCompilerHelpers.cs
- XmlSchemaComplexContent.cs
- MetadataSerializer.cs
- WmpBitmapEncoder.cs
- CodeExporter.cs
- XappLauncher.cs
- HttpProfileGroupBase.cs
- HierarchicalDataBoundControl.cs
- SimpleBitVector32.cs
- HtmlElement.cs
- HttpCapabilitiesEvaluator.cs
- SemaphoreFullException.cs
- AmbientProperties.cs
- HMACRIPEMD160.cs
- SoapConverter.cs
- UnsafeNativeMethodsCLR.cs
- ValueUtilsSmi.cs
- MailSettingsSection.cs
- SqlDataReader.cs
- TemplateKey.cs
- DownloadProgressEventArgs.cs
- TransformerInfoCollection.cs
- TextRunTypographyProperties.cs
- DataRow.cs
- ScaleTransform3D.cs
- Repeater.cs
- XamlStream.cs
- ToolStripOverflow.cs
- DesignerDataColumn.cs
- XmlExtensionFunction.cs
- WebControl.cs
- DetailsViewDesigner.cs
- WorkflowMessageEventArgs.cs
- Matrix.cs
- ClientSettingsSection.cs
- ContainerSelectorActiveEvent.cs
- DocumentReference.cs
- SqlDataSourceEnumerator.cs
- WindowsServiceCredential.cs
- WindowsUpDown.cs
- OLEDB_Enum.cs
- SqlTriggerAttribute.cs
- ToolBar.cs
- GZipStream.cs
- XmlSchemaGroup.cs
- ConnectionPoint.cs
- BaseTreeIterator.cs
- DataControlReferenceCollection.cs
- PerformanceCounter.cs
- XmlSchemaObjectCollection.cs
- CatalogZoneBase.cs
- WinInetCache.cs
- PopupRoot.cs
- PrivateUnsafeNativeCompoundFileMethods.cs
- ListViewGroupConverter.cs
- SiteMapPathDesigner.cs
- PropertyMapper.cs
- WindowsListViewGroupHelper.cs
- Serializer.cs
- LocatorGroup.cs
- BufferModesCollection.cs
- ThicknessAnimationBase.cs
- ToolBar.cs
- SafeViewOfFileHandle.cs
- ScriptingProfileServiceSection.cs
- XmlStreamNodeWriter.cs
- SecurityHelper.cs
- Rotation3DAnimation.cs
- MetaDataInfo.cs
- TextTrailingWordEllipsis.cs
- UserPreference.cs
- RepeaterItemCollection.cs
- ListQueryResults.cs
- DecoderFallbackWithFailureFlag.cs
- TableRowsCollectionEditor.cs
- MouseEvent.cs
- LicenseException.cs
- _LocalDataStore.cs
- LOSFormatter.cs
- DataGridViewElement.cs
- QueryCorrelationInitializer.cs
- CustomAttributeBuilder.cs
- EntityDataSourceViewSchema.cs
- ImageList.cs
- SimpleWorkerRequest.cs
- LocatorGroup.cs
- AxHost.cs
- DetailsViewInsertedEventArgs.cs