public Task HandleEventSucceededAsync( ISubscribe subscriberTo, IDomainEvent domainEvent, CancellationToken cancellationToken) { return(Tasks.Completed); }
public SmsController( ISubscribe subscribe, IUnsubscribe unsubscribe) { _subscribe = subscribe; _unsubscribe = unsubscribe; }
public static Awaiter GetAwaiter(this ISubscribe s) { var d1 = React.Scope(out var scope); var aw = new Awaiter(scope, d1.Dispose); s.Subscribe(d1.Dispose, scope); return(aw); }
public void MakeProxy(string EndpoindAddress, object callbackinstance) { NetTcpBinding netTcpbinding = new NetTcpBinding(SecurityMode.None); EndpointAddress endpointAddress = new EndpointAddress(EndpoindAddress); InstanceContext context = new InstanceContext(callbackinstance); DuplexChannelFactory<ISubscribe> channelFactory = new DuplexChannelFactory<ISubscribe>(new InstanceContext(this), netTcpbinding, endpointAddress); _proxy = channelFactory.CreateChannel(); }
public static void Subscribe(ISubscribe subscriber) { if (IsSubscribing(subscriber)) { return; } _subscribers.Add(subscriber); }
public static void UnSubscribe(ISubscribe subscriber) { if (!IsSubscribing(subscriber)) { return; } _subscribers.Remove(subscriber); }
public Task HandleEventFailedAsync( ISubscribe subscriberTo, IDomainEvent domainEvent, Exception exception, bool swallowException, CancellationToken cancellationToken) { return(Tasks.Completed); }
public void MakeProxy(string EndpoindAddress, object callbackinstance) { NetTcpBinding netTcpbinding = new NetTcpBinding(SecurityMode.None); EndpointAddress endpointAddress = new EndpointAddress(EndpoindAddress); InstanceContext context = new InstanceContext(callbackinstance); DuplexChannelFactory <ISubscribe> channelFactory = new DuplexChannelFactory <ISubscribe>(new InstanceContext(this), netTcpbinding, endpointAddress); _proxy = channelFactory.CreateChannel(); }
public IPublisher RemoveSubscriber(ISubscribe subscriber) { if (!subscribers.Contains(subscriber)) { return(this); } subscribers.Remove(subscriber); return(this); }
private async Task DispatchToSubscriberAsync( IDomainEvent domainEvent, ISubscribe subscriber, SubscriberInformation subscriberInformation, bool swallowException, CancellationToken cancellationToken) { _log.Verbose(() => $"Calling HandleAsync on handler '{subscriber.GetType().PrettyPrint()}' " + $"for aggregate event '{domainEvent.EventType.PrettyPrint()}'"); await _dispatchToSubscriberResilienceStrategy.BeforeHandleEventAsync( subscriber, domainEvent, cancellationToken) .ConfigureAwait(false); try { await subscriberInformation.HandleMethod( subscriber, domainEvent, cancellationToken) .ConfigureAwait(false); await _dispatchToSubscriberResilienceStrategy.HandleEventSucceededAsync( subscriber, domainEvent, cancellationToken) .ConfigureAwait(false); } catch (Exception e) when(swallowException) { _log.Error(e, $"Subscriber '{subscriberInformation.SubscriberType.PrettyPrint()}' threw " + $"'{e.GetType().PrettyPrint()}' while handling '{domainEvent.EventType.PrettyPrint()}': {e.Message}"); await _dispatchToSubscriberResilienceStrategy.HandleEventFailedAsync( subscriber, domainEvent, e, true, cancellationToken) .ConfigureAwait(false); } catch (Exception e) when(!swallowException) { await _dispatchToSubscriberResilienceStrategy.HandleEventFailedAsync( subscriber, domainEvent, e, false, cancellationToken) .ConfigureAwait(false); throw; } }
public static void Run() { ISubscribe <ExampleMessage> queue = Configuration.GetQueue <ExampleMessage>(); while (true) { Reset.WaitOne(); ExampleMessage message = queue.Receive(); Interlocked.Increment(ref _readCount); } }
public async Task InitConfigAsync() { var services = await ble.GetGattServicesForUuidAsync(model.ConfigServiceID); //TODO: check status service = services.Services[0]; //LedStateConfig ledStateConfigSource = new DataSource <LEDStateConfig>(service, model.LEDStateConfigID); ledStateConfigSource.BeforeSubscribe += () => current?.Unsubscribe(); ledStateConfigSource.AfterUnsubscribe += () => current = ledStateConfigSource; }
public void Subscribe <T>(ISubscribe <T> Subscriber) where T : class { if (SubscriberStore.TryGetValue(typeof(T), out var subScribers)) { subScribers.Add(new WeakReference(Subscriber)); } else { subScribers = new List <WeakReference>(); subScribers.Add(new WeakReference(Subscriber)); SubscriberStore.Add(typeof(T), subScribers); } }
public static Awaiter <T> GetAwaiter <T>(this ISubscribe <T> s) { var result = new Option <T>(); var d1 = React.Scope(out var scope); var aw = new Awaiter(scope, d1.Dispose); var res = new Awaiter <T>(aw, () => result.GetOrFail()); s.Subscribe(msg => { result = msg; d1.Dispose(); }, scope); return(res); }
/// <summary> /// Starts recurring billing charges for the subscriber. /// </summary> /// <param name="request">The subscription request.</param> /// <returns></returns> public override void Subscribe(ISubscribe subscribe) { SetApiAction(RequestAction.Subscribe); Queue(AuthorizeDotNetApi.Amount, subscribe.Amount.ToString()); Queue(AuthorizeDotNetApi.BillingCycles, subscribe.BillingCycles.ToString()); Queue(AuthorizeDotNetApi.BillingInterval, Enum.GetName(typeof(BillingInterval), subscribe.BillingInterval)); Queue(AuthorizeDotNetApi.CreditCardNumber, subscribe.CreditCard.CardNumber); Queue(AuthorizeDotNetApi.CreditCardExpiration, subscribe.CreditCard.ExpirationMonth + subscribe.CreditCard.ExpirationYear); Queue(AuthorizeDotNetApi.CreditCardCode, subscribe.CreditCard.CVV); //Queue(AuthorizeDotNetApi.Email, request.CustomerEmail); Queue(AuthorizeDotNetApi.TotalOccurences, subscribe.TotalOccurrences.ToString()); Queue(AuthorizeDotNetApi.Description, subscribe.Description); Queue(AuthorizeDotNetApi.StartsOn, subscribe.StartsOn.ToString()); Queue(AuthorizeDotNetApi.SubscriptionName, subscribe.Name); Queue(AuthorizeDotNetApi.TrialAmount, subscribe.TrialAmount.ToString()); Queue(AuthorizeDotNetApi.TrialBillingCycles, subscribe.TrialOccurrences.ToString()); }
public T Subscribe <T>(ISubscribe subscribe) where T : ISubscription { var request = _context.Create(); request.ApiAction = RequestAction.Subscribe; request.AddCurrency(_context.Currency); if (subscribe.Customer != null) { request.AddCustomer(subscribe.Customer); } if (subscribe.Shipping != null) { request.AddShipping(subscribe.Shipping); } request.Subscribe(subscribe); return((T)_context.Send(request)); }
static void Main(string[] args) { ChannelFactory <IReport> channel = new ChannelFactory <IReport>(new NetTcpBinding(), new EndpointAddress("net.tcp://localhost:8001/Service")); report = channel.CreateChannel(); ChannelFactory <ICustomer> channel1 = new ChannelFactory <ICustomer>(new NetTcpBinding(), new EndpointAddress("net.tcp://localhost:8002/CO")); customer = channel1.CreateChannel(); ChannelFactory <IOrder> channel2 = new ChannelFactory <IOrder>(new NetTcpBinding(), new EndpointAddress("net.tcp://localhost:8002/CO")); order = channel2.CreateChannel(); DuplexChannelFactory <ISubscribe> ch_sub = new DuplexChannelFactory <ISubscribe>(new CallBack(), "NetTcpBinding_ISubscribe");// new NetTcpBinding(), new EndpointAddress("net.tcp://localhost:8002/CO")); sub = ch_sub.CreateChannel(); form = new Form1(); Application.Run(form); }
private void MakeProxy(object callbackinstance) { try { NetTcpBinding netTcpbinding = new NetTcpBinding(SecurityMode.None); TimeSpan ts = new TimeSpan(1, 0, 0); netTcpbinding.CloseTimeout = ts; netTcpbinding.OpenTimeout = ts; netTcpbinding.SendTimeout = ts; netTcpbinding.ReceiveTimeout = ts; EndpointAddress endpointAddress = new EndpointAddress(ConfigurationManager.AppSettings["EndpointAddress"]); InstanceContext context = new InstanceContext(callbackinstance); DuplexChannelFactory <ISubscribe> channelFactory = new DuplexChannelFactory <ISubscribe>(new InstanceContext(this), netTcpbinding, endpointAddress); proxy = channelFactory.CreateChannel(); } catch (Exception ex) { CrFSMLogger.CrFSMLogger.Instance.WriteToLog(ex); } }
static IScope Delay(float seconds, ISubscribe s) { if (DefaultScope.Disposing) { return(Never.Instance); } var pub = DefaultScope.SubScope(out var res); var timer = Time.time + seconds; s.Subscribe(() => { if (timer.KeepWaiting(Time.time)) { return; } pub.Dispose(); }, res); return(res); }
/// <summary> /// Adds the specified subscriber. /// </summary> /// <param name="Subscriber">The subscriber.</param> /// <returns></returns> public long Add(ISubscribe Subscriber) { _subscribers.Add(Subscriber); _enumeratorInitialised = false; return _subscribers.Count(); }
public void CallSubscriberHandle(ISubscribe subscr) { subscr.Handle(this); }
/// <summary> /// Uns the subscribe. /// </summary> /// <param name="Subscriber">The subscriber.</param> /// <param name="Eventname">The eventname.</param> /// <returns></returns> public bool UnSubscribe(ISubscribe Subscriber, string EventName) { ISubsciberList _subs ; if (_subscriptions.TryGetValue(EventName, out _subs)) { _subs.Remove(Subscriber); return true; } else { return false; } }
public Processor(EventProcessorClient processor, ISubscribe <T> handler, string @event) { _processor = processor; _handler = handler; _event = @event; }
public MassTransitSB(IOptions <BusConfiguration> configuration, ISubscribe subscribe) { _Subscriber = subscribe; _Bus = GetBusInstance(configuration); _Bus.StartAsync().Wait(); }
/// <summary> /// ... /// </summary> /// <param name="Source">...</param> /// <returns>...</returns> public long ObjectRollback(ISubscribe Objector) { return registerObjection(Objector); }
public bool UnSubscribe(ISubscribe Subscriber, string Eventname) { return _subscribers.UnSubscribe(Subscriber, Eventname); }
public SubscribeController(ISubscribe subRepo) { SubRepo = subRepo; }
public static Task <Func <Task> > SubscribeAsync <TKey, TEntry>(this ISubscribe <TKey, TEntry> subscribe, TKey id, SubscriptionType subscribeType, Action <ISerie <TKey, TEntry> > callback) where TEntry : IEntry { return(subscribe.SubscribeAsync(new[] { id }, subscribeType, callback)); }
public void Subscribe <T>(ISubscribe <T> subscriber) where T : IEvent { _subscribers.Add(typeof(T), subscriber); }
/// <summary> /// ... /// </summary> /// <param name="Source">...</param> /// <returns>...</returns> public long ObjectCancel(ISubscribe Objector) { return registerObjection(Objector); }
/// <summary> /// ... /// </summary> /// <param name="Source">...</param> /// <returns>...</returns> public long registerObjection(ISubscribe Objector) { _objectors.Add(Objector) ; _objectionCount = _objectors.Count(); return _objectionCount ; }
/// <summary> /// ... /// </summary> /// <param name="Source">...</param> /// <returns>...</returns> public long ObjectUpdate(ISubscribe Objector) { return registerObjection(Objector); }
private void MakeProxy(object callbackinstance) { try { NetTcpBinding netTcpbinding = new NetTcpBinding(SecurityMode.None); TimeSpan ts = new TimeSpan(1, 0, 0); netTcpbinding.CloseTimeout = ts; netTcpbinding.OpenTimeout = ts; netTcpbinding.SendTimeout = ts; netTcpbinding.ReceiveTimeout = ts; EndpointAddress endpointAddress = new EndpointAddress(ConfigurationManager.AppSettings["EndpointAddress"]); InstanceContext context = new InstanceContext(callbackinstance); DuplexChannelFactory<ISubscribe> channelFactory = new DuplexChannelFactory<ISubscribe>(new InstanceContext(this), netTcpbinding, endpointAddress); proxy = channelFactory.CreateChannel(); } catch (Exception ex) { CrFSMLogger.CrFSMLogger.Instance.WriteToLog(ex); } }
/// <summary> /// Moves to the next subscriber in the list /// </summary> /// <returns></returns> public bool Next() { if (! (_enumeratorInitialised)) { _enumeratorInitialised = true; _enumerator = _subscribers.GetEnumerator(); _enumerator.Reset(); } if (_enumerator.MoveNext()) { _current = _enumerator.Current; return true; } else { return false; } }
public T Subscribe <T>(ISubscribe subscribe) where T : ISubscription { return(_repository.Subscribe <T>(subscribe)); }
public IPublisher AddSubscriber(ISubscribe subscriber) { subscribers.Add(subscriber); return(this); }
internal static ISubscribe Create() => _subscribe ?? (_subscribe = new Subscribe());
public static bool IsSubscribing(ISubscribe subscriber) { return(_subscribers.Contains(subscriber)); }
public SubscriberListBase() { _subscribers = new List<ISubscribe>(); _current = null; }
/// <summary> /// ... /// </summary> /// <param name="Source">...</param> /// <returns>...</returns> public long ObjectCommit(ISubscribe Objector) { return registerObjection(Objector); }
/// <summary> /// Starts recurring billing charges for the given customer. /// </summary> /// <param name="request">The subscription request.</param> /// <returns></returns> public abstract void Subscribe(ISubscribe subscribe);
public static IProcessor AttachTo <T>(this EventProcessorClient processor, ISubscribe <T> service, string @event) => new Processor <T>(processor, service, @event);
/// <summary> /// Subscribes the specified subscriber. /// </summary> /// <param name="Subscriber">The subscriber.</param> /// <param name="Eventname">The eventname.</param> /// <returns></returns> public bool Subscribe(ISubscribe Subscriber, string EventName) { ISubsciberList _subs ; if (_subscriptions.TryGetValue(EventName, out _subs)) { _subs.Add(Subscriber); return true; } else { if (StrictMode) { return false; } else { AddEvent(EventName); if (_subscriptions.TryGetValue(EventName, out _subs)) { _subs.Add(Subscriber); return true; } else { return false; } } } }
/// <summary> /// Uns the subscribe. /// </summary> /// <param name="Subscriber">The subscriber.</param> /// <param name="Eventname">The eventname.</param> /// <returns></returns> public bool UnSubscribe(ISubscribe Subscriber, string Eventname) { // TODO: Implement this method throw new NotImplementedException(); }
/// <summary> /// ... /// </summary> /// <param name="Source">...</param> /// <returns>...</returns> public bool Subscribe(ISubscribe Subscriber, string EventName) { return _subscribers.Subscribe( Subscriber, EventName); }
public bool UnSubscribe(ISubscribe Subscriber, string Eventname) { throw new NotImplementedException(); }