Enterprise Library Caching Application Block

1. Enterprise LibraryCaching Application Block Scott Densmore Software Design Engineer Brian Button Software Design Engineer Ron JacobsProduct Manager

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

3. 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

4. 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, Web service problems, or hardware failures

5. 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

6. 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.

7. 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

8. 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

9. 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

10. 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

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

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

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

14. Creating the Cache in Code Create the default cache manager CacheManager myCache = CacheManager.GetCacheManager(); Create the cache manager named “Products” CacheManager productsCache = CacheManager.GetCacheManager(“Products”);

15. Adding an Item to the Cache Add an item to the cache with defaults productsCache.Add(“ProductID123”, productObject); • 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

16. 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.

17. 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 15th 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.

18. Time-Based Expirations • Requires using extended overload of Add method • Caching Application Block classes support time-based expirations • AbsoluteTime • SlidingTime • ExtendedFormatTime • Absolute time example: expire at 2:00 AM on 3/21/05 DateTime refreshTime = new DateTime(2005, 3, 21, 2, 0, 0); AbsoluteTime expireTime = new AbsoluteTime(refreshTime); primitivesCache.Add("Key1", "Cache Item1", CacheItemPriority.Normal, null, expireTime);

19. Sliding Time Expirations Sliding time example: expire if item has not been accessed for 5 minutes TimeSpan refreshTime = new TimeSpan(0, 5, 0); SlidingTime expireTime = new SlidingTime(refreshTime); primitivesCache.Add("Key1", "Cache Item1", CacheItemPriority.Normal, null, expireTime);

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

21. Extended Time Format Expirations • Extended format example: expire at midnight every Saturday ExtendedFormatTime expireTime = new ExtendedFormatTime("0 0 * * 6"); primitivesCache.Add("Key1", "Cache Item1", CacheItemPriority.Normal, null, expireTime);

22. Notification-Based Expirations File dependency example: expire if the file Trigger.txt is changed FileDependency expireNotice = new FileDependency(“Trigger.txt”); productsCache.Add("Key1", "Cache Item1", CacheItemPriority.Normal, null, expireNotice); You can create custom expirations by creating classes that implement ICacheItemExpiration

23. 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

24. 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 ICacheItemRefreshAction when item is added to cache productsCache.Add("Key1", "Cache Item1", CacheItemPriority.Normal, new ProductCacheRefreshAction(), expireNotice);

25. Item Removal Notifications Class implementing ICacheItemRefreshAction must be marked as Serializable (for persistent backing store) [Serializable] public class ProductCacheRefreshAction : ICacheItemRefreshAction { public void Refresh(string key, object expiredValue, CacheItemRemovedReason removalReason) { // Item has been removed from cache. // Perform desired actions here, // based upon the removal reason (e.g. refresh the cache with the // item). } }

26. Retrieving an Item from the Cache Cast returned object to correct type Check for null (item not found in cache) public Product ReadProductByID(string productID) { Product product = (Product)cache.GetData(productID); if (product == null) { // Item not in cache } }

27. 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

28. Loading the Cache Proactively Create cache manager CacheManager productsCache = CacheManager.GetCacheManager(); Add items during component initialization // Retrieve the data from the source ArrayList list = dataProvider.GetProductList(); // Add all the items to the cache for (int i = 0; i < list.Count; i++) { Product product = (Product) list[i]; productsCache.Add( product.ProductID, product ); }

29. Loading the Cache Reactively Create cache manager CacheManager productsCache = CacheManager.GetCacheManager(); Add items when retrieved from data source Product product = (Product) productsCache.GetData(productID); if (product == null) { // Retrieve it from the data provider // and cache it for more requests. product = dataProvider.GetProductByID(productID); if (product != null) { productsCache.Add(productID, product); } }

30. 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.

31. 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.

32. Removing an Item from the Cache Remove item with specified key productsCache.Remove(“Product101Key”) No error occurs if key is not found

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

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

35. Flushing the Cache with Scavenging Priority is established when an item is added to the cache productsCache.Add("Key1", "Cache Item1", CacheItemPriority.High, new ProductCacheRefreshAction(), expireNotice) • Priority values • Low • Normal • High • NotRemovable • The scavenging algorithm is not an extension point

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

37. Key Extensibility Points • Custom backing store provider • Implement IBackingStore (derive from BaseBackingStore) • Use Configuration Console to select custom provider • Custom expiration policy • Implement ICacheItemExpiration • Specify object on call to Add method of CacheManager object • Plus… • Anything and everything – you have the source code! • Please post extensions and suggestions to the community

38. Enterprise Library v1 Caching Exceptions Legend Security Data Access Logging Dependency Plug-in Crypto Configuration Config Tool

39. Announcing: Enterprise Library 1.0 Download it Today! http://www.microsoft.com/practices

40. 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

41. http://www.microsoft.com/practicesEnterprise Library Communityhttp://go.microsoft.com/fwlink/?linkid=39209&clcid=0x09