GemStone.GemFire.Cache.Generic NamespacePivotal GemFire .NET Client Documentation
This namespace contains all the Pivotal GemFire .NET Client Generic API classes and enumerations.
Classes

  ClassDescription
Public classAllConnectionsInUseException
Thrown when all connections in a pool are in use..
Public classAlreadyConnectedException
Thrown when an attempt is made to connect to DistributedSystem second time.
Public classAssertionException
A gemfire assertion exception.
Public classAttributesFactory TKey, TValue 
Public classAttributesMutator TKey, TValue 
Supports modification of certain region attributes after the region has been created.
Public classAuthenticatedCache
Provides a distributed cache.
Public classAuthenticationFailedException
Thrown when authentication to the server fails.
Public classAuthenticationRequiredException
Thrown when credentials are not provided to a server which expects them.
Public classAuthInitializeGeneric
Public classBufferSizeExceededException
Thrown when the internal buffer size is exceeded.
Public classCache
Provides a distributed cache.
Public classCacheableFileName
An immutable filename wrapper that can serve as a distributable key object for caching as well as being a string value.
Public classCacheableHashSet
A mutable ICacheableKey hash set wrapper that can serve as a distributable object for caching.
Public classCacheableKey
This class wraps the native C++ gemfire::Serializable objects as managed [!:../../IGFSerializable] objects.
Public classCacheableLinkedHashSet
A mutable ICacheableKey hash set wrapper that can serve as a distributable object for caching. This is provided for compability with java side though is functionally identical to CacheableHashSet i.e. does not provide the linked semantics of java LinkedHashSet.
Public classCacheableObject
An mutable generic Object wrapper that can serve as a distributable value for caching.
Public classCacheableObjectArray
A mutable IGFSerializable object array wrapper that can serve as a distributable object for caching. Though this class provides compatibility with java Object[] serialization, it provides the semantics of .NET generic List class.
Public classCacheableObjectXml
A mutable generic Object wrapper that can serve as a distributable value for caching.
Public classCacheableUndefined
Encapsulate an undefined result.
Public classCacheAttributes
Defines attributes for configuring a cache.
Public classCacheAttributesFactory
Creates instances of CacheAttributes.
Public classCacheClosedException
Thrown when an operation is attempted on a closed cache.
Public classCacheExistsException
Thrown when an attempt is made to create an existing cache.
Public classCacheFactory
A factory class that must be used to obtain instance of Cache.
Public classCacheListenerAdapter TKey, TValue 
Utility class that implements all methods in ICacheListener with empty implementations. Applications can subclass this class and only override the methods for the events of interest.
Public classCacheListenerException
Thrown when the cache listener throws an exception.
Public classCacheListenerGeneric TKey, TValue 
Public classCacheLoader
CacheLoader
Public classCacheLoaderException
Thrown when the cache loader aborts the operation.
Public classCacheLoaderGeneric TKey, TValue 
Public classCacheProxyException
Thrown when there is an error in the cache proxy.
Public classCacheServerException
Thrown when an exception occurs on the cache server.
Public classCacheStatistics
Defines common statistical information for both the region and its entries.
Public classCacheTransactionManager
CacheTransactionManager encapsulates the transactions for a cache
Public classCacheWriterAdapter TKey, TValue 
Utility class that implements all methods in ICacheWriter with empty implementations. Applications can subclass this class and only override the methods for the events of interest.
Public classCacheWriterException
Thrown when the cache writer aborts the operation.
Public classCacheWriterGeneric TKey, TValue 
Public classCacheXmlException
Thrown when the cache xml is incorrect.
Public classClassCastException
Thrown when a cast operation fails.
Public classCommitConflictException
Thrown if commit fails.
Public classConcurrentModificationException
Thrown when a concurrent operation fails.
Public classCqAttributes TKey, TResult 
Defines attributes for configuring a cq.
Public classCqAttributesFactory TKey, TResult 
Creates instances of CqAttributes.
Public classCqAttributesMutator TKey, TResult 
Supports modification of certain cq attributes after the cq has been created.
Public classCqClosedException
Thrown if the Cq on which the operaion performed is closed
Public classCqEvent TKey, TResult 
This class encapsulates events that occur for cq.
Public classCqException
Thrown during continuous query execution time.
Public classCqExistsException
Thrown if a Cq by this name already exists on this client
Public classCqInvalidException
Thrown when cq is invalid
Public classCqListenerGeneric TKey, TResult 
Public classCqOperation
Public classCqQuery TKey, TResult 
Class to encapsulate a continuous query (CQ).
Public classCqQueryException
Thrown if the Cq Query failed
Public classCqServiceStatistics
Defines common statistical information for cqservice
Public classCqState
Static class containing convenience methods for CqState.
Public classCqStatistics
Defines common statistical information for a cq.
Public classCqStatusListenerGeneric TKey, TResult 
Public classDataInput
Provides operations for reading primitive data values, byte arrays, strings, IGFSerializable objects from a byte stream.
Public classDataOutput
Provides operations for writing primitive data values, and user-defined objects implementing IGFSerializable, to a byte stream. This class is intentionally not thread safe.
Public classDiskCorruptException
Thrown by the persistence manager when the data to be read from disk is corrupt.
Public classDiskFailureException
Thrown by the persistence manager when a write fails due to disk failure.
Public classDiskPolicy
Static class containing convenience methods for DiskPolicyType.
Public classDistributedSystem
DistributedSystem encapsulates this applications "connection" into the GemFire Java servers.
Public classDuplicateDurableClientException
Thrown when a duplicate durable client id is provided to the server.
Public classEntryDestroyedException
Thrown when an operation is attempted on a destroyed entry.
Public classEntryEvent TKey, TValue 
This class encapsulates events that occur for an entry in a region.
Public classEntryExistsException
Thrown when attempt is made to create an existing entry.
Public classEntryNotFoundException
Thrown when an operation is attempted on a non-existent entry.
Public classExecution TResult 
This class encapsulates events that occur for cq.
Public classExpiration
Static class containing convenience methods for ExpirationAction.
Public classFatalInternalException
Thrown when there is a fatal internal exception in GemFire.
Public classFileNotFoundException
Thrown when a non-existing file is accessed.
Public classFixedPartitionResolverGeneric TKey, TValue 
Public classFunctionExecutionException
Thrown when function execution failed
Public classFunctionService TResult 
Public classGemFireClassIds
Static class containing the classIds of the built-in cacheable types.
Public classGemFireConfigException
Thrown when gemfire configuration file is incorrect.
Public classGemFireException
The base exception class of all managed GemFire exceptions.
Public classGemFireIOException
Thrown when there is an input/output error.
Public classIllegalArgumentException
Thrown when an argument to a method is illegal.
Public classIllegalStateException
Thrown when the state of cache is manipulated to be illegal.
Public classInitFailedException
Thrown when persistence manager fails to initialize.
Public classInterruptedException
Thrown when an operation is interrupted.
Public classInvalidDeltaException
Public classKeyNotFoundException
Thrown if a Key is not present in the region.
Public classLeaseExpiredException
Thrown when lease of cache proxy has expired.
Public classLocalRegion TKey, TValue 
Public classLog
Defines methods available to clients that want to write a log message to their GemFire system's shared log file.
Public classMessageException
Thrown when an unknown message is received from the server.
Public classNoAvailableLocatorsException
Thrown when a client is unable to contact any locators.
Public classNoSystemException
Thrown when the connecting target is not running.
Public classNotAuthorizedException
Thrown when a client operation is not authorized on the server.
Public classNotConnectedException
Thrown when an operation is attempted before connecting to the distributed system.
Public classNotOwnerException
Thrown when an attempt is made to release a lock not owned by the thread.
Public classNullPointerException
Thrown when a null argument is provided to a method where it is expected to be non-null.
Public classOutOfMemoryException
Thrown when the system cannot allocate any more memory.
Public classOutOfRangeException
Thrown when bound of array/vector etc. is exceeded.
Public classPartitionResolverGeneric TKey, TValue 
Public classPdxIdentityFieldAttribute
Public classPersistenceManagerGeneric TKey, TValue 
Public classPool
A pool of connections.
Public classPoolFactory
This interface provides for the configuration and creation of instances of Pool.
Public classPoolManager
This interface provides for the configuration and creation of instances of PoolFactory.
Public classProperties TPropKey, TPropValue 
Provides a collection of properties, each of which is a key/value pair. Each key is a string, and the value may be a string or an integer.
Public classQuery TResult 
Class to encapsulate a query.
Public classQueryException
Thrown when query exception occurs at the server.
Public classQueryService TKey, TResult 
Provides a query service.
Public classReflectionBasedAutoSerializer
Public classRegion TKey, TValue 
Public classRegionAttributes TKey, TValue 
Defines attributes for configuring a region.
Public classRegionCreationFailedException
Thrown when a region creation operation fails.
Public classRegionDestroyedException
Thrown when an operation is attempted on a destroyed region.
Public classRegionEntry TKey, TValue 
An object in a region that represents an entry, that is, a key-value pair.
Public classRegionEvent TKey, TValue 
This class encapsulates events that occur for a region.
Public classRegionExistsException
Thrown when an attempt is made to create an existing region.
Public classRegionFactory
This interface provides for the configuration and creation of instances of Region.
Public classResultCollector TResult 
collect function execution results, default collector
Public classResultCollectorGeneric TResult 
Public classResultSet TResult 
Encapsulates a query result set. It specifies the interface for the resultset obtained from the Gemfire cache server
Public classSafeConvertClassGeneric
Public classScope
Static class containing convenience methods for ScopeType.
Public classSelectResultsIterator TResult 
Iterator for a query result.
Public classSerializable
This class wraps the native C++ gemfire::Serializable objects as managed IGFSerializable objects.
Public classShutdownFailedException
Thrown when persistence manager fails to close properly.
Public classStatisticDescriptor
A class that describes an individual statistic whose value is updated by an application and may be archived by GemFire. These descriptions are gathered together in a StatisticsType class.
Public classStatistics
An instantiation of an existing StatisticsType object with methods for setting, incrementing and getting individual StatisticDescriptor values.
Public classStatisticsDisabledException
Thrown when statistics are invoked for a region where they are disabled.
Public classStatisticsFactory
Instances of this interface provide methods that create instances of StatisticDescriptor and StatisticsType. Every StatisticsFactory is also a type factory.
Public classStatisticsType
This class is used to describe a logical collection of StatisticDescriptors.These descriptions are used to create an instance of Statistics class.
Public classStruct
Encapsulates a row of query struct set.
Public classStructSet TResult 
Encapsulates a query struct set.
Public classSystemProperties
A class for internal use, that encapsulates the properties that can be set through Connect(String) or a gfcpp.properties file.
Public classTimeoutException
Thrown when a timout occurs.
Public classTransactionDataNodeHasDepartedException
Thrown if transaction delegate went down.
Public classTransactionDataRebalancedException
Thrown if commit rebalance happens during a transaction.
Public classTransactionId
This class encapsulates Id of a transaction.
Public classUnknownException
An unknown exception occurred.
Public classUnsupportedOperationException
Thrown when an operation unsupported by the current configuration is attempted.
Public classUserFunctionExecutionException
UserFunctionExecutionException class is used to encapsulate gemfire sendException in case of Function execution.
Public classWrongRegionScopeException
Thrown when a region is created in an incorrect scope.
Interfaces

  InterfaceDescription
