public MemcachedLocker(MemcachedClient client, string key, TimeSpan timeOut)
{
this.client = client;
this.key = key;
this.timeOut = timeOut;
int sleep = 10;
DateTime now = DateTime.Now;
while (DateTime.Now - now < timeOut)
{
if (client.Add<DateTime?>(key, DateTime.Now.Add(timeOut)))
return;
//需要排除锁未释放的可能，如果检测到超过超时时间2倍的话，尝试获得锁
ulong version;
var time = client.Get<DateTime?>(key, out version);
if (time == null || (time.HasValue && time.Value.ToLocalTime().Add(timeOut + timeOut) < DateTime.Now))
{
LocalLoggingService.Warning("{0} {1} {2} {3}", DistributedServerConfiguration.ModuleName, "MemcachedLocker", "MemcachedLocker",
string.Format("发现一个超时的分布式锁，超时时间：{0} Key : {1}",
time, key));
if (client.Add<DateTime?>(key, DateTime.Now.Add(timeOut), version))
return;
}
if (sleep < 1000)
sleep = sleep * 110 / 100;
else
sleep = 1000;
Thread.Sleep(sleep);
}
throw new TimeoutException(string.Format("获得锁的时间超过了设定的最大时间 {0}", timeOut.ToString()));
}
public void Add(string key, object obj)
{
if (obj != null && !mc.KeyExists(key))
{
mc.Add(key, obj);
}
}
/// <summary>
/// 添加缓存信息(如果存在缓存信息则直接重写设置，否则添加)
/// 使用：MemcacheHelper.GetInstance().Add(key,value)
/// </summary>
/// <param name="key">需要缓存的键</param>
/// <param name="value">需要缓存的值</param>
public void Add(string key, object value)
{
if (_client.KeyExists(key))
{
_client.Set(key, value);
}
_client.Add(key, value);
}
public void Add <T>(string key, T value, DateTime date)
{
key = preFix + key;
if (value == null)
{
mc.Delete(key);
}
else
{
mc.Add(key, value, date);
}
}
/// <summary>
/// 添加缓存
/// </summary>
/// <param name="key"></param>
/// <param name="obj"></param>
public static void SetCache(string key, object obj)
{
bool exists = true;
if (string.IsNullOrEmpty(key))
{
throw new ArgumentNullException("key", "缓存键为null");
}
mc.Delete(key);
if (mc.Add(key, obj) == false)
{
throw new CacheException("存入缓存失败");
}
}
public void Add(string groupName, string key, object value)
{
MemcachedClient client = GetMemcachedClient(groupName);
RemoteCachePolicy policy = cacheSettingManager.GetRemoteCachePolicy(groupName);
if (policy != null && policy.AbsoluteExpirationTimeInSecond > 0)
{
client.Add(key, value, DateTime.Now.AddSeconds(policy.AbsoluteExpirationTimeInSecond));
}
else
{
client.Add(key, value);
}
}
//增加
protected void Button2_Click(object sender, EventArgs e)
{
client.Add("a", 5);
client.Add("b", "test");
bool result = client.Add("cc", "1234");
if (result)
{
Response.Write("<script>alert('添加成功!')</script>");
}
else
{
Response.Write("<script>alert('添加成功!')</script>");
}
}
/// <summary>
/// 添加缓存
/// </summary>
/// <param name="key">关键字</param>
/// <param name="value">缓存值</param>
public void Add <T>(string key, T value)
{
if (this.enable)
{
if (cache.Get(key) != null)
{
cache.Replace(key, value);
}
else
{
cache.Add(key, value);
}
}
return;
}
/// <summary>
/// 覆盖缓存
/// </summary>
/// <param name="pKey"></param>
/// <param name="pObject"></param>
/// <returns></returns>
private static bool StoreCache(string pKey, object pObject)
{
MemcachedClient mc = new MemcachedClient();
mc.EnableCompression = true;
bool _result = false;
if (IsCache(mc, pKey))
{
if (mc.Get(pKey) == null)
{
mc.Set(pKey, pObject);//缓存存在，强行覆盖
}
else
{
mc.Replace(pKey, pObject);//缓存存在，强行覆盖
}
_result = true;
}
else
{
mc.Add(pKey, pObject);//第一次加载缓存
_result = true;
}
return(_result);
}
//1.Add test
public String AddTest()
{
MemcachedClient cache = MemcachedClient.GetInstance("BeITMemcached");
cache.Add("BeIt", "123");
return(HandleLogs("[Cmd=Add]BeIt：" + cache.Get("BeIt").ToString()));
}
public static string GetAccessToken()
{
try
{
string key = "GetWxCatInfo_AccessToken";
//判断缓存是否存在
string access_token = memcached.Get <string>(key);
if (string.IsNullOrEmpty(access_token))
{
string appid = db.config["wechat:appid"];
string secret = db.config["wechat:secret"];
//获取最新的token
string url = $"https://api.weixin.qq.com/cgi-bin/token?grant_type=client_credential&appid={appid}&secret={secret}";
var response = client.SendAsync(new HttpRequestMessage(HttpMethod.Get, url)).Result;
var content = response.Content.ReadAsStringAsync().Result;
OAuthAccessTokenJsonResult result = Newtonsoft.Json.JsonConvert.DeserializeObject <OAuthAccessTokenJsonResult>(content);
if (result.errcode != 0)
{
Console.WriteLine("失败：" + Newtonsoft.Json.JsonConvert.SerializeObject(result));
return("");
}
access_token = result.access_token;
memcached.Add(key, result.access_token, 120);
}
return(access_token);
}
catch (Exception ex)
{
Console.WriteLine(ex.Message);
}
return("");
}
//更多的是存储一个自定义的类的实例对象。这就需要使用到序列化，下面我们来新加一个类MyObject，让其作为可序列化的对象来存储进Memcached中
public void MemcachedTest(string[] args)
{
//初始化池
SockIOPool sock = SockIOPool.GetInstance();
sock.SetServers(serverlist.ToArray()); //添加服务器列表
sock.InitConnections = 3; //设置连接池初始数目
sock.MinConnections = 3; //设置最小连接数目
sock.MaxConnections = 5; //设置最大连接数目
sock.SocketConnectTimeout = 1000; //设置连接的套接字超时。
sock.SocketTimeout = 3000; //设置套接字超时读取
sock.MaintenanceSleep = 30; //设置维护线程运行的睡眠时间。如果设置为0，那么维护线程将不会启动;
//获取或设置池的故障标志。
//如果这个标志被设置为true则socket连接失败，
//将试图从另一台服务器返回一个套接字如果存在的话。
//如果设置为false，则得到一个套接字如果存在的话。否则返回NULL，如果它无法连接到请求的服务器。
sock.Failover = true; //如果为false，对所有创建的套接字关闭Nagle的算法。
sock.Nagle = false;
sock.Initialize();
MemcachedClient mc = new MemcachedClient();
mc.EnableCompression = true; //是否启用压缩数据
//mc.Set(key,val);//设置 键值
//mc.KeyExists(key) //键 是否存
//mc.Get(key) //获取 一个键值
//mc.Delete(key);// 删除 键值
Console.WriteLine("----------------------------Set-----------");
mc.Set("key1", "value1");
Console.WriteLine(mc.Get("key1"));
Console.WriteLine("---------------------------replay---------");
mc.Replace("key1", "Replay new Key1");
Console.WriteLine(mc.Get("key1"));
Console.WriteLine("---------------------------键值是否存在----");
if (mc.KeyExists("key2"))
{
Console.WriteLine("key2存在");
}
else
{
Console.WriteLine("key2不存在，设置新值");
mc.Set("key2", "New key2");
}
Console.WriteLine("-------------------------删除数据--------");
mc.Delete("key2");
Console.WriteLine("删除之后的数据: " + mc.Get("key2"));
Console.WriteLine("-------------------------数据过期--------");
mc.Add("key3", "新数据三内容", DateTime.Now.AddMilliseconds(5000));
Console.WriteLine(mc.Get("key5"));
System.Threading.Thread.Sleep(6000);
Console.WriteLine("过期: " + mc.Get("key5"));
Console.ReadLine();
}
/// <summary>
/// 设置缓存数据
/// </summary>
/// <param name="key">键</param>
/// <param name="value">值</param>
/// <param name="coverType">覆盖类型</param>
public void Set(string key, object value, CoverType coverType = CoverType.set)
{
switch (coverType)
{
case CoverType.set:
_mcClient.Set(key, value);
break;
case CoverType.add:
_mcClient.Add(key, value);
break;
case CoverType.replace:
_mcClient.Replace(key, value);
break;
}
}
public void MemcachedClientTest()
{
client.Add("FirstCache", 1, DateTime.Now.AddSeconds(3600));
var value = client.Get("FirstCache");
Assert.IsNotNull(value);
Assert.AreEqual(value, 1);
}
/// <summary>
/// Set-新增或修改
/// </summary>
/// <param name="key">键</param>
/// <param name="value">值</param>
/// <returns>是否成功</returns>
public static bool AddCache(string key, object value)
{
if (MemcacheHelperInit())
{
if (!mc.KeyExists(key))
{
return(mc.Add(key, value));
}
else
{
return(mc.Set(key, value));
}
}
else
{
return(false);
}
}
/// <summary>
/// 缓存锁
/// </summary>
/// <returns></returns>
public static void LockCache(string name)
{
var flag = false;
while (!flag)
{
flag = cache.Add("L_C_Ta_" + name, "123", new TimeSpan(0, 0, 0, 30));
}
}
internal static void SetValue(string sessionId, string userName, DateTime dateTime)
{
MemcachedClient _mc = GetClient();
if (_mc.KeyExists(sessionId))
{
_mc.Delete(sessionId);
}
_mc.Add(sessionId, userName, dateTime);
}
public virtual void Insert(string key, object value, int seconds)
{
if (null != _client)
{
_client.Add(key, value, DateTime.Now.AddSeconds(seconds));
}
if (null != _logger)
{
_logger.Error("the distribute client is null.");
}
}
public void Add(string key, object value, DateTime expireDate)
{
if (mc.KeyExists(key))
{
mc.Set(key, value, expireDate);
}
else
{
mc.Add(key, value, expireDate);
}
}
/// <summary>
/// 添加缓存
/// 注意：如果缓存KEY已经存在，不会再次存储
/// </summary>
/// <param name="key">The key</param>
/// <param name="value">The value</param>
/// <param name="expiredTime">The expiredTime</param>
/// <returns>
/// The Boolean
/// </returns>
/// 创建者：孟祺宙
/// 创建日期：2014/8/15 11:19
/// 修改者：
/// 修改时间：
/// ----------------------------------------------------------------------------------------
public bool Add(string key, object value, DateTime expiredTime)
{
try
{
return(_memcachedClient.Add(GetKey(key), value, expiredTime));
}
catch (Exception ex)
{
return(false);
}
}
//1.Add test
public void AddTest()
{
try
{
MemcachedClient cache = MemcachedClient.GetInstance("BeITMemcached");
cache.Add("BeIt", "123");
HandleLogs("[Cmd=Add]BeIt：" + cache.Get("BeIt").ToString());
}
catch (Exception)
{
}
}
/// <summary>
/// 添加单个依赖项的缓存 (最小时间单位为秒)
/// </summary>
public static void Set(string depend, string key, object obj, int exp)
{
depend = depend.ToLower();
key = key.ToLower();
try
{
//HttpContext.Current.Application.Lock();
//将数据加入缓存
mclient.Add(key, obj, exp);
//HttpContext.Current.Application.UnLock();
////将Keys加入字典
//MDictionary_AddKeys(depend, key);
}
catch (System.Exception ex)
{
throw new Exception(ex.Message);
}
}
public void TestSet()
{
MemcachedClient mc = new MemcachedClient();
mc.EnableCompression = false;
mc.Add("SetTest", "123");
//Test Set
mc.Set("SetTest", "public bool Set(string key, object value, DateTime expiry, int hashCode)");
if (mc.KeyExists("SetTest"))
{
HandleLogs("[Cmd=Set]SetTest的值是：" + mc.Get("SetTest").ToString());
}
}
public override bool Add(string key, object value, CacheItemPolicy policy, string regionName = null)
{
if (policy == null)
{
policy = new CacheItemPolicy()
{
AbsoluteExpiration = DateTimeOffset.Now.AddMinutes(2)
};
}
TimeSpan ts = policy.AbsoluteExpiration - DateTimeOffset.Now;
return(_mclient.Add(key, value, DateTime.Now + ts));
}
private ulong GetIncreasedIndex(string index_key)
{
ulong?index = null;
while (index == null)
{
bool r = m_Client.Add(index_key, 0);
if (r)
{
index = 0;
}
else
{
//index = m_Client.Increment(en_index_key, 1);
MemcachedClient.CasResult casRst;
ulong unique;
do
{
object t = m_Client.Gets(index_key, out unique);
if (t == null)
{
index = null;
break;
}
index = Convert.ToUInt64(t);
if (index >= MAX_LENGTH)
{
index = 0;
}
else
{
index = index + 1;
}
casRst = m_Client.CheckAndSet(index_key, index.Value, unique);
} while (casRst != MemcachedClient.CasResult.Stored);
}
}
return(index.Value);
}
//增加
protected void Button1_Click(object sender, EventArgs e)
{
GetDb(out MemcachedClient MClient);
bool incre = MClient.Add("key1", "helloworld");
MClient.Set("key2", 12);
MClient.Set("key3", 3.1415);
MClient.Add("key4", "设置过期时间", DateTime.Now.AddMinutes(1));
MClient.Set("key5", "good", 4);
MClient.Set("key6", "20");
string s = MClient.Get("key1").ToString();
if (s == "helloworld" && incre == true)
{
Response.Write("<script>alert('添加成功!')</script>");
}
else
{
Response.Write("<script>alert('添加失败!')</script>");
}
}
public void TestGet()
{
MemcachedClient mc = new MemcachedClient();
mc.Add("Get", "Get A Cmd=Get");
if (mc.KeyExists("Get"))
{
Object o = mc.Get("Get");
if (o != null)
{
HandleLogs("[Cmd=Get]Get的值是：" + o.ToString());
mc.Delete("Get");
}
}
}
public SimpleRun()
{
var bin = new DatabaseBuilder().Append(MakeDoc(5000)).Build();
db = new MemoryDatabase(bin);
sqliteMemory = new SQLite_Test(5000, null, false, true);
sqliteMemory.Prepare(); sqliteMemory.Insert(); sqliteMemory.CreateIndex();
sqliteFile = new SQLite_Test(5000, null, false, false);
sqliteFile.Prepare(); sqliteFile.Insert(); sqliteFile.CreateIndex();
defaultLiteDb = new LiteDB_Test(5000, null, new LiteDB.FileOptions {
Journal = true, FileMode = LiteDB.FileMode.Shared
});
defaultLiteDb.Prepare(); defaultLiteDb.Insert(); defaultLiteDb.CreateIndex();
inmemoryLiteDb = new LiteDB_Test(5000);
inmemoryLiteDb.Prepare(); inmemoryLiteDb.Insert(); inmemoryLiteDb.CreateIndex();
liteDb2 = new LiteDB_Test2(5000);
liteDb2.Prepare(); liteDb2.Insert(); liteDb2.CreateIndex();
dictionary = new Dictionary <int, TestDoc>();
foreach (var item in MakeDoc(5000))
{
dictionary.Add(item.id, item);
}
{
var options = new DbOptions().SetCreateIfMissing(true);
var tempPath = Guid.NewGuid() + ".bin";
rocksDb = RocksDb.Open(options, tempPath);
foreach (var item in MakeDoc(5000))
{
rocksDb.Put(Encoding.UTF8.GetBytes("testdata." + item.id), MessagePackSerializer.Serialize(item));
}
}
var config = new MemcachedClientConfiguration(new LoggerDummy(), new Dummy());
localMemcached = new MemcachedClient(new LoggerDummy(), config);
foreach (var item in MakeDoc(5000))
{
localMemcached.Add("testdoc2." + item.id, item, 9999);
}
}
//[ValidateModel]
public object test(TestReq req)
{
var list = new List <testrr> {
new testrr {
name = "txy", sex = 1
},
new testrr {
name = "wz", sex = 0
},
};
cache.Add("test", JsonConvert.SerializeObject(list), DateTime.Now.AddDays(1));
var r = cache.Get("test");
//return r;
var list2 = JsonConvert.DeserializeObject <List <testrr> >(r.ToString());
return(list2);
}
/// <summary>
/// 存入Memcached
/// </summary>
/// <param name="cacheKey">缓存键值</param>
/// <param name="cacheValue">缓存值</param>
/// <param name="expiration">缓存过期策略（FileMonitorExpiration模式不适用）</param>
public static void MemcachedSet(this string cacheKey, object cacheValue, IExpiration expiration)
{
DateTime expiredTime = DateTime.MaxValue;
if (expiration is RelativeTimeExpiration)
{
expiredTime = ((RelativeTimeExpiration)expiration).ExpiredTime;
}
else if (expiration is AbsTimeExpiration)
{
expiredTime = ((AbsTimeExpiration)expiration).ExpiredTime;
}
if (mClient.KeyExists(cacheKey))
{
mClient.Delete(cacheKey);
}
mClient.Add(cacheKey, cacheValue, expiredTime);
}
/// <summary>
/// 将数据以键值对的方式，缓存到Memcached
/// </summary>
/// <param name="key">缓存键</param>
/// <param name="obj">缓存值</param>
/// <param name="expiry">有效期（服务器当前时间+expiry）</param>
public void Store(string key, object obj, TimeSpan expiry)
{
DateTime timeout = DateTime.Now.Add(expiry);
if (Exists(key))
{
if (Get(key) == null)
{
memcachedClient.Set(key, obj, timeout);//缓存存在(且对象为null)，强行覆盖
}
else
{
memcachedClient.Replace(key, obj, timeout);//缓存存在，强行覆盖
}
}
else
{
memcachedClient.Add(key, obj, timeout);//第一次加载缓存
}
}
