public virtual void Queue <T>(IBackgroundWorkerParamDelegate <T> workerRunnable, T state)
{
System.Threading.ThreadPool.QueueUserWorkItem(delegate(Object myState)
{
try
{
workerRunnable.Invoke(state);
}
catch (ThreadAbortException)
{
// Intended blank
}
#if SILVERLIGHT
catch (Exception e)
{
Log.Error(e);
throw;
}
#else
catch (Exception e)
{
Log.Error(e);
}
#endif
finally
{
ThreadLocalCleanupController.CleanupThreadLocal();
}
});
}
public IBeanContextHolder <I> CreateService <I>(String contextName, IBackgroundWorkerParamDelegate <IBeanContextFactory> registerPhaseDelegate, params Type[] serviceModuleTypes)
{
CheckNotDisposed();
IBeanContextInitializer beanContextInitializer = RegisterBean <BeanContextInitializer>().Finish();
if (contextName == null && registerPhaseDelegate == null && serviceModuleTypes.Length == 1)
{
contextName = serviceModuleTypes[0].Name;
}
BeanContextFactory childBeanContextFactory = beanContextFactory.CreateChildContextFactory(beanContextInitializer, this);
IServiceContext childContext = childBeanContextFactory.Create(contextName, this, registerPhaseDelegate, serviceModuleTypes);
writeLock.Lock();
try
{
if (children == null)
{
children = new IdentityHashSet <IServiceContext>();
}
children.Add(childContext);
}
finally
{
writeLock.Unlock();
}
return(new BeanContextHolder <I>(childContext));
}
public IServiceContext Create(String contextName, ServiceContext parent, IBackgroundWorkerParamDelegate <IBeanContextFactory> registerPhaseDelegate, Type[] serviceModuleTypes)
{
ServiceContext context = new ServiceContext(GenerateUniqueContextName(contextName, null), parent);
if (registerPhaseDelegate != null)
{
registerPhaseDelegate(this);
}
foreach (Type serviceModuleType in serviceModuleTypes)
{
RegisterBean(serviceModuleType);
}
IList <IBeanPreProcessor> preProcessors = parent.GetPreProcessors();
if (preProcessors != null)
{
for (int a = 0, size = preProcessors.Count; a < size; a++)
{
context.AddPreProcessor(preProcessors[a]);
}
}
IList <IBeanPostProcessor> postProcessors = parent.GetPostProcessors();
if (postProcessors != null)
{
for (int a = 0, size = postProcessors.Count; a < size; a++)
{
context.AddPostProcessor(postProcessors[a]);
}
}
beanContextInitializer.InitializeBeanContext(context, this);
return(context);
}
public void InvokeAndWait <K, V>(IMap <K, V> items, IBackgroundWorkerParamDelegate <Entry <K, V> > itemHandler)
{
if (items.Count == 0)
{
return;
}
if (!IsMultiThreadingAllowed() || items.Count == 1)
{
foreach (Entry <K, V> item in items)
{
itemHandler(item);
}
return;
}
List <Entry <K, V> > itemsList = new List <Entry <K, V> >(items.Count);
foreach (Entry <K, V> item in items)
{
itemsList.Add(item);
}
RunnableHandle <Entry <K, V> > runnableHandle = new RunnableHandle <Entry <K, V> >(itemHandler, itemsList, ThreadLocalCleanupController);
Runnable parallelRunnable = new ParallelRunnable <Entry <K, V> >(runnableHandle, true);
Runnable mainRunnable = new ParallelRunnable <Entry <K, V> >(runnableHandle, false);
QueueAndWait(items.Count - 1, parallelRunnable, mainRunnable, runnableHandle);
}
public override IServiceContext Start(IBackgroundWorkerParamDelegate <IBeanContextFactory> content)
{
return(StartIntern(delegate(IBeanContextFactory childContextFactory)
{
if (Content != null)
{
Content.Invoke(childContextFactory);
}
content.Invoke(childContextFactory);
}));
}
public void Use <V>(IBackgroundWorkerParamDelegate <V> runnable, V arg)
{
Object[] oldValues = SetThreadLocals();
try
{
runnable(arg);
}
finally
{
RestoreThreadLocals(oldValues);
}
}
protected virtual IServiceContext StartIntern(IBackgroundWorkerParamDelegate <IBeanContextFactory> content)
{
writeLock.Lock();
try
{
if (Log.DebugEnabled)
{
Log.Debug("Looking for existing child context...");
}
IServiceContext childContext = GetChildContext();
if (childContext == null || childContext.IsDisposed)
{
if (Log.DebugEnabled)
{
Log.Debug("No valid child context found. Creating new child context");
}
IBackgroundWorkerParamDelegate <IBeanContextFactory> rpd = new IBackgroundWorkerParamDelegate <IBeanContextFactory>(delegate(IBeanContextFactory beanContextFactory)
{
if (content != null)
{
content.Invoke(beanContextFactory);
}
beanContextFactory.RegisterBean <ChildContextFoot>().PropertyValue("ContextHandle", this);
});
if (ContextFactory != null)
{
childContext = ContextFactory.CreateChildContext(rpd);
}
else
{
childContext = BeanContext.CreateService(rpd);
}
SetChildContext(childContext);
childContexts.Add(childContext);
}
else if (Log.DebugEnabled)
{
Log.Debug("Existing child context found and valid");
}
IList <IUpwakingBean> upwakingBeans = childContext.GetImplementingObjects <IUpwakingBean>();
for (int a = 0, size = upwakingBeans.Count; a < size; a++)
{
upwakingBeans[a].WakeUp();
}
return(childContext);
}
finally
{
writeLock.Unlock();
}
}
protected void WaitEventToResume(IBackgroundWorkerParamDelegate <IProcessResumeItem> resumeDelegate, IBackgroundWorkerParamDelegate <Exception> errorDelegate)
{
IRootCache rootCache = RootCache;
IList <IWritableCache> selectedFirstLevelCaches = FirstLevelCacheManager.SelectFirstLevelCaches();
ISet <Object> collisionSet = new IdentityHashSet <Object>();
collisionSet.Add(rootCache);
for (int a = selectedFirstLevelCaches.Count; a-- > 0;)
{
collisionSet.Add(selectedFirstLevelCaches[a]);
}
// Without the current rootcache we can not handle the event now. We have to block till the rootCache and all childCaches get valid
EventDispatcher.WaitEventToResume(collisionSet, -1, resumeDelegate, errorDelegate);
}
public ThreadLocalCleanupController()
{
foreignContextHook = new IBackgroundWorkerParamDelegate <IServiceContext>(delegate(IServiceContext state)
{
Lock writeLock = listeners.GetWriteLock();
writeLock.Lock();
try
{
cachedForkStateEntries = null;
}
finally
{
writeLock.Unlock();
}
});
}
public void InvokeAndWait <V>(IList <V> items, IBackgroundWorkerParamDelegate <V> itemHandler)
{
if (items.Count == 0)
{
return;
}
if (!IsMultiThreadingAllowed() || items.Count == 1)
{
for (int a = items.Count; a-- > 0;)
{
V item = items[a];
itemHandler(item);
}
return;
}
RunnableHandle <V> runnableHandle = new RunnableHandle <V>(itemHandler, items, ThreadLocalCleanupController);
Runnable parallelRunnable = new ParallelRunnable <V>(runnableHandle, true);
Runnable mainRunnable = new ParallelRunnable <V>(runnableHandle, false);
QueueAndWait(items.Count - 1, parallelRunnable, mainRunnable, runnableHandle);
}
public QueueGroupKey(long queueInterval, IBackgroundWorkerParamDelegate <IList <T> > queuedDelegate)
: this(queueInterval, false, queuedDelegate)
{
// Intended blank
}
public void Run()
{
try
{
Thread currentThread = Thread.CurrentThread;
String oldName = currentThread.Name;
if (buildThreadLocals)
{
String name = runnableHandle.createdThread.Name;
currentThread.Name = name + " " + oldName;
}
try
{
Object parallelLock = runnableHandle.parallelLock;
IList <V> items = runnableHandle.items;
IForkState forkState = runnableHandle.forkState;
ParamHolder <Exception> exHolder = runnableHandle.exHolder;
CountDownLatch latch = runnableHandle.latch;
IBackgroundWorkerParamDelegate <V> run = new IBackgroundWorkerParamDelegate <V>(delegate(V item)
{
R result = runnableHandle.run(item);
IAggregrateResultHandler <R, V> aggregrateResultHandler = runnableHandle.aggregrateResultHandler;
if (aggregrateResultHandler != null)
{
lock (parallelLock)
{
aggregrateResultHandler(result, item);
}
}
});
while (true)
{
V item;
lock (parallelLock)
{
if (exHolder.Value != null)
{
// an uncatched error occurred somewhere
return;
}
// pop the last item of the queue
item = items[items.Count - 1];
items.RemoveAt(items.Count - 1);
}
if (item == null)
{
// queue finished
return;
}
try
{
if (buildThreadLocals)
{
forkState.Use(run, item);
}
else
{
run(item);
}
}
catch (Exception e)
{
lock (parallelLock)
{
if (exHolder.Value == null)
{
exHolder.Value = e;
}
}
}
finally
{
latch.CountDown();
}
}
}
finally
{
if (buildThreadLocals)
{
currentThread.Name = oldName;
}
}
}
finally
{
if (buildThreadLocals)
{
runnableHandle.threadLocalCleanupController.CleanupThreadLocal();
}
}
}
public virtual IServiceContext CreateChildContext(IBackgroundWorkerParamDelegate <IBeanContextFactory> content)
{
return(BeanContext.CreateService(content, Modules));
}
public IBeanContextHolder <I> CreateService <I>(IBackgroundWorkerParamDelegate <IBeanContextFactory> registerPhaseDelegate, params Type[] serviceModuleTypes)
{
return(CreateService <I>(null, registerPhaseDelegate, serviceModuleTypes));
}
public IServiceContext Create(String contextName, ServiceContext parent, IBackgroundWorkerParamDelegate <IBeanContextFactory> registerPhaseDelegate)
{
return(Create(contextName, parent, registerPhaseDelegate, emptyServiceModules));
}
public IServiceContext Create(String contextName, IBackgroundWorkerParamDelegate <IBeanContextFactory> registerPhaseDelegate, IList <IBeanPreProcessor> preProcessors,
IList <IBeanPostProcessor> postProcessors)
{
return(Create(contextName, registerPhaseDelegate, preProcessors, postProcessors, emptyServiceModules));
}
public QueueGroupKey(long queueInterval, bool invokeFromGuiThread, IBackgroundWorkerParamDelegate <IList <T> > queuedDelegate) : base(queueInterval, invokeFromGuiThread)
{
this.QueuedDelegate = queuedDelegate;
}
public void RegisterDisposeHook(IBackgroundWorkerParamDelegate <IServiceContext> waitCallback)
{
RegisterDisposableIntern(waitCallback, false);
}
public virtual IServiceContext Start(IBackgroundWorkerParamDelegate <IBeanContextFactory> content)
{
throw new NotSupportedException();
}
public RunnableHandle(IBackgroundWorkerParamDelegate <V> run, IList <V> items, IThreadLocalCleanupController threadLocalCleanupController) : base(items, threadLocalCleanupController)
{
this.run = run;
}
public void WaitEventToResume(Object eventTargetToResume, long maxWaitTime, IBackgroundWorkerParamDelegate <IProcessResumeItem> resumeDelegate, IBackgroundWorkerParamDelegate <Exception> errorDelegate)
{
try
{
IdentityHashSet <Object> pendingSet = new IdentityHashSet <Object>();
if (eventTargetToResume is IEnumerable)
{
pendingSet.AddAll((IEnumerable)eventTargetToResume);
}
else
{
pendingSet.Add(eventTargetToResume);
}
WaitForResumeItem pauseItem = null;
listenersWriteLock.Lock();
try
{
IList <Object> remainingPausedEventTargets = EvaluatePausedEventTargetsOfForeignThreads();
IdentityLinkedSet <Object> remainingPausedEventTargetsSet = new IdentityLinkedSet <Object>(remainingPausedEventTargets);
remainingPausedEventTargetsSet.RetainAll(pendingSet);
if (remainingPausedEventTargetsSet.Count > 0)
{
// We should wait now but we have to check if we are in the UI thread, which must never wait
if (GuiThreadHelper.IsInGuiThread())
{
// This is the trick: We "requeue" the current action in the UI pipeline to prohibit blocking
GuiThreadHelper.InvokeInGuiLate(delegate()
{
WaitEventToResume(eventTargetToResume, maxWaitTime, resumeDelegate, errorDelegate);
});
return;
}
pauseItem = new WaitForResumeItem(pendingSet);
waitForResumeSet.Add(pauseItem);
}
}
finally
{
listenersWriteLock.Unlock();
}
if (pauseItem == null)
{
resumeDelegate.Invoke(null);
return;
}
CountDownLatch latch = pauseItem.Latch;
if (maxWaitTime < 0)
{
latch.Await();
}
else if (maxWaitTime > 0)
{
latch.Await(TimeSpan.FromMilliseconds(maxWaitTime));
}
else
{
throw new System.Exception("Thread should wait but does not want to");
}
resumeDelegate.Invoke(pauseItem);
}
catch (Exception e)
{
if (Log.ErrorEnabled)
{
Log.Error(e);
}
if (errorDelegate != null)
{
errorDelegate.Invoke(e);
}
throw;
}
}