ignite-commits mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From ptupit...@apache.org
Subject ignite git commit: IGNITE-4234 .NET: Propagate missing CacheMetrics properties
Date Wed, 16 Nov 2016 15:16:31 GMT
Repository: ignite
Updated Branches:
  refs/heads/master f1e6257c5 -> 17316f934


IGNITE-4234 .NET: Propagate missing CacheMetrics properties

This closes #1239


Project: http://git-wip-us.apache.org/repos/asf/ignite/repo
Commit: http://git-wip-us.apache.org/repos/asf/ignite/commit/17316f93
Tree: http://git-wip-us.apache.org/repos/asf/ignite/tree/17316f93
Diff: http://git-wip-us.apache.org/repos/asf/ignite/diff/17316f93

Branch: refs/heads/master
Commit: 17316f934029890169ba17cb05386ffe675775cb
Parents: f1e6257
Author: Pavel Tupitsyn <ptupitsyn@apache.org>
Authored: Wed Nov 16 18:15:57 2016 +0300
Committer: Pavel Tupitsyn <ptupitsyn@apache.org>
Committed: Wed Nov 16 18:15:57 2016 +0300

----------------------------------------------------------------------
 .../platform/cache/PlatformCache.java           | 144 +++--
 .../platform/PlatformCacheWriteMetricsTask.java | 463 ++++++++++++++
 .../Apache.Ignite.Core.Tests.csproj             |   1 +
 .../Cache/CacheMetricsTest.cs                   | 128 ++++
 .../Cache/CacheSwapSpaceTest.cs                 |   4 +-
 .../Apache.Ignite.Core/Cache/ICacheMetrics.cs   | 236 +++++--
 .../Impl/Cache/CacheMetricsImpl.cs              | 617 ++++++++++++++-----
 7 files changed, 1339 insertions(+), 254 deletions(-)
----------------------------------------------------------------------


http://git-wip-us.apache.org/repos/asf/ignite/blob/17316f93/modules/core/src/main/java/org/apache/ignite/internal/processors/platform/cache/PlatformCache.java
----------------------------------------------------------------------
diff --git a/modules/core/src/main/java/org/apache/ignite/internal/processors/platform/cache/PlatformCache.java b/modules/core/src/main/java/org/apache/ignite/internal/processors/platform/cache/PlatformCache.java
index 677971c..4154c48 100644
--- a/modules/core/src/main/java/org/apache/ignite/internal/processors/platform/cache/PlatformCache.java
+++ b/modules/core/src/main/java/org/apache/ignite/internal/processors/platform/cache/PlatformCache.java
@@ -21,6 +21,7 @@ import org.apache.ignite.IgniteCache;
 import org.apache.ignite.IgniteCheckedException;
 import org.apache.ignite.IgniteException;
 import org.apache.ignite.binary.BinaryRawReader;
+import org.apache.ignite.binary.BinaryRawWriter;
 import org.apache.ignite.cache.CacheEntryProcessor;
 import org.apache.ignite.cache.CacheMetrics;
 import org.apache.ignite.cache.CachePartialUpdateException;
@@ -64,8 +65,6 @@ import org.apache.ignite.transactions.TransactionTimeoutException;
 import org.jetbrains.annotations.Nullable;
 
 import javax.cache.Cache;
-import javax.cache.expiry.Duration;
-import javax.cache.expiry.ExpiryPolicy;
 import javax.cache.integration.CompletionListener;
 import javax.cache.processor.EntryProcessorException;
 import javax.cache.processor.EntryProcessorResult;
@@ -80,7 +79,7 @@ import java.util.concurrent.locks.Lock;
 /**
  * Native cache wrapper implementation.
  */
