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();
}
