public void CreateRegionWithTallyLoader(ScopeType scope)
{
AttributesFactory af = new AttributesFactory();
af.SetCacheLoader(m_ldr);
af.SetScope(scope);
af.SetCachingEnabled(true);
m_region = CacheHelper.CreateRegion(TestRegion,
af.CreateRegionAttributes());
}
public void CreateRegionWithTallyWriter(ScopeType scope)
{
AttributesFactory af = new AttributesFactory();
af.SetCacheWriter(m_lwr);
af.SetScope(scope);
af.SetCachingEnabled(true);
m_netWriteRegion = CacheHelper.CreateRegion(TestRegionWrite,
af.CreateRegionAttributes());
}
private Region CreateRegion()
{
DistributedSystem dsys = DistributedSystem.Connect("exampleregion");
Cache cache = CacheFactory.Create("exampleregion", dsys);
AttributesFactory attributesFactory = new AttributesFactory();
attributesFactory.SetScope(ScopeType.Local);
attributesFactory.SetCachingEnabled(true);
RegionAttributes regionAttributes = attributesFactory.CreateRegionAttributes();
return cache.CreateRegion("exampleregion", regionAttributes);
}
private Region CreateRegion()
{
DistributedSystem dsys = DistributedSystem.Connect("exampleregion");
Cache cache = CacheFactory.Create("exampleregion", dsys);
AttributesFactory attributesFactory = new AttributesFactory();
attributesFactory.SetScope(ScopeType.Local);
attributesFactory.SetCachingEnabled(true);
RegionAttributes regionAttributes = attributesFactory.CreateRegionAttributes();
return(cache.CreateRegion("exampleregion", regionAttributes));
}
public void RegionThreeLoadEntries(int num)
{
AttributesFactory af = new AttributesFactory();
af.SetScope(ScopeType.Local);
af.SetCacheLoader(m_ldr);
m_region = CacheHelper.CreateRegion(TestRegion, af.CreateRegionAttributes());
m_ldr.Reset();
Thread.Sleep(100);
DoGets(m_region, num);
Assert.AreEqual(num, m_ldr.Loads);
IGFSerializable[] arr = m_region.GetKeys();
Assert.AreEqual(num, arr.Length);
}
public void RegionLookup()
{
Cache cache = (Cache) ctx["gemfire-cache"];
AttributesFactory attributesFactory = new AttributesFactory();
attributesFactory.SetScope(ScopeType.Local);
attributesFactory.SetCachingEnabled(true);
RegionAttributes regionAttributes = attributesFactory.CreateRegionAttributes();
Region existing = cache.CreateRegion("existing", regionAttributes);
Assert.IsTrue(ctx.ContainsObject("lookup"));
RegionLookupFactoryObject regionLookupFactoryObject = (RegionLookupFactoryObject)ctx.GetObject("&lookup");
Assert.AreEqual("existing", TestUtils.ReadField<string>("name", regionLookupFactoryObject));
//TODO SGFNET-20: existing is not registered as an alias with lookup/.
//Assert.AreEqual(ctx.GetObject("existing"), ctx.GetObject("lookup"));
}
public void RegionLookup()
{
Cache cache = (Cache)ctx["gemfire-cache"];
AttributesFactory attributesFactory = new AttributesFactory();
attributesFactory.SetScope(ScopeType.Local);
attributesFactory.SetCachingEnabled(true);
RegionAttributes regionAttributes = attributesFactory.CreateRegionAttributes();
Region existing = cache.CreateRegion("existing", regionAttributes);
Assert.IsTrue(ctx.ContainsObject("lookup"));
RegionLookupFactoryObject regionLookupFactoryObject = (RegionLookupFactoryObject)ctx.GetObject("&lookup");
Assert.AreEqual("existing", TestUtils.ReadField <string>("name", regionLookupFactoryObject));
//TODO SGFNET-20: existing is not registered as an alias with lookup/.
//Assert.AreEqual(ctx.GetObject("existing"), ctx.GetObject("lookup"));
}
public static void Main()
{
DistributedSystem MyDistributedSystem = null;
Cache MyCache = null;
string sKey = null;
CacheableString sValue = null;
try
{
Console.WriteLine("* Connecting to the distributed system and creating the cache.");
/* Properties can be passed to GemFire through two different mechanisms: the
* Properties object as is done below or the gemfire.properties file. The
* settings passed in a Properties object take precedence over any settings
* in a file. This way the end-user cannot bypass any required settings.
*
* Using a gemfire.properties file can be useful when you want to change the
* behavior of certain settings without doing a new build, test, and deploy cycle.
*
* See gemfire.properties for details on some of the other settings used in this
* project.
*
* For details on all of the possible settings and their respective values
* that can be specified in this configuration file, see chapter 5,
* "System Configuration", in the "System Administrator's Guide". This is
* installed in the docs\pdf folder under the GemFire installation folder
* (e.g., C:\Program Files\Gemfire5\docs\pdf\SystemAdmin.pdf).
*/
Properties DistributedSystemProperties = new Properties();
DistributedSystemProperties.Insert("name", "CacheClient");
/* Specify the file whose contents are used to initialize the cache when it is created.
*
* An XML file isn't needed at all because everything can be specified in code--much
* as the "license-file" property is. However, it provides a convenient way
* to isolate common settings that can be updated without a build/test/deploy cycle.
*/
DistributedSystemProperties.Insert("cache-xml-file", "HierarchicalClient.xml");
/* Define where the license file is located. It is very useful to do this in
* code vs. the gemfire.properties file, because it allows you to access the
* license used by the GemFire installation (as pointed to by the GEMFIRE
* environment variable).
*/
DistributedSystemProperties.Insert("license-file", "../../gfCppLicense.zip");
DistributedSystemProperties.Insert("log-file", "./csharpclient.log");
DistributedSystemProperties.Insert("log-level", "finest");
/* Override the mcast-port setting so the client runs "standalone".
* The client and server must run in separate distributed systems.
*/
//DistributedSystemProperties.Insert("mcast-port", "0");
// Connect to the GemFire distributed system.
MyDistributedSystem = DistributedSystem.Connect("LocalDS", DistributedSystemProperties);
/*//////////////////////////////////////////////////////////////////////////////
*
* Create the cache.
*
* //////////////////////////////////////////////////////////////////////////////*/
// Create the cache. This causes the cache-xml-file to be parsed.
MyCache = CacheFactory.Create("localCache", MyDistributedSystem);
/*//////////////////////////////////////////////////////////////////////////////
*
* Create the region.
*
* //////////////////////////////////////////////////////////////////////////////*/
// Prepare the attributes needed to create a sub-region.
AttributesFactory MyAttributesFactory = new AttributesFactory();
/* The "scope" determines how changes to the local cache are "broadcast"
* to like-named regions in other caches.
*
* For native clients DistributedAck and DistributedNoAck work
* identically.
*/
MyAttributesFactory.SetScope(ScopeType.DistributedAck);
/* Endpoints is a comma delimited list of logical names, hostnames, and ports of
* "server" caches with which to connect. The endpoints parameter follows this syntax:
*
* logicalName1=host1:port1, . . . ,logicalNameN=hostN:portN
*/
MyAttributesFactory.SetEndpoints("localhost:40404");
MyAttributesFactory.SetClientNotificationEnabled(true);
/* Because of implementation details, it is best not to cache data in a root-level
* region. There is nothing special about the name "root", it is just a good naming
* convention.
*
* Get the "root" region from the cache and create a sub-region under it for the
* data.
*/
Region MyExampleRegion = MyCache.GetRegion("root").CreateSubRegion(
"exampleRegion", MyAttributesFactory.CreateRegionAttributes());
Console.WriteLine(String.Format("{0}* Region, {1}, was created in the cache.",
Environment.NewLine, MyExampleRegion.FullPath));
Console.WriteLine("* Getting three values from the Hierarchical Server.");
// Retrieve several values from the cache.
for (int nCount = 0; nCount < 4; nCount++)
{
sKey = string.Format("Key{0}", nCount);
Console.WriteLine(String.Format("* Requesting object: {0}{1}",
sKey, Environment.NewLine));
/* Request the object from the cache. Because it doesn't exist in the local
* cache, it will be passed to the server. Because the server doesn't have
* it, the request will be passed to SimpleCacheLoader.Load(). The entry
* returned is a string.
*/
sValue = MyExampleRegion.Get(sKey) as CacheableString;
Console.WriteLine(String.Format("* Retrieved object: ({0})", sValue.ToString()));
}
Console.WriteLine("* If you look at the Cache Server's console, you can see the CacheListener notifications that happened in response to the gets.");
Console.WriteLine("{0}---[ Press <Enter> to continue. ]---", Environment.NewLine);
Console.ReadLine();
/*//////////////////////////////////////////////////////////////////////////////
*
* Exercise the serialization and deserialization methods.
*
* //////////////////////////////////////////////////////////////////////////////*/
// Demonstrate the process needed to manually deserialize the object from the cache.
Console.WriteLine(string.Format("* Manually deserializing the object for Key0: ({0})", MyExampleRegion.Get("Key0")));
// Demonstrate the static FromCache method in the CachedItem class and modify the object.
Console.WriteLine("* Using the FromCache() method and modifying the object for Key0");
// Get the item.
//sValue = (CacheableString)MyExampleRegion.Get("Key0");
sValue = MyExampleRegion.Get("Key0") as CacheableString;
Console.WriteLine(string.Format("* Original value: ({0})", sValue.ToString()));
/* This modifies the object associated with Key0 and uses CacheSerializer
* to perform manual serialization.
*/
String cachedItem = "PDA";
MyExampleRegion.Put("Key0", cachedItem);
// Reread the object from the cache.
sValue = (CacheableString)MyExampleRegion.Get("Key0");
Console.WriteLine(string.Format("* Retrieved updated object: {0}", sValue));
Console.WriteLine("* Invalidating the data for Key2");
/* Invalidating a cached item causes the object to be removed, but the
* key remains in the cache. If it is subsequently requested it will
* be retrieved using a CacheLoader if possible.
*/
MyExampleRegion.Invalidate("Key2");
Console.WriteLine("* Requesting Key2 after the invalidation.");
// Request the invalidated item.
sValue = (CacheableString)MyExampleRegion.Get("Key2");
Console.WriteLine(string.Format("* Retrieved object: {0}", sValue));
Console.WriteLine("* Destroying Key3");
// Destroying a cached item removes both the object and the key.
MyExampleRegion.Destroy("Key3");
Console.WriteLine("{0}---[ Press <Enter> to End the Application ]---",
Environment.NewLine);
Console.ReadLine();
}
catch (Exception ThrownException)
{
Console.Error.WriteLine(ThrownException.Message);
Console.Error.WriteLine(ThrownException.StackTrace);
Console.Error.WriteLine("---[ Press <Enter> to End the Application ]---");
Console.ReadLine();
}
finally
{
/* While there are not any ramifications of terminating without closing the cache
* and disconnecting from the distributed system, it is considered a best practice
* to do so.
*/
try
{
Console.WriteLine("Closing the cache and disconnecting.{0}",
Environment.NewLine);
}
catch { /* Ignore any exceptions */ }
try
{
/* Close the cache. This terminates the cache and releases all the resources.
* Generally speaking, after a cache is closed, any further method calls on
* it or region object will throw an exception.
*/
MyCache.Close();
}
catch { /* Ignore any exceptions */ }
try
{
/* Disconnect from the distributed system.
*/
MyDistributedSystem = null;
}
catch { /* Ignore any exceptions */ }
}
}