This inheritance list is sorted roughly, but not completely, alphabetically:

[detail level 123]

▼CGemFireException	Base exception for .NET client for GemFire
CCacheClosedException	Exception thrown when an operation is attempted upon a closed Cache
CGemFireClientRequestTimedOutException	Exception for when client requests time out
CGemFireIllegalArgumentException	Exception for illegal arguments to this library
CGemFireIllegalStateException	Exception used to indicate actions have resulted in an improper state of this library
CGemFireQueryException	Exception related to Queries
CGemFireResponseException	Exception for responses from server
CGemFireSubscriptionReauthenticateException	Exception to indicate the server has requested re-authentication on subscription channel
CGemFireTypeException	Exception denoting an issue with type and/or serialization of a type
▼CGemFireUnregisteredTypeException	Exception for unregistered types
CGemFireUnregisteredPdxTypeException	Exception denoting attempted usage of an unregistered Pdx type
CGemFireSecureSocketsRequiredException	Exception used to indicate that TLS is enabled on the Server and is required on the Client as well
CIAuthInitialize	Specifies the mechanism to obtain credentials for a client
CICacheExecution	Interface used to perform ICache level function execution
▼CICacheFactory	This interface provides for the configuration and creation of instances of Cache. Setters and configuration methods all return ICacheFactory to enable use of the Builder pattern
CCacheFactory	This factory class is the entry point and used to create the root class for this library
CICacheFunctionService	Interface for Cache level Function Service
CICacheListener< TKey, TValue >	An application plug-in that can be installed on a region
CICqAttributes< TKey, TResult >	Defines attributes for configuring a cq
CICqAttributesFactory< TKey, TResult >	Interface for CQ attributes factory
CICqEvent< TKey, TResult >	Interface representing Continuous Query events from server
CICqEvent< TKey, TValue >
CICqListener< TKey, TResult >	An application plug-in that can be installed on a region. Continuous Query Listener change notifications are invoked `after` the change has occured
CICqQuery< TKey, TResult >	Class to encapsulate a continuous query (CQ)
CICqQuery< TKey, TValue >
CIDataInput	Provides operations for reading primitive data values, byte arrays, strings, `ISerializable` objects from a byte stream
CIDataOutput	Provides operations for writing primitive data values, and user-defined objects implementing ISerializable, to a byte stream. This class is intentionally not thread safe
CIEntryEvent< TKey, TValue >	This class encapsulates events that occur for an entry in a region
CIJsonDocumentFactory	Interface for Json document factory
▼CIJsonSerialCacheable	Inherit from this interface to allow a class instance to be cached to GemFire as serialized, queryable JSON. If a region's TValue is typed with a class implementing this interface, the default System.Text.Json deserializer will be used, i.e. System.Text.Json.JsonSerializer This allows for custom serialization and deserialization through `System.Text.Json` attributes (e.g. [JsonConverter], [JsonPropertyName])
CIJsonDocument	Interface for JsonDocument
CIOpMetric	Interface for Operation Metrics
CIPartitionResolver< TKey, TValue >	Implementers of interface
CIPdxInstanceFactory	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 ICache.CreatePdxInstanceFactory. A factory can only create a single instance. To create multiple instances create multiple factories or use IPdxInstance.CreateWriter to create subsequent instances
CIPdxReader	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. 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
▼CIPdxSerializer	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 ITypeRegistry.RegisterPdxType to create new instance of type for de-serialization
CIReflectionBasedAutoSerializer	Interface for reflection based automatic serializer
CIPdxTypeMapper	Interface for mapping Pdx types
CIPdxUnreadFields	Interface for Pdx unread Fields
CIPdxWriter	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
CIPersistenceManager< 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
CIPool	A pool of connections
CIProperties< 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
CIQuery< TResult >	Class to encapsulate a remote query
CIQuery< TValue >
CIQueryService	Provides a query service
CIRegion< TKey, TValue >	Encapsulates a concrete region of cached data
CIRegionEvent< TKey, TValue >	This class encapsulates events that occur for a region
CIRegionExecution< TKey, TValue >	Interface for IRegion<TKey, TValue> level function executor
CIRegionFactory	This interface provides for the configuration and creation of instances of Region
CIRegionFunctionService< TKey, TValue >	Interface for IRegion<TKey, TValue> function services
CIResultCollector	Interface for result collection from queries
▼CISerializable	This interface class is the superclass of all user objects in the cache that can be serialized
CICacheableKey	This interface class is the superclass of all user objects in the cache that can be used as a key
CIDataSerializable	Interface for user defined serializable domain objects
CIPdxInstance	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 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 see cref="CreateWriter"/>
CIPdxSerializable	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 ITypeRegistry.RegisterPdxType to create new instance of type for de-serialization
CISubscriptionService< TKey >	This generic interface class provides all Register Interest API's for GemFire's generic non local region IRegion<TKey, TValue>
CISystemProperties	A class that encapsulates the GemFire client properties
CITransactionId	Interface for Transaction Ids
▼CITransactionManager	ITransactionManager encapsulates the transactions for a cache
CICache	Provides a client cache
CITypeRegistry	Registry for custom serializable types, both PDXSerializable and DataSerializable
CIWritablePdxInstance	WritablePdxInstance is a IPdxInstance that also supports field modification using the SetFieldmethod. To get a WritablePdxInstance call IPdxInstance.CreateWriter
CPoolStats.PoolLocatorStats	Nested classes about meter namespaces..

VMware Tanzu GemFire .NET Client API Reference