public static void TestBatchingWithKey(IAsyncFiber fiber) { using (fiber) using (ManualResetEvent reset = new ManualResetEvent(false)) { Channel <int> counter = new Channel <int>(); Task Cb(IDictionary <string, int> batch) { if (batch.ContainsKey("9")) { reset.Set(); } return(Task.CompletedTask); } string KeyResolver(int x) { return(x.ToString()); } //disposed with fiber counter.SubscribeToKeyedBatch(fiber, KeyResolver, Cb, TimeSpan.FromMilliseconds(1)); for (int i = 0; i < 10; i++) { counter.Publish(i); } Assert.IsTrue(reset.WaitOne(10000, false)); } }
public static void TestBatching(IAsyncFiber fiber) { using (fiber) using (ManualResetEvent reset = new ManualResetEvent(false)) { Channel <int> counter = new Channel <int>(); int total = 0; Task Cb(IList <int> batch) { total += batch.Count; if (total == 10) { reset.Set(); } return(Task.CompletedTask); } counter.SubscribeToBatch(fiber, Cb, TimeSpan.FromMilliseconds(1)); for (int i = 0; i < 10; i++) { counter.Publish(i); } Assert.IsTrue(reset.WaitOne(10000, false)); } }
public IDisposable SendRequest(TRequest request, IAsyncFiber fiber, Func <TReply, Task> onReply) { AsyncChannelRequest channelRequest = new AsyncChannelRequest(fiber, request, onReply); _requestChannel.Publish(channelRequest); return(new Unsubscriber(channelRequest, fiber)); }
// ReSharper disable once UnusedMember.Local private IDisposable AsyncSubscribeToChannel <T>(IAsyncFiber fiber, IHandleAsync <T> receive) { Type type = typeof(T); IChannel <T> channel = (IChannel <T>)_channels.GetOrAdd(type, _ => new Channel <T>()); return(channel.Subscribe(fiber, receive.HandleAsync)); }
public AsyncTimerAction(IAsyncFiber fiber, Func <Task> action, TimeSpan dueTime, TimeSpan interval) { _action = action; _interval = interval; _timer = new Timer(x => ExecuteOnTimerThread(fiber), null, dueTime, interval); fiber.Add(this); }
public void Run(IAsyncFiber fiber) { using AutoResetEvent wait = new AutoResetEvent(false); using (fiber) { int i = 0; Task AsyncHandler() { i++; if (i == OperationsPerInvoke) { wait.Set(); } return(Task.CompletedTask); } for (int j = 0; j < OperationsPerInvoke; j++) { fiber.Enqueue(AsyncHandler); } WaitHandle.WaitAny(new WaitHandle[] { wait }); } }
public AsyncTimerAction(IAsyncFiber fiber, Func <Task> action, TimeSpan dueTime) { _action = action; _interval = TimeSpan.FromMilliseconds(-1); _timer = new Timer(x => ExecuteOnTimerThread(fiber), null, dueTime, _interval); fiber.Add(this); }
public void RunMultAsync(IFiberFactory factory, Func <IChannel <int> > queueFactory, int count, int wait1) { using AutoResetEvent wait = new AutoResetEvent(false); int hCount = 0; Task AsyncHandler(int s) { int c = Interlocked.Increment(ref hCount); if (c == OperationsPerInvoke) { wait.Set(); } NOP(wait1 / 1000.0); return(Task.CompletedTask); } using IChannel <int> _queue = queueFactory(); using IDisposable fibers = new Disposables(Enumerable.Range(0, count).Select(x => { IAsyncFiber fiber = factory.CreateAsyncFiber(ex => { }); IDisposable sub = _queue.Subscribe(fiber, AsyncHandler); return(fiber); })); for (int j = 1; j <= OperationsPerInvoke; j++) { _queue.Publish(j); } WaitHandle.WaitAny(new WaitHandle[] { wait }); }
public static IChannel <T> NewChannel <T>(this IAsyncFiber fiber, Func <T, Task> onEvent) { Channel <T> channel = new(); channel.Subscribe(fiber, onEvent); return(channel); }
public static void TestPubSubWithFilter(IAsyncFiber fiber) { using (fiber) using (AutoResetEvent reset = new AutoResetEvent(false)) { Channel <int> channel = new Channel <int>(); Task OnMsg(int x) { Assert.IsTrue(x % 2 == 0); if (x == 4) { reset.Set(); } return(Task.CompletedTask); } channel.Subscribe(fiber, OnMsg, x => x % 2 == 0); channel.Publish(1); channel.Publish(2); channel.Publish(3); channel.Publish(4); Assert.IsTrue(reset.WaitOne(5000, false)); } }
public static void InOrderExecution(IAsyncFiber fiber) { using (fiber) using (AutoResetEvent reset = new AutoResetEvent(false)) { Channel <int> channel = new Channel <int>(); List <int> result = new List <int>(); Task Command(int i) { result.Add(i); if (i == 99) { reset.Set(); } return(Task.CompletedTask); } channel.Subscribe(fiber, Command); for (int i = 0; i < 100; i++) { channel.Publish(i); } Assert.IsTrue(reset.WaitOne(10000, false)); Assert.AreEqual(100, result.Count); for (int i = 0; i < 100; i++) { Assert.AreEqual(i, result[i]); } } }
public AsyncQueueConsumer(IAsyncFiber target, Func <TMsg, Task> callback, QueueChannelRR <TMsg> eventChannel) { _target = target; _callback = callback; _eventChannel = eventChannel; }
public void Setup() { _fiber = new Fiber(); _fiberReply = new Fiber(); _asyncFiber = new AsyncFiber(); _requestChannel.SetRequestHandler(_fiberReply, r => r.Reply(1)); _asyncRequestChannel.SetRequestHandler(_asyncFiber, async r => r.Reply(1)); }
public static IRequestPort <TRq, TRp> NewRequestPort <TRq, TRp>(this IAsyncFiber fiber, Func <IRequest <TRq, TRp>, Task> onEvent) { RequestChannel <TRq, TRp> channel = new(); channel.SetRequestHandler(fiber, onEvent); return(channel); }
public AsyncQueueConsumer(IAsyncFiber target, Func <TMsg, Task> callback, QueueChannel2 <TMsg> eventChannel) { _target = target; _callback = callback; _eventChannel = eventChannel; _cache = ConsumeNext; eventChannel.Signal += Signal; }
public AsyncKeyedBatchSubscriber(ISubscriberPort <T> channel, IAsyncFiber fiber, TimeSpan interval, Converter <T, TKey> keyResolver, Func <IDictionary <TKey, T>, Task> target) : base(channel, fiber, interval) { _keyResolver = keyResolver; _target = target; }
public IDisposable Subscribe(IAsyncFiber fiber, Func <T, Task> receive) { void Receive(T msg) { fiber.Enqueue(() => receive(msg)); } IDisposable disposable = _internalEvent.Subscribe(Receive); return(new Unsubscriber(disposable, fiber)); }
public IDisposable Schedule(IAsyncFiber fiber, Func <Task> action, TimeSpan dueTime) { if (dueTime.TotalMilliseconds <= 0) { AsyncPendingAction pending = new AsyncPendingAction(action); fiber.Enqueue(pending.ExecuteAsync); return(pending); } return(new AsyncTimerAction(fiber, action, dueTime)); }
public AsyncSnapshotRequest(IAsyncFiber fiber, ISubscriberPort <T> updatesPort, Func <T, Task> receive, Func <TSnapshot, Task> receiveSnapshot) { _fiber = fiber; _updatesPort = updatesPort; _receive = receive; _receiveSnapshot = receiveSnapshot; _fiber.Add(this); }
public IDisposable Subscribe(IAsyncFiber fiber, Func <Task> receive) { void Action() { fiber.Enqueue(receive); } IDisposable disposable = _internalEvent.Subscribe(Action); return(new Unsubscriber(disposable, fiber)); }
public void Run(IAsyncFiber fiber) { using (fiber) { using IDisposable sub = _channel.Subscribe(fiber, AsyncHandler); i = 0; Task.Run(Iterate); Task.Run(Iterate); WaitHandle.WaitAny(new WaitHandle[] { _wait }); } }
public IDisposable Subscribe(IAsyncFiber fiber, Func <T, Task> receive, Func <TSnapshot, Task> receiveSnapshot) { AsyncSnapshotRequest primedSubscribe = new AsyncSnapshotRequest(fiber, _updatesChannel, receive, receiveSnapshot); _requestChannel.SendRequest(null, fiber, x => { primedSubscribe.Publish(x); return(Task.CompletedTask); }); return(new Unsubscriber(primedSubscribe, fiber)); }
public IDisposable Subscribe(IAsyncFiber fiber, Func <TMsg, Task> receive) { AsyncQueueConsumer asyncQueueConsumer = new AsyncQueueConsumer(fiber, receive, this); lock (_lock) { _subscribers = _subscribers.Append(asyncQueueConsumer).ToArray(); _subCount++; } return(new Unsubscriber(asyncQueueConsumer, fiber)); }
public void Run(IAsyncFiber fiber) { using IDisposable sub = _channel.Subscribe(fiber, AsyncHandler); i = 0; for (int j = 0; j < _count; j++) { _ = Task.Run(Iterate); } WaitHandle.WaitAny(new WaitHandle[] { _wait }); }
private void ExecuteOnTimerThread(IAsyncFiber fiber) { if (_interval.Ticks == TimeSpan.FromMilliseconds(-1).Ticks || _cancelled) { fiber.Remove(this); DisposeTimer(); } if (!_cancelled) { fiber.Enqueue(ExecuteAsync); } }
public IDisposable Subscribe(IAsyncFiber fiber, Func <T, Task> receive) { lock (_lock) { IDisposable disposable = _updateChannel.Subscribe(fiber, receive); if (_hasValue) { T item = _last; fiber.Enqueue(() => receive(item)); } return(disposable); } }
private void Init(T decorated, Action <Exception> callback = null) { if (decorated == null) { throw new ArgumentNullException(nameof(decorated)); } _decorated = decorated; IAsyncExecutor executor = callback != null ? new AsyncExceptionHandlingExecutor(callback) : (IAsyncExecutor) new AsyncExecutor(); _fiber = new AsyncFiber(executor); }
public void Run(IAsyncFiber fiber) { using (fiber) { using IDisposable sub = _channel.Subscribe(fiber, AsyncHandler); _i = 0; for (int j = 0; j < OperationsPerInvoke; j++) { _channel.Publish(0); } WaitHandle.WaitAny(new WaitHandle[] { _wait }); } }
public static void TestPubSubSimple(IAsyncFiber fiber) { using (fiber) using (AutoResetEvent reset = new AutoResetEvent(false)) { Channel <string> channel = new Channel <string>(); channel.Subscribe(fiber, obj => { reset.Set(); return(Task.CompletedTask); }); channel.Publish("hello"); Assert.IsTrue(reset.WaitOne(5000, false)); } }
/// <summary> /// Subscribe an AsyncFiber to an Action based event /// </summary> /// <param name="fiber"></param> /// <param name="obj"></param> /// <param name="eventName"></param> /// <param name="receive"></param> /// <returns></returns> public static IDisposable SubscribeToEvent(this IAsyncFiber fiber, object obj, string eventName, Func <Task> receive) { EventInfo evt = obj.GetType().GetEvent(eventName); MethodInfo add = evt.GetAddMethod(); MethodInfo remove = evt.GetRemoveMethod(); void Action() { fiber.Enqueue(receive); } object[] addHandlerArgs = { (Action)Action }; add.Invoke(obj, addHandlerArgs); return(new Unsubscriber(new DisposeAction(() => remove.Invoke(obj, addHandlerArgs)), fiber)); }