ignite-commits mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From sboi...@apache.org
Subject [13/16] ignite git commit: IGNITE-1906: .NET: Implemented programmatic configuration.
Date Tue, 02 Feb 2016 17:17:56 GMT
http://git-wip-us.apache.org/repos/asf/ignite/blob/ee20f1d9/modules/platforms/dotnet/Apache.Ignite.Core.Tests/Cache/CacheConfigurationTest.cs
----------------------------------------------------------------------
diff --git a/modules/platforms/dotnet/Apache.Ignite.Core.Tests/Cache/CacheConfigurationTest.cs b/modules/platforms/dotnet/Apache.Ignite.Core.Tests/Cache/CacheConfigurationTest.cs
new file mode 100644
index 0000000..2e6a8a1
--- /dev/null
+++ b/modules/platforms/dotnet/Apache.Ignite.Core.Tests/Cache/CacheConfigurationTest.cs
@@ -0,0 +1,538 @@
+/*
+ * 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 System;
+    using System.Collections.Generic;
+    using System.Linq;
+    using Apache.Ignite.Core.Binary;
+    using Apache.Ignite.Core.Cache.Configuration;
+    using Apache.Ignite.Core.Cache.Store;
+    using Apache.Ignite.Core.Common;
+    using Apache.Ignite.Core.Discovery.Tcp;
+    using Apache.Ignite.Core.Discovery.Tcp.Static;
+    using NUnit.Framework;
+
+    /// <summary>
+    /// Tests cache configuration propagation.
+    /// </summary>
+    public class CacheConfigurationTest
+    {
+        /** */
+        private IIgnite _ignite;
+
+        /** */
+        private const string CacheName = "cacheName";
+
+        /** */
+        private static int _factoryProp;
+
+
+        /// <summary>
+        /// Fixture set up.
+        /// </summary>
+        [TestFixtureSetUp]
+        public void FixtureSetUp()
+        {
+            var cfg = new IgniteConfiguration
+            {
+                CacheConfiguration = new List<CacheConfiguration>
+                {
+                    new CacheConfiguration(),
+                    GetCustomCacheConfiguration()
+                },
+                JvmClasspath = TestUtils.CreateTestClasspath(),
+                JvmOptions = TestUtils.TestJavaOptions(),
+                GridName = CacheName,
+                BinaryConfiguration = new BinaryConfiguration(typeof(Entity)),
+                DiscoverySpi = new TcpDiscoverySpi
+                {
+                    IpFinder = new TcpDiscoveryStaticIpFinder
+                    {
+                        Endpoints = new[] { "127.0.0.1:47500", "127.0.0.1:47501" }
+                    }
+                }
+            };
+
+            _ignite = Ignition.Start(cfg);
+        }
+
+        /// <summary>
+        /// Fixture tear down.
+        /// </summary>
+        [TestFixtureTearDown]
+        public void FixtureTearDown()
+        {
+            Ignition.StopAll(true);
+        }
+
+        /// <summary>
+        /// Tests the default configuration.
+        /// </summary>
+        [Test]
+        public void TestDefaultConfiguration()
+        {
+            AssertConfigIsDefault(new CacheConfiguration());
+
+            AssertConfigIsDefault(_ignite.GetCache<int, int>(null).GetConfiguration());
+
+            AssertConfigIsDefault(_ignite.GetConfiguration().CacheConfiguration.Single(c => c.Name == null));
+        }
+
+        /// <summary>
+        /// Tests the custom configuration.
+        /// </summary>
+        [Test]
+        public void TestCustomConfiguration()
+        {
+            AssertConfigsAreEqual(GetCustomCacheConfiguration(),
+                _ignite.GetCache<int, int>(CacheName).GetConfiguration());
+
+            AssertConfigsAreEqual(GetCustomCacheConfiguration(),
+                _ignite.GetConfiguration().CacheConfiguration.Single(c => c.Name == CacheName));
+        }
+
+        /// <summary>
+        /// Tests the create from configuration.
+        /// </summary>
+        [Test]
+        public void TestCreateFromConfiguration()
+        {
+            var cacheName = Guid.NewGuid().ToString();
+            var cfg = GetCustomCacheConfiguration(cacheName);
+
+            var cache = _ignite.CreateCache<int, Entity>(cfg);
+            AssertConfigsAreEqual(cfg, cache.GetConfiguration());
+
+            // Can't create existing cache
+            Assert.Throws<IgniteException>(() => _ignite.CreateCache<int, int>(cfg));
+            
+            // Check put-get
+            cache[1] = new Entity { Foo = 1 };
+            Assert.AreEqual(1, cache[1].Foo);
+        }
+
+        /// <summary>
+        /// Tests the get or create from configuration.
+        /// </summary>
+        [Test]
+        public void TestGetOrCreateFromConfiguration()
+        {
+            var cacheName = Guid.NewGuid().ToString();
+            var cfg = GetCustomCacheConfiguration(cacheName);
+
+            var cache = _ignite.GetOrCreateCache<int, Entity>(cfg);
+            AssertConfigsAreEqual(cfg, cache.GetConfiguration());
+
+            var cache2 = _ignite.GetOrCreateCache<int, Entity>(cfg);
+            AssertConfigsAreEqual(cfg, cache2.GetConfiguration());
+
+            // Check put-get
+            cache[1] = new Entity { Foo = 1 };
+            Assert.AreEqual(1, cache[1].Foo);
+        }
+
+        /// <summary>
+        /// Tests the cache store.
+        /// </summary>
+        [Test]
+        public void TestCacheStore()
+        {
+            _factoryProp = 0;
+
+            var factory = new CacheStoreFactoryTest {TestProperty = 15};
+
+            var cache = _ignite.CreateCache<int, int>(new CacheConfiguration("cacheWithStore")
+            {
+                CacheStoreFactory = factory
+            });
+
+            Assert.AreEqual(factory.TestProperty, _factoryProp);
+
+            var factory0 = cache.GetConfiguration().CacheStoreFactory as CacheStoreFactoryTest;
+
+            Assert.IsNotNull(factory0);
+            Assert.AreEqual(factory.TestProperty, factory0.TestProperty);
+        }
+
+        /// <summary>
+        /// Asserts the configuration is default.
+        /// </summary>
+        private static void AssertConfigIsDefault(CacheConfiguration cfg)
+        {
+            Assert.AreEqual(CacheConfiguration.DefaultBackups, cfg.Backups);
+            Assert.AreEqual(CacheConfiguration.DefaultAtomicityMode, cfg.AtomicityMode);
+            Assert.AreEqual(CacheConfiguration.DefaultCacheMode, cfg.CacheMode);
+            Assert.AreEqual(CacheConfiguration.DefaultCopyOnRead, cfg.CopyOnRead);
+            Assert.AreEqual(CacheConfiguration.DefaultStartSize, cfg.StartSize);
+            Assert.AreEqual(CacheConfiguration.DefaultEagerTtl, cfg.EagerTtl);
+            Assert.AreEqual(CacheConfiguration.DefaultEvictSynchronizedKeyBufferSize, cfg.EvictSynchronizedKeyBufferSize);
+            Assert.AreEqual(CacheConfiguration.DefaultEvictSynchronized, cfg.EvictSynchronized);
+            Assert.AreEqual(CacheConfiguration.DefaultEvictSynchronizedConcurrencyLevel, cfg.EvictSynchronizedConcurrencyLevel);
+            Assert.AreEqual(CacheConfiguration.DefaultEvictSynchronizedTimeout, cfg.EvictSynchronizedTimeout);
+            Assert.AreEqual(CacheConfiguration.DefaultInvalidate, cfg.Invalidate);
+            Assert.AreEqual(CacheConfiguration.DefaultKeepVinaryInStore, cfg.KeepBinaryInStore);
+            Assert.AreEqual(CacheConfiguration.DefaultLoadPreviousValue, cfg.LoadPreviousValue);
+            Assert.AreEqual(CacheConfiguration.DefaultLockTimeout, cfg.LockTimeout);
+            Assert.AreEqual(CacheConfiguration.DefaultLongQueryWarningTimeout, cfg.LongQueryWarningTimeout);
+            Assert.AreEqual(CacheConfiguration.DefaultMaxConcurrentAsyncOperations, cfg.MaxConcurrentAsyncOperations);
+            Assert.AreEqual(CacheConfiguration.DefaultMaxEvictionOverflowRatio, cfg.MaxEvictionOverflowRatio);
+            Assert.AreEqual(CacheConfiguration.DefaultMemoryMode, cfg.MemoryMode);
+            Assert.AreEqual(CacheConfiguration.DefaultOffHeapMaxMemory, cfg.OffHeapMaxMemory);
+            Assert.AreEqual(CacheConfiguration.DefaultReadFromBackup, cfg.ReadFromBackup);
+            Assert.AreEqual(CacheConfiguration.DefaultRebalanceBatchSize, cfg.RebalanceBatchSize);
+            Assert.AreEqual(CacheConfiguration.DefaultRebalanceMode, cfg.RebalanceMode);
+            Assert.AreEqual(CacheConfiguration.DefaultRebalanceThrottle, cfg.RebalanceThrottle);
+            Assert.AreEqual(CacheConfiguration.DefaultRebalanceTimeout, cfg.RebalanceTimeout);
+            Assert.AreEqual(CacheConfiguration.DefaultSqlOnheapRowCacheSize, cfg.SqlOnheapRowCacheSize);
+            Assert.AreEqual(CacheConfiguration.DefaultStartSize, cfg.StartSize);
+            Assert.AreEqual(CacheConfiguration.DefaultStartSize, cfg.StartSize);
+            Assert.AreEqual(CacheConfiguration.DefaultEnableSwap, cfg.EnableSwap);
+            Assert.AreEqual(CacheConfiguration.DefaultWriteBehindBatchSize, cfg.WriteBehindBatchSize);
+            Assert.AreEqual(CacheConfiguration.DefaultWriteBehindEnabled, cfg.WriteBehindEnabled);
+            Assert.AreEqual(CacheConfiguration.DefaultWriteBehindFlushFrequency, cfg.WriteBehindFlushFrequency);
+            Assert.AreEqual(CacheConfiguration.DefaultWriteBehindFlushSize, cfg.WriteBehindFlushSize);
+        }
+
+        /// <summary>
+        /// Asserts that two configurations have the same properties.
+        /// </summary>
+        private static void AssertConfigsAreEqual(CacheConfiguration x, CacheConfiguration y)
+        {
+            Assert.AreEqual(x.Backups, y.Backups);
+            Assert.AreEqual(x.AtomicityMode, y.AtomicityMode);
+            Assert.AreEqual(x.CacheMode, y.CacheMode);
+            Assert.AreEqual(x.CopyOnRead, y.CopyOnRead);
+            Assert.AreEqual(x.StartSize, y.StartSize);
+            Assert.AreEqual(x.EagerTtl, y.EagerTtl);
+            Assert.AreEqual(x.EvictSynchronizedKeyBufferSize, y.EvictSynchronizedKeyBufferSize);
+            Assert.AreEqual(x.EvictSynchronized, y.EvictSynchronized);
+            Assert.AreEqual(x.EvictSynchronizedConcurrencyLevel, y.EvictSynchronizedConcurrencyLevel);
+            Assert.AreEqual(x.EvictSynchronizedTimeout, y.EvictSynchronizedTimeout);
+            Assert.AreEqual(x.Invalidate, y.Invalidate);
+            Assert.AreEqual(x.KeepBinaryInStore, y.KeepBinaryInStore);
+            Assert.AreEqual(x.LoadPreviousValue, y.LoadPreviousValue);
+            Assert.AreEqual(x.LockTimeout, y.LockTimeout);
+            Assert.AreEqual(x.LongQueryWarningTimeout, y.LongQueryWarningTimeout);
+            Assert.AreEqual(x.MaxConcurrentAsyncOperations, y.MaxConcurrentAsyncOperations);
+            Assert.AreEqual(x.MaxEvictionOverflowRatio, y.MaxEvictionOverflowRatio);
+            Assert.AreEqual(x.MemoryMode, y.MemoryMode);
+            Assert.AreEqual(x.OffHeapMaxMemory, y.OffHeapMaxMemory);
+            Assert.AreEqual(x.ReadFromBackup, y.ReadFromBackup);
+            Assert.AreEqual(x.RebalanceBatchSize, y.RebalanceBatchSize);
+            Assert.AreEqual(x.RebalanceMode, y.RebalanceMode);
+            Assert.AreEqual(x.RebalanceThrottle, y.RebalanceThrottle);
+            Assert.AreEqual(x.RebalanceTimeout, y.RebalanceTimeout);
+            Assert.AreEqual(x.SqlOnheapRowCacheSize, y.SqlOnheapRowCacheSize);
+            Assert.AreEqual(x.StartSize, y.StartSize);
+            Assert.AreEqual(x.StartSize, y.StartSize);
+            Assert.AreEqual(x.EnableSwap, y.EnableSwap);
+            Assert.AreEqual(x.WriteBehindBatchSize, y.WriteBehindBatchSize);
+            Assert.AreEqual(x.WriteBehindEnabled, y.WriteBehindEnabled);
+            Assert.AreEqual(x.WriteBehindFlushFrequency, y.WriteBehindFlushFrequency);
+            Assert.AreEqual(x.WriteBehindFlushSize, y.WriteBehindFlushSize);
+
+            AssertConfigsAreEqual(x.QueryEntities, y.QueryEntities);
+        }
+
+        /// <summary>
+        /// Asserts that two configurations have the same properties.
+        /// </summary>
+        private static void AssertConfigsAreEqual(ICollection<QueryEntity> x, ICollection<QueryEntity> y)
+        {
+            if (x == null)
+            {
+                Assert.IsNull(y);
+                return;
+            }
+
+            Assert.AreEqual(x.Count, y.Count);
+
+            for (var i = 0; i < x.Count; i++)
+                AssertConfigsAreEqual(x.ElementAt(i), y.ElementAt(i));
+        }
+
+        /// <summary>
+        /// Asserts that two configurations have the same properties.
+        /// </summary>
+        private static void AssertConfigsAreEqual(QueryEntity x, QueryEntity y)
+        {
+            Assert.IsNotNull(x);
+            Assert.IsNotNull(y);
+
+            Assert.AreEqual(x.KeyTypeName, y.KeyTypeName);
+            Assert.AreEqual(x.ValueTypeName, y.ValueTypeName);
+
+            AssertConfigsAreEqual(x.Fields, y.Fields);
+            AssertConfigsAreEqual(x.Aliases, y.Aliases);
+
+            AssertConfigsAreEqual(x.Indexes, y.Indexes);
+        }
+
+        /// <summary>
+        /// Asserts that two configurations have the same properties.
+        /// </summary>
+        private static void AssertConfigsAreEqual(ICollection<QueryIndex> x, ICollection<QueryIndex> y)
+        {
+            if (x == null)
+            {
+                Assert.IsNull(y);
+                return;
+            }
+
+            Assert.AreEqual(x.Count, y.Count);
+
+            for (var i = 0; i < x.Count; i++)
+                AssertConfigsAreEqual(x.ElementAt(i), y.ElementAt(i));
+        }
+
+        /// <summary>
+        /// Asserts that two configurations have the same properties.
+        /// </summary>
+        private static void AssertConfigsAreEqual(ICollection<QueryField> x, ICollection<QueryField> y)
+        {
+            if (x == null)
+            {
+                Assert.IsNull(y);
+                return;
+            }
+
+            Assert.AreEqual(x.Count, y.Count);
+
+            for (var i = 0; i < x.Count; i++)
+                AssertConfigsAreEqual(x.ElementAt(i), y.ElementAt(i));
+        }
+
+        /// <summary>
+        /// Asserts that two configurations have the same properties.
+        /// </summary>
+        private static void AssertConfigsAreEqual(ICollection<QueryAlias> x, ICollection<QueryAlias> y)
+        {
+            if (x == null)
+            {
+                Assert.IsNull(y);
+                return;
+            }
+
+            Assert.AreEqual(x.Count, y.Count);
+
+            for (var i = 0; i < x.Count; i++)
+                AssertConfigsAreEqual(x.ElementAt(i), y.ElementAt(i));
+        }
+
+        /// <summary>
+        /// Asserts that two configurations have the same properties.
+        /// </summary>
+        private static void AssertConfigsAreEqual(ICollection<QueryIndexField> x, ICollection<QueryIndexField> y)
+        {
+            if (x == null)
+            {
+                Assert.IsNull(y);
+                return;
+            }
+
+            Assert.AreEqual(x.Count, y.Count);
+
+            for (var i = 0; i < x.Count; i++)
+                AssertConfigsAreEqual(x.ElementAt(i), y.ElementAt(i));
+        }
+
+        /// <summary>
+        /// Asserts that two configurations have the same properties.
+        /// </summary>
+        private static void AssertConfigsAreEqual(QueryIndex x, QueryIndex y)
+        {
+            Assert.IsNotNull(x);
+            Assert.IsNotNull(y);
+
+            Assert.AreEqual(x.Name, y.Name);
+            Assert.AreEqual(x.IndexType, y.IndexType);
+
+            AssertConfigsAreEqual(x.Fields, y.Fields);
+        }
+
+        /// <summary>
+        /// Asserts that two configurations have the same properties.
+        /// </summary>
+        private static void AssertConfigsAreEqual(QueryField x, QueryField y)
+        {
+            Assert.IsNotNull(x);
+            Assert.IsNotNull(y);
+
+            Assert.AreEqual(x.Name, y.Name);
+            Assert.AreEqual(x.FieldTypeName, y.FieldTypeName);
+        }
+
+        /// <summary>
+        /// Asserts that two configurations have the same properties.
+        /// </summary>
+        private static void AssertConfigsAreEqual(QueryAlias x, QueryAlias y)
+        {
+            Assert.IsNotNull(x);
+            Assert.IsNotNull(y);
+
+            Assert.AreEqual(x.FullName, y.FullName);
+            Assert.AreEqual(x.Alias, y.Alias);
+        }
+
+        /// <summary>
+        /// Asserts that two configurations have the same properties.
+        /// </summary>
+        private static void AssertConfigsAreEqual(QueryIndexField x, QueryIndexField y)
+        {
+            Assert.IsNotNull(x);
+            Assert.IsNotNull(y);
+
+            Assert.AreEqual(x.Name, y.Name);
+            Assert.AreEqual(x.IsDescending, y.IsDescending);
+        }
+
+        /// <summary>
+        /// Gets the custom cache configuration.
+        /// </summary>
+        private static CacheConfiguration GetCustomCacheConfiguration(string name = null)
+        {
+            return new CacheConfiguration
+            {
+                Name = name ?? CacheName,
+                OffHeapMaxMemory = 1,
+                StartSize = 2,
+                MaxConcurrentAsyncOperations = 3,
+                WriteBehindFlushThreadCount = 4,
+                LongQueryWarningTimeout = TimeSpan.FromSeconds(5),
+                LoadPreviousValue = true,
+                EvictSynchronizedKeyBufferSize = 6,
+                CopyOnRead = true,
+                WriteBehindFlushFrequency = TimeSpan.FromSeconds(6),
+                WriteBehindFlushSize = 7,
+                EvictSynchronized = true,
+                AtomicWriteOrderMode = CacheAtomicWriteOrderMode.Primary,
+                AtomicityMode = CacheAtomicityMode.Atomic,
+                Backups = 8,
+                CacheMode = CacheMode.Partitioned,
+                EagerTtl = true,
+                EnableSwap = true,
+                EvictSynchronizedConcurrencyLevel = 9,
+                EvictSynchronizedTimeout = TimeSpan.FromSeconds(10),
+                Invalidate = true,
+                KeepBinaryInStore = true,
+                LockTimeout = TimeSpan.FromSeconds(11),
+                MaxEvictionOverflowRatio = 0.5f,
+                MemoryMode = CacheMemoryMode.OnheapTiered,
+                ReadFromBackup = true,
+                RebalanceBatchSize = 12,
+                RebalanceDelay = TimeSpan.FromSeconds(13),
+                RebalanceMode = CacheRebalanceMode.Async,
+                RebalanceThrottle = TimeSpan.FromSeconds(15),
+                RebalanceTimeout = TimeSpan.FromSeconds(16),
+                SqlEscapeAll = true,
+                SqlOnheapRowCacheSize = 17,
+                WriteBehindBatchSize = 18,
+                WriteBehindEnabled = false,
+                WriteSynchronizationMode = CacheWriteSynchronizationMode.PrimarySync,
+                QueryEntities = new[]
+                {
+                    new QueryEntity
+                    {
+                        KeyTypeName = "Integer",
+                        ValueTypeName = "java.lang.String",
+                        Fields = new[]
+                        {
+                            new QueryField("length", typeof(int)), 
+                            new QueryField("name", typeof(string)), 
+                            new QueryField("location", typeof(string)),
+                        },
+                        Aliases = new [] {new QueryAlias("length", "len") },
+                        Indexes = new[]
+                        {
+                            new QueryIndex("name") {Name = "index1" },
+                            new QueryIndex(new QueryIndexField("location", true))
+                            {
+                                Name= "index2",
+                                IndexType = QueryIndexType.FullText
+                            }
+                        }
+                    }
+                }
+            };
+        }
+
+        /// <summary>
+        /// Test factory.
+        /// </summary>
+        [Serializable]
+        private class CacheStoreFactoryTest : IFactory<ICacheStore>
+        {
+            /// <summary>
+            /// Gets or sets the test property.
+            /// </summary>
+            /// <value>
+            /// The test property.
+            /// </value>
+            public int TestProperty { get; set; }
+
+            /// <summary>
+            /// Creates an instance of the cache store.
+            /// </summary>
+            /// <returns>
+            /// New instance of the cache store.
+            /// </returns>
+            public ICacheStore CreateInstance()
+            {
+                _factoryProp = TestProperty;
+
+                return new CacheStoreTest();
+            }
+        }
+
+        /// <summary>
+        /// Test store.
+        /// </summary>
+        private class CacheStoreTest : CacheStoreAdapter
+        {
+            /** <inheritdoc /> */
+            public override object Load(object key)
+            {
+                return null;
+            }
+
+            /** <inheritdoc /> */
+            public override void Write(object key, object val)
+            {
+                // No-op.
+            }
+
+            /** <inheritdoc /> */
+            public override void Delete(object key)
+            {
+                // No-op.
+            }
+        }
+
+        /// <summary>
+        /// Test entity.
+        /// </summary>
+        private class Entity
+        {
+            /// <summary>
+            /// Gets or sets the foo.
+            /// </summary>
+            public int Foo { get; set; }
+        }
+    }
+}

