/// <summary> /// Ons the message. /// </summary> /// <param name="message">Message.</param> private void OnMessage(EasyCachingMessage message) { // each clients will recive the message, current client should ignore. if (!string.IsNullOrWhiteSpace(message.Id) && message.Id.Equals(_cacheId, StringComparison.OrdinalIgnoreCase)) { return; } //remove by prefix if (message.IsPrefix) { var prefix = message.CacheKeys.First(); _localCache.RemoveByPrefix(prefix); if (_options.EnableLogging) { _logger.LogTrace($"remove local cache that prefix is {prefix}"); } return; } foreach (var item in message.CacheKeys) { _localCache.Remove(item); if (_options.EnableLogging) { _logger.LogTrace($"remove local cache that cache key is {item}"); } } }
/// <summary> /// 接收消息 /// </summary> /// <param name="message"></param> public void ReceiveMessage(EasyCachingMessage message) { var subscribe = ServiceLocator.ServiceProvider.GetService(typeof(IEasyCachingBus)) as DefaultCAPBus; if (subscribe == null) { return; } subscribe.BaseOnMessage(message); }
/// <summary> /// 接收消息 /// </summary> /// <param name="message"></param> public void ReceiveMessage(EasyCachingMessage message) { var subscribe = _serviceProvider.GetService <IEasyCachingBus>() as DefaultCAPBus; if (subscribe == null) { return; } subscribe.BaseOnMessage(message); }
public void Publish(string topic, EasyCachingMessage message) { if (_syncExecutePolicy == null) { Bus.Publish(topic, message); } else { _syncExecutePolicy.Execute(() => Bus.Publish(topic, message)); } }
/// <summary> /// Publishs the async. /// </summary> /// <returns>The async.</returns> /// <param name="channel">Channel.</param> /// <param name="cacheKey">Cache key.</param> /// <param name="cacheValue">Cache value.</param> /// <param name="expiration">Expiration.</param> public async Task PublishAsync <T>(string channel, string cacheKey, T cacheValue, TimeSpan expiration) { ArgumentCheck.NotNullOrWhiteSpace(channel, nameof(channel)); //TODO : Handle Parameters EasyCachingMessage message = new EasyCachingMessage() { CacheKey = cacheKey, CacheValue = cacheValue, Expiration = expiration }; await _subscriber.PublishAsync(channel, _serializer.Serialize(message)); }
/// <summary> /// Publish the specified topic and message. /// </summary> /// <param name="topic">Topic.</param> /// <param name="message">Message.</param> public override void BasePublish(string topic, EasyCachingMessage message) { var channel = _pubChannelPool.Get(); try { var body = _serializer.Serialize(message); channel.ExchangeDeclare(_options.TopicExchangeName, ExchangeType.Topic, true, false, null); channel.BasicPublish(_options.TopicExchangeName, topic, false, null, body); } catch (Exception ex) { Console.WriteLine(ex.Message); } finally { _pubChannelPool.Return(channel); } }
/// <summary> /// Publish the specified topic and message async. /// </summary> /// <returns>The async.</returns> /// <param name="topic">Topic.</param> /// <param name="message">Message.</param> /// <param name="cancellationToken">Cancellation token.</param> public override Task BasePublishAsync(string topic, EasyCachingMessage message, CancellationToken cancellationToken = default(CancellationToken)) { var channel = _pubChannelPool.Get(); try { var body = _serializer.Serialize(message); channel.ExchangeDeclare(_options.TopicExchangeName, ExchangeType.Topic, true, false, null); channel.BasicPublish(_options.TopicExchangeName, topic, false, null, body); } catch (Exception ex) { Console.WriteLine(ex.Message); } finally { _pubChannelPool.Return(channel); } return(Task.CompletedTask); }
/// <summary> /// Publish the specified topic and message. /// </summary> /// <param name="topic">Topic.</param> /// <param name="message">Message.</param> public void Publish(string topic, EasyCachingMessage message) { var conn = _pubConnectionPool.Get(); try { var body = _serializer.Serialize(message); var model = conn.CreateModel(); model.ExchangeDeclare(_options.TopicExchangeName, ExchangeType.Topic, true, false, null); model.BasicPublish(_options.TopicExchangeName, topic, false, null, body); } catch (Exception ex) { Console.WriteLine(ex.Message); } finally { _pubConnectionPool.Return(conn); } }
/// <summary> /// Publish the specified channel and message. /// </summary> /// <returns>The publish.</returns> /// <param name="channel">Channel.</param> /// <param name="message">Message.</param> public void Publish(string channel, EasyCachingMessage message) { var _publisherChannel = _connectionChannelPool.Rent(); try { var body = _serializer.Serialize(message); _publisherChannel.ExchangeDeclare(_rabbitMQBusOptions.TopicExchangeName, ExchangeType.Topic, true, false, null); _publisherChannel.BasicPublish(_rabbitMQBusOptions.TopicExchangeName, channel, false, null, body); } catch (Exception ex) { Console.WriteLine(ex.Message); } finally { var returned = _connectionChannelPool.Return(_publisherChannel); if (!returned) { _publisherChannel.Dispose(); } } }
/// <summary> /// Publishs the specified topic and message async. /// </summary> /// <returns>The async.</returns> /// <param name="topic">Topic.</param> /// <param name="message">Message.</param> /// <param name="cancellationToken">Cancellation token.</param> public async Task PublishAsync(string topic, EasyCachingMessage message, CancellationToken cancellationToken = default(CancellationToken)) { ArgumentCheck.NotNullOrWhiteSpace(topic, nameof(topic)); await _subscriber.PublishAsync(topic, _serializer.Serialize(message)); }
/// <summary> /// Publish the specified topic and message. /// </summary> /// <param name="topic">Topic.</param> /// <param name="message">Message.</param> public void Publish(string topic, EasyCachingMessage message) { ArgumentCheck.NotNullOrWhiteSpace(topic, nameof(topic)); _subscriber.Publish(topic, _serializer.Serialize(message)); }
public void Publish(string topic, EasyCachingMessage message) { }
public Task PublishAsync(string topic, EasyCachingMessage message, CancellationToken cancellationToken = default(CancellationToken)) { return(Task.CompletedTask); }
/// <summary> /// Publish the specified topic and message. /// </summary> /// <param name="topic">Topic.</param> /// <param name="message">Message.</param> public override void BasePublish(string topic, EasyCachingMessage message) { _capBus.Publish(_options.TopicName, message); }
/// <summary> /// Publish the specified topic and message. /// </summary> /// <param name="topic">Topic.</param> /// <param name="message">Message.</param> public override void BasePublish(string topic, EasyCachingMessage message) { var msg = JsonConvert.SerializeObject(message); _client.Publish(topic, msg); }
public Task PublishAsync(string topic, EasyCachingMessage message, CancellationToken cancellationToken = default(CancellationToken)) { return(_asyncExecutePolicy == null ? Bus.PublishAsync(topic, message, cancellationToken) : _asyncExecutePolicy.ExecuteAsync(() => Bus.PublishAsync(topic, message, cancellationToken))); }
/// <summary> /// Publish the specified channel and message. /// </summary> /// <returns>The publish.</returns> /// <param name="channel">Channel.</param> /// <param name="message">Message.</param> public void Publish(string channel, EasyCachingMessage message) { ArgumentCheck.NotNullOrWhiteSpace(channel, nameof(channel)); _subscriber.Publish(channel, _serializer.Serialize(message)); }
/// <summary> /// Publishs the async. /// </summary> /// <returns>The async.</returns> /// <param name="channel">Channel.</param> /// <param name="message">Message.</param> public async Task PublishAsync(string channel, EasyCachingMessage message) { ArgumentCheck.NotNullOrWhiteSpace(channel, nameof(channel)); await _subscriber.PublishAsync(channel, _serializer.Serialize(message)); }
/// <summary> /// Publishs the specified topic and message async. /// </summary> /// <returns>The async.</returns> /// <param name="topic">Topic.</param> /// <param name="message">Message.</param> /// <param name="cancellationToken">Cancellation token.</param> public override async Task BasePublishAsync(string topic, EasyCachingMessage message, CancellationToken cancellationToken = default(CancellationToken)) { await _capBus.PublishAsync(_options.TopicName, message); }
/// <summary> /// Publishs the async. /// </summary> /// <returns>The async.</returns> /// <param name="topic">Topic.</param> /// <param name="message">Message.</param> /// <param name="cancellationToken">Cancellation token.</param> public override async Task BasePublishAsync(string topic, EasyCachingMessage message, CancellationToken cancellationToken = default(CancellationToken)) { var msg = JsonConvert.SerializeObject(message); await _client.PublishAsync(topic, msg); }
/// <summary> /// Publishs the async. /// </summary> /// <returns>The async.</returns> /// <param name="channel">Channel.</param> /// <param name="message">Message.</param> public Task PublishAsync(string channel, EasyCachingMessage message) { throw new NotImplementedException(); }