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));
}
