﻿<!DOCTYPE html>
<!--[if IE]><![endif]-->
<html>
  
  <head>
<link rel="canonical" href="https://ignite.apache.org/releases/2.7.5/dotnetdoc/api/Apache.Ignite.Core.Cache.Configuration.html" />

<META NAME="ROBOTS" CONTENT="NOINDEX">

    <meta charset="utf-8">
    <meta http-equiv="X-UA-Compatible" content="IE=edge,chrome=1">
    <title>Namespace Apache.Ignite.Core.Cache.Configuration
   | Apache Ignite.NET </title>
    <meta name="viewport" content="width=device-width">
    <meta name="title" content="Namespace Apache.Ignite.Core.Cache.Configuration
   | Apache Ignite.NET ">
    <meta name="generator" content="docfx 2.24.0.0">
    
    <link rel="shortcut icon" href="../images/favicon.ico">
    <link rel="stylesheet" href="../styles/docfx.vendor.css">
    <link rel="stylesheet" href="../styles/docfx.css">
    <link rel="stylesheet" href="../styles/main.css">
    <meta property="docfx:navrel" content="../toc.html">
    <meta property="docfx:tocrel" content="toc.html">
    
    <meta property="docfx:rel" content="../">
    
  
<script>
  (function(i,s,o,g,r,a,m){i['GoogleAnalyticsObject']=r;i[r]=i[r]||function(){
  (i[r].q=i[r].q||[]).push(arguments)},i[r].l=1*new Date();a=s.createElement(o),
  m=s.getElementsByTagName(o)[0];a.async=1;a.src=g;m.parentNode.insertBefore(a,m)
  })(window,document,'script','https://www.google-analytics.com/analytics.js','ga');

  ga('create', 'UA-61232409-1', 'auto');
  ga('send', 'pageview');

</script></head>
  <body data-spy="scroll" data-target="#affix">
    <div id="wrapper">
      <header>
        
        <nav id="autocollapse" class="navbar navbar-inverse ng-scope" role="navigation">
          <div class="container">
            <div class="navbar-header">
              <button type="button" class="navbar-toggle" data-toggle="collapse" data-target="#navbar">
                <span class="sr-only">Toggle navigation</span>
                <span class="icon-bar"></span>
                <span class="icon-bar"></span>
                <span class="icon-bar"></span>
              </button>
              
              <a class="navbar-brand" href="../index.html">
                <img id="logo" class="svg" src="../images/logo_ignite_32_32.png" alt="">
              </a>
            </div>
            <div class="collapse navbar-collapse" id="navbar">
              <form class="navbar-form navbar-right" role="search" id="search">
                <div class="form-group">
                  <input type="text" class="form-control" id="search-query" placeholder="Search" autocomplete="off">
                </div>
              </form>
            </div>
          </div>
        </nav>
        
        <div class="subnav navbar navbar-default">
          <div class="container hide-when-search" id="breadcrumb">
            <ul class="breadcrumb">
              <li></li>
            </ul>
          </div>
        </div>
      </header>
      <div class="container body-content">
        
        <div id="search-results">
          <div class="search-list"></div>
          <div class="sr-items"></div>
          <ul id="pagination"></ul>
        </div>
      </div>
      <div role="main" class="container body-content hide-when-search">
        
        <div class="sidenav hide-when-search">
          <a class="btn toc-toggle collapse" data-toggle="collapse" href="#sidetoggle" aria-expanded="false" aria-controls="sidetoggle">Show / Hide Table of Contents</a>
          <div class="sidetoggle collapse" id="sidetoggle">
            <div id="sidetoc"></div>
          </div>
        </div>
        <div class="article row grid-right">
          <div class="col-md-10">
            <article class="content wrap" id="_content" data-uid="Apache.Ignite.Core.Cache.Configuration">
  
  <h1 id="Apache_Ignite_Core_Cache_Configuration" data-uid="Apache.Ignite.Core.Cache.Configuration" class="text-break">Namespace Apache.Ignite.Core.Cache.Configuration
  </h1>
  <div class="markdown level0 summary"></div>
  <div class="markdown level0 conceptual"></div>
  <div class="markdown level0 remarks"></div>
    <h3 id="classes">Classes
  </h3>
      <h4><a class="xref" href="Apache.Ignite.Core.Cache.Configuration.CacheConfiguration.html">CacheConfiguration</a></h4>
      <section><p>Defines grid cache configuration.</p>
