APIs
- Java
- C#/.NET
- C++
Examples
- Java
- C#/.NET
- C++
- Python
- NodeJS
- PHP

▼

English

Chinese

Documentation Overview

Java

.NET/C#

C++

Python

Node.JS

SQL

PHP

REST API

Installing Using ZIP Archive

Installing Using Docker

Installing DEB or RPM package

Azure Kubernetes Service

Google Kubernetes Engine

VMWare

Version Upgrade

Understanding Configuration

Setting Up

Configuring Logging

Resources Injection

Starting and Stopping Nodes

Overview

TCP/IP Discovery

ZooKeeper Discovery

Discovery in the Cloud

Network Configuration

Connecting Client Nodes

Baseline Topology

Running Client Nodes Behind NAT

Thin Clients Overview

Java Thin Client

.NET Thin Client

C++ Thin Client

Python Thin Client

PHP Thin Client

Node.js Thin Client

Binary Client Protocol

Key-Value Queries

SQL and Scan Queries

Binary Types Metadata

Cache Configuration

Introduction

Data Partitioning

Affinity Colocation

Binary Marshaller

Memory Architecture

Configuring Data Regions

Eviction Policies

Replacement Policies

Ignite Persistence

External Storage

Swapping

Implementing Custom Cache Store

Configuring Snapshot Directory

Disk Compression

Tuning Persistence

Change Data Capture

Cluster Snapshots

Cache Configuration

Configuring Partition Backups

Partition Loss Policy

Atomicity Modes

Expiry Policy

On-Heap Caching

Cache Groups

Near Caches

Data Rebalancing

Data Streaming

Basic Cache Operations

Working with Binary Objects

Using Cache Queries

Read Repair

Performing Transactions

Introduction

Understanding Schemas

Defining Indexes

Using SQL API

Distributed Joins

Custom SQL Functions

JDBC Driver

JDBC Client Driver

Connection String and DSN

Querying and Modifying Data

Multiversion Concurrency Control

SQL Statistics

Calcite-based SQL Engine

SQL Conformance

Data Definition Language (DDL)

Data Manipulation Language (DML)

Transactions

Operational Commands

Aggregate functions

Numeric Functions

String Functions

Data and Time Functions

System Functions

Data Types

Optimizer Hints

Distributed Computing API

Cluster Groups

Executor Service

MapReduce API

Load Balancing

Fault Tolerance

Job Scheduling

Colocating Computations with Data

Deploying User Code

Peer Class Loading

Machine Learning

Partition Based Dataset

Updating Trained Models

Linear SVM (Support Vector Machine)

Multilayer Perceptron

Logistic Regression

k-NN Classification

ANN (Approximate Nearest Neighbor)

Linear Regression

Decision Trees Regression

k-NN Regression

K-Means Clustering

Gaussian mixture (GMM)

Preprocessing

Split the dataset on test and train datasets

Hyper-parameter tuning

Multiclass Classification

Gradient Boosting

Recommendation Systems

Import Model from XGBoost

Import Model from Apache Spark

Using Continuous Queries

Using Ignite Services

Using Ignite Messaging

Queue and Set

Atomic Types

CountDownLatch

Semaphore

ID Generator

Distributed Locks

REST API

Configuration Options

Deployment Options

Standalone Nodes

Asynchronous APIs

Logging

LINQ

Java Services Execution

.NET Platform Cache

Plugins

Serialization

Cross-Platform Support

Platform Interoperability

Remote Assembly Loading

Troubleshooting

ASP.NET Output Caching

ASP.NET Session State Caching

Entity Framework 2nd Level Cache

Serialization

Platform Interoperability

Objects Lifetime

Introduction

Cluster ID and Tag

Cluster States

Configuring Metrics

System Views

Performance Statistics

Tracing

Enabling and Listenting to Events

Events

Control Script

GridGain Control Center

SQLLine

Tableau

Informatica

Pentaho

Index Reader

Authentication

SSL/TLS

Master key rotation

Cache encryption key rotation

Sandbox

Spring Transactions

IgniteContext and IgniteRDD

Ignite DataFrame

Test Ignite with Spark-shell

Troubleshooting

MyBatis L2 Cache

RocketMQ Streamer

ZeroMQ Streamer

Twitter Streamer

PHP PDO

Performance Statistics

Change Data Capture

ZooKeeper IP Finder

Plugins

General Performance Tips

Memory and JVM Tuning

Persistence Tuning

SQL Tuning

Thread Pools Tuning

Troubleshooting and Debugging

Handling Exceptions

Benchmarking With Yardstick

Index

This section covers Ignite features, configuration approaches and architectural nuances that are specific for C# and .NET applications.

Docs Feedback