Factory class to create instances of RegionAttributes.

Namespace: GemStone.GemFire.Cache
Assembly:  GemStone.GemFire.Cache (in GemStone.GemFire.Cache.dll)


public sealed class AttributesFactory : UMWrap<gemfire::AttributesFactory>
Visual Basic (Declaration)
Public NotInheritable Class AttributesFactory _
	Inherits UMWrap<gemfire::AttributesFactory>
Visual C++
public ref class AttributesFactory sealed : public UMWrap<gemfire::AttributesFactory>


An AttributesFactory instance maintains state for creating RegionAttributes instances. The setter methods are used to change the settings that will be used for creating the next attributes instance with the CreateRegionAttributes()() method. If you create a factory with the default constructor, then the factory is set up to create attributes with all default settings. You can also create a factory by providing a preset RegionAttributes.

Once a RegionAttributes is created, it can only be modified after it has been used to create a Region, and then only by using an AttributesMutator obtained from the region.



ICacheLoader [default: null]
User-implemented plug-in for loading data on cache misses.
see SetCacheLoader(ICacheLoader), CacheLoader
ICacheWriter [default: null]
User-implemented plug-in for intercepting cache modifications, e.g. for writing to an external data source.
see SetCacheWriter(ICacheWriter), CacheWriter
ICacheListener [default: null]
User-implemented plug-in for receiving and handling cache-related events.
see SetCacheListener(ICacheListener), CacheListener


RegionTimeToLive [default: no expiration]
Expiration configuration for the entire region based on the lastModifiedTime ( LastModifiedTime ).
see SetRegionTimeToLive(ExpirationAction, UInt32), RegionTimeToLive, SetRegionTimeToLive(Int32)
RegionIdleTimeout [default: no expiration]
Expiration configuration for the entire region based on the lastAccessedTime ( LastAccessedTime ).
see SetRegionIdleTimeout(ExpirationAction, UInt32), RegionIdleTimeout, SetRegionIdleTimeout(Int32)
EntryTimeToLive [default: no expiration]
Expiration configuration for individual entries based on the lastModifiedTime ( LastModifiedTime ).
see SetEntryTimeToLive(ExpirationAction, UInt32), EntryTimeToLive, SetEntryTimeToLive(Int32)
EntryIdleTimeout [default: no expiration]
Expiration configuration for individual entries based on the lastAccessedTime ( LastAccessedTime ).
see SetEntryIdleTimeout(ExpirationAction, UInt32), EntryIdleTimeout, SetEntryIdleTimeout(Int32)


ScopeType [default:ScopeType.DistributedNoAck]
Properties of distribution for the region, including whether it is distributed at all, whether acknowledgements are required, and whether distributed synchronization is required.
see SetScope(ScopeType), Scope
@endcacheserver @nativeclient
ScopeType [default:ScopeType.DistributedNoAck]
The C++ cache can contain either local regions or distributed regions. Distributed regions are configured with servers that they distribute their operations to upto. Locally scoped regions do not have any distribution behavior. GFE native client regions scoped as ScopeType.DistributedNoAck and ScopeType.DistributedAck have identical distribution behavior.
see SetScope(ScopeType), Scope


Mirroring (boolean) [default:false]
Whether or not to enable mirroring in this region, used to keep regions across caches automatically in sync with respect to new key creation and the values associated with those keys. Note that subregion creation is never propagated automatically. A mirrored region also gets initialized when it is created with the superset of all the keys and value from the region with the same name in all other caches in the distributed system.
see SetMirroring(Boolean), Mirroring
InitialCapacity [default:16]
The initial capacity of the map used for storing the entries.
see SetInitialCapacity(Int32), InitialCapacity
LoadFactor [default:0.75]
The load factor of the map used for storing the entries.
see SetLoadFactor(Single), LoadFactor
ConcurrencyLevel [default:16]
The allowed concurrency among updates to values in the region is guided by the concurrencyLevel, which is used as a hint for internal sizing. The actual concurrency will vary. Ideally, you should choose a value to accommodate as many threads as will ever concurrently modify values in the region. Using a significantly higher value than you need can waste space and time, and a significantly lower value can lead to thread contention. But overestimates and underestimates within an order of magnitude do not usually have much noticeable impact. A value of one is appropriate when it is known that only one thread will modify and all others will only read.
see SetConcurrencyLevel(Int32), ConcurrencyLevel


Note that the RegionAttributes are not distributed with the region.


Inheritance Hierarchy

See Also