/// <summary>
/// Executing this method will perform all the operations of the sample
/// </summary>
public static void Run()
{
// Initialize cache
InitializeCache();
// Generate instance of Customer that will be used in different operations in this sample
Customer customer = CreateNewCustomer();
string key = GetKey(customer);
// Cache item versioning makes possible the concurrency checks on cacheitems.
// Scenario:
// User X and Y has fetched data from cache
// User Y makes changes to some cache items and write back the changes to cache
// Now the version of cache items with User X are obsolete and it can determine
// so by using cache item versioning.
// Adding item
CacheItemVersion itemversion = AddObjectToCache(key, customer);
// Update an item
CacheItemVersion latestItemversion = UpdateObjectInCache(key, customer, itemversion);
// Get an item with cache item version
GetObjectWithItemVersion(key, itemversion, latestItemversion);
// Remove an item if cache item
RemoveObjectWithItemVersion(key, latestItemversion);
// Dispose the cache once done
_cache.Dispose();
}
/// <summary>
/// This method Gets an object from cache using cache item version
/// </summary>
/// <param name="key"> String key to be fetched from cache </param>
/// <param name="oldCacheItemVersion"> Instance of CacheItemVersion to get item from cache if an updated item exist </param>
/// <param name="latestCacheItemVersion"> Instance of CacheItemVersion to get item from cache </param>
private static void GetObjectWithItemVersion(string key, CacheItemVersion oldCacheItemVersion, CacheItemVersion latestCacheItemVersion)
{
// Retrives item from cache based on CacheItemVersion
// Get item only is version superior to old version
Customer customer = _cache.GetIfNewer <Customer>(key, ref oldCacheItemVersion); //Version to be compared from cache
if (customer == null)
{
// Print output on console
Console.WriteLine("\nSpecified item version is latest.");
}
else
{
// Print output on console
Console.WriteLine(string.Format("\nCurrent Version of {0} is: {1}", GetKey(customer), oldCacheItemVersion.Version));
PrintCustomerDetails(customer);
}
// Get an item from cache from latest item version
customer = _cache.GetIfNewer <Customer>(key, ref latestCacheItemVersion); //Version to be compared from cache
if (customer == null)
{
// Print output on console
Console.WriteLine("\nSpecified item version is latest.");
}
else
{
// Print output on console
Console.WriteLine(string.Format("\nCurrent Version of {0} is: {1}", GetKey(customer), latestCacheItemVersion.Version));
PrintCustomerDetails(customer);
}
}
/// <summary>
/// Delete an object in the cache using cache item version
/// </summary>
/// <param name="key"> String key to be removed from cache </param>
/// <param name="cacheItemVersion"> Instance of CacheItemVersion to remove item from cache if item version is same in cache </param>
private static void RemoveObjectWithItemVersion(string key, CacheItemVersion cacheItemVersion)
{
// Remove object from cache if cache item version matched in cache
_cache.Remove(key, null, cacheItemVersion);
// Print output on console
Console.WriteLine("\nObject removed from cache.");
}
/// <summary>
/// This method adds object in the cache
/// </summary>
/// <param name="key"> String key to be added in cache</param>
/// <param name="customer"> Instance of Customer that will be inserted in the cache</param>
/// <returns>Returns cache item version</returns>
private static CacheItemVersion AddObjectToCache(string key, Customer customer)
{
CacheItemVersion cacheItemVersion = _cache.Add(key, customer);
// Print output on console
Console.WriteLine("\nItem is added to cache.");
return(cacheItemVersion);
}
/// <inheritdoc />
public override object Get(object key)
{
if (key == null)
{
return(null);
}
log.Debug("fetching object {0} from the cache", key);
CacheItemVersion version = null;
return(cache.Get(region, key.ToString(), ref version));
}
public object Get(object key)
{
if (key == null)
{
return(null);
}
if (log.IsDebugEnabled)
{
log.DebugFormat("fetching object {0} from the cache", key);
}
CacheItemVersion version = null;
return(cache.Get(region, key.ToString(), ref version));
}
/// <summary>
/// Delete an object in the cache using cache item version
/// </summary>
/// <param name="key"> String key to be removed from cache </param>
/// <param name="cacheItemVersion"> Instance of CacheItemVersion to remove item from cache if item version is same in cache </param>
private static void RemoveObjectWithItemVersion(string key, CacheItemVersion cacheItemVersion)
{
// Remove object from cache if cache item version matched in cache
Customer customerRemoved = (Customer)_cache.Remove(key, cacheItemVersion);
if (customerRemoved == null)
{
// Print output on console
Console.WriteLine("\nFailed to remove item from cache. The newer version of item exists in cache.");
}
else
{
// Print output on console
Console.WriteLine("\nFollowing Customer is removed from cache:");
PrintCustomerDetails(customerRemoved);
}
}
public APILogItem(string key, CacheItem item, string exceptionMessage)
{
_key = key;
_group = item.Group;
_subGroup = item.SubGroup;
_tags = item.Tags;
_namedTags = item.NamedTags;
_abs = item.AbsoluteExpiration;
_sld = item.SlidingExpiration;
_p = item.Priority;
_dep = item.Dependency;
_syncDep = item.SyncDependency;
_resyncProviderName = item.ResyncProviderName;
_version = item.Version;
_isResyncRequired = item.IsResyncExpiredItems;
this.ExceptionMessage = exceptionMessage;
}
/// <summary>
/// This method updates object in the cache if Cache Item Version matches
/// </summary>
/// <param name="key"> String key to be updated in cache </param>
/// <param name="customer"> Instance of Customer that will be updated in the cache </param>
/// <param name="oldItemVersion"> Instance of old CacheItemVersion to verify item is updated in cache </param>
/// <returns>Returns updated cache item version </returns>
private static CacheItemVersion UpdateObjectInCache(string key, Customer customer, CacheItemVersion oldItemVersion)
{
// Updaing the customer object in cache;
customer.CompanyName = "Gourmet Lanchonetes";
// Create a CacheItem instance and assign Cache Item Version
CacheItem cacheItem = new CacheItem(customer);
cacheItem.Version = oldItemVersion;
// Update item if version match
CacheItemVersion updatedItemVersio = _cache.Insert(key, cacheItem);
if (oldItemVersion.Version != updatedItemVersio.Version)
{
// Print output on console
Console.WriteLine("\nItem has changed since last time it was fetched.");
}
return(updatedItemVersio);
}
/// <summary>
/// Adds the specified entry to the cache.
/// </summary>
/// <param name="key">The entry key.</param>
/// <param name="resultItem">The entry value.</param>
public void PutItem(string key, DbResultItem resultItem, DbCommand dbCommand)
{
Logger.Instance.TraceDebug("Caching results against key \"" + key + "\"");
if (this.cache == null)
{
return;
}
CacheItem cacheItem = new CacheItem(resultItem.Value);
if (resultItem.DbSyncDependency)
{
cacheItem.Dependency = this.GetDependency(resultItem.TargetDatabase, key, resultItem.ConnectionString, dbCommand);
}
cacheItem.AbsoluteExpiration = resultItem.AbsoluteExpiration;
cacheItem.SlidingExpiration = resultItem.SlidingExpiration;
CacheItemVersion ver = cache.Insert(key, cacheItem);
ulong v = ver.Version;
Logger.Instance.TraceDebug("Cached results against key \"" + key + "\"");
}
public void Add_Get_Using_Region()
{
CreateRegion();
string myRegion = "MyRegion";
//
// TESTING SIMPLE Add/Get on default cache USING Region
//
// without Tags
// without version
//
Console.WriteLine("----------------------");
Console.WriteLine("Testing Simple Add/Get");
Console.WriteLine("Cache = default");
Console.WriteLine("Region = " + myRegion);
Console.WriteLine("Tags = <none>");
Console.WriteLine("Version = <none>");
Tag[] myTagIsNull = null;
CacheItemVersion thisisNull = null;
try
{
// Initialize the object with a Add
if ((itemVersion = _defaultCache.Add(myRegion, "KeyToMyString", myObjectForCaching, myTagIsNull)) != null)
{
Console.WriteLine("PASS----->Add-Object Added to Cache, " + itemVersion);
}
else
{
Console.WriteLine("**FAIL----->Add-Object did not add to cache");
}
// Do a Simple Get using version API
if ((item = (string)_defaultCache.Get(myRegion, "KeyToMyString", ref thisisNull)) != null)
{
Console.WriteLine("PASS----->Get-Object Get from cache");
}
else
{
Console.WriteLine("**FAIL----->Get-Object did not Get from cache");
}
// Do a Simple Get with invalid key
if ((item = (string)_defaultCache.Get("InvalidKey")) != null)
{
Console.WriteLine("**FAIL----->Get-Object returned from Cache, should not since key is invalid");
}
else
{
Console.WriteLine("PASS----->Get-Object did not Get from cache. Expected since key is invalid");
}
}
catch (CacheException ex)
{
Console.Write("**FAIL----->Add-Get-Distributed Cache Generated Exception:");
Console.WriteLine(ex.Message);
// Will never get this error since we are Removing existing regions and creating new ones
}
}
internal DataCacheItemVersion(CacheItemVersion itemVersion)
{
this.itemVersion = itemVersion;
}
public void Load_Large_Data()
{
CreateLoadTestRegion();
// Simple Load testing
// Object size every line starts with 100 bytes and grows "exponentially".
// Try this out
// - Increase the size of data and test behaviour
// - Increase number of iterateMax
// - If the app crashs with "out of memory"
// * Cache lotOfData.Length.ToString()
// * Behaviour noticed, application will still crash
// * Learning : Get the application to work before using DistributedCache
// Behaviour noticed
// - Regardless of a add to cache, test app run's out of memory
// - Memory increases exponentially
int iterateMax = 10;
string lotOfData =
"0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000" +
"0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000" +
"0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000" +
"0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000" +
"0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000" +
"0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000" +
"0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000" +
"0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000" +
"0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000" +
"0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000" +
"0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000";
Console.WriteLine("----------------------");
Console.WriteLine("Testing Simple Add/Get");
Console.WriteLine("Cache = default");
Console.WriteLine("Region = " + myLoadTestRegion);
Console.WriteLine("Tags = <none>");
Console.WriteLine("Version = <none>");
long totalSizeAdded = 0;
long iterate;
for (iterate = 0; iterate < iterateMax; iterate++)
{
try
{
// Lets know how much we want to add to cache before the add
Console.Write(lotOfData.Length);
if ((itemVersion = _defaultCache.Add(myLoadTestRegion, iterate.ToString(), lotOfData, null)) != null)
Console.Write(" PASS----->Add" + iterate + " ");
else
Console.WriteLine("**FAIL----->Add-Object did not add to cache - FAIL");
if ((item = (string) _defaultCache.Get(myLoadTestRegion, iterate.ToString(), ref thisisNull)) != null)
Console.WriteLine(item.Length + " PASS-->Get" + iterate + " ");
else
Console.WriteLine("**FAIL----->Get-Object did not Get from cache");
totalSizeAdded += lotOfData.Length;
lotOfData += lotOfData;
}
catch (CacheException ex)
{
Console.WriteLine("**FAIL----->Add-Get-This is failing probably because you are running this sample test");
Console.WriteLine(" within 10mins (default timeout)");
Console.Write("**FAIL----->Distributed Cache Generated Exception:");
Console.WriteLine(ex.Message);
// Will never get this error since I am now calling RemoveRegion at the start of the sample test
}
}
Console.WriteLine("Total Size added " + totalSizeAdded);
}
public void Add_Get_With_Tags()
{
// Testing simple Add/Get on a Region with Tags
// without Version
// Each object will have a unique key
// Each object can have multiple tags, hence the tag[]
// Multiple Objects can have the same tag
Console.WriteLine("----------------------");
Console.WriteLine("Testing Simple Add/GetByTag");
Console.WriteLine("Cache = default");
Console.WriteLine("Region = " + myRegion);
Console.WriteLine("Tags = yes");
Console.WriteLine("Version = <none>");
const int totalTags = 5;
Tag[] allMyTags = new System.Data.Caching.Tag[totalTags]
{
new Tag("Tag1"), new Tag("Tag2"),
new Tag("Tag3"), new Tag("Tag4"),
new Tag("Tag5")
};
List<KeyValuePair<string, object>> getByTagReturnKeyValuePair;
int totalObjects = 10;
try
{
for (int objectid = 0; objectid < totalObjects; objectid++)
{
if ((itemVersion = _defaultCache.Add(myRegion, "MyKey" + objectid,
myObjectForCaching, allMyTags)) != null)
Console.WriteLine("PASS----->Add-Object " +
"MyKey" + objectid +
" added to Cache, with all tags");
else
Console.WriteLine("**FAIL----->Add-Object did not add to cache");
}
for (int objectid = 0; objectid < totalObjects; objectid++)
for (int tagid = 0; tagid < totalTags; tagid++)
if ((getByTagReturnKeyValuePair = _defaultCache.GetByTag(myRegion, allMyTags[tagid])) != null)
Console.WriteLine("PASS----->GetByTag-Object " +
getByTagReturnKeyValuePair.ElementAt(tagid).Key +
" get from cache. Using Tag " + tagid);
else
Console.WriteLine("**FAIL----->GetByTag-Object did not Get from cache");
}
catch (CacheException ex)
{
Console.WriteLine("**FAIL----->Add-GetByTag-This is failing probably because you are running this sample test");
Console.WriteLine(" within 10mins (default timeout)");
Console.Write("**FAIL----->Distributed Cache Generated Exception:");
Console.WriteLine(ex.Message);
}
}
public void Add_Get_On_Region_With_Version()
{
//
// TESTING SIMPLE Add/Get ON REGION with Version
//
// without Tags
// Try this
// - Put a BreakPoint on the second Put and wait for 5 seconds before releaseing.
Console.WriteLine("-----------------------------------");
Console.WriteLine("Testing Simple Add/GetCacheItem/Put");
Console.WriteLine("Cache = default");
Console.WriteLine("Region = " + myRegion);
Console.WriteLine("Tags = <none>");
Console.WriteLine("Version = yes");
try
{
if ((itemVersion = _defaultCache.Add(myRegion, "KeyToMyStringWithVersion", myObjectForCaching, myTagIsNull)) != null)
Console.WriteLine("PASS----->Add-Object Added to Cache, " + itemVersion);
else
Console.WriteLine("**FAIL----->Add-Object did not add to cache");
if ((cacheItem1 = _defaultCache.GetCacheItem(myRegion, "KeyToMyStringWithVersion")) != null)
Console.WriteLine("PASS----->GetCacheItem-Object Get from cache");
else
Console.WriteLine("**FAIL----->GetCacheItem-Object did not Get from cache");
if ((cacheItem2 = _defaultCache.GetCacheItem(myRegion, "KeyToMyStringWithVersion")) != null)
Console.WriteLine("PASS----->GetCacheItem-Object Get from cache");
else
Console.WriteLine("**FAIL----->GetCacheItem-Object did not Get from cache");
if ((cacheItemVersion = _defaultCache.Put(myRegion, "KeyToMyStringWithVersion",
cacheItem1.Value, myTagIsNull, cacheItem1.Version)) != null)
Console.WriteLine("PASS----->Put-Object updated successfully");
else
Console.WriteLine("**FAIL----->Put-Object did not update successfully");
if ((cacheItemVersion = _defaultCache.Put(myRegion, "KeyToMyStringWithVersion",
cacheItem2.Value, myTagIsNull, cacheItem2.Version)) != null)
Console.WriteLine("**FAIL----->Put-Object update. Optimistic lock did not work");
else // this will throw a exception, so the else will not run if the object is locked.
Console.WriteLine("PASS----->Put-Object did not update. Optimistic lock worked");
}
catch (CacheException ex)
{
Console.WriteLine("PASS----->Add-GetCacheItem-Put-Expected behaviour since object is locked");
Console.WriteLine(" for 5 seconds");
Console.Write("PASS----->Distributed Cache Generated Exception:");
Console.WriteLine(ex.Message);
}
}
public void Add_Get_With_Tags()
{
// Testing simple Add/Get on a Region with Tags
// without Version
// Each object will have a unique key
// Each object can have multiple tags, hence the tag[]
// Multiple Objects can have the same tag
Console.WriteLine("----------------------");
Console.WriteLine("Testing Simple Add/GetByTag");
Console.WriteLine("Cache = default");
Console.WriteLine("Region = " + myRegion);
Console.WriteLine("Tags = yes");
Console.WriteLine("Version = <none>");
const int totalTags = 5;
Tag[] allMyTags = new System.Data.Caching.Tag[totalTags]
{
new Tag("Tag1"), new Tag("Tag2"),
new Tag("Tag3"), new Tag("Tag4"),
new Tag("Tag5")
};
List <KeyValuePair <string, object> > getByTagReturnKeyValuePair;
int totalObjects = 10;
try
{
for (int objectid = 0; objectid < totalObjects; objectid++)
{
if ((itemVersion = _defaultCache.Add(myRegion, "MyKey" + objectid,
myObjectForCaching, allMyTags)) != null)
{
Console.WriteLine("PASS----->Add-Object " +
"MyKey" + objectid +
" added to Cache, with all tags");
}
else
{
Console.WriteLine("**FAIL----->Add-Object did not add to cache");
}
}
for (int objectid = 0; objectid < totalObjects; objectid++)
{
for (int tagid = 0; tagid < totalTags; tagid++)
{
if ((getByTagReturnKeyValuePair = _defaultCache.GetByTag(myRegion, allMyTags[tagid])) != null)
{
Console.WriteLine("PASS----->GetByTag-Object " +
getByTagReturnKeyValuePair.ElementAt(tagid).Key +
" get from cache. Using Tag " + tagid);
}
else
{
Console.WriteLine("**FAIL----->GetByTag-Object did not Get from cache");
}
}
}
}
catch (CacheException ex)
{
Console.WriteLine("**FAIL----->Add-GetByTag-This is failing probably because you are running this sample test");
Console.WriteLine(" within 10mins (default timeout)");
Console.Write("**FAIL----->Distributed Cache Generated Exception:");
Console.WriteLine(ex.Message);
}
}
public void Add_Get_Using_Region()
{
CreateRegion();
string myRegion = "MyRegion";
//
// TESTING SIMPLE Add/Get on default cache USING Region
//
// without Tags
// without version
//
Console.WriteLine("----------------------");
Console.WriteLine("Testing Simple Add/Get");
Console.WriteLine("Cache = default");
Console.WriteLine("Region = " + myRegion);
Console.WriteLine("Tags = <none>");
Console.WriteLine("Version = <none>");
Tag[] myTagIsNull = null;
CacheItemVersion thisisNull = null;
try
{
// Initialize the object with a Add
if ((itemVersion = _defaultCache.Add(myRegion, "KeyToMyString", myObjectForCaching, myTagIsNull)) != null)
Console.WriteLine("PASS----->Add-Object Added to Cache, " + itemVersion);
else
Console.WriteLine("**FAIL----->Add-Object did not add to cache");
// Do a Simple Get using version API
if ((item = (string) _defaultCache.Get(myRegion, "KeyToMyString", ref thisisNull)) != null)
Console.WriteLine("PASS----->Get-Object Get from cache");
else
Console.WriteLine("**FAIL----->Get-Object did not Get from cache");
// Do a Simple Get with invalid key
if ((item = (string) _defaultCache.Get("InvalidKey")) != null)
Console.WriteLine("**FAIL----->Get-Object returned from Cache, should not since key is invalid");
else
Console.WriteLine("PASS----->Get-Object did not Get from cache. Expected since key is invalid");
}
catch (CacheException ex)
{
Console.Write("**FAIL----->Add-Get-Distributed Cache Generated Exception:");
Console.WriteLine(ex.Message);
// Will never get this error since we are Removing existing regions and creating new ones
}
}
public void Add_Get_Simple()
{
//
// TESTING SIMPLE Add/Get on default cache
//
// no regions
//
// Need to catch exception here to allow the program to run continously
// Try this out
// - Comment the try catch on this block of code
// - Run this program twice within 10 mins
// - Result, Add will throw a exception
// - Run this program after 10 mins
// - Result, Program will run ok
// Try this out
// - Put a VS-BreakPoint at the Get("KetToMyString") call
// - Run the sample test after 10 mins
// - Get will fail
Console.WriteLine("----------------------");
Console.WriteLine("Testing Simple Add/Get");
Console.WriteLine("Cache = default");
Console.WriteLine("Region = <none>");
Console.WriteLine("Tags = <none>");
Console.WriteLine("Version = <none>");
try
{
if ((itemVersion = _defaultCache.Add("KeyToMyString", myObjectForCaching)) != null)
Console.WriteLine("PASS--->Add-Object Added to Cache, HashCode: " + itemVersion.GetHashCode());
else
Console.WriteLine("**FAIL--->Add-Object did not add to cache - FAIL");
if ((item = (string) _defaultCache.Get("KeyToMyString")) != null)
Console.WriteLine("PASS--->Get-Object Get from cache");
else
Console.WriteLine("**FAIL--->Get-Object did not Get from cache");
if ((item = (string) _defaultCache.Get("InCorrectKeySpecified")) == null)
Console.WriteLine("PASS--->Get-Object did not Get, since invalid key specified");
else
Console.WriteLine("**FAIL--->Get-Object Get from cache, unexpected result");
}
catch (CacheException ex)
{
Console.WriteLine("**FAIL--->Add-Get-This is failing probably because you are running this");
Console.WriteLine(" sample test within 10mins (default timeout) in clusterconfig.xml");
Console.WriteLine(" To get this working, in the admin tool");
Console.WriteLine(" - stop cluster");
Console.WriteLine(" - delete cache default");
Console.WriteLine(" - create cache default");
Console.WriteLine(" - start cluster");
Console.Write("**FAIL--->Distributed Cache Generated Exception:");
Console.WriteLine(ex.Message);
}
}
public void Add_GetAndLock_Using_Region()
{
CreateRegion();
//
// TESTING SIMPLE Add/GetAndLock using Region
//
// without Tags
// without version
//
// Try this out
// - Put a BreakPoint on the first Get, and hold execution for then 5 seconds.
// It will return the object. Since the lock will expire.
// Additionally : Study behaviour of Put and PutAndLock
// - Put a BreakPoint on the second GetAndLock, and hold the execution for 5 seconds.
// It will lock the object for 10 seconds. Since the first lock has expired.
// Additionally : Study behaviour of Put and PutAndLock
Console.WriteLine("-----------------------------");
Console.WriteLine("Testing Simple Add/Get/GetAndLock/GetIfVersionMismatch/Put/PutAndLock");
Console.WriteLine("Cache = default");
Console.WriteLine("Region = " + myRegion);
Console.WriteLine("Tags = <none>");
Console.WriteLine("Version = <none>");
CacheItemVersion myVersionBeforeChange = null, myVersionAfterChange = null, myVersionChangedOnceMore = null;
LockHandle lockHandle;
string myKey = "KeyToMyStringTryingLock";
try
{
// Initialize the object with a Add
if ((itemVersion = _defaultCache.Add(myRegion, myKey, myObjectForCaching, myTagIsNull)) != null)
{
Console.WriteLine("PASS----->Add-Object Added to Cache");
}
else
{
Console.WriteLine("**FAIL----->Add-Object did not add to cache");
}
// Do a Simple Get, lock the object for 5 seconds
if ((item = (string)_defaultCache.GetAndLock(myRegion, myKey,
new TimeSpan(0, 0, 5), out lockHandle)) != null)
{
Console.WriteLine("PASS----->GetAndLock-Object Get from cache");
}
else
{
Console.WriteLine("**FAIL----->GetAndLock-Object did not Get from cache");
}
// Do a optimistic Get
if ((item = (string)_defaultCache.Get(myRegion, myKey, ref myVersionBeforeChange)) != null)
{
Console.WriteLine("PASS----->Get-Object returned. Get will always pass. Will not wait");
Console.WriteLine(" on a updating object. Current Version will be returned.");
}
else
{
Console.WriteLine("**FAIL----->Get-Object did not return.");
}
try
{
// Do a one more Simple Get, and attempt lock the object for 10 seconds
if ((item = (string)_defaultCache.GetAndLock(myRegion, myKey,
new TimeSpan(0, 0, 10), out lockHandle)) != null)
{
Console.WriteLine("**FAIL----->GetAndLock-Object Get from cache");
}
else
{
// Since a exception will catch it, this will never return null
Console.WriteLine("PASS----->GetAndLock-Object did not Get from cache");
}
}
catch (CacheException ex)
{
Console.WriteLine("PASS----->GetAndLock hit a exception, becuase object is already locked");
Console.Write("PASS----->GetAndLock-Distributed Cache Generated Exception:");
Console.WriteLine(ex.Message);
}
if ((item = (string)_defaultCache.GetIfVersionMismatch(myRegion, myKey, ref myVersionBeforeChange)) != null)
{
Console.WriteLine("**FAIL----->GetIfVersionMismatch-Object changed. Should not return as object has");
Console.WriteLine(" not been changed");
}
else
{
Console.WriteLine("PASS----->GetIfVersionMismatch-Object has not changed. Hence did not return.");
}
// Now update the object with a Put
if ((myVersionAfterChange = _defaultCache.Put(myRegion, myKey,
myObjectForCaching + "Put1", myTagIsNull, thisisNull)) != null)
{
Console.WriteLine("PASS----->Put1-null-version-Object changed. Put will pass even if object");
Console.WriteLine(" is locked. Object will also be unlocked.");
myObjectForCaching += "Put1";
}
else
{
Console.WriteLine("PASS----->Put1-null-version-Object did not change.");
}
// Object with older version changed
if ((item = (string)_defaultCache.GetIfVersionMismatch(myRegion, myKey, ref myVersionBeforeChange)) != null)
{
Console.WriteLine("PASS----->GetIfVersionMismatch-Object has been changed.");
}
else
{
Console.WriteLine("**FAIL----->GetIfVersionMismatch-Object did not return. Put ");
Console.WriteLine(" did modify the object. Should return.");
}
// Object with newer version after Put
if ((item = (string)_defaultCache.GetIfVersionMismatch(myRegion, myKey, ref myVersionAfterChange)) != null)
{
Console.WriteLine("**FAIL----->GetIfVersionMismatch-Object with newer version not changed.");
Console.WriteLine(" Should not return.");
}
else
{
Console.WriteLine("PASS----->GetIfVersionMismatch-Object with newer version not changed");
}
if ((myVersionChangedOnceMore = _defaultCache.Put(myRegion, myKey,
myObjectForCaching + "Put2", myTagIsNull, myVersionBeforeChange)) !=
null)
{
Console.WriteLine("PASS----->Put2-version from Put1-Object changed.");
myObjectForCaching += "Put2";
}
else
{
Console.WriteLine("**FAIL----->Put2-version from Put1-Object did not change.");
}
try
{
// Try the above PutAndUnlock
if ((myVersionChangedOnceMore = _defaultCache.PutAndUnlock(myRegion, myKey,
myObjectForCaching + "Put3", lockHandle, myTagIsNull)) !=
null)
{
Console.WriteLine("PASS----->PutAndUnlock-Object updated and unlocked.");
myObjectForCaching += "Put3";
}
else
{
Console.WriteLine("**FAIL----->PutAndUnlock-Object should have updated and unlocked.");
}
}
catch (CacheException ex)
{
Console.WriteLine("PASS----->PutAndUnlock-Expected exception since object is already unlocked.");
Console.Write("PASS---->PutAndUnlock-Distributed Cache Generated Exception:");
Console.WriteLine(ex.Message);
}
// Unlock Object
try
{
if (_defaultCache.Unlock(myRegion, myKey, lockHandle))
{
Console.WriteLine("PASS----->Unlock-Object unlocked");
}
else
{
Console.WriteLine("**FAIL----->Object could not be unlocked");
}
}
catch (CacheException ex)
{
Console.WriteLine("PASS----->Unlock-Expected exception since object is already unlocked.");
Console.Write("PASS----->Unlock-Distributed Cache Generated Exception:");
Console.WriteLine(ex.Message);
}
// Final Test the state of object should be "This is my Object.Put1Put2"
if ((item = (string)_defaultCache.Get(myRegion, myKey, ref myVersionChangedOnceMore)) ==
myObjectForCaching)
{
Console.WriteLine("PASS----->Get-Object retrived from cache.");
}
else
{
Console.WriteLine("**FAIL----->Get-Object was not retrived from cache");
}
}
catch (CacheException ex)
{
Console.Write(
"**FAIL---->Add-Get-GetAndLock-GetIfVersionMismatch-Put-PutAndUnlock-Distributed Cache Generated Exception:");
Console.WriteLine(ex.Message);
}
}
public object Get(string sessionId, string key, string group, string subGroup)
{
CacheItemVersion version = null;
return(_cache.Get <object>(key));
}
public void Load_Large_Data()
{
CreateLoadTestRegion();
// Simple Load testing
// Object size every line starts with 100 bytes and grows "exponentially".
// Try this out
// - Increase the size of data and test behaviour
// - Increase number of iterateMax
// - If the app crashs with "out of memory"
// * Cache lotOfData.Length.ToString()
// * Behaviour noticed, application will still crash
// * Learning : Get the application to work before using DistributedCache
// Behaviour noticed
// - Regardless of a add to cache, test app run's out of memory
// - Memory increases exponentially
int iterateMax = 10;
string lotOfData =
"0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000" +
"0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000" +
"0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000" +
"0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000" +
"0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000" +
"0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000" +
"0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000" +
"0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000" +
"0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000" +
"0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000" +
"0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000";
Console.WriteLine("----------------------");
Console.WriteLine("Testing Simple Add/Get");
Console.WriteLine("Cache = default");
Console.WriteLine("Region = " + myLoadTestRegion);
Console.WriteLine("Tags = <none>");
Console.WriteLine("Version = <none>");
long totalSizeAdded = 0;
long iterate;
for (iterate = 0; iterate < iterateMax; iterate++)
{
try
{
// Lets know how much we want to add to cache before the add
Console.Write(lotOfData.Length);
if ((itemVersion = _defaultCache.Add(myLoadTestRegion, iterate.ToString(), lotOfData, null)) != null)
{
Console.Write(" PASS----->Add" + iterate + " ");
}
else
{
Console.WriteLine("**FAIL----->Add-Object did not add to cache - FAIL");
}
if ((item = (string)_defaultCache.Get(myLoadTestRegion, iterate.ToString(), ref thisisNull)) != null)
{
Console.WriteLine(item.Length + " PASS-->Get" + iterate + " ");
}
else
{
Console.WriteLine("**FAIL----->Get-Object did not Get from cache");
}
totalSizeAdded += lotOfData.Length;
lotOfData += lotOfData;
}
catch (CacheException ex)
{
Console.WriteLine("**FAIL----->Add-Get-This is failing probably because you are running this sample test");
Console.WriteLine(" within 10mins (default timeout)");
Console.Write("**FAIL----->Distributed Cache Generated Exception:");
Console.WriteLine(ex.Message);
// Will never get this error since I am now calling RemoveRegion at the start of the sample test
}
}
Console.WriteLine("Total Size added " + totalSizeAdded);
}
public void Add_Get_Simple()
{
//
// TESTING SIMPLE Add/Get on default cache
//
// no regions
//
// Need to catch exception here to allow the program to run continously
// Try this out
// - Comment the try catch on this block of code
// - Run this program twice within 10 mins
// - Result, Add will throw a exception
// - Run this program after 10 mins
// - Result, Program will run ok
// Try this out
// - Put a VS-BreakPoint at the Get("KetToMyString") call
// - Run the sample test after 10 mins
// - Get will fail
Console.WriteLine("----------------------");
Console.WriteLine("Testing Simple Add/Get");
Console.WriteLine("Cache = default");
Console.WriteLine("Region = <none>");
Console.WriteLine("Tags = <none>");
Console.WriteLine("Version = <none>");
try
{
if ((itemVersion = _defaultCache.Add("KeyToMyString", myObjectForCaching)) != null)
{
Console.WriteLine("PASS--->Add-Object Added to Cache, HashCode: " + itemVersion.GetHashCode());
}
else
{
Console.WriteLine("**FAIL--->Add-Object did not add to cache - FAIL");
}
if ((item = (string)_defaultCache.Get("KeyToMyString")) != null)
{
Console.WriteLine("PASS--->Get-Object Get from cache");
}
else
{
Console.WriteLine("**FAIL--->Get-Object did not Get from cache");
}
if ((item = (string)_defaultCache.Get("InCorrectKeySpecified")) == null)
{
Console.WriteLine("PASS--->Get-Object did not Get, since invalid key specified");
}
else
{
Console.WriteLine("**FAIL--->Get-Object Get from cache, unexpected result");
}
}
catch (CacheException ex)
{
Console.WriteLine("**FAIL--->Add-Get-This is failing probably because you are running this");
Console.WriteLine(" sample test within 10mins (default timeout) in clusterconfig.xml");
Console.WriteLine(" To get this working, in the admin tool");
Console.WriteLine(" - stop cluster");
Console.WriteLine(" - delete cache default");
Console.WriteLine(" - create cache default");
Console.WriteLine(" - start cluster");
Console.Write("**FAIL--->Distributed Cache Generated Exception:");
Console.WriteLine(ex.Message);
}
}
public void Add_GetAndLock_Using_Region()
{
CreateRegion();
//
// TESTING SIMPLE Add/GetAndLock using Region
//
// without Tags
// without version
//
// Try this out
// - Put a BreakPoint on the first Get, and hold execution for then 5 seconds.
// It will return the object. Since the lock will expire.
// Additionally : Study behaviour of Put and PutAndLock
// - Put a BreakPoint on the second GetAndLock, and hold the execution for 5 seconds.
// It will lock the object for 10 seconds. Since the first lock has expired.
// Additionally : Study behaviour of Put and PutAndLock
Console.WriteLine("-----------------------------");
Console.WriteLine("Testing Simple Add/Get/GetAndLock/GetIfVersionMismatch/Put/PutAndLock");
Console.WriteLine("Cache = default");
Console.WriteLine("Region = " + myRegion);
Console.WriteLine("Tags = <none>");
Console.WriteLine("Version = <none>");
CacheItemVersion myVersionBeforeChange = null, myVersionAfterChange = null, myVersionChangedOnceMore = null;
LockHandle lockHandle;
string myKey = "KeyToMyStringTryingLock";
try
{
// Initialize the object with a Add
if ((itemVersion = _defaultCache.Add(myRegion, myKey, myObjectForCaching, myTagIsNull)) != null)
Console.WriteLine("PASS----->Add-Object Added to Cache");
else
Console.WriteLine("**FAIL----->Add-Object did not add to cache");
// Do a Simple Get, lock the object for 5 seconds
if ((item = (string) _defaultCache.GetAndLock(myRegion, myKey,
new TimeSpan(0, 0, 5), out lockHandle)) != null)
Console.WriteLine("PASS----->GetAndLock-Object Get from cache");
else
Console.WriteLine("**FAIL----->GetAndLock-Object did not Get from cache");
// Do a optimistic Get
if ((item = (string) _defaultCache.Get(myRegion, myKey, ref myVersionBeforeChange)) != null)
{
Console.WriteLine("PASS----->Get-Object returned. Get will always pass. Will not wait");
Console.WriteLine(" on a updating object. Current Version will be returned.");
}
else
Console.WriteLine("**FAIL----->Get-Object did not return.");
try
{
// Do a one more Simple Get, and attempt lock the object for 10 seconds
if ((item = (string) _defaultCache.GetAndLock(myRegion, myKey,
new TimeSpan(0, 0, 10), out lockHandle)) != null)
Console.WriteLine("**FAIL----->GetAndLock-Object Get from cache");
else
// Since a exception will catch it, this will never return null
Console.WriteLine("PASS----->GetAndLock-Object did not Get from cache");
}
catch (CacheException ex)
{
Console.WriteLine("PASS----->GetAndLock hit a exception, becuase object is already locked");
Console.Write("PASS----->GetAndLock-Distributed Cache Generated Exception:");
Console.WriteLine(ex.Message);
}
if ((item = (string) _defaultCache.GetIfVersionMismatch(myRegion, myKey, ref myVersionBeforeChange)) != null)
{
Console.WriteLine("**FAIL----->GetIfVersionMismatch-Object changed. Should not return as object has");
Console.WriteLine(" not been changed");
}
else
Console.WriteLine("PASS----->GetIfVersionMismatch-Object has not changed. Hence did not return.");
// Now update the object with a Put
if ((myVersionAfterChange = _defaultCache.Put(myRegion, myKey,
myObjectForCaching + "Put1", myTagIsNull, thisisNull)) != null)
{
Console.WriteLine("PASS----->Put1-null-version-Object changed. Put will pass even if object");
Console.WriteLine(" is locked. Object will also be unlocked.");
myObjectForCaching += "Put1";
}
else
Console.WriteLine("PASS----->Put1-null-version-Object did not change.");
// Object with older version changed
if ((item = (string) _defaultCache.GetIfVersionMismatch(myRegion, myKey, ref myVersionBeforeChange)) != null)
Console.WriteLine("PASS----->GetIfVersionMismatch-Object has been changed.");
else
{
Console.WriteLine("**FAIL----->GetIfVersionMismatch-Object did not return. Put ");
Console.WriteLine(" did modify the object. Should return.");
}
// Object with newer version after Put
if ((item = (string) _defaultCache.GetIfVersionMismatch(myRegion, myKey, ref myVersionAfterChange)) != null)
{
Console.WriteLine("**FAIL----->GetIfVersionMismatch-Object with newer version not changed.");
Console.WriteLine(" Should not return.");
}
else
Console.WriteLine("PASS----->GetIfVersionMismatch-Object with newer version not changed");
if ((myVersionChangedOnceMore = _defaultCache.Put(myRegion, myKey,
myObjectForCaching + "Put2", myTagIsNull, myVersionBeforeChange)) !=
null)
{
Console.WriteLine("PASS----->Put2-version from Put1-Object changed.");
myObjectForCaching += "Put2";
}
else
Console.WriteLine("**FAIL----->Put2-version from Put1-Object did not change.");
try
{
// Try the above PutAndUnlock
if ((myVersionChangedOnceMore = _defaultCache.PutAndUnlock(myRegion, myKey,
myObjectForCaching + "Put3", lockHandle, myTagIsNull)) !=
null)
{
Console.WriteLine("PASS----->PutAndUnlock-Object updated and unlocked.");
myObjectForCaching += "Put3";
}
else
Console.WriteLine("**FAIL----->PutAndUnlock-Object should have updated and unlocked.");
}
catch (CacheException ex)
{
Console.WriteLine("PASS----->PutAndUnlock-Expected exception since object is already unlocked.");
Console.Write("PASS---->PutAndUnlock-Distributed Cache Generated Exception:");
Console.WriteLine(ex.Message);
}
// Unlock Object
try
{
if (_defaultCache.Unlock(myRegion, myKey, lockHandle))
Console.WriteLine("PASS----->Unlock-Object unlocked");
else
Console.WriteLine("**FAIL----->Object could not be unlocked");
}
catch (CacheException ex)
{
Console.WriteLine("PASS----->Unlock-Expected exception since object is already unlocked.");
Console.Write("PASS----->Unlock-Distributed Cache Generated Exception:");
Console.WriteLine(ex.Message);
}
// Final Test the state of object should be "This is my Object.Put1Put2"
if ((item = (string) _defaultCache.Get(myRegion, myKey, ref myVersionChangedOnceMore)) ==
myObjectForCaching)
Console.WriteLine("PASS----->Get-Object retrived from cache.");
else
Console.WriteLine("**FAIL----->Get-Object was not retrived from cache");
}
catch (CacheException ex)
{
Console.Write(
"**FAIL---->Add-Get-GetAndLock-GetIfVersionMismatch-Put-PutAndUnlock-Distributed Cache Generated Exception:");
Console.WriteLine(ex.Message);
}
}
public object Get(string sessionId, string key, string group, string subGroup)
{
CacheItemVersion version = null;
return(_cache.Get(key, DSReadOption.None, ref version));
}
public void Add_Get_On_Region_With_Version()
{
//
// TESTING SIMPLE Add/Get ON REGION with Version
//
// without Tags
// Try this
// - Put a BreakPoint on the second Put and wait for 5 seconds before releaseing.
Console.WriteLine("-----------------------------------");
Console.WriteLine("Testing Simple Add/GetCacheItem/Put");
Console.WriteLine("Cache = default");
Console.WriteLine("Region = " + myRegion);
Console.WriteLine("Tags = <none>");
Console.WriteLine("Version = yes");
try
{
if ((itemVersion = _defaultCache.Add(myRegion, "KeyToMyStringWithVersion", myObjectForCaching, myTagIsNull)) != null)
{
Console.WriteLine("PASS----->Add-Object Added to Cache, " + itemVersion);
}
else
{
Console.WriteLine("**FAIL----->Add-Object did not add to cache");
}
if ((cacheItem1 = _defaultCache.GetCacheItem(myRegion, "KeyToMyStringWithVersion")) != null)
{
Console.WriteLine("PASS----->GetCacheItem-Object Get from cache");
}
else
{
Console.WriteLine("**FAIL----->GetCacheItem-Object did not Get from cache");
}
if ((cacheItem2 = _defaultCache.GetCacheItem(myRegion, "KeyToMyStringWithVersion")) != null)
{
Console.WriteLine("PASS----->GetCacheItem-Object Get from cache");
}
else
{
Console.WriteLine("**FAIL----->GetCacheItem-Object did not Get from cache");
}
if ((cacheItemVersion = _defaultCache.Put(myRegion, "KeyToMyStringWithVersion",
cacheItem1.Value, myTagIsNull, cacheItem1.Version)) != null)
{
Console.WriteLine("PASS----->Put-Object updated successfully");
}
else
{
Console.WriteLine("**FAIL----->Put-Object did not update successfully");
}
if ((cacheItemVersion = _defaultCache.Put(myRegion, "KeyToMyStringWithVersion",
cacheItem2.Value, myTagIsNull, cacheItem2.Version)) != null)
{
Console.WriteLine("**FAIL----->Put-Object update. Optimistic lock did not work");
}
else // this will throw a exception, so the else will not run if the object is locked.
{
Console.WriteLine("PASS----->Put-Object did not update. Optimistic lock worked");
}
}
catch (CacheException ex)
{
Console.WriteLine("PASS----->Add-GetCacheItem-Put-Expected behaviour since object is locked");
Console.WriteLine(" for 5 seconds");
Console.Write("PASS----->Distributed Cache Generated Exception:");
Console.WriteLine(ex.Message);
}
}
