Class List

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

[detail level 1234567]

▼NApache
▼NIgnite
▼NCore	Ignite APIs.
►NBinary	Ignite Binary Objects API classes.
CBinaryConfiguration	Binary type configuration.
CBinaryObjectException	Indicates an error during binarization.
CBinaryReflectiveSerializer	Binary serializer which reflectively writes all fields except of ones with System.NonSerializedAttribute
CBinaryTypeConfiguration	Binary type configuration.
CBinaryTypeNames	Binary type name constants.
CIBinarizable	Interface to implement custom serialization logic.
CIBinary	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.
CIBinaryIdMapper	Maps class name and class field names to integer identifiers.
CIBinaryNameMapper	Maps type and field names to different names.
CIBinaryObject	Wrapper for serialized objects.
CIBinaryObjectBuilder	binary object builder. Provides ability to build binary objects dynamically without having class definitions
CIBinaryRawReader	Raw reader for binary objects.
CIBinaryRawWriter	Raw writer for binary objects.
CIBinaryReader	Reader for binary objects.
CIBinarySerializer	Binary serializer.
CIBinaryType	Binary type metadata.
CIBinaryWriter	Writer for binary objects.
►NCache	Main Data Grid APIs.
►NAffinity
CAffinityKey	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.
CAffinityKeyMappedAttribute	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
►NConfiguration
CCacheConfiguration	Defines grid cache configuration.
CNearCacheConfiguration	Defines near cache configuration
CQueryAlias	Represents cache query configuration alias.
CQueryEntity	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.
CQueryField	Represents a queryable field.
CQueryIndex	Represents cache query index configuration.
CQueryIndexField	Represents an indexed field.
CQuerySqlFieldAttribute	Marks field or property for SQL queries
CQueryTextFieldAttribute	Marks field or property for Text queries
►NEvent	Cache events API.
CICacheEntryEvent	Cache entry event.
CICacheEntryEventFilter	Cache entry event filter.
CICacheEntryEventListener	Cache entry event listener.
►NEviction
CEvictionPolicyBase	Base class for predefined eviction policies.
CIEvictionPolicy	Represents a cache eviction policy. Only predefined implementations are supported now: LruEvictionPolicy, FifoEvictionPolicy.
►NExpiry	Cache expiration API.
CExpiryPolicy	Default expiry policy implementation with all durations deinfed explicitly.
CIExpiryPolicy	Defines functions to determine when cache entries will expire based on creation, access and modification operations.
►NQuery	APIs for creating and executing cache queries.
►NContinuous	APIs for creating and executing cache continuous queries.
CContinuousQuery	API for configuring continuous cache queries
CContinuousQueryExtensions	Extensions for continuous queries.
CIContinuousQueryHandle	Represents a continuous query handle.
CIQueryCursor	Query result cursor. Can be processed either in iterative mode, or by taking all entries using IQueryCursor<T>.GetAll() method
CQueryBase	Base class for all Ignite cache entry queries.
CScanQuery	Scan query over cache entries. Will accept all the entries if no predicate was set.
CSqlFieldsQuery	SQL fields query.
CSqlQuery	SQL Query.
CTextQuery	Text query.
►NStore	Cache store interfaces.
CCacheParallelLoadStoreAdapter	Cache storage adapter with parallel loading in LoadAll method.
CCacheStoreAdapter	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.
CCacheStoreException	Indicates an error during CacheStore operation.
CICacheStore	API for cache persistent storage for read-through and write-through behavior
CICacheStoreSession	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.SessionEnd(bool) method.
CCacheAtomicUpdateTimeoutException	Indicates atomic operation timeout.
CCacheEntryProcessorException	An exception to indicate a problem occurred attempting to execute an ICacheEntryProcessor<K, V, A, R> against an entry.
CCacheException	Indicates an error during Cache operation.
CCachePartialUpdateException	Exception thrown from non-transactional cache in case when update succeeded only partially.
CCacheResult	Represents a cache operation result with a success flag.
CICache	Main entry point for Ignite cache APIs. You can get a named cache by calling IIgnite.GetCache<TK,TV> method
CICacheAffinity	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
CICacheEntry	Cache entry interface.
CICacheEntryFilter	Cache entry predicate.
CICacheEntryProcessor	An invocable function that allows applications to perform compound operations on a cache entry atomically, according the defined consistency of a cache
CICacheEntryProcessorResult	Represents a result of processing ICacheEntry<K, V> by ICacheEntryProcessor<K, V, A, R>.
CICacheLock	Cache locking interface. All members are thread-safe and may be used concurrently from multiple threads.
CICacheMetrics	Cache metrics used to obtain statistics on cache itself.
CIMutableCacheEntry	Mutable representation of ICacheEntry<K, V>
►NCluster	Cluster-related classes.
CClusterGroupEmptyException	Indicates an illegal call on empty projection. Thrown by projection when operation that requires at least one node is called on empty projection.
CClusterTopologyException	Indicates an error with grid topology (e.g., crashed node, etc.)
CICluster	Represents whole cluster (group of all nodes in a cluster). All members are thread-safe and may be used concurrently from multiple threads.
CIClusterGroup	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:
CIClusterMetrics	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
CIClusterNode	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
CIClusterNodeFilter	Represents cluster node filter.
►NCommon	Common Ignite types.
CClientDisconnectedException	Indicates that client-mode local node has been disconnected from the cluster.
CIFactory	Factory that produces instances of a specific type. Implementation can be passed over the wire and thus should be marked with SerializableAttribute.
CIgniteException	General Ignite exception. Indicates any error condition within Ignite.
CIgniteFutureCancelledException	Indicates future cancellation within Ignite.
CIgniteGuid	Ignite guid with additional local ID.
►NCommunication
►NTcp
CTcpCommunicationSpi	TcpCommunicationSpi is default communication SPI which uses TCP/IP protocol and Java NIO to communicate with other nodes
CICommunicationSpi	Communication SPI is responsible for data exchange between nodes
►NCompute	Compute Grid functionality.
CComputeExecutionRejectedException	Indicates a situation when execution service provided by the user in configuration rejects execution.
CComputeJobAdapter	Convenience adapter for IComputeJob<T> implementations. It provides the following functionality:
CComputeJobFailoverException	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.
CComputeTaskAdapter	Convenience adapter for IComputeTask<TArg,TJobRes,TTaskRes> interface
CComputeTaskCancelledException	This exception indicates that Ignite task was cancelled.
CComputeTaskNoResultCacheAttribute	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.
CComputeTaskSplitAdapter	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.
CComputeTaskTimeoutException	Indicates that task execution timed out.
CComputeUserUndeclaredException	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.
CICompute	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
CIComputeAction	Defines a void function having no arguments.
CIComputeFunc	Defines function having a single argument.
CIComputeJob	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
CIComputeJobResult	Job execution result which gets passed to IComputeTask<TA,T,TR>.OnResult method.
CIComputeReducer	Compute reducer which is capable of result collecting and reducing.
CIComputeTask	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
►NDatastream	Ignite Streamer classes.
CIDataStreamer	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
CIStreamReceiver	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.
CStreamTransformer	Convenience adapter to transform update existing values in streaming cache based on the previously cached value.
CStreamVisitor	Convenience adapter to visit every key-value tuple in the stream. Note that the visitor does not update the cache.
►NDataStructures	Distributed data structures.
►NConfiguration
CAtomicConfiguration	Configuration for atomic data structures.
CIAtomicLong	Represents a distributed atomic long value.
CIAtomicReference	Represents a named value in the distributed cache.
CIAtomicSequence	Represents a distributed atomic sequence of numbers.
►NDiscovery
►NTcp
►NMulticast
CTcpDiscoveryMulticastIpFinder	Multicast-based IP finder
►NStatic
CTcpDiscoveryStaticIpFinder	IP Finder which works only with pre-configured list of IP addresses.
CITcpDiscoveryIpFinder	Represents an IP finder for TcpDiscoverySpi. Only predefined implementations are supported now: TcpDiscoveryStaticIpFinder, TcpDiscoveryMulticastIpFinder.
CTcpDiscoveryIpFinderBase	Base IpFinder class.
CTcpDiscoverySpi	TCP discover service provider.
CIDiscoverySpi	Represents a discovery service provider interface. Only predefined implementation is supported now: TcpDiscoverySpi.
►NEvents	Event Subscription functionality together with various events emitted by Ignite.
CCacheEvent	In-memory database (cache) event.
CCacheQueryExecutedEvent	Cache query execution event.
CCacheQueryReadEvent	Cache query read event.
CCacheRebalancingEvent	In-memory database (cache) rebalancing event. Rebalance event happens every time there is a change
CCheckpointEvent	Grid checkpoint event.
CDiscoveryEvent	Grid discovery event.
CEventBase	Base event implementation.
CEventType	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
CIEvent	Represents a Ignite event.
CIEventFilter	Represents an event filter.
CIEventListener	Represents an event listener.
CIEvents	Provides functionality for event notifications on nodes defined by ClusterGroup. All members are thread-safe and may be used concurrently from multiple threads.
CJobEvent	Ignite job event.
CSwapSpaceEvent	Grid swap space event.
CTaskEvent	Ignite task event.
►NInterop
CJavaObject	Represents a Java object wrapper
►NLifecycle	Lifecycle-related classes.
CILifecycleBean	A bean that reacts to Ignite lifecycle events defined in LifecycleEventType. Use this bean whenever you need to plug some custom logic before or after Ignite startup and stopping routines
►NMessaging	Topic-based Messaging functionality.
CIMessageListener	Represents messaging filter predicate.
CIMessaging	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.
►NResource	Attributes to inject resources into user-defined code such as tasks, jobs, entry processors.
CInstanceResourceAttribute	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.
CStoreSessionResourceAttribute	Annotates a field or a setter method for injection of current ICacheStoreSession instance. It can be injected into ICacheStore.
►NServices	Managed Services APIs.
CIService	Represents Ignite-managed service.
CIServiceContext	Represents service execution context.
CIServiceDescriptor	Service deployment descriptor.
CIServices	Defines functionality to deploy distributed services in the Ignite.
CServiceConfiguration	Service configuration.
CServiceInvocationException	Indicates an error during Grid Services invocation.
►NTransactions	Transaction-related classes.
CITransaction	Grid cache transaction
CITransactionMetrics	Transaction metrics, shared across all caches.
CITransactions	Transactions facade. All members are thread-safe and may be used concurrently from multiple threads.
CTransactionConfiguration	Transactions configuration.
CTransactionHeuristicException	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.
CTransactionOptimisticException	Exception thrown whenever Ignite transactions fail optimistically.
CTransactionRollbackException	Exception thrown whenever Ignite transactions has been automatically rolled back.
CTransactionTimeoutException	Exception thrown whenever Ignite transactions time out.
CIgniteConfiguration	Grid configuration.
CIgniteConfigurationSection	Ignite configuration section for app.config and web.config files.
CIgnition	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.
CIIgnite	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.