public void Remove(CacheConfig cacheConfig, object state = null)
{
CacheUtil.MegreConfig(cacheConfig);
var key = CacheUtil.GetName(cacheConfig, state);
RemoveCache(key);
}
public TReturnData GetAndAddData <TReturnData>(CacheConfig cacheConfig, Func <TReturnData> getData, object state = null)
{
CacheUtil.MegreConfig(cacheConfig);
var key = CacheUtil.GetName(cacheConfig, state);
return(GetAndAddData(key, cacheConfig.Duration.GetValueOrDefault(), getData, cacheConfig.DependencyKeys));
}
/// <summary>
/// 添加缓存
/// </summary>
/// <param name="services"></param>
/// <param name="cfg"></param>
/// <returns></returns>
public static IServiceCollection AddCache(this IServiceCollection services, IConfiguration cfg)
{
var config = new CacheConfig();
var section = cfg.GetSection("Cache");
section?.Bind(config);
services.AddSingleton(config);
if (!config.IsEnabled) // 如果未启用缓存
{
return(services);
}
var assembly = AssemblyHelper.LoadByNameEndString($"Cache.{config.Provider}");
Check.NotNull(assembly, $"缓存实现程序集({config.Provider})未找到");
var handlerType = assembly.GetTypes().FirstOrDefault(m => typeof(ICacheHandler).IsAssignableFrom(m));
if (handlerType != null)
{
services.AddSingleton(typeof(ICacheHandler), handlerType);
}
return(services);
}
// This method gets called by the runtime. Use this method to add services to the container.
public void ConfigureServices(IServiceCollection services)
{
services.AddMemoryCache();
services.AddMvc();
IConfigurationBuilder builder = new ConfigurationBuilder()
.SetBasePath(this.HostingEnvironment.ContentRootPath)
.AddJsonFile("appsettings.json", optional: true, reloadOnChange: true)
.AddJsonFile($"appsettings.{this.HostingEnvironment.EnvironmentName}.json", optional: true)
.AddEnvironmentVariables();
var config = builder.Build();
CacheConfig _cacheProvider = new CacheConfig();
config.GetSection(nameof(CacheConfig)).Bind(_cacheProvider);
if (_cacheProvider.RedisEnable)
{
//Use Redis
services.AddSingleton(typeof(ICacheService), new RedisCacheService(new RedisCacheOptions
{
Configuration = _cacheProvider.ConnectionString,
InstanceName = _cacheProvider.InstanceName
}));
}
else
{
//Use MemoryCache
services.AddSingleton <IMemoryCache>(factory => new MemoryCache(new MemoryCacheOptions()));
services.AddSingleton <ICacheService, MemoryCacheService>();
}
}
private void _addObjetoSeguridad()
{
try
{
// Login
string strClaveSeg = "#_OASis2006_#";
CommonServices.Seguridad seg = new CommonServices.Seguridad();
string fLogin = seg.Encriptar(strClaveSeg, System.Configuration.ConfigurationManager.AppSettings["OAS_SitioWebLogin"]);
string fPassword = seg.Encriptar(strClaveSeg, System.Configuration.ConfigurationManager.AppSettings["OAS_SitioWebPassword"]);
this.LoginCache = new OAS_Seguridad.Cliente.OASisLogin(fLogin,
fPassword,
false);
this.LoginCache.LoginUser();
if (this.LoginCache.Authorized == false)
{
CacheConfig.Remove("OASisLogin");
throw new System.Security.SecurityException("Acceso no autorizado", null as Exception);
}
}catch (Exception ex)
{
Errores err = new Errores();
err.SetError(ex, "_addObjetoSeguridad");
}
}
public static ICacheProvider BuildCacheProviderWithTraceLogging(this CacheConfig config)
{
var logger = new Logger(config);
var components = BuildComponents(config, logger);
return(new CacheProvider(components.Cache, logger, config, components.DependencyManager, components.FeatureSupport));
}
public DaemonConfig(Version version, CommunicationConfig communication, CacheConfig cache, PathsConfig paths)
{
this.Version = version;
this.Communication = communication;
this.Cache = cache;
this.Paths = paths;
}
private ICache GetCache(CacheConfig config)
{
ICache cache = null;
var normalisedCacheToUse = !string.IsNullOrWhiteSpace(config.CacheToUse) ? config.CacheToUse.ToLowerInvariant() : string.Empty;
switch (normalisedCacheToUse)
{
case CacheTypes.MemoryCache:
cache = new MemoryCacheAdapter(_logger);
break;
case CacheTypes.WebCache:
cache = new WebCacheAdapter(_logger);
break;
case CacheTypes.AppFabricCache:
cache = new AppFabricCacheAdapter(_logger, config);
break;
case CacheTypes.memcached:
cache = new memcachedAdapter(_logger, config);
break;
case CacheTypes.redis:
cache = new RedisCacheAdapter(_logger, config);
break;
default:
cache = new MemoryCacheAdapter(_logger);
break;
}
return(cache);
}
private void btnSave_Click(object sender, EventArgs e)
{
string strReturnMsg = CheckInput();
if (strReturnMsg != string.Empty)
{
MessageBox.Show(strReturnMsg);
return;
}
//新增
if (m_CacheConfig == null)
{
string strTableNameValueNew = cboEditTableName.SelectedValue.ToString().Trim();
if (m_CacheConfigDAL.CalcCount("TableName='" + strTableNameValueNew + "'") > 0)
{
MessageBox.Show(@"表名已经存在");
return;
}
CacheConfig model = EntityOperateManager.AddEntity <CacheConfig>(this.tabPage);
model.CacheChekGuid = Guid.NewGuid().ToString();
model.CacheTableName = Guid.NewGuid().ToString();
int intReturn = m_CacheConfigDAL.Add(model);
if (intReturn > 0)
{
MessageBox.Show(@"添加成功");
model.Id = intReturn;
m_lstCacheConfig.Add(model);
ListCacheConfig = m_lstCacheConfig;
this.DialogResult = DialogResult.OK;
}
else
{
MessageBox.Show(@"添加失败");
}
}
//修改
else
{
string strTableNameValueEdit = cboEditTableName.SelectedValue.ToString().Trim();
if (m_CacheConfigDAL.CalcCount(" Id !=" + m_CacheConfig.Id + " and TableName='" + strTableNameValueEdit + "'") > 0)
{
MessageBox.Show(@"表名已经存在");
return;
}
m_CacheConfig = EntityOperateManager.EditEntity(this.tabPage, m_CacheConfig);
bool blnReturn = m_CacheConfigDAL.Update(m_CacheConfig);
if (blnReturn)
{
MessageBox.Show(@"修改成功");
ListCacheConfig = m_lstCacheConfig;
this.DialogResult = DialogResult.OK;
}
else
{
MessageBox.Show(@"修改失败");
}
}
}
private static void ExtractServerNodesFromConfig(CacheConfig config)
{
// Here we test to see if the old separator char is used.If not, we use the
// preferred one, otherwise we revert to the obsolete one (for backwards compatibility)
char separator = CacheConstants.ConfigDistributedServerSeparator;
if (config.DistributedCacheServers.Contains(CacheConstants.ConfigDistributedServerSeparatorObsolete))
{
separator = CacheConstants.ConfigDistributedServerSeparatorObsolete;
}
var endPointList = config.DistributedCacheServers.Split(separator);
if (endPointList.Length == 0)
{
return;
}
foreach (var endpoint in endPointList)
{
var endPointComponents = endpoint.Split(CacheConstants.ConfigDistributedServerPortSeparator);
if (endPointComponents.Length < 2)
{
continue;
}
int port;
if (int.TryParse(endPointComponents[1], out port))
{
var cacheEndpoint = new ServerNode(endPointComponents[0], port);
config.ServerNodes.Add(cacheEndpoint);
}
}
}
/// <summary>编辑
///
/// </summary>
private void DoEdit()
{
string strMsg = CheckSelect("修改");
if (strMsg != string.Empty)
{
MessageBox.Show(strMsg);
return;
}
DataGridViewRow drRowEdit = grdData.SelectedRows[0];
CacheConfig model = drRowEdit.Tag as CacheConfig;
if (model == null)
{
int intKeyID = int.Parse(drRowEdit.Cells[gridmrzId.Name].Value.ToString());
model = m_CacheConfigDAL.GetModel(intKeyID);
}
if (model != null)
{
FrmCacheConfigSimpleDialog frmDialog = new FrmCacheConfigSimpleDialog(model, m_lstCacheConfig);
if (frmDialog.ShowDialog() == DialogResult.OK)
{
m_lstCacheConfig = frmDialog.ListCacheConfig;
grdData.DataSource = m_lstCacheConfig;
grdData.Refresh();
}
}
}
public bool updateConfigCache(CacheConfig info)
{
bool result = true;
DocsPaUtils.Query q = DocsPaUtils.InitQuery.getInstance().getQuery("U_CONFIG_CACHE");
q.setParam("idAmministrazione", "'" + info.idAmministrazione + "'");
if (info.caching)
{
q.setParam("caching", "1");
}
else
{
q.setParam("caching", "0");
}
q.setParam("massima_dimensione_caching", info.massima_dimensione_caching.ToString());
q.setParam("massima_dimensione_file", info.massima_dimensione_file.ToString());
q.setParam("doc_root_server", "'" + info.doc_root_server + "'");
q.setParam("ora_inizio_cache", "'" + info.ora_inizio_cache + "'");
q.setParam("ora_fine_cache", "'" + info.ora_fine_cache + "'");
q.setParam("urlwscaching", "'" + info.urlwscaching + "'");
q.setParam("urlwscachinglocale", "'" + info.url_ws_caching_locale + "'");
q.setParam("doc_root_server_locale", "'" + info.doc_root_server_locale + "'");
string sql = q.getSQL();
logger.Debug("updateConfigCache - query: " + sql);
if (!this.ExecuteNonQuery(sql))
{
result = false;
throw new Exception();
}
return(result);
}
private ICacheDependencyManager GetCacheDependencyManager(CacheConfig config, ICache cache)
{
ICacheDependencyManager dependencyMgr = null;
var normalisedDependencyManagerConfig = !string.IsNullOrWhiteSpace(config.DependencyManagerToUse) ? config.DependencyManagerToUse.ToLowerInvariant() : string.Empty;
switch (normalisedDependencyManagerConfig)
{
case CacheDependencyManagerTypes.Default:
dependencyMgr = GetRedisCacheDependencyManagerIfApplicable(config, cache);
break;
case CacheDependencyManagerTypes.Redis:
dependencyMgr = GetRedisCacheDependencyManagerIfApplicable(config, cache);
break;
case CacheDependencyManagerTypes.Generic:
dependencyMgr = new GenericDependencyManager(cache, _logger, config);
break;
case CacheDependencyManagerTypes.Unspecified:
// try and determine what one to use based on the cache type
dependencyMgr = GetRedisCacheDependencyManagerIfApplicable(config, cache);
break;
default:
dependencyMgr = new GenericDependencyManager(cache, _logger, config);
break;
}
return(dependencyMgr);
}
public SignalCharting(ISignalChart chartControl, TickerType tickerType, BarItemType barType, object dataStreamSource)
{
this.dataStreamSource = dataStreamSource;
this.tickerType = tickerType;
this.barType = barType;
this.chartControl = chartControl;
this.registeredAnalytics = new List <AnalyticsItem>();
SharedCacheFactory.Instance.CacheWriter = new FileCacheWriter("cache");
SharedCacheFactory.Instance.CacheReader = new FileCacheReader("cache");
if (dataStreamSource is string)
{
FileInfo file = new FileInfo(dataStreamSource.ToString());
long fileHash = file.Attributes.GetHashCode() ^ file.CreationTime.Ticks ^ file.LastWriteTime.Ticks ^ file.Length;
CacheConfig cacheConfig = new CacheConfig("cache");
cacheConfig.Initialize();
cacheConfig.Open(CachingModeOption.Reading);
CacheRow row = cacheConfig.Read(fileHash);
cacheConfig.Close();
if (row == null)
{
cacheConfig.Open(CachingModeOption.Writing);
cacheId = Guid.NewGuid();
cacheConfig.Append(fileHash, cacheId, SessionModeOption.Backtesting);
cacheConfig.Close();
}
else
{
cacheId = new Guid((byte[])row["SessionId"]);
}
}
}
static void Main(string[] args)
{
CacheConfig config = new CacheConfig();
//config.LoadConfig("");
config.CacheTime = 1800;
config.Policy = CachePolicy.FIFO;
config.PersPolicy = PersistencePolicy.Expire;
ICache <int, int> cache = CacheFactory <int, int> .Create(config);
cache.CacheRemoveListener += Cache_CacheRemoveListener;
for (int i = 0; i < 10; i++)
{
Task.Factory.StartNew(() =>
{
int num = i * 10;
for (int j = num; j < num + 10000; j++)
{
cache.Add(j, j);
}
});
}
Thread.Sleep(10000);
int reslut = 0;
if (cache.TryGetCache(10020, out reslut))
{
Console.WriteLine(reslut);
}
Console.Read();
}
public AppFabricCacheAdapter(ILogging logger, CacheConfig config = null)
{
_logger = logger;
_factory = new AppFabricCacheFactory(_logger, config);
_cache = _factory.ConstructCache();
}
static CacheService()
{
if (_G.EnabledCache == false && _G.RefurbishCache == false)
return;
DefaultCache = new CacheConfig();
DefaultCache.Enabled = true;
DefaultCache.Address = "ch5Live";
DefaultCache.Port = "11211";
DefaultCache.MinPoolSize = 10;
DefaultCache.MaxPoolSize = 100;
DefaultCache.ConnectionTimeout = 1000;
COMMONT = Get("Live", "Commont2", 60 * 30, false);
CHECK_INFO = Get("Live", "Check_INFO2", 60 * 30, false);
UserExt = Get("Live", "UserExt2", 60 * 30, false);
Message = Get("Live", "Message2", 60 * 10, false);
Topic = Get("Live", "Topic2", 60 * 10, false);
Mall = Get("Mall", "m", 60 * 5, false);
Snapup = Get("Snapup", "s", 60 * 5, false);
}
/// <summary>
/// Application Start
/// </summary>
protected void Application_Start()
{
log4net.Config.XmlConfigurator.Configure();
LogService.Instance.SetApplicationVariables(DomainApplicationService.Instance.MachineName, DomainApplicationService.Instance.ApplicationCode);
LogService.Instance.Log.InfoFormat("Global.asax Application_Start() Called.");
DomainApplicationService.Instance.IOCContainer = new ClientBootstrapper().Run();
GlobalConfiguration.Configure(WebApiConfig.Register);
AreaRegistration.RegisterAllAreas();
RouteConfig.RegisterRoutes(RouteTable.Routes);
BundleConfig.RegisterBundles(BundleTable.Bundles);
EntityConfig.Register();
CacheConfig.PreloadItems();
FilterConfig.RegisterGlobalFilters(GlobalFilters.Filters);
ModelBinderConfig.Register();
//
//If you want to ignore the certificate check when requesting an https resource, uncomment the following code.
//This is useful if your app connects uses https/ssl resources which dont have a cert issued by a valid
//signing authority.
//This should probably never be uncommented in a production app though. Its here for reference in case its needed.
//
//ServicePointManager.ServerCertificateValidationCallback = delegate
//{
// return true;
//};
}
static CacheConfig AutoConfigMaster()
{
string localHost = "localhost";
CacheConfig config = new CacheConfig();
//
// Master
//
config.MasterHostName = localHost;
config.MasterPortNumber = 7709;
config.Ring = new CacheRing();
//
// Listener
//
config.ListenerHostName = localHost;
config.ListenerIP = "127.0.0.1";
config.ListenerPortNumber = 7709;
config.IsMaster = true;
//
// Trace
//
config.IsTraceEnabled = false;
config.TraceFilePath = string.Format("D:\\CacheSupport\\Logs\\Master_{0}.txt", 7710);
return(config);
}
public static CacheFactoryComponentResult BuildComponents(this CacheConfig config, ILogging logger)
{
var resolver = new CacheAdapterResolver(logger);
var factory = resolver.GetCacheConstructionFactoryUsingConfig(config);
return(factory.CreateCacheComponents());
}
public static ICacheProvider GetCacheProvider()
{
var provider = CacheConfig.Create()
.BuildCacheProviderWithTraceLogging();
return(provider);
}
public CacheConfig getConfigurazioneCache(string idAmministrazione)
{
CacheConfig info = null;
DocsPaUtils.Query queryDef = DocsPaUtils.InitQuery.getInstance().getQuery("S_CONFIG_CACHE");
queryDef.setParam("idAmministrazione", "'" + idAmministrazione + "'");
logger.Debug("getConfigurazioneCache - query :" + queryDef.getSQL());
string commandText = queryDef.getSQL();
using (DocsPaDB.DBProvider dbProvider = new DocsPaDB.DBProvider())
{
using (System.Data.IDataReader reader = dbProvider.ExecuteReader(commandText))
{
if (reader != null)
{
while (reader.Read())
{
info = new CacheConfig();
info.caching = reader.GetInt32(reader.GetOrdinal("CACHING")) == 1 ? true : false;
info.doc_root_server = reader.GetString(reader.GetOrdinal("DOC_ROOT_SERVER"));
info.massima_dimensione_caching = reader.GetDouble(reader.GetOrdinal("MASSIMA_DIMENSIONE_CACHING"));
info.massima_dimensione_file = reader.GetDouble(reader.GetOrdinal("MASSIMA_DIMENSIONE_FILE"));
info.idAmministrazione = reader.GetString(reader.GetOrdinal("idAmministrazione"));
info.ora_fine_cache = reader.GetString(reader.GetOrdinal("ORA_FINE_CACHE"));
info.ora_inizio_cache = reader.GetString(reader.GetOrdinal("ORA_INIZIO_CACHE"));
info.urlwscaching = reader.GetString(reader.GetOrdinal("urlwscaching"));
info.url_ws_caching_locale = reader.GetString(reader.GetOrdinal("url_ws_caching_locale"));
info.doc_root_server_locale = reader.GetString(reader.GetOrdinal("doc_root_server_locale"));
}
}
}
}
return(info);
}
/// <summary>
/// Initialise the container with core dependencies. The cache/cache provider should be set to be
/// singletons if adapting to use with a Dependency Injection mechanism
/// </summary>
/// <remarks>Note: In a .Net 4 web app, this method could be invoked using the new PreApplicationStartMethod attribute
/// as in: <code>[assembly: PreApplicationStartMethod(typeof(MyStaticClass), "PreStartInitialise")]</code>
/// Also note this section should be replaced with the DependencyInjection container of choice. This
/// code simply acts as a cheap and simple utility mechanism for this without requiring a dependency on a
/// container that you dont like/use. You can opt to replace the ICacheAdapterResolver with
/// your resolver of choice as well to utilise your own dependency resolution mechanism.
/// </remarks>
public static void PreStartInitialise(ILogging logger = null, CacheConfig config = null, ICacheAdapterResolver resolver = null)
{
if (!_isInitialised)
{
lock (_lockRef)
{
if (!_isInitialised)
{
try
{
_cacheProvider = CacheBinder.ResolveCacheFromConfig(config, logger, resolver);
CacheBinder.Logger.WriteInfoMessage(string.Format("Initialised cache of type: {0}", CacheBinder.Configuration.CacheToUse));
_cache = _cacheProvider.InnerCache;
_isInitialised = true;
}
catch (Exception ex)
{
var outerEx = new ApplicationException(string.Format("Problem initialising cache of type: {0}", CacheBinder.Configuration.CacheToUse), ex);
CacheBinder.Logger.WriteException(outerEx);
throw outerEx;
}
}
}
}
}
public void Custom_config_build_key_then_valid()
{
var config = new CacheConfig(pattern: "{key}:{region}");
var key = config.BuildCacheKey("r", "k");
Assert.AreEqual(key, "k:r");
}
internal void MapSettingsFromConfigToAppFabricSettings(CacheConfig config, DataCacheFactoryConfiguration factoryConfig)
{
SetSecuritySettings(config, factoryConfig);
SetMaxConnectionsToServer(config, factoryConfig);
SetChannelOpenTimeout(config, factoryConfig);
SetLocalCacheConfiguration(config, factoryConfig);
}
public AppConfig()
{
Azure = new AzureConfig();
Database = new DatabaseConfig();
Logging = new LoggingConfig();
Cache = new CacheConfig();
}
public override string GetKey(CacheConfig config, object state)
{
IContext context = (IContext)state;
var prefix = GetRealText(config.KeyPrefix, context);
var key = GetRealText(config.Key, context);
return(BuildKey(prefix, key));
}
public Logger(CacheConfig config = null)
{
if (config == null)
{
config = new CacheConfig();
}
_config = config;
}
public UserConfig(string activeRelease, DatabasesConfig databases, EnvironmentVariablesConfig environmentVariables, CacheConfig cache, BeepsConfig beeps)
{
mActiveRelease = activeRelease;
mDatabases = databases;
mEnvironmentVariables = environmentVariables;
mCache = cache;
mBeeps = beeps;
}
/// <summary>
/// Construct the ICacheProvider implementation using the configuration provided, the
/// logging implementation provided, and the cache adapter resolver provided. If
/// any of these items are passed as null, the existing values/settings are used. If there
/// are no existing settings, then the default implementation is used.
/// </summary>
/// <param name="config">Configuration to use when creating the cache engine. if NULL
/// is passed in, then the configuration is created based on values in the configuration file.</param>
/// <param name="logger">The logging implementation to use. If NULL is provided, then the
/// generic logging implementation is used.</param>
/// <param name="resolver">The CacheAdapter resolver to use. If NULL is provided, the
/// default resolver is used. You would typically provided your own resolver if you
/// wanted to use different dependency resolution engines such as Ninject or Autofac which
/// provide much richer lifetime support.</param>
/// <returns></returns>
public static ICacheProvider ResolveCacheFromConfig(CacheConfig config, ILogging logger = null, ICacheAdapterResolver resolver = null)
{
_config = config;
_logger = logger;
_resolver = resolver;
EnsureObjectPropertiesAreValidObjects();
return(_resolver.ResolveCacheFromConfig(_config));
}
public static CacheConfig UsingDistributedServerNodes(this CacheConfig config, IEnumerable <string> nodeAddresses)
{
nodeAddresses.ToList().ForEach(n =>
{
AddServerNodeIfNotPresent(config, n);
});
return(config);
}
private void dataNavigator_PositionChanged(object sender, EventArgs e)
{
if (dataNavigator.ListInfo == null)
{
return;
}
m_CacheConfig = m_lstCacheConfig[this.dataNavigator.CurrentIndex];
DisplayData(m_CacheConfig);
}
public MemoryCache[] CreateCache(CacheConfig[] configuration)
{
var result = new List<MemoryCache>(configuration.Length);
foreach (var config in configuration)
{
result.Add(new MemoryCache(config.Region, config.Properties));
}
return result.ToArray();
}
public Dictionary<string, CacheConfig> Read()
{
Dictionary<String, CacheConfig> dic = new Dictionary<string, CacheConfig>();
try
{
string path = System.IO.Path.Combine(AppDomain.CurrentDomain.BaseDirectory, "CacheConfig.xml");
if (!System.IO.File.Exists(path))
path = System.IO.Path.Combine(AppDomain.CurrentDomain.BaseDirectory, @"bin\CacheConfig.xml");
if (!System.IO.File.Exists(path))
return dic;
XElement tables = XElement.Load(path);
var list = tables.Descendants("Table");
foreach (var item in list)
{
var name = GetName(item);
if (name != "")
{
var cacheConfig = new CacheConfig();
cacheConfig.Name = name;
cacheConfig.CacheMode = GetCacheMode(item);
if (cacheConfig.CacheMode == CacheMode.OnFind)
cacheConfig.Size = GetSize(item);
else
cacheConfig.Size = 0;
cacheConfig.SortBy = GetExpression(item);
cacheConfig.Predicate = GetPredicate(item);
dic.Add(name, cacheConfig);
}
}
}
catch
{
dic = new Dictionary<string, CacheConfig>();
}
return dic;
}
public GarbageCollectContext(CacheConfig cacheConfig, bool dryRun, ILog log)
{
mCacheConfig = cacheConfig;
mDryRun = dryRun;
mLog = log;
}