</section>
      <h4><a class="xref" href="Apache.Ignite.Core.Cache.Configuration.CacheKeyConfiguration.html">CacheKeyConfiguration</a></h4>
      <section><p>Configuration defining various aspects of cache keys without explicit usage of annotations on user classes.</p>
</section>
      <h4><a class="xref" href="Apache.Ignite.Core.Cache.Configuration.MemoryConfiguration.html">MemoryConfiguration</a></h4>
      <section><p>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. 
<p>
By default, the page memory allocates a single continuous memory region. All the caches that
will be configured in an application will be mapped to this memory region by default,
thus, all the cache data will reside in that memory region.
<p>
If initial size of the default memory region doesn&apos;t satisfy requirements or it&apos;s
required to have multiple memory regions with different properties
then <a class="xref" href="Apache.Ignite.Core.Cache.Configuration.MemoryPolicyConfiguration.html">MemoryPolicyConfiguration</a> can be used for both scenarios.
For instance, using memory policies you can define memory regions of different maximum size,
eviction policies, swapping options, etc. Once you define a new memory region you can bind
particular Ignite caches to it. <p>
To learn more about memory policies refer to <a class="xref" href="Apache.Ignite.Core.Cache.Configuration.MemoryPolicyConfiguration.html">MemoryPolicyConfiguration</a> documentation.
<p>
Obsolete, use <a class="xref" href="Apache.Ignite.Core.Configuration.DataStorageConfiguration.html">DataStorageConfiguration</a>.</p>
</section>
      <h4><a class="xref" href="Apache.Ignite.Core.Cache.Configuration.MemoryPolicyConfiguration.html">MemoryPolicyConfiguration</a></h4>
      <section><p>Defines page memory policy configuration. See <a class="xref" href="Apache.Ignite.Core.Cache.Configuration.MemoryConfiguration.html#Apache_Ignite_Core_Cache_Configuration_MemoryConfiguration_MemoryPolicies">MemoryPolicies</a>.
Obsolete, use <a class="xref" href="Apache.Ignite.Core.Configuration.DataRegionConfiguration.html">DataRegionConfiguration</a>.</p>
</section>
      <h4><a class="xref" href="Apache.Ignite.Core.Cache.Configuration.NearCacheConfiguration.html">NearCacheConfiguration</a></h4>
      <section><p>Defines near cache configuration.
<p>
Distributed cache can also be fronted by a Near cache, which is a smaller local cache that stores most 
recently or most frequently accessed data. 
Just like with a partitioned cache, the user can control the size of the near cache and its eviction policies. </p>
</section>
      <h4><a class="xref" href="Apache.Ignite.Core.Cache.Configuration.QueryAlias.html">QueryAlias</a></h4>
      <section><p>Represents cache query configuration alias.</p>
</section>
      <h4><a class="xref" href="Apache.Ignite.Core.Cache.Configuration.QueryEntity.html">QueryEntity</a></h4>
      <section><p>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.</p>
</section>
      <h4><a class="xref" href="Apache.Ignite.Core.Cache.Configuration.QueryField.html">QueryField</a></h4>
      <section><p>Represents a queryable field.</p>
</section>
      <h4><a class="xref" href="Apache.Ignite.Core.Cache.Configuration.QueryIndex.html">QueryIndex</a></h4>
      <section><p>Represents cache query index configuration.</p>
</section>
      <h4><a class="xref" href="Apache.Ignite.Core.Cache.Configuration.QueryIndexField.html">QueryIndexField</a></h4>
      <section><p>Represents an indexed field.</p>
</section>
      <h4><a class="xref" href="Apache.Ignite.Core.Cache.Configuration.QuerySqlFieldAttribute.html">QuerySqlFieldAttribute</a></h4>
      <section><p>Marks field or property for SQL queries.
<p>
Using this attribute is an alternative to <a class="xref" href="Apache.Ignite.Core.Cache.Configuration.QueryEntity.html#Apache_Ignite_Core_Cache_Configuration_QueryEntity_Fields">Fields</a> in <a class="xref" href="Apache.Ignite.Core.Cache.Configuration.CacheConfiguration.html">CacheConfiguration</a>.</p>
</section>
      <h4><a class="xref" href="Apache.Ignite.Core.Cache.Configuration.QueryTextFieldAttribute.html">QueryTextFieldAttribute</a></h4>
      <section><p>Marks field or property for Text queries.
