/// <summary> /// Creates an observable for smart card events. /// </summary> /// <param name="factory">Factory to use for <see cref="ISCardMonitor"/> creation.</param> /// <param name="scope">Scope of the establishment. This can either be a local or remote connection.</param> /// <param name="readerNames">Name of the smart card reader that shall be monitored.</param> /// <param name="scheduler">The scheduler to run the add and remove event handler logic on.</param> /// <returns></returns> public static IObservable <MonitorEvent> CreateObservable(this IMonitorFactory factory, SCardScope scope, IEnumerable <string> readerNames, IScheduler scheduler = null) { if (factory == null) { throw new ArgumentNullException(nameof(factory)); } if (readerNames == null) { throw new ArgumentNullException(nameof(readerNames)); } return(Observable.Create <MonitorEvent>(obs => { var monitor = factory.Create(scope); var useScheduler = scheduler ?? Scheduler.ForCurrentContext(); var readers = readerNames .Where(name => !string.IsNullOrWhiteSpace(name)) .ToArray(); var subscription = monitor .ObserveEvents(useScheduler) .Subscribe(obs); monitor.Start(readers); return new CompositeDisposable(subscription, monitor); })); }
public WordTransformerWithMonitorUnderTest( ITransformationTraversalWithMonitor traversal, ITransformationNodeFactory nodeFactory, IWordModulator wordModulator, IMonitorFactory monitorFactory) : base(traversal, nodeFactory, wordModulator, monitorFactory) { }
public ThreadWrangler(IDataActions dataActions, IApplicationSettings applicationSettings, IMonitorFactory monitorFactory, IMonitorJobActions monitorJobActions) { _dataActions = dataActions; _applicationSettings = applicationSettings; _monitorFactory = monitorFactory; _monitorJobActions = monitorJobActions; _manualResetEvent = new ManualResetEvent(false); _theServiceShouldContinue = true; }
public void SetUp() { _fakeMonitorFactory = Substitute.For <IMonitorFactory>(); _fakeFileMonitor = Substitute.For <IFileMonitor>(); _fakeMonitorFactory.CreateFileMonitor().Returns(_fakeFileMonitor); _fakeProjectionFolderCreator = Substitute.For <IProjectionFolderCreator>(); _fakeProjectionPipelineFactory = Substitute.For <IProjectionPipelineFactory>(); _uut = new SubfolderController(_fakeProjectionFolderCreator, _fakeMonitorFactory, _fakeProjectionPipelineFactory); }
public ProductsMonitorService(IDateTimeNow dateTimeNow) { _dateTimeNow = dateTimeNow; _modelPortfolioRepository = new ModelPortfolioRepository(); _behaviourFactory = new BehaviourFactory(); _productRepository = new ProductRepository(_modelPortfolioRepository, _behaviourFactory, _dateTimeNow); _rebalancerHandler = new RebalanceHandler(_behaviourFactory); _payoutHandler = new PayoutHandler(_behaviourFactory); _monitorFactory = new MonitorFactory(_dateTimeNow, _rebalancerHandler, _payoutHandler); _monitorHandler = new MonitorHandler(_monitorFactory); }
public static IServiceEndpoint <TMessage, TCommand, TEvent, TRequest, TResponse> CreateMonitoringProxy <TMessage, TCommand, TEvent, TRequest, TResponse>( this IServiceEndpoint <TMessage, TCommand, TEvent, TRequest, TResponse> endpoint, IMonitorFactory <TMessage> monitorFactory) where TMessage : class where TCommand : TMessage where TEvent : TMessage where TRequest : TMessage where TResponse : TMessage { return(new ServiceEndpointMonitoringProxy <TMessage, TCommand, TEvent, TRequest, TResponse>(endpoint, monitorFactory)); }
/// <summary> /// Creates an observable for smart card events. /// </summary> /// <param name="factory">Factory to use for <see cref="ISCardMonitor"/> creation.</param> /// <param name="scope">Scope of the establishment. This can either be a local or remote connection.</param> /// <param name="readerName">Name of the smart card reader that shall be monitored.</param> /// <param name="scheduler">The scheduler to run the add and remove event handler logic on.</param> /// <returns></returns> public static IObservable <MonitorEvent> CreateObservable(this IMonitorFactory factory, SCardScope scope, string readerName, IScheduler scheduler = null) { if (factory == null) { throw new ArgumentNullException(nameof(factory)); } if (readerName == null) { throw new ArgumentNullException(nameof(readerName)); } return(factory.CreateObservable(scope, new[] { readerName }, scheduler)); }
public void SetUp() { _fakeFolderMonitor = Substitute.For <IMonitor>(); _fakeMonitorFactory = Substitute.For <IMonitorFactory>(); _fakeSubfolderController = Substitute.For <ISubfolderController>(); _fakeMonitorFactory.CreateFolderMonitor().Returns(_fakeFolderMonitor); var configuration = CreateDefaultConfiguration(); _paths = configuration.Paths; Configuration.ConfigurationManager.OverrideConfiguration(configuration, false); _uut = new BaseFolderController(_fakeMonitorFactory, _fakeSubfolderController); }
public WordTransformerWithMonitor( ITransformationTraversalWithMonitor traversal, ITransformationNodeFactory nodeFactory, IWordModulator wordModulator, IMonitorFactory monitorFactory) : base(traversal, nodeFactory, wordModulator) { if (monitorFactory == null) { throw new ArgumentNullException(nameof(monitorFactory)); } this.generatedWordsCounter = monitorFactory.OpenPerformanceCounter("New Words per Word"); this.processedNodesCounter = monitorFactory.OpenPerformanceCounter("New Words per Word - Base"); }
public WordDictionaryWithMonitor(IWordDictionary core, IMonitorFactory monitorFactory) { if (core == null) { throw new ArgumentNullException(nameof(core)); } if (monitorFactory == null) { throw new ArgumentNullException(nameof(monitorFactory)); } this.core = core; this.wordTestCount = monitorFactory.OpenPerformanceCounter("Word Hit Ratio - Base"); this.wordHitCount = monitorFactory.OpenPerformanceCounter("Word Hit Ratio"); }
private void SubscribeToReaderEvents(IMonitorFactory monitorFactory, IReadOnlyCollection <string> readerNames) { _subscription?.Dispose(); if (readerNames.Count <= 0) { return; } _subscription = monitorFactory .CreateObservable(SCardScope.System, readerNames) .Do(ev => EventHistory.AddOnScheduler(ev)) // Always add elements using the UI scheduler! .Subscribe( onNext: _ => { }, onError: OnError); }
public TransformationTraversalWithMonitor(ITransformationTraversal core, IMonitorFactory monitorFactory) { if (core == null) { throw new ArgumentNullException(nameof(core)); } if (monitorFactory == null) { throw new ArgumentNullException(nameof(monitorFactory)); } this.core = core; this.backlogCount = monitorFactory.OpenPerformanceCounter("Traversal Backlog"); this.rateOfEmbark = monitorFactory.OpenPerformanceCounter("Traversal Embark per Second"); this.rateOfDisembark = monitorFactory.OpenPerformanceCounter("Traversal Disembark per Second"); }
void LoadAppSettings() { try { _applicationSettings = new ApplicationSettings(); _dataActions = new DataActions(_applicationSettings); _timeActions = new TimeActions(); _emailActions = new EmailActions(_applicationSettings); _monitorJobActions = new MonitorJobActions(_timeActions, _applicationSettings); _monitorFactory = new MonitorFactory(_emailActions, _timeActions); } catch (Exception ex) { Log.ErrorFormat("monitoryService was unable to create all the startup objects it needs to run. The exception was '{0}'", ex); throw; } }
public MainWindowViewModel(IContextFactory contextFactory, IMonitorFactory monitorFactory) { Readers = new ReactiveCollection <string>().AddTo(_disposables); EventHistory = new ReactiveCollection <MonitorEvent>().AddTo(_disposables); RefreshReaderListCommand = new ReactiveCommand().AddTo(_disposables); ClearEventListCommand = new ReactiveCommand().AddTo(_disposables); RefreshReaderListCommand .Select(_ => GetReaderNames(contextFactory)) .Do(UpdateReaderList) .Do(readerNames => SubscribeToReaderEvents(monitorFactory, readerNames)) .Subscribe() .AddTo(_disposables); ClearEventListCommand .Do(_ => EventHistory.ClearOnScheduler()) .Subscribe() .AddTo(_disposables); }
public void Run() { Console.Write("what product information is required(LED, LCD, CRT) : "); string product = Console.ReadLine(); IMonitorFactory factory = null; IMonitor inputs = null; if (product == "LED") { var fact = (IFactory <ILEDFactory>)_services.GetService(typeof(IFactory <ILEDFactory>)); inputs = new LEDMonitor(10000, "1968X1360"); factory = fact.Create(); } else if (product == "LCD") { var fact = (IFactory <ILCDFactory>)_services.GetService(typeof(IFactory <ILCDFactory>)); inputs = new LCDMonitor(9000, "1688X1180"); factory = fact.Create(); } else if (product == "CRT") { var fact = (IFactory <ICRTFactory>)_services.GetService(typeof(IFactory <ICRTFactory>)); inputs = new CRTMonitor(9000, "1688X1180"); factory = fact.Create(); } else { Console.Write("Invalid Input !!!"); Console.ReadKey(); return; } IMonitor typeofMonitor = factory.GetMonitor(inputs); Console.WriteLine(typeofMonitor.ToString()); Console.ReadKey(); }
/// <summary> /// Creates an observable for smart card events. /// </summary> /// <param name="factory">Factory to use for <see cref="ISCardMonitor"/> creation.</param> /// <param name="scope">Scope of the establishment. This can either be a local or remote connection.</param> /// <param name="readerNames">Name of the smart card reader that shall be monitored.</param> /// <param name="scheduler">The scheduler to run the add and remove event handler logic on.</param> /// <returns></returns> public static IObservable <MonitorEvent> CreateObservable(this IMonitorFactory factory, SCardScope scope, IEnumerable <string> readerNames, IScheduler scheduler = null) { if (factory == null) { throw new ArgumentNullException(nameof(factory)); } if (readerNames == null) { throw new ArgumentNullException(nameof(readerNames)); } var useScheduler = scheduler ?? Scheduler.ForCurrentContext(); IObservable <MonitorEvent> events = null; var monitor = factory.Start( scope, readerNames, preStartMonitor => events = preStartMonitor.ObserveEvents(useScheduler) ); return(Observable.Using(() => monitor, _ => events)); }
public static void Main() { Console.WriteLine("Listen device attached/detached events. Press any key to stop."); // var deviceMonitor = DeviceMonitor var factory = DeviceMonitorFactory.Instance; monitorFactory = MonitorFactory.Instance; var subscriptionDev = factory .CreateObservable(SCardScope.System) .Select(GetEventAsPrintableText) .Do(Console.WriteLine) .Subscribe( onNext: _ => { }, onError: OnError); Console.WriteLine("Press any key to exit."); Console.ReadKey(); subscriptionDev.Dispose(); }
public MonitorHandler(IMonitorFactory monitorFactory) { _monitorFactory = monitorFactory; }
public ServiceEndpointClientMonitoringProxy(IServiceEndpointClient <TMessage, TCommand, TEvent, TRequest, TResponse> endpointClient, IMonitorFactory <TMessage> monitorFactory) { if (endpointClient == null) { throw new NullReferenceException("endpointClient cannot be null"); } if (monitorFactory == null) { throw new NullReferenceException("monitorFactory cannot be null"); } _endpointClient = endpointClient; _monitor = monitorFactory.Create(endpointClient.Name); }
public ICanSpecifyLoggingOrCreate <TMessage, TCommand, TEvent, TRequest, TResponse> UsingMonitor(IMonitorFactory <TMessage> monitorFactory) { _monitorFactory = monitorFactory; return(this); }
public Item(string description, Dictionary <string, string> settings, IMonitorFactory factory) { Description = description; Settings = settings; Factory = factory; }
public void SetUp() { _timeActions = MockRepository.GenerateStub <ITimeActions>(); _emailActions = MockRepository.GenerateStub <IEmailActions>(); _monitorFactory = new MonitorFactory(_emailActions, _timeActions); }
public BaseFolderController(IMonitorFactory monitorFactory, ISubfolderController subfolderController) { _subfolderController = subfolderController; _folderMonitor = monitorFactory.CreateFolderMonitor(); _folderMonitor.Created += HandleNewFolder; }
public SubfolderController(IProjectionFolderCreator projectionFolderCreator, IMonitorFactory monitorFactory, IProjectionPipelineFactory projectionPipelineFactory) { _projectionFolderCreator = projectionFolderCreator; _monitorFactory = monitorFactory; _projectionPipelineFactory = projectionPipelineFactory; }
public MeasurableUnitOfWork(IEnumerable<IDbContextManager> contextList, IMonitorFactory monitorFactory) : base(contextList) { this.monitorFactory = monitorFactory; }
public MeasurableUnitOfWork(IEnumerable <IDbContextManager> contextList, IMonitorFactory monitorFactory) : base(contextList) { this.monitorFactory = monitorFactory; }
// some external code would call this for each plugin that is found and // either loaded dynamically at runtime or a static list at compile time public void Add(Guid id, string description, Dictionary <string, string> settings, IMonitorFactory factory) { _list.Add(id, new Item(description, settings, factory)); factory.RegisterContainerAndTypes(_container); }
public ICanSpecifyLoggingOrCreate <TMessage, TCommand, TEvent, TRequest, TResponse> UsingConsoleMonitor(TimeSpan period, IScheduler scheduler = null) { _monitorFactory = new ConsoleTimerMonitorFactory <TMessage>(period, scheduler ?? Scheduler.Default); return(this); }
public MonitorService(ILog log, IRepository repository, IMonitorFactory monitorFactory) { _log = log.ThrowIfNull(nameof(log)); _repository = repository.ThrowIfNull(nameof(repository)); _monitorFactory = monitorFactory.ThrowIfNull(nameof(monitorFactory)); }