http://git-wip-us.apache.org/repos/asf/ignite/blob/ee20f1d9/modules/platforms/dotnet/Apache.Ignite.Core.Tests/Cache/CacheDynamicStartTest.cs
----------------------------------------------------------------------
diff --git a/modules/platforms/dotnet/Apache.Ignite.Core.Tests/Cache/CacheDynamicStartTest.cs b/modules/platforms/dotnet/Apache.Ignite.Core.Tests/Cache/CacheDynamicStartTest.cs
index 63443b7..7c18a34 100644
--- a/modules/platforms/dotnet/Apache.Ignite.Core.Tests/Cache/CacheDynamicStartTest.cs
+++ b/modules/platforms/dotnet/Apache.Ignite.Core.Tests/Cache/CacheDynamicStartTest.cs
@@ -79,9 +79,9 @@ namespace Apache.Ignite.Core.Tests.Cache
         /// <param name="name">Grid name.</param>
         /// <param name="springCfg">Spring configuration.</param>
         /// <returns>Configuration.</returns>
-        private static IgniteConfigurationEx CreateConfiguration(string name, string springCfg)
+        private static IgniteConfiguration CreateConfiguration(string name, string springCfg)
         {
-            IgniteConfigurationEx cfg = new IgniteConfigurationEx();
+            var cfg = new IgniteConfiguration();
 
             BinaryConfiguration portCfg = new BinaryConfiguration();
 

http://git-wip-us.apache.org/repos/asf/ignite/blob/ee20f1d9/modules/platforms/dotnet/Apache.Ignite.Core.Tests/Cache/CacheTestAsyncWrapper.cs
----------------------------------------------------------------------
diff --git a/modules/platforms/dotnet/Apache.Ignite.Core.Tests/Cache/CacheTestAsyncWrapper.cs b/modules/platforms/dotnet/Apache.Ignite.Core.Tests/Cache/CacheTestAsyncWrapper.cs
index 33c9f11..09e57dc 100644
--- a/modules/platforms/dotnet/Apache.Ignite.Core.Tests/Cache/CacheTestAsyncWrapper.cs
+++ b/modules/platforms/dotnet/Apache.Ignite.Core.Tests/Cache/CacheTestAsyncWrapper.cs
@@ -23,6 +23,7 @@ namespace Apache.Ignite.Core.Tests.Cache
     using System.Diagnostics;
     using System.Threading.Tasks;
     using Apache.Ignite.Core.Cache;
+    using Apache.Ignite.Core.Cache.Configuration;
     using Apache.Ignite.Core.Cache.Expiry;
     using Apache.Ignite.Core.Cache.Query;
     using Apache.Ignite.Core.Cache.Query.Continuous;
@@ -58,6 +59,12 @@ namespace Apache.Ignite.Core.Tests.Cache
         }
 
         /** <inheritDoc /> */