Public interfaceIAuthInitialize
Specifies the mechanism to obtain credentials for a client. It is mandantory for clients when the server is running in secure mode having a security-client-authenticator module specified. Implementations should register the library path as security-client-auth-library system property and factory function (a zero argument function returning pointer to an AuthInitialize object) as the security-client-auth-factory system property. For a managed class implementing IAuthInitialize the fully qualified name of the factory function should be provided in the form {Namespace}.{Class Name}.{Method Name} as the security-client-auth-factory property.
Public interfaceICacheableKey
This interface class is the superclass of all user objects in the cache that can be used as a key.
Public interfaceICacheListener TKey, TValue 
An application plug-in that can be installed on a region.
Public interfaceICacheLoader TKey, TValue 
A data-loading application plug-in that can be installed on a region.
Public interfaceICacheLoaderProxy
Public interfaceICacheWriter TKey, TValue 
An application plug-in that can be installed on a region. Defines methods that are called before entry modification, such as writing the value to a database.
Public interfaceICqEvent TKey, TResult 
An application plug-in that can be installed on a region. Listener change notifications are invoked after the change has occured.
Public interfaceICqListener TKey, TResult 
An application plug-in that can be installed on a region. Listener change notifications are invoked after the change has occured.
Public interfaceICqResults TResult 
Interface to encapsulate a select query result set.
Public interfaceICqStatusListener TKey, TResult 
Extension of CqListener. Adds two new methods to CqListener, one that is called when the cq is connected and one that is called when the cq is disconnected.
Public interfaceIFixedPartitionResolver TKey, TValue 
Public interfaceIFixedPartitionResolverProxy
Public interfaceIGemFireCache
GemFireCache represents the singleton cache that must be created in order to connect to Gemfire server.
Public interfaceIGFDelta
This interface is used for delta propagation. To use delta propagation, an application class must implement interfaces IGFDelta as well as IGFSerializable. The IGFDelta interface methods HasDelta( ), ToDelta( ) and FromDelta( ) must be implemented by the class, as these methods are used by GemFire to detect the presence of delta in an object, to serialize the delta, and to apply a serialized delta to an existing object of the class. If a customized cloning method is required, the class must also implement the interface System.ICloneable. To use cloning in delta propagation for a region, the region attribute for cloning must be enabled.
Public interfaceIGFSerializable
This interface class is the superclass of all user objects in the cache that can be serialized.
Public interfaceIPartitionResolver TKey, TValue 
Public interfaceIPartitionResolverProxy
Public interfaceIPdxInstance
PdxInstance provides run time access to the fields of a PDX without deserializing the PDX. Preventing deserialization saves time and memory and does not require the domain class. This interface is implemented by NativeClient. The PdxInstance implementation is a light weight wrapper that simply refers to the raw bytes of the PDX that are kept in the cache. Applications can choose to access PdxInstances instead of .NET objects by configuring the Cache to prefer PDX instances during deserialization. This can be done in cache.xml by setting the attribute read-serialized to true on the pdx element. Or it can be done programmatically using the [!:CacheFactory.SetPdxReadSerialized] method. Once this preference is configured, then any time deserialization of a PDX is done it will deserialize into a PdxInstance. PdxInstance are immutable. If you want to change one call [!:IPdxInstance.CreateWriter].
Public interfaceIPdxInstanceFactory
PdxInstanceFactory gives you a way to create PdxInstances. Call the write methods to populate the field data and then call Create  to produce an actual instance that contains the data. To create a factory call [!:IRegionService.CreatePdxInstanceFactory]. A factory can only create a single instance. To create multiple instances create multiple factories or use [!:IPdxInstance.CreateWriter] to create subsequent instances.
Public interfaceIPdxReader
A IPdxReader will be passed to IPdxSerializable.fromData or during deserialization of a PDX. The domain class needs to deserialize field members using this interface. This interface is implemented by Native Client. Each readXXX call will return the field's value. If the serialized PDX does not contain the named field then a default value will be returned. Standard Java defaults are used. For Objects this is null and for primitives it is 0 or 0.0.
Public interfaceIPdxSerializable
When a domain class implements PdxSerializable it marks itself as a PDX. The implementation of toData provides the serialization code and fromData provides the deserialization code. These methods also define each field name and field type of the PDX. Domain classes should serialize and de-serialize all its member fields in same order in toData and fromData method. A domain class which implements this interface should register delgate [!:Serializable.RegisterPdxType] to create new instance of type for de-serilization.
Public interfaceIPdxSerializer
The IPdxSerializer interface allows domain classes to be serialized and deserialized as PDXs without modification of the domain class. A domain class should register delgate [!:Serializable.RegisterPdxType] to create new instance of type for de-serilization.
Public interfaceIPdxTypeMapper
Application can implement this interface to map pdx type name to local type name. Need to set this using [!:Serializable.SetPdxTypeMapper]
Public interfaceIPdxUnreadFields
Serialize the data in gemfire Portable Data eXchange(Pdx) Format. This format provides class versioning(forward and backward compability of types) in cache. This provides ability to query .NET domian objects.
Public interfaceIPdxWriter
A IPdxWriter will be passed to IPdxSerializable.toData when it is serializing the domain class. The domain class needs to serialize member fields using this interface. This interface is implemented by Native Client.
Public interfaceIPersistenceManager TKey, TValue 
IPersistenceManager interface for persistence and overflow. This class abstracts the disk-related operations in case of persistence or overflow to disk. A specific disk storage implementation will implement all the methods described here.
Public interfaceIPersistenceManagerProxy
Public interfaceIRegion TKey, TValue 
Public interfaceIRegionService
Public interfaceIResultCollector TResult 
collect function execution results, can be overriden
Public interfaceISelectResults TResult 
Interface to encapsulate a select query result set.
Public interfaceISubscriptionService TKey 
Public interfaceIWritablePdxInstance
WritablePdxInstance is a [!:IPdxInstance] that also supports field modification using the SetField(String, Object)method. To get a WritablePdxInstance call [!:IPdxInstance.CreateWriter].
Public interfaceResultCollectorG
Delegates

  DelegateDescription
