public ArrayRenderer GetArrayRenderer(string template, object[] args) { if (_renderers.TryGetValue(template, out var renderer)) { return((ArrayRenderer)renderer); } var arguments = BuildArguments(template); var argumentTypes = new LocalList <Type>(args.Length); foreach (var arg in args) { argumentTypes.Add(arg.GetType()); } var messageRenderer = new DefaultStringFormatter(template); renderer = new ArrayRenderer(arguments, messageRenderer, argumentTypes, _converters); using (Lock.Enter(_lock)) { _renderers[template] = renderer; } return((ArrayRenderer)renderer); }
public IEnumerator <double> GetEnumerator() { using (Lock.Enter()) { return((Queue?.ToArray().AsEnumerable() ?? Enumerable.Empty <double>()).GetEnumerator()); } }
public ImmutableArray <T> Clear() { using (Lock.Enter()) { DistinctSet.Clear(); return(DistinctInOrderArrayStorage = ImmutableArray <T> .Empty); } }
public Task EnqueueAsync(TItem item) { using (Lock.Enter()) { ItemsQueue.Enqueue(item); return(LockedInsertUpdateAsync()); } }
public void LockEnter() { var lockStruct = Lock.Enter(_lock); Assert.True(Monitor.IsEntered(_lock)); lockStruct.Dispose(); Assert.False(Monitor.IsEntered(_lock)); }
private int?SetThrottleLevelLimiter(int?throttleLevel = null) { using (Lock.Enter()) { ThrottleLevelLimiter = throttleLevel <= 0 ? null : throttleLevel; LockedUpdateEnqueueAccess(); return(ThrottleLevelLimiter); } }
public void LockUsing() { using (Lock.Enter(_lock)) { Assert.True(Monitor.IsEntered(_lock)); } Assert.False(Monitor.IsEntered(_lock)); }
public void AddGroup <TActor>(IActorGroup <TActor> actorGroup) where TActor : Actor { var typeId = Typeof <TActor> .Id; using (Lock.Enter(_groups)) { _groups.Add(typeId, actorGroup); } }
public void AddFilter <TComponent>(IActorFilter <TComponent> actorFilter) where TComponent : IComponent { var filterId = Typeof <IActorFilter <TComponent> > .Id; using (Lock.Enter(_filters)) { _filters.Add(filterId, actorFilter); } }
public ImmutableArray <T> Remove(T item) { using (Lock.Enter()) { return(DistinctSet.Remove(item) ? DistinctInOrderArrayStorage = DistinctInOrderArrayStorage.Remove(item) : DistinctInOrderArrayStorage ); } }
public void Write(LogContext context, JsonObject message) { using (Lock.Enter(_lock)) { context.WriteMessage(message, _output); _output.WriteLine(); _output.Flush(); } }
public ISequencerExceptionRegister TryReThrowException() { using (Lock.Enter()) { if (TryGetExceptionLocked() == null) { return(this); } throw AggregateException; } }
public static void RegisterPerfCounterFactory(IPerfCounterFactoryUC factory) { if (factory == null) { throw new ArgumentNullException(nameof(factory)); } using (Lock.Enter()) { Factories[factory.PerfCounterType] = factory; } }
public ConcurrencyLevelEntry TryEnter() { using (Lock.Enter()) { if (ConcurrencyLevelValue >= MaxConcurrencyLevel) { return(ConcurrencyLevelEntry.NoEntry); } ++ConcurrencyLevelValue; return(new ConcurrencyLevelEntry(ActionOnExit)); } }
public Task RegisterAsync(Action asyncCallback) { if (asyncCallback == null) { throw new ArgumentNullException(nameof(asyncCallback)); } CallBackRequest request = new CallBackRequest(asyncCallback, TickGeneratorRequest.Add); if (Status == TickGeneratorStatus.Disposed) { return(request.TrySetDisposed().Task); } if (Status == TickGeneratorStatus.Disposing) { return(request.TrySetCanceled().Task); } using (Lock.Enter()) { NullSafeSequencer.PointArg(SeqPointTypeUC.Notify, TickGeneratorSequencer.RegisterStatus, Status); NullSafeSequencer.PointArg(SeqPointTypeUC.Notify, TickGeneratorSequencer.RegisterActiveProcessing, ActiveProcessing); if (Status == TickGeneratorStatus.Disposed) { return(request.TrySetDisposed().Task); } if (Status == TickGeneratorStatus.Disposing) { return(request.TrySetCanceled().Task); } Requests.Enqueue(request); if (ActiveProcessing) { return(request.Task); } } if (Processing(processActions: false) == ProcessingResult.Processed) { return(request.Task); } using (Lock.Enter()) { NullSafeSequencer.PointArg(SeqPointTypeUC.Notify, TickGeneratorSequencer.RegisterEnd, Status); if (Status == TickGeneratorStatus.Disposed) { return(request.TrySetDisposed().Task); } TryUpdateTimer(activate: true); return(request.Task); } }
public void Enrich(LogLevel level, Type sender, JsonObject message) { if (!_senders.TryGetValue(sender, out var value)) { value = new JsonVerbose(ReflectionUtils.GetName(sender)); using (Lock.Enter(_lock)) { _senders[sender] = value; } } message.Add(Name, value); }
public Task EnqueuedItemsAsync() { using (Lock.Enter()) { if (ItemsQueue.Count > 0) { return(Task.CompletedTask); } var tcs = new TaskCompletionSource <object>(TaskCreationOptions.RunContinuationsAsynchronously); DequeueAccess.Enqueue(tcs); return(tcs.Task); } }
public override string ToString() { using (Lock.Enter()) { return ($"[ConcurrentQueueNotifier]" + $"[{nameof(ThrottleLevel)}:{ThrottleLevelLimiter?.ToString() ?? "none"}]" + $"[AwaitingEnqueues:{EnqueueAccess.Count}]" + $"[AwaitingDequeues:{DequeueAccess.Count}]" + $"[ItemsCount:{ItemsQueue.Count}]" ); } }
/// <summary> /// Use only with TryDequeue with same priority! /// </summary> public AsyncEnqueuedCompletionUC EnqueuedItemsAsync(TPrioritySelectorEnum prioritySelector) { using (Lock.Enter()) { if (HasItems(prioritySelector)) { return(AsyncEnqueuedCompletionUC.Completed); //AsyncEnqueuedCompletionUC.AlreadyAsyncEnqueued; } TaskCompletionSource <object> asyncEnqueued = new TaskCompletionSource <object>(TaskCreationOptions.RunContinuationsAsynchronously); NotifyPriority[prioritySelector].Enqueue(asyncEnqueued); return(new AsyncEnqueuedCompletionUC(asyncEnqueued.Task)); } }
/// <summary> /// Use only with TryDequeue without overridden priority! /// Awaitable returns completed as long as there are any items for any priority! /// </summary> public AsyncEnqueuedCompletionUC EnqueuedItemsAsync() { using (Lock.Enter()) { if (HasItems()) { return(AsyncEnqueuedCompletionUC.Completed); } TaskCompletionSource <object> asyncEnqueued = new TaskCompletionSource <object>(TaskCreationOptions.RunContinuationsAsynchronously); NotifyAnyPriority.Enqueue(asyncEnqueued); return(new AsyncEnqueuedCompletionUC(asyncEnqueued.Task)); } }
public static IPerfCounterUC CreatePerfCounter(this PerfCounterTypeUC perfCounterType, string processName = null, int?pid = null) { IPerfCounterFactoryUC factory; using (Lock.Enter()) { if (!Factories.TryGetValue(perfCounterType, out factory) || factory == null) { throw new ArgumentException($"{nameof(PerfCounterTypeUC)}.{perfCounterType} not registered!"); } } return(factory.NewPerfCounterUC(processName, pid)); }
public ISequencerExceptionRegister RegisterException(Exception exception) { if (exception == null) { return(this); } using (Lock.Enter()) { Exceptions.Enqueue(exception); AggregateException = new AggregateException(Exceptions); } TokenSource.Cancel(false); return(this); }
public bool TryDequeu(out TItem item) { using (Lock.Enter()) { if (ItemsQueue.Count <= 0) { item = default(TItem); return(false); } item = ItemsQueue.Dequeue(); LockedUpdateEnqueueAccess(); return(true); } }
public void Dispose() { using (Lock.Enter()) { StopWatch?.Stop(); PerfCounter?.Dispose(); Queue?.Clear(); Unique?.Clear(); StopWatch = null; PerfCounter = null; Queue = null; Unique = null; } }
public AsyncTimerProcessorResult <TArg> RegisterAsync <TArg>(TimeSpan delay) { TimerProcessorCallBackRequest request = TimerProcessorCallBackRequest.Add <TArg>(RealTimeSource.GetUtcNow(), delay); if (Status == TimerProcessorStatus.Disposed) { return(request.TrySetDisposed().GetAsyncResult <TArg>()); } if (Status == TimerProcessorStatus.Disposing) { return(request.TrySetCanceled().GetAsyncResult <TArg>()); } using (Lock.Enter()) { NullSafeSequencer.PointArg(SeqPointTypeUC.Notify, TimerProcessorSequencer.RegisterStatus, Status); NullSafeSequencer.PointArg(SeqPointTypeUC.Notify, TimerProcessorSequencer.RegisterActiveProcessing, ActiveProcessing); if (Status == TimerProcessorStatus.Disposed) { return(request.TrySetDisposed().GetAsyncResult <TArg>()); } if (Status == TimerProcessorStatus.Disposing) { return(request.TrySetCanceled().GetAsyncResult <TArg>()); } Requests.Enqueue(request); if (ActiveProcessing) { return(request.GetAsyncResult <TArg>()); } } if (Processing(processActions: false) == ProcessingResult.Processed) { return(request.GetAsyncResult <TArg>()); } using (Lock.Enter()) { NullSafeSequencer.PointArg(SeqPointTypeUC.Notify, TimerProcessorSequencer.RegisterEnd, Status); if (Status == TimerProcessorStatus.Disposed) { return(request.TrySetDisposed().GetAsyncResult <TArg>()); } TryUpdateTimer(activate: true); return(request.GetAsyncResult <TArg>()); } }
public void Write(LogContext context, JsonObject message) { using (Lock.Enter(_lock)) { var output = GetOutput(context.Level); Console.ForegroundColor = GetColor(context.Level); context.WriteMessage(message, output); output.WriteLine(); output.Flush(); Console.ResetColor(); } }
public static Type GetForCommand(Type commandType) { if (ResolvedTypes.TryGetValue(commandType, out var exists)) { return(exists); } var pipelineType = Command.MakeGenericType(commandType); using (Lock.Enter(ResolvedTypes)) { ResolvedTypes[commandType] = pipelineType; } return(pipelineType); }
public static Type GetForNotification(Type notificationType) { if (ResolvedTypes.TryGetValue(notificationType, out var exists)) { return(exists); } var pipelineType = Notification.MakeGenericType(notificationType); using (Lock.Enter(ResolvedTypes)) { ResolvedTypes[notificationType] = pipelineType; } return(pipelineType); }
public IJsonConverter Get(Type type) { if (_converters.TryGetValue(type, out var exists)) { return(exists); } var converter = Build(type); using (Lock.Enter(_lock)) { _converters[type] = converter; } return(converter); }
public static Type GetForQuery(Type queryType) { if (ResolvedTypes.TryGetValue(queryType, out var exists)) { return(exists); } var resultType = ReflectionUtils.GetGenericInterfaceParameters(queryType, QueryType)[0]; var pipelineType = Query.MakeGenericType(queryType, resultType); using (Lock.Enter(ResolvedTypes)) { ResolvedTypes[queryType] = pipelineType; } return(pipelineType); }