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