/// <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); }