+        public CacheConfiguration GetConfiguration()
+        {
+            return _cache.GetConfiguration();
+        }
+
+        /** <inheritDoc /> */
         public bool IsEmpty()
         {
             return _cache.IsEmpty();

http://git-wip-us.apache.org/repos/asf/ignite/blob/ee20f1d9/modules/platforms/dotnet/Apache.Ignite.Core.Tests/Cache/Query/CacheQueriesCodeConfigurationTest.cs
----------------------------------------------------------------------
diff --git a/modules/platforms/dotnet/Apache.Ignite.Core.Tests/Cache/Query/CacheQueriesCodeConfigurationTest.cs b/modules/platforms/dotnet/Apache.Ignite.Core.Tests/Cache/Query/CacheQueriesCodeConfigurationTest.cs
new file mode 100644
index 0000000..a969127
--- /dev/null
+++ b/modules/platforms/dotnet/Apache.Ignite.Core.Tests/Cache/Query/CacheQueriesCodeConfigurationTest.cs
@@ -0,0 +1,295 @@
+/*
+ * 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.
+ */
+
+// ReSharper disable MemberCanBePrivate.Local
+// ReSharper disable UnusedAutoPropertyAccessor.Local
+// ReSharper disable UnusedMember.Local
+namespace Apache.Ignite.Core.Tests.Cache.Query
+{
+    using System;
+    using System.Linq;
+    using Apache.Ignite.Core.Binary;
+    using Apache.Ignite.Core.Cache.Configuration;
+    using Apache.Ignite.Core.Cache.Query;
+    using NUnit.Framework;
+
+    /// <summary>
+    /// Tests queries with in-code configuration.
+    /// </summary>
+    public class CacheQueriesCodeConfigurationTest
+    {
+        const string CacheName = "personCache";
+
+        /// <summary>
+        /// Tests the SQL query.
+        /// </summary>
+        [Test]
+        public void TestQueryEntityConfiguration()
+        {
+            var cfg = new IgniteConfiguration
+            {
+                JvmOptions = TestUtils.TestJavaOptions(),
+                JvmClasspath = TestUtils.CreateTestClasspath(),
+                BinaryConfiguration = new BinaryConfiguration(typeof (QueryPerson)),
+                CacheConfiguration = new[]
+                {
+                    new CacheConfiguration(CacheName, new QueryEntity(typeof (int), typeof (QueryPerson))
+                    {
+                        Fields = new[]
+                        {
+                            new QueryField("Name", typeof (string)),
+                            new QueryField("Age", typeof (int))
+                        },
+                        Indexes = new[]
+                        {
+                            new QueryIndex(false, QueryIndexType.FullText, "Name"), new QueryIndex("Age")
+                        }
+                    })
+                }
+            };
+
+            using (var ignite = Ignition.Start(cfg))
+            {
+                var cache = ignite.GetCache<int, QueryPerson>(CacheName);
+
+                Assert.IsNotNull(cache);
+
+                cache[1] = new QueryPerson("Arnold", 10);
+                cache[2] = new QueryPerson("John", 20);
+
+                using (var cursor = cache.Query(new SqlQuery(typeof (QueryPerson), "age > 10")))
+                {
+                    Assert.AreEqual(2, cursor.GetAll().Single().Key);
+                }
+
+                using (var cursor = cache.Query(new TextQuery(typeof (QueryPerson), "Ar*")))
+                {
+                    Assert.AreEqual(1, cursor.GetAll().Single().Key);
+                }
+            }
+        }
+
+        /// <summary>
+        /// Tests the attribute configuration.
+        /// </summary>
+        [Test]
+        public void TestAttributeConfiguration()
+        {
+            // ReSharper disable once ObjectCreationAsStatement
+            Assert.Throws<InvalidOperationException>(() => new QueryEntity(typeof (RecursiveQuery)));
+
+            var qe = new QueryEntity {ValueType = typeof(AttributeTest) };
+
+            Assert.AreEqual(typeof(AttributeTest), qe.ValueType);
+
+            var fields = qe.Fields.ToArray();
+
+            CollectionAssert.AreEquivalent(new[]
+            {
+                "SqlField", "IndexedField1", "FullTextField", "Inner", "Inner.Foo",
+                "GroupIndex1", "GroupIndex2", "GroupIndex3"
+            }, fields.Select(x => x.Name));
+
+            var idx = qe.Indexes.ToArray();
+
+            Assert.AreEqual(QueryIndexType.Sorted, idx[0].IndexType);
+            Assert.AreEqual(QueryIndexType.Sorted, idx[1].IndexType);
+            Assert.AreEqual(QueryIndexType.Sorted, idx[2].IndexType);
+            Assert.AreEqual(QueryIndexType.FullText, idx[3].IndexType);
+
+            CollectionAssert.AreEquivalent(new[] {"GroupIndex1", "GroupIndex2"}, idx[0].Fields.Select(f => f.Name));
+            CollectionAssert.AreEquivalent(new[] {"GroupIndex1", "GroupIndex3"}, idx[1].Fields.Select(f => f.Name));
+            CollectionAssert.AreEquivalent(new[] {"IndexedField1"}, idx[2].Fields.Select(f => f.Name));
+            CollectionAssert.AreEquivalent(new[] {"FullTextField"}, idx[3].Fields.Select(f => f.Name));
+        }
+
+        /// <summary>
+        /// Tests the attribute configuration query.
+        /// </summary>
+        [Test]
+        public void TestAttributeConfigurationQuery()
+        {
+            var cfg = new IgniteConfiguration
+            {
+                JvmOptions = TestUtils.TestJavaOptions(),
+                JvmClasspath = TestUtils.CreateTestClasspath(),
+                BinaryConfiguration = new BinaryConfiguration(
+                    typeof (AttributeQueryPerson), typeof (AttributeQueryAddress)),
+            };
+
+            using (var ignite = Ignition.Start(cfg))
+            {
+                var cache = ignite.GetOrCreateCache<int, AttributeQueryPerson>(new CacheConfiguration(CacheName,
+                        typeof (AttributeQueryPerson)));
+
+                Assert.IsNotNull(cache);
+
+                cache[1] = new AttributeQueryPerson("Arnold", 10)
+                {
+                    Address = new AttributeQueryAddress {Country = "USA", Street = "Pine Tree road"}
+                };
+
+                cache[2] = new AttributeQueryPerson("John", 20);
+
+                using (var cursor = cache.Query(new SqlQuery(typeof(AttributeQueryPerson), "age > ?", 10)))
+                {
+                    Assert.AreEqual(2, cursor.GetAll().Single().Key);
+                }
+
+                using (var cursor = cache.Query(new SqlQuery(typeof(AttributeQueryPerson), "Country = ?", "USA")))
+                {
+                    Assert.AreEqual(1, cursor.GetAll().Single().Key);
+                }
+
+                using (var cursor = cache.Query(new TextQuery(typeof(AttributeQueryPerson), "Ar*")))
+                {
+                    Assert.AreEqual(1, cursor.GetAll().Single().Key);
+                }
+
+                using (var cursor = cache.Query(new TextQuery(typeof(AttributeQueryPerson), "Pin*")))
+                {
+                    Assert.AreEqual(1, cursor.GetAll().Single().Key);
+                }
+            }
+        }
+
+        /// <summary>
+        /// Test person.
+        /// </summary>
+        private class AttributeQueryPerson
+        {
+            /// <summary>
+            /// Initializes a new instance of the <see cref="AttributeQueryPerson"/> class.
+            /// </summary>
+            /// <param name="name">The name.</param>
+            /// <param name="age">The age.</param>
+            public AttributeQueryPerson(string name, int age)
+            {
+                Name = name;
+                Age = age;
+            }
+
+            /// <summary>
+            /// Gets or sets the name.
+            /// </summary>
+            /// <value>
+            /// The name.
+            /// </value>
+            [QueryTextField]
+            public string Name { get; set; }
+
+            /// <summary>
+            /// Gets or sets the age.
+            /// </summary>
+            /// <value>
+            /// The age.
+            /// </value>
+            [QuerySqlField]
+            public int Age { get; set; }
+
+            /// <summary>
+            /// Gets or sets the address.
+            /// </summary>
+            /// <value>
+            /// The address.
+            /// </value>
+            [QuerySqlField]
+            public AttributeQueryAddress Address { get; set; }
+        }
+
+        /// <summary>
+        /// Address.
+        /// </summary>
+        private class AttributeQueryAddress
+        {
+            /// <summary>
+            /// Gets or sets the country.
+            /// </summary>
+            /// <value>
+            /// The country.
+            /// </value>
+            [QuerySqlField]
+            public string Country { get; set; }
+
+            /// <summary>
+            /// Gets or sets the street.
+            /// </summary>
+            /// <value>
+            /// The street.
+            /// </value>
+            [QueryTextField]
+            public string Street { get; set; }
+        }
+
+        /// <summary>
+        /// Query.
+        /// </summary>
+        private class RecursiveQuery
+        {
+            /// <summary>
+            /// Gets or sets the inner.
+            /// </summary>
+            /// <value>
+            /// The inner.
+            /// </value>
+            [QuerySqlField]
+            public RecursiveQuery Inner { get; set; }
+        }
+
+        /// <summary>
+        /// Attribute test class.
+        /// </summary>
+        private class AttributeTest
+        {
+            [QuerySqlField]
+            public double SqlField { get; set; }
+
+            [QuerySqlField(IsIndexed = true, Name = "IndexedField1")]
+            public int IndexedField { get; set; }
+
+            [QueryTextField]
+            public string FullTextField { get; set; }
+
+            [QuerySqlField]
+            public AttributeTestInner Inner { get; set; }
+
+            [QuerySqlField(IsIndexed = true, IndexGroups = new[] {"group1", "group2"})]
+            public string GroupIndex1 { get; set; }
+
+            [QuerySqlField(IsIndexed = true, IndexGroups = new[] {"group1"})]
+            public string GroupIndex2 { get; set; }
+
+            [QuerySqlField(IsIndexed = true, IndexGroups = new[] {"group2"})]
+            public string GroupIndex3 { get; set; }
+        }
+
+        /// <summary>
+        /// Inner class.
+        /// </summary>
+        private class AttributeTestInner
+        {
+            /// <summary>
+            /// Gets or sets the foo.
+            /// </summary>
+            /// <value>
+            /// The foo.
+            /// </value>
+            [QuerySqlField]
+            public string Foo { get; set; }
+        }
+    }
+}

http://git-wip-us.apache.org/repos/asf/ignite/blob/ee20f1d9/modules/platforms/dotnet/Apache.Ignite.Core.Tests/Cache/Query/CacheQueriesTest.cs
----------------------------------------------------------------------
diff --git a/modules/platforms/dotnet/Apache.Ignite.Core.Tests/Cache/Query/CacheQueriesTest.cs b/modules/platforms/dotnet/Apache.Ignite.Core.Tests/Cache/Query/CacheQueriesTest.cs
index 08a98f6..8020649 100644
--- a/modules/platforms/dotnet/Apache.Ignite.Core.Tests/Cache/Query/CacheQueriesTest.cs
+++ b/modules/platforms/dotnet/Apache.Ignite.Core.Tests/Cache/Query/CacheQueriesTest.cs
@@ -57,7 +57,7 @@ namespace Apache.Ignite.Core.Tests.Cache.Query
             TestUtils.JvmDebug = true;
             TestUtils.KillProcesses();
 
-            IgniteConfigurationEx cfg = new IgniteConfigurationEx
+            IgniteConfiguration cfg = new IgniteConfiguration
             {
                 BinaryConfiguration = new BinaryConfiguration
                 {

http://git-wip-us.apache.org/repos/asf/ignite/blob/ee20f1d9/modules/platforms/dotnet/Apache.Ignite.Core.Tests/Cache/Query/Continuous/ContinuousQueryAbstractTest.cs
----------------------------------------------------------------------
diff --git a/modules/platforms/dotnet/Apache.Ignite.Core.Tests/Cache/Query/Continuous/ContinuousQueryAbstractTest.cs b/modules/platforms/dotnet/Apache.Ignite.Core.Tests/Cache/Query/Continuous/ContinuousQueryAbstractTest.cs
index bdca918..0036abd 100644
--- a/modules/platforms/dotnet/Apache.Ignite.Core.Tests/Cache/Query/Continuous/ContinuousQueryAbstractTest.cs
+++ b/modules/platforms/dotnet/Apache.Ignite.Core.Tests/Cache/Query/Continuous/ContinuousQueryAbstractTest.cs
@@ -95,7 +95,7 @@ namespace Apache.Ignite.Core.Tests.Cache.Query.Continuous
             GC.Collect();
             TestUtils.JvmDebug = true;
 
-            IgniteConfigurationEx cfg = new IgniteConfigurationEx();
+            IgniteConfiguration cfg = new IgniteConfiguration();
 
             BinaryConfiguration portCfg = new BinaryConfiguration();
 

http://git-wip-us.apache.org/repos/asf/ignite/blob/ee20f1d9/modules/platforms/dotnet/Apache.Ignite.Core.Tests/Cache/Store/CacheStoreSessionTest.cs
----------------------------------------------------------------------
diff --git a/modules/platforms/dotnet/Apache.Ignite.Core.Tests/Cache/Store/CacheStoreSessionTest.cs b/modules/platforms/dotnet/Apache.Ignite.Core.Tests/Cache/Store/CacheStoreSessionTest.cs
index 137215e..5cc0849 100644
--- a/modules/platforms/dotnet/Apache.Ignite.Core.Tests/Cache/Store/CacheStoreSessionTest.cs
+++ b/modules/platforms/dotnet/Apache.Ignite.Core.Tests/Cache/Store/CacheStoreSessionTest.cs
@@ -55,7 +55,7 @@ namespace Apache.Ignite.Core.Tests.Cache.Store
 
             TestUtils.JvmDebug = true;
 
-            IgniteConfigurationEx cfg = new IgniteConfigurationEx
+            IgniteConfiguration cfg = new IgniteConfiguration
             {
                 GridName = IgniteName,
                 JvmClasspath = TestUtils.CreateTestClasspath(),

http://git-wip-us.apache.org/repos/asf/ignite/blob/ee20f1d9/modules/platforms/dotnet/Apache.Ignite.Core.Tests/Cache/Store/CacheStoreTest.cs
----------------------------------------------------------------------
diff --git a/modules/platforms/dotnet/Apache.Ignite.Core.Tests/Cache/Store/CacheStoreTest.cs b/modules/platforms/dotnet/Apache.Ignite.Core.Tests/Cache/Store/CacheStoreTest.cs
index 1270138..b48cdc9 100644
--- a/modules/platforms/dotnet/Apache.Ignite.Core.Tests/Cache/Store/CacheStoreTest.cs
+++ b/modules/platforms/dotnet/Apache.Ignite.Core.Tests/Cache/Store/CacheStoreTest.cs
@@ -23,7 +23,6 @@ namespace Apache.Ignite.Core.Tests.Cache.Store
     using Apache.Ignite.Core.Binary;
     using Apache.Ignite.Core.Cache;
     using Apache.Ignite.Core.Cache.Store;
-    using Apache.Ignite.Core.Impl;
     using NUnit.Framework;
 
     /// <summary>
@@ -137,24 +136,18 @@ namespace Apache.Ignite.Core.Tests.Cache.Store
         [TestFixtureSetUp]
         public void BeforeTests()
         {
-            //TestUtils.JVM_DEBUG = true;
-
             TestUtils.KillProcesses();
 
             TestUtils.JvmDebug = true;
 
-            IgniteConfigurationEx cfg = new IgniteConfigurationEx();
-
-            cfg.GridName = GridName;
-            cfg.JvmClasspath = TestUtils.CreateTestClasspath();
-            cfg.JvmOptions = TestUtils.TestJavaOptions();
-            cfg.SpringConfigUrl = "config\\native-client-test-cache-store.xml";
-
-            BinaryConfiguration portCfg = new BinaryConfiguration();
-
-            portCfg.Types = new List<string> { typeof(Key).FullName, typeof(Value).FullName };
-
-            cfg.BinaryConfiguration = portCfg;
+            var cfg = new IgniteConfiguration
+            {
+                GridName = GridName,
+                JvmClasspath = TestUtils.CreateTestClasspath(),
+                JvmOptions = TestUtils.TestJavaOptions(),
+                SpringConfigUrl = "config\\native-client-test-cache-store.xml",
+                BinaryConfiguration = new BinaryConfiguration(typeof (Key), typeof (Value))
+            };
 
             Ignition.Start(cfg);
         }

http://git-wip-us.apache.org/repos/asf/ignite/blob/ee20f1d9/modules/platforms/dotnet/Apache.Ignite.Core.Tests/Dataload/DataStreamerTest.cs
----------------------------------------------------------------------
diff --git a/modules/platforms/dotnet/Apache.Ignite.Core.Tests/Dataload/DataStreamerTest.cs b/modules/platforms/dotnet/Apache.Ignite.Core.Tests/Dataload/DataStreamerTest.cs
index 20ae629..f5a04c1 100644
--- a/modules/platforms/dotnet/Apache.Ignite.Core.Tests/Dataload/DataStreamerTest.cs
+++ b/modules/platforms/dotnet/Apache.Ignite.Core.Tests/Dataload/DataStreamerTest.cs
@@ -461,9 +461,9 @@ namespace Apache.Ignite.Core.Tests.Dataload
         /// Gets the Ignite configuration.
         /// </summary>
         /// <param name="gridName">Grid name.</param>
-        private static IgniteConfigurationEx GetIgniteConfiguration(string gridName)
+        private static IgniteConfiguration GetIgniteConfiguration(string gridName)
         {
-            return new IgniteConfigurationEx
+            return new IgniteConfiguration
             {
                 GridName = gridName,
                 SpringConfigUrl = "config\\native-client-test-cache.xml",

http://git-wip-us.apache.org/repos/asf/ignite/blob/ee20f1d9/modules/platforms/dotnet/Apache.Ignite.Core.Tests/ExceptionsTest.cs
----------------------------------------------------------------------
diff --git a/modules/platforms/dotnet/Apache.Ignite.Core.Tests/ExceptionsTest.cs b/modules/platforms/dotnet/Apache.Ignite.Core.Tests/ExceptionsTest.cs
index 79297da..50ecfac 100644
--- a/modules/platforms/dotnet/Apache.Ignite.Core.Tests/ExceptionsTest.cs
+++ b/modules/platforms/dotnet/Apache.Ignite.Core.Tests/ExceptionsTest.cs
@@ -285,7 +285,7 @@ namespace Apache.Ignite.Core.Tests
         /// </summary>
         private static IIgnite StartGrid(string gridName = null)
         {
-            return Ignition.Start(new IgniteConfigurationEx
+            return Ignition.Start(new IgniteConfiguration
             {
                 SpringConfigUrl = "config\\native-client-test-cache.xml",
                 JvmOptions = TestUtils.TestJavaOptions(),

http://git-wip-us.apache.org/repos/asf/ignite/blob/ee20f1d9/modules/platforms/dotnet/Apache.Ignite.Core.Tests/IgniteConfigurationTest.cs
----------------------------------------------------------------------
diff --git a/modules/platforms/dotnet/Apache.Ignite.Core.Tests/IgniteConfigurationTest.cs b/modules/platforms/dotnet/Apache.Ignite.Core.Tests/IgniteConfigurationTest.cs
new file mode 100644
index 0000000..15f5804
--- /dev/null
+++ b/modules/platforms/dotnet/Apache.Ignite.Core.Tests/IgniteConfigurationTest.cs
@@ -0,0 +1,367 @@
+/*
+ * 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.
+ */
+
+#pragma warning disable 618  // deprecated SpringConfigUrl
+namespace Apache.Ignite.Core.Tests
+{
+    using System;
+    using System.ComponentModel;
+    using System.IO;
+    using System.Linq;
+    using Apache.Ignite.Core.Cache.Configuration;
+    using Apache.Ignite.Core.Common;
+    using Apache.Ignite.Core.Discovery;
+    using Apache.Ignite.Core.Discovery.Tcp;
+    using Apache.Ignite.Core.Discovery.Tcp.Multicast;
+    using Apache.Ignite.Core.Discovery.Tcp.Static;
+    using Apache.Ignite.Core.Events;
+    using NUnit.Framework;
+
+    /// <summary>
+    /// Tests code-based configuration.
+    /// </summary>
+    public class IgniteConfigurationTest
+    {
+        /// <summary>
+        /// Fixture setup.
+        /// </summary>
+        [TestFixtureSetUp]
+        public void FixtureSetUp()
+        {
+            Ignition.StopAll(true);
+        }
+
+        /// <summary>
+        /// Tests the default configuration properties.
+        /// </summary>
+        [Test]
+        public void TestDefaultConfigurationProperties()
+        {
+            CheckDefaultProperties(new IgniteConfiguration());
+        }
+
+        /// <summary>
+        /// Tests the default value attributes.
+        /// </summary>
+        [Test]
+        public void TestDefaultValueAttributes()
+        {
+            CheckDefaultValueAttributes(new IgniteConfiguration());
+            CheckDefaultValueAttributes(new TcpDiscoverySpi());
+            CheckDefaultValueAttributes(new CacheConfiguration());
+            CheckDefaultValueAttributes(new TcpDiscoveryMulticastIpFinder());
+        }
+
+        /// <summary>
+        /// Tests all configuration properties.
+        /// </summary>
+        [Test]
+        public void TestAllConfigurationProperties()
+        {
+            var cfg = new IgniteConfiguration(GetCustomConfig());
+
+            using (var ignite = Ignition.Start(cfg))
+            {
+                var resCfg = ignite.GetConfiguration();
+
+                var disco = (TcpDiscoverySpi) cfg.DiscoverySpi;
+                var resDisco = (TcpDiscoverySpi) resCfg.DiscoverySpi;
+
+                Assert.AreEqual(disco.NetworkTimeout, resDisco.NetworkTimeout);
+                Assert.AreEqual(disco.AckTimeout, resDisco.AckTimeout);
+                Assert.AreEqual(disco.MaxAckTimeout, resDisco.MaxAckTimeout);
+                Assert.AreEqual(disco.SocketTimeout, resDisco.SocketTimeout);
+                Assert.AreEqual(disco.JoinTimeout, resDisco.JoinTimeout);
+
+                var ip = (TcpDiscoveryStaticIpFinder) disco.IpFinder;
+                var resIp = (TcpDiscoveryStaticIpFinder) resDisco.IpFinder;
+
+                // There can be extra IPv6 endpoints
+                Assert.AreEqual(ip.Endpoints, resIp.Endpoints.Take(2).Select(x => x.Trim('/')).ToArray());
+
+                Assert.AreEqual(cfg.GridName, resCfg.GridName);
+                Assert.AreEqual(cfg.IncludedEventTypes, resCfg.IncludedEventTypes);
+                Assert.AreEqual(cfg.MetricsExpireTime, resCfg.MetricsExpireTime);
+                Assert.AreEqual(cfg.MetricsHistorySize, resCfg.MetricsHistorySize);
+                Assert.AreEqual(cfg.MetricsLogFrequency, resCfg.MetricsLogFrequency);
+                Assert.AreEqual(cfg.MetricsUpdateFrequency, resCfg.MetricsUpdateFrequency);
+                Assert.AreEqual(cfg.NetworkSendRetryCount, resCfg.NetworkSendRetryCount);
+                Assert.AreEqual(cfg.NetworkTimeout, resCfg.NetworkTimeout);
+                Assert.AreEqual(cfg.NetworkSendRetryDelay, resCfg.NetworkSendRetryDelay);
+                Assert.AreEqual(cfg.WorkDirectory, resCfg.WorkDirectory);
+                Assert.AreEqual(cfg.JvmClasspath, resCfg.JvmClasspath);
+                Assert.AreEqual(cfg.JvmOptions, resCfg.JvmOptions);
+                Assert.IsTrue(File.Exists(resCfg.JvmDllPath));
+                Assert.AreEqual(cfg.Localhost, resCfg.Localhost);
+            }
+        }
+
+        /// <summary>
+        /// Tests the spring XML.
+        /// </summary>
+        [Test]
+        public void TestSpringXml()
+        {
+            // When Spring XML is used, all properties are ignored.
+            var cfg = GetCustomConfig();
+
+            cfg.SpringConfigUrl = "config\\marshaller-default.xml";
+
+            using (var ignite = Ignition.Start(cfg))
+            {
+                var resCfg = ignite.GetConfiguration();
+
+                CheckDefaultProperties(resCfg);
+            }
+        }
+
+        /// <summary>
+        /// Tests the client mode.
+        /// </summary>
+        [Test]
+        public void TestClientMode()
+        {
+            using (var ignite = Ignition.Start(new IgniteConfiguration
+            {
+                Localhost = "127.0.0.1",
+                DiscoverySpi = GetStaticDiscovery()
+            }))
+            using (var ignite2 = Ignition.Start(new IgniteConfiguration
+            {
+                Localhost = "127.0.0.1",
+                DiscoverySpi = GetStaticDiscovery(),
+                GridName = "client",
+                ClientMode = true
+            }))
+            {
+                const string cacheName = "cache";
+
+                ignite.CreateCache<int, int>(cacheName);
+
+                Assert.AreEqual(2, ignite2.GetCluster().GetNodes().Count);
+                Assert.AreEqual(1, ignite.GetCluster().ForCacheNodes(cacheName).GetNodes().Count);
+
+                Assert.AreEqual(false, ignite.GetConfiguration().ClientMode);
+                Assert.AreEqual(true, ignite2.GetConfiguration().ClientMode);
+            }
+        }
+
+        /// <summary>
+        /// Tests the default spi.
+        /// </summary>
+        [Test]
+        public void TestDefaultSpi()
+        {
+            var cfg = new IgniteConfiguration
+            {
+                DiscoverySpi =
+                    new TcpDiscoverySpi
+                    {
+                        AckTimeout = TimeSpan.FromDays(2),
+                        MaxAckTimeout = TimeSpan.MaxValue,
+                        JoinTimeout = TimeSpan.MaxValue,
+                        NetworkTimeout = TimeSpan.MaxValue,
+                        SocketTimeout = TimeSpan.MaxValue
+                    },
+                JvmClasspath = TestUtils.CreateTestClasspath(),
+                JvmOptions = TestUtils.TestJavaOptions(),
+                Localhost = "127.0.0.1"
+            };
+
+            using (var ignite = Ignition.Start(cfg))
+            {
+                cfg.GridName = "ignite2";
+                using (var ignite2 = Ignition.Start(cfg))
+                {
+                    Assert.AreEqual(2, ignite.GetCluster().GetNodes().Count);
+                    Assert.AreEqual(2, ignite2.GetCluster().GetNodes().Count);
+                }
+            }
+        }
+
+        /// <summary>
+        /// Tests the invalid timeouts.
+        /// </summary>
+        [Test]
+        public void TestInvalidTimeouts()
+        {
+            var cfg = new IgniteConfiguration
+            {
+                DiscoverySpi =
+                    new TcpDiscoverySpi
+                    {
+                        AckTimeout = TimeSpan.FromMilliseconds(-5),
+                        JoinTimeout = TimeSpan.MinValue,
+                    },
+                JvmClasspath = TestUtils.CreateTestClasspath(),
+                JvmOptions = TestUtils.TestJavaOptions(),
+            };
+
+            Assert.Throws<IgniteException>(() => Ignition.Start(cfg));
+        }
+
+        /// <summary>
+        /// Tests the static ip finder.
+        /// </summary>
+        [Test]
+        public void TestStaticIpFinder()
+        {
+            TestIpFinders(new TcpDiscoveryStaticIpFinder
+            {
+                Endpoints = new[] {"127.0.0.1:47500"}
+            }, new TcpDiscoveryStaticIpFinder
+            {
+                Endpoints = new[] {"127.0.0.1:47501"}
+            });
+        }
+
+        /// <summary>
+        /// Tests the multicast ip finder.
+        /// </summary>
+        [Test]
+        public void TestMulticastIpFinder()
+        {
+            TestIpFinders(
+                new TcpDiscoveryMulticastIpFinder {MulticastGroup = "228.111.111.222", MulticastPort = 54522},
+                new TcpDiscoveryMulticastIpFinder {MulticastGroup = "228.111.111.223", MulticastPort = 54522});
+        }
+
+        /// <summary>
+        /// Tests the ip finders.
+        /// </summary>
+        /// <param name="ipFinder">The ip finder.</param>
+        /// <param name="ipFinder2">The ip finder2.</param>
+        private static void TestIpFinders(TcpDiscoveryIpFinderBase ipFinder, TcpDiscoveryIpFinderBase ipFinder2)
+        {
+            var cfg = new IgniteConfiguration
+            {
+                DiscoverySpi =
+                    new TcpDiscoverySpi
+                    {
+                        IpFinder = ipFinder
+                    },
+                JvmClasspath = TestUtils.CreateTestClasspath(),
+                JvmOptions = TestUtils.TestJavaOptions(),
+                Localhost = "127.0.0.1"
+            };
+
+            using (var ignite = Ignition.Start(cfg))
+            {
+                // Start with the same endpoint
+                cfg.GridName = "ignite2";
+                using (var ignite2 = Ignition.Start(cfg))
+                {
+                    Assert.AreEqual(2, ignite.GetCluster().GetNodes().Count);
+                    Assert.AreEqual(2, ignite2.GetCluster().GetNodes().Count);
+                }
+
+                // Start with incompatible endpoint and check that there are 2 topologies
+                ((TcpDiscoverySpi) cfg.DiscoverySpi).IpFinder = ipFinder2;
+
+                using (var ignite2 = Ignition.Start(cfg))
+                {
+                    Assert.AreEqual(1, ignite.GetCluster().GetNodes().Count);
+                    Assert.AreEqual(1, ignite2.GetCluster().GetNodes().Count);
+                }
+            }
+        }
+
+        /// <summary>
+        /// Checks the default properties.
+        /// </summary>
+        /// <param name="cfg">The CFG.</param>
+        private static void CheckDefaultProperties(IgniteConfiguration cfg)
+        {
+            Assert.AreEqual(IgniteConfiguration.DefaultMetricsExpireTime, cfg.MetricsExpireTime);
+            Assert.AreEqual(IgniteConfiguration.DefaultMetricsHistorySize, cfg.MetricsHistorySize);
+            Assert.AreEqual(IgniteConfiguration.DefaultMetricsLogFrequency, cfg.MetricsLogFrequency);
+            Assert.AreEqual(IgniteConfiguration.DefaultMetricsUpdateFrequency, cfg.MetricsUpdateFrequency);
+            Assert.AreEqual(IgniteConfiguration.DefaultNetworkTimeout, cfg.NetworkTimeout);
+            Assert.AreEqual(IgniteConfiguration.DefaultNetworkSendRetryCount, cfg.NetworkSendRetryCount);
+            Assert.AreEqual(IgniteConfiguration.DefaultNetworkSendRetryDelay, cfg.NetworkSendRetryDelay);
+        }
+
+        /// <summary>
+        /// Checks the default value attributes.
+        /// </summary>
+        /// <param name="obj">The object.</param>
+        private static void CheckDefaultValueAttributes(object obj)
+        {
+            var props = obj.GetType().GetProperties();
+
+            foreach (var prop in props)
+            {
+                var attr = prop.GetCustomAttributes(true).OfType<DefaultValueAttribute>().FirstOrDefault();
+                var propValue = prop.GetValue(obj, null);
+
+                if (attr != null)
+                    Assert.AreEqual(attr.Value, propValue);
+                else if (prop.PropertyType.IsValueType)
+                    Assert.AreEqual(Activator.CreateInstance(prop.PropertyType), propValue);
+                else
+                    Assert.IsNull(propValue);
+            }
+        }
+
+        /// <summary>
+        /// Gets the custom configuration.
+        /// </summary>
+        private static IgniteConfiguration GetCustomConfig()
+        {
+            return new IgniteConfiguration
+            {
+                DiscoverySpi = new TcpDiscoverySpi
+                {
+                    NetworkTimeout = TimeSpan.FromSeconds(1),
+                    AckTimeout = TimeSpan.FromSeconds(2),
+                    MaxAckTimeout = TimeSpan.FromSeconds(3),
+                    SocketTimeout = TimeSpan.FromSeconds(4),
+                    JoinTimeout = TimeSpan.FromSeconds(5),
+                    IpFinder = new TcpDiscoveryStaticIpFinder
+                    {
+                        Endpoints = new[] { "127.0.0.1:47500", "127.0.0.1:47501" }
+                    }
+                },
+                GridName = "gridName1",
+                IncludedEventTypes = EventType.SwapspaceAll,
+                MetricsExpireTime = TimeSpan.FromMinutes(7),
+                MetricsHistorySize = 125,
+                MetricsLogFrequency = TimeSpan.FromMinutes(8),
+                MetricsUpdateFrequency = TimeSpan.FromMinutes(9),
+                NetworkSendRetryCount = 54,
+                NetworkTimeout = TimeSpan.FromMinutes(10),
+                NetworkSendRetryDelay = TimeSpan.FromMinutes(11),
+                WorkDirectory = Path.GetTempPath(),
+                JvmOptions = TestUtils.TestJavaOptions(),
+                JvmClasspath = TestUtils.CreateTestClasspath(),
+                Localhost = "127.0.0.1"
+            };
+        }
+
+        /// <summary>
+        /// Gets the static discovery.
+        /// </summary>
+        /// <returns></returns>
+        private static IDiscoverySpi GetStaticDiscovery()
+        {
+            return new TcpDiscoverySpi
+            {
+                IpFinder = new TcpDiscoveryStaticIpFinder {Endpoints = new[] {"127.0.0.1:47500", "127.0.0.1:47501"}}
+            };
+        }
+    }
+}

http://git-wip-us.apache.org/repos/asf/ignite/blob/ee20f1d9/modules/platforms/dotnet/Apache.Ignite.Core.Tests/MarshallerTest.cs
----------------------------------------------------------------------
diff --git a/modules/platforms/dotnet/Apache.Ignite.Core.Tests/MarshallerTest.cs b/modules/platforms/dotnet/Apache.Ignite.Core.Tests/MarshallerTest.cs
index 541de0c..7def56f 100644
--- a/modules/platforms/dotnet/Apache.Ignite.Core.Tests/MarshallerTest.cs
+++ b/modules/platforms/dotnet/Apache.Ignite.Core.Tests/MarshallerTest.cs
@@ -34,7 +34,7 @@ namespace Apache.Ignite.Core.Tests
         {
             using (var grid = Ignition.Start("config\\marshaller-default.xml"))
             {
-                var cache = grid.GetOrCreateCache<int, int>(null);
+                var cache = grid.GetOrCreateCache<int, int>((string) null);
 
                 cache.Put(1, 1);
 
@@ -51,7 +51,7 @@ namespace Apache.Ignite.Core.Tests
         {
             using (var grid = Ignition.Start("config\\marshaller-explicit.xml"))
             {
-                var cache = grid.GetOrCreateCache<int, int>(null);
+                var cache = grid.GetOrCreateCache<int, int>((string) null);
 
                 cache.Put(1, 1);
 

http://git-wip-us.apache.org/repos/asf/ignite/blob/ee20f1d9/modules/platforms/dotnet/Apache.Ignite.Core.Tests/SerializationTest.cs
----------------------------------------------------------------------
diff --git a/modules/platforms/dotnet/Apache.Ignite.Core.Tests/SerializationTest.cs b/modules/platforms/dotnet/Apache.Ignite.Core.Tests/SerializationTest.cs
index 07caaf3..a36e30f 100644
--- a/modules/platforms/dotnet/Apache.Ignite.Core.Tests/SerializationTest.cs
+++ b/modules/platforms/dotnet/Apache.Ignite.Core.Tests/SerializationTest.cs
@@ -43,7 +43,7 @@ namespace Apache.Ignite.Core.Tests
         [TestFixtureSetUp]
         public void SetUp()
         {
-            var cfg = new IgniteConfigurationEx
+            var cfg = new IgniteConfiguration
             {
                 GridName = GridName,
                 JvmClasspath = TestUtils.CreateTestClasspath(),

http://git-wip-us.apache.org/repos/asf/ignite/blob/ee20f1d9/modules/platforms/dotnet/Apache.Ignite.Core.Tests/TestRunner.cs
----------------------------------------------------------------------
diff --git a/modules/platforms/dotnet/Apache.Ignite.Core.Tests/TestRunner.cs b/modules/platforms/dotnet/Apache.Ignite.Core.Tests/TestRunner.cs
index 2b0ab8e..a1083b6 100644
--- a/modules/platforms/dotnet/Apache.Ignite.Core.Tests/TestRunner.cs
+++ b/modules/platforms/dotnet/Apache.Ignite.Core.Tests/TestRunner.cs
@@ -20,6 +20,7 @@ namespace Apache.Ignite.Core.Tests
     using System;
     using System.Diagnostics;
     using System.Reflection;
+    using Apache.Ignite.Core.Tests.Cache.Query;
     using Apache.Ignite.Core.Tests.Memory;
     using NUnit.ConsoleRunner;
 
@@ -31,9 +32,9 @@ namespace Apache.Ignite.Core.Tests
             Debug.Listeners.Add(new TextWriterTraceListener(Console.Out));
             Debug.AutoFlush = true;
 
-            //TestOne(typeof(ContinuousQueryAtomiclBackupTest), "TestInitialQuery");
+            TestOne(typeof(IgniteConfigurationTest), "TestStaticIpFinder");
 
-            TestAll(typeof (ExecutableTest));
+            //TestAll(typeof (CacheQueriesCodeConfigurationTest));
             //TestAllInAssembly();
         }
 

http://git-wip-us.apache.org/repos/asf/ignite/blob/ee20f1d9/modules/platforms/dotnet/Apache.Ignite.Core/Apache.Ignite.Core.csproj
----------------------------------------------------------------------
diff --git a/modules/platforms/dotnet/Apache.Ignite.Core/Apache.Ignite.Core.csproj b/modules/platforms/dotnet/Apache.Ignite.Core/Apache.Ignite.Core.csproj
index 7de8330..1c83168 100644
--- a/modules/platforms/dotnet/Apache.Ignite.Core/Apache.Ignite.Core.csproj
+++ b/modules/platforms/dotnet/Apache.Ignite.Core/Apache.Ignite.Core.csproj
@@ -17,6 +17,7 @@
     <OutputPath>bin\x64\Debug\</OutputPath>
     <AllowUnsafeBlocks>true</AllowUnsafeBlocks>
     <DefineConstants>DEBUG;CODE_ANALYSIS</DefineConstants>
+    <CodeAnalysisRuleSet>Apache.Ignite.Core.ruleset</CodeAnalysisRuleSet>
     <DocumentationFile>bin\x64\Debug\Apache.Ignite.Core.XML</DocumentationFile>
     <RunCodeAnalysis>true</RunCodeAnalysis>
     <CodeAnalysisRuleSet>Apache.Ignite.Core.ruleset</CodeAnalysisRuleSet>
@@ -25,6 +26,7 @@
     <PlatformTarget>x64</PlatformTarget>
     <OutputPath>bin\x64\Release\</OutputPath>
     <AllowUnsafeBlocks>true</AllowUnsafeBlocks>
+    <CodeAnalysisRuleSet>Apache.Ignite.Core.ruleset</CodeAnalysisRuleSet>
     <Optimize>true</Optimize>
     <DocumentationFile>bin\x64\Release\Apache.Ignite.Core.XML</DocumentationFile>
     <CodeAnalysisRuleSet>Apache.Ignite.Core.ruleset</CodeAnalysisRuleSet>
@@ -34,6 +36,7 @@
     <OutputPath>bin\x86\Debug\</OutputPath>
     <AllowUnsafeBlocks>true</AllowUnsafeBlocks>
     <DefineConstants>DEBUG;CODE_ANALYSIS</DefineConstants>
+    <CodeAnalysisRuleSet>Apache.Ignite.Core.ruleset</CodeAnalysisRuleSet>
     <DocumentationFile>bin\x86\Debug\Apache.Ignite.Core.XML</DocumentationFile>
     <CodeAnalysisRuleSet>Apache.Ignite.Core.ruleset</CodeAnalysisRuleSet>
   </PropertyGroup>
@@ -41,6 +44,7 @@
     <PlatformTarget>x86</PlatformTarget>
     <OutputPath>bin\x86\Release\</OutputPath>
     <AllowUnsafeBlocks>true</AllowUnsafeBlocks>
+    <CodeAnalysisRuleSet>Apache.Ignite.Core.ruleset</CodeAnalysisRuleSet>
     <Optimize>true</Optimize>
     <DocumentationFile>bin\x86\Release\Apache.Ignite.Core.XML</DocumentationFile>
     <CodeAnalysisRuleSet>Apache.Ignite.Core.ruleset</CodeAnalysisRuleSet>
@@ -65,6 +69,8 @@
     <Compile Include="Cache\CacheException.cs" />
     <Compile Include="Cache\CachePartialUpdateException.cs" />
     <Compile Include="Cache\CachePeekMode.cs" />
+    <Compile Include="Cache\Configuration\QueryAlias.cs" />
+    <Compile Include="Cache\Configuration\QueryTextFieldAttribute.cs" />
     <Compile Include="Cache\Event\CacheEntryEventType.cs" />
     <Compile Include="Cache\Event\ICacheEntryEvent.cs" />
     <Compile Include="Cache\Event\ICacheEntryEventFilter.cs" />
@@ -98,6 +104,7 @@
     <Compile Include="Cache\Store\CacheStoreAdapter.cs" />
     <Compile Include="Cache\Store\CacheStoreException.cs" />
     <Compile Include="Cache\Store\ICacheStore.cs" />
+    <Compile Include="Common\IFactory.cs" />
     <Compile Include="Cache\Store\ICacheStoreSession.cs" />
     <Compile Include="Cache\Store\Package-Info.cs" />
     <Compile Include="Cluster\ClusterGroupEmptyException.cs" />
@@ -128,6 +135,25 @@
     <Compile Include="Compute\IComputeJobResult.cs" />
     <Compile Include="Compute\IComputeReducer.cs" />
     <Compile Include="Compute\IComputeTask.cs" />
+    <Compile Include="Cache\Configuration\CacheAtomicityMode.cs" />
+    <Compile Include="Cache\Configuration\CacheAtomicWriteOrderMode.cs" />
+    <Compile Include="Cache\Configuration\CacheConfiguration.cs" />
+    <Compile Include="Cache\Configuration\CacheMemoryMode.cs" />
+    <Compile Include="Cache\Configuration\CacheMode.cs" />
+    <Compile Include="Cache\Configuration\CacheRebalanceMode.cs" />
+    <Compile Include="Cache\Configuration\CacheWriteSynchronizationMode.cs" />
+    <Compile Include="Discovery\Tcp\ITcpDiscoveryIpFinder.cs" />
+    <Compile Include="Discovery\Tcp\TcpDiscoverySpi.cs" />
+    <Compile Include="Cache\Configuration\QueryIndexField.cs" />
+    <Compile Include="Discovery\IDiscoverySpi.cs" />
+    <Compile Include="Discovery\Tcp\TcpDiscoveryIpFinderBase.cs" />
+    <Compile Include="Discovery\Tcp\Multicast\TcpDiscoveryMulticastIpFinder.cs" />
+    <Compile Include="Cache\Configuration\QueryEntity.cs" />
+    <Compile Include="Cache\Configuration\QueryField.cs" />
+    <Compile Include="Cache\Configuration\QueryIndex.cs" />
+    <Compile Include="Cache\Configuration\QueryIndexType.cs" />
+    <Compile Include="Cache\Configuration\QuerySqlFieldAttribute.cs" />
+    <Compile Include="Discovery\Tcp\Static\TcpDiscoveryStaticIpFinder.cs" />
     <Compile Include="Compute\Package-Info.cs" />
     <Compile Include="Datastream\IDataStreamer.cs" />
     <Compile Include="Datastream\IStreamReceiver.cs" />
@@ -158,6 +184,7 @@
     <Compile Include="Ignition.cs" />
     <Compile Include="IIgnite.cs" />
     <Compile Include="Impl\Binary\BinaryEnum.cs" />
+    <Compile Include="Impl\Binary\JavaTypes.cs" />
     <Compile Include="Impl\Cache\CacheAffinityImpl.cs" />
     <Compile Include="Impl\Cache\CacheEntry.cs" />
     <Compile Include="Impl\Cache\CacheEntryFilterHolder.cs" />
@@ -235,7 +262,6 @@
     <Compile Include="Impl\Events\Events.cs" />
     <Compile Include="Impl\Events\RemoteListenEventFilter.cs" />
     <Compile Include="Impl\ExceptionUtils.cs" />
-    <Compile Include="Impl\IgniteConfigurationEx.cs" />
     <Compile Include="Impl\Ignite.cs" />
     <Compile Include="Impl\IgniteManager.cs" />
     <Compile Include="Impl\IgniteProxy.cs" />
@@ -405,6 +431,7 @@
     <None Include="Apache.Ignite.Core.ruleset" />
     <None Include="Apache.Ignite.Core.snk" />
   </ItemGroup>
+  <ItemGroup />
   <Import Project="$(MSBuildToolsPath)\Microsoft.CSharp.targets" />
   <!-- To modify your build process, add your task inside one of the targets below and uncomment it. 
        Other similar extension points exist, see Microsoft.Common.targets.

http://git-wip-us.apache.org/repos/asf/ignite/blob/ee20f1d9/modules/platforms/dotnet/Apache.Ignite.Core/Binary/BinaryConfiguration.cs
----------------------------------------------------------------------
diff --git a/modules/platforms/dotnet/Apache.Ignite.Core/Binary/BinaryConfiguration.cs b/modules/platforms/dotnet/Apache.Ignite.Core/Binary/BinaryConfiguration.cs
index 4d82a65..fa2fb1c 100644
--- a/modules/platforms/dotnet/Apache.Ignite.Core/Binary/BinaryConfiguration.cs
+++ b/modules/platforms/dotnet/Apache.Ignite.Core/Binary/BinaryConfiguration.cs
@@ -17,8 +17,10 @@
 
 namespace Apache.Ignite.Core.Binary
 {
+    using System;
     using System.Collections.Generic;
     using System.Diagnostics.CodeAnalysis;
+    using System.Linq;
     using Apache.Ignite.Core.Impl.Common;
 
     /// <summary>
@@ -27,7 +29,7 @@ namespace Apache.Ignite.Core.Binary
     public class BinaryConfiguration
     {
         /// <summary>
-        /// Constructor.
+        /// Initializes a new instance of the <see cref="BinaryConfiguration"/> class.
         /// </summary>
         public BinaryConfiguration()
         {
@@ -35,9 +37,9 @@ namespace Apache.Ignite.Core.Binary
         }
 
         /// <summary>
-        /// Copying constructor.
+        /// Initializes a new instance of the <see cref="BinaryConfiguration" /> class.
         /// </summary>
-        /// <param name="cfg">Configuration to copy.</param>
+        /// <param name="cfg">The binary configuration to copy.</param>
         public BinaryConfiguration(BinaryConfiguration cfg)
         {
             IgniteArgumentCheck.NotNull(cfg, "cfg");
@@ -47,15 +49,20 @@ namespace Apache.Ignite.Core.Binary
             DefaultKeepDeserialized = cfg.DefaultKeepDeserialized;
             DefaultSerializer = cfg.DefaultSerializer;
 
-            Types = cfg.Types != null ? new List<string>(cfg.Types) : null;
+            TypeConfigurations = cfg.TypeConfigurations == null
+                ? null
+                : cfg.TypeConfigurations.Select(x => new BinaryTypeConfiguration(x)).ToList();
 
-            if (cfg.TypeConfigurations != null)
-            {
-                TypeConfigurations = new List<BinaryTypeConfiguration>(cfg.TypeConfigurations.Count);
+            Types = cfg.Types == null ? null : cfg.Types.ToList();
+        }
 
-                foreach (BinaryTypeConfiguration typeCfg in cfg.TypeConfigurations)
-                    TypeConfigurations.Add(new BinaryTypeConfiguration(typeCfg));
-            }
+        /// <summary>
+        /// Initializes a new instance of the <see cref="BinaryConfiguration"/> class.
+        /// </summary>
+        /// <param name="binaryTypes">Binary types to register.</param>
+        public BinaryConfiguration(params Type[] binaryTypes)
+        {
+            TypeConfigurations = binaryTypes.Select(t => new BinaryTypeConfiguration(t)).ToList();
         }
 
         /// <summary>

http://git-wip-us.apache.org/repos/asf/ignite/blob/ee20f1d9/modules/platforms/dotnet/Apache.Ignite.Core/Cache/Configuration/CacheAtomicWriteOrderMode.cs
----------------------------------------------------------------------
diff --git a/modules/platforms/dotnet/Apache.Ignite.Core/Cache/Configuration/CacheAtomicWriteOrderMode.cs b/modules/platforms/dotnet/Apache.Ignite.Core/Cache/Configuration/CacheAtomicWriteOrderMode.cs
new file mode 100644
index 0000000..c9a41e8
--- /dev/null
+++ b/modules/platforms/dotnet/Apache.Ignite.Core/Cache/Configuration/CacheAtomicWriteOrderMode.cs
@@ -0,0 +1,43 @@
+/*
+ * 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.Cache.Configuration
+{
+    /// <summary>
+    /// Cache write ordering mode. This enumeration is taken into account only in 
+    /// <see cref="CacheAtomicityMode.Atomic"/> atomicity mode.
+    /// Write ordering mode determines which node assigns the write version, sender or the primary node.
+    /// </summary>
+    public enum CacheAtomicWriteOrderMode
+    {
+        /// <summary>
+        /// In this mode, write versions are assigned on a sender node which generally leads to better
+        /// performance in <see cref="CacheWriteSynchronizationMode.FullSync"/> synchronization mode, 
+        /// since in this case sender can send write requests to primary and backups at the same time.
+        /// <para/>
+        /// This mode will be automatically configured only with <see cref="CacheWriteSynchronizationMode.FullSync"/>
+        /// write synchronization mode, as for other synchronization modes it does not render better performance.
+        /// </summary>
+        Clock,
+
+        /// <summary>
+        /// Cache version is assigned only on primary node. This means that sender will only send write request
+        /// to primary node, which in turn will assign write version and forward it to backups.
+        /// </summary>
+        Primary
+    }
+}
\ No newline at end of file

http://git-wip-us.apache.org/repos/asf/ignite/blob/ee20f1d9/modules/platforms/dotnet/Apache.Ignite.Core/Cache/Configuration/CacheAtomicityMode.cs
----------------------------------------------------------------------
diff --git a/modules/platforms/dotnet/Apache.Ignite.Core/Cache/Configuration/CacheAtomicityMode.cs b/modules/platforms/dotnet/Apache.Ignite.Core/Cache/Configuration/CacheAtomicityMode.cs
new file mode 100644
index 0000000..8c36a77
--- /dev/null
+++ b/modules/platforms/dotnet/Apache.Ignite.Core/Cache/Configuration/CacheAtomicityMode.cs
@@ -0,0 +1,54 @@
+/*
+ * 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.Cache.Configuration
+{
+    using Apache.Ignite.Core.Cache;
+
+    /// <summary>
+    /// Cache atomicity mode.
+    /// </summary>
+    public enum CacheAtomicityMode
+    {
+        /// <summary>
+        /// Specifies fully ACID-compliant transactional cache behavior.
+        /// </summary>
+        Transactional,
+
+        /// <summary>
+        /// Specifies atomic-only cache behaviour. In this mode distributed transactions and distributed
+        /// locking are not supported. Disabling transactions and locking allows to achieve much higher
+        /// performance and throughput ratios.
+        /// <para/>
+        /// In addition to transactions and locking, one of the main differences to <see cref="Atomic"/> mode
+        /// is that bulk writes, such as <see cref="ICache{TK,TV}.PutAll"/> 
+        /// and <see cref="ICache{TK,TV}.RemoveAll(System.Collections.Generic.IEnumerable{TK})"/> methods, 
+        /// become simple batch operations which can partially fail. In case of partial
+        /// failure, <see cref="CachePartialUpdateException"/>will be thrown which will contain a list of keys 
+        /// for which the update failed. It is recommended that bulk writes are used
+        /// whenever multiple keys need to be inserted or updated in cache, as they reduce number of network trips and
+        /// provide better performance.
+        /// <para/>
+        /// Note that even without locking and transactions, <see cref="Atomic"/> mode still provides
+        /// full consistency guarantees across all cache nodes.
+        /// <para/>
+        /// Also note that all data modifications in <see cref="Atomic"/> mode are guaranteed to be atomic
+        /// and consistent with writes to the underlying persistent store, if one is configured.        
+        /// </summary>
+        Atomic
+    }
+}
\ No newline at end of file


Mime
View raw message