コード例 #1
0
 private IDisposable UpdateBadge(byte[] key, RedisTargetInfo targetInfo)
 {
     return(_clientAccessor.With(targetInfo, client => client.SCard(ustring.Make(key).ToString())) // TODO: async
            .SubscribeWithLog(len =>
     {
         _model.BadgeText = $"Set ({len})";
     }));
 }
コード例 #2
0
        public IDisposable BindLength(byte[] key, RedisTargetInfo targetInfo)
        {
            _model.BadgeText = "String";

            return(_clientAccessor.With(targetInfo, client => client.StrLen(ustring.Make(key).ToString())) // TODO: async
                   .SubscribeWithLog(len =>
            {
                _model.BadgeText = $"String ({len})";
            }));
        }
コード例 #3
0
 public IObservable <RedisResultInfo> Execute(
     RedisTargetInfo targetInfo, RedisCommandInfo commandInfo)
 {
     return(_clientAccessor.With(targetInfo, client =>
     {
         // TODO: async
         return client.Call(commandInfo.Name, commandInfo.Args);
     })
            .Select(data => RedisResultInfo.MapResult(
                        targetInfo,
                        commandInfo,
                        data))
            .Catch <RedisResultInfo, RedisException>(exception => Observable.Return(
                                                         new RedisResultInfo.Error(
                                                             targetInfo,
                                                             commandInfo,
                                                             exception))));
 }
コード例 #4
0
        public IObservable <StructProjectionInfo> Project(
            ResultProjectionInfo resultProjectionInfo)
        {
            if (resultProjectionInfo == null)
            {
                return(Observable.Return(
                           new StructProjectionInfo(null, StructProjectionKind.None)));
            }

            var key = Encoding.UTF8.GetString(resultProjectionInfo.Value);

            return(_clientAccessor.With(
                       resultProjectionInfo.Result.TargetInfo,
                       client => client.Type(key))
                   .Select(type =>
            {
                switch (type)
                {
                case "string":
                    return new StructProjectionInfo(
                        resultProjectionInfo, StructProjectionKind.String);

                case "list":
                    return new StructProjectionInfo(
                        resultProjectionInfo, StructProjectionKind.List);

                case "set":
                    return new StructProjectionInfo(
                        resultProjectionInfo, StructProjectionKind.Set);

                case "zset":
                    return new StructProjectionInfo(
                        resultProjectionInfo, StructProjectionKind.ZSet);

                case "hash":
                    return new StructProjectionInfo(
                        resultProjectionInfo, StructProjectionKind.Hash);
                }

                return new StructProjectionInfo(
                    resultProjectionInfo, StructProjectionKind.None);
            }));
        }
コード例 #5
0
        private IObservable <string[]> GetQuickAccessItems(
            string text)
        {
            if (!string.IsNullOrWhiteSpace(text) && !text.Contains("*"))
            {
                text = text.Trim() + "*";
            }

            RedisTargetInfo targetInfo = null;

            if (_model.IsDatabaseTargetSelected)
            {
                targetInfo = _model.SelectedDatabaseTarget.DatabaseInfo;
            }

            if (_model.IsServerTargetSelected)
            {
                targetInfo = _model.SelectedServerTarget.ServerInfo;
            }

            if (!string.IsNullOrWhiteSpace(text) && targetInfo != null)
            {
                return(_clientAccessor.With(targetInfo, client =>
                {
                    var scan = client.Scan(0, text);
                    if (scan != null)
                    {
                        var items = scan.Items
                                    .ToArray();

                        return Observable.Return(items);
                    }

                    return Observable.Return(new string[0]);
                }));
            }

            return(Observable.Return(new string[0]));
        }