public async Task <string> Shedule(Expression <Action> expression, DateTimeOffset runAt)
        {
            var body    = expression.Body as MethodCallExpression;
            var argType = body.Arguments[0].GetType();

            var parameters = from parameter in body.Arguments
                             let exp = parameter as MemberExpression
                                       let valueArgument = parameter as ConstantExpression
                                                           select new MethodParameter()
            {
                TypeName = parameter.Type.FullName,
                Value    = valueArgument.Value.ToString()
            };

            var cachedObject = new CachedJob()
            {
                AssemblyName     = body.Object.Type.Assembly.GetName().FullName,
                ClassName        = body.Object.Type.FullName,
                MethodName       = body.Method.Name,
                MethodParameters = parameters.ToArray(),
                RunAt            = runAt.UtcDateTime
            };

            var key = await _cacheRepository.SetEntity(cachedObject);

            return(key);
        }
        public async Task RedisServerTest()
        {
            //Arrange
            var options         = Options.Create(new MemoryDistributedCacheOptions());
            var cacheRepository = new MemoryDistributedCache(options);
            var serverMock      = new Mock <IServer>();

            serverMock.Setup(x => x.KeysAsync(It.IsAny <int>(),
                                              It.IsAny <RedisValue>(),
                                              It.IsAny <int>(),
                                              It.IsAny <long>(),
                                              It.IsAny <int>(),
                                              It.IsAny <CommandFlags>())).Returns(GetTestValues);
            var loggerMock  = new Mock <ILogger <RedisServer> >();
            var redisServer = new RedisServer(serverMock.Object, cacheRepository, loggerMock.Object);

            Expression <Func <Task> > expression = () => _testClassObject.TestMethod("test", 1);
            var body    = expression.Body as MethodCallExpression;
            var argType = body.Arguments[0].GetType();

            var parameters = from parameter in body.Arguments
                             let exp = parameter as MemberExpression
                                       let valueArgument = parameter as ConstantExpression
                                                           select new MethodParameter()
            {
                TypeName = parameter.Type.FullName,
                Value    = valueArgument.Value.ToString()
            };

            var cachedObject = new CachedJob()
            {
                AssemblyName     = body.Object.Type.Assembly.GetName().FullName,
                ClassName        = body.Object.Type.FullName,
                MethodName       = body.Method.Name,
                MethodParameters = parameters.ToArray(),
                RunAt            = ((DateTimeOffset)DateTime.UtcNow.AddSeconds(2)).UtcDateTime
            };
            var jsonData = JsonConvert.SerializeObject(cachedObject);
            await cacheRepository.SetStringAsync("1", jsonData);

            var cancellationToken = new CancellationToken();
            var src = CancellationTokenSource.CreateLinkedTokenSource(cancellationToken);
            //Act
            await redisServer.StartAsync(cancellationToken);

            for (int i = 0; i < 3; i++)
            {
                await Task.Delay(TimeSpan.FromSeconds(1));
            }

            src.Cancel();
        }