public void InvokeAndWait <R, K, V>(IMap <K, V> items, IResultingBackgroundWorkerParamDelegate <R, Entry <K, V> > itemHandler, IAggregrateResultHandler <R, Entry <K, V> > aggregateResultHandler)
{
if (items.Count == 0)
{
return;
}
if (!IsMultiThreadingAllowed() || items.Count == 1)
{
foreach (Entry <K, V> item in items)
{
R result = itemHandler(item);
if (aggregateResultHandler != null)
{
aggregateResultHandler(result, item);
}
}
return;
}
List <Entry <K, V> > itemsList = new List <Entry <K, V> >(items.Count);
foreach (Entry <K, V> item in items)
{
itemsList.Add(item);
}
ResultingRunnableHandle <R, Entry <K, V> > runnableHandle = new ResultingRunnableHandle <R, Entry <K, V> >(itemHandler, aggregateResultHandler, itemsList, ThreadLocalCleanupController);
Runnable parallelRunnable = new ResultingParallelRunnable <R, Entry <K, V> >(runnableHandle, true);
Runnable mainRunnable = new ResultingParallelRunnable <R, Entry <K, V> >(runnableHandle, false);
QueueAndWait(items.Count - 1, parallelRunnable, mainRunnable, runnableHandle);
}
public R Use <R, V>(IResultingBackgroundWorkerParamDelegate <R, V> runnable, V arg)
{
Object[] oldValues = SetThreadLocals();
try
{
return(runnable(arg));
}
finally
{
RestoreThreadLocals(oldValues);
}
}
public R InvokeInGuiAndWait <R, P>(IResultingBackgroundWorkerParamDelegate <R, P> callback, P state)
{
if (IsInGuiThread() || SyncContext == null)
{
return(callback(state));
}
R result = default(R);
SyncContext.Send(delegate(Object state2)
{
result = callback(state);
}, null);
return(result);
}
public R ExecuteWithCache <R, T>(ICacheProvider cacheProvider, IResultingBackgroundWorkerParamDelegate <R, T> runnable, T state)
{
ParamChecker.AssertParamNotNull(cacheProvider, "cacheProvider");
ParamChecker.AssertParamNotNull(runnable, "runnable");
Stack <ICacheProvider> stack = cacheProviderStackTL.Value;
if (stack == null)
{
stack = new Stack <ICacheProvider>();
cacheProviderStackTL.Value = stack;
}
stack.Push(cacheProvider);
try
{
return(runnable(state));
}
finally
{
if (!Object.ReferenceEquals(stack.Pop(), cacheProvider))
{
throw new Exception("Must never happen");
}
}
}
public void InvokeAndWait <R, V>(IList <V> items, IResultingBackgroundWorkerParamDelegate <R, V> itemHandler,
IAggregrateResultHandler <R, V> aggregateResultHandler)
{
if (items.Count == 0)
{
return;
}
if (!IsMultiThreadingAllowed() || items.Count == 1)
{
for (int a = items.Count; a-- > 0;)
{
V item = items[a];
R result = itemHandler(item);
aggregateResultHandler(result, item);
}
return;
}
ResultingRunnableHandle <R, V> runnableHandle = new ResultingRunnableHandle <R, V>(itemHandler, aggregateResultHandler, items, ThreadLocalCleanupController);
Runnable parallelRunnable = new ResultingParallelRunnable <R, V>(runnableHandle, true);
Runnable mainRunnable = new ResultingParallelRunnable <R, V>(runnableHandle, false);
QueueAndWait(items.Count - 1, parallelRunnable, mainRunnable, runnableHandle);
}
public ResultingRunnableHandle(IResultingBackgroundWorkerParamDelegate <R, V> run, IAggregrateResultHandler <R, V> aggregrateResultHandler, IList <V> items, IThreadLocalCleanupController threadLocalCleanupController) : base(items, threadLocalCleanupController)
{
this.run = run;
this.aggregrateResultHandler = aggregrateResultHandler;
}
public R ExecuteWithCache <R, T>(ICache cache, IResultingBackgroundWorkerParamDelegate <R, T> runnable, T state)
{
ParamChecker.AssertParamNotNull(cache, "cache");
ParamChecker.AssertParamNotNull(runnable, "runnable");
return(ExecuteWithCache <R, T>(new SingleCacheProvider(cache), runnable, state));
}
public R ExecuteWithCache <R, T>(IResultingBackgroundWorkerParamDelegate <R, T> runnable, T state)
{
return(ExecuteWithCache(ThreadLocalCacheProvider, runnable, state));
}
