/// <summary>
/// 创建订阅者
/// </summary>
/// <returns></returns>
public ActionResult CreateSubscribe()
{
var model = new RedisSubscriber();
model.Id = TDemoTable.GetNewId().ToString();
return(View(model));
}
public void OnMessage_EventTriggered(string channelName)
{
Action <RedisChannel, RedisValue> method = null;
A.CallTo(() => _subscriber.Subscribe(
channelName,
A <Action <RedisChannel, RedisValue> > ._,
A <CommandFlags> ._)).Invokes(i => method = i.GetArgument <Action <RedisChannel, RedisValue> >(1));
var eventHandler = A.Fake <EventHandler <CacheUpdateNotificationArgs> >();
A.CallTo(() => _itemSerializer.Deserialize <CacheUpdateNotificationArgs>(A <byte[]> ._)).Returns(new CacheUpdateNotificationArgs()
{
ClientName = "A"
});
var cacheSubscriber = new RedisSubscriber(_connection, _remoteCache, _itemSerializer);
cacheSubscriber.CacheUpdate += eventHandler;
cacheSubscriber.CacheDelete += eventHandler;
method.Invoke(channelName, "a");
A.CallTo(() => eventHandler(A <object> .Ignored, A <CacheUpdateNotificationArgs> ._)).MustHaveHappened(Repeated.Exactly.Once);
}
/// <summary>
/// 订阅
/// 重复订阅只保留最后一次订阅
/// </summary>
/// <param name="desc">描叙</param>
/// <param name="notifyURL">通知回调的相对或绝对URL</param>
/// <returns></returns>
public async Task <bool> SubscribeAsync(RedisSubscriber user)
{
var db = this.GetDatabase();
await db.HashDeleteAsync(NotifyHashKey, Encryption.GetMD5(user.Id));
return(await db.HashSetAsync(NotifyHashKey, Encryption.GetMD5(user.Id), user.ToRedisValue()));
}
public void GetAsync_CallsRemoteCache()
{
var cacheSubscriber = new RedisSubscriber(_connection, _remoteCache, _itemSerializer);
cacheSubscriber.GetAsync("A", typeof(string));
A.CallTo(() => _remoteCache.GetAsync("A", typeof(string), A <Func <Task <object> > > ._)).MustHaveHappened(Repeated.Exactly.Once);
}
public void Constructor_SubscribesToCacheDeleteChannel_WithItself()
{
var cacheSubscriber = new RedisSubscriber(_connection, _remoteCache, _itemSerializer);
A.CallTo(() => _subscriber.Subscribe(
"cacheDelete",
A <Action <RedisChannel, RedisValue> > .That.Matches(f => f.Target.Equals(cacheSubscriber)),
A <CommandFlags> ._)).MustHaveHappened(Repeated.Exactly.Once);
}
public void GetAsync_CallingDataRetriever_DoesNotThrow()
{
var cacheSubscriber = new RedisSubscriber(_connection, _remoteCache, _itemSerializer);
A.CallTo(() => _remoteCache.GetAsync("A", typeof(string), A <Func <Task <object> > > ._))
.Invokes(call => call.GetArgument <Func <Task <object> > >(2).Invoke());
Action act = () => cacheSubscriber.GetAsync("A", typeof(string));
act.ShouldNotThrow();
}
public IDisposable Subscribe(string key, Action<string, string> handler)
{
if (string.IsNullOrWhiteSpace(key))
{
throw new ArgumentNullException("key");
}
if (handler == null)
{
throw new ArgumentNullException("handler");
}
var subscription = new RedisChannel(key, RedisChannel.PatternMode.Literal);
var subscriber = new RedisSubscriber(() => _subscriber.Value.Unsubscribe(subscription));
_subscriber.Value.Subscribe(subscription, (k, v) => handler(k, v));
return subscriber;
}
private static async Task <RedisSubscriber> CreateRedisSubscriber(string redisUrl)
{
var redisSubscriber = new RedisSubscriber(redisUrl);
await redisSubscriber.Subscribe(channelMessage => { Console.WriteLine($"OnNext({channelMessage.Message})"); },
"messages");
await redisSubscriber.Subscribe(channelMessage =>
{
var recordChange = JsonConvert.DeserializeObject <RecordChangedNotification <Product> >(channelMessage.Message);
Console.WriteLine($"OnNext Product changed({recordChange.ChangeType})");
Console.WriteLine($"OnNext Product changed({recordChange.Entity.Id})");
}, nameof(Product) + "-Changes");
await redisSubscriber.Subscribe(channelMessage =>
{
var tableDependencyStatus = JsonConvert.DeserializeObject <VersionedTableDependencyStatus>(channelMessage.Message);
Console.WriteLine($"OnNext tableDependencyStatus changed({tableDependencyStatus.TableDependencyStatus})");
}, nameof(Product) + "-Status");
redisSubscriber.WhenIsConnectedChanges.Subscribe(c => Console.WriteLine($"REDIS is connected: {c}"));
return(redisSubscriber);
}
public async Task <JsonResult> CreateSubscribe(RedisSubscriber model)
{
var state = await PubSubRedis.Instance.SubscribeAsync(model);
return(Json(new { state = state, value = "操作成功" }));
}
