C# RedisClient.FlushDb方法代码示例

 public static void ClearAll()
 {
     using (var client = new RedisClient(CacheIp))
     {
         client.FlushDb();
         client.FlushAll();
     }
 }

        public static void ShouldSerializeDateEntitiesInListsWithTimeZoneOffset()
        {
            var date = DateTime.Now;
            using (var redis = new RedisClient())
            {
                redis.FlushDb();

                var list = redis.As<DateTime>().Lists["listId"];
                list.Add(date);             // silently drops timezone offset (0400)
                var dateFromList = list[0]; // fetch the incorrectly stored date
                Assert.AreEqual(date.ToLocalTime(), dateFromList.ToLocalTime());

            }
        }

        public ActionResult data_to_redis()
        {
            DataTable table = GetDataTable("select distinct road from   familiarrealty_f.houseinfo");

            HashSet<string> non_rep_address = new HashSet<string>();
            List<String> json_strings = new List<String>();

            ServiceStack.Redis.RedisClient redis = new ServiceStack.Redis.RedisClient();
            redis.FlushDb();

            foreach (DataRow row in table.Rows) {
                var json_result = new { road = row["road"].ToString() };
                redis.AddItemToList("road:geo", json_result.ToJSON());
                json_strings.Add(json_result.ToJSON());
                non_rep_address.Add(json_result.ToJSON());
            }

            //Response.Write(String.Format(@"non_rep_address count is {0},json_string_count is {1}",non_rep_address.Count,json_strings.Count));
            return new RenderJsonResult {
                  Result =  json_strings
            };
        }

        public void Can_failover_MqServer_at_runtime()
        {
            const int iterations = 100;
            var failoverHost = "redis-failover:6379";
            var localClient = new RedisClient("localhost:6379");

            localClient.FlushDb();
            var failoverClient = new RedisClient(failoverHost);
            failoverClient.FlushDb();

            var clientManager = new PooledRedisClientManager(new[] { "localhost" });
            var mqHost = new RedisMqServer(clientManager);

            var map = new Dictionary<string, int>();
            var received = 0;
            mqHost.RegisterHandler<Msg>(c =>
            {
                var dto = c.GetBody();
                received++;
                int count;
                map.TryGetValue(dto.Host, out count);
                map[dto.Host] = count + 1;

                lock (clientManager)
                {
                    "Received #{0} from {1}".Print(received, dto.Host);
                    if (received == iterations)
                        Monitor.Pulse(clientManager);
                }

                return null;
            });

            mqHost.Start();

            RunMqInLoop(mqHost, iterations: iterations, callback: () =>
            {
                lock (clientManager)
                    "{0} msgs were published.".Print(iterations);
            });

            Thread.Sleep(500);

            clientManager.FailoverTo(failoverHost);

            lock (clientManager)
                Monitor.Wait(clientManager);

            "localclient inq: {0}, outq: {1}".Print(
                localClient.GetListCount("mq:Msg.inq"),
                localClient.GetListCount("mq:Msg.outq"));
            "failoverClient inq: {0}, outq: {1}".Print(
                failoverClient.GetListCount("mq:Msg.inq"),
                failoverClient.GetListCount("mq:Msg.outq"));

            Assert.That(received, Is.EqualTo(100));
            Assert.That(map.Count, Is.EqualTo(2));
            var msgsFromAllHosts = 0;
            foreach (var count in map.Values)
            {
                Assert.That(count, Is.GreaterThan(0));
                msgsFromAllHosts += count;
            }
            Assert.That(msgsFromAllHosts, Is.EqualTo(iterations));
        }

 private RedisClient GetConnection()
 {
     if (_client == null)
     {
         _client = new RedisClient("TestDataLinux", 6379);
         _client.FlushDb();
     }
     return _client;
 }

		private void CleanOldRedisData()
		{
			using (var redisClient = new RedisClient(RedisServerUri))
			{
				redisClient.FlushDb();
			}
		}