////////////////////////////////////////////////////////////////////////// /// <summary> /// Sends event synchronously /// </summary> public void SendEvent(IEventDispatcher dispatcher) { using (dispatcher) { dispatcher.Dispatch(); } }
public void UnPack(Client client, Packet packet, IEventDispatcher eventDispatcher) { string name = packet.Reader.ReadString(); string modeltype = packet.Reader.ReadString(); eventDispatcher.ThrowNewEvent(EventID, new PlayerBasicsDatas(name, modeltype, client)); }
public RuntimeEntity(int uniqueId, ITemplate template, IEventDispatcher eventDispatcher) : this(uniqueId, eventDispatcher, "") { foreach (DataAccessor accessor in template.SelectData()) { Data.IData data = template.Current(accessor); AddData_unlocked(accessor, data.Duplicate()); } }
/*============================================================================*/ /* Public Functions */ /*============================================================================*/ public void MapListener(IEventDispatcher dispatcher, Enum type, Delegate listener, Type eventClass = null) { if (eventClass == null) { eventClass = typeof(Event); } List<EventMapConfig> currentListeners = _suspended ? _suspendedListeners : _listeners; EventMapConfig config; int i = currentListeners.Count; while (i-- > 0) { config = currentListeners [i]; if (config.Equals (dispatcher, type, listener, eventClass)) return; } Delegate callback = eventClass == typeof(Event) ? listener : (Action<IEvent>)delegate(IEvent evt){ RouteEventToListener(evt, listener, eventClass); }; config = new EventMapConfig (dispatcher, type, listener, eventClass, callback); currentListeners.Add (config); if (!_suspended) { dispatcher.AddEventListener (type, callback); } }
static LogManager() { _configuration = PulsusConfiguration.Default; _eventsFactory = new DefaultEventFactory(); _eventDispatcher = new DefaultEventDispatcher(_configuration); _jsonSerializer = new JsonNetSerializer(); }
/*============================================================================*/ /* Constructor */ /*============================================================================*/ public ModuleConnectionConfigurator( IEventDispatcher localDispatcher, IEventDispatcher channelDispatcher) { _localToChannelRelay = new EventRelay(localDispatcher, channelDispatcher).Start(); _channelToLocalRelay = new EventRelay(channelDispatcher, localDispatcher).Start(); }
public void RegisterAbility(NWCard parentCard, IEventDispatcher eventDispatcher, AbilityActivatedDelegate activatedCallBack) { _parentCard = parentCard; if (Type == NWAbilityType.Triggered) { switch (Trigger.Type) { case NWTriggerType.DrawCard: { break; } case NWTriggerType.EnterZone: { eventDispatcher.OnCardChangeZone += CardChangeZoneHandler; break; } case NWTriggerType.StartOfTurn: { break; } case NWTriggerType.None: default: { break; } } OnActivateAbility += activatedCallBack; } }
public void UnmapListener(IEventDispatcher dispatcher, Enum type, Delegate listener, Type eventClass = null) { if (eventClass == null) { eventClass = typeof(Event); } List<EventMapConfig> currentListeners = _suspended ? _suspendedListeners : _listeners; EventMapConfig config; int i = currentListeners.Count; while (i-- > 0) { config = currentListeners [i]; if (config.Equals (dispatcher, type, listener, eventClass)) { if (!_suspended) { dispatcher.RemoveEventListener (type, config.callback); } currentListeners.RemoveAt (i); return; } } }
public static void AddListener(int type, IEventListener listener, IEventDispatcher source = null) { if (!listeners.ContainsKey(type)) listeners.Add(type, new List<ListenerData>()); listeners[type].Add(new ListenerData(listener, source)); }
public void UnPack(Client client, Packet packet, IEventDispatcher eventDispatcher) { byte id = packet.Reader.ReadByte(); float x = packet.Reader.ReadSingle(), y = packet.Reader.ReadSingle(), d= packet.Reader.ReadSingle(); eventDispatcher.ThrowNewEvent(EventID, new GiveImpulseDatas {ID = id, X = x, Y = y, Damages = d}); }
public bool Init(IEventDispatcher disp) { _disp = disp; //给创建完成Timer事件注册一个方法 _window.EventCreateTimer += WindowOnEventCreateTimer; return true; }
public void UnPack(Client client, Packet packet, IEventDispatcher eventDispatcher) { byte id = packet.Reader.ReadByte(), anim = packet.Reader.ReadByte(), lives = packet.Reader.ReadByte(); float x = packet.Reader.ReadSingle(), y = packet.Reader.ReadSingle(), yaw = packet.Reader.ReadSingle(), damages = packet.Reader.ReadSingle(); eventDispatcher.ThrowNewEvent(EventID, new CharacterPositionDatas { ID = id, X = x, Y = y, Yaw = yaw, Anim = anim, Lives = lives, Damages = damages}); }
/// <summary> /// Init constructor. /// </summary> public RecordedBayeuxDataSource(IEventDispatcher eventDispatcher, string url, string contentType, bool allowUpdateToken) : base(eventDispatcher, url, contentType) { Token = DefaultToken; ClientID = "0xDEADBEEF"; AllowUpdateTokenOnRequest = allowUpdateToken; }
public void before() { context = new Context(); dispatcher = new EventDispatcher(); subject = new LifecycleEventRelay(context, dispatcher); reportedTypes = new List<object>(); }
public Event(string type, bool bubbles = false) { this.Type = type; this._isBubbles = bubbles; target = null; currentTarget = null; }
public void UnPack(Client client, Packet packet, IEventDispatcher eventDispatcher) { string ip = client.ToString().Split(':')[0]; ushort port = packet.Reader.ReadUInt16(); eventDispatcher.ThrowNewEvent(EventID, new MasterServerDatas {IP = ip, Port = port}); }
/*============================================================================*/ /* Constructor */ /*============================================================================*/ /** * @private */ public ModuleConnector(IContext context) { IInjector injector= context.injector; _rootInjector = GetRootInjector(injector); _localDispatcher = injector.GetInstance(typeof(IEventDispatcher)) as IEventDispatcher; context.WhenDestroying(Destroy); }
public EventProcessor(IEventStoreConnectionFactory eventStoreConnectionFactory, IEventDispatcher eventDispatcher, IMongoDbEventPositionRepository mongoDbEventPositionRepository, ILog logService) { this.eventStoreConnectionFactory = eventStoreConnectionFactory; this.eventDispatcher = eventDispatcher; this.mongoDbEventPositionRepository = mongoDbEventPositionRepository; this.logService = logService; }
/*============================================================================*/ /* Constructor */ /*============================================================================*/ public EventMapConfig (IEventDispatcher dispatcher, Enum type, Delegate listener, Type eventClass, Delegate callback) { _dispatcher = dispatcher; _type = type; _eventClass = eventClass; _listener = listener; _callback = callback; }
/*============================================================================*/ /* Constructor */ /*============================================================================*/ public EventCommandTrigger (IInjector injector, IEventDispatcher dispatcher, Enum type, Type eventClass = null, IEnumerable<CommandMappingList.Processor> processors = null, ILogger logger = null) { _dispatcher = dispatcher; _type = type; _eventClass = eventClass; _mappings = new CommandMappingList(this, processors, logger); _executor = new CommandExecutor(injector, _mappings.RemoveMapping); }
//--------------------------------------------------------------------- // Constructor //--------------------------------------------------------------------- /** * Creates a new <code>CommandMap</code> object * * @param eventDispatcher The <code>IEventDispatcher</code> to listen to * @param injector An <code>IInjector</code> to use for this context * @param reflector An <code>IReflector</code> to use for this context */ public CommandMap( IEventDispatcher eventDispatcher, IInjector injector, IReflector reflector ) { this.eventDispatcher = eventDispatcher; this.injector = injector; this.reflector = reflector; this.eventTypeMap = new Dictionary<string,Dictionary<Type, Dictionary<Type, Action<Event>>>>(); this.verifiedCommandClasses = new Dictionary<Type,bool>(); }
public PrnGenerationIntegration() { userContext = A.Fake<IUserContext>(); A.CallTo(() => userContext.UserId).Returns(Guid.NewGuid()); eventDispatcher = A.Fake<IEventDispatcher>(); }
/*============================================================================*/ /* Constructor */ /*============================================================================*/ public ContextViewBasedExistenceWatcher(IContext context, object contextView, IEventDispatcher modularityDispatcher, IParentFinder parentFinder) { _logger = context.GetLogger(this); _context = context; _contextView = contextView; _parentFinder = parentFinder; _modularityDispatcher = modularityDispatcher; _context.WhenDestroying(Destroy); }
public void before() { reportedExecutions = new List<object>(); IContext context = new Context(); injector = context.injector; injector.Map(typeof(Action<object>), "ReportingFunction").ToValue((Action<object>)reportingFunction); dispatcher = new EventDispatcher(); subject = new EventCommandMap(context, dispatcher); }
public CommandDispatcher( ICommandHandler[] handlers, Func<IEnumerable<ICommandHandler>> pluginHandlerFactory, IEventDispatcher eventDispatcher) { _handlers = handlers; _pluginHandlerFactory = pluginHandlerFactory; _eventDispatcher = eventDispatcher; }
public void SetUp() { dataLayerMock = MockRepository.StrictMock<IDataLayer>(); settingsStub = MockRepository.Stub<ISettings>(); eventDispatcherMock = MockRepository.StrictMock<IEventDispatcher>(); viewMock = MockRepository.StrictMock<IOptionsPageView>(); loggerFactoryMock = MockRepository.DynamicMock<ILoggerFactory>(); loggerFactoryMock.Stub(x => x.GetLogger(null)).IgnoreArguments().Return(MockRepository.Stub<ILogger>()); controller = new OptionsPageController(loggerFactoryMock, dataLayerMock, settingsStub, eventDispatcherMock); }
public WasteRecoveryIntegration() { var userContext = A.Fake<IUserContext>(); A.CallTo(() => userContext.UserId).Returns(Guid.NewGuid()); eventDispatcher = A.Fake<IEventDispatcher>(); context = new IwsContext(userContext, eventDispatcher); }
public static void RemoveListener(int type, IEventListener listener, IEventDispatcher source = null) { if (listeners.ContainsKey(type)) foreach (var l in listeners[type].FindAll(x => ReferenceEquals(x.Listener, listener))) if ((l.DSource == null && source == null) || ReferenceEquals(l.DSource, source)) listeners[type].Remove(l); if (listeners[type].Count == 0) listeners.Remove(type); }
public void Parse(Client client, Packet.Packet packet, IEventDispatcher eventDispatcher) { if (!_packets.ContainsKey(packet.Header.ID)) { if (PacketNotFound != null) PacketNotFound.BeginInvoke(packet, null, null); } else _packets[packet.Header.ID].UnPack(client, packet, eventDispatcher); }
public void RunBeforeEachTest() { eventDispatcher = new EventDispatcher(); injector = new UnityInjector(); reflector = new UnityReflector(); commandMap = new CommandMap( eventDispatcher, injector, reflector ); //TODO Use the Unity lifetimemanager here injector.MapValue( typeof(ICommandTest), this ); }
public RuntimeEntityService(IEventDispatcher eventDispatcher, ILogger logger, [CanBeNull] IEntityTemplateProvider templateProvider = null, [CanBeNull] ICollection <EngineEntity> entities = null) { _eventDispatcher = eventDispatcher; _logger = logger; TemplateProvider = templateProvider; if (entities != null) { foreach (var entity in entities) { _entityList.Add(entity); _entityLookup.Add(entity.Id, entity); } } _idProvider = new UniqueIdProvider(_entityList.Count > 0 ? _entityList.Max(p => p.Id + 1) : 0); }
public CommandProcessor( IEventStore eventStore, IAggregateRootRepository aggregateRootRepository, IEventDispatcher eventDispatcher, IDomainEventSerializer domainEventSerializer, ICommandMapper commandMapper, IDomainTypeNameMapper domainTypeNameMapper, Options options) { if (eventStore == null) { throw new ArgumentNullException("eventStore"); } if (aggregateRootRepository == null) { throw new ArgumentNullException("aggregateRootRepository"); } if (eventDispatcher == null) { throw new ArgumentNullException("eventDispatcher"); } if (domainEventSerializer == null) { throw new ArgumentNullException("domainEventSerializer"); } if (commandMapper == null) { throw new ArgumentNullException("commandMapper"); } if (domainTypeNameMapper == null) { throw new ArgumentNullException("domainTypeNameMapper"); } if (options == null) { throw new ArgumentNullException("options"); } _eventStore = eventStore; _aggregateRootRepository = aggregateRootRepository; _eventDispatcher = eventDispatcher; _domainEventSerializer = domainEventSerializer; _commandMapper = commandMapper; _domainTypeNameMapper = domainTypeNameMapper; _options = options; }
public PowerLogEventStream( IConfigurationSource configurationSource, IPowerLogEventParser powerLogEventParser, IEventDispatcher viewEventDispatcher, bool seekEndWhenFileChanges) { _configurationSource = configurationSource.Require(nameof(configurationSource)); _powerLogEventParser = powerLogEventParser.Require(nameof(powerLogEventParser)); _viewEventDispatcher = viewEventDispatcher.Require(nameof(viewEventDispatcher)); _seekEndWhenFileChanges = seekEndWhenFileChanges; _filePath = _configurationSource.GetSettings().PowerLogFilePath; _eventHandlers.Add( new DelegateEventHandler <ViewEvents.ConfigurationSettingsSaved>( __event => { string newFilePath = _configurationSource.GetSettings().PowerLogFilePath; if (!newFilePath.Eq(_filePath)) { Task.Run( () => { lock (_lock) { _remainingText = null; _streamPosition = 0L; _filePath = newFilePath; if (_seekEndWhenFileChanges) { SeekEnd_(); } } }); } })); _eventHandlers.ForEach(__eventHandler => _viewEventDispatcher.RegisterHandler(__eventHandler)); }
/** * @private */ internal void _init( ArmatureData armatureData, SkinData skinData, object display, IArmatureProxy proxy, IEventDispatcher <EventObject> eventManager ) { if (_armatureData != null) { return; } _armatureData = armatureData; _skinData = skinData; _animation = BaseObject.BorrowObject <Animation>(); _display = display; _proxy = proxy; _eventManager = eventManager; _animation._init(this); _animation.animations = _armatureData.animations; }
public WaitEvent(IEventDispatcher dispatcher, string EventType, object thisObj, string callName, object[] paramList = null, bool checkSame = true) { if (checkSame) { for (int i = 0; i < list.Count; i++) { if (list[i].dispatcher == dispatcher && list[i].EventType == EventType && list[i].thisObj == thisObj && list[i].callName == callName) { return; } } } this.dispatcher = dispatcher; this.EventType = EventType; this.thisObj = thisObj; this.callName = callName; this.paramList = paramList; dispatcher.AddListener(EventType, OnListenerBack); list.Add(this); }
public GarbageCollectionSegmentRunner( IContext context, IParameterProvider parameterProvider, IOperationExecutive operationExecutive, IGateway <TEntity> gateway, ISafeRepository safeRepository, IEventDispatcher <TEntity> eventDispatcher, IInitializer initializer) { this.context = context; this.parameterProvider = parameterProvider; this.operationExecutive = operationExecutive; this.gateway = gateway; this.safeRepository = safeRepository; this.eventDispatcher = eventDispatcher; this.idsOfEntitiesToDelete = null; initializer.Register( new Initializer(this), suppressEvents: true); }
/// Returns true if the provided observer is already registered public static bool HasListenerStrangeEvent(object evt, EventCallback callback) { if (strangeDispatcher == null && instance != null && instance.context != null) { if ((instance.context as MainContextInput).dispatcher != null) { strangeDispatcher = (instance.context as MainContextInput).dispatcher; } } if (strangeDispatcher != null) { return(strangeDispatcher.HasListener(evt, callback)); } else { Debug.LogError("strangeDispatcher Not Redy"); } return(false); }
/** * @private */ override protected Armature _generateArmature(BuildArmaturePackage dataPackage) { if (Application.isPlaying) { if (_gameObject == null) { _gameObject = new GameObject("DragonBones Object", typeof(ClockHandler)); _gameObject.isStatic = true; _gameObject.hideFlags = HideFlags.HideInHierarchy; } if (_eventManager == null) { _eventManager = _gameObject.AddComponent <UnityArmatureComponent>(); } } var armature = BaseObject.BorrowObject <Armature>(); var armatureDisplayContainer = _armatureGameObject == null ? new GameObject(dataPackage.armature.name) : _armatureGameObject; var armatureComponent = armatureDisplayContainer.GetComponent <UnityArmatureComponent>(); if (armatureComponent == null) { armatureComponent = armatureDisplayContainer.AddComponent <UnityArmatureComponent>(); } armatureComponent._armature = armature; armature._armatureData = dataPackage.armature; armature._skinData = dataPackage.skin; armature._animation = BaseObject.BorrowObject <Animation>(); armature._display = armatureDisplayContainer; armature._eventDispatcher = armatureComponent; armature._eventManager = _eventManager; armature._animation._armature = armature; armature.animation.animations = dataPackage.armature.animations; _armatureGameObject = null; return(armature); }
public void SetupBase() { _plantProviderMock = new Mock <IPlantProvider>(); _plantProviderMock.SetupGet(x => x.Plant).Returns(TestPlant); _plantProvider = _plantProviderMock.Object; _personApiServiceMock = new Mock <IPersonApiService>(); _personApiService = _personApiServiceMock.Object; var currentUserProviderMock = new Mock <ICurrentUserProvider>(); currentUserProviderMock.Setup(x => x.GetCurrentUserOid()).Returns(_currentUserOid); _currentUserProvider = currentUserProviderMock.Object; var eventDispatcher = new Mock <IEventDispatcher>(); _eventDispatcher = eventDispatcher.Object; var permissionCacheMock = new Mock <IPermissionCache>(); _permissionCache = permissionCacheMock.Object; _timeProvider = new ManualTimeProvider(new DateTime(2020, 2, 1, 0, 0, 0, DateTimeKind.Utc)); TimeService.SetProvider(_timeProvider); _dbContextOptions = new DbContextOptionsBuilder <IPOContext>() .UseInMemoryDatabase(Guid.NewGuid().ToString()) .Options; // ensure current user exists in db using (var context = new IPOContext(_dbContextOptions, _plantProvider, _eventDispatcher, _currentUserProvider)) { if (context.Persons.SingleOrDefault(p => p.Oid == _currentUserOid) == null) { var person = AddPerson(context, _currentUserOid, "Ole", "Lukkøye", "ol", "*****@*****.**"); AddSavedFiltersToPerson(context, person); } } SetupNewDatabase(_dbContextOptions); }
private void RedispatchKeyEvent(IEventDispatcher targetComponent, ICloneable systemManagerKeyEvent) { _keyEvent = (KeyboardEvent)systemManagerKeyEvent.Clone(); _keyEvent.Target = targetComponent; /** * 1) Dispatch from here * */ DispatchEvent(_keyEvent); // the event might be canceled if (_keyEvent.Canceled) { return; } /** * 2) Dispatch from the component * */ targetComponent.DispatchEvent(_keyEvent); }
protected async Task FinishProduction(IEventDispatcher eventDispatcher) { var productionFinished = false; eventDispatcher.RegisterHandler <ProductionFinishedEvent>(async e => { productionFinished = true; await Task.Delay(0); }); await Task.Run(async() => { while (true) { if (productionFinished) { break; } await Task.Delay(200); } }); }
protected async Task HeatOven(IEventDispatcher eventDispatcher) { bool isOvenHeated = false; eventDispatcher.RegisterHandler <OvenHeatedEvent>(async e => { isOvenHeated = true; await Task.Delay(0); }); await Task.Run(async() => { while (true) { if (isOvenHeated) { break; } await Task.Delay(200); } }); }
public void SetUp() { matchTileGridModel = Substitute.For <IMatchTileGridModel>(); eventDispatcher = Substitute.For <IEventDispatcher> (); matchTileTouchedCommand = new MatchTileTouchedCommand(); matchTileTouchedCommand.matchTileGridModel = matchTileGridModel; matchTileTouchedCommand.eventDispatcher = eventDispatcher; GameObject gameObject = new GameObject(); gameObject.transform.localPosition = Vector3.zero; TouchedObject touchedObject = new TouchedObject(); touchedObject.objectHit = gameObject; matchTileTouchedCommand.touchedObject = touchedObject; eventDispatcher.CleanAndDestroy(); }
public void InjectDependencies( int heroInstanceId, ITurnHandler turnHandler, IEventDispatcher eventDispatcher, IGameActionsExecutioner gameActionsExecutioner) { InitializeHeroEntity(heroInstanceId); _turnHandler = turnHandler; _heroSelector.InjectDependencies( _hero, turnHandler, _heroActionController, eventDispatcher ); _heroActionController.InjectDependencies(_hero, gameActionsExecutioner); _heroMovementController.InjectDependencies(_hero); _guiView.InjectDependencies(_hero, HeroHealth); _heroHealthController.InjectDependencies(_hero, HeroHealth); _heroAttackController.InjectDependencies(_hero); _heroAbilityController.InjectDependencies(_hero); }
public TransitionCommitter( ICommunicationModelProvider communicationModelProvider, IPlatformHttpClientProvider platformHttpClientProvider, IRoutineCompletionSink routineCompletionSink, IEventDispatcher eventDispatcher, IRoutineMethodResolver routineMethodResolver, IDomainServiceProvider domainServiceProvider, IMethodInvokerFactory methodInvokerFactory, IEnumerable <IRoutineTransitionAction> transitionActions, ITransitionUserContext transitionUserContext) { _communicationModelProvider = communicationModelProvider; _platformHttpClientProvider = platformHttpClientProvider; _routineCompletionSink = routineCompletionSink; _eventDispatcher = eventDispatcher; _routineMethodResolver = routineMethodResolver; _domainServiceProvider = domainServiceProvider; _methodInvokerFactory = methodInvokerFactory; _transitionActions = transitionActions; _transitionUserContext = transitionUserContext; }
/// <summary> /// Binds the lifetime of the pool to the <see cref="eventDispatcher" />. /// </summary> /// <param name="self"></param> /// <param name="eventDispatcher"></param> /// <returns></returns> /// <exception cref="ArgumentNullException"></exception> public static AddressablesPool BindTo(this AddressablesPool self, IEventDispatcher eventDispatcher) { if (eventDispatcher == null) { self.Dispose(); throw new ArgumentNullException(nameof(eventDispatcher)); } void OnDispatch() { if (!self.IsDisposed) { self.Dispose(); } eventDispatcher.OnDispatch -= OnDispatch; } eventDispatcher.OnDispatch += OnDispatch; return(self); }
public SavedLogViewModel( IConfigurationSource configurationSource, IPowerLogManager powerLogManager, IEventDispatcher viewEventDispatcher, Guid id, string title, DateTimeOffset timestamp, string filePath) { configurationSource.Require(nameof(configurationSource)); _powerLogManager = powerLogManager.Require(nameof(powerLogManager)); _viewEventDispatcher = viewEventDispatcher.Require(nameof(viewEventDispatcher)); ID = id; Title = title ?? string.Empty; Timestamp = timestamp; _filePath = filePath; _textEditorFilePath = configurationSource.GetSettings().TextEditorFilePath; }
public Singleton( DiContainer container, GameStateMachine <JameStateType> gsMachine, SessionFlags pSessionFlags, [Inject(Id = GameInstaller.GLOBAL_DISPATCHER)] IEventDispatcher eventDispatcher, GameConfig pGameConfig, NetworkManager pNetworkManager, GuiManager guiManager) { diContainer = container; sessionFlags = pSessionFlags; gameConfig = pGameConfig; gameStateMachine = gsMachine; notificationDispatcher = eventDispatcher; networkManager = pNetworkManager; gui = guiManager; _initialize(); _instance = this; }
public LocalDatabaseCardInfoProvider( ICardDatabase cardDatabase, IEventDispatcher eventDispatcher) { _cardDatabase = cardDatabase.Require(nameof(cardDatabase)); _eventDispatcher = eventDispatcher.Require(nameof(eventDispatcher)); LoadCards(); _eventDispatcher.RegisterHandler( new DelegateEventHandler <ViewEvents.CardDatabaseUpdated>( __ => LoadCards())); void LoadCards() { IEnumerable <Models.Data.Card> cardInfos = _cardDatabase.GetCards().Result; _cardByDatabaseID = cardInfos.ToDictionary(__cardInfo => __cardInfo.dbfId); _cardByID = cardInfos.ToDictionary(__cardInfo => __cardInfo.id); } }
/// <summary> /// Initializes a new instance of the <see cref="EventDispatcher" /> class. /// </summary> /// <param name="eventDispatcher">The event dispatcher.</param> /// <param name="eventStore">The event store.</param> /// <param name="notificationService">The notification service.</param> /// <param name="dispatcherId">The dispatcher identifier.</param> /// <param name="batchSize">Size of the batch.</param> public EventDispatcher( IEventDispatcher eventDispatcher, IEventStore eventStore, INotificationService notificationService, Guid dispatcherId, int batchSize) { Guard.Against.Null(() => eventDispatcher); Guard.Against.Null(() => eventStore); Guard.Against.Null(() => notificationService); this.eventDispatcher = eventDispatcher; this.eventStore = eventStore; this.notificationService = notificationService; this.dispatcherId = dispatcherId; this.batchSize = batchSize; this.timer = new Timer(this.OnTimeout, null, Timeout.Infinite, Timeout.Infinite); this.Start(); }
public TS3QueryClient(EventDispatchType dispatcher) { status = QueryClientStatus.Disconnected; tcpClient = new TcpClient(); isInQueue = false; switch (dispatcher) { case EventDispatchType.None: EventDispatcher = new NoEventDispatcher(); break; case EventDispatchType.CurrentThread: EventDispatcher = new CurrentThreadEventDisptcher(); break; case EventDispatchType.DoubleThread: EventDispatcher = new DoubleThreadEventDispatcher(); break; case EventDispatchType.AutoThreadPooled: throw new NotSupportedException(); //break; case EventDispatchType.NewThreadEach: throw new NotSupportedException(); //break; default: throw new NotSupportedException(); } }
/** * @private */ override protected Armature _generateArmature(BuildArmaturePackage dataPackage) { if (Application.isPlaying) // { if (_gameObject == null) { _gameObject = new GameObject("DragonBones Object", typeof(ClockHandler)); _gameObject.isStatic = true; _gameObject.hideFlags = HideFlags.HideInHierarchy; } if (_eventManager == null) { _eventManager = _gameObject.AddComponent <UnityArmatureComponent>(); (_eventManager as UnityArmatureComponent).isUGUI = _isUGUI; } } var armature = BaseObject.BorrowObject <Armature>(); var armatureDisplay = _armatureGameObject == null ? new GameObject(dataPackage.armature.name) : _armatureGameObject; var armatureComponent = armatureDisplay.GetComponent <UnityArmatureComponent>(); if (armatureComponent == null) { armatureComponent = armatureDisplay.AddComponent <UnityArmatureComponent>(); armatureComponent.isUGUI = _isUGUI; } armatureComponent._armature = armature; armature._init( dataPackage.armature, dataPackage.skin, armatureDisplay, armatureComponent, _eventManager ); _armatureGameObject = null; return(armature); }
void IPlayerDeckTrackerInterface.TrackDeck( Models.Client.Decklist decklist) { Reset(); IEventDispatcher eventDispatcher = _eventDispatcherFactory.Create(); _viewModel = new PlayerDeckTrackerViewModel( _cardInfoProvider, _configurationSource, eventDispatcher, _viewEventDispatcher, decklist); _cancellation = new CancellationTokenSource(); Task.Run( async() => { using (IEventStream eventStream = _eventStreamFactory.Create()) { while (true) { object @event = await eventStream.ReadNext(_cancellation.Token); if (@event == null) { return; } eventDispatcher.DispatchEvent(@event); } } }); _view = new PlayerDeckTrackerView(_viewModel); _view.Show(); }
/// <summary> /// Registers the event publisher. /// </summary> /// <param name="model">The model.</param> private void RegisterEventPublisher(ComponentModel model) { EventInfo[] events = model.Service.GetEvents(); foreach (EventInfo e in events) { object[] attrs = e.GetCustomAttributes(typeof(EventPublisherAttribute), true); if (attrs.Length > 0) { EventPublisherAttribute publisherAttr = (EventPublisherAttribute)attrs[0]; IEventDispatcher dispatcher = Kernel[typeof(IEventDispatcher)] as IEventDispatcher; if (dispatcher != null) { dispatcher.RegisterEventPublisher( publisherAttr.Topic, publisherAttr.Description, publisherAttr.EventScope, e); } } } }
/// <summary> /// Initializes a new instance of the <see cref="DownloaderFile"/> class. /// </summary> public DownloaderFile( IIO io, Config config, ITransport transport, IEventDispatcher eventDispatcher = null, ICache cache = null, IFileSystem fileSystem = null) { this.io = io; this.config = config; this.transport = transport; this.eventDispatcher = eventDispatcher; this.cache = cache; this.fileSystem = fileSystem ?? new FileSystemLocal(); if (CacheFileSystem.GCIsNecessary(cache)) { cache.GC(config.Get(Settings.CacheFilesTTL), config.Get(Settings.CacheFilesMaxSize)); } lastCacheWrites = new Dictionary <string, string>(); }
/// <summary> /// Binds the lifetime of the instance to the <see cref="eventDispatcher" />. /// </summary> /// <param name="self"></param> /// <param name="eventDispatcher"></param> /// <returns></returns> /// <exception cref="ArgumentNullException"></exception> public static PooledObjectOperation <GameObject> BindTo(this PooledObjectOperation <GameObject> self, IEventDispatcher eventDispatcher) { if (eventDispatcher == null) { self.Dispose(); throw new ArgumentNullException(nameof(eventDispatcher)); } void OnDispatch() { if (!self.IsDisposed) { self.Dispose(); } eventDispatcher.OnDispatch -= OnDispatch; } eventDispatcher.OnDispatch += OnDispatch; return(self); }
public ApiClient(IOptions <ApiClientConfiguration> configuration, TokenContainer token, HttpClient http, CommandMapper commandMapper, QueryMapper queryMapper, IExceptionHandler exceptionHandler, IEventDispatcher eventDispatcher, Interop interop) { Ensure.NotNull(configuration, "configuration"); Ensure.NotNull(token, "token"); Ensure.NotNull(http, "http"); Ensure.NotNull(commandMapper, "commandMapper"); Ensure.NotNull(queryMapper, "queryMapper"); Ensure.NotNull(exceptionHandler, "exceptionHandler"); Ensure.NotNull(eventDispatcher, "eventDispatcher"); Ensure.NotNull(interop, "interop"); this.configuration = configuration.Value; this.token = token; this.http = http; this.commandMapper = commandMapper; this.queryMapper = queryMapper; this.exceptionHandler = exceptionHandler; this.eventDispatcher = eventDispatcher; this.interop = interop; http.BaseAddress = this.configuration.ApiUrl; EnsureAuthorization(); }
/// <summary> /// Set the container on the view model and resolve the basic dependencies /// </summary> public static void SetContainer(IContainer container) { _container = container; if (_container.IsRegistered <IGlobalVariablesService>()) { _globalVariables = _container.Resolve <IGlobalVariablesService>(); } if (_container.IsRegistered <ILogger>()) { _logger = _container.Resolve <ILogger>(); } if (_container.IsRegistered <IViewModelsManager>()) { _vmManager = _container.Resolve <IViewModelsManager>(); } if (_container.IsRegistered <ILocalizationManager>()) { _localization = _container.Resolve <ILocalizationManager>(); } if (_container.IsRegistered <IObjectMapper>()) { _mapper = _container.Resolve <IObjectMapper>(); } if (_container.IsRegistered <IEventDispatcher>()) { _eventDispatcher = _container.Resolve <IEventDispatcher>(); } if (_container.IsRegistered <IRepositoryManager>()) { _repositoryManager = _container.Resolve <IRepositoryManager>(); } }
public void Ctor() { this._dispatcher = new EventDispatcher(); this._dispatcher.Subscribe(new ActionEventHandler <ProjectEvent, ProjectCreatedEventArgument>( e => { Assert.IsNotNull(e.Subject.Project); ++this._counter; })); this._dispatcher.Subscribe(new Action <ProjectRemovedEventArgument>( e => { Assert.IsNotNull(e.Subject.Project); ++this._counter; })); this._dispatcher.Subscribe(new LowPriorityEventHandler()); this._dispatcher.Subscribe(new HightPriorityEventHandler()); }
public bool dispatchEvent(EventX e) { bool bubbles = e.bubbles; if (!bubbles && (mEventListeners == null || mEventListeners.ContainsKey(e.type) == false)) { return(false); } IEventDispatcher previousTarget = e.target; e.setTarget(mTarget); bool b = invokeEvent(e); if (previousTarget != null) { e.setTarget(previousTarget); } return(b); }