/// <summary>
///
/// </summary>
//static string ip2 = Barfoo.Library.Configuration.ConfigurationUtility.AppSettings<string>("MemcachedIp2", "124.172.232.48:8041");
private static MemcachedClient GetService(string dbName)
{
if (_mCaches.ContainsKey(dbName) && _mCaches[dbName] != null)
{
return(_mCaches[dbName]);
}
var ips = new string[] { ip };
/*
* if (!string.IsNullOrEmpty(ip2))
* {
* ips = new string[] { ip, ip2 };
* }*/
MemcachedClient.Setup(dbName, ips);
var _mCache = MemcachedClient.GetInstance(dbName);
_mCache.SendReceiveTimeout = 5000;
_mCache.ConnectTimeout = 5000;
_mCache.MinPoolSize = 1;
_mCache.MaxPoolSize = 100;
if (!_mCaches.ContainsKey(dbName))
{
_mCaches[dbName] = _mCache;
}
return(_mCache);
}
public MemCached(string cacheName, string servers, int sendReceiveTimeout, int connectTimeout, uint minPoolSize, uint maxPoolSize, string region, TimeSpan defaultExpirationTime)
{
try
{
try
{
MemcachedClient.Setup(cacheName, servers.Split(','));
}
catch (Exception e)
{
//LFFK.LogManager.Error(CacheConstants.Error_Init, e);
}
mc = MemcachedClient.GetInstance(cacheName);
mc.SendReceiveTimeout = sendReceiveTimeout;
mc.ConnectTimeout = connectTimeout;
mc.MinPoolSize = minPoolSize;
mc.MaxPoolSize = maxPoolSize;
mc.KeyPrefix = region;
CacheName = cacheName;
DefaultExpirationTime = defaultExpirationTime;
}
catch (Exception ex)
{
throw new Exception(Constants.Error_Data_InitConfigFailed, ex);
}
}
/// <summary>
/// 创建缓存池
/// </summary>
/// <param name="name">名称</param>
/// <param name="servers">服务器</param>
/// <param name="enable">是否可用</param>
public MemCache(string name, string[] servers, bool enable)
{
if (!MemcachedClient.Exists(name))
{
MemcachedClient.Setup(name, servers);
}
cache = MemcachedClient.GetInstance(name);
this.enable = enable;
}
public static MemcachedClient DefaultClient()
{
if (defaultInstance == null)
{
MemcachedClient.Setup(defaultCacheName, new string[] { "localhost" });
defaultInstance = MemcachedClient.GetInstance(defaultCacheName);
}
return(defaultInstance);
}
public Memcached(string name, string[] servers)
{
try
{
_Instance = MemcachedClient.GetInstance(name);
}
catch
{
MemcachedClient.Setup(name, servers);
_Instance = MemcachedClient.GetInstance(name);
}
}
public bool MemcacheClientInit()
{
MemcachedClient.Setup("BeITMemcached", new string[] { "127.0.0.1" });
MemcachedClient cache = MemcachedClient.GetInstance("BeITMemcached");
cache.SendReceiveTimeout = 5000;
cache.ConnectTimeout = 5000;
cache.MinPoolSize = 1;
cache.MaxPoolSize = 5;
return(true);
}
public CacheClient(string cachename, string host, string port)
{
this.port = port;
//MemcachedClient.Exists(cachename)
MemcachedClient.Setup(cachename, new string[] { host + ":" + port });
_cache = MemcachedClient.GetInstance(cachename);
//Console.WriteLine(_cache.Name);
//Change client settings to values other than the default like this:
_cache.SendReceiveTimeout = 5000;
_cache.ConnectTimeout = 5000;
_cache.MinPoolSize = 1;
_cache.MaxPoolSize = 5;
}
protected override void DoPrepare()
{
if (!MemcachedClient.Exists(cacheGroup))
{
MemcachedClient.Setup(cacheGroup, new[] { "172.16.85.52" });
}
client = MemcachedClient.GetInstance(cacheGroup);
client.KeyPrefix = cacheGroup + "_";
client.ConnectTimeout = 5000;
client.SendReceiveTimeout = 10000;
client.MinPoolSize = 1;
client.MaxPoolSize = 1;
}
//在构造函数中建造连接客户端
public BeITMemcacheTest()
{
string myConn = ConfigurationManager.AppSettings["memcache"].ToString();
string[] servers = new string[1];
servers[0] = myConn + ":11211";
if (!MemcachedClient.Exists("MyCache"))
{
MemcachedClient.Setup("MyCache", servers);
}
client = MemcachedClient.GetInstance("MyCache");
}
public void Setup()
{
ClearCache();
server = new MemcachedServer(IPAddress.Any, 33433);
if (MemcachedClient.Exists("default") == false)
{
MemcachedClient.Setup("default", new[] { "127.0.0.1:33433" });
}
client = MemcachedClient.GetInstance("default");
client.SendReceieveTimeout = 250000;
server.Start();
}
public bool MemcacheClientInit()
{
this.nosqlTb.Text += "MemcacheClient Init Started!\r\n";
MemcachedClient.Setup("BeITMemcached", new string[] { "127.0.0.1" });
MemcachedClient cache = MemcachedClient.GetInstance("BeITMemcached");
cache.SendReceiveTimeout = 5000;
cache.ConnectTimeout = 5000;
cache.MinPoolSize = 1;
cache.MaxPoolSize = 5;
this.nosqlTb.Text += "MemcacheClient Init End!\r\n";
return(true);
}
public MemcachedHelper(string instanceName, string memcachedHost)
{
this._MemcachedClient = null;
this._MemcachedConnectionHost = "";
if (string.IsNullOrWhiteSpace(memcachedHost))
{
throw new ArgumentNullException(memcachedHost, "连接地址配置不能为空");
}
if (string.IsNullOrWhiteSpace(instanceName))
{
throw new ArgumentNullException(instanceName, "实例名不能为空");
}
this._MemcachedClient = null;
if (!MemcachedClient.Exists(instanceName))
{
lock (_SyncRoot)
{
if (MemcachedClient.Exists(instanceName))
{
this._MemcachedClient = MemcachedClient.GetInstance(instanceName);
}
else
{
string str = "";
if (memcachedHost.Split(new char[] { '.' }).Count <string>() >= 4)
{
str = memcachedHost;
}
else
{
str = ConfigHelper.GetValue(memcachedHost);
if (string.IsNullOrWhiteSpace(str))
{
throw new ArgumentNullException(memcachedHost, "配置文件找不到此" + memcachedHost + "节点或此节点值不能为空");
}
}
this._MemcachedConnectionHost = str;
MemcachedClient.Setup(instanceName, str.Split(new char[] { ',' }));
this._MemcachedClient = MemcachedClient.GetInstance(instanceName);
this._MemcachedClient.SendReceiveTimeout = 0x1388;
this._MemcachedClient.MinPoolSize = 10;
this._MemcachedClient.MaxPoolSize = 0xf4240;
}
}
}
else
{
this._MemcachedClient = MemcachedClient.GetInstance(instanceName);
}
}
public MemcachedService(IConfiguration config, SchedulerService schedulerService)
{
_schedulerService = schedulerService;
_config = config;
try
{
MemcachedClient.Setup(_config["memcachedservername"], _config["memcachedservers"].Split(','));
}
catch (ConfigurationErrorsException e)
{
}
_memcachedClient = MemcachedClient.GetInstance(_config["memcachedservername"]);
}
MemcachedClient InitCache()
{
GXService providerService = ServiceFactory.GetGXServices().Get(GXServices.CACHE_SERVICE);
String address = providerService.Properties.Get("CACHE_PROVIDER_ADDRESS");
if (!String.IsNullOrEmpty(address))
{
MemcachedClient.Setup("instance", address.Split(',', ';', ' '));
}
else
{
MemcachedClient.Setup("instance", new string[] { "127.0.0.1:11211" });
}
return(MemcachedClient.GetInstance("instance"));
}
public IEnumerable <TestCaseData> Clients()
{
MemcachedClient.Reset();
MemcachedClient.Setup("default", new string[] { "localhost:11211" });
MemcachedClient.GetInstance("default").KeyPrefix = Guid.NewGuid().ToString();
MemcachedClient.SetupBinary("default-binary", new string[] { "localhost:11211" });
MemcachedClient.GetInstance("default-binary").KeyPrefix = Guid.NewGuid().ToString();
Assert.AreEqual(MemcachedClient.ProtocolType.Text, MemcachedClient.GetInstance("default").Protocol);
Assert.AreEqual(MemcachedClient.ProtocolType.Binary, MemcachedClient.GetInstance("default-binary").Protocol);
return(new List <TestCaseData>()
{
new TestCaseData(MemcachedClient.GetInstance("default")).SetName("Text Client"),
new TestCaseData(MemcachedClient.GetInstance("default-binary")).SetName("Binary Client")
});
}
/// <summary>
/// 获取缓存实例
/// </summary>
/// <returns>缓存实例</returns>
private MemcachedClient GetInstance()
{
MemcachedClient cache = null;
if (MemcachedClient.Exists(_instancename) == false)
{
MemcachedClient.Setup(_instancename, _serverlist.Split(','));
}
cache = MemcachedClient.GetInstance(_instancename);
cache.SendReceiveTimeout = _sendreceivetimeout;
cache.MinPoolSize = _minPoolSize;
cache.MaxPoolSize = _maxpoolsize;
return(cache);
}
public void initialize(string cacheName, string[] serverList)
{
try
{
//set cache expiration from config
double expiry;
double.TryParse(Utils.Utils.GetAppSetting(Constants.CONFIG_MEMCACHED_EXPIRY), out expiry);
cacheExpiry = TimeSpan.FromHours(expiry);
//set client
MemcachedClient.Setup(cacheName, serverList);
cache = BeIT.MemCached.MemcachedClient.GetInstance(cacheName);
}
catch (Exception exc)
{
//TODO: Log the error
}
}
/// <summary>
/// method for setup an instance.
/// </summary>
/// <param name="name">The name of the instance.</param>
/// <param name="servers">
/// A list of memcached servers in standard notation: host:port.
/// If port is omitted, the default value of 11211 is used.
/// Both IP addresses and host names are accepted, for example:
/// "localhost", "127.0.0.1", "cache01.example.com:12345", "127.0.0.1:12345", etc
/// </param>
/// <returns></returns>
public bool Setup(string name, IEnumerable <string> servers)
{
try
{
memcleintName = name;
MemcachedClient.Setup(name, servers.ToArray());
MemcachedClient client = MemcachedClient.GetInstance(name);
client.SendReceiveTimeout = 5000; //设置接收发送连接超时时间
client.MinPoolSize = 1; //连接池
client.MaxPoolSize = 10;
return(true);
}
catch (Exception ex)
{
Log4netHelper.Error("设置memcached客户端失败：" + ex);
return(false);
}
}
internal MemcachedClient GetMemcachedClient(string groupName)
{
lock (lockObj)
{
if (!MemcachedClient.Exists(groupName))
{
MemcachedClient.Setup(groupName, servers);
}
MemcachedClient client = MemcachedClient.GetInstance(groupName);
client.KeyPrefix = groupName + "_";
client.ConnectTimeout = 5000;
client.SendReceiveTimeout = 10000;
client.MinPoolSize = 1;
client.MaxPoolSize = 1;
return(client);
}
}
protected override void InitInternal(CacheSetting setting)
{
base.InitInternal(setting);
var memcachedName = this.CacheName;
string keyPrefix = null;
if (setting != null)
{
if (!string.IsNullOrEmpty(setting.CacheInstanceName))
{
memcachedName = setting.CacheInstanceName;
}
keyPrefix = setting.KeyPrefix;
if (!string.IsNullOrEmpty(setting.Servers))
{
MemcachedClient.Setup(memcachedName, setting.Servers.Split(','));
}
}
this.MemcachedClientInstance = MemcachedClient.GetInstance(memcachedName);
this.MemcachedClientInstance.KeyPrefix = keyPrefix;
}
public MemcachedQueue(string queueName, string[] serverList, MemcachedConfig config = null)
{
m_QueueName = queueName;
serverList = serverList.BubbleSort();
string k = string.Join(",", serverList);
if (MemcachedClient.Exists(k) == false)
{
MemcachedClient.Setup(k, serverList);
}
m_Client = MemcachedClient.GetInstance(k);
if (config != null)
{
if (config.SendReceiveTimeout.HasValue)
{
m_Client.SendReceiveTimeout = config.SendReceiveTimeout.Value;
}
if (config.ConnectTimeout.HasValue)
{
m_Client.ConnectTimeout = config.ConnectTimeout.Value;
}
if (config.MinPoolSize.HasValue)
{
m_Client.MinPoolSize = config.MinPoolSize.Value;
}
if (config.MaxPoolSize.HasValue)
{
m_Client.MaxPoolSize = config.MaxPoolSize.Value;
}
if (config.SocketRecycleAge.HasValue)
{
m_Client.SocketRecycleAge = config.SocketRecycleAge.Value;
}
if (config.CompressionThreshold.HasValue)
{
m_Client.CompressionThreshold = config.CompressionThreshold.Value;
}
}
}
void InitMemCache(string host) //ip:poart
{
//以下代码，要以具体使用的 Memcached Client 来处理
//
string[] servers = { host };
//缓存服务设置，配置优先级高，无配置使用默认值
if (!MemcachedClient.Exists(host))
{
MemcachedClient.Setup(host, servers);
}
//实例化
_cache = MemcachedClient.GetInstance(host);
//检查缓存服务是否开启
_cache.SendReceiveTimeout = 1000;
_cache.MinPoolSize = 10;
_cache.MaxPoolSize = 100;
}
public DistributedAlbianCached(string name, string[] servers)
{
_name = name;
MemcachedClient.Setup(name, servers);
_client = MemcachedClient.GetInstance(name);
}
