Enterprise Library Caching Application Block Brian Button Software

Enterprise Library Caching Application Block Brian Button Software Design Engineer Ron Jacobs Product Manager Scott Densmore Software Design Engineer

Agenda Caching architectural guidance from patterns & practices Describe implementation of caching scenarios and guidance using the Caching Application Block Demonstration Questions

Sound familiar? Users are complaining about application performance You have already spent the next year’s IT budget scaling out your database servers to handle the amount of requests for data Your application cannot perform, or is severely degraded, without a live connection to the backend data source

Why Cache? Performance Storing relevant data as close as possible to the data consumer avoids repetitive data creation, processing, and transportation Scalability Avoid wasting resources processing the same data, business functionality, and user interface fragments required by multiple users and processes Reduce database requests, allowing more users to be served Availability Storing that data in another place, your application may be able to survive system failures such as network latency,

Sample Application Caching Scenarios You are creating a smart client application that uses locally cached reference data to create requests and support offline operations You are creating a Windows Service or Console application which needs a cache to improve performance

Caching Application Block Provides a flexible and extensible caching mechanism that can be used at all layers of an application Supports backing stores that persist cache data into a database or isolated storage, so the data can survive app restarts Easy to use Easy to configure, using the Enterprise Library Configuration Tool Thread-safe Ensures that the states of the in-memory cache and the backing store remain synchronized.

Exploring the Caching Application Block Creating the Caching Application Block configuration Selecting a backing store Creating the cache Adding an item to the cache Setting the expiration policy Retrieving an item from the cache Implementing cache loading strategies Removing an item from the cache Flushing the cache Key extensibility points

Creating Configuration Add the Caching Application Block to your application configuration Create a cache manager for each set of data to be cached Designate one as the default cache manager

Cache Storage Guidance Memory resident cache. Memory-based caching is usually used when: An application is frequently using the same data An application often needs to reacquire the data Disk resident cache. Disk based caching is useful when: You are handling large amounts of data Data in the application services (for example, a database) may not always be available for reacquisition (for example, in offline scenarios) Cached data lifetime must survive process recycles and computer reboots Caching Architecture Guide for. NET Framework Applications

Caching Application Block Storage Cache always exists in memory Cache always has a backing store Null backing store (in-memory only, not persistent) Persistent storage Persistent backing stores Useful when cached data lifetime must survive process recycles and computer reboots Isolated storage, Data Access Application Block Contents always match in-memory cache In-memory cache is loaded from backing store during cache initialization

Backing Store Configuration Isolated Storage Segregated by user and assembly Caching Application Block provides partition to segregate multiple cache managers within an application

Backing Store Configuration Data Access Application Block Segregated by database instance and named partition Require configuring the Data Access Application Block

Backing Store Configuration Encrypting cache data in the backing store Requires Cryptography Application Block Select Symmetric provider to use

Creating the Cache in Code Create the default cache manager Cache. Manager my. Cache = Cache. Manager. Get. Cache. Manager(); Create the cache manager named “Products” Cache. Manager products. Cache = Cache. Manager. Get. Cache. Manager(“Products”);

Adding an Item to the Cache Add an item to the cache with defaults products. Cache. Add(“Product. ID 123”, product. Object); Defaults Scavenging priority: Normal No expiration Notes Adding a second item with the same key as an existing item replaces the existing item When configured to use a persistent backing store, objects added to the cache must be serializable

Determining an Expiration Policy Time-based expirations Invalidate data based on either relative or absolute time periods For use when volatile cache items—such as those that have regular data refreshes or those that are valid for only a set amount of time—are stored in a cache. Notification-based expirations Validity of a cached item based on the properties of an application resource, such as a file, a folder, or any other type of data source.

Time-Based Expirations Absolute. Allows you to define the lifetime of an item by specifying the absolute time for an item to expire. Simple—You define the lifetime of an item by setting a specific date and time for the item to expire. Extended—You define the lifetime of an item by specifying expressions such as every minute, every Sunday, expire at 5: 15 AM on the 15 th of every month, and so on. Sliding. Allows you to define the lifetime of an item by specifying the interval between the item being accessed and the policy defining it as expired.

Time-Based Expirations Requires using extended overload of Add method Caching Application Block classes support timebased expirations Absolute. Time Sliding. Time Extended. Format. Time Absolute time example: expire at 2: 00 AM on 3/21/05 Date. Time refresh. Time = new Date. Time(2005, 3, 21, 2, 0, 0); Absolute. Time expire. Time = new Absolute. Time(refresh. Time); primitives. Cache. Add("Key 1", "Cache Item 1", Cache. Item. Priority. Normal, null, expire. Time);

Sliding Time Expirations Sliding time example: expire if item has not been accessed for 5 minutes Time. Span refresh. Time = new Time. Span(0, 5, 0); Sliding. Time expire. Time = new Sliding. Time(refresh. Time); primitives. Cache. Add("Key 1", "Cache Item 1", Cache. Item. Priority. Normal, null, expire. Time);

Extended Time Format Expirations Extended time format “<Minute> <Hour> <Day of month> <Month> <Day of week>” * means run every period Examples “* * *” “ 5 * *” “* 21 * * *” every day “ 31 15 * * *” “ 7 4 * * 6” “ 15 21 4 7 *” expires every minute expire 5 th minute of every hour expire every minute of the 21 st hour of expire 3: 31 PM every day expire Saturday 4: 07 AM expire 9: 15 PM on 4 July

Extended Time Format Expirations Extended format example: expire at midnight every Saturday Extended. Format. Time expire. Time = new Extended. Format. Time("0 0 * * 6"); primitives. Cache. Add("Key 1", "Cache Item 1", Cache. Item. Priority. Normal, null, expire. Time);

