Here are the classes, structs, unions and interfaces with brief descriptions:

CCacheClosedException	Exception thrown when an operation is attempted upon a closed Cache
CCacheFactory	This factory class is the entry point and used to create the root class for this library
CGemFireClientRequestTimedOutException	Exception for when client requests time out
CGemFireException	Base exception for .NET client for GemFire
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
CGemFireSecureSocketsRequiredException	Exception used to indicate that TLS is enabled on the Server and is required on the Client as well
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
CGemFireUnregisteredPdxTypeException	Exception denoting attempted usage of an unregistered Pdx type
CGemFireUnregisteredTypeException	Exception for unregistered types
CIAuthInitialize	Specifies the mechanism to obtain credentials for a client
CICache	Provides a client cache
CICacheableKey	This interface class is the superclass of all user objects in the cache that can be used as a key
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
CICacheFunctionService	Interface for Cache level Function Service
CICacheListener	An application plug-in that can be installed on a region
CICqAttributes	Defines attributes for configuring a cq
CICqAttributesFactory	Interface for CQ attributes factory
CICqEvent	Interface representing Continuous Query events from server
CICqListener	An application plug-in that can be installed on a region. Continuous Query Listener change notifications are invoked `after` the change has occured
CICqQuery	Class to encapsulate a continuous query (CQ)
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
CIDataSerializable	Interface for user defined serializable domain objects
CIEntryEvent	This class encapsulates events that occur for an entry in a region
CIJsonDocument	Interface for JsonDocument
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])
CIOpMetric	Interface for Operation Metrics
CIPartitionResolver	Implementers of interface
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"/>
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
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
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
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	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	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	Class to encapsulate a remote query
CIQueryService	Provides a query service
CIReflectionBasedAutoSerializer	Interface for reflection based automatic serializer
CIRegion	Encapsulates a concrete region of cached data
CIRegionEvent	This class encapsulates events that occur for a region
CIRegionExecution	Interface for IRegion<TKey, TValue> level function executor
CIRegionFactory	This interface provides for the configuration and creation of instances of Region
CIRegionFunctionService	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
CISubscriptionService	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
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

VMware Tanzu GemFire .NET Client API Reference