<p>
Using this attribute is an alternative to <a class="xref" href="Apache.Ignite.Core.Cache.Configuration.QueryEntity.html#Apache_Ignite_Core_Cache_Configuration_QueryEntity_Fields">Fields</a> in <a class="xref" href="Apache.Ignite.Core.Cache.Configuration.CacheConfiguration.html">CacheConfiguration</a>.</p>
</section>
    <h3 id="enums">Enums
  </h3>
      <h4><a class="xref" href="Apache.Ignite.Core.Cache.Configuration.CacheAtomicityMode.html">CacheAtomicityMode</a></h4>
      <section><p>Cache atomicity mode.</p>
</section>
      <h4><a class="xref" href="Apache.Ignite.Core.Cache.Configuration.CacheMode.html">CacheMode</a></h4>
      <section><p>Caching modes.</p>
</section>
      <h4><a class="xref" href="Apache.Ignite.Core.Cache.Configuration.CacheRebalanceMode.html">CacheRebalanceMode</a></h4>
      <section><p>Cache rebalance mode. When rebalancing is enabled (i.e. has value other than <a class="xref" href="Apache.Ignite.Core.Cache.Configuration.CacheRebalanceMode.html#Apache_Ignite_Core_Cache_Configuration_CacheRebalanceMode_None">None</a>), 
distributed caches will attempt to rebalance all necessary values from other grid nodes. 
<p>
Replicated caches will try to load the full set of cache entries from other nodes, 
while partitioned caches will only load the entries for which current node is primary or backup.
<p>
Note that rebalance mode only makes sense for <a class="xref" href="Apache.Ignite.Core.Cache.Configuration.CacheMode.html#Apache_Ignite_Core_Cache_Configuration_CacheMode_Replicated">Replicated</a> 
and <a class="xref" href="Apache.Ignite.Core.Cache.Configuration.CacheMode.html#Apache_Ignite_Core_Cache_Configuration_CacheMode_Partitioned">Partitioned</a> caches. Caches with <a class="xref" href="Apache.Ignite.Core.Cache.Configuration.CacheMode.html#Apache_Ignite_Core_Cache_Configuration_CacheMode_Local">Local</a> 
mode are local by definition and therefore cannot rebalance any values from neighboring nodes.</p>
</section>
      <h4><a class="xref" href="Apache.Ignite.Core.Cache.Configuration.CacheWriteSynchronizationMode.html">CacheWriteSynchronizationMode</a></h4>
      <section><p>Mode indicating how Ignite should wait for write replies from other nodes.</p>
</section>
      <h4><a class="xref" href="Apache.Ignite.Core.Cache.Configuration.DataPageEvictionMode.html">DataPageEvictionMode</a></h4>
      <section><p>Memory page eviction mode.
Only data pages, that store key-value entries, are eligible for eviction.
The other types of pages, like index or system pages, are not evictable.</p>
</section>
      <h4><a class="xref" href="Apache.Ignite.Core.Cache.Configuration.PartitionLossPolicy.html">PartitionLossPolicy</a></h4>
      <section><p>Partition loss policy. Defines how cache will behave in a case when one or more partitions are
lost because of a node(s) failure.
<p>
All <em>Safe policies prevent a user from interaction with partial data in lost partitions until 
<a class="xref" href="Apache.Ignite.Core.IIgnite.html#Apache_Ignite_Core_IIgnite_ResetLostPartitions_System_Collections_Generic_IEnumerable_System_String__">ResetLostPartitions(IEnumerable&lt;String&gt;)</a> method is called.
<p>
*All policies allow working with partial data in lost partitions.
<p>
ReadOnly</em> and ReadWrite* policies do not automatically change partition state and thus do not change
rebalancing assignments for such partitions.</p>
</section>
      <h4><a class="xref" href="Apache.Ignite.Core.Cache.Configuration.QueryIndexType.html">QueryIndexType</a></h4>
      <section><p>Query index type.</p>
</section>
</article>
          </div>
          
          <div class="hidden-sm col-md-2" role="complementary">
            <div class="sideaffix">
              <nav class="bs-docs-sidebar hidden-print hidden-xs hidden-sm affix" id="affix">
              <!-- <p><a class="back-to-top" href="#top">Back to top</a><p> -->
              </nav>
            </div>
          </div>
        </div>
      </div>
      
      <footer>
        <div class="grad-bottom"></div>
        <div class="footer">
          <div class="container">
            <span class="pull-right">
              <a href="#top">Back to top</a>
            </span>
            © 2015 - 2018 The Apache Software Foundation
            
          </div>
        </div>
      </footer>
    </div>
    
    <script type="text/javascript" src="../styles/docfx.vendor.js"></script>
    <script type="text/javascript" src="../styles/docfx.js"></script>
    <script type="text/javascript" src="../styles/main.js"></script>
  </body>
</html>
