Class Hierarchy

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

[detail level 1234]

CApache.Ignite.Core.Cache.Affinity.AffinityFunctionContext	Affinity function context.
CApache.Ignite.Core.DataStructures.Configuration.AtomicConfiguration	Configuration for atomic data structures.
►CAttribute
CApache.Ignite.Core.Binary.TimestampAttribute	Instructs the serializer to write DateTime fields and properties in Timestamp format, which is interoperable with other platforms and works in SQL, but does not allow non-UTC values
CApache.Ignite.Core.Cache.Affinity.AffinityKeyMappedAttribute	Specifies cache key field to be used to determine a node on which given cache key will be stored. Only one field or property can be marked with this attribute
CApache.Ignite.Core.Cache.Configuration.QuerySqlFieldAttribute	Marks field or property for SQL queries
CApache.Ignite.Core.Cache.Configuration.QueryTextFieldAttribute	Marks field or property for Text queries
CApache.Ignite.Core.Compute.ComputeTaskNoResultCacheAttribute	This attribute disables caching of task results when attached to IComputeTask<A,T,R> instance. Use it when number of jobs within task grows too big, or jobs themselves are too large to keep in memory throughout task execution. By default all results are cached and passed into IComputeTask<TA,T,TR>.OnResult and IComputeTask<A,T,R>.Reduce methods. When this attribute is attached to a task class, then this list of job results will always be empty.
CApache.Ignite.Core.Plugin.PluginProviderTypeAttribute	When applied to IPluginConfiguration, defines the type of IPluginProvider<T> to instantiate.
CApache.Ignite.Core.Resource.InstanceResourceAttribute	Attribute which injects IIgnite instance. Can be defined inside implementors of IComputeTask<A,T,TR> and IComputeJob interfaces. Can be applied to non-static fields, properties and methods returning void and accepting a single parameter.
CApache.Ignite.Core.Resource.StoreSessionResourceAttribute	Annotates a field or a setter method for injection of current ICacheStoreSession instance. It can be injected into ICacheStore.
CApache.Ignite.Core.Binary.BinaryConfiguration	Binary type configuration.
CApache.Ignite.Core.Binary.BinaryTypeConfiguration	Binary type configuration.
CApache.Ignite.Core.Binary.BinaryTypeNames	Binary type name constants.
CApache.Ignite.Core.Cache.Configuration.CacheConfiguration	Defines grid cache configuration.
CApache.Ignite.Linq.CacheLinqExtensions	Extensions methods for ICache<TK,TV>.
CApache.Ignite.Linq.CompiledQuery	Represents a compiled cache query.
►CConfigurationSection
CApache.Ignite.Core.IgniteConfigurationSection	Ignite configuration section for app.config and web.config files.
►CApache.Ignite.Core.Cache.Query.Continuous.ContinuousQuery	Continuous query base class, see ContinuousQuery<K, V>.
CApache.Ignite.Core.Cache.Query.Continuous.ContinuousQuery< TK, TV >	API for configuring continuous cache queries
CApache.Ignite.Core.Cache.Query.Continuous.ContinuousQueryExtensions	Extensions for continuous queries.
►CEventArgs
CApache.Ignite.Core.Lifecycle.ClientReconnectEventArgs	Contains client reconnect event data.
CApache.Ignite.Core.Events.EventType	Contains event type constants. The decision to use class and not enumeration is dictated by allowing users to create their own events and/or event types which would be impossible with enumerations
►CException
►CApache.Ignite.Core.Common.IgniteException	General Ignite exception. Indicates any error condition within Ignite.
CApache.Ignite.Core.Binary.BinaryObjectException	Indicates an error during binarization.
CApache.Ignite.Core.Cache.CacheEntryProcessorException	An exception to indicate a problem occurred attempting to execute an ICacheEntryProcessor<K, V, A, R> against an entry.
►CApache.Ignite.Core.Cache.CacheException	Indicates an error during Cache operation.
CApache.Ignite.Core.Cache.CacheAtomicUpdateTimeoutException	Indicates atomic operation timeout.
CApache.Ignite.Core.Cache.CachePartialUpdateException	Exception thrown from non-transactional cache in case when update succeeded only partially.
CApache.Ignite.Core.Cache.Store.CacheStoreException	Indicates an error during CacheStore operation.
CApache.Ignite.Core.Cluster.ClusterGroupEmptyException	Indicates an illegal call on empty projection. Thrown by projection when operation that requires at least one node is called on empty projection.
CApache.Ignite.Core.Cluster.ClusterTopologyException	Indicates an error with grid topology (e.g., crashed node, etc.)
CApache.Ignite.Core.Common.ClientDisconnectedException	Indicates that client-mode local node has been disconnected from the cluster.
CApache.Ignite.Core.Common.IgniteFutureCancelledException	Indicates future cancellation within Ignite.
CApache.Ignite.Core.Common.JavaException	Indicates an error on Java side and contains full Java stack trace.
CApache.Ignite.Core.Compute.ComputeExecutionRejectedException	Indicates a situation when execution service provided by the user in configuration rejects execution.
CApache.Ignite.Core.Compute.ComputeJobFailoverException	This runtime exception can be thrown from IComputeJob<T>.Execute() method to force job failover to another node within task topology. IComputeFunc<T,R> or IComputeFunc<T> passed into any of the ICompute methods can also throw this exception to force failover.
CApache.Ignite.Core.Compute.ComputeTaskCancelledException	This exception indicates that Ignite task was cancelled.
CApache.Ignite.Core.Compute.ComputeTaskTimeoutException	Indicates that task execution timed out.
CApache.Ignite.Core.Compute.ComputeUserUndeclaredException	This exception is thrown when user's code throws undeclared runtime exception. By user core it is assumed the code in Ignite task, Ignite job or SPI. In most cases it should be an indication of unrecoverable error condition such as assertion, out of memory error, etc.
CApache.Ignite.Core.Services.ServiceInvocationException	Indicates an error during Grid Services invocation.
CApache.Ignite.Core.Transactions.TransactionDeadlockException	Indicates a deadlock within Ignite transaction
CApache.Ignite.Core.Transactions.TransactionHeuristicException	Exception thrown whenever Ignite transaction enters an unknown state. This exception is usually thrown whenever commit partially succeeds. Cache will still resolve this situation automatically to ensure data integrity, by invalidating all values participating in this transaction on remote nodes.
CApache.Ignite.Core.Transactions.TransactionOptimisticException	Exception thrown whenever Ignite transactions fail optimistically.
CApache.Ignite.Core.Transactions.TransactionRollbackException	Exception thrown whenever Ignite transactions has been automatically rolled back.
CApache.Ignite.Core.Transactions.TransactionTimeoutException	Exception thrown whenever Ignite transactions time out.
CApache.Ignite.Core.Plugin.PluginNotFoundException	Indicates missing Ignite plugin.
►CApache.Ignite.Core.Cache.Affinity.IAffinityFunction	Represents a function that maps cache keys to cluster nodes
►CApache.Ignite.Core.Cache.Affinity.AffinityFunctionBase	Base class for predefined affinity functions.
CApache.Ignite.Core.Cache.Affinity.Rendezvous.RendezvousAffinityFunction	Affinity function for partitioned cache based on Highest Random Weight algorithm.
CApache.Ignite.Core.DataStructures.IAtomicLong	Represents a distributed atomic long value.
CApache.Ignite.Core.DataStructures.IAtomicReference< T >	Represents a named value in the distributed cache.
CApache.Ignite.Core.DataStructures.IAtomicSequence	Represents a distributed atomic sequence of numbers.
CApache.Ignite.Core.Binary.IBinarizable	Interface to implement custom serialization logic.
CApache.Ignite.Core.Binary.IBinary	Defines binary objects functionality. With binary objects you are able to: Seamlessly interoperate between Java, .NET, and C++. Make any object binary with zero code change to your existing code. Nest binary objects within each other. Automatically handle circular or null references. Automatically convert collections and maps between Java, .NET, and C++. Optionally avoid deserialization of objects on the server side. Avoid need to have concrete class definitions on the server side. Dynamically change structure of the classes without having to restart the cluster. Index into binary objects for querying purposes.
CApache.Ignite.Core.Binary.IBinaryIdMapper	Maps class name and class field names to integer identifiers.
►CApache.Ignite.Core.Binary.IBinaryNameMapper	Maps type and field names to different names.
CApache.Ignite.Core.Binary.BinaryBasicNameMapper	Base binary name mapper implementation.
CApache.Ignite.Core.Binary.IBinaryObject	Wrapper for serialized objects.
CApache.Ignite.Core.Binary.IBinaryObjectBuilder	binary object builder. Provides ability to build binary objects dynamically without having class definitions
CApache.Ignite.Core.Binary.IBinaryRawReader	Raw reader for binary objects.
CApache.Ignite.Core.Binary.IBinaryRawWriter	Raw writer for binary objects.
CApache.Ignite.Core.Binary.IBinaryReader	Reader for binary objects.
►CApache.Ignite.Core.Binary.IBinarySerializer	Binary serializer.
CApache.Ignite.Core.Binary.BinaryReflectiveSerializer	Binary serializer which reflectively writes all fields except of ones with System.NonSerializedAttribute
CApache.Ignite.Core.Binary.IBinaryType	Binary type metadata.
►CIBinaryWriteAware
CApache.Ignite.Core.Cache.Affinity.AffinityKey	Optional wrapper for cache keys to provide support for custom affinity mapping. The value returned by Affinity will be used for key-to-node affinity.
CApache.Ignite.Core.Common.IgniteGuid	Ignite guid with additional local ID.
CApache.Ignite.Core.Datastream.StreamTransformer< TK, TV, TArg, TRes >	Convenience adapter to transform update existing values in streaming cache based on the previously cached value.
CApache.Ignite.Core.Binary.IBinaryWriter	Writer for binary objects.
CApache.Ignite.Core.Cache.ICacheAffinity	Provides affinity information to detect which node is primary and which nodes are backups for a partitioned cache. You can get an instance of this interface by calling IIgnite.GetAffinity method
CApache.Ignite.Core.Cache.ICacheEntry< out out TK, out out TV >	Cache entry interface.
►CApache.Ignite.Core.Cache.ICacheEntry< TK, TV >
CApache.Ignite.Core.Cache.Event.ICacheEntryEvent< out out TK, out out TV >	Cache entry event.
CApache.Ignite.Core.Cache.IMutableCacheEntry< out out TK, TV >	Mutable representation of ICacheEntry<K, V>
CApache.Ignite.Core.Cache.Event.ICacheEntryEventFilter< TK, TV >	Cache entry event filter.
CApache.Ignite.Core.Cache.Event.ICacheEntryEventListener< TK, TV >	Cache entry event listener.
CApache.Ignite.Core.Cache.ICacheEntryFilter< in in TK, in in TV >	Cache entry predicate.
CApache.Ignite.Core.Cache.ICacheEntryProcessor< in in TK, TV, in in TArg, out out TRes >	An invocable function that allows applications to perform compound operations on a cache entry atomically, according the defined consistency of a cache
CApache.Ignite.Core.Cache.ICacheEntryProcessor< TK, TV, TArg, TRes >
CApache.Ignite.Core.Cache.ICacheEntryProcessorResult< out out TK, out out T >	Represents a result of processing ICacheEntry<K, V> by ICacheEntryProcessor<K, V, A, R>.
CApache.Ignite.Core.Cache.ICacheMetrics	Cache metrics used to obtain statistics on cache itself.
CApache.Ignite.Core.Plugin.Cache.ICachePluginConfiguration	Cache plugin configuration marker interface. Starting point to extend CacheConfiguration and extend existing cache functionality.
CApache.Ignite.Linq.ICacheQueryable	Common interface for cache queryables.
►CICacheStore
►CApache.Ignite.Core.Cache.Store.ICacheStore< TK, TV >	API for cache persistent storage for read-through and write-through behavior
CApache.Ignite.Core.Cache.Store.CacheParallelLoadStoreAdapter< TK, TV, TData >	Cache storage adapter with parallel loading in LoadAll method.
CApache.Ignite.Core.Cache.Store.CacheStoreAdapter< TK, TV >	Cache storage convenience adapter. It provides default implementation for bulk operations, such as LoadAll, PutAll and RemoveAll by sequentially calling corresponding Load, Put and Remove operations. Use this adapter whenever such behaviour is acceptable. However in many cases it maybe more preferable to take advantage of database batch update functionality, and therefore default adapter implementation may not be the best option. Note that LoadCache method has empty implementation because it is essentially up to the user to invoke it with specific arguments.
CApache.Ignite.Core.Cache.Store.ICacheStoreSession	Session for the cache store operations. The main purpose of cache store session is to hold context between multiple store invocations whenever in transaction. For example, you can save current database connection in the session Properties map. You can then commit this connection in the ICacheStore<K,V>.SessionEnd(bool) method.
►CApache.Ignite.Core.Cluster.IClusterGroup	Defines grid projection which represents a common functionality over a group of nodes. Grid projection allows to group Ignite nodes into various subgroups to perform distributed operations on them. All ForXXX(...)' methods will create a child grid projection from existing projection. If you create a new projection from current one, then the resulting projection will include a subset of nodes from current projection. The following code snippet shows how to create grid projections:
CApache.Ignite.Core.Cluster.ICluster	Represents whole cluster (group of all nodes in a cluster). All members are thread-safe and may be used concurrently from multiple threads.
CApache.Ignite.Core.Cluster.IClusterMetrics	Represents runtime information of a cluster. Apart from obvious statistical value, this information is used for implementation of load balancing, failover, and collision SPIs. For example, collision SPI in combination with fail-over SPI could check if other nodes don't have any active or waiting jobs and fail-over some jobs to those nodes
CApache.Ignite.Core.Cluster.IClusterNode	Interface representing a single cluster node. Use GetAttribute<T> or GetMetrics to get static and dynamic information about remote nodes. You can get a list of all nodes in grid by calling IClusterGroup.GetNodes on IIgnite instance
CApache.Ignite.Core.Cluster.IClusterNodeFilter	Represents cluster node filter.
►CApache.Ignite.Core.Communication.ICommunicationSpi	Communication SPI is responsible for data exchange between nodes
CApache.Ignite.Core.Communication.Tcp.TcpCommunicationSpi	TcpCommunicationSpi is default communication SPI which uses TCP/IP protocol and Java NIO to communicate with other nodes
CApache.Ignite.Core.Compute.ICompute	Defines Ignite functionality for executing tasks and closures over nodes in the IClusterGroup. Instance of ICompute is obtained from grid projection using IClusterGroup.GetCompute method
CApache.Ignite.Core.Compute.IComputeAction	Defines a void function having no arguments.
CApache.Ignite.Core.Compute.IComputeFunc< in in TArg, out out TRes >	Defines function having a single argument.
CApache.Ignite.Core.Compute.IComputeFunc< out out TRes >	Defines function having no arguments.
CApache.Ignite.Core.Compute.IComputeJob< out out TRes >	Defines executable unit for IComputeTask<A,T,R>. Ignite task gets split into jobs when IComputeTask<A,T,R>.Map(IList<IClusterNode>, A) method is called. This method returns all jobs for the task mapped to their corresponding Ignite nodes for execution. Grid will then serialize this jobs and send them to requested nodes for execution
►CApache.Ignite.Core.Compute.IComputeJob< T >
CApache.Ignite.Core.Compute.ComputeJobAdapter< T >	Convenience adapter for IComputeJob<T> implementations. It provides the following functionality:
CApache.Ignite.Core.Compute.IComputeJobResult< out out TRes >	Job execution result which gets passed to IComputeTask<TA,T,TR>.OnResult method.
CApache.Ignite.Core.Compute.IComputeReducer< in in TRes, out out TReduceRes >	Compute reducer which is capable of result collecting and reducing.
CApache.Ignite.Core.Compute.IComputeTask< in in TArg, TJobRes, out out TRes >	Ignite task interface defines a task that can be executed on the grid. Ignite task is responsible for splitting business logic into multiple Ignite jobs, receiving results from individual Ignite jobs executing on remote nodes, and reducing (aggregating) received jobs' results into final Ignite task result
►CApache.Ignite.Core.Compute.IComputeTask< object, TJobRes, TReduceRes >
CApache.Ignite.Core.Compute.IComputeTask< TJobRes, out out TReduceRes >	IComputeTask without an argument.
►CApache.Ignite.Core.Compute.IComputeTask< TArg, TJobRes, TTaskRes >
►CApache.Ignite.Core.Compute.ComputeTaskAdapter< TArg, TJobRes, TTaskRes >	Convenience adapter for IComputeTask<TArg,TJobRes,TTaskRes> interface
CApache.Ignite.Core.Compute.ComputeTaskSplitAdapter< TArg, TJobRes, TTaskRes >	This class defines simplified adapter for IComputeTask<A,T,R>. This adapter can be used when jobs can be randomly assigned to available Ignite nodes. This adapter is sufficient in most homogeneous environments where all nodes are equally suitable for executing grid job, see Split method for more details.
►CApache.Ignite.Core.Cache.Query.Continuous.IContinuousQueryHandle	Represents a continuous query handle.
CApache.Ignite.Core.Cache.Query.Continuous.IContinuousQueryHandle< T >	Represents a continuous query handle.
►CApache.Ignite.Core.Discovery.IDiscoverySpi	Represents a discovery service provider interface. Only predefined implementation is supported now: TcpDiscoverySpi.
CApache.Ignite.Core.Discovery.Tcp.TcpDiscoverySpi	TCP discover service provider.
►CIDisposable
CApache.Ignite.Core.Cache.ICacheLock	Cache locking interface. All members are thread-safe and may be used concurrently from multiple threads.
CApache.Ignite.Core.Cache.Query.Continuous.IContinuousQueryHandle< T >	Represents a continuous query handle.
CApache.Ignite.Core.Cache.Query.IQueryCursor< T >	Query result cursor. Can be processed either in iterative mode, or by taking all entries using IQueryCursor<T>.GetAll() method
CApache.Ignite.Core.Datastream.IDataStreamer< TK, TV >	Data streamer is responsible for loading external data into cache. It achieves it by properly buffering updates and properly mapping keys to nodes responsible for the data to make sure that there is the least amount of data movement possible and optimal network and memory utilization
CApache.Ignite.Core.IIgnite	Main entry point for all Ignite APIs. You can obtain an instance of IGrid through Ignition.GetIgnite(), or for named grids you can use Ignition.GetIgnite(string). Note that you can have multiple instances of IGrid running in the same process by giving each instance a different name. All members are thread-safe and may be used concurrently from multiple threads.
CApache.Ignite.Core.Transactions.ITransaction	Grid cache transaction
►CIEnumerable
CApache.Ignite.Core.Cache.Query.IQueryCursor< T >	Query result cursor. Can be processed either in iterative mode, or by taking all entries using IQueryCursor<T>.GetAll() method
►CIEnumerable< ICacheEntry< TK, TV >>
CApache.Ignite.Core.Cache.ICache< TK, TV >	Main entry point for Ignite cache APIs. You can get a named cache by calling IIgnite.GetCache<TK,TV> method
►CIEquatable
CApache.Ignite.Core.Cache.Affinity.AffinityKey	Optional wrapper for cache keys to provide support for custom affinity mapping. The value returned by Affinity will be used for key-to-node affinity.
CApache.Ignite.Core.Cache.Affinity.AffinityTopologyVersion	Affinity topology version.
CApache.Ignite.Core.Common.IgniteGuid	Ignite guid with additional local ID.
►CApache.Ignite.Core.Events.EventBase	Base event implementation.
CApache.Ignite.Core.Events.CacheEvent	In-memory database (cache) event.
CApache.Ignite.Core.Events.CacheQueryExecutedEvent	Cache query execution event.
CApache.Ignite.Core.Events.CacheQueryReadEvent	Cache query read event.
CApache.Ignite.Core.Events.CacheRebalancingEvent	In-memory database (cache) rebalancing event. Rebalance event happens every time there is a change
CApache.Ignite.Core.Events.CheckpointEvent	Grid checkpoint event.
CApache.Ignite.Core.Events.DiscoveryEvent	Grid discovery event.
CApache.Ignite.Core.Events.JobEvent	Ignite job event.
CApache.Ignite.Core.Events.TaskEvent	Ignite task event.
►CIEquatable< CacheResult< T >>
CApache.Ignite.Core.Cache.CacheResult< T >	Represents a cache operation result with a success flag.
►CApache.Ignite.Core.Events.IEvent	Represents a Ignite event.
CApache.Ignite.Core.Events.EventBase	Base event implementation.
CApache.Ignite.Core.Events.IEventFilter< in in T >	Represents an event filter.
CApache.Ignite.Core.Events.IEventListener< in in T >	Represents an event listener.
CApache.Ignite.Core.Events.IEvents	Provides functionality for event notifications on nodes defined by ClusterGroup. All members are thread-safe and may be used concurrently from multiple threads.
►CApache.Ignite.Core.Events.IEventStorageSpi	Manages local event storage
CApache.Ignite.Core.Events.MemoryEventStorageSpi	In-memory event storage.
CApache.Ignite.Core.Events.NoopEventStorageSpi	No-op event storage interface, does not store anything.
►CApache.Ignite.Core.Cache.Eviction.IEvictionPolicy	Represents a cache eviction policy. Only predefined implementations are supported now: LruEvictionPolicy, FifoEvictionPolicy.
CApache.Ignite.Core.Cache.Eviction.EvictionPolicyBase	Base class for predefined eviction policies.
►CApache.Ignite.Core.Cache.Expiry.IExpiryPolicy	Defines functions to determine when cache entries will expire based on creation, access and modification operations.
CApache.Ignite.Core.Cache.Expiry.ExpiryPolicy	Default expiry policy implementation with all durations deinfed explicitly.
CApache.Ignite.Core.Common.IFactory< out out T >	Factory that produces instances of a specific type. Implementation can be passed over the wire and thus should be marked with SerializableAttribute.
CApache.Ignite.Core.IgniteConfiguration	Grid configuration.
CApache.Ignite.AspNet.IgniteWebUtils	Ignite web utilities.
CApache.Ignite.Core.Ignition	This class defines a factory for the main Ignite API. Use Start() method to start Ignite with default configuration. All members are thread-safe and may be used concurrently from multiple threads.
CApache.Ignite.Core.Lifecycle.ILifecycleHandler	Handles lifecycle events defined in LifecycleEventType. Use this interface whenever you need to plug some custom logic before or after Ignite startup and stopping routines
►CApache.Ignite.Core.Log.ILogger	Defines Ignite logging interface
CApache.Ignite.Core.Log.CategoryLogger	Wrapping logger with a predefined category
CApache.Ignite.Core.Cache.IMemoryMetrics	Memory usage metrics.
CApache.Ignite.Core.Messaging.IMessageListener< in in T >	Represents messaging filter predicate.
CApache.Ignite.Core.Messaging.IMessaging	Provides functionality for topic-based message exchange among nodes defined by IClusterGroup. Users can send ordered and unordered messages to various topics. Note that same topic name cannot be reused between ordered and unordered messages. All members are thread-safe and may be used concurrently from multiple threads.
CApache.Ignite.Core.PersistentStore.IPersistentStoreMetrics	Persistent store metrics.
CApache.Ignite.Core.Interop.IPlatformTarget	Interface to interoperate with org.apache.ignite.internal.processors.platform.PlatformTarget on Java side.
CApache.Ignite.Core.Plugin.IPluginConfiguration	Plugin configuration interface
CApache.Ignite.Core.Plugin.IPluginContext< out out T >	Plugin execution context.
CApache.Ignite.Core.Plugin.IPluginProvider< in in TConfig >	Pluggable Ignite component. Should have parameterless constructor
►CIQueryEntityInternal
CApache.Ignite.Core.Cache.Configuration.QueryEntity	Query entity is a description of cache entry (composed of key and value) in a way of how it must be indexed and can be queried.
CApache.Ignite.Core.Services.IService	Represents Ignite-managed service.
CApache.Ignite.Core.Services.IServiceContext	Represents service execution context.
CApache.Ignite.Core.Services.IServiceDescriptor	Service deployment descriptor.
CApache.Ignite.Core.Services.IServices	Defines functionality to deploy distributed services in the Ignite.
►CApache.Ignite.Core.Datastream.IStreamReceiver< TK, TV >	Updates cache with batch of entries. Usually it is enough to configure IDataStreamer<K,V>.AllowOverwrite property and appropriate internal cache receiver will be chosen automatically. But in some cases custom implementation may help to achieve better performance.
CApache.Ignite.Core.Datastream.StreamTransformer< TK, TV, TArg, TRes >	Convenience adapter to transform update existing values in streaming cache based on the previously cached value.
CApache.Ignite.Core.Datastream.StreamVisitor< TK, TV >	Convenience adapter to visit every key-value tuple in the stream. Note that the visitor does not update the cache.
►CApache.Ignite.Core.Discovery.Tcp.ITcpDiscoveryIpFinder	Represents an IP finder for TcpDiscoverySpi. Only predefined implementations are supported now: TcpDiscoveryStaticIpFinder, TcpDiscoveryMulticastIpFinder.
►CApache.Ignite.Core.Discovery.Tcp.TcpDiscoveryIpFinderBase	Base IpFinder class.
►CApache.Ignite.Core.Discovery.Tcp.Static.TcpDiscoveryStaticIpFinder	IP Finder which works only with pre-configured list of IP addresses.
CApache.Ignite.Core.Discovery.Tcp.Multicast.TcpDiscoveryMulticastIpFinder	Multicast-based IP finder
CApache.Ignite.Core.Transactions.ITransactionMetrics	Transaction metrics, shared across all caches.
CApache.Ignite.Core.Transactions.ITransactions	Transactions facade. All members are thread-safe and may be used concurrently from multiple threads.
CApache.Ignite.Core.Interop.JavaObject	Represents a Java object wrapper
CApache.Ignite.Core.Log.LoggerExtensions	Extension methods for ILogger
CApache.Ignite.Core.Cache.Configuration.MemoryConfiguration	A page memory configuration for an Apache Ignite node. The page memory is a manageable off-heap based memory architecture that divides all continuously allocated memory regions into pages of fixed size. An individual page can store one or many cache key-value entries that allows reusing the memory in the most efficient way and avoid memory fragmentation issues
CApache.Ignite.Core.Cache.Configuration.MemoryPolicyConfiguration	Defines page memory policy configuration. See MemoryConfiguration.MemoryPolicies.
CApache.Ignite.Core.Cache.Configuration.NearCacheConfiguration	Defines near cache configuration
►COutputCacheProvider
CApache.Ignite.AspNet.IgniteOutputCacheProvider	ASP.NET output cache provider that uses Ignite cache as a storage
CApache.Ignite.Core.PersistentStore.PersistentStoreConfiguration	Configures Apache Ignite persistent store.
CApache.Ignite.Core.Cache.Configuration.QueryAlias	Represents cache query configuration alias.
►CApache.Ignite.Core.Cache.Query.QueryBase	Base class for all Ignite cache entry queries.
CApache.Ignite.Core.Cache.Query.ScanQuery< TK, TV >	Scan query over cache entries. Will accept all the entries if no predicate was set.
CApache.Ignite.Core.Cache.Query.SqlQuery	SQL Query.
CApache.Ignite.Core.Cache.Query.TextQuery	Text query.
CApache.Ignite.Core.Cache.Configuration.QueryField	Represents a queryable field.
CApache.Ignite.Core.Cache.Configuration.QueryIndex	Represents cache query index configuration.
CApache.Ignite.Core.Cache.Configuration.QueryIndexField	Represents an indexed field.
CApache.Ignite.Linq.QueryOptions	Cache query options.
CApache.Ignite.Core.Services.ServiceConfiguration	Service configuration.
►CSessionStateStoreProviderBase
CApache.Ignite.AspNet.IgniteSessionStateStoreProvider	ASP.NET Session-State Store Provider that uses Ignite distributed cache as an underlying storage
CApache.Ignite.Core.Configuration.SqlConnectorConfiguration	SQL connector configuration (for ODBC and JDBC).
CApache.Ignite.Core.Cache.Query.SqlFieldsQuery	SQL fields query.
CApache.Ignite.Core.Transactions.TransactionConfiguration	Transactions configuration.