-@SuppressWarnings({"unchecked", "UnusedDeclaration", "TryFinallyCanBeTryWithResources", "TypeMayBeWeakened"})
+@SuppressWarnings({"unchecked", "UnusedDeclaration", "TryFinallyCanBeTryWithResources", "TypeMayBeWeakened", "WeakerAccess"})
 public class PlatformCache extends PlatformAbstractTarget {
     /** */
     public static final int OP_CLEAR = 1;
@@ -911,59 +910,7 @@ public class PlatformCache extends PlatformAbstractTarget {
             case OP_METRICS:
                 CacheMetrics metrics = cache.localMetrics();
 
-                writer.writeLong(metrics.getCacheGets());
-                writer.writeLong(metrics.getCachePuts());
-                writer.writeLong(metrics.getCacheHits());
-                writer.writeLong(metrics.getCacheMisses());
-                writer.writeLong(metrics.getCacheTxCommits());
-                writer.writeLong(metrics.getCacheTxRollbacks());
-                writer.writeLong(metrics.getCacheEvictions());
-                writer.writeLong(metrics.getCacheRemovals());
-                writer.writeFloat(metrics.getAveragePutTime());
-                writer.writeFloat(metrics.getAverageGetTime());
-                writer.writeFloat(metrics.getAverageRemoveTime());
-                writer.writeFloat(metrics.getAverageTxCommitTime());
-                writer.writeFloat(metrics.getAverageTxRollbackTime());
-                writer.writeString(metrics.name());
-                writer.writeLong(metrics.getOverflowSize());
-                writer.writeLong(metrics.getOffHeapEntriesCount());
-                writer.writeLong(metrics.getOffHeapAllocatedSize());
-                writer.writeInt(metrics.getSize());
-                writer.writeInt(metrics.getKeySize());
-                writer.writeBoolean(metrics.isEmpty());
-                writer.writeInt(metrics.getDhtEvictQueueCurrentSize());
-                writer.writeInt(metrics.getTxThreadMapSize());
-                writer.writeInt(metrics.getTxXidMapSize());
-                writer.writeInt(metrics.getTxCommitQueueSize());
-                writer.writeInt(metrics.getTxPrepareQueueSize());
-                writer.writeInt(metrics.getTxStartVersionCountsSize());
-                writer.writeInt(metrics.getTxCommittedVersionsSize());
-                writer.writeInt(metrics.getTxRolledbackVersionsSize());
-                writer.writeInt(metrics.getTxDhtThreadMapSize());
-                writer.writeInt(metrics.getTxDhtXidMapSize());
-                writer.writeInt(metrics.getTxDhtCommitQueueSize());
-                writer.writeInt(metrics.getTxDhtPrepareQueueSize());
-                writer.writeInt(metrics.getTxDhtStartVersionCountsSize());
-                writer.writeInt(metrics.getTxDhtCommittedVersionsSize());
-                writer.writeInt(metrics.getTxDhtRolledbackVersionsSize());
-                writer.writeBoolean(metrics.isWriteBehindEnabled());
-                writer.writeInt(metrics.getWriteBehindFlushSize());
-                writer.writeInt(metrics.getWriteBehindFlushThreadCount());
-                writer.writeLong(metrics.getWriteBehindFlushFrequency());
-                writer.writeInt(metrics.getWriteBehindStoreBatchSize());
-                writer.writeInt(metrics.getWriteBehindTotalCriticalOverflowCount());
-                writer.writeInt(metrics.getWriteBehindCriticalOverflowCount());
-                writer.writeInt(metrics.getWriteBehindErrorRetryCount());
-                writer.writeInt(metrics.getWriteBehindBufferSize());
-                writer.writeString(metrics.getKeyType());
-                writer.writeString(metrics.getValueType());
-                writer.writeBoolean(metrics.isStoreByValue());
-                writer.writeBoolean(metrics.isStatisticsEnabled());
-                writer.writeBoolean(metrics.isManagementEnabled());
-                writer.writeBoolean(metrics.isReadThrough());
-                writer.writeBoolean(metrics.isWriteThrough());
-                writer.writeFloat(metrics.getCacheHitPercentage());
-                writer.writeFloat(metrics.getCacheMissPercentage());
+                writeCacheMetrics(writer, metrics);
 
                 break;
 
@@ -1362,6 +1309,91 @@ public class PlatformCache extends PlatformAbstractTarget {
     }
 
     /**
+     * Writes cache metrics.
+     *
+     * @param writer Writer.
+     * @param metrics Metrics.
+     */
+    public static void writeCacheMetrics(BinaryRawWriter writer, CacheMetrics metrics) {
+        assert writer != null;
+        assert metrics != null;
+
+        writer.writeLong(metrics.getCacheHits());
+        writer.writeFloat(metrics.getCacheHitPercentage());
+        writer.writeLong(metrics.getCacheMisses());
+        writer.writeFloat(metrics.getCacheMissPercentage());
+        writer.writeLong(metrics.getCacheGets());
+        writer.writeLong(metrics.getCachePuts());
+        writer.writeLong(metrics.getCacheRemovals());
+        writer.writeLong(metrics.getCacheEvictions());
+        writer.writeFloat(metrics.getAverageGetTime());
+        writer.writeFloat(metrics.getAveragePutTime());
+        writer.writeFloat(metrics.getAverageRemoveTime());
+        writer.writeFloat(metrics.getAverageTxCommitTime());
+        writer.writeFloat(metrics.getAverageTxRollbackTime());
+        writer.writeLong(metrics.getCacheTxCommits());
+        writer.writeLong(metrics.getCacheTxRollbacks());
+        writer.writeString(metrics.name());
+        writer.writeLong(metrics.getOverflowSize());
+        writer.writeLong(metrics.getOffHeapGets());
+        writer.writeLong(metrics.getOffHeapPuts());
+        writer.writeLong(metrics.getOffHeapRemovals());
+        writer.writeLong(metrics.getOffHeapEvictions());
+        writer.writeLong(metrics.getOffHeapHits());
+        writer.writeFloat(metrics.getOffHeapHitPercentage());
+        writer.writeLong(metrics.getOffHeapMisses());
+        writer.writeFloat(metrics.getOffHeapMissPercentage());
+        writer.writeLong(metrics.getOffHeapEntriesCount());
+        writer.writeLong(metrics.getOffHeapPrimaryEntriesCount());
+        writer.writeLong(metrics.getOffHeapBackupEntriesCount());
+        writer.writeLong(metrics.getOffHeapAllocatedSize());
+        writer.writeLong(metrics.getOffHeapMaxSize());
+        writer.writeLong(metrics.getSwapGets());
+        writer.writeLong(metrics.getSwapPuts());
+        writer.writeLong(metrics.getSwapRemovals());
+        writer.writeLong(metrics.getSwapHits());
+        writer.writeLong(metrics.getSwapMisses());
+        writer.writeLong(metrics.getSwapEntriesCount());
+        writer.writeLong(metrics.getSwapSize());
+        writer.writeFloat(metrics.getSwapHitPercentage());
+        writer.writeFloat(metrics.getSwapMissPercentage());
+        writer.writeInt(metrics.getSize());
+        writer.writeInt(metrics.getKeySize());
+        writer.writeBoolean(metrics.isEmpty());
+        writer.writeInt(metrics.getDhtEvictQueueCurrentSize());
+        writer.writeInt(metrics.getTxThreadMapSize());
+        writer.writeInt(metrics.getTxXidMapSize());
+        writer.writeInt(metrics.getTxCommitQueueSize());
+        writer.writeInt(metrics.getTxPrepareQueueSize());
+        writer.writeInt(metrics.getTxStartVersionCountsSize());
+        writer.writeInt(metrics.getTxCommittedVersionsSize());
+        writer.writeInt(metrics.getTxRolledbackVersionsSize());
+        writer.writeInt(metrics.getTxDhtThreadMapSize());
+        writer.writeInt(metrics.getTxDhtXidMapSize());
+        writer.writeInt(metrics.getTxDhtCommitQueueSize());
+        writer.writeInt(metrics.getTxDhtPrepareQueueSize());
+        writer.writeInt(metrics.getTxDhtStartVersionCountsSize());
+        writer.writeInt(metrics.getTxDhtCommittedVersionsSize());
+        writer.writeInt(metrics.getTxDhtRolledbackVersionsSize());
+        writer.writeBoolean(metrics.isWriteBehindEnabled());
+        writer.writeInt(metrics.getWriteBehindFlushSize());
+        writer.writeInt(metrics.getWriteBehindFlushThreadCount());
+        writer.writeLong(metrics.getWriteBehindFlushFrequency());
+        writer.writeInt(metrics.getWriteBehindStoreBatchSize());
+        writer.writeInt(metrics.getWriteBehindTotalCriticalOverflowCount());
+        writer.writeInt(metrics.getWriteBehindCriticalOverflowCount());
+        writer.writeInt(metrics.getWriteBehindErrorRetryCount());
+        writer.writeInt(metrics.getWriteBehindBufferSize());
+        writer.writeString(metrics.getKeyType());
+        writer.writeString(metrics.getValueType());
+        writer.writeBoolean(metrics.isStoreByValue());
+        writer.writeBoolean(metrics.isStatisticsEnabled());
+        writer.writeBoolean(metrics.isManagementEnabled());
+        writer.writeBoolean(metrics.isReadThrough());
+        writer.writeBoolean(metrics.isWriteThrough());
+    }
+
+    /**
      * Writes error with EntryProcessorException cause.
      */
     private static class GetAllWriter implements PlatformFutureUtils.Writer {

http://git-wip-us.apache.org/repos/asf/ignite/blob/17316f93/modules/core/src/test/java/org/apache/ignite/platform/PlatformCacheWriteMetricsTask.java
----------------------------------------------------------------------
diff --git a/modules/core/src/test/java/org/apache/ignite/platform/PlatformCacheWriteMetricsTask.java b/modules/core/src/test/java/org/apache/ignite/platform/PlatformCacheWriteMetricsTask.java
new file mode 100644
index 0000000..593f26d
--- /dev/null
+++ b/modules/core/src/test/java/org/apache/ignite/platform/PlatformCacheWriteMetricsTask.java
@@ -0,0 +1,463 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements.  See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License.  You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.apache.ignite.platform;
+
+import org.apache.ignite.Ignite;
+import org.apache.ignite.cache.CacheMetrics;
+import org.apache.ignite.cluster.ClusterNode;
+import org.apache.ignite.compute.ComputeJob;
+import org.apache.ignite.compute.ComputeJobAdapter;
+import org.apache.ignite.compute.ComputeJobResult;
+import org.apache.ignite.compute.ComputeTaskAdapter;
+import org.apache.ignite.internal.binary.BinaryRawWriterEx;
+import org.apache.ignite.internal.processors.platform.PlatformContext;
+import org.apache.ignite.internal.processors.platform.cache.PlatformCache;
+import org.apache.ignite.internal.processors.platform.memory.PlatformMemory;
+import org.apache.ignite.internal.processors.platform.memory.PlatformOutputStream;
+import org.apache.ignite.internal.processors.platform.utils.PlatformUtils;
+import org.apache.ignite.internal.util.typedef.F;
+import org.apache.ignite.resources.IgniteInstanceResource;
+import org.jetbrains.annotations.Nullable;
+
+import java.util.Collections;
+import java.util.List;
+import java.util.Map;
+
+/**
+ * Test task writing predefined metrics values to a stream.
+ */
+@SuppressWarnings("UnusedDeclaration")
+public class PlatformCacheWriteMetricsTask extends ComputeTaskAdapter<Long, Object> {
+    /** {@inheritDoc} */
+    @Nullable @Override public Map<? extends ComputeJob, ClusterNode> map(List<ClusterNode> subgrid, Long ptr) {
+        return Collections.singletonMap(new Job(ptr), F.first(subgrid));
+    }
+
+    /** {@inheritDoc} */
+    @Nullable @Override public Object reduce(List<ComputeJobResult> results) {
+        return results.get(0).getData();
+    }
+
+    /**
+     * Job.
+     */
+    private static class Job extends ComputeJobAdapter {
+        /** Grid. */
+        @IgniteInstanceResource
+        protected transient Ignite ignite;
+
+        /** Stream ptr. */
+        private final long ptr;
+
+        /**
+         * Constructor.
+         *
+         * @param ptr Stream ptr.
+         */
+        private Job(long ptr) {
+            this.ptr = ptr;
+        }
+
+        /** {@inheritDoc} */
+        @Nullable @Override public Object execute() {
+            PlatformContext ctx = PlatformUtils.platformContext(ignite);
+
+            try (PlatformMemory mem = ctx.memory().get(ptr)) {
+                PlatformOutputStream out = mem.output();
+                BinaryRawWriterEx writer = ctx.writer(out);
+
+                PlatformCache.writeCacheMetrics(writer, new TestCacheMetrics());
+
+                out.synchronize();
+            }
+
+            return true;
+        }
+    }
+
+    /**
+     * Predefined metrics.
+     */
+    private static class TestCacheMetrics implements CacheMetrics {
+        /** {@inheritDoc} */
+        @Override public long getCacheHits() {
+            return 1;
+        }
+
+        /** {@inheritDoc} */
+        @Override public float getCacheHitPercentage() {
+            return 2;
+        }
+
+        /** {@inheritDoc} */
+        @Override public long getCacheMisses() {
+            return 3;
+        }
+
+        /** {@inheritDoc} */
+        @Override public float getCacheMissPercentage() {
+            return 4;
+        }
+
+        /** {@inheritDoc} */
+        @Override public long getCacheGets() {
+            return 5;
+        }
+
+        /** {@inheritDoc} */
+        @Override public long getCachePuts() {
+            return 6;
+        }
+
+        /** {@inheritDoc} */
+        @Override public long getCacheRemovals() {
+            return 7;
+        }
+
+        /** {@inheritDoc} */
+        @Override public long getCacheEvictions() {
+            return 8;
+        }
+
+        /** {@inheritDoc} */
+        @Override public float getAverageGetTime() {
+            return 9;
+        }
+
+        /** {@inheritDoc} */
+        @Override public float getAveragePutTime() {
+            return 10;
+        }
+
+        /** {@inheritDoc} */
+        @Override public float getAverageRemoveTime() {
+            return 11;
+        }
+
+        /** {@inheritDoc} */
+        @Override public float getAverageTxCommitTime() {
+            return 12;
+        }
+
+        /** {@inheritDoc} */
+        @Override public float getAverageTxRollbackTime() {
+            return 13;
+        }
+
+        /** {@inheritDoc} */
+        @Override public long getCacheTxCommits() {
+            return 14;
+        }
+
+        /** {@inheritDoc} */
+        @Override public long getCacheTxRollbacks() {
+            return 15;
+        }
+
+        /** {@inheritDoc} */
+        @Override public String name() {
+            return "myCache";
+        }
+
+        /** {@inheritDoc} */
+        @Override public long getOverflowSize() {
+            return 16;
+        }
+
+        /** {@inheritDoc} */
+        @Override public long getOffHeapGets() {
+            return 17;
+        }
+
+        /** {@inheritDoc} */
+        @Override public long getOffHeapPuts() {
+            return 18;
+        }
+
+        /** {@inheritDoc} */
+        @Override public long getOffHeapRemovals() {
+            return 19;
+        }
+
+        /** {@inheritDoc} */
+        @Override public long getOffHeapEvictions() {
+            return 20;
+        }
+
+        /** {@inheritDoc} */
+        @Override public long getOffHeapHits() {
+            return 21;
+        }
+
+        /** {@inheritDoc} */
+        @Override public float getOffHeapHitPercentage() {
+            return 22;
+        }
+
+        /** {@inheritDoc} */
+        @Override public long getOffHeapMisses() {
+            return 23;
+        }
+
+        /** {@inheritDoc} */
+        @Override public float getOffHeapMissPercentage() {
+            return 24;
+        }
+
+        /** {@inheritDoc} */
+        @Override public long getOffHeapEntriesCount() {
+            return 25;
+        }
+
+        /** {@inheritDoc} */
+        @Override public long getOffHeapPrimaryEntriesCount() {
+            return 26;
+        }
+
+        /** {@inheritDoc} */
+        @Override public long getOffHeapBackupEntriesCount() {
+            return 27;
+        }
+
+        /** {@inheritDoc} */
+        @Override public long getOffHeapAllocatedSize() {
+            return 28;
+        }
+
+        /** {@inheritDoc} */
+        @Override public long getOffHeapMaxSize() {
+            return 29;
+        }
+
+        /** {@inheritDoc} */
+        @Override public long getSwapGets() {
+            return 30;
+        }
+
+        /** {@inheritDoc} */
+        @Override public long getSwapPuts() {
+            return 31;
+        }
+
+        /** {@inheritDoc} */
+        @Override public long getSwapRemovals() {
+            return 32;
+        }
+
+        /** {@inheritDoc} */
+        @Override public long getSwapHits() {
+            return 33;
+        }
+
+        /** {@inheritDoc} */
+        @Override public long getSwapMisses() {
+            return 34;
+        }
+
+        /** {@inheritDoc} */
+        @Override public long getSwapEntriesCount() {
+            return 35;
+        }
+
+        /** {@inheritDoc} */
+        @Override public long getSwapSize() {
+            return 36;
+        }
+
+        /** {@inheritDoc} */
+        @Override public float getSwapHitPercentage() {
+            return 37;
+        }
+
+        /** {@inheritDoc} */
+        @Override public float getSwapMissPercentage() {
+            return 38;
+        }
+
+        /** {@inheritDoc} */
+        @Override public int getSize() {
+            return 39;
+        }
+
+        /** {@inheritDoc} */
+        @Override public int getKeySize() {
+            return 40;
+        }
+
+        /** {@inheritDoc} */
+        @Override public boolean isEmpty() {
+            return true;
+        }
+
+        /** {@inheritDoc} */
+        @Override public int getDhtEvictQueueCurrentSize() {
+            return 41;
+        }
+
+        /** {@inheritDoc} */
+        @Override public int getTxThreadMapSize() {
+            return 42;
+        }
+
+        /** {@inheritDoc} */
+        @Override public int getTxXidMapSize() {
+            return 43;
+        }
+
+        /** {@inheritDoc} */
+        @Override public int getTxCommitQueueSize() {
+            return 44;
+        }
+
+        /** {@inheritDoc} */
+        @Override public int getTxPrepareQueueSize() {
+            return 45;
+        }
+
+        /** {@inheritDoc} */
+        @Override public int getTxStartVersionCountsSize() {
+            return 46;
+        }
+
+        /** {@inheritDoc} */
+        @Override public int getTxCommittedVersionsSize() {
+            return 47;
+        }
+
+        /** {@inheritDoc} */
+        @Override public int getTxRolledbackVersionsSize() {
+            return 48;
+        }
+
+        /** {@inheritDoc} */
+        @Override public int getTxDhtThreadMapSize() {
+            return 49;
+        }
+
+        /** {@inheritDoc} */
+        @Override public int getTxDhtXidMapSize() {
+            return 50;
+        }
+
+        /** {@inheritDoc} */
+        @Override public int getTxDhtCommitQueueSize() {
+            return 51;
+        }
+
+        /** {@inheritDoc} */
+        @Override public int getTxDhtPrepareQueueSize() {
+            return 52;
+        }
+
+        /** {@inheritDoc} */
+        @Override public int getTxDhtStartVersionCountsSize() {
+            return 53;
+        }
+
+        /** {@inheritDoc} */
+        @Override public int getTxDhtCommittedVersionsSize() {
+            return 54;
+        }
+
+        /** {@inheritDoc} */
+        @Override public int getTxDhtRolledbackVersionsSize() {
+            return 55;
+        }
+
+        /** {@inheritDoc} */
+        @Override public boolean isWriteBehindEnabled() {
+            return true;
+        }
+
+        /** {@inheritDoc} */
+        @Override public int getWriteBehindFlushSize() {
+            return 56;
+        }
+
+        /** {@inheritDoc} */
+        @Override public int getWriteBehindFlushThreadCount() {
+            return 57;
+        }
+
+        /** {@inheritDoc} */
+        @Override public long getWriteBehindFlushFrequency() {
+            return 58;
+        }
+
+        /** {@inheritDoc} */
+        @Override public int getWriteBehindStoreBatchSize() {
+            return 59;
+        }
+
+        /** {@inheritDoc} */
+        @Override public int getWriteBehindTotalCriticalOverflowCount() {
+            return 60;
+        }
+
+        /** {@inheritDoc} */
+        @Override public int getWriteBehindCriticalOverflowCount() {
+            return 61;
+        }
+
+        /** {@inheritDoc} */
+        @Override public int getWriteBehindErrorRetryCount() {
+            return 62;
+        }
+
+        /** {@inheritDoc} */
+        @Override public int getWriteBehindBufferSize() {
+            return 63;
+        }
+
+        /** {@inheritDoc} */
+        @Override public String getKeyType() {
+            return "foo";
+        }
+
+        /** {@inheritDoc} */
+        @Override public String getValueType() {
+            return "bar";
+        }
+
+        /** {@inheritDoc} */
+        @Override public boolean isStoreByValue() {
+            return true;
+        }
+
+        /** {@inheritDoc} */
+        @Override public boolean isStatisticsEnabled() {
+            return true;
+        }
+
+        /** {@inheritDoc} */
+        @Override public boolean isManagementEnabled() {
+            return true;
+        }
+
+        /** {@inheritDoc} */
+        @Override public boolean isReadThrough() {
+            return true;
+        }
+
+        /** {@inheritDoc} */
+        @Override public boolean isWriteThrough() {
+            return true;
+        }
+    }
+}
+

http://git-wip-us.apache.org/repos/asf/ignite/blob/17316f93/modules/platforms/dotnet/Apache.Ignite.Core.Tests/Apache.Ignite.Core.Tests.csproj
----------------------------------------------------------------------
diff --git a/modules/platforms/dotnet/Apache.Ignite.Core.Tests/Apache.Ignite.Core.Tests.csproj b/modules/platforms/dotnet/Apache.Ignite.Core.Tests/Apache.Ignite.Core.Tests.csproj
index ccd7cc4..f440c25 100644
--- a/modules/platforms/dotnet/Apache.Ignite.Core.Tests/Apache.Ignite.Core.Tests.csproj
+++ b/modules/platforms/dotnet/Apache.Ignite.Core.Tests/Apache.Ignite.Core.Tests.csproj
@@ -68,6 +68,7 @@
     <Compile Include="Binary\TypeResolverTest.cs" />
     <Compile Include="Cache\Affinity\AffinityKeyTest.cs" />
     <Compile Include="Cache\Affinity\AffinityTopologyVersionTest.cs" />
+    <Compile Include="Cache\CacheMetricsTest.cs" />
     <Compile Include="Cache\CacheResultTest.cs" />
     <Compile Include="Cache\CacheSwapSpaceTest.cs" />
     <Compile Include="Cache\Store\CacheStoreAdapterTest.cs" />

http://git-wip-us.apache.org/repos/asf/ignite/blob/17316f93/modules/platforms/dotnet/Apache.Ignite.Core.Tests/Cache/CacheMetricsTest.cs
----------------------------------------------------------------------
diff --git a/modules/platforms/dotnet/Apache.Ignite.Core.Tests/Cache/CacheMetricsTest.cs b/modules/platforms/dotnet/Apache.Ignite.Core.Tests/Cache/CacheMetricsTest.cs
new file mode 100644
index 0000000..0114280
--- /dev/null
+++ b/modules/platforms/dotnet/Apache.Ignite.Core.Tests/Cache/CacheMetricsTest.cs
@@ -0,0 +1,128 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements.  See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License.  You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+namespace Apache.Ignite.Core.Tests.Cache
+{
+    using Apache.Ignite.Core.Cache;
+    using Apache.Ignite.Core.Impl;
+    using Apache.Ignite.Core.Impl.Cache;
+    using NUnit.Framework;
+
+    /// <summary>
+    /// Tests cache metrics propagation.
+    /// </summary>
+    public class CacheMetricsTest
+    {
+        /// <summary>
+        /// Tests the metrics propagation.
+        /// </summary>
+        [Test]
+        public void TestMetricsPropagation()
+        {
+            using (var ignite = Ignition.Start(TestUtils.GetTestConfiguration()))
+            {
+                using (var inStream = IgniteManager.Memory.Allocate().GetStream())
+                {
+                    var result = ignite.GetCompute().ExecuteJavaTask<bool>(
+                        "org.apache.ignite.platform.PlatformCacheWriteMetricsTask", inStream.MemoryPointer);
+
+                    Assert.IsTrue(result);
+
+                    inStream.SynchronizeInput();
+
+                    var reader = ((Ignite)ignite).Marshaller.StartUnmarshal(inStream);
+
+                    ICacheMetrics metrics = new CacheMetricsImpl(reader);
+
+                    Assert.AreEqual(1, metrics.CacheHits);
+                    Assert.AreEqual(2, metrics.CacheHitPercentage);
+                    Assert.AreEqual(3, metrics.CacheMisses);
+                    Assert.AreEqual(4, metrics.CacheMissPercentage);
+                    Assert.AreEqual(5, metrics.CacheGets);
+                    Assert.AreEqual(6, metrics.CachePuts);
+                    Assert.AreEqual(7, metrics.CacheRemovals);
+                    Assert.AreEqual(8, metrics.CacheEvictions);
+                    Assert.AreEqual(9, metrics.AverageGetTime);
+                    Assert.AreEqual(10, metrics.AveragePutTime);
+                    Assert.AreEqual(11, metrics.AverageRemoveTime);
+                    Assert.AreEqual(12, metrics.AverageTxCommitTime);
+                    Assert.AreEqual(13, metrics.AverageTxRollbackTime);
+                    Assert.AreEqual(14, metrics.CacheTxCommits);
+                    Assert.AreEqual(15, metrics.CacheTxRollbacks);
+                    Assert.AreEqual("myCache", metrics.CacheName);
+                    Assert.AreEqual(16, metrics.OverflowSize);
+                    Assert.AreEqual(17, metrics.OffHeapGets);
+                    Assert.AreEqual(18, metrics.OffHeapPuts);
+                    Assert.AreEqual(19, metrics.OffHeapRemovals);
+                    Assert.AreEqual(20, metrics.OffHeapEvictions);
+                    Assert.AreEqual(21, metrics.OffHeapHits);
+                    Assert.AreEqual(22, metrics.OffHeapHitPercentage);
+                    Assert.AreEqual(23, metrics.OffHeapMisses);
+                    Assert.AreEqual(24, metrics.OffHeapMissPercentage);
+                    Assert.AreEqual(25, metrics.OffHeapEntriesCount);
+                    Assert.AreEqual(26, metrics.OffHeapPrimaryEntriesCount);
+                    Assert.AreEqual(27, metrics.OffHeapBackupEntriesCount);
+                    Assert.AreEqual(28, metrics.OffHeapAllocatedSize);
+                    Assert.AreEqual(29, metrics.OffHeapMaxSize);
+                    Assert.AreEqual(30, metrics.SwapGets);
+                    Assert.AreEqual(31, metrics.SwapPuts);
+                    Assert.AreEqual(32, metrics.SwapRemovals);
+                    Assert.AreEqual(33, metrics.SwapHits);
+                    Assert.AreEqual(34, metrics.SwapMisses);
+                    Assert.AreEqual(35, metrics.SwapEntriesCount);
+                    Assert.AreEqual(36, metrics.SwapSize);
+                    Assert.AreEqual(37, metrics.SwapHitPercentage);
+                    Assert.AreEqual(38, metrics.SwapMissPercentage);
+                    Assert.AreEqual(39, metrics.Size);
+                    Assert.AreEqual(40, metrics.KeySize);
+                    Assert.AreEqual(true, metrics.IsEmpty);
+                    Assert.AreEqual(41, metrics.DhtEvictQueueCurrentSize);
+                    Assert.AreEqual(42, metrics.TxThreadMapSize);
+                    Assert.AreEqual(43, metrics.TxXidMapSize);
+                    Assert.AreEqual(44, metrics.TxCommitQueueSize);
+                    Assert.AreEqual(45, metrics.TxPrepareQueueSize);
+                    Assert.AreEqual(46, metrics.TxStartVersionCountsSize);
+                    Assert.AreEqual(47, metrics.TxCommittedVersionsSize);
+                    Assert.AreEqual(48, metrics.TxRolledbackVersionsSize);
+                    Assert.AreEqual(49, metrics.TxDhtThreadMapSize);
+                    Assert.AreEqual(50, metrics.TxDhtXidMapSize);
+                    Assert.AreEqual(51, metrics.TxDhtCommitQueueSize);
+                    Assert.AreEqual(52, metrics.TxDhtPrepareQueueSize);
+                    Assert.AreEqual(53, metrics.TxDhtStartVersionCountsSize);
+                    Assert.AreEqual(54, metrics.TxDhtCommittedVersionsSize);
+                    Assert.AreEqual(55, metrics.TxDhtRolledbackVersionsSize);
+                    Assert.AreEqual(true, metrics.IsWriteBehindEnabled);
+                    Assert.AreEqual(56, metrics.WriteBehindFlushSize);
+                    Assert.AreEqual(57, metrics.WriteBehindFlushThreadCount);
+                    Assert.AreEqual(58, metrics.WriteBehindFlushFrequency);
+                    Assert.AreEqual(59, metrics.WriteBehindStoreBatchSize);
+                    Assert.AreEqual(60, metrics.WriteBehindTotalCriticalOverflowCount);
+                    Assert.AreEqual(61, metrics.WriteBehindCriticalOverflowCount);
+                    Assert.AreEqual(62, metrics.WriteBehindErrorRetryCount);
+                    Assert.AreEqual(63, metrics.WriteBehindBufferSize);
+                    Assert.AreEqual("foo", metrics.KeyType);
+                    Assert.AreEqual("bar", metrics.ValueType);
+                    Assert.AreEqual(true, metrics.IsStoreByValue);
+                    Assert.AreEqual(true, metrics.IsStatisticsEnabled);
+                    Assert.AreEqual(true, metrics.IsManagementEnabled);
+                    Assert.AreEqual(true, metrics.IsReadThrough);
+                    Assert.AreEqual(true, metrics.IsWriteThrough);
+                }
+            }
+        }
+    }
+}

http://git-wip-us.apache.org/repos/asf/ignite/blob/17316f93/modules/platforms/dotnet/Apache.Ignite.Core.Tests/Cache/CacheSwapSpaceTest.cs
----------------------------------------------------------------------
diff --git a/modules/platforms/dotnet/Apache.Ignite.Core.Tests/Cache/CacheSwapSpaceTest.cs b/modules/platforms/dotnet/Apache.Ignite.Core.Tests/Cache/CacheSwapSpaceTest.cs
index 296fd13..f32de21 100644
--- a/modules/platforms/dotnet/Apache.Ignite.Core.Tests/Cache/CacheSwapSpaceTest.cs
+++ b/modules/platforms/dotnet/Apache.Ignite.Core.Tests/Cache/CacheSwapSpaceTest.cs
@@ -113,7 +113,9 @@ namespace Apache.Ignite.Core.Tests.Cache
                 var metrics = cache.GetMetrics();
 
                 Assert.AreEqual(4, metrics.OffHeapEntriesCount);  // Entry takes more space than the value
-                Assert.AreEqual(3, metrics.OverflowSize / entrySize);  // 10 - 3 - 4 = 3
+                Assert.AreEqual(3, metrics.SwapEntriesCount);  // 10 - 3 - 4 = 3
+                Assert.AreEqual(3, metrics.OverflowSize / entrySize);
+                Assert.AreEqual(metrics.SwapSize, metrics.OverflowSize);
             }
         }
     }

