private bool OnThumbnailReady(IThumbnailProvider dw, ValueEventHandler <Tuple <IThumbnailProvider, ISurface <ColorBgra> > > callback, ISurface <ColorBgra> thumb)
{
ValueEventArgs <Tuple <IThumbnailProvider, ISurface <ColorBgra> > > args = ValueEventArgs <Tuple <IThumbnailProvider, ISurface <ColorBgra> > > .Get(Tuple.Create <IThumbnailProvider, ISurface <ColorBgra> >(dw, thumb));
List <Tuple <ValueEventHandler <Tuple <IThumbnailProvider, ISurface <ColorBgra> > >, object, ValueEventArgs <Tuple <IThumbnailProvider, ISurface <ColorBgra> > > > > thumbnailReadyInvokeList = this.thumbnailReadyInvokeList;
lock (thumbnailReadyInvokeList)
{
this.thumbnailReadyInvokeList.Add(new Tuple <ValueEventHandler <Tuple <IThumbnailProvider, ISurface <ColorBgra> > >, object, ValueEventArgs <Tuple <IThumbnailProvider, ISurface <ColorBgra> > > >(callback, this, args));
}
try
{
this.syncContext.Post(delegate(object _) {
this.DrainThumbnailReadyInvokeList();
}, null);
return(true);
}
catch (Exception exception)
{
if (!(exception is ObjectDisposedException) && !(exception is InvalidOperationException))
{
throw;
}
return(false);
}
}
public static void Raise <T>(this ValueEventHandler <T> handler, object sender, ValueEventArgs <T> e)
{
if (handler != null)
{
handler(sender, e);
}
}
private void HookUpEvents()
{
using (Dictionary <string, Property> .ValueCollection.Enumerator enumerator = this.properties.Values.GetEnumerator())
{
while (enumerator.MoveNext())
{
ValueEventHandler <object> handler;
ValueEventHandler <bool> handler3;
Property property = enumerator.Current;
if (this.valueChangedHandlers.TryGetValue(property, out handler))
{
property.ValueChanged -= handler;
}
ValueEventHandler <object> handler2 = (s, e) => this.OnPropertyValueChanged(property, e.Value);
property.ValueChanged += handler2;
this.valueChangedHandlers.Add(property, handler2);
if (this.readOnlyChangedHandlers.TryGetValue(property, out handler3))
{
property.ReadOnlyChanged -= handler3;
}
ValueEventHandler <bool> handler4 = (s, e) => this.OnPropertyReadOnlyChanged(property, e.Value);
property.ReadOnlyChanged += handler4;
this.readOnlyChangedHandlers.Add(property, handler4);
}
}
}
public async Task CanGetEventSubscriptions_WhenTheyHaveBeenSubscribedBefore()
{
Action <Type> register = t => { };
var expectedValue = 0;
var @event = new ValueEvent(Value);
var eventHandlerInstance = new ValueEventHandler();
var eventHandler = new Func <ValueEvent, Task>(e =>
{
expectedValue = e.Value;
return(Task.CompletedTask);
});
A.CallTo(() => this.handlerRegistry.GetEventHandlers(@event)).Returns(new[] { eventHandlerInstance });
this.testee.AddEventHandler(eventHandler);
this.testee.ScanAssemblyForMessageHandlers(Assembly.GetExecutingAssembly(), register);
var subscriptions = this.testee.GetEventSubscriptions(@event);
var tasks = subscriptions.Select(s => s.HandleAsync(@event));
await Task.WhenAll(tasks).ConfigureAwait(false);
expectedValue.Should().Be(Value);
eventHandlerInstance.Value.Should().Be(Value);
}
public void CanSubscribeEventHandler()
{
var handler = new ValueEventHandler();
this.testee.SubscribeEventHandler <ValueEvent>(handler.HandleAsync);
var subscriptions = this.testee.Subscriptions.GetEventSubscriptions(new ValueEvent(11));
subscriptions.Single().Should().BeAssignableTo <EventSubscription <ValueEvent> >();
}
public static void Raise <T>(this ValueEventHandler <T> handler, object sender, T value)
{
if (handler != null)
{
ValueEventArgs <T> e = ValueEventArgs <T> .Get(value);
handler(sender, e);
e.Return();
}
}
private void StateMachineThread()
{
this.threadException = null;
ValueEventHandler <PaintDotNet.Updates.State> handler = delegate(object sender, ValueEventArgs <PaintDotNet.Updates.State> e) {
this.stateMachineInitialized.Set();
this.OnStateBegin(e.Value);
};
ProgressEventHandler handler2 = (sender, e) => this.OnStateProgress(e.Percent);
try
{
this.stateMachineNotBusy.Set();
this.OnStateMachineBegin();
this.stateMachineNotBusy.Reset();
this.stateMachine.NewState += handler;
this.stateMachine.StateProgress += handler2;
this.stateMachine.Start();
do
{
this.stateMachineNotBusy.Set();
this.OnStateWaitingForInput(this.stateMachine.CurrentState);
this.inputAvailable.WaitOne();
this.inputAvailable.Reset();
if (this.pleaseAbort)
{
break;
}
this.stateMachine.ProcessInput(this.queuedInput);
}while (!this.stateMachine.IsInFinalState);
this.stateMachineNotBusy.Set();
}
catch (Exception exception)
{
this.threadException = exception;
}
finally
{
this.stateMachineNotBusy.Set();
this.stateMachineInitialized.Set();
this.stateMachine.NewState -= handler;
this.stateMachine.StateProgress -= handler2;
this.OnStateMachineFinished();
}
}
public void EnsureInitialize(Assembly assembly)
{
foreach (var type in assembly.GetTypes())
{
ExecutionContainerAttribute containerAttr =
type.GetCustomAttributes(typeof(ExecutionContainerAttribute), false)
.Cast <ExecutionContainerAttribute>()
.FirstOrDefault();
if (containerAttr == null)
{
continue;
}
LogErrorAttribute classErrorAttr = type.GetCustomAttributes(typeof(LogErrorAttribute), false).Cast <LogErrorAttribute>().FirstOrDefault();
var factory = _factories[containerAttr.FactoryType];
var methods = type.GetMethods( );
foreach (var method in methods)
{
ExecutionAttribute executionAttr = method.GetCustomAttributes(typeof(ExecutionAttribute), false).Cast <ExecutionAttribute>().FirstOrDefault();
LogErrorAttribute logErrorAttr = method.GetCustomAttributes(typeof(LogErrorAttribute), false).Cast <LogErrorAttribute>().FirstOrDefault();
if (executionAttr != null)
{
var handle = method.MethodHandle;
ValueEventHandler handler = (object sender, ValueEventArgs e) => MethodBase.GetMethodFromHandle(handle).Invoke(null, new object[] { sender, e });
var execution = new FuncExecution(handler);
if (logErrorAttr != null)
{
execution.SwallowError = logErrorAttr.Swallow;
execution.LogError = true;
}
else if (classErrorAttr != null)
{
execution.SwallowError = classErrorAttr.Swallow;
execution.LogError = true;
}
factory.Add(executionAttr.Key, execution);
}
}
}
}
public static void Main(String[] args)
{
ThreadPool.SetMaxThreads(2, 256);
//Executor executor = Executors.newFixedThreadPool(2);
//EventFactory<ValueEvent<String>> factory = ValueEventHandler.factory();
Disruptor <ValueEvent <String> > disruptorA =
new Disruptor <ValueEvent <String> >(
() => new ValueEvent <string>(),
1024,
TaskScheduler.Default,
ProducerType.MULTI,
new BlockingWaitStrategy());
Disruptor <ValueEvent <String> > disruptorB =
new Disruptor <ValueEvent <String> >(
() => new ValueEvent <string>(),
1024,
TaskScheduler.Default,
ProducerType.SINGLE,
new BlockingWaitStrategy());
ValueEventHandler <String> handlerA = new ValueEventHandler <String>(
disruptorB.GetRingBuffer);
disruptorA.HandleEventsWith(handlerA);
ValueEventHandler <String> handlerB = new ValueEventHandler <String>(
disruptorA.GetRingBuffer);
disruptorB.HandleEventsWith(handlerB);
disruptorA.Start();
disruptorB.Start();
Console.Read();
}
public void QueueThumbnailUpdate(IThumbnailProvider updateMe, int thumbSideLength, ValueEventHandler <Tuple <IThumbnailProvider, ISurface <ColorBgra> > > callback)
{
if (thumbSideLength < 1)
{
throw new ArgumentOutOfRangeException("thumbSideLength", "must be greater than or equal to 1");
}
object updateLock = this.updateLock;
lock (updateLock)
{
this.RemoveFromQueue(updateMe);
Tuple <IThumbnailProvider, ValueEventHandler <Tuple <IThumbnailProvider, ISurface <ColorBgra> > >, int> item = new Tuple <IThumbnailProvider, ValueEventHandler <Tuple <IThumbnailProvider, ISurface <ColorBgra> > >, int>(updateMe, callback, thumbSideLength);
if (this.renderQueue.Any <Tuple <IThumbnailProvider, ValueEventHandler <Tuple <IThumbnailProvider, ISurface <ColorBgra> > >, int> >())
{
Tuple <IThumbnailProvider, ValueEventHandler <Tuple <IThumbnailProvider, ISurface <ColorBgra> > >, int> tuple2 = this.renderQueue.PeekBack();
if (item.Equals(tuple2))
{
this.renderQueue.DequeueBack();
}
}
this.renderQueue.Enqueue(item);
Monitor.Pulse(this.updateLock);
}
}
//delegate void( object , ValueEventArgs ) ValueEventHandler;
//public EventHandler/*<TArgs>*/ EventHandler;
public FuncExecution(ValueEventHandler /*<TArgs>*/ func)
{
EventHandler += func;
}
