public override CacheDependency GetCacheDependency(
string virtualPath,
IEnumerable virtualPathDependencies,
DateTime utcStart)
{
if (virtualPath.Contains("App_Themes/default"))
{
String pathToDependencyFile = CacheHelper.GetPathToThemeCacheDependencyFile();
String pathToThemeFile = SiteUtils.GetFullPathToThemeFile();
if(pathToDependencyFile != null)
{
AggregateCacheDependency dependency = new AggregateCacheDependency();
dependency.Add(new CacheDependency(pathToDependencyFile));
try
{
dependency.Add(new CacheDependency(pathToThemeFile));
}
catch (HttpException)
{ // this can happen if the site is configured for a skin that doesn't exist
}
return dependency;
}
}
return base.GetCacheDependency(virtualPath, virtualPathDependencies, utcStart);
}
protected virtual void SaveDataToCacheInternal(string key, object data, CacheDependency dependency)
{
if (string.IsNullOrEmpty(key))
{
throw new ArgumentNullException("key");
}
if (!this.Enabled)
{
throw new InvalidOperationException(System.Web.SR.GetString("DataSourceCache_CacheMustBeEnabled"));
}
DateTime noAbsoluteExpiration = Cache.NoAbsoluteExpiration;
TimeSpan noSlidingExpiration = Cache.NoSlidingExpiration;
switch (this.ExpirationPolicy)
{
case DataSourceCacheExpiry.Absolute:
noAbsoluteExpiration = DateTime.UtcNow.AddSeconds((this.Duration == 0) ? ((double) 0x7fffffff) : ((double) this.Duration));
break;
case DataSourceCacheExpiry.Sliding:
noSlidingExpiration = TimeSpan.FromSeconds((double) this.Duration);
break;
}
AggregateCacheDependency dependencies = new AggregateCacheDependency();
string[] cachekeys = null;
if (this.KeyDependency.Length > 0)
{
cachekeys = new string[] { this.KeyDependency };
dependencies.Add(new CacheDependency[] { new CacheDependency(null, cachekeys) });
}
if (dependency != null)
{
dependencies.Add(new CacheDependency[] { dependency });
}
HttpRuntime.CacheInternal.UtcInsert(key, data, dependencies, noAbsoluteExpiration, noSlidingExpiration);
}
internal override void CacheBuildResult(string cacheKey, BuildResult result, long hashCode, DateTime utcStart)
{
if (!BuildResultCompiledType.UsesDelayLoadType(result))
{
ICollection virtualPathDependencies = result.VirtualPathDependencies;
CacheDependency dependencies = null;
if (virtualPathDependencies != null)
{
dependencies = result.VirtualPath.GetCacheDependency(virtualPathDependencies, utcStart);
if (dependencies != null)
{
result.UsesCacheDependency = true;
}
}
if (result.CacheToMemory)
{
CacheItemPriority normal;
BuildResultCompiledAssemblyBase base2 = result as BuildResultCompiledAssemblyBase;
if (((base2 != null) && (base2.ResultAssembly != null)) && !base2.UsesExistingAssembly)
{
string assemblyCacheKey = BuildResultCache.GetAssemblyCacheKey(base2.ResultAssembly);
Assembly assembly = (Assembly) this._cache.Get(assemblyCacheKey);
if (assembly == null)
{
this._cache.UtcInsert(assemblyCacheKey, base2.ResultAssembly, null, Cache.NoAbsoluteExpiration, Cache.NoSlidingExpiration, CacheItemPriority.NotRemovable, null);
}
CacheDependency dependency2 = new CacheDependency(0, null, new string[] { assemblyCacheKey });
if (dependencies != null)
{
AggregateCacheDependency dependency3 = new AggregateCacheDependency();
dependency3.Add(new CacheDependency[] { dependencies, dependency2 });
dependencies = dependency3;
}
else
{
dependencies = dependency2;
}
}
string memoryCacheKey = GetMemoryCacheKey(cacheKey);
if (result.IsUnloadable)
{
normal = CacheItemPriority.Normal;
}
else
{
normal = CacheItemPriority.NotRemovable;
}
CacheItemRemovedCallback onRemoveCallback = null;
if (result.ShutdownAppDomainOnChange || (result is BuildResultCompiledAssemblyBase))
{
if (this._onRemoveCallback == null)
{
this._onRemoveCallback = new CacheItemRemovedCallback(this.OnCacheItemRemoved);
}
onRemoveCallback = this._onRemoveCallback;
}
this._cache.UtcInsert(memoryCacheKey, result, dependencies, result.MemoryCacheExpiration, result.MemoryCacheSlidingExpiration, normal, onRemoveCallback);
}
}
}
public void SingleDependency ()
{
string depFile = Path.Combine (_tempFolder, "dep.tmp");
AggregateCacheDependency aggregate = new AggregateCacheDependency ();
aggregate.Add (new CacheDependency (depFile));
DateTime absoluteExpiration = DateTime.Now.AddSeconds (4);
TimeSpan slidingExpiration = TimeSpan.Zero;
CacheItemPriority priority = CacheItemPriority.Default;
string original = "MONO";
HttpRuntime.Cache.Insert ("key", original, aggregate,
absoluteExpiration, slidingExpiration, priority,
null);
string cachedValue = HttpRuntime.Cache.Get ("key") as string;
Assert.IsNotNull (cachedValue, "#A1");
Assert.AreEqual ("MONO", cachedValue, "#A2");
Assert.IsFalse (aggregate.HasChanged, "#A3");
cachedValue = HttpRuntime.Cache.Get ("key") as string;
Assert.IsNotNull (cachedValue, "#B1");
Assert.AreEqual ("MONO", cachedValue, "#B2");
Assert.IsFalse (aggregate.HasChanged, "#B3");
File.WriteAllText (depFile, "OK", Encoding.UTF8);
Thread.Sleep (500);
cachedValue = HttpRuntime.Cache.Get ("key") as string;
Assert.IsNull (cachedValue, "#C1");
Assert.IsTrue (aggregate.HasChanged, "#C2");
}
//建立DataSet缓存的汇总依赖项
//将缓存与多个对相关联
void AddDependency()
{
//依赖项一，XML文件依赖项
CacheDependency fileDep = new CacheDependency(Server.MapPath("~/App_Data/Employees.xml"));
//依赖项二，Key依赖项
string[] keyDependencies = { "Company" };
CacheDependency keyDep = new CacheDependency(null, keyDependencies);
//聚合依赖项
AggregateCacheDependency aggDep = new AggregateCacheDependency();
aggDep.Add(fileDep); //加入文件依赖项
aggDep.Add(keyDep); //加入Key依赖项
Cache.Insert("Employees", dsEmployee, aggDep);
}
public void Insert(string key, object value, CacheDependency dependencies, DateTime absoluteExpiration, TimeSpan slidingExpiration, CacheItemUpdateCallback onUpdateCallback)
{
if (((dependencies == null) && (absoluteExpiration == NoAbsoluteExpiration)) && (slidingExpiration == NoSlidingExpiration))
{
throw new ArgumentException(System.Web.SR.GetString("Invalid_Parameters_To_Insert"));
}
if (onUpdateCallback == null)
{
throw new ArgumentNullException("onUpdateCallback");
}
DateTime utcAbsoluteExpiration = DateTimeUtil.ConvertToUniversalTime(absoluteExpiration);
this._cacheInternal.DoInsert(true, key, value, null, NoAbsoluteExpiration, NoSlidingExpiration, CacheItemPriority.NotRemovable, null, true);
string[] cachekeys = new string[] { key };
CacheDependency expensiveObjectDependency = new CacheDependency(null, cachekeys);
if (dependencies == null)
{
dependencies = expensiveObjectDependency;
}
else
{
AggregateCacheDependency dependency2 = new AggregateCacheDependency();
dependency2.Add(new CacheDependency[] { dependencies, expensiveObjectDependency });
dependencies = dependency2;
}
this._cacheInternal.DoInsert(false, "w" + key, new SentinelEntry(key, expensiveObjectDependency, onUpdateCallback), dependencies, utcAbsoluteExpiration, slidingExpiration, CacheItemPriority.NotRemovable, s_sentinelRemovedCallback, true);
}
//
// private helper methods
//
private static void AddCacheKeyToDependencies(ref CacheDependency dependencies, string cacheKey)
{
CacheDependency keyDep = new CacheDependency(0, null, new string[1] {
cacheKey
});
if (dependencies == null)
{
dependencies = keyDep;
}
else
{
// if it's not an aggregate, we have to create one because you can't add
// it to anything but an aggregate
AggregateCacheDependency agg = dependencies as AggregateCacheDependency;
if (agg != null)
{
agg.Add(keyDep);
}
else
{
agg = new AggregateCacheDependency();
agg.Add(keyDep, dependencies);
dependencies = agg;
}
}
}
/// <summary>
/// Creates a cache dependency based on the specified virtual paths.
/// </summary>
/// <param name="definition">The definition.</param>
/// <param name="virtualPath">The path to the primary virtual resource.</param>
/// <returns>
/// A <see cref="T:System.Web.Caching.CacheDependency"/> object for the specified virtual resources.
/// </returns>
public virtual CacheDependency GetCacheDependency(PathDefinition definition, string virtualPath, IEnumerable virtualPathDependencies, DateTime utcStart)
{
CacheDependency result = this.GetCurrentCacheDependency(definition, virtualPath, virtualPathDependencies, utcStart);
//If the requested file does not exist in the current resolver then keep these dependencies and add dependencies of the next resolver.
//This will allow the resolvers higher in the chain to be pinged again when the file might be available to them.
if (this.Next != null && !this.CurrentExists(definition, virtualPath))
{
var nextDependencies = this.Next.GetCacheDependency(definition, virtualPath, virtualPathDependencies, utcStart);
if (nextDependencies != null)
{
if (result != null)
{
var aggr = new AggregateCacheDependency();
aggr.Add(result, nextDependencies);
result = aggr;
}
else
{
result = nextDependencies;
}
}
}
return result;
}
public static CacheDependency CreateOutputCacheDependency(string dependency)
{
Sql7DependencyInfo info;
if (dependency == null)
{
throw new HttpException(System.Web.SR.GetString("Invalid_sqlDependency_argument", new object[] { dependency }));
}
if (StringUtil.EqualsIgnoreCase(dependency, "CommandNotification"))
{
HttpContext current = HttpContext.Current;
SqlCacheDependency dependency2 = new SqlCacheDependency();
current.SqlDependencyCookie = dependency2._sqlYukonDep.Id;
return(dependency2);
}
AggregateCacheDependency dependency3 = null;
ArrayList list = ParseSql7OutputCacheDependency(dependency);
if (list.Count == 1)
{
info = (Sql7DependencyInfo)list[0];
return(CreateSql7SqlCacheDependencyForOutputCache(info._database, info._table, dependency));
}
dependency3 = new AggregateCacheDependency();
for (int i = 0; i < list.Count; i++)
{
info = (Sql7DependencyInfo)list[i];
dependency3.Add(new CacheDependency[] { CreateSql7SqlCacheDependencyForOutputCache(info._database, info._table, dependency) });
}
return(dependency3);
}
//ContentListTypeId
//BinaryPropertyTypeIds
internal static CacheDependency CreateNodeDataDependency(NodeData nodeData)
{
if (nodeData == null)
{
throw new ArgumentNullException("nodeData");
}
var aggregateCacheDependency = new System.Web.Caching.AggregateCacheDependency();
aggregateCacheDependency.Add(
new NodeIdDependency(nodeData.Id),
new PathDependency(nodeData.Path),
//new VersionIdDependency(nodeData.VersionId),
new NodeTypeDependency(nodeData.NodeTypeId)
);
//Add cache dependency for resource files, if
//node data contains string resource keys.
if (SR.ResourceManager.Running)
{
var resourcePaths = new List <string>();
//deal with string properties only
foreach (var propertyType in nodeData.PropertyTypes.Where(propertyType => propertyType.DataType == Schema.DataType.String))
{
AddResourceDependencyIfNeeded(aggregateCacheDependency, nodeData.GetDynamicRawData(propertyType) as string, resourcePaths);
}
//display name is not a dynamic raw data, add it separately
AddResourceDependencyIfNeeded(aggregateCacheDependency, nodeData.DisplayName, resourcePaths);
}
return(aggregateCacheDependency);
}
public void Insert(string key, object value, CacheDependency dependencies, DateTime absoluteExpiration, TimeSpan slidingExpiration, CacheItemUpdateCallback onUpdateCallback)
{
if (((dependencies == null) && (absoluteExpiration == NoAbsoluteExpiration)) && (slidingExpiration == NoSlidingExpiration))
{
throw new ArgumentException(System.Web.SR.GetString("Invalid_Parameters_To_Insert"));
}
if (onUpdateCallback == null)
{
throw new ArgumentNullException("onUpdateCallback");
}
DateTime utcAbsoluteExpiration = DateTimeUtil.ConvertToUniversalTime(absoluteExpiration);
this._cacheInternal.DoInsert(true, key, value, null, NoAbsoluteExpiration, NoSlidingExpiration, CacheItemPriority.NotRemovable, null, true);
string[] cachekeys = new string[] { key };
CacheDependency expensiveObjectDependency = new CacheDependency(null, cachekeys);
if (dependencies == null)
{
dependencies = expensiveObjectDependency;
}
else
{
AggregateCacheDependency dependency2 = new AggregateCacheDependency();
dependency2.Add(new CacheDependency[] { dependencies, expensiveObjectDependency });
dependencies = dependency2;
}
this._cacheInternal.DoInsert(false, "w" + key, new SentinelEntry(key, expensiveObjectDependency, onUpdateCallback), dependencies, utcAbsoluteExpiration, slidingExpiration, CacheItemPriority.NotRemovable, s_sentinelRemovedCallback, true);
}
/// <summary>
/// Salva os dados para o cache.
/// </summary>
/// <param name="key"></param>
/// <param name="data"></param>
/// <param name="dependency"></param>
protected virtual void SaveDataToCacheInternal(string key, object data, CacheDependency dependency)
{
if (string.IsNullOrEmpty(key))
{
throw new ArgumentNullException("key");
}
if (!this.Enabled)
{
throw new InvalidOperationException("Cannot perform operation when cache is not enabled.");
}
DateTime noAbsoluteExpiration = System.Web.Caching.Cache.NoAbsoluteExpiration;
TimeSpan noSlidingExpiration = System.Web.Caching.Cache.NoSlidingExpiration;
switch (this.ExpirationPolicy)
{
case System.Web.UI.DataSourceCacheExpiry.Absolute:
noAbsoluteExpiration = DateTime.UtcNow.AddSeconds((this.Duration == 0) ? ((double)0x7fffffff) : ((double)this.Duration));
break;
case System.Web.UI.DataSourceCacheExpiry.Sliding:
noSlidingExpiration = TimeSpan.FromSeconds((double)this.Duration);
break;
}
var dependencies = new System.Web.Caching.AggregateCacheDependency();
string[] cachekeys = null;
if (this.KeyDependency.Length > 0)
{
cachekeys = new string[] {
this.KeyDependency
};
dependencies.Add(new CacheDependency[] {
new CacheDependency(null, cachekeys)
});
}
if (dependency != null)
{
dependencies.Add(new CacheDependency[] {
dependency
});
}
HttpRuntime.Cache.Insert(key, data, dependencies, noAbsoluteExpiration, noSlidingExpiration);
}
public void Create(DependencyCreateArgs args)
{
AggregateDependencyCreateArgs arg = (AggregateDependencyCreateArgs)args;
IDependencyWrapper[] wrappers = arg.Wrappers;
instance = new AggregateCacheDependency();
foreach (IDependencyWrapper wrapper in wrappers)
{
instance.Add((CacheDependency)wrapper.Instance);
}
}
private static CacheDependency CreateNodeDependency(int id, string path, int nodeTypeId)
{
var aggregateCacheDependency = new System.Web.Caching.AggregateCacheDependency();
aggregateCacheDependency.Add(
new NodeIdDependency(id),
new PathDependency(path),
new NodeTypeDependency(nodeTypeId)
);
return aggregateCacheDependency;
}
private static CacheDependency CreateNodeDependency(int id, string path, int nodeTypeId)
{
var aggregateCacheDependency = new System.Web.Caching.AggregateCacheDependency();
aggregateCacheDependency.Add(
new NodeIdDependency(id),
new PathDependency(path),
new NodeTypeDependency(nodeTypeId)
);
return(aggregateCacheDependency);
}
public static void SetToCache(object dataCache, string cacheName, string[] tableNameInDatabase)
{
System.Web.Caching.SqlCacheDependency[] sqlDep = new SqlCacheDependency[tableNameInDatabase.Length];
for (int i = 0; i < tableNameInDatabase.Length; i++)
{
sqlDep[i] = new System.Web.Caching.SqlCacheDependency(DATABASE_NAME, tableNameInDatabase[i]);
}
System.Web.Caching.AggregateCacheDependency agg = new System.Web.Caching.AggregateCacheDependency();
agg.Add(sqlDep);
HttpContext.Current.Cache.Insert(cacheName, dataCache, agg, DateTime.Now.AddDays(1), Cache.NoSlidingExpiration);
}
// DevDiv Bugs 162763:
// Add a an event that fires *before* an item is evicted from the ASP.NET Cache
public void Insert(
string key,
object value,
CacheDependency dependencies,
DateTime absoluteExpiration,
TimeSpan slidingExpiration,
CacheItemUpdateCallback onUpdateCallback)
{
if (dependencies == null && absoluteExpiration == Cache.NoAbsoluteExpiration && slidingExpiration == Cache.NoSlidingExpiration)
{
throw new ArgumentException(SR.GetString(SR.Invalid_Parameters_To_Insert));
}
if (onUpdateCallback == null)
{
throw new ArgumentNullException("onUpdateCallback");
}
DateTime utcAbsoluteExpiration = DateTimeUtil.ConvertToUniversalTime(absoluteExpiration);
// Insert updatable cache entry
ObjectCache.Insert(key, value, new CacheInsertOptions()
{
Priority = CacheItemPriority.NotRemovable
});
// Ensure the sentinel depends on its updatable entry
string[] cacheKeys = { key };
CacheDependency expensiveObjectDep = new CacheDependency(null, cacheKeys);
if (dependencies == null)
{
dependencies = expensiveObjectDep;
}
else
{
AggregateCacheDependency deps = new AggregateCacheDependency();
deps.Add(dependencies, expensiveObjectDep);
dependencies = deps;
}
// Insert sentinel entry for the updatable cache entry
HttpRuntime.Cache.InternalCache.Insert(
CacheInternal.PrefixValidationSentinel + key,
new SentinelEntry(key, expensiveObjectDep, onUpdateCallback),
new CacheInsertOptions()
{
Dependencies = dependencies,
AbsoluteExpiration = utcAbsoluteExpiration,
SlidingExpiration = slidingExpiration,
Priority = CacheItemPriority.NotRemovable,
OnRemovedCallback = Cache.s_sentinelRemovedCallback
});
}
public static void SetCache(DataTable dataCache, string cacheName, string[] tableNameInDatabase)
{
//System.Web.Caching.SqlCacheDependency sqlDep1 = new System.Web.Caching.SqlCacheDependency(Const.DATABASE_NAME, "tblTradeTransaction");
//System.Web.Caching.SqlCacheDependency sqlDep2 = new System.Web.Caching.SqlCacheDependency(Const.DATABASE_NAME, "tblRemainTransaction");
System.Web.Caching.SqlCacheDependency[] sqlDep = new SqlCacheDependency[tableNameInDatabase.Length];
for (int i = 0; i < tableNameInDatabase.Length; i++)
{
sqlDep[i] = new System.Web.Caching.SqlCacheDependency(DATABASE_NAME, tableNameInDatabase[i]);
}
System.Web.Caching.AggregateCacheDependency agg = new System.Web.Caching.AggregateCacheDependency();
//agg.Add(sqlDep1, sqlDep2);
agg.Add(sqlDep);
HttpContext.Current.Cache.Insert(cacheName, dataCache, agg, DateTime.Now.AddDays(1), Cache.NoSlidingExpiration);
}
internal static CacheDependency CreateNodeHeadDependency(NodeHead nodeHead)
{
if (nodeHead == null)
throw new ArgumentNullException("nodeHead", "NodeHead cannot be null.");
var aggregateCacheDependency = new System.Web.Caching.AggregateCacheDependency();
aggregateCacheDependency.Add(
new NodeIdDependency(nodeHead.Id),
new PathDependency(nodeHead.Path)
);
return aggregateCacheDependency;
}
public static EditorConfiguration GetConfig()
{
EditorConfiguration editorConfig = null;
if (
(HttpRuntime.Cache["mojoEditorConfig"] != null)
&& (HttpRuntime.Cache["mojoEditorConfig"] is EditorConfiguration)
)
{
return (EditorConfiguration)HttpRuntime.Cache["mojoEditorConfig"];
}
else
{
String configFileName = "mojoEditor.config";
if (ConfigurationManager.AppSettings["mojoEditorConfigFileName"] != null)
{
configFileName = ConfigurationManager.AppSettings["mojoEditorConfigFileName"];
}
if (!configFileName.StartsWith("~/"))
{
configFileName = "~/" + configFileName;
}
String pathToConfigFile = HttpContext.Current.Server.MapPath(configFileName);
XmlDocument configXml = new XmlDocument();
configXml.Load(pathToConfigFile);
editorConfig = new EditorConfiguration(configXml.DocumentElement);
AggregateCacheDependency aggregateCacheDependency = new AggregateCacheDependency();
aggregateCacheDependency.Add(new CacheDependency(pathToConfigFile));
System.Web.HttpRuntime.Cache.Insert(
"mojoEditorConfig",
editorConfig,
aggregateCacheDependency,
DateTime.Now.AddYears(1),
TimeSpan.Zero,
System.Web.Caching.CacheItemPriority.Default,
null);
return (EditorConfiguration)HttpRuntime.Cache["mojoEditorConfig"];
}
//return editorConfig;
}
//ContentListTypeId
//BinaryPropertyTypeIds
internal static CacheDependency CreateNodeDataDependency(NodeData nodeData)
{
if (nodeData == null)
throw new ArgumentNullException("nodeData");
var aggregateCacheDependency = new System.Web.Caching.AggregateCacheDependency();
aggregateCacheDependency.Add(
new NodeIdDependency(nodeData.Id),
new PathDependency(nodeData.Path),
//new VersionIdDependency(nodeData.VersionId),
new NodeTypeDependency(nodeData.NodeTypeId)
);
return aggregateCacheDependency;
}
internal static CacheDependency CreateNodeHeadDependency(NodeHead nodeHead)
{
if (nodeHead == null)
{
throw new ArgumentNullException("nodeHead", "NodeHead cannot be null.");
}
var aggregateCacheDependency = new System.Web.Caching.AggregateCacheDependency();
aggregateCacheDependency.Add(
new NodeIdDependency(nodeHead.Id),
new PathDependency(nodeHead.Path)
);
return(aggregateCacheDependency);
}
protected override void SaveDataToCacheInternal(string key, object data, CacheDependency dependency)
{
string[] array = new string[this.FileDependencies.Count];
this.FileDependencies.CopyTo(array, 0);
CacheDependency dependency2 = new CacheDependency(0, array);
if (dependency != null)
{
AggregateCacheDependency dependency3 = new AggregateCacheDependency();
dependency3.Add(new CacheDependency[] { dependency2, dependency });
dependency = dependency3;
}
else
{
dependency = dependency2;
}
base.SaveDataToCacheInternal(key, data, dependency);
}
//ContentListTypeId
//BinaryPropertyTypeIds
internal static CacheDependency CreateNodeDataDependency(NodeData nodeData)
{
if (nodeData == null)
{
throw new ArgumentNullException("nodeData");
}
var aggregateCacheDependency = new System.Web.Caching.AggregateCacheDependency();
aggregateCacheDependency.Add(
new NodeIdDependency(nodeData.Id),
new PathDependency(nodeData.Path),
//new VersionIdDependency(nodeData.VersionId),
new NodeTypeDependency(nodeData.NodeTypeId)
);
return(aggregateCacheDependency);
}
/// <devdoc>
/// Saves data to the ASP.NET cache using the specified key.
/// </devdoc>
protected override void SaveDataToCacheInternal(string key, object data, CacheDependency dependency) {
int fileCount = FileDependencies.Count;
string[] filenames = new string[fileCount];
FileDependencies.CopyTo(filenames, 0);
CacheDependency fileDependency = new CacheDependency(0, filenames);
if (dependency != null) {
// There was another dependency passed in, aggregate them
AggregateCacheDependency aggregateDependency = new AggregateCacheDependency();
aggregateDependency.Add(fileDependency, dependency);
dependency = aggregateDependency;
}
else {
// No other dependencies, just the file one
dependency = fileDependency;
}
base.SaveDataToCacheInternal(key, data, dependency);
}
protected override void SaveDataToCacheInternal(string key, object data, CacheDependency dependency)
{
string sqlCacheDependency = this.SqlCacheDependency;
if ((sqlCacheDependency.Length > 0) && !string.Equals(sqlCacheDependency, "CommandNotification", StringComparison.OrdinalIgnoreCase))
{
CacheDependency dependency2 = System.Web.Caching.SqlCacheDependency.CreateOutputCacheDependency(sqlCacheDependency);
if (dependency != null)
{
AggregateCacheDependency dependency3 = new AggregateCacheDependency();
dependency3.Add(new CacheDependency[] { dependency2, dependency });
dependency = dependency3;
}
else
{
dependency = dependency2;
}
}
base.SaveDataToCacheInternal(key, data, dependency);
}
public static CacheDependency CreateOutputCacheDependency(string dependency)
{
if (dependency == null)
{
throw new HttpException(InvalidDependencyFormatMessage(dependency));
}
if (dependency.Length == 0)
{
throw new ArgumentException(InvalidDependencyFormatMessage(dependency), "dependency");
}
int colon;
string[] pairs = dependency.Split(';');
var dependencies = new List <SqlCacheDependency> ();
foreach (string pair in pairs)
{
colon = pair.IndexOf(':');
if (colon == -1)
{
throw new ArgumentException(InvalidDependencyFormatMessage(dependency), "dependency");
}
dependencies.Add(new SqlCacheDependency(pair.Substring(0, colon), pair.Substring(colon + 1)));
}
switch (dependencies.Count)
{
case 0:
return(null);
case 1:
return(dependencies [0]);
default:
var acd = new AggregateCacheDependency();
acd.Add(dependencies.ToArray());
return(acd);
}
}
private static void AddCacheKeyToDependencies(ref CacheDependency dependencies, string cacheKey)
{
CacheDependency dependency = new CacheDependency(0, null, new string[] { cacheKey });
if (dependencies == null)
{
dependencies = dependency;
}
else
{
AggregateCacheDependency dependency2 = dependencies as AggregateCacheDependency;
if (dependency2 != null)
{
dependency2.Add(new CacheDependency[] { dependency });
}
else
{
dependency2 = new AggregateCacheDependency();
dependency2.Add(new CacheDependency[] { dependency, dependencies });
dependencies = dependency2;
}
}
}
public static Collection<WebPageInfo> GetPhysicalPages(
string fileExtensionPattern)
{
Collection<WebPageInfo> physicalPages = null;
string cachekey = "physicalwebpages" + fileExtensionPattern;
if (
(HttpContext.Current != null)
&& (HttpRuntime.Cache[cachekey] == null)
)
{
log.Debug("couldn't find cache item " + cachekey + " creating cache item now.");
physicalPages = LoadPhysicalPages(fileExtensionPattern);
AggregateCacheDependency aggregateCacheDependency = new AggregateCacheDependency();
aggregateCacheDependency.Add(new CacheDependency(HttpContext.Current.Server.MapPath("~/Web.config")));
DateTime absoluteExpiration = DateTime.Now.AddMinutes(WebConfigSettings.WebPageInfoCacheMinutes);
TimeSpan slidingExpiration = TimeSpan.Zero;
CacheItemPriority priority = CacheItemPriority.Default;
CacheItemRemovedCallback callback = null;
HttpRuntime.Cache.Insert(
cachekey,
physicalPages,
aggregateCacheDependency,
absoluteExpiration,
slidingExpiration,
priority,
callback);
}
physicalPages = HttpRuntime.Cache[cachekey] as Collection<WebPageInfo>;
return physicalPages;
}
private static void AddCacheKeyToDependencies(ref CacheDependency dependencies, string cacheKey)
{
CacheDependency dependency = new CacheDependency(0, null, new string[] { cacheKey });
if (dependencies == null)
{
dependencies = dependency;
}
else
{
AggregateCacheDependency dependency2 = dependencies as AggregateCacheDependency;
if (dependency2 != null)
{
dependency2.Add(new CacheDependency[] { dependency });
}
else
{
dependency2 = new AggregateCacheDependency();
dependency2.Add(new CacheDependency[] { dependency, dependencies });
dependencies = dependency2;
}
}
}
/// <devdoc>
/// Saves data to the ASP.NET cache using the specified key.
/// </devdoc>
protected override void SaveDataToCacheInternal(string key, object data, CacheDependency dependency) {
string sqlCacheDependency = SqlCacheDependency;
// Here we only create cache dependencies for SQL Server 2000 and
// earlier that use a polling based mechanism. For SQL Server 2005
// and after, the data source itself creates the SqlCacheDependency
// and passes it in as a parameter.
if (sqlCacheDependency.Length > 0 && !String.Equals(sqlCacheDependency, Sql9CacheDependencyDirective, StringComparison.OrdinalIgnoreCase)) {
// Call internal helper method to parse the dependency list
CacheDependency sqlDependency = System.Web.Caching.SqlCacheDependency.CreateOutputCacheDependency(sqlCacheDependency);
if (dependency != null) {
// There was another dependency passed in, aggregate them
AggregateCacheDependency aggregateDependency = new AggregateCacheDependency();
aggregateDependency.Add(sqlDependency, dependency);
dependency = aggregateDependency;
}
else {
// No other dependencies, just the SQL one
dependency = sqlDependency;
}
}
base.SaveDataToCacheInternal(key, data, dependency);
}
/// <summary>
/// Creates the cache item for the cache region which all other cache items in the region
/// will be dependent upon
/// </summary>
/// <remarks>
/// <para>Specified Region dependencies will be associated to the cache item</para>
/// </remarks>
private void CacheRootItem()
{
if (log.IsDebugEnabled)
{
log.DebugFormat("Creating root cache entry for cache region: {0}", _name);
}
//register ant cache dependencies for change notifications
//and build an aggragate dependency if multiple dependencies exist
CacheDependency rootCacheDependency = null;
if (_dependencyEnlisters.Count > 0)
{
var dependencies = new List<CacheDependency>(_dependencyEnlisters.Count);
foreach (ICacheDependencyEnlister enlister in _dependencyEnlisters)
{
log.Debug("Enlisting cache dependency for change notification");
dependencies.Add(enlister.Enlist());
}
if (dependencies.Count == 1)
{
rootCacheDependency = dependencies[0];
}
else
{
var jointDependency = new AggregateCacheDependency();
jointDependency.Add(dependencies.ToArray());
rootCacheDependency = jointDependency;
}
log.Debug("Attaching cache dependencies to root cache entry. Cache entry will be removed when change is detected.");
}
_webCache.Add(_rootCacheKey, _rootCacheKey, rootCacheDependency, System.Web.Caching.Cache.NoAbsoluteExpiration,
System.Web.Caching.Cache.NoSlidingExpiration, _priority, RootCacheItemRemovedCallback);
//flag the root cache item as beeing cached
_isRootItemCached = true;
}
/// <internalonly/>
/// <devdoc>
/// <para>[To be supplied.]</para>
/// </devdoc>
protected internal override void Render(HtmlTextWriter output) {
CacheDependency sqlCacheDep = null;
// If the output is cached, use it and do nothing else
if (_outputString != null) {
output.Write(_outputString);
RegisterValidationEvents();
return;
}
// If caching was turned off, just render the control
if (_cachingDisabled || !RuntimeConfig.GetAppConfig().OutputCache.EnableFragmentCache) {
_cachedCtrl.RenderControl(output);
return;
}
// Create SQL cache dependency before we render the page
if (_sqlDependency != null) {
sqlCacheDep = SqlCacheDependency.CreateOutputCacheDependency(_sqlDependency);
}
_cacheEntry.CssStyleString = GetCssStyleRenderString(output.GetType());
// Create a new HtmlTextWriter, with the same type as the current one (see ASURT 118922)
StringWriter tmpWriter = new StringWriter();
HtmlTextWriter tmpHtmlWriter = Page.CreateHtmlTextWriterFromType(tmpWriter, output.GetType());
CacheDependency cacheDep;
TextWriter savedWriter = Context.Response.SwitchWriter(tmpWriter);
try {
// Make sure the Page knows about us while the control's OnPreRender is called
Page.PushCachingControl(this);
_cachedCtrl.RenderControl(tmpHtmlWriter);
Page.PopCachingControl();
}
finally {
Context.Response.SwitchWriter(savedWriter);
}
_cacheEntry.OutputString = tmpWriter.ToString();
// Send the output to the response
output.Write(_cacheEntry.OutputString);
// Cache the output
cacheDep = _cacheDependency;
if (sqlCacheDep != null) {
if (cacheDep == null) {
cacheDep = sqlCacheDep;
}
else {
AggregateCacheDependency aggr = new AggregateCacheDependency();
aggr.Add(cacheDep);
aggr.Add(sqlCacheDep);
cacheDep = aggr;
}
}
ControlCachedVary cachedVary = null;
string realItemCacheKey;
// If there are no varies, use the non-varying key
if (_varyByParamsCollection == null && _varyByControlsCollection == null && _varyByCustom == null) {
realItemCacheKey = _cacheKey;
}
else {
string[] varyByParams = null;
if (_varyByParamsCollection != null)
varyByParams = _varyByParamsCollection.GetParams();
cachedVary = new ControlCachedVary(varyByParams, _varyByControlsCollection, _varyByCustom);
HashCodeCombiner combinedHashCode = new HashCodeCombiner(_nonVaryHashCode);
realItemCacheKey = ComputeVaryCacheKey(combinedHashCode, cachedVary);
}
// Compute the correct expiration, sliding or absolute
DateTime utcExpirationTime;
TimeSpan slidingExpiration;
if (_useSlidingExpiration) {
utcExpirationTime = Cache.NoAbsoluteExpiration;
slidingExpiration = _utcExpirationTime - DateTime.UtcNow;
}
else {
utcExpirationTime = _utcExpirationTime;
slidingExpiration = Cache.NoSlidingExpiration;
}
try {
OutputCache.InsertFragment(_cacheKey, cachedVary,
realItemCacheKey, _cacheEntry,
cacheDep /*dependencies*/,
utcExpirationTime, slidingExpiration,
_provider);
}
catch {
if (cacheDep != null) {
cacheDep.Dispose();
}
throw;
}
}
private CacheDependency GetDependencies()
{
if (string.IsNullOrEmpty(SqlDependencyName)) return null;
var a = new AggregateCacheDependency();
foreach (string t in WatchTables) {
a.Add(new SqlCacheDependency(SqlDependencyName, t));
}
return a;
}
// DevDiv Bugs 162763:
// Add a an event that fires *before* an item is evicted from the ASP.NET Cache
public void Insert(
string key,
object value,
CacheDependency dependencies,
DateTime absoluteExpiration,
TimeSpan slidingExpiration,
CacheItemUpdateCallback onUpdateCallback) {
if (dependencies == null && absoluteExpiration == Cache.NoAbsoluteExpiration && slidingExpiration == Cache.NoSlidingExpiration) {
throw new ArgumentException(SR.GetString(SR.Invalid_Parameters_To_Insert));
}
if (onUpdateCallback == null) {
throw new ArgumentNullException("onUpdateCallback");
}
DateTime utcAbsoluteExpiration = DateTimeUtil.ConvertToUniversalTime(absoluteExpiration);
// Insert updatable cache entry
_cacheInternal.DoInsert (
true,
key,
value,
null,
Cache.NoAbsoluteExpiration,
Cache.NoSlidingExpiration,
CacheItemPriority.NotRemovable,
null,
true);
// Ensure the sentinel depends on its updatable entry
string[] cacheKeys = { key };
CacheDependency expensiveObjectDep = new CacheDependency(null, cacheKeys);
if (dependencies == null) {
dependencies = expensiveObjectDep;
}
else {
AggregateCacheDependency deps = new AggregateCacheDependency();
deps.Add(dependencies, expensiveObjectDep);
dependencies = deps;
}
// Insert sentinel entry for the updatable cache entry
_cacheInternal.DoInsert(
false,
CacheInternal.PrefixValidationSentinel + key,
new SentinelEntry(key, expensiveObjectDep, onUpdateCallback),
dependencies,
utcAbsoluteExpiration,
slidingExpiration,
CacheItemPriority.NotRemovable,
Cache.s_sentinelRemovedCallback,
true);
}
internal CacheDependency CreateCacheDependency(CacheDependencyType dependencyType, CacheDependency dependency)
{
if (this._dependencies != null)
{
if ((dependencyType == CacheDependencyType.Files) || (dependencyType == CacheDependencyType.CacheItems))
{
foreach (ResponseDependencyInfo info in this._dependencies)
{
using (CacheDependency dependency2 = dependency)
{
if (dependencyType == CacheDependencyType.Files)
{
dependency = new CacheDependency(0, info.items, null, dependency2, info.utcDate);
}
else
{
dependency = new CacheDependency(null, info.items, dependency2, DateTimeUtil.ConvertToLocalTime(info.utcDate));
}
}
}
return dependency;
}
CacheDependency dependency3 = null;
VirtualPathProvider virtualPathProvider = HostingEnvironment.VirtualPathProvider;
if ((virtualPathProvider != null) && (this._requestVirtualPath != null))
{
dependency3 = virtualPathProvider.GetCacheDependency(this._requestVirtualPath, this.GetDependencies(), this._oldestDependency);
}
if (dependency3 == null)
{
return dependency;
}
AggregateCacheDependency dependency4 = new AggregateCacheDependency();
dependency4.Add(new CacheDependency[] { dependency3 });
if (dependency != null)
{
dependency4.Add(new CacheDependency[] { dependency });
}
dependency = dependency4;
}
return dependency;
}
public override SiteMapNode BuildSiteMap()
{
// Use a lock to make this method thread-safe
lock (siteMapLock)
{
// First, see if we already have constructed the
// rootNode. If so, return it...
if (root != null)
{
return(root);
}
// We need to build the site map!
// Clear out the current site map structure
base.Clear();
// Get the categories and products information from the database
ProductsBLL productsAPI = new ProductsBLL();
Northwind.ProductsDataTable products = productsAPI.GetProducts();
// Create the root SiteMapNode
root = new SiteMapNode(
this, "root", "~/SiteMapProvider/Default.aspx", "All Categories");
AddNode(root);
// Create SiteMapNodes for the categories and products
foreach (Northwind.ProductsRow product in products)
{
// Add a new category SiteMapNode, if needed
string categoryKey, categoryName;
bool createUrlForCategoryNode = true;
if (product.IsCategoryIDNull())
{
categoryKey = "Category:None";
categoryName = "None";
createUrlForCategoryNode = false;
}
else
{
categoryKey = string.Concat("Category:", product.CategoryID);
categoryName = product.CategoryName;
}
SiteMapNode categoryNode = FindSiteMapNodeFromKey(categoryKey);
// Add the category SiteMapNode if it does not exist
if (categoryNode == null)
{
string productsByCategoryUrl = string.Empty;
if (createUrlForCategoryNode)
{
productsByCategoryUrl =
"~/SiteMapProvider/ProductsByCategory.aspx?CategoryID="
+ product.CategoryID;
}
categoryNode = new SiteMapNode(
this, categoryKey, productsByCategoryUrl, categoryName);
AddNode(categoryNode, root);
}
// Add the product SiteMapNode
string productUrl =
"~/SiteMapProvider/ProductDetails.aspx?ProductID="
+ product.ProductID;
SiteMapNode productNode = new SiteMapNode(
this, string.Concat("Product:", product.ProductID),
productUrl, product.ProductName);
AddNode(productNode, categoryNode);
}
// Add a "dummy" item to the cache using a SqlCacheDependency
// on the Products and Categories tables
System.Web.Caching.SqlCacheDependency productsTableDependency =
new System.Web.Caching.SqlCacheDependency("NorthwindDB", "Products");
System.Web.Caching.SqlCacheDependency categoriesTableDependency =
new System.Web.Caching.SqlCacheDependency("NorthwindDB", "Categories");
// Create an AggregateCacheDependency
System.Web.Caching.AggregateCacheDependency aggregateDependencies =
new System.Web.Caching.AggregateCacheDependency();
aggregateDependencies.Add(productsTableDependency, categoriesTableDependency);
// Add the item to the cache specifying a callback function
HttpRuntime.Cache.Insert(
CacheDependencyKey, DateTime.Now, aggregateDependencies,
Cache.NoAbsoluteExpiration, Cache.NoSlidingExpiration,
CacheItemPriority.Normal,
new CacheItemRemovedCallback(OnSiteMapChanged));
// Finally, return the root node
return(root);
}
}
public static mojoProfileConfiguration GetConfig()
{
mojoProfileConfiguration profileConfig = null;
string cacheKey = GetCacheKey();
if (
(System.Web.HttpRuntime.Cache[cacheKey] != null)
&& (System.Web.HttpRuntime.Cache[cacheKey] is mojoProfileConfiguration)
)
{
return (mojoProfileConfiguration)System.Web.HttpRuntime.Cache[cacheKey];
}
else
{
string configFileName = GetConfigFileName();
if (configFileName.Length == 0) { return profileConfig; }
if (!configFileName.StartsWith("~/"))
{
configFileName = "~/" + configFileName;
}
string pathToConfigFile = HttpContext.Current.Server.MapPath(configFileName);
XmlDocument configXml = new XmlDocument();
configXml.Load(pathToConfigFile);
profileConfig = new mojoProfileConfiguration(configXml.DocumentElement);
AggregateCacheDependency aggregateCacheDependency = new AggregateCacheDependency();
aggregateCacheDependency.Add(new CacheDependency(pathToConfigFile));
// more dependencies can be added if needed
System.Web.HttpRuntime.Cache.Insert(
cacheKey,
profileConfig,
aggregateCacheDependency,
DateTime.Now.AddYears(1),
TimeSpan.Zero,
System.Web.Caching.CacheItemPriority.Default,
null);
return (mojoProfileConfiguration)System.Web.HttpRuntime.Cache[cacheKey];
}
}
internal CacheDependency CreateCacheDependencyForResponse()
{
if (this._cacheDependencyForResponse == null)
{
CacheDependency dependency = this._cacheItemDependencyList.CreateCacheDependency(CacheDependencyType.CacheItems, null);
dependency = this._fileDependencyList.CreateCacheDependency(CacheDependencyType.Files, dependency);
dependency = this._virtualPathDependencyList.CreateCacheDependency(CacheDependencyType.VirtualPaths, dependency);
if (this._userAddedDependencies != null)
{
AggregateCacheDependency dependency2 = new AggregateCacheDependency();
dependency2.Add(this._userAddedDependencies);
if (dependency != null)
{
dependency2.Add(new CacheDependency[] { dependency });
}
this._userAddedDependencies = null;
this._cacheDependencyForResponse = dependency2;
}
else
{
this._cacheDependencyForResponse = dependency;
}
}
return this._cacheDependencyForResponse;
}
public static TinyMceConfiguration GetConfig()
{
TinyMceConfiguration config = new TinyMceConfiguration();
try
{
if (
(HttpRuntime.Cache["mojoTinyConfiguration"] != null)
&& (HttpRuntime.Cache["mojoTinyConfiguration"] is TinyMceConfiguration)
)
{
return (TinyMceConfiguration)HttpRuntime.Cache["mojoTinyConfiguration"];
}
string pathToConfigFile = HostingEnvironment.MapPath("~/" + GetConfigFileName());
XmlDocument configXml = new XmlDocument();
configXml.Load(pathToConfigFile);
if(WebConfigSettings.TinyMceUseV4)
{
config.LoadV4FromConfigurationXml(configXml.DocumentElement);
}
else
{
config.LoadValuesFromConfigurationXml(configXml.DocumentElement);
}
AggregateCacheDependency aggregateCacheDependency = new AggregateCacheDependency();
string pathToWebConfig = HostingEnvironment.MapPath("~/Web.config");
aggregateCacheDependency.Add(new CacheDependency(pathToWebConfig));
HttpRuntime.Cache.Insert(
"mojoTinyConfiguration",
config,
aggregateCacheDependency,
DateTime.Now.AddYears(1),
TimeSpan.Zero,
CacheItemPriority.Default,
null);
return (TinyMceConfiguration)HttpRuntime.Cache["mojoTinyConfiguration"];
}
catch (HttpException ex)
{
log.Error(ex);
}
catch (XmlException ex)
{
log.Error(ex);
}
catch (ArgumentException ex)
{
log.Error(ex);
}
catch (NullReferenceException ex)
{
log.Error(ex);
}
return config;
}
//
// private helper methods
//
private static void AddCacheKeyToDependencies(ref CacheDependency dependencies, string cacheKey) {
CacheDependency keyDep = new CacheDependency(0, null, new string[1] {cacheKey});
if (dependencies == null) {
dependencies = keyDep;
}
else {
// if it's not an aggregate, we have to create one because you can't add
// it to anything but an aggregate
AggregateCacheDependency agg = dependencies as AggregateCacheDependency;
if (agg != null) {
agg.Add(keyDep);
}
else {
agg = new AggregateCacheDependency();
agg.Add(keyDep, dependencies);
dependencies = agg;
}
}
}
/// <devdoc>
/// Returns the XmlDocument representing the XML data.
/// If necessary, the XML data will be reloaded along with the transform, if available.
/// </devdoc>
public XmlDocument GetXmlDocument() {
string cacheKey = null;
if (!_cacheLookupDone && Cache.Enabled) {
// If caching is enabled, attempt to load from cache.
cacheKey = CreateCacheKey();
_xmlDocument = Cache.LoadDataFromCache(cacheKey) as XmlDocument;
_cacheLookupDone = true;
}
if (_xmlDocument == null) {
// Load up the data
_xmlDocument = new XmlDocument();
CacheDependency transformCacheDependency;
CacheDependency dataCacheDependency;
PopulateXmlDocument(_xmlDocument, out dataCacheDependency, out transformCacheDependency);
if (cacheKey != null) {
Debug.Assert(Cache.Enabled);
// If caching is enabled, save the XmlDocument to cache.
CacheDependency fileDependency;
if (dataCacheDependency != null) {
if (transformCacheDependency != null) {
// We have both a data file as well as a transform file dependency
AggregateCacheDependency aggregateDependency = new AggregateCacheDependency();
aggregateDependency.Add(dataCacheDependency, transformCacheDependency);
fileDependency = aggregateDependency;
}
else {
// We only have a data file dependency
fileDependency = dataCacheDependency;
}
}
else {
// We have at most only a transform file dependency (or no dependency at all)
fileDependency = transformCacheDependency;
}
Cache.SaveDataToCache(cacheKey, _xmlDocument, fileDependency);
}
}
return _xmlDocument;
}
public static PayPalIPNHandlerProviderConfig GetConfig()
{
try
{
if (
(HttpRuntime.Cache["PayPalIPNHandlerProviderConfig"] != null)
&& (HttpRuntime.Cache["PayPalIPNHandlerProviderConfig"] is PayPalIPNHandlerProviderConfig)
)
{
return (PayPalIPNHandlerProviderConfig)HttpRuntime.Cache["PayPalIPNHandlerProviderConfig"];
}
PayPalIPNHandlerProviderConfig config
= new PayPalIPNHandlerProviderConfig();
String configFolderName = "~/Setup/ProviderConfig/paypalipnhandlers/";
string pathToConfigFolder
= HttpContext.Current.Server.MapPath(configFolderName);
if (!Directory.Exists(pathToConfigFolder)) return config;
DirectoryInfo directoryInfo
= new DirectoryInfo(pathToConfigFolder);
FileInfo[] configFiles = directoryInfo.GetFiles("*.config");
foreach (FileInfo fileInfo in configFiles)
{
XmlDocument configXml = new XmlDocument();
configXml.Load(fileInfo.FullName);
config.LoadValuesFromConfigurationXml(configXml.DocumentElement);
}
AggregateCacheDependency aggregateCacheDependency
= new AggregateCacheDependency();
string pathToWebConfig
= HttpContext.Current.Server.MapPath("~/Web.config");
aggregateCacheDependency.Add(new CacheDependency(pathToWebConfig));
System.Web.HttpRuntime.Cache.Insert(
"PayPalIPNHandlerProviderConfig",
config,
aggregateCacheDependency,
DateTime.Now.AddYears(1),
TimeSpan.Zero,
System.Web.Caching.CacheItemPriority.Default,
null);
return (PayPalIPNHandlerProviderConfig)HttpRuntime.Cache["PayPalIPNHandlerProviderConfig"];
}
catch (HttpException ex)
{
log.Error(ex);
}
catch (System.Xml.XmlException ex)
{
log.Error(ex);
}
catch (ArgumentException ex)
{
log.Error(ex);
}
catch (NullReferenceException ex)
{
log.Error(ex);
}
return null;
}
public static IndexBuilderConfiguration GetConfig()
{
try
{
if (
(HttpRuntime.Cache["mojoIndexBuilderConfiguration"] != null)
&& (HttpRuntime.Cache["mojoIndexBuilderConfiguration"] is IndexBuilderConfiguration)
)
{
return (IndexBuilderConfiguration)HttpRuntime.Cache["mojoIndexBuilderConfiguration"];
}
IndexBuilderConfiguration indexBuilderConfig
= new IndexBuilderConfiguration();
String configFolderName = "~/Setup/ProviderConfig/indexbuilders/";
string pathToConfigFolder
= HostingEnvironment.MapPath(configFolderName);
if (!Directory.Exists(pathToConfigFolder)) return indexBuilderConfig;
DirectoryInfo directoryInfo
= new DirectoryInfo(pathToConfigFolder);
FileInfo[] configFiles = directoryInfo.GetFiles("*.config");
foreach (FileInfo fileInfo in configFiles)
{
XmlDocument configXml = new XmlDocument();
configXml.Load(fileInfo.FullName);
indexBuilderConfig.LoadValuesFromConfigurationXml(configXml.DocumentElement);
}
AggregateCacheDependency aggregateCacheDependency
= new AggregateCacheDependency();
string pathToWebConfig
= HostingEnvironment.MapPath("~/Web.config");
aggregateCacheDependency.Add(new CacheDependency(pathToWebConfig));
System.Web.HttpRuntime.Cache.Insert(
"mojoIndexBuilderConfiguration",
indexBuilderConfig,
aggregateCacheDependency,
DateTime.Now.AddYears(1),
TimeSpan.Zero,
System.Web.Caching.CacheItemPriority.Default,
null);
return (IndexBuilderConfiguration)HttpRuntime.Cache["mojoIndexBuilderConfiguration"];
}
catch (HttpException ex)
{
log.Error(ex);
}
catch (System.Xml.XmlException ex)
{
log.Error(ex);
}
catch (ArgumentException ex)
{
log.Error(ex);
}
catch (NullReferenceException ex)
{
log.Error(ex);
}
return null;
}