http://git-wip-us.apache.org/repos/asf/ignite/blob/17316f93/modules/platforms/dotnet/Apache.Ignite.Core/Cache/ICacheMetrics.cs
----------------------------------------------------------------------
diff --git a/modules/platforms/dotnet/Apache.Ignite.Core/Cache/ICacheMetrics.cs b/modules/platforms/dotnet/Apache.Ignite.Core/Cache/ICacheMetrics.cs
index 3c01587..9117bf8 100644
--- a/modules/platforms/dotnet/Apache.Ignite.Core/Cache/ICacheMetrics.cs
+++ b/modules/platforms/dotnet/Apache.Ignite.Core/Cache/ICacheMetrics.cs
@@ -26,7 +26,7 @@ namespace Apache.Ignite.Core.Cache
         /// The number of get requests that were satisfied by the cache.
         /// </summary>
         /// <returns>
-        /// The number of hits
+        /// The number of hits.
         /// </returns>
         long CacheHits { get; }
 
@@ -42,7 +42,7 @@ namespace Apache.Ignite.Core.Cache
         /// A miss is a get request that is not satisfied.
         /// </summary>
         /// <returns>
-        /// The number of misses
+        /// The number of misses.
         /// </returns>
         long CacheMisses { get; }
 
@@ -80,7 +80,7 @@ namespace Apache.Ignite.Core.Cache
         long CacheRemovals { get; }
 
         /// <summary>