Notification-Based Expirations File dependency example: expire if the file Trigger. txt is changed File. Dependency expire. Notice = new File. Dependency(“Trigger. txt”); products. Cache. Add("Key 1", "Cache Item 1", Cache. Item. Priority. Normal, null, expire. Notice); You can create custom expirations by creating classes that implement ICache. Item. Expiration

Configuring Expiration Poll Frequency Removal of expired items occurs on a background thread You can set the frequency of how often this thread will run looking for expired items

Item Removal Notifications Caching Application Block provides notification when an item is removed from cache Item has expired Item was removed explicitly through code Item was scavenged Provide an object that implements ICache. Item. Refresh. Action when item is added to cache products. Cache. Add("Key 1", "Cache Item 1", Cache. Item. Priority. Normal, new Product. Cache. Refresh. Action(), expire. Notice);

Item Removal Notifications Class implementing ICache. Item. Refresh. Action must be marked as Serializable (for persistent backing store) [Serializable] public class Product. Cache. Refresh. Action : ICache. Item. Refresh. Action { public void Refresh(string key, object expired. Value, Cache. Item. Removed. Reason removal. Reason) { // Item has been removed from cache. // Perform desired actions here, // based upon the removal reason (e. g. refresh the cache with the // item). } }

Retrieving an Item from the Cache Cast returned object to correct type Check for null (item not found in cache) public Product Read. Product. By. ID(string product. ID) { Product product = (Product)cache. Get. Data(product. ID); if (product == null) { // Item not in cache } }

Loading the Cache Proactive loading Cache is preloaded with items on application startup Application response time improves, as all items are in cache Application startup time increases, as all items are loaded May cache items that are never requested, using unnecessary resources Loading typically done on a separate thread, increasing complexity Reactive loading Cache an item after it is retrieved from the data source Only caches items truly needed (uses less resources) Response times slower during application execution if an item is not yet cached

Loading the Cache Proactively Create cache manager Cache. Manager products. Cache = Cache. Manager. Get. Cache. Manager(); Add items during component initialization // Retrieve the data from the source Array. List list = data. Provider. Get. Product. List(); // Add all the items to the cache for (int i = 0; i < list. Count; i++) { Product product = (Product) list[i]; products. Cache. Add( product. Product. ID, product ); }

Loading the Cache Reactively Create cache manager Cache. Manager products. Cache = Cache. Manager. Get. Cache. Manager(); Add items when retrieved from data source Product product = (Product) products. Cache. Get. Data(product. ID); if (product == null) { // Retrieve it from the data provider // and cache it for more requests. product = data. Provider. Get. Product. By. ID(product. ID); if (product != null) { products. Cache. Add(product. ID, product); } }

Loading the Cache Proactive caching is recommended in situations that have one or more of the following characteristics: You are using static or semistatic state that has known update periods. If you use it in other scenarios, the state might expire before it is used. You are using state with a known lifetime. You are using state of a known size. If you use proactive cache data loading when you do not know the size of the data, you might exhaust system resources. You must try to not use resources that you do not have. You have problematic resources, such as a slow database, a slow network, or unreliable Web services. You can use this technique to retrieve all the state proactively, cache it, and work against the cache as much as it can.

Loading the Cache Reactive caching is recommended in situations that have one or more of the following characteristics: You are using lots of state and you do not have sufficient resources to cache all state for the entire application. You are using reliable and responsive resources, such as a database, network, or Web service that will not impede application stability and performance. You are interested in caching data that is not available during the initialization of an application. For example, this data might be affected by user input such as common search queries or user-specific data such as a user's profile.

Removing an Item from the Cache Remove item with specified key products. Cache. Remove(“Product 101 Key”) No error occurs if key is not found

Flushing the Cache Use to manage storage, memory and other resources efficiently Explicit flushing Initiated by application code Removes all items from the cache products. Cache. Flush() Scavenging Initiated by application block Based upon priority and last access time Configuration settings control size of cache and number removed

Flushing the Cache with Scavenging configuration Maximum elements in cache Number of items removed when scavenging occurs

Flushing the Cache with Scavenging Priority is established when an item is added to the cache products. Cache. Add("Key 1", "Cache Item 1", Cache. Item. Priority. High, new Product. Cache. Refresh. Action(), expire. Notice) Priority values Low Normal High Not. Removable The scavenging algorithm is not an extension point

View/Application Share: Demonstration [Live Meeting View/Application Share. Use Live Meeting > Edit Slide Properties. . . to edit. ]

Key Extensibility Points Custom backing store provider Implement IBacking. Store (derive from Base. Backing. Store) Use Configuration Console to select custom provider Custom expiration policy Implement ICache. Item. Expiration Specify object on call to Add method of Cache. Manager object Plus… Anything and everything – you have the source code! Please post extensions and suggestions to the community

Enterprise Library v 1 Caching Exceptions Legend Security Data Access Logging Dependency Plug-in Crypto Configuration Config Tool

Announcing: Enterprise Library 1. 0 http: //www. microsoft. com/practices t i d a lo n w o D ! y a d o T

patterns & practices Live! 3/14 Enterprise Library Logging & Instrumentation Application Block 3/17 Enterprise Library Exception Handling Application Block 3/22 Enterprise Library Cryptography Application Block 3/24 Enterprise Library Security Application Block http: //www. pnplive. com

http: //www. microsoft. com/practices Enterprise Library Community http: //go. microsoft. com/fwlink/? linkid=39209&clcid=0 x 09