C# ITimeProvider类代码示例

        public void Init(Func< bool > shouldPauseCb, ITimeProvider time, WeaponConfig config, Rect levelBounds, int shotDirection)
        {
            base.Init( shouldPauseCb, time, config, levelBounds );

            PrefabPoolManager.Prepare( ShotPrefabLink, 8);
            ShotDirection = shotDirection;
        }

 public BrowserExecutionContextCreator(IBrowserStepExecutionStrategyFactory stepExecutionStrategyFactory,
     IWebDriverFactory webDriverFactory, ITimeProvider timeProvider)
 {
     _stepExecutionStrategyFactory = stepExecutionStrategyFactory;
     _webDriverFactory = webDriverFactory;
     _timeProvider = timeProvider;
 }

 public virtual void Init(Func<bool> shouldPauseCb, ITimeProvider time, WeaponConfig config, Rect levelBounds)
 {
     base.Init( shouldPauseCb, time);
     Config = config;
     LevelBounds = levelBounds;
     ShotFiredTimeStamp = Time.Time;
 }

 public SecureCookieProvider(ITimeProvider timeProvider)
 {
     string key = ConfigurationManager.AppSettings.Get("CookieKey");
     string salt = ConfigurationManager.AppSettings.Get("CookieSalt");
     crypto = CryptoFactory.Rijndael(key, salt);
     this.timeProvider = timeProvider;
 }

        public static bool EvalDailyTrigger(this IDailyScheduledTask task, ITimeProvider timeProvider)
        {
            if (task.RepeatIntervalInDays <= 0 || ((Int32)(timeProvider.Time.Date - task.StartTime.Date).TotalDays % task.RepeatIntervalInDays != 0))
                return false;

            return TimeHelpers.AreTimesEqualToTheSecond(timeProvider.Time, task.StartTime);
        }

 public static IReaderStrategy Create(
     ISourceDefinitionConfigurator sources, ITimeProvider timeProvider, IPrincipal runAs)
 {
     var builder = new Builder();
     sources.ConfigureSourceProcessingStrategy(builder);
     return builder.Build(timeProvider, runAs);
 }

        public MainWindow(ITimeProvider provider)
        {

            LogTimeCommand = new DelegateCommand( ActionLogTime );
            _provider = provider;
            DataContext = this;

            Directory.CreateDirectory( "Work" );

            var doc = XDocument.Load( "config.xml" );
            _breakElements = doc.XPathSelectElements("//Break").ToList();

         
            var catList = doc.XPathSelectElements("//Category").Select(e => e.Value).ToList();
            Cats = new ObservableCollection< string >(catList);
            
#if DEBUG

            for ( var i = 0; i < 10; ++i )
            {
                Cats.Add( "Project "+i );
            }
#endif



            InitializeComponent();


            _dumpBreaks();


            list.IsEnabled = false;


            // Disable updater for now, fake time
           /* {
                startTime.Text = "8:00";
                _doNotUpdate = true;
            }*/

            //_doNotUpdate = false;
            _updater = Task.Run( () =>
            {

                while ( true )
                {
                    if ( DoNotUpdate == false )
                    {
                        startTime.Dispatcher.Invoke( () => startTime.Text = DateTime.Now.ToString( "HH:mm:ss" ) );
                    }
                    //startTime.Dispatcher.Invoke(() =>  startTime.Text = SystemClock.Instance.Now.ToString("HH:mm", null));
                   


                    Thread.Sleep( 1000 );
                }
            } ).ContinueWith( ErrorFunc );

        }

        public SystemInformationProvider(ITimeProvider timeProvider, IMachineNameProvider machineNameProvider, ISystemPerformanceDataProvider systemPerformanceDataProvider, IHttpStatusCodeCheckResultProvider httpStatusCodeCheckResultProvider)
        {
            if (timeProvider == null)
            {
                throw new ArgumentNullException("timeProvider");
            }

            if (machineNameProvider == null)
            {
                throw new ArgumentNullException("machineNameProvider");
            }

            if (systemPerformanceDataProvider == null)
            {
                throw new ArgumentNullException("systemPerformanceDataProvider");
            }

            if (httpStatusCodeCheckResultProvider == null)
            {
                throw new ArgumentNullException("httpStatusCodeCheckResultProvider");
            }

            this.timeProvider = timeProvider;
            this.machineNameProvider = machineNameProvider;
            this.systemPerformanceDataProvider = systemPerformanceDataProvider;
            this.httpStatusCodeCheckResultProvider = httpStatusCodeCheckResultProvider;
        }

        protected ReaderSubscriptionBase(
            IPublisher publisher,
            Guid subscriptionId,
            CheckpointTag @from,
            IReaderStrategy readerStrategy,
            ITimeProvider timeProvider,
            long? checkpointUnhandledBytesThreshold,
            int? checkpointProcessedEventsThreshold,
            bool stopOnEof,
            int? stopAfterNEvents)
        {
            if (publisher == null) throw new ArgumentNullException("publisher");
            if (readerStrategy == null) throw new ArgumentNullException("readerStrategy");
            if (timeProvider == null) throw new ArgumentNullException("timeProvider");
            if (checkpointProcessedEventsThreshold > 0 && stopAfterNEvents > 0)
                throw new ArgumentException("checkpointProcessedEventsThreshold > 0 && stopAfterNEvents > 0");

            _publisher = publisher;
            _readerStrategy = readerStrategy;
            _timeProvider = timeProvider;
            _checkpointUnhandledBytesThreshold = checkpointUnhandledBytesThreshold;
            _checkpointProcessedEventsThreshold = checkpointProcessedEventsThreshold;
            _stopOnEof = stopOnEof;
            _stopAfterNEvents = stopAfterNEvents;
            _subscriptionId = subscriptionId;
            _lastPassedOrCheckpointedEventPosition = null;

            _eventFilter = readerStrategy.EventFilter;

            _positionTagger = readerStrategy.PositionTagger;
            _positionTracker = new PositionTracker(_positionTagger);
            _positionTracker.UpdateByCheckpointTagInitial(@from);
        }

 protected CommandCreator(IOutputManager outputManager, ITimeProvider timeProvider, IMessagesRepository messagesRepository, IFollowingRepository followingRepository)
 {
     OutputManager = outputManager;
     TimeProvider = timeProvider;
     MessagesRepository = messagesRepository;
     FollowingRepository = followingRepository;
 }

 public static bool EvalWeeklyTrigger(this IWeeklyScheduledTask task, ITimeProvider timeProvider)
 {
     if (task.RepeatIntervalInWeeks <= 0 || (((Int32)(timeProvider.Time.Date - task.StartTime.Date).TotalDays / 7) % task.RepeatIntervalInWeeks != 0)) return false;
     var dayOfWeek = (int)timeProvider.Time.DayOfWeek;
     var daysOfWeek = (DaysOfWeek)(1 << dayOfWeek);
     return task.DaysOfWeekToActivate.HasFlag(daysOfWeek) && TimeHelpers.AreTimesEqualToTheSecond(timeProvider.Time, task.StartTime);
 }

 public void CalculateStoreOmittedOrPartlyCompletedShotPoints(DrillingDepartmentId id, ITimeProvider provider)
 {
     // Check if this was previously done
     // Store the data
     // TODO - SHOULD THIS BE VISUALISED
     // Issue OmittedOrPartlyCompletedShotPointsStored event
 }

        public void AddPlannedWorkgroup(DrillingDepartmentId id, RequestId requestId, WorkgroupEntity we, ITimeProvider provider)
        {
            // Create the Planned Workgroup
            DoWork("Create a Planned Workgroup and add to the Drilling Department Structure");

            RecordAndRealizeThat(new PlannedWorkgroupAddedToDepartment(id, requestId, we, provider.GetUtcNow()));
        }

        public override sealed IProjectionProcessingPhase[] CreateProcessingPhases(
            IPublisher publisher, Guid projectionCorrelationId, PartitionStateCache partitionStateCache,
            Action updateStatistics, CoreProjection coreProjection, ProjectionNamesBuilder namingBuilder,
            ITimeProvider timeProvider, IODispatcher ioDispatcher,
            CoreProjectionCheckpointWriter coreProjectionCheckpointWriter)
        {
            var definesFold = _sourceDefinition.DefinesFold;

            var readerStrategy = CreateReaderStrategy(timeProvider);

            var zeroCheckpointTag = readerStrategy.PositionTagger.MakeZeroCheckpointTag();

            var checkpointManager = CreateCheckpointManager(
                projectionCorrelationId, publisher, ioDispatcher, namingBuilder, coreProjectionCheckpointWriter,
                definesFold, readerStrategy);


            var resultWriter = CreateFirstPhaseResultWriter(
                checkpointManager as IEmittedEventWriter, zeroCheckpointTag, namingBuilder);

            var firstPhase = CreateFirstProcessingPhase(
                publisher, projectionCorrelationId, partitionStateCache, updateStatistics, coreProjection,
                _subscriptionDispatcher, zeroCheckpointTag, checkpointManager, readerStrategy, resultWriter);

            return CreateProjectionProcessingPhases(
                publisher, projectionCorrelationId, namingBuilder, partitionStateCache, coreProjection, ioDispatcher,
                firstPhase);
        }

        public void setup()
        {
            _checkpointUnhandledBytesThreshold = 1000;
            _checkpointProcessedEventsThreshold = 2000;
            Given();
            _bus = new InMemoryBus("bus");
            _timeProvider = new RealTimeProvider();
            _projectionCorrelationId = Guid.NewGuid();
            _eventHandler = new TestHandler<EventReaderSubscriptionMessage.CommittedEventReceived>();
            _checkpointHandler = new TestHandler<EventReaderSubscriptionMessage.CheckpointSuggested>();
            _progressHandler = new TestHandler<EventReaderSubscriptionMessage.ProgressChanged>();
            _subscriptionStartedHandler = new TestHandler<EventReaderSubscriptionMessage.SubscriptionStarted>();
            _notAuthorizedHandler = new TestHandler<EventReaderSubscriptionMessage.NotAuthorized>();
            _eofHandler = new TestHandler<EventReaderSubscriptionMessage.EofReached>();
            _partitionEofHandler = new TestHandler<EventReaderSubscriptionMessage.PartitionEofReached>();
            _partitionMeasuredHandler = new TestHandler<EventReaderSubscriptionMessage.PartitionMeasured>();
            _partitionDeletedHandler = new TestHandler<EventReaderSubscriptionMessage.PartitionDeleted>();

            _bus.Subscribe(_eventHandler);
            _bus.Subscribe(_checkpointHandler);
            _bus.Subscribe(_progressHandler);
            _bus.Subscribe(_eofHandler);
            _bus.Subscribe(_partitionEofHandler);
            _bus.Subscribe(_partitionMeasuredHandler);
            _readerStrategy = CreateCheckpointStrategy();
            _subscription = CreateProjectionSubscription();


            When();
        }