-        /// The total number of evictions from the cache. An eviction is a removal initiated by the cache itself 
+        /// The total number of evictions from the cache. An eviction is a removal initiated by the cache itself
         /// to free up space. An eviction is not treated as a removal and does not appear in the removal counts.
         /// </summary>
         /// <returns>
@@ -161,6 +161,70 @@ namespace Apache.Ignite.Core.Cache
         long OverflowSize { get; }
 
         /// <summary>
+        /// The total number of get requests to the off-heap memory.
+        /// </summary>
+        /// <returns>
+        /// The number of gets.
+        /// </returns>
+        long OffHeapGets { get; }
+
+        /// <summary>
+        /// The total number of put requests to the off-heap memory.
+        /// </summary>
+        /// <returns>
+        /// The number of puts.
+        /// </returns>
+        long OffHeapPuts { get; }
+
+        /// <summary>
+        /// The total number of removals from the off-heap memory. This does not include evictions.
+        /// </summary>
+        /// <returns>
+        /// The number of removals.
+        /// </returns>
+        long OffHeapRemovals { get; }
+
+        /// <summary>
+        /// The total number of evictions from the off-heap memory.
+        /// </summary>
+        /// <returns>
+        /// The number of evictions.
+        /// </returns>
+        long OffHeapEvictions { get; }
+
+        /// <summary>
+        /// The number of get requests that were satisfied by the off-heap memory.
+        /// </summary>
+        /// <returns>
+        /// The off-heap hits number.
+        /// </returns>
+        long OffHeapHits { get; }
+
+        /// <summary>
+        /// Gets the percentage of hits on off-heap memory.
+        /// </summary>
+        /// <returns>
+        /// The percentage of hits on off-heap memory.
+        /// </returns>
+        float OffHeapHitPercentage { get; }
+
+        /// <summary>
+        /// A miss is a get request that is not satisfied by off-heap memory.
+        /// </summary>
+        /// <returns>
+        /// The off-heap misses number.
+        /// </returns>
+        long OffHeapMisses { get; }
+
+        /// <summary>
+        /// Gets the percentage of misses on off-heap memory.
+        /// </summary>
+        /// <returns>
+        /// The percentage of misses on off-heap memory.
+        /// </returns>
+        float OffHeapMissPercentage { get; }
+
+        /// <summary>
         /// Gets number of entries stored in off-heap memory.
         /// </summary>
         /// <returns>
