Пример #1
0
 public AsyncSemaphoreContainer(
     IAsyncContainer <M, R> container,
     string semaphoreName)
 {
     _container = container;
     _semaphore = PipeManager.GetSemaphore(semaphoreName);
 }
        protected void AddExecutor(
            bool defaultExecutor = false)
        {
            _currentExecutorSettings
            .ExecuteConditions = _conditionalQueueBuilder.GetFuncIfConditions();

            if (defaultExecutor)
            {
                _conditionalQueueBuilder.SetDefault(
                    _currentExecutorSettings,
                    _currentContainer);
            }
            else
            {
                _conditionalQueueBuilder.Enque(
                    _currentExecutorSettings,
                    _currentContainer);
            }

            if (_executeIf)
            {
                _conditionalQueueBuilder.RemoveIfCondition();
                _executeIf = false;
            }

            _skipCurrentExecutor     = false;
            _currentContainer        = null;
            _currentExecutorSettings = null;
        }
 public static ValueTask RunAsync <T>(this IAsyncContainer <T> container, Action <T> action)
 {
     return(container.RunAsync((t, action) =>
     {
         action(t);
         return new ValueTask <object?>(default(object));
     }, action).AsValueTask());
 }
 public static ValueTask RunAsync <T>(this IAsyncContainer <T> container, Func <T, ValueTask> action)
 {
     return(container.RunAsync(async(t, action) =>
     {
         await action(t);
         return default(object?);
     }, action).AsValueTask());
 }
        protected void StopWatch()
        {
            if (_skipCurrentExecutor)
            {
                return;
            }

            _currentContainer = new AsyncStopWatchContainer <M, R>(_currentContainer);
        }
 public AsyncReTryContainer(
     IAsyncContainer <M, R> container,
     int count,
     int timeOutMilliseconds)
 {
     _container           = container;
     _count               = count;
     _timeOutMilliseconds = timeOutMilliseconds;
 }
        protected void Retry(
            int count, int timeOutMilliseconds)
        {
            if (_skipCurrentExecutor)
            {
                return;
            }

            _currentContainer = new AsyncReTryContainer <M, R>(_currentContainer, count, timeOutMilliseconds);
        }
        protected void StopWatch(
            bool condition)
        {
            if (_skipCurrentExecutor || !condition)
            {
                return;
            }

            _currentContainer = new AsyncStopWatchContainer <M, R>(_currentContainer);
        }
 protected void SetExecutor(
     Func <M, IPipeCache, PipeResult <R> > executor,
     bool isDefault = false)
 {
     _skipCurrentExecutor     = false;
     _currentContainer        = new AsyncFuncCacheContainer <M, R>(executor);
     _currentExecutorSettings = isDefault
          ? new ExecutorSettings <M, R> {
         Label = "Default"
     }
          : new ExecutorSettings <M, R>();
 }
 protected void SetExecutor(
     Func <IAsyncExecutor <M, R> > executor,
     bool isDefault = false)
 {
     _skipCurrentExecutor     = false;
     _currentContainer        = new AsyncExecutorContainer <M, R>(executor);
     _currentExecutorSettings = isDefault
          ? new ExecutorSettings <M, R> {
         Label = "Default"
     }
          : new ExecutorSettings <M, R>();
 }
        protected void Restricted(
            int initialCount,
            string key)
        {
            if (_skipCurrentExecutor)
            {
                return;
            }

            PipeManager.SetSemaphore(initialCount, key);
            _currentContainer = new AsyncSemaphoreContainer <M, R>(_currentContainer, key);
        }
 public AsyncStopWatchContainer(IAsyncContainer <M, R> container)
 {
     _container = container;
 }
 public static ValueTask <TResult> RunAsync <T, TResult>(this IAsyncContainer <T> container, Func <T, TResult> func)
 {
     return(container.RunAsync((t, func) => new ValueTask <TResult>(func(t)), func));
 }
 public static ValueTask <TResult> RunAsync <T, TResult, TParam>(this IAsyncContainer <T> container, Func <T, TParam, ValueTask <TResult> > func, TParam param)
 {
     return(container.RunAsync(func, param));
 }