public new bool ShouldContinue([NotNull] string query, [NotNull] string caption)
{
var workItem = new MarshalItemFunc <string, string, bool>(base.ShouldContinue, query, caption);
AsyncCmdletSynchronizationContext.PostItem(workItem);
return(workItem.WaitForResult());
}
public static void Async([NotNull] Func <Task> handler, int boundedCapacity)
{
var previousContext = SynchronizationContext.Current;
try
{
using (var synchronizationContext = new AsyncCmdletSynchronizationContext(boundedCapacity))
{
SetSynchronizationContext(synchronizationContext);
_currentAsyncCmdletContext = synchronizationContext;
var task = handler();
if (task == null)
{
return;
}
var waitable = task.ContinueWith(t => synchronizationContext.Complete(), scheduler: TaskScheduler.Default);
synchronizationContext.ProcessQueue();
waitable.GetAwaiter().GetResult();
}
}
finally
{
SetSynchronizationContext(previousContext);
_currentAsyncCmdletContext = previousContext as AsyncCmdletSynchronizationContext;
}
}
public new bool TransactionAvailable()
{
var workItem = new MarshalItemFunc <bool>(base.TransactionAvailable);
AsyncCmdletSynchronizationContext.PostItem(workItem);
return(workItem.WaitForResult());
}
public new bool ShouldProcess([NotNull] string target, [NotNull] string action)
{
var workItem = new MarshalItemFunc <string, string, bool>(base.ShouldProcess, target, action);
AsyncCmdletSynchronizationContext.PostItem(workItem);
return(workItem.WaitForResult());
}
public new bool ShouldContinue([NotNull] string query, [NotNull] string caption, ref bool yesToAll, ref bool noToAll)
{
var workItem = new MarshalItemFuncRef <string, string, bool, bool, bool>(base.ShouldContinue, query, caption,
yesToAll, noToAll);
AsyncCmdletSynchronizationContext.PostItem(workItem);
return(workItem.WaitForResult(ref yesToAll, ref noToAll));
}
public new bool ShouldProcess([NotNull] string verboseDescription, [NotNull] string verboseWarning, [NotNull] string caption)
{
var workItem = new MarshalItemFunc <string, string, string, bool>(base.ShouldProcess, verboseDescription,
verboseWarning, caption);
AsyncCmdletSynchronizationContext.PostItem(workItem);
return(workItem.WaitForResult());
}
public new bool ShouldProcess(string verboseDescription, string verboseWarning, string caption,
out ShouldProcessReason shouldProcessReason)
{
var workItem = new MarshalItemFuncOut <string, string, string, bool, ShouldProcessReason>(
base.ShouldProcess, verboseDescription, verboseWarning, caption);
AsyncCmdletSynchronizationContext.PostItem(workItem);
return(workItem.WaitForResult(out shouldProcessReason));
}
public static void Async([NotNull] Func <Task> handler, int boundedCapacity)
{
var previousContext = SynchronizationContext.Current;
try
{
using (var synchronizationContext = new AsyncCmdletSynchronizationContext(boundedCapacity))
{
SetSynchronizationContext(synchronizationContext);
currentAsyncCmdletContext = synchronizationContext;
var task = handler();
if (task == null)
{
return;
}
var waitable = task.ContinueWith(t => synchronizationContext.Complete(), scheduler: TaskScheduler.Default);
synchronizationContext.ProcessQueue();
waitable.GetAwaiter().GetResult();
//error handling - exception is AggregateException therefore throwing inner exception
var exception = task.Exception;
if (exception != null && exception.InnerException != null)
{
throw exception.InnerException;
}
}
}
finally
{
SetSynchronizationContext(previousContext);
currentAsyncCmdletContext = previousContext as AsyncCmdletSynchronizationContext;
}
}
public new void WriteCommandDetail([NotNull] string text)
{
AsyncCmdletSynchronizationContext.PostItem(new MarshalItemAction <string>(base.WriteCommandDetail, text));
}
protected sealed override void ProcessRecord()
{
AsyncCmdletSynchronizationContext.Async(ProcessRecordAsync, BoundedCapacity);
}
public new void WriteProgress([NotNull] ProgressRecord progressRecord)
{
AsyncCmdletSynchronizationContext.PostItem(new MarshalItemAction <ProgressRecord>(base.WriteProgress, progressRecord));
}
public new void WriteWarning([NotNull] string text)
{
AsyncCmdletSynchronizationContext.PostItem(new MarshalItemAction <string>(base.WriteWarning, text));
}
public new void WriteObject([CanBeNull] object sendToPipeline)
{
AsyncCmdletSynchronizationContext.PostItem(new MarshalItemAction <object>(base.WriteObject, sendToPipeline));
}
public new void WriteObject([CanBeNull] object sendToPipeline, bool enumerateCollection)
{
AsyncCmdletSynchronizationContext.PostItem(new MarshalItemAction <object, bool>(base.WriteObject, sendToPipeline, enumerateCollection));
}
public new void WriteError([NotNull] ErrorRecord errorRecord)
{
AsyncCmdletSynchronizationContext.PostItem(new MarshalItemAction <ErrorRecord>(base.WriteError, errorRecord));
}
public new void WriteDebug([CanBeNull] string text)
{
AsyncCmdletSynchronizationContext.PostItem(new MarshalItemAction <string>(base.WriteDebug, text));
}
protected sealed override void StopProcessing()
{
AsyncCmdletSynchronizationContext.Async(StopProcessingAsync, BoundedCapacity);
}
public new void ThrowTerminatingError(ErrorRecord errorRecord)
{
AsyncCmdletSynchronizationContext.PostItem(new MarshalItemAction <ErrorRecord>(base.ThrowTerminatingError, errorRecord));
}
public new void WriteVerbose(string text)
{
var workItem = new MarshalItemAction <string>(base.WriteVerbose, text);
AsyncCmdletSynchronizationContext.PostItem(workItem);
}