@@ -169,6 +233,22 @@ namespace Apache.Ignite.Core.Cache
         long OffHeapEntriesCount { get; }
 
         /// <summary>
+        /// Gets the number of primary entries stored in off-heap memory.
+        /// </summary>
+        /// <returns>
+        /// Number of primary entries stored in off-heap memory.
+        /// </returns>
+        long OffHeapPrimaryEntriesCount { get; }
+
+        /// <summary>
+        /// Gets number of backup entries stored in off-heap memory.
+        /// </summary>
+        /// <returns>
+        /// Number of backup entries stored in off-heap memory.
+        /// </returns>
+        long OffHeapBackupEntriesCount { get; }
+
+        /// <summary>
         /// Gets memory size allocated in off-heap.
         /// </summary>
         /// <returns>
@@ -177,6 +257,86 @@ namespace Apache.Ignite.Core.Cache
         long OffHeapAllocatedSize { get; }
 
         /// <summary>
+        /// Gets off-heap memory maximum size.
+        /// </summary>
+        /// <returns>
+        /// Off-heap memory maximum size.
+        /// </returns>
+        long OffHeapMaxSize { get; }
+
+        /// <summary>
+        /// The total number of get requests to the swap.
+        /// </summary>
+        /// <returns>
+        /// The number of gets from the swap.
+        /// </returns>
+        long SwapGets { get; }
+
+        /// <summary>
+        /// The total number of put requests to the swap.
+        /// </summary>
+        /// <returns>
+        /// The number of puts to the swap.
+        /// </returns>
+        long SwapPuts { get; }
+
+        /// <summary>
+        /// The total number of removals from the swap.
+        /// </summary>
+        /// <returns>
+        /// The number of removals from the swap.
+        /// </returns>
+        long SwapRemovals { get; }
+
+        /// <summary>
+        /// The number of get requests that were satisfied by the swap.
+        /// </summary>
+        /// <returns>
+        /// The swap hits number.
+        /// </returns>
+        long SwapHits { get; }
+
+        /// <summary>
+        /// A number of get requests to that were not satisfied by the swap.
+        /// </summary>
+        /// <returns>
+        /// The swap misses number.
+        /// </returns>
+        long SwapMisses { get; }
+
+        /// <summary>
+        /// Gets number of entries stored in swap.
+        /// </summary>
+        /// <returns>
+        /// Number of entries stored in swap.
+        /// </returns>
+        long SwapEntriesCount { get; }
+
+        /// <summary>
+        /// Gets size of swap, in bytes.
+        /// </summary>
+        /// <returns>
+        /// Size of swap, in bytes.
+        /// </returns>
+        long SwapSize { get; }
+
+        /// <summary>
+        /// Gets the percentage of hits on swap.
+        /// </summary>
+        /// <returns>
+        /// The percentage of hits on swap.
+        /// </returns>
+        float SwapHitPercentage { get; }
+
+        /// <summary>
+        /// Gets the percentage of misses on swap.
+        /// </summary>
+        /// <returns>
+        /// The percentage of misses on swap.
+        /// </returns>
+        float SwapMissPercentage { get; }
+
+        /// <summary>
         /// Gets number of non-null values in the cache.
         /// </summary>
         /// <returns>
@@ -329,10 +489,10 @@ namespace Apache.Ignite.Core.Cache
         bool IsWriteBehindEnabled { get; }
 
         /// <summary>
-        /// Gets the maximum size of the write-behind buffer. When the count of unique keys in write buffer exceeds 
-        /// this value, the buffer is scheduled for write to the underlying store. 
-        /// <para /> 
-        /// If this value is 0, then flush is performed only on time-elapsing basis. 
+        /// Gets the maximum size of the write-behind buffer. When the count of unique keys in write buffer exceeds
+        /// this value, the buffer is scheduled for write to the underlying store.
+        /// <para />
+        /// If this value is 0, then flush is performed only on time-elapsing basis.
         /// </summary>
         /// <returns>
         /// Buffer size that triggers flush procedure.
@@ -348,8 +508,8 @@ namespace Apache.Ignite.Core.Cache
         int WriteBehindFlushThreadCount { get; }
 
         /// <summary>
-        /// Gets the cache flush frequency. All pending operations on the underlying store will be performed 
-        /// within time interval not less then this value. 
+        /// Gets the cache flush frequency. All pending operations on the underlying store will be performed
+        /// within time interval not less then this value.
         /// <para /> If this value is 0, then flush is performed only when buffer size exceeds flush size.
         /// </summary>
         /// <returns>
@@ -366,7 +526,7 @@ namespace Apache.Ignite.Core.Cache
         int WriteBehindStoreBatchSize { get; }
 
         /// <summary>
-        /// Gets count of write buffer overflow events since initialization. 
+        /// Gets count of write buffer overflow events since initialization.
         /// Each overflow event causes the ongoing flush operation to be performed synchronously.
         /// </summary>
         /// <returns>
@@ -375,7 +535,7 @@ namespace Apache.Ignite.Core.Cache
         int WriteBehindTotalCriticalOverflowCount { get; }
 
         /// <summary>
-        /// Gets count of write buffer overflow events in progress at the moment. 
+        /// Gets count of write buffer overflow events in progress at the moment.
         /// Each overflow event causes the ongoing flush operation to be performed synchronously.
         /// </summary>
         /// <returns>
@@ -384,8 +544,8 @@ namespace Apache.Ignite.Core.Cache
         int WriteBehindCriticalOverflowCount { get; }
 
         /// <summary>
-        /// Gets count of cache entries that are in a store-retry state. 
-        /// An entry is assigned a store-retry state when underlying store failed due some reason 
+        /// Gets count of cache entries that are in a store-retry state.
+        /// An entry is assigned a store-retry state when underlying store failed due some reason
         /// and cache has enough space to retain this entry till the next try.
         /// </summary>
         /// <returns>
@@ -394,7 +554,7 @@ namespace Apache.Ignite.Core.Cache
         int WriteBehindErrorRetryCount { get; }
 
         /// <summary>
-        /// Gets count of entries that were processed by the write-behind store 
+        /// Gets count of entries that were processed by the write-behind store
         /// and have not been flushed to the underlying store yet.
         /// </summary>
         /// <returns>
@@ -420,50 +580,50 @@ namespace Apache.Ignite.Core.Cache
 
         /// <summary>
         /// Whether storeByValue true or storeByReference false. When true, both keys and values are stored by value. 
-        /// <para /> 
-        /// When false, both keys and values are stored by reference. Caches stored by reference are capable of 
-        /// mutation by any threads holding the reference. 
-        /// The effects are: 
+        /// <para />
+        /// When false, both keys and values are stored by reference. Caches stored by reference are capable of
+        /// mutation by any threads holding the reference.
+        /// The effects are:
         /// - if the key is mutated, then the key may not be retrievable or removable
         /// - if the value is mutated, then all threads in the JVM can potentially observe those mutations, subject
         /// to the normal Java Memory Model rules.
-        /// Storage by reference only applies to the local heap. 
-        /// If an entry is moved off heap it will need to be transformed into a representation. 
-        /// Any mutations that occur after transformation may not be reflected in the cache. 
-        /// <para /> 
-        /// When a cache is storeByValue, any mutation to the key or value does not affect the key of value 
-        /// stored in the cache. 
-        /// <para /> 
+        /// Storage by reference only applies to the local heap.
+        /// If an entry is moved off heap it will need to be transformed into a representation.
+        /// Any mutations that occur after transformation may not be reflected in the cache.
+        /// <para />
+        /// When a cache is storeByValue, any mutation to the key or value does not affect the key of value
+        /// stored in the cache.
+        /// <para />
         /// The default value is true.
         /// </summary>
         /// <returns>
-        /// True if the cache is store by value
+        /// True if the cache is store by value.
         /// </returns>
         bool IsStoreByValue { get; }
 
         /// <summary>
