private void loadProducts() { IProductBussinessService productBussinessService = null; DataTable productTable = null; try { if (Cache["Products"] == null) { productBussinessService = BizDelegateFactory.Current.ProductBussinessService; productTable = productBussinessService.RetreiveAllProducts(); SqlCacheDependency productCache = new SqlCacheDependency("SpencersDB", "Products"); Cache.Insert("Products", productTable, productCache); } } catch (Exception ex) { CommonLabel.Text = ex.Message; CommonLabel.ForeColor = Color.Red; } finally { productBussinessService = null; } }
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); }
private void ReloadAndCacheCustomers() { // Read connection string from web.config file string CS = ConfigurationManager.ConnectionStrings["StoreConnectionString"].ConnectionString; lock (thisLock) { using (SqlConnection con = new SqlConnection(CS)) { SqlDataAdapter da = new SqlDataAdapter("spGetCustomers", con); da.SelectCommand.CommandType = CommandType.StoredProcedure; DataSet ds = new DataSet(); da.Fill(ds); CacheItemRemovedCallback onCacheItemRemoved = new CacheItemRemovedCallback(CacheItemRemovedCallbackMethod); // Build SqlCacheDependency object using the database and table names SqlCacheDependency sqlDependency = new SqlCacheDependency("Store", "Customers"); // Pass SqlCacheDependency object, when caching data Cache.Insert("CustomersData", ds, sqlDependency, DateTime.Now.AddHours(24), Cache.NoSlidingExpiration, CacheItemPriority.Default, onCacheItemRemoved); GridView1.DataSource = ds; GridView1.DataBind(); } } }
/// <summary> /// Enlists a cache dependency to recieve change notifciations with an underlying resource /// </summary> /// <returns> /// The cache dependency linked to the notification subscription /// </returns> public CacheDependency Enlist() { SqlCacheDependency dependency; //setup and execute the command that will register the cache dependency for //change notifications using (var connection = new SqlConnection(connectionString)) { using (var exeCommand = new System.Data.SqlClient.SqlCommand(command, connection)) { //is the command a sproc if (isStoredProcedure) { exeCommand.CommandType = CommandType.StoredProcedure; } if (commandTimeout.HasValue) { exeCommand.CommandTimeout = this.commandTimeout.Value; } //hook the deondency up to the command dependency = new SqlCacheDependency(exeCommand); connection.Open(); //execute the query, this will enlist the dependency. Notice that we execute a non query since //we dont need any results exeCommand.ExecuteNonQuery(); } } return(dependency); }
public List <Event> LoadJson() { List <Event> events; using (StreamReader r = new StreamReader("../../EventList.json")) { string json = r.ReadToEnd(); var serializer = new JavaScriptSerializer(); // events = JsonConvert.DeserializeObject<List<Event>>(json); } if (HttpRuntime.Cache["Events"] == null) { string myConnectionString = ConfigurationManager.ConnectionStrings["SouthWorkDB"].ConnectionString; //Create your Sql Connection here using (SqlConnection con = new SqlConnection(myConnectionString)) { //Open the sql connection con.Open(); events = getEventsFromDB(con); } // Create the Sql Cache dependency object to use it on ur cache. // First parameter is the database name, second the table to create the dependency. SouthWorkDB SqlCacheDependency SQL_DEPENDENCY = new SqlCacheDependency("SouthWorkDBCache", "Events"); HttpRuntime.Cache.Insert("Events", events, SQL_DEPENDENCY); } else { events = HttpRuntime.Cache["Events"] as List <Event>; } return(events); }
public static DataSet MyData() { DataSet ds; Cache cache = HttpContext.Current.Cache; lock (lockObject) { ds = (DataSet)cache[DataKey]; if (ds == null) { string cs = ConfigurationManager.ConnectionStrings["data"] .ConnectionString; using (SqlConnection conn = new SqlConnection(cs)) { string sql = "dbo.GetInfo"; using (SqlCommand cmd = new SqlCommand(sql, conn)) { cmd.CommandType = CommandType.StoredProcedure; using (SqlDataAdapter adapter = new SqlDataAdapter(cmd)) { conn.Open(); SqlCacheDependency dep = new SqlCacheDependency(cmd); adapter.Fill(ds); cache.Insert(DataKey, ds, dep); } } } } } return(ds); }
internal override void ProcessOutputCacheDirective(string directiveName, IDictionary directive) { bool val = false; string andRemoveNonEmptyAttribute = System.Web.UI.Util.GetAndRemoveNonEmptyAttribute(directive, "varybycontentencoding"); if (andRemoveNonEmptyAttribute != null) { base.OutputCacheParameters.VaryByContentEncoding = andRemoveNonEmptyAttribute; } string str2 = System.Web.UI.Util.GetAndRemoveNonEmptyAttribute(directive, "varybyheader"); if (str2 != null) { base.OutputCacheParameters.VaryByHeader = str2; } object obj2 = System.Web.UI.Util.GetAndRemoveEnumAttribute(directive, typeof(OutputCacheLocation), "location"); if (obj2 != null) { this._outputCacheLocation = (OutputCacheLocation)obj2; base.OutputCacheParameters.Location = this._outputCacheLocation; } string depString = System.Web.UI.Util.GetAndRemoveNonEmptyAttribute(directive, "sqldependency"); if (depString != null) { base.OutputCacheParameters.SqlDependency = depString; SqlCacheDependency.ValidateOutputCacheDependencyString(depString, true); } if (System.Web.UI.Util.GetAndRemoveBooleanAttribute(directive, "nostore", ref val)) { base.OutputCacheParameters.NoStore = val; } base.ProcessOutputCacheDirective(directiveName, directive); }
protected void Page_Load(object sender, EventArgs e) { //Ao carregar a página pela 1 vez if (!Page.IsPostBack) { //Habilitar o serviço aspnet_regsql -ed -E -d CURSO //Habilitar a tabela aspnet_regsql -et -E -d CURSO -t TB_LINGUAGEM //Habilitei o serviço de notificação na base(CURSO) SqlCacheDependencyAdmin.EnableNotifications( WebConfigurationManager .ConnectionStrings["CURSO"].ConnectionString); //Habilitei o monitoramento na tabela(TB_LINGUAGEM) localizada na base(CURSO) SqlCacheDependencyAdmin.EnableTableForNotifications( WebConfigurationManager .ConnectionStrings["CURSO"].ConnectionString, "TB_LINGUAGEM"); //Classe responsável por criar uma dependência com a tabela(TB_LINGUAGEM) //localizada na base(CURSO) SqlCacheDependency Dependencia = new SqlCacheDependency("CURSO", "TB_LINGUAGEM"); //Inseri o conteúdo da tabela(TB_LINGUAGEM) no cache Cache.Insert("TABELA", Contexto.TB_LINGUAGEM); } }
// private static EntityConnectionStringBuilder entityConnectionString = new // EntityConnectionStringBuilder(ConfigurationManager.ConnectionStrings["TestdbEntities"].ConnectionString); public static IEnumerable <Student> GetStudentData() { IEnumerable <Student> studentData = HttpContext.Current.Cache.Get("student") as IEnumerable <Student>; if (studentData == null) { using (var context = new SchoolContext()) { //try // { SqlCacheDependency SqlDep = new SqlCacheDependency("TEST_SAMO", "Student"); // } //catch (DatabaseNotEnabledForNotificationException exDBDis) // { // SqlCacheDependencyAdmin.EnableNotifications(System.Configuration.ConfigurationManager.ConnectionStrings["SchoolContext"].ConnectionString); // } //catch (TableNotEnabledForNotificationException exTabDis) // { // SqlCacheDependencyAdmin.EnableTableForNotifications(System.Configuration.ConfigurationManager.ConnectionStrings["SchoolContext"].ConnectionString, "Student"); IQueryable <Student> studentDataCache = context.Students.Include("Enrollments.Course"); studentData = studentDataCache.ToList(); HttpContext.Current.Cache.Insert("student", studentData, SqlDep, DateTime.Now.AddMinutes(3), Cache.NoSlidingExpiration); // } } } return(studentData); }
public DataTable GetRealDataWithDependency(string queryString, ref SqlCacheDependency dependency) { var connection = GetActualConnection(); try { if (connection.State == ConnectionState.Closed) { connection.Open(); } var adapter = CreateDbAdapter(); var cmd = CreateDbCommand(queryString, connection); cmd.Transaction = GetActualTransaction(); dependency = new SqlCacheDependency((SqlCommand)cmd); adapter.SelectCommand = cmd; return(GetFilledDataTable(adapter)); } finally { if (NeedToDisposeActualConnection) { connection.Dispose(); } } }
public static IEnumerable <Course> GetCourseData() { IEnumerable <Course> courseData = HttpContext.Current.Cache.Get("course") as IEnumerable <Course>; if (courseData == null) { using (var context = new SchoolContext()) { //try // { SqlCacheDependency SqlDep = new SqlCacheDependency("TEST_SAMO", "Course"); // } //catch (TableNotEnabledForNotificationException exTabDis) // { // SqlCacheDependencyAdmin.EnableTableForNotifications(System.Configuration.ConfigurationManager.ConnectionStrings["SchoolContext"].ConnectionString, "Course"); // } //finally // { IQueryable <Course> courseDataCache = context.Courses; courseData = courseDataCache.ToList(); HttpContext.Current.Cache.Insert("course", courseData, SqlDep, DateTime.Now.AddMinutes(1), Cache.NoSlidingExpiration); // } } } return(courseData); }
private void LoadCategories() { ICategoryBussinessService categoryBussinessService = null; DataTable categoryTable = null; try { if (Cache["Categories"] == null) { categoryBussinessService = BizDelegateFactory.Current.CategoryBussinessService; categoryTable = categoryBussinessService.RetreiveAllCategory(); SqlCacheDependency categoryCache = new SqlCacheDependency("SpencersDB", "Products"); Cache.Insert("Categories", categoryTable, categoryCache); } CategoryIdDataList.DataSource = Cache["Categories"]; CategoryIdDataList.DataBind(); } catch (Exception ex) { CommonLabel.Text = ex.Message; CommonLabel.ForeColor = Color.Red; } finally { categoryBussinessService = null; } }
private void UpdateCache() { var connectionString = ConfigurationManager.ConnectionStrings["AdventureWorks"] .ConnectionString; SqlDependency.Start(connectionString); using (var conn = new SqlConnection(connectionString)) { using (SqlCommand command = new SqlCommand("SELECT PersonType FROM Person.Person WHERE PersonType = 'EM'", conn)) { var empCount = GetCurrentEmployeeCount(); string key = "employee_count"; string value = "Count: " + empCount + ", as of " + DateTime.Now.ToLongTimeString(); SqlCacheDependency dep = new SqlCacheDependency(command); DateTime exp = DateTime.Now.AddMinutes(5); conn.Open(); command.ExecuteScalar(); HttpContext.Cache .Add(key, value, dep, exp, Cache.NoSlidingExpiration, CacheItemPriority.Default, CallBack); } } }
public List <ShopingInfoViewModel> GetInfoViewModels() { var cache = CacheHelper.GetCache("ShopingInfo"); //先读取 if (cache == null) //如果没有该缓存 { SqlCacheDependency dep = new SqlCacheDependency("TestCache", "ShopingInfoes"); var shopinfo = (from sp in GetAllShopingInfo() join st in GetAllShopingType() on sp.ShopingTypeId equals st.ID into temp from a in temp.DefaultIfEmpty() select new ShopingInfoViewModel { ShopingName = sp.ShopingName, ShopingCount = sp.ShopingCount, ShopingPric = sp.ShopingPric, Stock = sp.Stock, Volumeofvolume = sp.Volumeofvolume, ShopingTypeName = a.ShopingName }).ToList(); CacheHelper.AddobjectToCache("ShopingInfo", shopinfo, dep);//添加缓存 return(shopinfo); } var result = (List <ShopingInfoViewModel>)cache;//有就直接返回该缓存 return(result); }
public void SetSqlDateTableCache(string key, object value, string table, string connectionName = null) { string database = connectionName ?? "ImageOfTaiWan"; sqlCacheDependency = new SqlCacheDependency(database, table); cache.Insert(key, value, sqlCacheDependency); }
protected void btnGetData_Click(object sender, EventArgs e) { if (Cache["ProductData"] == null) { string CS = @"Data Source=DESKTOP-661ODQ1;Initial Catalog=ASPDOTNETDB;Integrated Security=True"; string CS1 = ConfigurationManager.ConnectionStrings["DBConnectionString"].ConnectionString; SqlConnection con = new SqlConnection(CS1); SqlDataAdapter da = new SqlDataAdapter("spGetProducts", con); da.SelectCommand.CommandType = CommandType.StoredProcedure; DataSet DS = new DataSet(); da.Fill(DS); //Cache.Insert("ProductData", DS, null, System.Web.Caching.Cache.NoAbsoluteExpiration, TimeSpan.FromSeconds(120), CacheItemPriority.Default, null); SqlCacheDependency sqlCacheDependency = new SqlCacheDependency("ASPDOTNETDB", "tblProducts"); Cache.Insert("ProductData", DS, sqlCacheDependency, System.Web.Caching.Cache.NoAbsoluteExpiration, TimeSpan.FromSeconds(120), CacheItemPriority.Default, null); GridView1.DataSource = DS; GridView1.DataBind(); lblMessage.Text = DS.Tables[0].Rows.Count.ToString() + " row(s) retrieve from the Database"; } else { DataSet DS = new DataSet(); DS = (DataSet)Cache["ProductData"]; GridView1.DataSource = DS; GridView1.DataBind(); lblMessage.Text = DS.Tables[0].Rows.Count.ToString() + " row(s) retrieve from the Cache"; } }
protected void Page_Load(object sender, EventArgs e) { Label1.Text = "Cache Refresh: " + DateTime.Now.ToLongTimeString(); using (var connection = new SqlConnection(ConfigurationManager.ConnectionStrings["WageringConn"].ConnectionString)) { using (SqlCommand command = new SqlCommand(GetSQL(), connection)) { SqlCacheDependency dependency = new SqlCacheDependency(command); // Refresh the cache after the number of minutes // listed below if a change does not occur. // This value could be stored in a configuration file. int numberOfMinutes = 3; DateTime expires = DateTime.Now.AddMinutes(numberOfMinutes); Response.Cache.SetExpires(expires); Response.Cache.SetCacheability(HttpCacheability.Public); Response.Cache.SetValidUntilExpires(true); Response.AddCacheDependency(dependency); connection.Open(); GridView1.DataSource = command.ExecuteReader(); GridView1.DataBind(); } } }
public void CreateOutputCacheDependency() { CacheDependency sqc; AssertExtensions.Throws <HttpException> (() => { sqc = SqlCacheDependency.CreateOutputCacheDependency(null); }, "#A1"); AssertExtensions.Throws <ArgumentException> (() => { sqc = SqlCacheDependency.CreateOutputCacheDependency(String.Empty); }, "#A2"); AssertExtensions.Throws <ArgumentException> (() => { sqc = SqlCacheDependency.CreateOutputCacheDependency("Database"); }, "#A2"); // Not testable without a real database //sqc = SqlCacheDependency.CreateOutputCacheDependency ("Database:table"); //Assert.IsTrue (sqc is SqlCacheDependency, "#B1"); // //sqc = SqlCacheDependency.CreateOutputCacheDependency ("Database:table; AnotherDatabase:table"); //Assert.IsTrue (sql is AggregateCacheDependency, "#B2"); }
public AspNetNotication( CacheSpec aCacheSpec, SqlCacheDependency aDependency) { CacheSpec = aCacheSpec; dependency = aDependency; }
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> /// 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; } }
/// <summary> /// 数据库缓存依赖 /// </summary> /// <typeparam name="T"></typeparam> /// <param name="value">存储值</param> /// <param name="cacheKey">缓存键</param> /// <param name="database">数据库名称</param> /// <param name="table">表名称</param> public void WriteCache <T>(T value, string cacheKey, string database, string table) where T : class { //制定缓存策略 SqlCacheDependency scd = new SqlCacheDependency(database, table); //插入缓存 cache.Insert(cacheKey, value, scd); }
/// <summary> /// Add a new object into the cache using the SQL cache dependency. Only for HttpRuntime cache. /// </summary> /// <param name="key">The key of the object to add</param> /// <param name="value">The value of the object to add</param> /// <param name="databaseEntryName">The database entry name</param> /// /// <param name="tableName">The table name</param> public void Insert(string key, object value, string databaseEntryName, string tableName) { // Add the SqlCacheDependency objects for Products var objectTableDependency = new SqlCacheDependency(databaseEntryName, tableName); // Add the item to the data cache using productsTableDependency HttpRuntime.Cache.Insert(key, value, objectTableDependency, Cache.NoAbsoluteExpiration, Cache.NoSlidingExpiration); }
public DealDAO() { dependency = new SqlCacheDependency("anythinglk", "Deals"); allDealsQuery = from deal in db.Deals orderby deal.PlacedOn descending select deal; cacheInfo = new CacheInfo(); HttpContext.Current.Cache.Insert("CacheValid", cacheInfo, dependency); }
public void Constructor_1() { SqlCacheDependency sqc; Assert.Throws <ArgumentNullException> (() => { sqc = new SqlCacheDependency(null); }, "#A1"); }
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); }
private SqlCacheDependency CreateSqlDepenedency(string conString, DbCommand dbCommand) { SqlCommand sqlCmd = dbCommand as SqlCommand; SqlCacheDependency depenedency = null; if (sqlCmd != null) { depenedency = new SqlCacheDependency(conString, sqlCmd.CommandText.StripTabsAndNewlines()); if (sqlCmd.Parameters != null && sqlCmd.Parameters.Count > 0) { foreach (SqlParameter parameter in sqlCmd.Parameters) { SqlCmdParams dependencyParameter = new SqlCmdParams(); //dependencyParameter.Direction = (SqlParamDirection)((int)parameter.Direction - 1); switch (parameter.Direction) { case ParameterDirection.Input: dependencyParameter.Direction = SqlParamDirection.Input; break; case ParameterDirection.InputOutput: dependencyParameter.Direction = SqlParamDirection.InputOutput; break; case ParameterDirection.Output: dependencyParameter.Direction = SqlParamDirection.Output; break; case ParameterDirection.ReturnValue: dependencyParameter.Direction = SqlParamDirection.ReturnValue; break; } dependencyParameter.IsNullable = parameter.IsNullable; dependencyParameter.LocaleID = parameter.LocaleId; dependencyParameter.Offset = parameter.Offset; dependencyParameter.Precision = parameter.Precision; dependencyParameter.Scale = parameter.Scale; dependencyParameter.Size = parameter.Size; dependencyParameter.SourceColumn = parameter.SourceColumn; dependencyParameter.SourceColumnNullMapping = parameter.SourceColumnNullMapping; dependencyParameter.SourceVersion = (SqlDataRowVersion)parameter.SourceVersion; dependencyParameter.SqlValue = parameter.SqlValue; dependencyParameter.UdtTypeName = parameter.UdtTypeName; dependencyParameter.SourceColumn = parameter.SourceColumn; dependencyParameter.Type = (CmdParamsType)parameter.SqlDbType; dependencyParameter.TypeName = parameter.TypeName; dependencyParameter.SourceColumn = parameter.SourceColumn; dependencyParameter.Value = parameter.Value; depenedency.CommandParams.Add(parameter.ParameterName, dependencyParameter); } } } return(depenedency); }
public static void SaveToCacheDependency(string cacheName, object data) { string database = System.Configuration.ConfigurationSettings.AppSettings["CoreDb"]; SqlCacheDependency sqlDep = new SqlCacheDependency(database, "HtmlCached"); if (data != null) { HttpContext.Current.Cache.Insert(cacheName, data, sqlDep); } }
/// <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); }
//启用SQL缓存依赖 protected void EnableSqlDenpendency() { DataSet ds = (DataSet)Cache["ProductsInfo"]; if (ds == null) { ds = GetProductDataSet(); //指定SQL缓存依赖 SqlCacheDependency sqldependency = new SqlCacheDependency("NorthwindDataBase", "Products"); Cache.Insert("ProductsInfo", ds, sqldependency); } }
private void InsertCache(string cacheKey, object ob, SqlCommand cmd, CacheItemRemovedCallback removedCallback) { SqlCacheDependency scd = new SqlCacheDependency(cmd); using (cmd.Connection) { cmd.ExecuteNonQuery(); } HttpRuntime.Cache.Insert(cacheKey, ob, scd, absoluteExpiration, slidingExpiration, cachePriority, removedCallback); }
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); }
private DataTable GetTable() { SqlConnection con = new SqlConnection(connectionString); string sql = "SELECT ContactName FROM dbo.Customers"; SqlDataAdapter da = new SqlDataAdapter(sql, con); // Create a dependency for the Employees table. dependency = new SqlCacheDependency(da.SelectCommand); DataSet ds = new DataSet(); da.Fill(ds, "Customers"); return ds.Tables[0]; }
protected void Page_Load(object sender, EventArgs e) { if (!this.IsPostBack) { lblInfo.Text += "Creating dependent item...<br />"; Cache.Remove("CachedItem"); // Create a dependency for the Employees table. SqlCacheDependency dependency = new SqlCacheDependency( "Northwind", "Employees"); DataTable dt = GetEmployeeTable(); lblInfo.Text += "Adding dependent item<br>"; Cache.Insert("CachedItem", dt, dependency); } }
protected void Page_Load(object sender, EventArgs e) { if (!Page.IsPostBack) { System.Data.SqlClient.SqlDependency.Start(System.Web.Configuration.WebConfigurationManager.ConnectionStrings["connection"].ConnectionString); SqlConnection con = new SqlConnection(WebConfigurationManager.ConnectionStrings["connection"].ConnectionString); SqlCommand cmd = new SqlCommand(); cmd.CommandType = CommandType.Text; cmd.CommandText = "select CategoryID, ProductID, ProductName, UnitPrice, UnitsInStock from dbo.Products"; cmd.Connection = con; SqlDataAdapter adapter = new SqlDataAdapter(); adapter.SelectCommand = cmd; SqlCacheDependency dependency = new SqlCacheDependency(cmd); DataSet dataSet = new DataSet(); adapter.Fill(dataSet, "Products"); Cache.Insert("key1", dataSet, dependency); } Label1.Text = Cache["key1"].ToString(); }
public void comentarios(string razon) { lblCache.Text = "Cache Refresh: (Cada 3 minutos) " + DateTime.Now.ToLongTimeString(); // Create a dependency connection to the database. SqlDependency.Start(GetConnectionString()); using (SqlConnection connection = new SqlConnection(GetConnectionString())) { using (SqlCommand command = new SqlCommand(ObtenerComentarios(razon), connection)) { SqlCacheDependency dependency = new SqlCacheDependency(command); // Refresh the cache after the number of minutes // listed below if a change does not occur. // This value could be stored in a configuration file. int numberOfMinutes = 3; DateTime expires = DateTime.Now.AddMinutes(numberOfMinutes); Response.Cache.SetExpires(expires); Response.Cache.SetCacheability(HttpCacheability.Public); Response.Cache.SetValidUntilExpires(true); Response.AddCacheDependency(dependency); connection.Open(); GridComentarios.DataSource = command.ExecuteReader(); GridComentarios.DataBind(); if (!Context.User.Identity.IsAuthenticated) { imgComentario1.ImageUrl = string.Format("img/avatar/Ninguno.jpg"); } else { imgComentario1.ImageUrl = string.Format("img/avatar/{0}.jpg", Context.User.Identity.Name); } } } }
static DummySqlCacheObjectCacheNoDI() { //create the new cache object Cache = new SqlCacheDependency<IEnumerable<DummyObject>>("DummySqlCacheObjectCache", BuildCacheDataSource, SqlDataProviderTest.ConnectionStringToUse(), DatabaseSchemaUsedForCacheRefresh, CacheSqlToUseToTriggerRefresh); }
private void loadProducts() { IProductBussinessService productBussinessService = null; DataTable productTable = null; try { if (Cache["Products"] == null) { productBussinessService = BizDelegateFactory.Current.ProductBussinessService; productTable = productBussinessService.RetreiveAllProducts(); SqlCacheDependency productCache = new SqlCacheDependency("SpencersDB", "Products"); Cache.Insert("Products", productTable,productCache); } } catch (Exception ex) { CommonLabel.Text = ex.Message; CommonLabel.ForeColor = Color.Red; } finally { productBussinessService = null; } }
protected void GridComentarios_RowDataBound(object sender, GridViewRowEventArgs e) { if (e.Row.RowType == DataControlRowType.DataRow) { //string idComentario = e.Row.Cells[0].Text; // Si fuese un BoundField string idComentario = (e.Row.Cells[0].FindControl("lblIdComentario") as Label).Text; GridView grilla = (GridView)e.Row.FindControl("GridSubComentario"); lblCache.Text = "Cache Refresh: " + DateTime.Now.ToLongTimeString(); SqlDependency.Start(GetConnectionString()); using (SqlConnection connection = new SqlConnection(GetConnectionString())) { using (SqlCommand command = new SqlCommand(ObtenerSubComentarios(idComentario), connection)) { SqlCacheDependency dependency = new SqlCacheDependency(command); int numberOfMinutes = 3; DateTime expires = DateTime.Now.AddMinutes(numberOfMinutes); Response.Cache.SetExpires(expires); Response.Cache.SetCacheability(HttpCacheability.Public); Response.Cache.SetValidUntilExpires(true); Response.AddCacheDependency(dependency); connection.Open(); grilla.DataSource = command.ExecuteReader(); grilla.DataBind(); if (!Context.User.Identity.IsAuthenticated) { imgComentario1.ImageUrl = string.Format("img/avatar/Ninguno.jpg"); } else { imgComentario1.ImageUrl = string.Format("img/avatar/{0}.jpg", Context.User.Identity.Name); } } } } }
public override SiteMapNode BuildSiteMap() { lock (_lock) { // Return immediately if this method has been called before if (_root != null) return _root; // Query the database for site map nodes SqlConnection connection = new SqlConnection(_connect); try { SqlCommand command = new SqlCommand("proc_GetSiteMap", connection); command.CommandType = CommandType.StoredProcedure; // Create a SQL cache dependency if requested SqlCacheDependency dependency = null; if (_2005dependency) dependency = new SqlCacheDependency(command); else if (!String.IsNullOrEmpty(_database) && !string.IsNullOrEmpty(_table)) dependency = new SqlCacheDependency(_database, _table); connection.Open(); SqlDataReader reader = command.ExecuteReader(); _indexID = reader.GetOrdinal("ID"); _indexUrl = reader.GetOrdinal("Url"); _indexTitle = reader.GetOrdinal("Title"); _indexDesc = reader.GetOrdinal("Description"); _indexRoles = reader.GetOrdinal("Roles"); _indexParent = reader.GetOrdinal("Parent"); if (reader.Read()) { // Create the root SiteMapNode and add it to the site map _root = CreateSiteMapNodeFromDataReader(reader); AddNode(_root, null); // Build a tree of SiteMapNodes underneath the root node while (reader.Read()) { // Create another site map node and add it to the site map SiteMapNode node = CreateSiteMapNodeFromDataReader(reader); AddNode(node, GetParentNodeFromDataReader(reader)); } // Use the SQL cache dependency if (dependency != null) { HttpRuntime.Cache.Insert(_cacheDependencyName, new object(), dependency, Cache.NoAbsoluteExpiration, Cache.NoSlidingExpiration, CacheItemPriority.NotRemovable, new CacheItemRemovedCallback(OnSiteMapChanged)); } } } finally { connection.Close(); } // Return the root SiteMapNode return _root; } }