public static List<KeyValuePair<string,string>> GetData() {
var cache = System.Web.HttpContext.Current.Cache;
SqlCacheDependency SqlDep = null;
var modules = Cache["Modules"] as List<KeyValuePair<string,string>>;
if (modules == null) {
// Because of possible exceptions thrown when this
// code runs, use Try...Catch...Finally syntax.
try {
// Instantiate SqlDep using the SqlCacheDependency constructor.
SqlDep = new SqlCacheDependency("Test", "SD_TABLES");
}
// Handle the DatabaseNotEnabledForNotificationException with
// a call to the SqlCacheDependencyAdmin.EnableNotifications method.
catch (DatabaseNotEnabledForNotificationException exDBDis) {
SqlCacheDependencyAdmin.EnableNotifications("Test");
}
// Handle the TableNotEnabledForNotificationException with
// a call to the SqlCacheDependencyAdmin.EnableTableForNotifications method.
catch (TableNotEnabledForNotificationException exTabDis) {
SqlCacheDependencyAdmin.EnableTableForNotifications("Test", "SD_TABLES");
}
finally {
// Assign a value to modules here before calling the next line
Cache.Insert("Modules", modules, SqlDep);
}
}
return modules;
}
/// <summary>
/// 数据依赖缓存
/// </summary>
/// <param name="key"></param>
/// <param name="valueInserted">对象</param>
/// <param name="connectionString"></param>
/// <param name="dependencyTableName">与 SqlCacheDependency 关联的数据库表的名称</param>
/// <param name="databaseEntryName">在应用程序的 Web.config 文件的 caching 的 sqlCacheDependency 的 databases 元素（ASP.NET 设置架构）元素中定义的数据库的名称。 </param>
public static void Insert(
string key, object valueInserted, string connectionString, string dependencyTableName, string databaseEntryName)
{
SqlCacheDependencyAdmin.EnableNotifications(connectionString);
SqlCacheDependencyAdmin.EnableTableForNotifications(connectionString, dependencyTableName);
Insert(key, valueInserted, new SqlCacheDependency(databaseEntryName, dependencyTableName));
}
protected void Page_PreRender(object sender, EventArgs e)
{
try
{
// <Snippet2>
string[] enabledTablesList =
SqlCacheDependencyAdmin.GetTablesEnabledForNotifications(
ConfigurationManager.ConnectionStrings["MyConnectionString"].ConnectionString);
// </Snippet2>
if (enabledTablesList.Length > 0)
{
enabledTables.DataSource = enabledTablesList;
enabledTables.DataBind();
}
else
{
enabledTablesMsg.Text = "No tables are enabled for change notifications.";
enabledTables.Visible = false;
disableTable.Visible = false;
}
}
// <Snippet8>
catch (DatabaseNotEnabledForNotificationException ex)
{
enabledTables.Visible = false;
disableTable.Visible = false;
enabledTablesMsg.Text = "Cache notifications are not enabled in this database.";
tableName.Visible = false;
enableTable.Visible = false;
tableEnableMsg.Text = "Must enable database for notifications before enabling tables";
}
// </Snippet8>
}
protected void Page_PreRender(object sender, EventArgs e)
{
try
{
string[] enabledTablesList =
SqlCacheDependencyAdmin.GetTablesEnabledForNotifications(ConnString.SqlServer);
if (enabledTablesList.Length > 0)
{
enabledTables.DataSource = enabledTablesList;
enabledTables.DataBind();
}
else
{
enabledTablesMsg.Text = "No tables are enabled for change notifications.";
enabledTables.Visible = false;
disableTable.Visible = false;
}
}
catch (DatabaseNotEnabledForNotificationException ex)
{
enabledTables.Visible = false;
disableTable.Visible = false;
enabledTablesMsg.Text = "Cache notifications are not enabled in this database.";
tableName.Visible = false;
enableTable.Visible = false;
tableEnableMsg.Text = "Must enable database for notifications before enabling tables";
}
}
protected void enableTable_Click(object sender, EventArgs e)
{
try
{
if (tableName.Text.Contains(";"))
{
string[] tables = tableName.Text.Split(new Char[] { ';' });
for (int i = 0; i < tables.Length; i++)
{
tables[i] = tables[i].Trim();
}
SqlCacheDependencyAdmin.EnableTableForNotifications(ConnString.SqlServer,
tables);
}
else
{
SqlCacheDependencyAdmin.EnableTableForNotifications(ConnString.SqlServer,
tableName.Text);
}
}
catch (HttpException ex)
{
enableTableErrorMsg.Text = "<br />" +
"An error occured enabling a table.<br />" +
"The error message was: " +
ex.Message;
enableTableErrorMsg.Visible = true;
}
}
public static void InitialSqlDependencyDataBase()
{
var conStr = ConfigurationManager.ConnectionStrings["WorkDbContext"].ConnectionString;
SqlCacheDependencyAdmin.EnableNotifications(conStr);
SqlCacheDependencyAdmin.EnableTableForNotifications(conStr, "Employee");
}
public static void EnableSqlCacheDependency <TEntity>(this Table <TEntity> table) where TEntity : class
{
Type entityType = typeof(TEntity);
MetaTable metaTable = table.Context.Mapping.GetTable(entityType);
SqlCacheDependencyAdmin.EnableTableForNotifications(table.Context.Connection.ConnectionString, metaTable.TableName);
}
protected void Page_Load(object sender, EventArgs e)
{
string CS = @"Data Source=DESKTOP-661ODQ1;Initial Catalog=ASPDOTNETDB;Integrated Security=True";
SqlCacheDependencyAdmin.EnableNotifications(CS);
SqlCacheDependencyAdmin.EnableTableForNotifications(CS, "tblProducts");
}
/// <summary>
/// 启动应用程序
/// </summary>
protected void Application_Start()
{
NFine.Application.AutoMapper.Configuration.Configure();//注册DTO映射(AutoMapper)
AreaRegistration.RegisterAllAreas();
GlobalConfiguration.Configure(WebApiConfig.Register);
FilterConfig.RegisterGlobalFilters(GlobalFilters.Filters);
RouteConfig.RegisterRoutes(RouteTable.Routes);
//DBConnection.Encrypt = true;//开启数据库连接字符串加密功能
var connectionString = DBConnection.connectionString;
//启动数据库的数据缓存依赖功能
SqlCacheDependencyAdmin.EnableNotifications(connectionString);
string[] tables = { "Web_Attachment", "Web_Content", "Web_Node", "Web_FriendLinks", "Sys_Items", "Sys_ItemsDetail", "Sys_Module", "Sys_ModuleButton", "Sys_ModuleForm", "Sys_Role", "Sys_RoleAuthorize", "Sys_User", "Sys_UserLogOn", "Sys_Area", "Sys_Log", "Sys_Organize", "Sys_BackupServer", "Sys_FileBackup", "Web_Picture" };
//启用数据表缓存
SqlCacheDependencyAdmin.EnableTableForNotifications(connectionString, tables);
//注册缓存依赖的服务代码：在vs命令行输入：aspnet_regsql -S . -U sa -P 123 -ed -d NFineBase -et -t Web_Content
//-S localhost：数据库地址
//-U sa：数据库登录名
//-P 123456：数据库登录密码
//-d wcfDemo：数据库的名称
//-t user：表名称(小写)
//消息队列处理，需要服务器部署redis
//MessageQueueConfig.RegisterExceptionLogQueue();
}
protected AggregateCacheDependency GetAggregateCacheDependency <T>()
{
AggregateCacheDependency acd = new AggregateCacheDependency();
IEnumerable <string> tables = GetTables <T>();
foreach (string table in tables)
{
SqlCacheDependency cd = null;
try
{
cd = new SqlCacheDependency(DatabaseEntryName, table);
}
catch (DatabaseNotEnabledForNotificationException ex)
{
SqlCacheDependencyAdmin.EnableNotifications(ConfigurationManager.ConnectionStrings[ConnectionStringName].ConnectionString);
SqlCacheDependencyAdmin.EnableTableForNotifications(ConfigurationManager.ConnectionStrings[ConnectionStringName].ConnectionString, table);
}
catch (TableNotEnabledForNotificationException ex)
{
SqlCacheDependencyAdmin.EnableTableForNotifications(ConfigurationManager.ConnectionStrings[ConnectionStringName].ConnectionString, table);
}
if (cd == null)
{
cd = new SqlCacheDependency(DatabaseEntryName, table);
}
acd.Add(cd);
}
return(acd);
}
/// <summary>
/// Caches Linq query´s that is created for LinqToSql.
/// Limitations are the same as SqlCacheDependency
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="q">The linq query</param>
/// <param name="dc">Your LinqToSql DataContext</param>
/// <param name="CacheId">The unique Id for the cache</param>
/// <returns></returns>
public static List <T> LinqCache <T>(this IQueryable <T> q, DataContext dc, string CacheId)
{
try
{
List <T> objCache = (List <T>)HttpRuntime.Cache.Get(CacheId);
if (objCache == null)
{
/////////No cache... implement new SqlCacheDependeny//////////
//1. Get connstring from DataContext
var connStr = Properties.Settings.Default.ioschoolsConnectionString;
//2. Get SqlCommand from DataContext and the LinqQuery
string sqlCmd = dc.GetCommand(q).CommandText;
//3. Create Conn to use in SqlCacheDependency
using (SqlConnection conn = new SqlConnection(connStr))
{
conn.Open();
//4. Create Command to use in SqlCacheDependency
using (SqlCommand cmd = new SqlCommand(sqlCmd, conn))
{
//5.0 Add all parameters provided by the Linq Query
foreach (System.Data.Common.DbParameter dbp in dc.GetCommand(q).Parameters)
{
cmd.Parameters.Add(new SqlParameter(dbp.ParameterName, dbp.Value));
}
//5.1 Enable DB for Notifications... Only needed once per DB...
SqlCacheDependencyAdmin.EnableNotifications(connStr);
//5.2 Get ElementType for the query
var attrib = (TableAttribute)Attribute.GetCustomAttribute(q.ElementType, typeof(TableAttribute));
string notificationTable = attrib.Name;
//5.3 Enable the elementtype for notification (if not done!)
if (!SqlCacheDependencyAdmin.GetTablesEnabledForNotifications(connStr).Contains(notificationTable))
{
SqlCacheDependencyAdmin.EnableTableForNotifications(connStr, notificationTable);
}
//6. Create SqlCacheDependency
SqlCacheDependency sqldep = new SqlCacheDependency(cmd);
// - removed 090506 - 7. Refresh the LinqQuery from DB so that we will not use the current Linq cache
// - removed 090506 - dc.Refresh(System.Data.Linq.RefreshMode.OverwriteCurrentValues, q);
//8. Execute SqlCacheDepency query...
cmd.ExecuteNonQuery();
//9. Execute LINQ-query to have something to cache...
objCache = q.ToList();
//10. Cache the result but use the already created objectCache. Or else the Linq-query will be executed once more...
HttpRuntime.Cache.Insert(CacheId, objCache, sqldep);
}
}
}
//Return the created (or cached) List
return(objCache);
}
catch (Exception ex)
{
Syslog.Write(ex);
throw;
}
}
public bool isDependencyTableEnabled(Type aType)
{
String _table = Loader.GetClassMap(aType).GetTableName();
return(Loader.HasClassMap(aType)
&&
SqlCacheDependencyAdmin.GetTablesEnabledForNotifications(Config.DataSource).Contains(_table));
}
public static List <T> FromCache <T>(this IQueryable <T> q, ICache currentCache, string sqlConnStr)
{
var queryObject = (ObjectQuery)(q);
string sqlCmd = queryObject.ToTraceString();
var cacheKey = string.Format("{0}__{1}", sqlCmd.GetMd5Sum(), string.Join(",", queryObject.Parameters.OrderBy(a => a.Name).Select(a => a.Value).ToArray()));
List <T> objCache = (List <T>)(currentCache.Get(cacheKey));
if (objCache == null)
{
using (SqlConnection conn = new SqlConnection(sqlConnStr))
{
conn.Open();
SqlCommand cmd = new SqlCommand(sqlCmd, conn);
foreach (var param in queryObject.Parameters)
{
cmd.Parameters.AddWithValue(param.Name, param.Value);
}
foreach (SqlParameter param in cmd.Parameters)
{
sqlCmd = sqlCmd.Replace("@" + param.ParameterName, "'{0}'".FormatWith(param.Value.ToString().Replace("'", "''")));
}
cmd = new SqlCommand(sqlCmd, conn);
using (cmd)
{
SqlCacheDependency sqlDep = null;
CreateDependency:
try
{
sqlDep = new SqlCacheDependency(cmd);
}
catch (DatabaseNotEnabledForNotificationException)
{
SqlCacheDependencyAdmin.EnableNotifications(sqlConnStr);
goto CreateDependency;
}
catch (TableNotEnabledForNotificationException ex)
{
((string[])(ex.Data["Tables"]))
.Where(table => !SqlCacheDependencyAdmin.GetTablesEnabledForNotifications(sqlConnStr).Contains(table)).ToList()
.ForEach(table => SqlCacheDependencyAdmin.EnableTableForNotifications(sqlConnStr, table));
goto CreateDependency;
}
var reader = cmd.ExecuteReader();
string results = string.Empty;
while (reader.Read())
{
}
objCache = q.ToList();
currentCache.Insert(cacheKey, objCache, sqlDep);
}
}
}
return(objCache);
}
public void CompleteCachingMode(CachingMode mode)
{
if (mode == CachingMode.Polling)
{
SqlCacheDependencyAdmin.DisableNotifications(ConnectionString);
}
else if (mode == CachingMode.Notification)
{
SqlDependency.Stop(ConnectionString);
}
}
/// <summary>
/// SQL缓存依赖 用于SQL2000数据库 sql2005不需要
/// </summary>
/// <param name="table"></param>
/// <returns></returns>
public static SqlCacheDependency GetDependency(string ConnectionString_SQL2000, string table)
{
SqlCacheDependencyAdmin.EnableNotifications(ConnectionString_SQL2000); //启动数据库的数据缓存依赖功能
SqlCacheDependencyAdmin.EnableTableForNotifications(ConnectionString_SQL2000, table); //启用数据表缓存
SqlCacheDependency dependency = new SqlCacheDependency(
new System.Data.SqlClient.SqlConnectionStringBuilder(
ConnectionString_SQL2000
).InitialCatalog, table);
return(dependency);
}
protected void disableTable_Click(object sender, EventArgs e)
{
foreach (ListItem item in enabledTables.Items)
{
if (item.Selected)
{
SqlCacheDependencyAdmin.DisableTableForNotifications(ConnString.SqlServer,
item.Text);
}
}
}
public void PrepareCachingMode(CachingMode mode)
{
if (mode == CachingMode.Polling)
{
SqlCacheDependencyAdmin.EnableNotifications(ConnectionString);
SqlCacheDependencyAdmin.EnableTableForNotifications(ConnectionString, "Production.Product");
}
else if (mode == CachingMode.Notification)
{
SqlDependency.Start(ConnectionString);
}
}
// </Snippet4>
// <Snippet5>
protected void disableTable_Click(object sender, EventArgs e)
{
foreach (ListItem item in enabledTables.Items)
{
if (item.Selected)
{
SqlCacheDependencyAdmin.DisableTableForNotifications(
ConfigurationManager.ConnectionStrings["MyConnectionString"].ConnectionString,
item.Text);
}
}
}
protected void Application_Start()
{
DbConfig.InitializeDatabase();
AreaRegistration.RegisterAllAreas();
FilterConfig.RegisterGlobalFilters(GlobalFilters.Filters);
RouteConfig.RegisterRoutes(RouteTable.Routes);
BundleConfig.RegisterBundles(BundleTable.Bundles);
AutoMapperConfig.Config(Assembly.Load(ServerModelsAssembly));
SqlCacheDependencyAdmin.EnableNotifications(ConnectionString);
SqlCacheDependencyAdmin.EnableTableForNotifications(ConnectionString, CountriesTable);
}
private static void SetAuth()
{
lock (typeof(AuthCacheConfig))
{
SqlCacheDependency dep = null;
try
{
dep = new SqlCacheDependency("BlueCarGps", "User");
}
catch (DatabaseNotEnabledForNotificationException exDBDis)
{
LogUtil.Logger.Error(exDBDis.Message, exDBDis);
try
{
SqlCacheDependencyAdmin.EnableNotifications(Settings.Default.db);
}
catch (UnauthorizedAccessException ex)
{
LogUtil.Logger.Error(ex.Message, ex);
}
}
catch (TableNotEnabledForNotificationException exTabDis)
{
LogUtil.Logger.Error(exTabDis.Message, exTabDis);
try
{
SqlCacheDependencyAdmin.EnableTableForNotifications(Settings.Default.db, "User");
}
catch (SqlException ex)
{
LogUtil.Logger.Error(ex.Message, ex);
}
}
finally
{
//HttpRuntime.Cache.Insert(
// cacheKey,
// new UserService(Settings.Default.db).All(),
// dep,
// Cache.NoAbsoluteExpiration,
// Cache.NoSlidingExpiration,
// CacheItemPriority.High,
// null);
HttpRuntime.Cache.Insert(
cacheKey,
new UserService(Settings.Default.db).All(),
dep);
}
}
}
public static void SetDependency()
{
string conn = ConfigurationManager.AppSettings["Whiskey-Database-String"];
string connString = ConfigurationManager.ConnectionStrings[conn].ConnectionString;
string[] tables = new string[] { "W_Storage", "A_Department", "S_Store", "P_Product",
"P_Brand", "P_Category", "P_Size", "P_Color", "P_Season", "W_Storage", "W_OrderBlank_Item", "W_OrderBlank", "A_Administrator",
"M_Member", "F_Factorys",
//"A_MemberRole_MemberModule_Relation","A_Member_MemberRole_Relation","A_MemberModule","M_MemberRole","A_Administrator_Type",
"A_Module", "A_Permission", "A_Role", "T_Template", "P_ProductOrigNumber", "P_Product_Attribute", "T_TemplateTheme",
"A_QrLogin", "O_JobPosition", "S_StoreType", "P_ProductCrowd" };
SqlCacheDependencyAdmin.EnableNotifications(connString);
SqlCacheDependencyAdmin.EnableTableForNotifications(connString, tables);
}
public void Start(params Type[] aDependencyTablesType)
{
try
{
String _datasource = Config.DataSource;
SqlCacheDependencyAdmin.EnableNotifications(_datasource);
System.Data.SqlClient.SqlDependency.Start(_datasource);
EnableDependency(aDependencyTablesType);
}
catch (Exception anExc)
{
logger.Error(anExc);
}
}
protected TableDependency(string strTableConfigKey, string strDataBaseConfigKey)
{
string dbName = ConfigurationManager.AppSettings[strDataBaseConfigKey];
string tableConfig = ConfigurationManager.AppSettings[strTableConfigKey];
string[] tables = tableConfig.Split(configurationSeparator);
string strDNS = ConfigurationManager.ConnectionStrings[dbName].ConnectionString;
SqlCacheDependencyAdmin.EnableNotifications(strDNS);
SqlCacheDependencyAdmin.EnableTableForNotifications(strDNS, tables);
foreach (string tableName in tables)
{
dependency.Add(new SqlCacheDependency(dbName, tableName));
}
}
private static void SetCacheData(string cacheItemName, object dataSet, string connString, string tableName)
{
string cacheEntryname = "NorthwindCache";
//Many articles online state that the following statement should be run only once at the start of the application.
//Few articles say the object get replaced if called again with same connection string.
SqlDependency.Start(connString);
//The following statements needs to be run only once against the connection string and the database table, hence may also be moved to an appropriate place in code.
SqlCacheDependencyAdmin.EnableNotifications(connString);
SqlCacheDependencyAdmin.EnableTableForNotifications(connString, tableName);
System.Web.Caching.SqlCacheDependency dependency = new System.Web.Caching.SqlCacheDependency(cacheEntryname, tableName);
HostingEnvironment.Cache.Insert(cacheItemName, dataSet, dependency);
}
void Application_Start(object sender, EventArgs e)
{
// 在应用程序启动时运行的代码
AreaRegistration.RegisterAllAreas();
GlobalConfiguration.Configure(WebApiConfig.Register);
RouteConfig.RegisterRoutes(RouteTable.Routes);
//配缓存数据库依赖
string connectionString = System.Configuration.ConfigurationManager.ConnectionStrings["connStr"].ToString();
//启动数据库的数据缓存依赖功能
SqlCacheDependencyAdmin.EnableNotifications(connectionString);
//启用数据表缓存
SqlCacheDependencyAdmin.EnableTableForNotifications(connectionString, "Person"); //第二个参数可以是单个表名或表名的数组
}
//<script runat = "server" >
protected void Page_Load(object sender, EventArgs e)
{
string connectionString = ConfigurationManager.ConnectionStrings["Northwind"].ConnectionString;
SqlCacheDependency SqlDep = null;
if (Cache["SqlSource"] == null)
{
try
{
SqlDep = new SqlCacheDependency("Northwind", "Categories");
}
catch (DatabaseNotEnabledForNotificationException exDBDis)
{
try
{
SqlCacheDependencyAdmin.EnableNotifications(connectionString);
}
catch (UnauthorizedAccessException exPerm)
{
Response.Redirect(".\\ErrorPage.html");
}
}
catch (TableNotEnabledForNotificationException exTabDis)
{
try
{
SqlCacheDependencyAdmin.EnableTableForNotifications("Northwind", "Categories");
}
// If a SqlException is thrown, redirect to an error page.
catch (SqlException exc)
{
Response.Redirect(".\\ErrorPage.htm");
}
}
finally
{
Cache.Insert("SqlSource", Source1, SqlDep);
CacheMsg.Text = "The data object was created explicitly.";
}
}
else
{
CacheMsg.Text = "The data was retrieved from the Cache.";
}
}
private void PrepareDatabase()
{
var connectionString =
ConfigurationManager.ConnectionStrings["AdventureWorks"]
.ConnectionString;
try
{
SqlCacheDependencyAdmin.EnableNotifications(connectionString);
SqlCacheDependencyAdmin.EnableTableForNotifications(connectionString, "Person.Person");
}
catch (Exception ex)
{
Console.WriteLine(ex.StackTrace);
}
}
public static void SqlCacheDependency_Insert(string[] tableName, string keyCache, object data)
{
try
{
var aggCacheDep = new AggregateCacheDependency();
var sqlDepGroup = new SqlCacheDependency[tableName.Length];
for (var i = 0; i < tableName.Length; i++)
{
sqlDepGroup[i] = new SqlCacheDependency(DatabaseName, tableName[i]);
}
aggCacheDep.Add(sqlDepGroup);
if (data != null)
{
HttpRuntime.Cache.Insert(keyCache, data, aggCacheDep);
}
}
catch (Exception ex)
{
var strErr = ex.Message;
var exErr = string.Format("is not enabled for SQL cache notification.", tableName, DatabaseName);
if (strErr.Contains(exErr))
{
try
{
SqlCacheDependencyAdmin.EnableNotifications(StrCn);
SqlCacheDependencyAdmin.EnableTableForNotifications(StrCn, tableName);
var aggCacheDep = new AggregateCacheDependency();
var sqlDepGroup = new SqlCacheDependency[tableName.Length];
for (int i = 0; i < tableName.Length; i++)
{
sqlDepGroup[i] = new SqlCacheDependency(DatabaseName, tableName[i]);
}
aggCacheDep.Add(sqlDepGroup);
if (data != null)
{
HttpRuntime.Cache.Insert(keyCache, data, aggCacheDep);
}
}
catch (Exception ex1)
{
}
}
}
}
private void EnableDependency(params Type[] DependencyTablesType)
{
foreach (Type _tableType in DependencyTablesType)
{
String _table = Loader.GetClassMap(_tableType).GetTableName();
if (Loader.HasClassMap(_tableType))
{
if (!SqlCacheDependencyAdmin.GetTablesEnabledForNotifications(Config.DataSource).Contains(_table))
{
SqlCacheDependencyAdmin.EnableTableForNotifications(Config.DataSource, _table);
logger.Info("Enabling Notification For: " + _table);
}
else if (!MutableDependencyTablesType.Exists(m => m == _tableType))
{
logger.Info("Already Enabled Notification For: " + _table);
MutableDependencyTablesType.Add(_tableType);
}
}
}
}
/// <summary>
/// 启动应用程序
/// </summary>
protected void Application_Start()
{
NFine.Application.AutoMapper.Configuration.Configure();//注册DTO映射(AutoMapper)
AreaRegistration.RegisterAllAreas();
FilterConfig.RegisterGlobalFilters(GlobalFilters.Filters);
RouteConfig.RegisterRoutes(RouteTable.Routes);
var connectionString = System.Configuration.ConfigurationManager.ConnectionStrings["NFineDbContext"].ToString();
//启动数据库的数据缓存依赖功能
SqlCacheDependencyAdmin.EnableNotifications(connectionString);
string[] tables = { "Web_Attachment", "Web_Content", "Web_Node", "Web_FriendLinks", "Sys_Items", "Sys_ItemsDetail", "Sys_Module", "Sys_ModuleButton", "Sys_ModuleForm", "Sys_Role", "Sys_RoleAuthorize", "Sys_User", "Sys_UserLogOn", "Sys_Area", "Sys_Log", "Sys_Organize" };
//启用数据表缓存
SqlCacheDependencyAdmin.EnableTableForNotifications(connectionString, tables);
//注册缓存依赖的服务代码：在vs命令行输入：aspnet_regsql -S . -U sa -P 123 -ed -d NFineBase -et -t Web_Content
//-S localhost：数据库地址
//-U sa：数据库登录名
//-P 123456：数据库登录密码
//-d wcfDemo：数据库的名称
//-t user：表名称(小写)
}