-        /// Checks whether statistics collection is enabled in this cache. 
-        /// <para /> 
+        /// Checks whether statistics collection is enabled in this cache.
+        /// <para />
         /// The default value is false.
         /// </summary>
         /// <returns>
-        /// True if statistics collection is enabled
+        /// True if statistics collection is enabled.
         /// </returns>
         bool IsStatisticsEnabled { get; }
 
         /// <summary>
-        /// Checks whether management is enabled on this cache. 
-        /// <para /> 
+        /// Checks whether management is enabled on this cache.
+        /// <para />
         /// The default value is false.
         /// </summary>
         /// <returns>
-        /// True if management is enabled
+        /// True if management is enabled.
         /// </returns>
         bool IsManagementEnabled { get; }
 
         /// <summary>
-        /// Determines if a cache should operate in read-through mode. 
-        /// <para /> 
+        /// Determines if a cache should operate in read-through mode.
+        /// <para />
         /// The default value is false
         /// </summary>
         /// <returns>
@@ -472,10 +632,10 @@ namespace Apache.Ignite.Core.Cache
         bool IsReadThrough { get; }
 
         /// <summary>
-        /// Determines if a cache should operate in "write-through" mode. 
-        /// <para /> 
-        /// Will appropriately cause the configured CacheWriter to be invoked. 
-        /// <para /> 
+        /// Determines if a cache should operate in "write-through" mode.
+        /// <para />
+        /// Will appropriately cause the configured CacheWriter to be invoked.
+        /// <para />
         /// The default value is false
         /// </summary>
         /// <returns>