Public delegatePdxTypeFactoryMethod
Signature of function delegates passed to [!:Serializable.RegisterPdxType]. Such functions should return an empty instance of the type they represent. New instance will be created during de-serialization of Pdx Types IPdxSerializable.
Public delegatePropertyVisitorGeneric TPropKey, TPropValue 
Delegate that represents visitor for the Properties class.
Public delegateTypeFactoryMethodGeneric
Signature of function delegates passed to RegisterType(TypeFactoryMethod). Such functions should return an empty instance of the type they represent. The delegate shall be stored in the internal DelegateWrapper class and an instance will be initialized in the DelegateWrapper.NativeDelegate method by a call to FromData(DataInput).
Enumerations

  EnumerationDescription
Public enumerationCqOperationType
Enumerated type for CqOperationType
Public enumerationCqStateType
Enumerated type for cq state @nativeclient For Native Clients: @endnativeclient
Public enumerationDiskPolicyType
Enumerated type for disk policy. Contains values for setting the disk policy type.
Public enumerationExpirationAction
Enumerated type for expiration (LRU) actions. Contains values for setting an action type.
Public enumerationFieldType
Enumerated type for pdx FieldType
Public enumerationLogLevel
Logging levels.
Public enumerationRegionShortcut
Public enumerationScopeType
Enumerated type for region distribution scope. Contains values for setting Scope. Local scope is invalid (it is a non-native client local region), and DistributedAck and DistributedNoAck have the same behavior.