protected ConcurrentObservableBase(bool isMultithreaded, TInternalCollection initialCollection) { // If compiled as debug, then store the stack trace as an aid to working out which object this is in case of a binding error. // This is non performant, so only use this in debug builds. #if DEBUG // This function checks if the declaring class of a method in a stack frame inherits from the base type name passed in. // Was unable to use Type.IsSubClassOf() due to the type being derived by reflection. bool InheritsFrom(StackFrame stackFrame, string baseNameTest) { var testType = stackFrame.GetMethod().DeclaringType; while (testType != null) { if (testType.Name == baseNameTest) { return(true); } testType = testType.BaseType; } return(false); } // Get all the stack frames up to the point where this object was created. Omit the constructors for this object. StackTrace stackTrace = new StackTrace(true); var baseName = typeof(ConcurrentObservableBase <T, TInternalCollection>).Name;; _stackFrames = stackTrace.GetFrames().SkipWhile(frame => InheritsFrom(frame, baseName)).ToArray(); #endif _lock = isMultithreaded ? new ReaderWriterLockSlim() : null; _internalCollection = initialCollection; _viewChanged = new ThrottledAction(() => OnPropertyChanged(nameof(CollectionView), nameof(Count)), TimeSpan.FromMilliseconds(20)); }
public ListBoxDragDropHelper(ListBox listBox, Action <int, IEnumerable <TItem> > moveItemsAction, Func <DragEventArgs, IEnumerable> tryGetInsertItemsAction, Action <int, IEnumerable> insertItemsAction) { this.listBox = listBox; this.moveItemsAction = moveItemsAction; this.tryGetInsertItemsAction = tryGetInsertItemsAction ?? (eventArgs => null); this.insertItemsAction = insertItemsAction; insertMarkerAdorner = new InsertMarkerAdorner(listBox); throttledAutoScrollAction = new ThrottledAction(ThrottledAutoScroll, ThrottledActionMode.InvokeMaxEveryDelayTime, TimeSpan.FromMilliseconds(250)); listBox.Loaded += ListBoxLoaded; if (listBox.IsLoaded) { InitializeAdornerLayer(); } listBox.PreviewDragOver += ListBoxPreviewDragOver; listBox.Drop += ListBoxDrop; var listboxItemStyle = new Style(typeof(ListBoxItem), listBox.ItemContainerStyle); listboxItemStyle.Setters.Add(new EventSetter(UIElement.PreviewMouseLeftButtonDownEvent, (MouseButtonEventHandler)ListBoxItemPreviewMouseLeftButtonDown)); listboxItemStyle.Setters.Add(new EventSetter(UIElement.PreviewMouseMoveEvent, (MouseEventHandler)ListBoxItemPreviewMouseMove)); listboxItemStyle.Setters.Add(new EventSetter(UIElement.DragEnterEvent, (DragEventHandler)ListBoxItemDragEnter)); listboxItemStyle.Setters.Add(new EventSetter(UIElement.DragLeaveEvent, (DragEventHandler)ListBoxItemDragLeave)); listboxItemStyle.Setters.Add(new EventSetter(UIElement.DropEvent, (DragEventHandler)ListBoxItemDrop)); listBox.ItemContainerStyle = listboxItemStyle; }
public void ConstructorTest() { AssertHelper.ExpectedException <ArgumentNullException>(() => new ThrottledAction(null)); var throttledAction = new ThrottledAction(() => { }); Assert.IsFalse(throttledAction.IsRunning); }
public void InvokeOnlyIfIdleForDelayTimeWithoutSynchronizationContext() { Assert.IsNull(SynchronizationContext.Current); int actionCallCount = 0; var throttledAction = new ThrottledAction(() => Interlocked.Add(ref actionCallCount, 1), ThrottledActionMode.InvokeOnlyIfIdleForDelayTime, TimeSpan.FromMilliseconds(100)); Assert.IsFalse(throttledAction.IsRunning); throttledAction.InvokeAccumulated(); Assert.IsTrue(throttledAction.IsRunning); throttledAction.InvokeAccumulated(); throttledAction.InvokeAccumulated(); // Multiple calls of InvokeAccumulated within the delayTime should call the action just once. Task.Delay(200).Wait(); Assert.AreEqual(1, actionCallCount); Assert.IsFalse(throttledAction.IsRunning); actionCallCount = 0; throttledAction.InvokeAccumulated(); Task.Delay(60).Wait(); throttledAction.InvokeAccumulated(); Task.Delay(60).Wait(); throttledAction.InvokeAccumulated(); Task.Delay(60).Wait(); throttledAction.InvokeAccumulated(); // Calls just once: The waits between InvokeAccumulated are less than the idle (delay) time. Task.Delay(200).Wait(); Assert.AreEqual(1, actionCallCount); Assert.IsFalse(throttledAction.IsRunning); }
private void Awake() { serverState = new State(); clientState = new State(); networkedComponentTypeInfo = NetLib.GetNetworkedComponentTypeInfo(typeof(State)); sendUpdateAction = new ThrottledAction(SendUpdate, 0.25f); }
public void InvokeOnlyIfIdleForDelayTimePerformanceTest() { int actionCallCount = 0; var throttledAction = new ThrottledAction(() => Interlocked.Add(ref actionCallCount, 1), ThrottledActionMode.InvokeOnlyIfIdleForDelayTime, TimeSpan.FromMilliseconds(10)); for (int i = 0; i < 200000; i++) { throttledAction.InvokeAccumulated(); } Task.Delay(100).Wait(); Assert.AreEqual(1, actionCallCount); }
public void Start() { ClientPeer = new ClientPeer(); ClientPeer.OnConnectedToServer += InternalOnConnectedToServer; ClientPeer.OnDisconnectedFromServer += InternalOnDisconnectedFromServer; ClientPeer.ShouldApplyStateSnapshots = false; ClientPeer.Start(this, CreateGameObjectFromState); SendInputPeriodicFunction = new ThrottledAction(SendPlayerInput, SendPlayerInputInterval); Camera = Object.Instantiate(OsFps.Instance.CameraPrefab); CreateGui(); }
public WorkspaceController(IDocumentService documentService, Lazy <ShellViewModel> shellViewModel, Lazy <ErrorListViewModel> errorListViewModel, Lazy <OutputViewModel> outputViewModel, ScriptHost host) { taskScheduler = TaskScheduler.FromCurrentSynchronizationContext(); this.documentService = documentService; this.shellViewModel = shellViewModel; this.errorListViewModel = errorListViewModel; this.outputViewModel = outputViewModel; this.host = host; this.updateDiagnosticsAction = new ThrottledAction(UpdateDiagnostics, ThrottledActionMode.InvokeOnlyIfIdleForDelayTime, TimeSpan.FromSeconds(2)); this.outputTextWriter = new DelegateTextWriter(AppendOutputText); this.errorTextWriter = new DelegateTextWriter(AppendErrorText); this.startCommand = new DelegateCommand(StartScript, CanStartScript); this.stopCommand = new DelegateCommand(StopScript, CanStopScript); this.documentIds = new Dictionary <DocumentFile, DocumentId>(); }
public void InvokeMaxEveryDelayTimeTestWithoutSynchronizationContext() { Assert.IsNull(SynchronizationContext.Current); int actionCallCount = 0; var throttledAction = new ThrottledAction(() => Interlocked.Add(ref actionCallCount, 1), ThrottledActionMode.InvokeMaxEveryDelayTime, TimeSpan.FromMilliseconds(100)); Assert.IsFalse(throttledAction.IsRunning); throttledAction.InvokeAccumulated(); Assert.IsTrue(throttledAction.IsRunning); throttledAction.InvokeAccumulated(); throttledAction.InvokeAccumulated(); // Multiple calls of InvokeAccumulated within the delayTime should call the action just once. Task.Delay(200).Wait(); Assert.AreEqual(1, actionCallCount); Assert.IsFalse(throttledAction.IsRunning); actionCallCount = 0; throttledAction.InvokeAccumulated(); Task.Delay(10).Wait(); throttledAction.InvokeAccumulated(); Task.Delay(150).Wait(); throttledAction.InvokeAccumulated(); // Calls the action twice: First 2 InvokeAccumulated are within delayTime; Last is after delayTime. Task.Delay(200).Wait(); Assert.AreEqual(2, actionCallCount); Assert.IsFalse(throttledAction.IsRunning); actionCallCount = 0; throttledAction.InvokeAccumulated(); Task.Delay(10).Wait(); throttledAction.Cancel(); // Do not call the action because it is cancelled. Task.Delay(200).Wait(); Assert.AreEqual(0, actionCallCount); Assert.IsFalse(throttledAction.IsRunning); // Calling Cancel multiple time most not throw an exception throttledAction.Cancel(); throttledAction.Cancel(); }
public TranscodingController(IMessageService messageService, IShellService shellService, IMusicFileContext musicFileContext, ISelectionService selectionService, TranscodingService transcodingService, Lazy <ITranscoder> transcoder, Lazy <TranscodingListViewModel> transcodingListViewModel) { this.messageService = messageService; this.shellService = shellService; this.musicFileContext = musicFileContext; this.selectionService = selectionService; this.transcodingService = transcodingService; this.transcoder = transcoder; this.transcodingListViewModel = transcodingListViewModel; cancellationTokenSources = new Dictionary <TranscodeItem, CancellationTokenSource>(); convertToMp3AllCommand = new DelegateCommand(ConvertToMp3All, CanConvertToMp3All); convertToMp3SelectedCommand = new DelegateCommand(ConvertToMp3Selected, CanConvertToMp3Selected); cancelAllCommand = new DelegateCommand(CancelAll, CanCancelAll); cancelSelectedCommand = new DelegateCommand(CancelSelected, CanCancelSelected); throttler = new SemaphoreSlim(Environment.ProcessorCount); // Do not dispose the throttler; it is used after Shutdown to cancel the open tasks transcodingManager = new TranscodingManager(); throttledMusicFilesCollectionChangedAction = new ThrottledAction(ThrottledMusicFilesCollectionChanged, ThrottledActionMode.InvokeOnlyIfIdleForDelayTime, TimeSpan.FromMilliseconds(10)); }
public void Start( ushort?portNumber, int maxPlayerCount, object objectContainingRpcs, float sendGameStateInterval ) { ObjectContainingRpcs = objectContainingRpcs; ShouldSendStateSnapshots = true; sendGameStatePeriodicFunction = new ThrottledAction(SendGameState, sendGameStateInterval); this.maxPlayerCount = maxPlayerCount; var connectionConfig = NetLib.CreateConnectionConfig( out reliableSequencedChannelId, out reliableChannelId, out unreliableStateUpdateChannelId, out unreliableFragmentedChannelId, out unreliableChannelId ); var hostTopology = new HostTopology(connectionConfig, maxPlayerCount); Start(portNumber, hostTopology); }
public void InvokeMaxEveryDelayTimeTestWithSynchronizationContext() { using var context = UnitTestSynchronizationContext.Create(); int actionCallCount = 0; var throttledAction = new ThrottledAction(() => Interlocked.Add(ref actionCallCount, 1), ThrottledActionMode.InvokeMaxEveryDelayTime, TimeSpan.FromMilliseconds(100)); Assert.IsFalse(throttledAction.IsRunning); throttledAction.InvokeAccumulated(); Assert.IsTrue(throttledAction.IsRunning); throttledAction.InvokeAccumulated(); throttledAction.InvokeAccumulated(); // As long the unit test synchronization context is not executed the actionCallCount must not be increased. Task.Delay(200).Wait(); Assert.AreEqual(0, actionCallCount); // Execute the unit test synchronization context. context.WaitFor(() => actionCallCount > 0, TimeSpan.FromMilliseconds(200)); Assert.AreEqual(1, actionCallCount); Assert.IsFalse(throttledAction.IsRunning); }
public PlayerView(PlayerService playerService) { this.InitializeComponent(); this.viewModel = new Lazy <PlayerViewModel>(() => ViewHelper.GetViewModel <PlayerViewModel>(this)); this.playerService = playerService; this.mediaPlayer = new MediaPlayer(); this.duratonConverter = new Converters.DurationConverter(); updateTimer = new DispatcherTimer(); updateTimer.Interval = TimeSpan.FromMilliseconds(100); updateTimer.Tick += UpdateTimerTick; throttledSliderValueChangedAction = new ThrottledAction(ThrottledSliderValueChanged, ThrottledActionMode.InvokeMaxEveryDelayTime, TimeSpan.FromMilliseconds(100)); previousCommand = new DelegateCommand(Previous, CanPrevious); playPauseCommand = new DelegateCommand(PlayPause, CanPlayPause); nextCommand = new DelegateCommand(Next, CanNext); playerService.PreviousCommand = previousCommand; playerService.PlayPauseCommand = playPauseCommand; playerService.NextCommand = nextCommand; playerService.IsPlayCommand = true; Loaded += FirstTimeLoadedHandler; }
public FeedViewModel(IFeedView view) : base(view, false) { updateSearchAction = new ThrottledAction(UpdateSearch); UpdateItemsListView(); }
protected ConcurrentObservableBase(bool isMultithreaded, TInternalCollection initialCollection) { _lock = isMultithreaded ? new ReaderWriterLockSlim() : null; _internalCollection = initialCollection; _viewChanged = new ThrottledAction(() => OnPropertyChanged(nameof(CollectionView), nameof(Count)), TimeSpan.FromMilliseconds(20)); }