http://git-wip-us.apache.org/repos/asf/ignite/blob/17316f93/modules/platforms/dotnet/Apache.Ignite.Core/Impl/Cache/CacheMetricsImpl.cs
----------------------------------------------------------------------
diff --git a/modules/platforms/dotnet/Apache.Ignite.Core/Impl/Cache/CacheMetricsImpl.cs b/modules/platforms/dotnet/Apache.Ignite.Core/Impl/Cache/CacheMetricsImpl.cs
index d42a76d6..48943b4 100644
--- a/modules/platforms/dotnet/Apache.Ignite.Core/Impl/Cache/CacheMetricsImpl.cs
+++ b/modules/platforms/dotnet/Apache.Ignite.Core/Impl/Cache/CacheMetricsImpl.cs
@@ -25,224 +25,523 @@ namespace Apache.Ignite.Core.Impl.Cache
     /// </summary>
     internal class CacheMetricsImpl : ICacheMetrics
     {
+        /** */
+        private readonly long _cacheHits;
+
+        /** */
+        private readonly float _cacheHitPercentage;
+
+        /** */
+        private readonly long _cacheMisses;
+
+        /** */
+        private readonly float _cacheMissPercentage;
+
+        /** */
+        private readonly long _cacheGets;
+
+        /** */
+        private readonly long _cachePuts;
+
+        /** */
+        private readonly long _cacheRemovals;
+
+        /** */
+        private readonly long _cacheEvictions;
+
+        /** */
+        private readonly float _averageGetTime;
+
+        /** */
+        private readonly float _averagePutTime;
+
+        /** */
+        private readonly float _averageRemoveTime;
+
+        /** */
+        private readonly float _averageTxCommitTime;
+
+        /** */
+        private readonly float _averageTxRollbackTime;
+
+        /** */
+        private readonly long _cacheTxCommits;
+
+        /** */
+        private readonly long _cacheTxRollbacks;
+
+        /** */
+        private readonly string _cacheName;
+
+        /** */
+        private readonly long _overflowSize;
+
+        /** */
+        private readonly long _offHeapGets;
+
+        /** */
+        private readonly long _offHeapPuts;
+
+        /** */
+        private readonly long _offHeapRemovals;
+
+        /** */
+        private readonly long _offHeapEvictions;
+
+        /** */
+        private readonly long _offHeapHits;
+
+        /** */
+        private readonly float _offHeapHitPercentage;
+
+        /** */
+        private readonly long _offHeapMisses;
+
+        /** */
+        private readonly float _offHeapMissPercentage;
+
+        /** */
+        private readonly long _offHeapEntriesCount;
+
+        /** */
+        private readonly long _offHeapPrimaryEntriesCount;
+
+        /** */
+        private readonly long _offHeapBackupEntriesCount;
+
+        /** */
+        private readonly long _offHeapAllocatedSize;
+
+        /** */
+        private readonly long _offHeapMaxSize;
+
+        /** */
+        private readonly long _swapGets;
+
+        /** */
+        private readonly long _swapPuts;
+
+        /** */
+        private readonly long _swapRemovals;
+
+        /** */
+        private readonly long _swapHits;
+
+        /** */
+        private readonly long _swapMisses;
+
+        /** */
+        private readonly long _swapEntriesCount;
+
+        /** */
+        private readonly long _swapSize;
+
+        /** */
+        private readonly float _swapHitPercentage;
+
+        /** */
+        private readonly float _swapMissPercentage;
+
+        /** */
+        private readonly int _size;
+
+        /** */
+        private readonly int _keySize;
+
+        /** */
+        private readonly bool _isEmpty;
+
+        /** */
+        private readonly int _dhtEvictQueueCurrentSize;
+
+        /** */
+        private readonly int _txThreadMapSize;
+
+        /** */
+        private readonly int _txXidMapSize;
+
+        /** */
+        private readonly int _txCommitQueueSize;
+
+        /** */
+        private readonly int _txPrepareQueueSize;
+
+        /** */
+        private readonly int _txStartVersionCountsSize;
+
+        /** */
+        private readonly int _txCommittedVersionsSize;
+
+        /** */
+        private readonly int _txRolledbackVersionsSize;
+
+        /** */
+        private readonly int _txDhtThreadMapSize;
+
+        /** */
+        private readonly int _txDhtXidMapSize;
+
+        /** */
+        private readonly int _txDhtCommitQueueSize;
+
+        /** */
+        private readonly int _txDhtPrepareQueueSize;
+
+        /** */
+        private readonly int _txDhtStartVersionCountsSize;
+
+        /** */
+        private readonly int _txDhtCommittedVersionsSize;
+
+        /** */
+        private readonly int _txDhtRolledbackVersionsSize;
+
+        /** */
+        private readonly bool _isWriteBehindEnabled;
+
+        /** */
+        private readonly int _writeBehindFlushSize;
+
+        /** */
+        private readonly int _writeBehindFlushThreadCount;
+
+        /** */
+        private readonly long _writeBehindFlushFrequency;
+
+        /** */
+        private readonly int _writeBehindStoreBatchSize;
+
+        /** */
+        private readonly int _writeBehindTotalCriticalOverflowCount;
+
+        /** */
+        private readonly int _writeBehindCriticalOverflowCount;
+
+        /** */
+        private readonly int _writeBehindErrorRetryCount;
+
+        /** */
+        private readonly int _writeBehindBufferSize;
+
+        /** */
+        private readonly string _keyType;
+
+        /** */
+        private readonly string _valueType;
+
+        /** */
+        private readonly bool _isStoreByValue;
+
+        /** */
+        private readonly bool _isStatisticsEnabled;
+
+        /** */
+        private readonly bool _isManagementEnabled;
+
+        /** */
+        private readonly bool _isReadThrough;
+
+        /** */
+        private readonly bool _isWriteThrough;
+
         /// <summary>
         /// Initializes a new instance of the <see cref="CacheMetricsImpl"/> class.
         /// </summary>
         /// <param name="reader">The reader.</param>
         public CacheMetricsImpl(IBinaryRawReader reader)
         {
-            CacheGets = reader.ReadLong();
-            CachePuts = reader.ReadLong();
-            CacheHits = reader.ReadLong();
-            CacheMisses = reader.ReadLong();
-            CacheTxCommits = reader.ReadLong();
-            CacheTxRollbacks = reader.ReadLong();
-            CacheEvictions = reader.ReadLong();
-            CacheRemovals = reader.ReadLong();
-            AveragePutTime = reader.ReadFloat();
-            AverageGetTime = reader.ReadFloat();
-            AverageRemoveTime = reader.ReadFloat();
-            AverageTxCommitTime = reader.ReadFloat();
-            AverageTxRollbackTime = reader.ReadFloat();
-            CacheName = reader.ReadString();
-            OverflowSize = reader.ReadLong();
-            OffHeapEntriesCount = reader.ReadLong();
-            OffHeapAllocatedSize = reader.ReadLong();
-            Size = reader.ReadInt();
-            KeySize = reader.ReadInt();
-            IsEmpty = reader.ReadBoolean();
-            DhtEvictQueueCurrentSize = reader.ReadInt();
-            TxThreadMapSize = reader.ReadInt();
-            TxXidMapSize = reader.ReadInt();
-            TxCommitQueueSize = reader.ReadInt();
-            TxPrepareQueueSize = reader.ReadInt();
-            TxStartVersionCountsSize = reader.ReadInt();
-            TxCommittedVersionsSize = reader.ReadInt();
-            TxRolledbackVersionsSize = reader.ReadInt();
-            TxDhtThreadMapSize = reader.ReadInt();
-            TxDhtXidMapSize = reader.ReadInt();
-            TxDhtCommitQueueSize = reader.ReadInt();
-            TxDhtPrepareQueueSize = reader.ReadInt();
-            TxDhtStartVersionCountsSize = reader.ReadInt();
-            TxDhtCommittedVersionsSize = reader.ReadInt();
-            TxDhtRolledbackVersionsSize = reader.ReadInt();
-            IsWriteBehindEnabled = reader.ReadBoolean();
-            WriteBehindFlushSize = reader.ReadInt();
-            WriteBehindFlushThreadCount = reader.ReadInt();
-            WriteBehindFlushFrequency = reader.ReadLong();
-            WriteBehindStoreBatchSize = reader.ReadInt();
-            WriteBehindTotalCriticalOverflowCount = reader.ReadInt();
-            WriteBehindCriticalOverflowCount = reader.ReadInt();
-            WriteBehindErrorRetryCount = reader.ReadInt();
-            WriteBehindBufferSize = reader.ReadInt();
-            KeyType = reader.ReadString();
-            ValueType = reader.ReadString();
-            IsStoreByValue = reader.ReadBoolean();
-            IsStatisticsEnabled = reader.ReadBoolean();
-            IsManagementEnabled = reader.ReadBoolean();
-            IsReadThrough = reader.ReadBoolean();
-            IsWriteThrough = reader.ReadBoolean();
-            CacheHitPercentage = reader.ReadFloat();
-            CacheMissPercentage = reader.ReadFloat();
+            _cacheHits = reader.ReadLong();
+            _cacheHitPercentage = reader.ReadFloat();
+            _cacheMisses = reader.ReadLong();
+            _cacheMissPercentage = reader.ReadFloat();
+            _cacheGets = reader.ReadLong();
+            _cachePuts = reader.ReadLong();
+            _cacheRemovals = reader.ReadLong();
+            _cacheEvictions = reader.ReadLong();
+            _averageGetTime = reader.ReadFloat();
+            _averagePutTime = reader.ReadFloat();
+            _averageRemoveTime = reader.ReadFloat();
+            _averageTxCommitTime = reader.ReadFloat();
+            _averageTxRollbackTime = reader.ReadFloat();
+            _cacheTxCommits = reader.ReadLong();
+            _cacheTxRollbacks = reader.ReadLong();
+            _cacheName = reader.ReadString();
+            _overflowSize = reader.ReadLong();
+            _offHeapGets = reader.ReadLong();
+            _offHeapPuts = reader.ReadLong();
+            _offHeapRemovals = reader.ReadLong();
+            _offHeapEvictions = reader.ReadLong();
+            _offHeapHits = reader.ReadLong();
+            _offHeapHitPercentage = reader.ReadFloat();
+            _offHeapMisses = reader.ReadLong();
+            _offHeapMissPercentage = reader.ReadFloat();
+            _offHeapEntriesCount = reader.ReadLong();
+            _offHeapPrimaryEntriesCount = reader.ReadLong();
+            _offHeapBackupEntriesCount = reader.ReadLong();
+            _offHeapAllocatedSize = reader.ReadLong();
+            _offHeapMaxSize = reader.ReadLong();
+            _swapGets = reader.ReadLong();
+            _swapPuts = reader.ReadLong();
+            _swapRemovals = reader.ReadLong();
+            _swapHits = reader.ReadLong();
+            _swapMisses = reader.ReadLong();
+            _swapEntriesCount = reader.ReadLong();
+            _swapSize = reader.ReadLong();
+            _swapHitPercentage = reader.ReadFloat();
+            _swapMissPercentage = reader.ReadFloat();
+            _size = reader.ReadInt();
+            _keySize = reader.ReadInt();
+            _isEmpty = reader.ReadBoolean();
+            _dhtEvictQueueCurrentSize = reader.ReadInt();
+            _txThreadMapSize = reader.ReadInt();
+            _txXidMapSize = reader.ReadInt();
+            _txCommitQueueSize = reader.ReadInt();
+            _txPrepareQueueSize = reader.ReadInt();
+            _txStartVersionCountsSize = reader.ReadInt();
+            _txCommittedVersionsSize = reader.ReadInt();
+            _txRolledbackVersionsSize = reader.ReadInt();
+            _txDhtThreadMapSize = reader.ReadInt();
+            _txDhtXidMapSize = reader.ReadInt();
+            _txDhtCommitQueueSize = reader.ReadInt();
+            _txDhtPrepareQueueSize = reader.ReadInt();
+            _txDhtStartVersionCountsSize = reader.ReadInt();
+            _txDhtCommittedVersionsSize = reader.ReadInt();
+            _txDhtRolledbackVersionsSize = reader.ReadInt();
+            _isWriteBehindEnabled = reader.ReadBoolean();
+            _writeBehindFlushSize = reader.ReadInt();
+            _writeBehindFlushThreadCount = reader.ReadInt();
+            _writeBehindFlushFrequency = reader.ReadLong();
+            _writeBehindStoreBatchSize = reader.ReadInt();
+            _writeBehindTotalCriticalOverflowCount = reader.ReadInt();
+            _writeBehindCriticalOverflowCount = reader.ReadInt();
+            _writeBehindErrorRetryCount = reader.ReadInt();
+            _writeBehindBufferSize = reader.ReadInt();
+            _keyType = reader.ReadString();
+            _valueType = reader.ReadString();
+            _isStoreByValue = reader.ReadBoolean();
+            _isStatisticsEnabled = reader.ReadBoolean();
+            _isManagementEnabled = reader.ReadBoolean();
+            _isReadThrough = reader.ReadBoolean();
+            _isWriteThrough = reader.ReadBoolean();
         }
 
-        /** <inheritdoc /> */
-        public long CacheHits { get; private set; }
+        /** <inheritDoc /> */
+        public long CacheHits { get { return _cacheHits; } }
+
+        /** <inheritDoc /> */
+        public float CacheHitPercentage { get { return _cacheHitPercentage; } }
+
+        /** <inheritDoc /> */
+        public long CacheMisses { get { return _cacheMisses; } }
+
+        /** <inheritDoc /> */
+        public float CacheMissPercentage { get { return _cacheMissPercentage; } }
+
+        /** <inheritDoc /> */
+        public long CacheGets { get { return _cacheGets; } }
+
+        /** <inheritDoc /> */
+        public long CachePuts { get { return _cachePuts; } }
+
+        /** <inheritDoc /> */
+        public long CacheRemovals { get { return _cacheRemovals; } }
+
+        /** <inheritDoc /> */
+        public long CacheEvictions { get { return _cacheEvictions; } }
+
+        /** <inheritDoc /> */
+        public float AverageGetTime { get { return _averageGetTime; } }
+
+        /** <inheritDoc /> */
+        public float AveragePutTime { get { return _averagePutTime; } }
+
+        /** <inheritDoc /> */
+        public float AverageRemoveTime { get { return _averageRemoveTime; } }
+
+        /** <inheritDoc /> */
+        public float AverageTxCommitTime { get { return _averageTxCommitTime; } }
+
+        /** <inheritDoc /> */
+        public float AverageTxRollbackTime { get { return _averageTxRollbackTime; } }
+
+        /** <inheritDoc /> */
+        public long CacheTxCommits { get { return _cacheTxCommits; } }
+
+        /** <inheritDoc /> */
+        public long CacheTxRollbacks { get { return _cacheTxRollbacks; } }
+
+        /** <inheritDoc /> */
+        public string CacheName { get { return _cacheName; } }
+
+        /** <inheritDoc /> */
+        public long OverflowSize { get { return _overflowSize; } }
+
+        /** <inheritDoc /> */
+        public long OffHeapGets { get { return _offHeapGets; } }
+
+        /** <inheritDoc /> */
+        public long OffHeapPuts { get { return _offHeapPuts; } }
+
+        /** <inheritDoc /> */
+        public long OffHeapRemovals { get { return _offHeapRemovals; } }
+
+        /** <inheritDoc /> */
+        public long OffHeapEvictions { get { return _offHeapEvictions; } }
 
-        /** <inheritdoc /> */
-        public float CacheHitPercentage { get; private set; }
+        /** <inheritDoc /> */
+        public long OffHeapHits { get { return _offHeapHits; } }
 
-        /** <inheritdoc /> */
-        public long CacheMisses { get; private set; }
+        /** <inheritDoc /> */
+        public float OffHeapHitPercentage { get { return _offHeapHitPercentage; } }
 
-        /** <inheritdoc /> */
-        public float CacheMissPercentage { get; private set; }
+        /** <inheritDoc /> */
+        public long OffHeapMisses { get { return _offHeapMisses; } }
 
-        /** <inheritdoc /> */
-        public long CacheGets { get; private set; }
+        /** <inheritDoc /> */
+        public float OffHeapMissPercentage { get { return _offHeapMissPercentage; } }
 
-        /** <inheritdoc /> */
-        public long CachePuts { get; private set; }
+        /** <inheritDoc /> */
+        public long OffHeapEntriesCount { get { return _offHeapEntriesCount; } }
 
-        /** <inheritdoc /> */
-        public long CacheRemovals { get; private set; }
+        /** <inheritDoc /> */
+        public long OffHeapPrimaryEntriesCount { get { return _offHeapPrimaryEntriesCount; } }
 
-        /** <inheritdoc /> */
-        public long CacheEvictions { get; private set; }
+        /** <inheritDoc /> */
+        public long OffHeapBackupEntriesCount { get { return _offHeapBackupEntriesCount; } }
 
-        /** <inheritdoc /> */
-        public float AverageGetTime { get; private set; }
+        /** <inheritDoc /> */
+        public long OffHeapAllocatedSize { get { return _offHeapAllocatedSize; } }
 
-        /** <inheritdoc /> */
-        public float AveragePutTime { get; private set; }
+        /** <inheritDoc /> */
+        public long OffHeapMaxSize { get { return _offHeapMaxSize; } }
 
-        /** <inheritdoc /> */
-        public float AverageRemoveTime { get; private set; }
+        /** <inheritDoc /> */
+        public long SwapGets { get { return _swapGets; } }
 
-        /** <inheritdoc /> */
-        public float AverageTxCommitTime { get; private set; }
+        /** <inheritDoc /> */
+        public long SwapPuts { get { return _swapPuts; } }
 
-        /** <inheritdoc /> */
-        public float AverageTxRollbackTime { get; private set; }
+        /** <inheritDoc /> */
+        public long SwapRemovals { get { return _swapRemovals; } }
 
-        /** <inheritdoc /> */
-        public long CacheTxCommits { get; private set; }
+        /** <inheritDoc /> */
+        public long SwapHits { get { return _swapHits; } }
 
-        /** <inheritdoc /> */
-        public long CacheTxRollbacks { get; private set; }
+        /** <inheritDoc /> */
+        public long SwapMisses { get { return _swapMisses; } }
 
-        /** <inheritdoc /> */
-        public string CacheName { get; private set; }
+        /** <inheritDoc /> */
+        public long SwapEntriesCount { get { return _swapEntriesCount; } }
 
-        /** <inheritdoc /> */
-        public long OverflowSize { get; private set; }
+        /** <inheritDoc /> */
+        public long SwapSize { get { return _swapSize; } }
 
-        /** <inheritdoc /> */
-        public long OffHeapEntriesCount { get; private set; }
+        /** <inheritDoc /> */
+        public float SwapHitPercentage { get { return _swapHitPercentage; } }
 
-        /** <inheritdoc /> */
-        public long OffHeapAllocatedSize { get; private set; }
+        /** <inheritDoc /> */
+        public float SwapMissPercentage { get { return _swapMissPercentage; } }
 
-        /** <inheritdoc /> */
-        public int Size { get; private set; }
+        /** <inheritDoc /> */
+        public int Size { get { return _size; } }
 
-        /** <inheritdoc /> */
-        public int KeySize { get; private set; }
+        /** <inheritDoc /> */
+        public int KeySize { get { return _keySize; } }
 
-        /** <inheritdoc /> */
-        public bool IsEmpty { get; private set; }
+        /** <inheritDoc /> */
+        public bool IsEmpty { get { return _isEmpty; } }
 
-        /** <inheritdoc /> */
-        public int DhtEvictQueueCurrentSize { get; private set; }
+        /** <inheritDoc /> */
+        public int DhtEvictQueueCurrentSize { get { return _dhtEvictQueueCurrentSize; } }
 
-        /** <inheritdoc /> */
-        public int TxThreadMapSize { get; private set; }
+        /** <inheritDoc /> */
+        public int TxThreadMapSize { get { return _txThreadMapSize; } }
 
-        /** <inheritdoc /> */
-        public int TxXidMapSize { get; private set; }
+        /** <inheritDoc /> */
+        public int TxXidMapSize { get { return _txXidMapSize; } }
 
-        /** <inheritdoc /> */
-        public int TxCommitQueueSize { get; private set; }
+        /** <inheritDoc /> */
+        public int TxCommitQueueSize { get { return _txCommitQueueSize; } }
 
-        /** <inheritdoc /> */
-        public int TxPrepareQueueSize { get; private set; }
+        /** <inheritDoc /> */
+        public int TxPrepareQueueSize { get { return _txPrepareQueueSize; } }
 
-        /** <inheritdoc /> */
-        public int TxStartVersionCountsSize { get; private set; }
+        /** <inheritDoc /> */
+        public int TxStartVersionCountsSize { get { return _txStartVersionCountsSize; } }
 
-        /** <inheritdoc /> */
-        public int TxCommittedVersionsSize { get; private set; }
+        /** <inheritDoc /> */
+        public int TxCommittedVersionsSize { get { return _txCommittedVersionsSize; } }
 
-        /** <inheritdoc /> */
-        public int TxRolledbackVersionsSize { get; private set; }
+        /** <inheritDoc /> */
+        public int TxRolledbackVersionsSize { get { return _txRolledbackVersionsSize; } }
 
-        /** <inheritdoc /> */
-        public int TxDhtThreadMapSize { get; private set; }
+        /** <inheritDoc /> */
+        public int TxDhtThreadMapSize { get { return _txDhtThreadMapSize; } }
 
-        /** <inheritdoc /> */
-        public int TxDhtXidMapSize { get; private set; }
+        /** <inheritDoc /> */
+        public int TxDhtXidMapSize { get { return _txDhtXidMapSize; } }
 
-        /** <inheritdoc /> */
-        public int TxDhtCommitQueueSize { get; private set; }
+        /** <inheritDoc /> */
+        public int TxDhtCommitQueueSize { get { return _txDhtCommitQueueSize; } }
 
-        /** <inheritdoc /> */
-        public int TxDhtPrepareQueueSize { get; private set; }
+        /** <inheritDoc /> */
+        public int TxDhtPrepareQueueSize { get { return _txDhtPrepareQueueSize; } }
 
-        /** <inheritdoc /> */
-        public int TxDhtStartVersionCountsSize { get; private set; }
+        /** <inheritDoc /> */
+        public int TxDhtStartVersionCountsSize { get { return _txDhtStartVersionCountsSize; } }
 
-        /** <inheritdoc /> */
-        public int TxDhtCommittedVersionsSize { get; private set; }
+        /** <inheritDoc /> */
+        public int TxDhtCommittedVersionsSize { get { return _txDhtCommittedVersionsSize; } }
 
-        /** <inheritdoc /> */
-        public int TxDhtRolledbackVersionsSize { get; private set; }
+        /** <inheritDoc /> */
+        public int TxDhtRolledbackVersionsSize { get { return _txDhtRolledbackVersionsSize; } }
 
-        /** <inheritdoc /> */
-        public bool IsWriteBehindEnabled { get; private set; }
+        /** <inheritDoc /> */
+        public bool IsWriteBehindEnabled { get { return _isWriteBehindEnabled; } }
 
-        /** <inheritdoc /> */
-        public int WriteBehindFlushSize { get; private set; }
+        /** <inheritDoc /> */
+        public int WriteBehindFlushSize { get { return _writeBehindFlushSize; } }
 
-        /** <inheritdoc /> */
-        public int WriteBehindFlushThreadCount { get; private set; }
+        /** <inheritDoc /> */
+        public int WriteBehindFlushThreadCount { get { return _writeBehindFlushThreadCount; } }
 
-        /** <inheritdoc /> */
-        public long WriteBehindFlushFrequency { get; private set; }
+        /** <inheritDoc /> */
+        public long WriteBehindFlushFrequency { get { return _writeBehindFlushFrequency; } }
 
-        /** <inheritdoc /> */
-        public int WriteBehindStoreBatchSize { get; private set; }
+        /** <inheritDoc /> */
+        public int WriteBehindStoreBatchSize { get { return _writeBehindStoreBatchSize; } }
 
-        /** <inheritdoc /> */
-        public int WriteBehindTotalCriticalOverflowCount { get; private set; }
+        /** <inheritDoc /> */
+        public int WriteBehindTotalCriticalOverflowCount { get { return _writeBehindTotalCriticalOverflowCount; } }
 
-        /** <inheritdoc /> */
-        public int WriteBehindCriticalOverflowCount { get; private set; }
+        /** <inheritDoc /> */
+        public int WriteBehindCriticalOverflowCount { get { return _writeBehindCriticalOverflowCount; } }
 
-        /** <inheritdoc /> */
-        public int WriteBehindErrorRetryCount { get; private set; }
+        /** <inheritDoc /> */
+        public int WriteBehindErrorRetryCount { get { return _writeBehindErrorRetryCount; } }
 
-        /** <inheritdoc /> */
-        public int WriteBehindBufferSize { get; private set; }
+        /** <inheritDoc /> */
+        public int WriteBehindBufferSize { get { return _writeBehindBufferSize; } }
 
-        /** <inheritdoc /> */
-        public string KeyType { get; private set; }
+        /** <inheritDoc /> */
+        public string KeyType { get { return _keyType; } }
 
-        /** <inheritdoc /> */
-        public string ValueType { get; private set; }
+        /** <inheritDoc /> */
+        public string ValueType { get { return _valueType; } }
 
-        /** <inheritdoc /> */
-        public bool IsStoreByValue { get; private set; }
+        /** <inheritDoc /> */
+        public bool IsStoreByValue { get { return _isStoreByValue; } }
 
-        /** <inheritdoc /> */
-        public bool IsStatisticsEnabled { get; private set; }
+        /** <inheritDoc /> */
+        public bool IsStatisticsEnabled { get { return _isStatisticsEnabled; } }
 
-        /** <inheritdoc /> */
-        public bool IsManagementEnabled { get; private set; }
+        /** <inheritDoc /> */
+        public bool IsManagementEnabled { get { return _isManagementEnabled; } }
 
-        /** <inheritdoc /> */
-        public bool IsReadThrough { get; private set; }
+        /** <inheritDoc /> */
+        public bool IsReadThrough { get { return _isReadThrough; } }
 
-        /** <inheritdoc /> */
-        public bool IsWriteThrough { get; private set; }
+        /** <inheritDoc /> */
+        public bool IsWriteThrough { get { return _isWriteThrough; } }
     }
 }
\ No newline at end of file


Mime
View raw message