From fd2e3667812ce46787860d925ca38c794b6770a1 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?As=C4=B1m=20Arslan?= <arslanasim@gmail.com>
Date: Tue, 2 Jan 2018 14:06:40 +0300
Subject: [PATCH] API doc improvement Added Test Categories for features
 introduced at specific versions

---
 .../ClientConnection.cs                       |   3 -
 .../DefaultSocketFactory.cs                   |  27 ---
 .../EventMessageConst.cs                      |   2 +-
 .../IClientMessage.cs                         |  92 +++++++--
 .../ClientClusterService.cs                   |   2 +-
 .../Hazelcast.Client.Spi/ClientContext.cs     |   3 +-
 .../ClientExecutionService.cs                 |   3 +-
 .../Hazelcast.Client.Spi/ClientInvocation.cs  |   3 +-
 .../ClientInvocationService.cs                |   3 +-
 .../ClientListenerService.cs                  |   3 +-
 .../ClientMembershipListener.cs               |   3 +-
 .../ClientNonSmartInvocationService.cs        |   3 +-
 .../ClientPartitionService.cs                 |   3 +-
 .../Hazelcast.Client.Spi/ClientProxy.cs       |   3 +-
 .../ClientSmartInvocationService.cs           |   3 +-
 .../Hazelcast.Client.Spi/EventRegistration.cs |   3 +-
 .../Hazelcast.Client.Spi/Exception.cs         |  21 ++-
 .../IClientClusterService.cs                  |   3 +-
 .../IClientExecutionService.cs                |   6 +-
 .../IClientInvocationService.cs               |   1 +
 .../IClientListenerService.cs                 |  10 +-
 .../IClientPartitionService.cs                |   7 +
 .../IClientProxyFactory.cs                    |   1 +
 Hazelcast.Net/Hazelcast.Client.Spi/IFuture.cs |   1 +
 .../ListenerRegistrationKey.cs                |   1 +
 .../MemberAttributeChange.cs                  |   1 +
 .../MemberAttributeOperationType.cs           |   1 +
 .../Hazelcast.Client.Spi/ObjectNamespace.cs   |   1 +
 .../Hazelcast.Client.Spi/ProxyManager.cs      |   1 +
 .../Hazelcast.Client.Spi/SettableFuture.cs    |   1 +
 .../Hazelcast.Client/ClientNearCache.cs       |   2 +-
 .../Hazelcast.Client/HazelcastClient.cs       |  36 +++-
 .../Hazelcast.Client/ILoadBalancer.cs         |   5 +
 .../AbstractXmlConfigHelper.cs                |   2 +
 .../Hazelcast.Config/ClientConfig.cs          | 130 +++++++++++--
 .../Hazelcast.Config/ClientNetworkConfig.cs   | 104 ++++++++++-
 .../GlobalSerializerConfig.cs                 |   4 +
 Hazelcast.Net/Hazelcast.Config/GroupConfig.cs |  21 ++-
 .../Hazelcast.Config/InMemoryFormat.cs        |   8 +-
 .../Hazelcast.Config/NearCacheConfig.cs       | 154 +++++++++++++--
 .../NearCacheConfigReadOnly.cs                |  36 ++++
 .../Hazelcast.Config/ProxyFactoryConfig.cs    |  19 ++
 Hazelcast.Net/Hazelcast.Config/SSLConfig.cs   |   1 +
 .../Hazelcast.Config/SerializationConfig.cs   | 176 ++++++++++++++++++
 .../Hazelcast.Config/SerializerConfig.cs      |   4 +
 .../SocketInterceptorConfig.cs                |   4 +
 .../Hazelcast.Config/SocketOptions.cs         |   6 +
 .../XmlClientConfigBuilder.cs                 |  17 ++
 Hazelcast.Net/Hazelcast.Core/IMap.cs          |   4 +-
 .../AggregatorAndProjectionTest.cs            |   1 +
 .../Hazelcast.Client.Test/ClientMapTest.cs    |   1 +
 .../ClientNearCacheTest.cs                    |   1 +
 .../PartitionPredicateTest.cs                 |   1 +
 Hazelcast.Test/Hazelcast.Test.csproj          |   6 +-
 docs/hazelcastdoc.shfbproj                    |  15 +-
 55 files changed, 857 insertions(+), 116 deletions(-)
 delete mode 100644 Hazelcast.Net/Hazelcast.Client.Connection/DefaultSocketFactory.cs

diff --git a/Hazelcast.Net/Hazelcast.Client.Connection/ClientConnection.cs b/Hazelcast.Net/Hazelcast.Client.Connection/ClientConnection.cs
index b468bc862e..ff4c1fdf3e 100644
--- a/Hazelcast.Net/Hazelcast.Client.Connection/ClientConnection.cs
+++ b/Hazelcast.Net/Hazelcast.Client.Connection/ClientConnection.cs
@@ -70,9 +70,6 @@ public ClientConnection(ClientConnectionManager clientConnectionManager,
 
             var isa = address.GetInetSocketAddress();
             var socketOptions = clientNetworkConfig.GetSocketOptions();
-            var socketFactory = socketOptions.GetSocketFactory() ?? new DefaultSocketFactory();
-            _clientSocket = socketFactory.CreateSocket();
-
             try
             {
                 _clientSocket = new Socket(isa.AddressFamily, SocketType.Stream, ProtocolType.Tcp);
diff --git a/Hazelcast.Net/Hazelcast.Client.Connection/DefaultSocketFactory.cs b/Hazelcast.Net/Hazelcast.Client.Connection/DefaultSocketFactory.cs
deleted file mode 100644
index 62ae6a11c7..0000000000
--- a/Hazelcast.Net/Hazelcast.Client.Connection/DefaultSocketFactory.cs
+++ /dev/null
@@ -1,27 +0,0 @@
-// Copyright (c) 2008-2017, Hazelcast, Inc. All Rights Reserved.
-// 
-// Licensed 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.
-
-using System.Net.Sockets;
-
-namespace Hazelcast.Client.Connection
-{
-    internal class DefaultSocketFactory : ISocketFactory
-    {
-        /// <exception cref="System.IO.IOException"></exception>
-        public virtual Socket CreateSocket()
-        {
-            return new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);
-        }
-    }
-}
\ No newline at end of file
diff --git a/Hazelcast.Net/Hazelcast.Client.Protocol/EventMessageConst.cs b/Hazelcast.Net/Hazelcast.Client.Protocol/EventMessageConst.cs
index a1b3d681fa..ac17a71bfd 100644
--- a/Hazelcast.Net/Hazelcast.Client.Protocol/EventMessageConst.cs
+++ b/Hazelcast.Net/Hazelcast.Client.Protocol/EventMessageConst.cs
@@ -19,7 +19,7 @@ namespace Hazelcast.Client.Protocol
     ///     Message type ids of event responses in client protocol. They also used to bind a request to event inside Request
     ///     annotation.
     /// </remarks>
-    public sealed class EventMessageConst
+    internal sealed class EventMessageConst
     {
         public const int EventMember = 200;
         public const int EventMemberList = 201;
diff --git a/Hazelcast.Net/Hazelcast.Client.Protocol/IClientMessage.cs b/Hazelcast.Net/Hazelcast.Client.Protocol/IClientMessage.cs
index eba47870f3..98dc7bb587 100644
--- a/Hazelcast.Net/Hazelcast.Client.Protocol/IClientMessage.cs
+++ b/Hazelcast.Net/Hazelcast.Client.Protocol/IClientMessage.cs
@@ -17,29 +17,95 @@
 
 namespace Hazelcast.Client.Protocol
 {
+    /// <summary>
+    ///     Client Message is the carrier framed data as defined below.
+    /// </summary>
+    /// <remarks>
+    ///     <p>
+    ///         Client Message is the carrier framed data as defined below.
+    ///     </p>
+    ///     <p>
+    ///         Any request parameter, response or event data will be carried in
+    ///         the payload.
+    ///     </p>
+    ///     <p />
+    ///     <pre>
+    ///         0                   1                   2                   3
+    ///         0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1
+    ///         +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+    ///         |R|                      Frame Length                           |
+    ///         +-------------+---------------+---------------------------------+
+    ///         |  Version    |B|E|  Flags    |               Type              |
+    ///         +-------------+---------------+---------------------------------+
+    ///         |                                                               |
+    ///         +                       CorrelationId                           +
+    ///         |                                                               |
+    ///         +---------------------------------------------------------------+
+    ///         |                        PartitionId                            |
+    ///         +-----------------------------+---------------------------------+
+    ///         |        Data Offset          |                                 |
+    ///         +-----------------------------+                                 |
+    ///         |                      Message Payload Data                    ...
+    ///         |                                                              ...
+    ///     </pre>
+    /// </remarks>
     public interface IClientMessage
     {
+        /// <summary>Sets the flags field value.</summary>
+        /// <param name="flags">The value to set in the flags field.</param>
+        /// <returns>The ClientMessage with the new flags field value.</returns>
         IClientMessage AddFlag(short flags);
+
+        /// <param name="listenerEventFlag">Check this flag to see if it is set.</param>
+        /// <returns>true if the given flag is set, false otherwise.</returns>
+        bool IsFlagSet(short listenerEventFlag);
+
+        /// <summary>Returns the flags field value.</summary>
+        /// <returns>The flags field value.</returns>
+        short GetFlags();
+
+        /// <summary>Returns the message type field.</summary>
+        /// <returns>The message type field value.</returns>
+        int GetMessageType();
+
+        /// <summary>Returns the correlation ID field.</summary>
+        /// <returns>The correlation ID field.</returns>
+        long GetCorrelationId();
+
+        /// <summary>Sets the correlation ID field.</summary>
+        /// <param name="correlationId">The value to set in the correlation ID field.</param>
+        /// <returns>The ClientMessage with the new correlation ID field value.</returns>
+        IClientMessage SetCorrelationId(long correlationId);
+
+        /// <summary>Returns the partition ID field.</summary>
+        /// <returns>The partition ID field.</returns>
+        int GetPartitionId();
+
+        /// <summary>Sets the partition ID field.</summary>
+        /// <param name="partitionId">The value to set in the partitions ID field.</param>
+        /// <returns>The ClientMessage with the new partitions ID field value.</returns>
+        IClientMessage SetPartitionId(int partitionId);
+
+        /// <summary>Returns the frame length field.</summary>
+        /// <returns>The frame length field.</returns>
+        int GetFrameLength();
+
+        /// <summary>Returns the version field value.</summary>
+        /// <returns>The version field value.</returns>
+        short GetVersion();
+        
+        /// <summary>Checks the frame size and total data size to validate the message size.</summary>
+        /// <returns>true if the message is constructed.</returns>
+        bool IsComplete();
+
+        bool IsRetryable();
         bool GetBoolean();
         byte GetByte();
-        long GetCorrelationId();
         IData GetData();
         short GetShort();
         int GetInt();
         long GetLong();
         KeyValuePair<IData, IData> GetMapEntry();
-        int GetMessageType();
-        int GetPartitionId();
         string GetStringUtf8();
-        bool IsFlagSet(short listenerEventFlag);
-        bool IsRetryable();
-        bool IsComplete();
-
-        /// <summary>Sets the correlation id field.</summary>
-        /// <param name="correlationId">The value to set in the correlation id field.</param>
-        /// <returns>The ClientMessage with the new correlation id field value.</returns>
-        IClientMessage SetCorrelationId(long correlationId);
-
-        IClientMessage SetPartitionId(int partitionId);
     }
 }
\ No newline at end of file
diff --git a/Hazelcast.Net/Hazelcast.Client.Spi/ClientClusterService.cs b/Hazelcast.Net/Hazelcast.Client.Spi/ClientClusterService.cs
index 416b1b6cd5..139eea4712 100644
--- a/Hazelcast.Net/Hazelcast.Client.Spi/ClientClusterService.cs
+++ b/Hazelcast.Net/Hazelcast.Client.Spi/ClientClusterService.cs
@@ -31,7 +31,7 @@
 using Hazelcast.Security;
 using Hazelcast.Util;
 using ICredentials = Hazelcast.Security.ICredentials;
-
+#pragma warning disable CS1591
 namespace Hazelcast.Client.Spi
 {
     /// <summary>
diff --git a/Hazelcast.Net/Hazelcast.Client.Spi/ClientContext.cs b/Hazelcast.Net/Hazelcast.Client.Spi/ClientContext.cs
index e56f75bea4..793592a8e7 100644
--- a/Hazelcast.Net/Hazelcast.Client.Spi/ClientContext.cs
+++ b/Hazelcast.Net/Hazelcast.Client.Spi/ClientContext.cs
@@ -15,7 +15,8 @@
 using Hazelcast.Config;
 using Hazelcast.IO.Serialization;
 
-namespace Hazelcast.Client.Spi
+#pragma warning disable CS1591
+ namespace Hazelcast.Client.Spi
 {
     internal sealed class ClientContext
     {
diff --git a/Hazelcast.Net/Hazelcast.Client.Spi/ClientExecutionService.cs b/Hazelcast.Net/Hazelcast.Client.Spi/ClientExecutionService.cs
index b9b8c4e7f7..49167d541c 100644
--- a/Hazelcast.Net/Hazelcast.Client.Spi/ClientExecutionService.cs
+++ b/Hazelcast.Net/Hazelcast.Client.Spi/ClientExecutionService.cs
@@ -18,7 +18,8 @@
 using Hazelcast.Core;
 using Hazelcast.Util;
 
-namespace Hazelcast.Client.Spi
+#pragma warning disable CS1591
+ namespace Hazelcast.Client.Spi
 {
     internal sealed class ClientExecutionService : IClientExecutionService
     {
diff --git a/Hazelcast.Net/Hazelcast.Client.Spi/ClientInvocation.cs b/Hazelcast.Net/Hazelcast.Client.Spi/ClientInvocation.cs
index eff17ad7f6..6631e6a984 100644
--- a/Hazelcast.Net/Hazelcast.Client.Spi/ClientInvocation.cs
+++ b/Hazelcast.Net/Hazelcast.Client.Spi/ClientInvocation.cs
@@ -17,7 +17,8 @@
 using Hazelcast.IO;
 using Hazelcast.Util;
 
-namespace Hazelcast.Client.Spi
+#pragma warning disable CS1591
+ namespace Hazelcast.Client.Spi
 {
     internal class ClientInvocation
     {
diff --git a/Hazelcast.Net/Hazelcast.Client.Spi/ClientInvocationService.cs b/Hazelcast.Net/Hazelcast.Client.Spi/ClientInvocationService.cs
index 927c6682e8..6363febc0d 100644
--- a/Hazelcast.Net/Hazelcast.Client.Spi/ClientInvocationService.cs
+++ b/Hazelcast.Net/Hazelcast.Client.Spi/ClientInvocationService.cs
@@ -28,7 +28,8 @@
 using Hazelcast.Logging;
 using Hazelcast.Util;
 
-namespace Hazelcast.Client.Spi
+#pragma warning disable CS1591
+ namespace Hazelcast.Client.Spi
 {
     internal abstract class ClientInvocationService : IClientInvocationService, IConnectionListener
     {
diff --git a/Hazelcast.Net/Hazelcast.Client.Spi/ClientListenerService.cs b/Hazelcast.Net/Hazelcast.Client.Spi/ClientListenerService.cs
index 54fe14edd6..81c8b44ead 100644
--- a/Hazelcast.Net/Hazelcast.Client.Spi/ClientListenerService.cs
+++ b/Hazelcast.Net/Hazelcast.Client.Spi/ClientListenerService.cs
@@ -26,7 +26,8 @@
 using Hazelcast.Logging;
 using Hazelcast.Util;
 
-namespace Hazelcast.Client.Spi
+#pragma warning disable CS1591
+ namespace Hazelcast.Client.Spi
 {
     internal class
         ClientListenerService : IClientListenerService, IConnectionListener, IConnectionHeartbeatListener, IDisposable
diff --git a/Hazelcast.Net/Hazelcast.Client.Spi/ClientMembershipListener.cs b/Hazelcast.Net/Hazelcast.Client.Spi/ClientMembershipListener.cs
index fa1be14f6f..0400daca1f 100644
--- a/Hazelcast.Net/Hazelcast.Client.Spi/ClientMembershipListener.cs
+++ b/Hazelcast.Net/Hazelcast.Client.Spi/ClientMembershipListener.cs
@@ -23,7 +23,8 @@
 using Hazelcast.Logging;
 using Hazelcast.Util;
 
-namespace Hazelcast.Client.Spi
+#pragma warning disable CS1591
+ namespace Hazelcast.Client.Spi
 {
     internal class ClientMembershipListener
     {
diff --git a/Hazelcast.Net/Hazelcast.Client.Spi/ClientNonSmartInvocationService.cs b/Hazelcast.Net/Hazelcast.Client.Spi/ClientNonSmartInvocationService.cs
index e5109abdca..cd06f63c9a 100644
--- a/Hazelcast.Net/Hazelcast.Client.Spi/ClientNonSmartInvocationService.cs
+++ b/Hazelcast.Net/Hazelcast.Client.Spi/ClientNonSmartInvocationService.cs
@@ -17,7 +17,8 @@
 using Hazelcast.IO;
 using Hazelcast.Util;
 
-namespace Hazelcast.Client.Spi
+#pragma warning disable CS1591
+ namespace Hazelcast.Client.Spi
 {
     internal class ClientNonSmartInvocationService : ClientInvocationService
     {
diff --git a/Hazelcast.Net/Hazelcast.Client.Spi/ClientPartitionService.cs b/Hazelcast.Net/Hazelcast.Client.Spi/ClientPartitionService.cs
index b18092b697..78016e2eff 100644
--- a/Hazelcast.Net/Hazelcast.Client.Spi/ClientPartitionService.cs
+++ b/Hazelcast.Net/Hazelcast.Client.Spi/ClientPartitionService.cs
@@ -24,7 +24,8 @@
 using Hazelcast.Net.Ext;
 using Hazelcast.Util;
 
-namespace Hazelcast.Client.Spi
+#pragma warning disable CS1591
+ namespace Hazelcast.Client.Spi
 {
     internal sealed class
         ClientPartitionService : IClientPartitionService
diff --git a/Hazelcast.Net/Hazelcast.Client.Spi/ClientProxy.cs b/Hazelcast.Net/Hazelcast.Client.Spi/ClientProxy.cs
index 17a452d731..30c7fee172 100644
--- a/Hazelcast.Net/Hazelcast.Client.Spi/ClientProxy.cs
+++ b/Hazelcast.Net/Hazelcast.Client.Spi/ClientProxy.cs
@@ -23,7 +23,8 @@
 using Hazelcast.Partition.Strategy;
 using Hazelcast.Util;
 
-namespace Hazelcast.Client.Spi
+#pragma warning disable CS1591
+ namespace Hazelcast.Client.Spi
 {
     internal abstract class ClientProxy : IDistributedObject
     {
diff --git a/Hazelcast.Net/Hazelcast.Client.Spi/ClientSmartInvocationService.cs b/Hazelcast.Net/Hazelcast.Client.Spi/ClientSmartInvocationService.cs
index dfe8334bf1..a69b26327c 100644
--- a/Hazelcast.Net/Hazelcast.Client.Spi/ClientSmartInvocationService.cs
+++ b/Hazelcast.Net/Hazelcast.Client.Spi/ClientSmartInvocationService.cs
@@ -17,7 +17,8 @@
 using Hazelcast.IO;
 using Hazelcast.Util;
 
-namespace Hazelcast.Client.Spi
+#pragma warning disable CS1591
+ namespace Hazelcast.Client.Spi
 {
     internal class ClientSmartInvocationService : ClientInvocationService
     {
diff --git a/Hazelcast.Net/Hazelcast.Client.Spi/EventRegistration.cs b/Hazelcast.Net/Hazelcast.Client.Spi/EventRegistration.cs
index 7b88f9cc84..5b634ca507 100644
--- a/Hazelcast.Net/Hazelcast.Client.Spi/EventRegistration.cs
+++ b/Hazelcast.Net/Hazelcast.Client.Spi/EventRegistration.cs
@@ -14,7 +14,8 @@
 
 using Hazelcast.Client.Connection;
 
-namespace Hazelcast.Client.Spi
+#pragma warning disable CS1591
+ namespace Hazelcast.Client.Spi
 {
     internal class EventRegistration
     {
diff --git a/Hazelcast.Net/Hazelcast.Client.Spi/Exception.cs b/Hazelcast.Net/Hazelcast.Client.Spi/Exception.cs
index 265c2c0972..78fd6e39e2 100644
--- a/Hazelcast.Net/Hazelcast.Client.Spi/Exception.cs
+++ b/Hazelcast.Net/Hazelcast.Client.Spi/Exception.cs
@@ -16,41 +16,58 @@
 using Hazelcast.Core;
 using Hazelcast.IO;
 
-namespace Hazelcast.Client.Spi
+#pragma warning disable CS1591
+ namespace Hazelcast.Client.Spi
 {
+    /// <summary>
+    /// Marker interface for exceptions to indicate that an operation can be retried. 
+    /// E.g. a map.get sent to a machine where the partition has just moved to another machine.
+    /// </summary>
     [Serializable]
     public class RetryableHazelcastException : HazelcastException
     {
+        /// <inheritdoc />
         public RetryableHazelcastException()
         {
         }
 
+        /// <inheritdoc />
         public RetryableHazelcastException(string message) : base(message)
         {
         }
     }
 
+    /// <summary>
+    /// A <see cref="RetryableHazelcastException"/> that indicates operation is sent to a machine that isn't member of the cluster
+    /// </summary>
     [Serializable]
     public class TargetNotMemberException : RetryableHazelcastException
     {
+        /// <inheritdoc />
         public TargetNotMemberException(string message) : base(message)
         {
         }
     }
 
+    /// <summary>
+    /// Thrown when a client invocation is failed because related target is disconnected, and
+    /// whether the invocation runs or not is indeterminate
+    /// </summary>
     [Serializable]
     public class TargetDisconnectedException : RetryableHazelcastException
     {
+        /// <inheritdoc />
         public TargetDisconnectedException(Address address) : base("Target[" + address + "] disconnected.")
         {
         }
 
+        /// <inheritdoc />
         public TargetDisconnectedException(Address address, string message)
             : base("Target[" + address + "] disconnected, " + message)
         {
         }
 
-
+        /// <inheritdoc />
         public TargetDisconnectedException(string msg) : base(msg)
         {
         }
diff --git a/Hazelcast.Net/Hazelcast.Client.Spi/IClientClusterService.cs b/Hazelcast.Net/Hazelcast.Client.Spi/IClientClusterService.cs
index 725b831747..455630a3f3 100644
--- a/Hazelcast.Net/Hazelcast.Client.Spi/IClientClusterService.cs
+++ b/Hazelcast.Net/Hazelcast.Client.Spi/IClientClusterService.cs
@@ -16,7 +16,8 @@
 using Hazelcast.Core;
 using Hazelcast.IO;
 
-namespace Hazelcast.Client.Spi
+#pragma warning disable CS1591
+ namespace Hazelcast.Client.Spi
 {
     /// <author>mdogan 5/16/13</author>
     public interface IClientClusterService
diff --git a/Hazelcast.Net/Hazelcast.Client.Spi/IClientExecutionService.cs b/Hazelcast.Net/Hazelcast.Client.Spi/IClientExecutionService.cs
index bdac7057a0..c5ad13ff85 100644
--- a/Hazelcast.Net/Hazelcast.Client.Spi/IClientExecutionService.cs
+++ b/Hazelcast.Net/Hazelcast.Client.Spi/IClientExecutionService.cs
@@ -17,8 +17,12 @@
 using System.Threading.Tasks;
 using Hazelcast.Core;
 
-namespace Hazelcast.Client.Spi
+#pragma warning disable CS1591
+ namespace Hazelcast.Client.Spi
 {
+    /// <summary>
+    /// Executor service for Hazelcast clients.
+    /// </summary>
     public interface IClientExecutionService
     {
         Task Schedule(Action command, long delay, TimeUnit unit);
diff --git a/Hazelcast.Net/Hazelcast.Client.Spi/IClientInvocationService.cs b/Hazelcast.Net/Hazelcast.Client.Spi/IClientInvocationService.cs
index 3cf51e893c..ee01344a61 100644
--- a/Hazelcast.Net/Hazelcast.Client.Spi/IClientInvocationService.cs
+++ b/Hazelcast.Net/Hazelcast.Client.Spi/IClientInvocationService.cs
@@ -17,6 +17,7 @@
 using Hazelcast.IO;
 using Hazelcast.Util;
 
+#pragma warning disable CS1591
 namespace Hazelcast.Client.Spi
 {
     /// <summary>
diff --git a/Hazelcast.Net/Hazelcast.Client.Spi/IClientListenerService.cs b/Hazelcast.Net/Hazelcast.Client.Spi/IClientListenerService.cs
index 58405cee0b..039a21de28 100644
--- a/Hazelcast.Net/Hazelcast.Client.Spi/IClientListenerService.cs
+++ b/Hazelcast.Net/Hazelcast.Client.Spi/IClientListenerService.cs
@@ -15,8 +15,16 @@
 using Hazelcast.Client.Protocol;
 using Hazelcast.Util;
 
-namespace Hazelcast.Client.Spi
+#pragma warning disable CS1591
+ namespace Hazelcast.Client.Spi
 {
+    /// <summary>
+    /// Client service to add/remove remote listeners.
+    /// </summary>
+    /// <remarks>
+    /// For smart client, it registers local  listeners to all nodes in the cluster.
+    /// For dummy client, it registers global listener to one node.
+    /// </remarks>
     public interface IClientListenerService
     {
         bool AddEventHandler(long correlationId, DistributedEventHandler eventHandler);
diff --git a/Hazelcast.Net/Hazelcast.Client.Spi/IClientPartitionService.cs b/Hazelcast.Net/Hazelcast.Client.Spi/IClientPartitionService.cs
index 2f11ddf8fc..14103efc1f 100644
--- a/Hazelcast.Net/Hazelcast.Client.Spi/IClientPartitionService.cs
+++ b/Hazelcast.Net/Hazelcast.Client.Spi/IClientPartitionService.cs
@@ -14,8 +14,15 @@
 
 using Hazelcast.IO;
 
+#pragma warning disable CS1591
 namespace Hazelcast.Client.Spi
 {
+    /// <summary>
+    /// Partition service for Hazelcast clients.
+    /// </summary>
+    /// <remarks>
+    /// Allows to retrieve information about the partition count, partition owner or partition ID of a key.
+    /// </remarks>
     public interface IClientPartitionService
     {
         int GetPartitionCount();
diff --git a/Hazelcast.Net/Hazelcast.Client.Spi/IClientProxyFactory.cs b/Hazelcast.Net/Hazelcast.Client.Spi/IClientProxyFactory.cs
index d8b3f35a75..2579165f90 100644
--- a/Hazelcast.Net/Hazelcast.Client.Spi/IClientProxyFactory.cs
+++ b/Hazelcast.Net/Hazelcast.Client.Spi/IClientProxyFactory.cs
@@ -14,6 +14,7 @@
 
 using System;
 
+#pragma warning disable CS1591
 namespace Hazelcast.Client.Spi
 {
     internal delegate ClientProxy ClientProxyFactory(Type type, string id);
diff --git a/Hazelcast.Net/Hazelcast.Client.Spi/IFuture.cs b/Hazelcast.Net/Hazelcast.Client.Spi/IFuture.cs
index b55fb3a830..a9c387aa43 100644
--- a/Hazelcast.Net/Hazelcast.Client.Spi/IFuture.cs
+++ b/Hazelcast.Net/Hazelcast.Client.Spi/IFuture.cs
@@ -15,6 +15,7 @@
 using System;
 using System.Threading.Tasks;
 
+#pragma warning disable CS1591
 namespace Hazelcast.Client.Spi
 {
     public interface IFuture<T>
diff --git a/Hazelcast.Net/Hazelcast.Client.Spi/ListenerRegistrationKey.cs b/Hazelcast.Net/Hazelcast.Client.Spi/ListenerRegistrationKey.cs
index 9cf8c5735e..4045a69a31 100644
--- a/Hazelcast.Net/Hazelcast.Client.Spi/ListenerRegistrationKey.cs
+++ b/Hazelcast.Net/Hazelcast.Client.Spi/ListenerRegistrationKey.cs
@@ -15,6 +15,7 @@
 using Hazelcast.Client.Protocol;
 using Hazelcast.Util;
 
+#pragma warning disable CS1591
 namespace Hazelcast.Client.Spi
 {
     internal class ListenerRegistrationKey
diff --git a/Hazelcast.Net/Hazelcast.Client.Spi/MemberAttributeChange.cs b/Hazelcast.Net/Hazelcast.Client.Spi/MemberAttributeChange.cs
index e314ec3a19..997d14fead 100644
--- a/Hazelcast.Net/Hazelcast.Client.Spi/MemberAttributeChange.cs
+++ b/Hazelcast.Net/Hazelcast.Client.Spi/MemberAttributeChange.cs
@@ -12,6 +12,7 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
+#pragma warning disable CS1591
 namespace Hazelcast.Client.Spi
 {
     internal class MemberAttributeChange
diff --git a/Hazelcast.Net/Hazelcast.Client.Spi/MemberAttributeOperationType.cs b/Hazelcast.Net/Hazelcast.Client.Spi/MemberAttributeOperationType.cs
index 1feaa82788..5e0b2cf4cc 100644
--- a/Hazelcast.Net/Hazelcast.Client.Spi/MemberAttributeOperationType.cs
+++ b/Hazelcast.Net/Hazelcast.Client.Spi/MemberAttributeOperationType.cs
@@ -12,6 +12,7 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
+#pragma warning disable CS1591
 namespace Hazelcast.Client.Spi
 {
     /// <summary>Used to identify the type of member attribute change, either PUT or REMOVED</summary>
diff --git a/Hazelcast.Net/Hazelcast.Client.Spi/ObjectNamespace.cs b/Hazelcast.Net/Hazelcast.Client.Spi/ObjectNamespace.cs
index 123b939fbd..fc0d990396 100644
--- a/Hazelcast.Net/Hazelcast.Client.Spi/ObjectNamespace.cs
+++ b/Hazelcast.Net/Hazelcast.Client.Spi/ObjectNamespace.cs
@@ -15,6 +15,7 @@
 using System;
 using System.Text;
 
+#pragma warning disable CS1591
 namespace Hazelcast.Client.Spi
 {
     [Serializable]
diff --git a/Hazelcast.Net/Hazelcast.Client.Spi/ProxyManager.cs b/Hazelcast.Net/Hazelcast.Client.Spi/ProxyManager.cs
index ba822bace3..98fd46f13b 100644
--- a/Hazelcast.Net/Hazelcast.Client.Spi/ProxyManager.cs
+++ b/Hazelcast.Net/Hazelcast.Client.Spi/ProxyManager.cs
@@ -28,6 +28,7 @@
 using Hazelcast.Logging;
 using Hazelcast.Util;
 
+#pragma warning disable CS1591
 namespace Hazelcast.Client.Spi
 {
     internal sealed class ProxyManager
diff --git a/Hazelcast.Net/Hazelcast.Client.Spi/SettableFuture.cs b/Hazelcast.Net/Hazelcast.Client.Spi/SettableFuture.cs
index aa6cef2f4e..5f3f9987c5 100644
--- a/Hazelcast.Net/Hazelcast.Client.Spi/SettableFuture.cs
+++ b/Hazelcast.Net/Hazelcast.Client.Spi/SettableFuture.cs
@@ -18,6 +18,7 @@
 using System.Threading.Tasks;
 using Hazelcast.Util;
 
+#pragma warning disable CS1591
 namespace Hazelcast.Client.Spi
 {
     //WARNING: All exceptions should returned from the _taskSource otherwise UnobservedTaskException problem occur
diff --git a/Hazelcast.Net/Hazelcast.Client/ClientNearCache.cs b/Hazelcast.Net/Hazelcast.Client/ClientNearCache.cs
index eb9b7991d1..d3ac6cd5ee 100644
--- a/Hazelcast.Net/Hazelcast.Client/ClientNearCache.cs
+++ b/Hazelcast.Net/Hazelcast.Client/ClientNearCache.cs
@@ -27,7 +27,7 @@
 
 namespace Hazelcast.Client
 {
-    public enum ClientNearCacheType
+    internal enum ClientNearCacheType
     {
         Map,
         ReplicatedMap
diff --git a/Hazelcast.Net/Hazelcast.Client/HazelcastClient.cs b/Hazelcast.Net/Hazelcast.Client/HazelcastClient.cs
index 7639610bde..a116e3fb15 100644
--- a/Hazelcast.Net/Hazelcast.Client/HazelcastClient.cs
+++ b/Hazelcast.Net/Hazelcast.Client/HazelcastClient.cs
@@ -102,96 +102,115 @@ private HazelcastClient(ClientConfig config)
             _lockReferenceIdGenerator = new ClientLockReferenceIdGenerator();
         }
 
+        /// <inheritdoc />
         public string GetName()
         {
             return _instanceName;
         }
 
+        /// <inheritdoc />
         public IQueue<T> GetQueue<T>(string name)
         {
             return GetDistributedObject<IQueue<T>>(ServiceNames.Queue, name);
         }
 
+        /// <inheritdoc />
         public IRingbuffer<T> GetRingbuffer<T>(string name)
         {
             return GetDistributedObject<IRingbuffer<T>>(ServiceNames.Ringbuffer, name);
         }
 
+        /// <inheritdoc />
         public ITopic<T> GetTopic<T>(string name)
         {
             return GetDistributedObject<ITopic<T>>(ServiceNames.Topic, name);
         }
 
+        /// <inheritdoc />
         public IHSet<T> GetSet<T>(string name)
         {
             return GetDistributedObject<IHSet<T>>(ServiceNames.Set, name);
         }
 
+        /// <inheritdoc />
         public IHList<T> GetList<T>(string name)
         {
             return GetDistributedObject<IHList<T>>(ServiceNames.List, name);
         }
 
+        /// <inheritdoc />
         public IMap<TKey, TValue> GetMap<TKey, TValue>(string name)
         {
             return GetDistributedObject<IMap<TKey, TValue>>(ServiceNames.Map, name);
         }
 
+        /// <inheritdoc />
         public IMultiMap<TKey, TValue> GetMultiMap<TKey, TValue>(string name)
         {
             return GetDistributedObject<IMultiMap<TKey, TValue>>(ServiceNames.MultiMap, name);
         }
 
+        /// <inheritdoc />
         public IReplicatedMap<TKey, TValue> GetReplicatedMap<TKey, TValue>(string name)
         {
             return GetDistributedObject<IReplicatedMap<TKey, TValue>>(ServiceNames.ReplicatedMap, name);
         }
 
+        /// <inheritdoc />
         public ILock GetLock(string key)
         {
             return GetDistributedObject<ILock>(ServiceNames.Lock, key);
         }
 
+        /// <inheritdoc />
         public ICluster GetCluster()
         {
             return new ClientClusterProxy(_clusterService);
         }
 
+        /// <inheritdoc />
         public IEndpoint GetLocalEndpoint()
         {
             return _clusterService.GetLocalClient();
         }
 
+        /// <inheritdoc />
         public ITransactionContext NewTransactionContext()
         {
             return NewTransactionContext(TransactionOptions.GetDefault());
         }
 
+        /// <inheritdoc />
         public ITransactionContext NewTransactionContext(TransactionOptions options)
         {
             return new TransactionContextProxy(this, options);
         }
 
+        /// <inheritdoc />
         public IIdGenerator GetIdGenerator(string name)
         {
             return GetDistributedObject<IIdGenerator>(ServiceNames.IdGenerator, name);
         }
 
+        /// <inheritdoc />
         public IAtomicLong GetAtomicLong(string name)
         {
             return GetDistributedObject<IAtomicLong>(ServiceNames.AtomicLong, name);
         }
 
+        /// <inheritdoc />
         public ICountDownLatch GetCountDownLatch(string name)
         {
             return GetDistributedObject<ICountDownLatch>(ServiceNames.CountDownLatch, name);
         }
 
+        /// <inheritdoc />
         public ISemaphore GetSemaphore(string name)
         {
             return GetDistributedObject<ISemaphore>(ServiceNames.Semaphore, name);
         }
 
+        /// <inheritdoc />
         public ICollection<IDistributedObject> GetDistributedObjects()
         {
             try
@@ -213,37 +232,44 @@ public ICollection<IDistributedObject> GetDistributedObjects()
             }
         }
 
+        /// <inheritdoc />
         public string AddDistributedObjectListener(IDistributedObjectListener distributedObjectListener)
         {
             return _proxyManager.AddDistributedObjectListener(distributedObjectListener);
         }
 
+        /// <inheritdoc />
         public bool RemoveDistributedObjectListener(string registrationId)
         {
             return _proxyManager.RemoveDistributedObjectListener(registrationId);
         }
 
+        /// <inheritdoc />
         public IClientService GetClientService()
         {
             throw new NotSupportedException();
         }
 
+        /// <inheritdoc />
         public ILifecycleService GetLifecycleService()
         {
             return _lifecycleService;
         }
 
+        /// <inheritdoc />
         public T GetDistributedObject<T>(string serviceName, string name) where T : IDistributedObject
         {
             var clientProxy = _proxyManager.GetOrCreateProxy<T>(serviceName, name);
             return (T) ((IDistributedObject) clientProxy);
         }
 
+        /// <inheritdoc />
         public ConcurrentDictionary<string, object> GetUserContext()
         {
             return _userContext;
         }
 
+        /// <inheritdoc />
         public void Shutdown()
         {
             GetLifecycleService().Shutdown();
@@ -258,16 +284,22 @@ public static ICollection<IHazelcastInstance> GetAllHazelcastClients()
             return (ICollection<IHazelcastInstance>) Clients.Values;
         }
 
+        /// <summary>
+        /// Gets the configured <see cref="ILoadBalancer"/> instance
+        /// </summary>
+        /// <returns></returns>
         public ILoadBalancer GetLoadBalancer()
         {
             return _loadBalancer;
         }
 
-        //    @Override
+        /// <summary>
+        /// Not supported yet.
+        /// </summary>
+        /// <exception cref="NotSupportedException"></exception>
         public IClientPartitionService GetPartitionService()
         {
             throw new NotSupportedException("not supported yet");
-            //return new PartitionServiceProxy(partitionService);
         }
 
         /// <summary>
diff --git a/Hazelcast.Net/Hazelcast.Client/ILoadBalancer.cs b/Hazelcast.Net/Hazelcast.Client/ILoadBalancer.cs
index ca5df1b228..8ca5e7272f 100644
--- a/Hazelcast.Net/Hazelcast.Client/ILoadBalancer.cs
+++ b/Hazelcast.Net/Hazelcast.Client/ILoadBalancer.cs
@@ -32,6 +32,11 @@ namespace Hazelcast.Client
     /// </summary>
     public interface ILoadBalancer
     {
+        /// <summary>
+        /// Initializes the LoadBalancer.
+        /// </summary>
+        /// <param name="cluster">the Cluster this LoadBalancer uses to select members from</param>
+        /// <param name="config">the ClientConfig</param>
         void Init(ICluster cluster, ClientConfig config);
 
         /// <summary>Returns the next member to route to</summary>
diff --git a/Hazelcast.Net/Hazelcast.Config/AbstractXmlConfigHelper.cs b/Hazelcast.Net/Hazelcast.Config/AbstractXmlConfigHelper.cs
index a8ae22ac28..ad0f75c084 100644
--- a/Hazelcast.Net/Hazelcast.Config/AbstractXmlConfigHelper.cs
+++ b/Hazelcast.Net/Hazelcast.Config/AbstractXmlConfigHelper.cs
@@ -21,6 +21,8 @@
 
 namespace Hazelcast.Config
 {
+#pragma warning disable CS1591
+
     public abstract class AbstractXmlConfigHelper
     {
         private static readonly ILogger Logger = Logging.Logger.GetLogger(typeof (AbstractXmlConfigHelper));
diff --git a/Hazelcast.Net/Hazelcast.Config/ClientConfig.cs b/Hazelcast.Net/Hazelcast.Config/ClientConfig.cs
index 5e9f16c45f..8ed6efc9cc 100644
--- a/Hazelcast.Net/Hazelcast.Config/ClientConfig.cs
+++ b/Hazelcast.Net/Hazelcast.Config/ClientConfig.cs
@@ -21,6 +21,9 @@
 
 namespace Hazelcast.Config
 {
+    /// <summary>
+    /// Main configuration to setup a Hazelcast Client.
+    /// </summary>
     public class ClientConfig
     {
         private static readonly ILogger Logger = Logging.Logger.GetLogger(typeof (ClientConfig));
@@ -79,30 +82,55 @@ public class ClientConfig
 
         private SerializationConfig _serializationConfig = new SerializationConfig();
 
+        /// <summary>
+        /// Helper method to add a new ListenerConfig.
+        /// </summary>
+        /// <param name="listenerConfig">ListnerConfig</param>
+        /// <returns>configured <see cref="ClientConfig"/> for chaining</returns>
         public virtual ClientConfig AddListenerConfig(ListenerConfig listenerConfig)
         {
             GetListenerConfigs().Add(listenerConfig);
             return this;
         }
 
+        /// <summary>
+        /// Helper method to add a new NearCacheConfig.
+        /// </summary>
+        /// <param name="nearCacheConfig">NearCacheConfig</param>
+        /// <returns>configured <see cref="ClientConfig"/> for chaining</returns>
         public virtual ClientConfig AddNearCacheConfig(NearCacheConfig nearCacheConfig)
         {
             _nearCacheConfigMap.Add(nearCacheConfig.GetName(), nearCacheConfig);
             return this;
         }
 
+        /// <summary>
+        /// Helper method to add a new NearCacheConfig.
+        /// </summary>
+        /// <param name="mapName">name of the IMap / ICache that Near Cache config will be applied to</param>
+        /// <param name="nearCacheConfig">NearCacheConfig</param>
+        /// <returns>configured <see cref="ClientConfig"/> for chaining</returns>
         public virtual ClientConfig AddNearCacheConfig(string mapName, NearCacheConfig nearCacheConfig)
         {
             _nearCacheConfigMap.Add(mapName, nearCacheConfig);
             return this;
         }
 
+        /// <summary>
+        /// Helper method to add a new <see cref="ProxyFactoryConfig"/>.
+        /// </summary>
+        /// <param name="proxyFactoryConfig">ProxyFactoryConfig</param>
+        /// <returns>configured <see cref="ClientConfig"/> for chaining</returns>
         public virtual ClientConfig AddProxyFactoryConfig(ProxyFactoryConfig proxyFactoryConfig)
         {
             _proxyFactoryConfigs.Add(proxyFactoryConfig);
             return this;
         }
 
+        /// <summary>
+        /// Gets <see cref="ICredentials"/>.
+        /// </summary>
+        /// <returns>Credentials</returns>
         public virtual ICredentials GetCredentials()
         {
             if (_credentials == null)
@@ -113,113 +141,191 @@ public virtual ICredentials GetCredentials()
             return _credentials;
         }
 
+        /// <summary>
+        /// Gets pool-size for internal ExecutorService which handles responses etc.
+        /// </summary>
         public virtual int GetExecutorPoolSize()
         {
             return _executorPoolSize;
         }
 
+        /// <summary>
+        /// Gets <see cref="GroupConfig"/>.
+        /// </summary>
+        /// <returns><see cref="GroupConfig"/></returns>
         public virtual GroupConfig GetGroupConfig()
         {
             return _groupConfig;
         }
 
+        /// <summary>
+        /// Gets list of configured <see cref="ListenerConfig"/>.
+        /// </summary>
+        /// <returns>list of configured <see cref="ListenerConfig"/></returns>
         public virtual IList<ListenerConfig> GetListenerConfigs()
         {
             return _listenerConfigs;
         }
 
+        /// <summary>
+        /// Gets <see cref="IManagedContext"/>.
+        /// </summary>
+        /// <returns><see cref="IManagedContext"/></returns>
         public virtual IManagedContext GetManagedContext()
         {
             return _managedContext;
         }
 
+        /// <summary>
+        /// Gets <see cref="NearCacheConfig"/>.
+        /// </summary>
+        /// <param name="mapName">name of map</param>
+        /// <returns><see cref="NearCacheConfig"/></returns>
         public virtual NearCacheConfig GetNearCacheConfig(string mapName)
         {
             return LookupByPattern(_nearCacheConfigMap, mapName);
         }
 
+        /// <summary>
+        /// Gets dictionary of all configured <see cref="NearCacheConfig"/>'s with the name key and configuration as the value.
+        /// </summary>
+        /// <returns>Dictionary of NearCacheConfig</returns>
         public virtual IDictionary<string, NearCacheConfig> GetNearCacheConfigMap()
         {
             return _nearCacheConfigMap;
         }
 
-        //public virtual ClientSecurityConfig GetSecurityConfig()
-        //{
-        //    return securityConfig;
-        //}
-
-        //public virtual void SetSecurityConfig(ClientSecurityConfig securityConfig)
-        //{
-        //    this.securityConfig = securityConfig;
-        //}
-
+        /// <summary>
+        /// Gets <see cref="ClientNetworkConfig"/>.
+        /// </summary>
+        /// <returns><see cref="ClientNetworkConfig"/></returns>
         public virtual ClientNetworkConfig GetNetworkConfig()
         {
             return _networkConfig;
         }
 
+        /// <summary>
+        /// Gets <see cref="ProxyFactoryConfig"/>.
+        /// </summary>
+        /// <returns><see cref="ProxyFactoryConfig"/></returns>
         public virtual IList<ProxyFactoryConfig> GetProxyFactoryConfigs()
         {
             return _proxyFactoryConfigs;
         }
 
+        /// <summary>
+        /// Gets <see cref="SerializationConfig"/>.
+        /// </summary>
+        /// <returns><see cref="SerializationConfig"/></returns>
         public virtual SerializationConfig GetSerializationConfig()
         {
             return _serializationConfig;
         }
 
-        public void SetConfigPatternMatcher(IConfigPatternMatcher matchingPointConfigPatternMatcher)
+        /// <summary>
+        /// Sets <see cref="IConfigPatternMatcher"/>.
+        /// </summary>
+        /// <param name="matchingPointConfigPatternMatcher"><see cref="IConfigPatternMatcher"/></param>
+        /// <returns><see cref="SerializationConfig"/></returns>
+        public ClientConfig SetConfigPatternMatcher(IConfigPatternMatcher matchingPointConfigPatternMatcher)
         {
             _configPatternMatcher = matchingPointConfigPatternMatcher;
+            return this;
         }
 
+        /// <summary>
+        /// Sets <see cref="ICredentials"/> object.
+        /// </summary>
+        /// <param name="credentials"><see cref="ICredentials"/> to be set</param>
+        /// <returns><see cref="ClientConfig"/> for chaining</returns>
         public virtual ClientConfig SetCredentials(ICredentials credentials)
         {
             _credentials = credentials;
             return this;
         }
 
+        /// <summary>
+        /// Sets pool-size for internal ExecutorService which handles responses etc.
+        /// </summary>
+        /// <param name="executorPoolSize">executor pool size</param>
+        /// <returns><see cref="ClientConfig"/> for chaining</returns>
         public virtual ClientConfig SetExecutorPoolSize(int executorPoolSize)
         {
             _executorPoolSize = executorPoolSize;
             return this;
         }
 
+        /// <summary>
+        /// Sets <see cref="GroupConfig"/> object.
+        /// </summary>
+        /// <param name="groupConfig"><see cref="GroupConfig"/> to be set</param>
+        /// <returns><see cref="ClientConfig"/> for chaining</returns>
         public virtual ClientConfig SetGroupConfig(GroupConfig groupConfig)
         {
             _groupConfig = groupConfig;
             return this;
         }
 
+        /// <summary>
+        /// Sets <see cref="ListenerConfig"/> object.
+        /// </summary>
+        /// <param name="listenerConfigs"><see cref="ListenerConfig"/> to be set</param>
+        /// <returns><see cref="ClientConfig"/> for chaining</returns>
         public virtual ClientConfig SetListenerConfigs(IList<ListenerConfig> listenerConfigs)
         {
             _listenerConfigs = listenerConfigs;
             return this;
         }
 
+        /// <summary>
+        /// Sets <see cref="IManagedContext"/> object.
+        /// </summary>
+        /// <param name="managedContext"><see cref="IManagedContext"/></param>
+        /// <returns><see cref="ClientConfig"/> for chaining</returns>
         public virtual ClientConfig SetManagedContext(IManagedContext managedContext)
         {
             _managedContext = managedContext;
             return this;
         }
 
+        /// <summary>
+        /// Sets all near cache configs.
+        /// </summary>
+        /// <param name="nearCacheConfigMap">Dictionary of map-name to NearCacheConfig</param>
+        /// <returns><see cref="ClientConfig"/> for chaining</returns>
         public virtual ClientConfig SetNearCacheConfigMap(IDictionary<string, NearCacheConfig> nearCacheConfigMap)
         {
             _nearCacheConfigMap = nearCacheConfigMap;
             return this;
         }
 
-        public virtual void SetNetworkConfig(ClientNetworkConfig networkConfig)
+        /// <summary>
+        /// Sets <see cref="ClientNetworkConfig"/>.
+        /// </summary>
+        /// <param name="networkConfig"><see cref="ClientNetworkConfig"/></param>
+        /// <returns><see cref="ClientConfig"/> for chaining</returns>
+        public virtual ClientConfig SetNetworkConfig(ClientNetworkConfig networkConfig)
         {
             _networkConfig = networkConfig;
+            return this;
         }
 
+        /// <summary>
+        /// Sets <see cref="ProxyFactoryConfig"/>.
+        /// </summary>
+        /// <param name="proxyFactoryConfigs"><see cref="ProxyFactoryConfig"/></param>
+        /// <returns><see cref="ClientConfig"/> for chaining</returns>
         public virtual ClientConfig SetProxyFactoryConfigs(IList<ProxyFactoryConfig> proxyFactoryConfigs)
         {
             _proxyFactoryConfigs = proxyFactoryConfigs;
             return this;
         }
 
+        /// <summary>
+        /// Sets <see cref="SerializationConfig"/>.
+        /// </summary>
+        /// <param name="serializationConfig"><see cref="SerializationConfig"/></param>
+        /// <returns><see cref="ClientConfig"/> for chaining</returns>
         public virtual ClientConfig SetSerializationConfig(SerializationConfig serializationConfig)
         {
             _serializationConfig = serializationConfig;
diff --git a/Hazelcast.Net/Hazelcast.Config/ClientNetworkConfig.cs b/Hazelcast.Net/Hazelcast.Config/ClientNetworkConfig.cs
index 69b4820487..19c449ad37 100644
--- a/Hazelcast.Net/Hazelcast.Config/ClientNetworkConfig.cs
+++ b/Hazelcast.Net/Hazelcast.Config/ClientNetworkConfig.cs
@@ -16,6 +16,9 @@
 
 namespace Hazelcast.Config
 {
+    /// <summary>
+    /// Contains configuration parameters for client network related behavior
+    /// </summary>
     public class ClientNetworkConfig
     {
         /// <summary>List of the initial set of addresses.</summary>
@@ -76,12 +79,21 @@ public class ClientNetworkConfig
 
         private SSLConfig _sslConfig = new SSLConfig();
 
+        /// <summary>
+        /// Adds given addresses to the list of candidate addresses that client will use to establish initial connection.
+        /// </summary>
+        /// <param name="addresses"></param>
+        /// <returns><see cref="ClientNetworkConfig"/> for chaining</returns>
         public virtual ClientNetworkConfig AddAddress(params string[] addresses)
         {
             _addressList.AddRange(addresses);
             return this;
         }
 
+        /// <summary>
+        /// Returns the list of candidate addresses that client will use to establish initial connection
+        /// </summary>
+        /// <returns>list of addresses</returns>
         public virtual IList<string> GetAddresses()
         {
             if (_addressList.Count == 0)
@@ -91,49 +103,85 @@ public virtual IList<string> GetAddresses()
             return _addressList;
         }
 
+        /// <summary>
+        /// While client is trying to connect initially to one of the members in the configured address list,
+        /// all might be not available. Instead of giving up, throwing Exception and stopping client, it will
+        /// attempt to retry as much as connection attempt limit times.
+        /// </summary>
+        /// <returns>number of times to attempt to connect</returns>
         public virtual int GetConnectionAttemptLimit()
         {
             return _connectionAttemptLimit;
         }
 
+        /// <summary>
+        /// Gets the connection attempt period, in millis, for the next attempt to find a member to connect.
+        /// </summary>
+        /// <returns>connection attempt period in millis</returns>
         public virtual int GetConnectionAttemptPeriod()
         {
             return _connectionAttemptPeriod;
         }
 
+        /// <summary>
+        /// Gets connection timeout.
+        /// </summary>
+        /// <returns>connection timeout</returns>
         public virtual int GetConnectionTimeout()
         {
             return _connectionTimeout;
         }
 
+        /// <summary>
+        /// Gets <see cref="SocketInterceptorConfig"/>.
+        /// </summary>
+        /// <returns><see cref="SocketInterceptorConfig"/></returns>
         public virtual SocketInterceptorConfig GetSocketInterceptorConfig()
         {
             return _socketInterceptorConfig;
         }
 
+        /// <summary>
+        /// Gets <see cref="SocketOptions"/>.
+        /// </summary>
+        /// <returns><see cref="SocketOptions"/></returns>
         public virtual SocketOptions GetSocketOptions()
         {
             return _socketOptions;
         }
 
+        /// <summary>
+        /// Gets <see cref="SSLConfig"/>.
+        /// </summary>
+        /// <returns><see cref="SSLConfig"/></returns>
         public virtual SSLConfig GetSSLConfig()
         {
             return _sslConfig;
         }
 
+        /// <summary>
+        /// Specifies whether the redo operations are enabled or not.
+        /// </summary>
+        /// <returns></returns>
         public virtual bool IsRedoOperation()
         {
             return _redoOperation;
         }
 
-        /// <summary>Enabling ssl for client</summary>
-        //private SSLConfig sslConfig = null;
+        /// <summary>
+        /// Specifies whether the client is smart or not.
+        /// </summary>
+        /// <returns><c>true</c> if client is smart</returns>
         public virtual bool IsSmartRouting()
         {
             return _smartRouting;
         }
 
-        // required for spring module
+        /// <summary>
+        /// Sets all addresses
+        /// </summary>
+        /// <param name="addresses">list of addresses</param>
+        /// <returns><see cref="ClientNetworkConfig"/> for chaining</returns>
         public virtual ClientNetworkConfig SetAddresses(IList<string> addresses)
         {
             _addressList.Clear();
@@ -141,48 +189,98 @@ public virtual ClientNetworkConfig SetAddresses(IList<string> addresses)
             return this;
         }
 
+        /// <summary>
+        /// While client is trying to connect initially to one of the members in the configured address list,
+        /// all might be not available. Instead of giving up, throwing Exception and stopping client, it will
+        /// attempt to retry as much as connection attempt limit times.
+        /// </summary>
+        /// <param name="connectionAttemptLimit">
+        /// number of times to attempt to connect;
+        /// A zero value means try forever.
+        /// A negative value means default value
+        /// </param>
+        /// <returns><see cref="ClientNetworkConfig"/> for chaining</returns>
         public virtual ClientNetworkConfig SetConnectionAttemptLimit(int connectionAttemptLimit)
         {
             _connectionAttemptLimit = connectionAttemptLimit;
             return this;
         }
 
+        /// <summary>
+        /// Sets the connection attempt period, in millis, for the next attempt to find a member to connect..
+        /// </summary>
+        /// <param name="connectionAttemptPeriod">time to wait before another attempt in millis</param>
+        /// <returns><see cref="ClientNetworkConfig"/> for chaining</returns>
         public virtual ClientNetworkConfig SetConnectionAttemptPeriod(int connectionAttemptPeriod)
         {
             _connectionAttemptPeriod = connectionAttemptPeriod;
             return this;
         }
 
+        /// <summary>
+        /// Sets connection timeout
+        /// </summary>
+        /// <param name="connectionTimeout">connection timeout</param>
+        /// <returns><see cref="ClientNetworkConfig"/> for chaining</returns>
         public virtual ClientNetworkConfig SetConnectionTimeout(int connectionTimeout)
         {
             _connectionTimeout = connectionTimeout;
             return this;
         }
 
+        /// <summary>
+        /// If true, client will redo the operations that were executing on the server and client lost the connection.
+        /// This can be because of network, or simply because the member died. However it is not clear whether the
+        /// application is performed or not. For idempotent operations this is harmless, but for non-idempotent ones
+        /// retrying can cause to undesirable effects. Note that the redo can perform on any member.
+        /// If false, the operation will throw exception
+        /// </summary>
+        /// <param name="redoOperation">true if redo operations are enabled</param>
+        /// <returns><see cref="ClientNetworkConfig"/> for chaining</returns>
         public virtual ClientNetworkConfig SetRedoOperation(bool redoOperation)
         {
             _redoOperation = redoOperation;
             return this;
         }
 
+        /// <summary>
+        /// If true, client will route the key based operations to owner of the key at the best effort.
+        /// </summary>
+        /// <param name="smartRouting">true if smart routing should be enabled.</param>
+        /// <returns><see cref="ClientNetworkConfig"/> for chaining</returns>
         public virtual ClientNetworkConfig SetSmartRouting(bool smartRouting)
         {
             _smartRouting = smartRouting;
             return this;
         }
 
+        /// <summary>
+        /// Sets <see cref="SocketInterceptorConfig"/>
+        /// </summary>
+        /// <param name="socketInterceptorConfig"><see cref="SocketInterceptorConfig"/></param>
+        /// <returns><see cref="ClientNetworkConfig"/> for chaining</returns>
         public virtual ClientNetworkConfig SetSocketInterceptorConfig(SocketInterceptorConfig socketInterceptorConfig)
         {
             _socketInterceptorConfig = socketInterceptorConfig;
             return this;
         }
 
+        /// <summary>
+        /// Sets <see cref="SocketOptions"/>
+        /// </summary>
+        /// <param name="socketOptions"><see cref="SocketOptions"/></param>
+        /// <returns><see cref="ClientNetworkConfig"/> for chaining</returns>
         public virtual ClientNetworkConfig SetSocketOptions(SocketOptions socketOptions)
         {
             _socketOptions = socketOptions;
             return this;
         }
 
+        /// <summary>
+        /// Sets <see cref="SSLConfig"/>
+        /// </summary>
+        /// <param name="sslConfig"><see cref="SSLConfig"/></param>
+        /// <returns><see cref="ClientNetworkConfig"/> for chaining</returns>
         public virtual ClientNetworkConfig SetSSLConfig(SSLConfig sslConfig)
         {
             _sslConfig = sslConfig;
diff --git a/Hazelcast.Net/Hazelcast.Config/GlobalSerializerConfig.cs b/Hazelcast.Net/Hazelcast.Config/GlobalSerializerConfig.cs
index 80070d5757..eb35aa2caf 100644
--- a/Hazelcast.Net/Hazelcast.Config/GlobalSerializerConfig.cs
+++ b/Hazelcast.Net/Hazelcast.Config/GlobalSerializerConfig.cs
@@ -17,6 +17,9 @@
 
 namespace Hazelcast.Config
 {
+    /// <summary>
+    /// Contains the configuration for global serializer.
+    /// </summary>
     public class GlobalSerializerConfig
     {
         private string _className;
@@ -57,6 +60,7 @@ public bool GetOverrideClrSerialization()
             return _overrideClrSerialization;
         }
 
+        /// <inheritdoc />
         public override string ToString()
         {
             return string.Format("ClassName: {0}, Implementation: {1}, OverrideClrSerialization: {2}",
diff --git a/Hazelcast.Net/Hazelcast.Config/GroupConfig.cs b/Hazelcast.Net/Hazelcast.Config/GroupConfig.cs
index adc0a08be6..29f103a700 100644
--- a/Hazelcast.Net/Hazelcast.Config/GroupConfig.cs
+++ b/Hazelcast.Net/Hazelcast.Config/GroupConfig.cs
@@ -25,21 +25,27 @@ namespace Hazelcast.Config
     /// </remarks>
     public sealed class GroupConfig
     {
+        /// <summary>
+        /// Default group password.
+        /// </summary>
         public const string DefaultGroupPassword = "dev-pass";
 
+        /// <summary>
+        /// Default group name.
+        /// </summary>
         public const string DefaultGroupName = "dev";
 
         private string _name = DefaultGroupName;
 
         private string _password = DefaultGroupPassword;
 
-        /// <summary>Creates a GroupConfig with default group-name and group-password.</summary>
-        /// <remarks>Creates a GroupConfig with default group-name and group-password.</remarks>
+        /// <summary>Creates a <see cref="GroupConfig"/> with default group-name and group-password.</summary>
+        /// <remarks>Creates a <see cref="GroupConfig"/> with default group-name and group-password.</remarks>
         public GroupConfig()
         {
         }
 
-        /// <summary>Creates a GroupConfig with the given group-name and default group-password</summary>
+        /// <summary>Creates a <see cref="GroupConfig"/> with the given group-name and default group-password</summary>
         /// <param name="name">the name of the group</param>
         /// <exception cref="System.ArgumentException">if name is null.</exception>
         public GroupConfig(string name)
@@ -47,7 +53,7 @@ public GroupConfig(string name)
             SetName(name);
         }
 
-        /// <summary>Creates a GroupConfig with the given group-name and group-password</summary>
+        /// <summary>Creates a <see cref="GroupConfig"/> with the given group-name and group-password</summary>
         /// <param name="name">the name of the group</param>
         /// <param name="password">the password of the group</param>
         /// <exception cref="System.ArgumentException">if name or password is null.</exception>
@@ -57,6 +63,7 @@ public GroupConfig(string name, string password)
             SetPassword(password);
         }
 
+        /// <inheritdoc />
         public override bool Equals(object obj)
         {
             if (this == obj)
@@ -72,6 +79,7 @@ public override bool Equals(object obj)
                    (_password == null ? other._password == null : _password.Equals(other._password));
         }
 
+        /// <inheritdoc />
         public override int GetHashCode()
         {
             return (_name != null ? _name.GetHashCode() : 0) + 31*(_password != null ? _password.GetHashCode() : 0);
@@ -96,7 +104,7 @@ public string GetPassword()
         /// <summary>Sets the group name.</summary>
         /// <remarks>Sets the group name.</remarks>
         /// <param name="name">the name to set</param>
-        /// <returns>the updated GroupConfig.</returns>
+        /// <returns>the updated <see cref="GroupConfig"/>.</returns>
         /// <exception cref="System.ArgumentException">if name is null.</exception>
         public GroupConfig SetName(string name)
         {
@@ -107,7 +115,7 @@ public GroupConfig SetName(string name)
         /// <summary>Sets the password.</summary>
         /// <remarks>Sets the password.</remarks>
         /// <param name="password">the password to set</param>
-        /// <returns>the updated GroupConfig.</returns>
+        /// <returns>the updated <see cref="GroupConfig"/>.</returns>
         /// <exception cref="System.ArgumentException">if password is null.</exception>
         public GroupConfig SetPassword(string password)
         {
@@ -115,6 +123,7 @@ public GroupConfig SetPassword(string password)
             return this;
         }
 
+        /// <inheritdoc />
         public override string ToString()
         {
             var builder = new StringBuilder();
diff --git a/Hazelcast.Net/Hazelcast.Config/InMemoryFormat.cs b/Hazelcast.Net/Hazelcast.Config/InMemoryFormat.cs
index 17c110a6ba..f6c8244be2 100644
--- a/Hazelcast.Net/Hazelcast.Config/InMemoryFormat.cs
+++ b/Hazelcast.Net/Hazelcast.Config/InMemoryFormat.cs
@@ -17,8 +17,14 @@ namespace Hazelcast.Config
     /// <summary>Storage format type of values stored in cluster</summary>
     public enum InMemoryFormat
     {
+        /// <summary>
+        /// Binary format
+        /// </summary>
         Binary,
+
+        /// <summary>
+        /// Object data
+        /// </summary>
         Object
-        // Offheap
     }
 }
\ No newline at end of file
diff --git a/Hazelcast.Net/Hazelcast.Config/NearCacheConfig.cs b/Hazelcast.Net/Hazelcast.Config/NearCacheConfig.cs
index c59d1cef5e..29d4773f2c 100644
--- a/Hazelcast.Net/Hazelcast.Config/NearCacheConfig.cs
+++ b/Hazelcast.Net/Hazelcast.Config/NearCacheConfig.cs
@@ -17,6 +17,9 @@
 
 namespace Hazelcast.Config
 {
+    /// <summary>
+    /// Contains the configuration for a Near Cache.
+    /// </summary>
     public class NearCacheConfig
     {
         public const int DefaultTtlSeconds = 0;
@@ -26,8 +29,8 @@ public class NearCacheConfig
 
         public static readonly InMemoryFormat DefaultMemoryFormat = InMemoryFormat.Binary;
 
-        private bool _cacheLocalEntries;
         private string _evictionPolicy = DefaultEvictionPolicy;
+        private bool _cacheLocalEntries;
         private InMemoryFormat _inMemoryFormat = DefaultMemoryFormat;
         private bool _invalidateOnChange = true;
         private int _maxIdleSeconds = DefaultMaxIdleSeconds;
@@ -56,7 +59,6 @@ public NearCacheConfig(NearCacheConfig config)
             _maxIdleSeconds = config.GetMaxIdleSeconds();
             _maxSize = config.GetMaxSize();
             _timeToLiveSeconds = config.GetTimeToLiveSeconds();
-            _cacheLocalEntries = config.IsCacheLocalEntries();
         }
 
         public NearCacheConfig()
@@ -68,6 +70,10 @@ public NearCacheConfig(string name)
             _name = name;
         }
 
+        /// <summary>
+        /// Returns an immutable version of this configuration.
+        /// </summary>
+        /// <returns><see cref="NearCacheConfigReadOnly"/></returns>
         public virtual NearCacheConfigReadOnly GetAsReadOnly()
         {
             if (_readOnly == null)
@@ -77,101 +83,201 @@ public virtual NearCacheConfigReadOnly GetAsReadOnly()
             return _readOnly;
         }
 
+        /// <summary>
+        /// Returns the eviction policy for the Near Cache.
+        /// </summary>
+        /// <returns>eviction policy</returns>
         public virtual string GetEvictionPolicy()
         {
             return _evictionPolicy;
         }
 
+        /// <summary>
+        /// Returns <see cref="InMemoryFormat"/> 
+        /// </summary>
+        /// <returns><see cref="InMemoryFormat"/> </returns>
         public virtual InMemoryFormat GetInMemoryFormat()
         {
             return _inMemoryFormat;
         }
 
+        /// <summary>
+        /// Gets the maximum number of seconds each entry can stay in the Near Cache as untouched (not read).
+        /// </summary>
+        /// <remarks>
+        /// Entries that are untouched more than <c>maxIdleSeconds</c> value will get removed from the Near Cache.
+        /// </remarks>
+        /// <returns>maximum number of seconds each entry can stay in the Near Cache as untouched</returns>
         public virtual int GetMaxIdleSeconds()
         {
             return _maxIdleSeconds;
         }
 
+        /// <summary>
+        /// Returns the maximum size of the Near Cache.<br/>
+        /// When the maxSize is reached, the Near Cache is evicted based on the policy defined.
+        /// </summary>
+        /// <returns>the maximum size of the Near Cache</returns>
         public virtual int GetMaxSize()
         {
             return _maxSize;
         }
 
+        /// <summary>
+        /// Returns the name of the Near Cache
+        /// </summary>
+        /// <returns>the name of the Near Cache</returns>
         public virtual string GetName()
         {
             return _name;
         }
 
+        /// <summary>
+        /// Returns the maximum number of seconds for each entry to stay in the Near Cache (time to live).<br/>
+        /// Entries that are older than <c>timeToLiveSeconds</c> will automatically be evicted from the Near Cache.
+        /// </summary>
+        /// <returns>the maximum number of seconds for each entry to stay in the Near Cache</returns>
         public virtual int GetTimeToLiveSeconds()
         {
             return _timeToLiveSeconds;
         }
 
-        public virtual bool IsCacheLocalEntries()
-        {
-            return _cacheLocalEntries;
-        }
-
+        /// <summary>
+        /// Checks if Near Cache entries are invalidated when the entries in the backing data structure are changed
+        /// (updated or removed).
+        /// <br/>
+        /// When this setting is enabled, a Hazelcast instance with a Near Cache listens for cluster-wide changes
+        /// on the entries of the backing data structure and invalidates its corresponding Near Cache entries.
+        /// Changes done on the local Hazelcast instance always invalidate the Near Cache immediately.        
+        /// </summary>
+        /// <returns><c>true</c> if Near Cache invalidations are enabled on changes, <c>false</c> otherwise</returns>
         public virtual bool IsInvalidateOnChange()
         {
             return _invalidateOnChange;
         }
 
-        public virtual NearCacheConfig SetCacheLocalEntries(bool cacheLocalEntries)
-        {
-            _cacheLocalEntries = cacheLocalEntries;
-            return this;
-        }
-
+        /// <summary>
+        /// Sets the eviction policy.
+        /// Valid values are:
+        /// <ul>
+        /// <li><c>LRU</c> (Least Recently Used)</li>
+        /// <li><c>LFU</c> (Least Frequently Used)</li>
+        /// <li><c>NONE</c> (no extra eviction, time-to-live-seconds or max-idle-seconds may still apply)</li>
+        /// <li><c>RANDOM</c> (random entry)</li>
+        /// </ul>
+        /// </summary>
+        /// <param name="evictionPolicy">eviction policy.</param>
+        /// <returns>this Near Cache config instance</returns>
         public virtual NearCacheConfig SetEvictionPolicy(string evictionPolicy)
         {
             _evictionPolicy = evictionPolicy;
             return this;
         }
 
+        /// <summary>
+        /// Sets the data type used to store entries.
+        /// <br/>
+        /// Possible values:
+        /// <ul>
+        /// <li><c>BINARY</c>: keys and values are stored as binary data</li>
+        /// <li><c>OBJECT</c>: values are stored in their object forms</li>
+        /// <li><c>NATIVE</c>: keys and values are stored in native memory</li>
+        /// </ul>
+        /// The default value is <c>BINARY</c>.
+        /// </summary>
+        /// <param name="inMemoryFormat">the data type used to store entries</param>
+        /// <returns>this Near Cache config instance</returns>
         public virtual NearCacheConfig SetInMemoryFormat(InMemoryFormat inMemoryFormat)
         {
             _inMemoryFormat = inMemoryFormat;
             return this;
         }
 
-        // this setter is for reflection based configuration building
+        /// <summary>
+        /// <see cref="SetInMemoryFormat(Hazelcast.Config.InMemoryFormat)"/>
+        /// this setter is for reflection based configuration building
+        /// </summary>
         public virtual NearCacheConfig SetInMemoryFormat(string inMemoryFormat)
         {
             Enum.TryParse(inMemoryFormat, true, out _inMemoryFormat);
             return this;
         }
 
+        /// <summary>
+        /// Sets if Near Cache entries are invalidated when the entries in the backing data structure are changed
+        /// (updated or removed).
+        /// <br/>
+        /// When this setting is enabled, a Hazelcast instance with a Near Cache listens for cluster-wide changes
+        /// on the entries of the backing data structure and invalidates its corresponding Near Cache entries.
+        /// Changes done on the local Hazelcast instance always invalidate the Near Cache immediately.
+        /// </summary>
+        /// <param name="invalidateOnChange"></param>
+        /// <returns>this Near Cache config instance</returns>
         public virtual NearCacheConfig SetInvalidateOnChange(bool invalidateOnChange)
         {
             _invalidateOnChange = invalidateOnChange;
             return this;
         }
 
+        /// <summary>
+        /// Set the maximum number of seconds each entry can stay in the Near Cache as untouched (not read).
+        /// </summary>
+        /// <remarks>
+        /// Entries that are untouched (not read) more than <c>maxIdleSeconds</c> value will get removed from the Near Cache.
+        /// <br/>
+        /// Accepts any integer between <c>0</c> and <c>int.MaxValue</c>. The value <c>0</c> means <c>int.MaxValue</c>.
+        /// The default is <c>0</c>.
+        /// </remarks>
+        /// <param name="maxIdleSeconds"></param>
+        /// <returns>this Near Cache config instance</returns>
         public virtual NearCacheConfig SetMaxIdleSeconds(int maxIdleSeconds)
         {
             _maxIdleSeconds = maxIdleSeconds;
             return this;
         }
-
+        /// <summary>
+        /// Sets the maximum size of the Near Cache. 
+        /// When the maxSize is reached, the Near Cache is evicted based on the policy defined.
+        /// <br/>
+        /// Accepts any integer between <c>0</c> and <c>int.MaxValue</c>. The value <c>0</c> means <c>int.MaxValue</c>.
+        /// The default is <c>0</c>.
+        /// </summary>
+        /// <param name="maxSize">the maximum size of the Near Cache</param>
+        /// <returns>this Near Cache config instance</returns>
         public virtual NearCacheConfig SetMaxSize(int maxSize)
         {
             _maxSize = maxSize;
             return this;
         }
 
+        /// <summary>
+        /// Sets the name of the Near Cache.
+        /// </summary>
+        /// <param name="name">the name of the Near Cache</param>
+        /// <returns>this Near Cache config instance</returns>
         public virtual NearCacheConfig SetName(string name)
         {
             _name = name;
             return this;
         }
 
+        /// <summary>
+        /// Returns the maximum number of seconds for each entry to stay in the Near Cache (time to live).
+        /// <br/>
+        /// Entries that are older than {@code timeToLiveSeconds} will automatically be evicted from the Near Cache.
+        /// <br/>
+        /// Accepts any integer between <c>0</c> and <c>int.MaxValue</c>. The value <c>0</c> means <c>int.MaxValue</c>.
+        /// The default is <c>0</c>.
+        /// </summary>
+        /// <param name="timeToLiveSeconds">the maximum number of seconds for each entry to stay in the Near Cache</param>
+        /// <returns>this Near Cache config instance</returns>
         public virtual NearCacheConfig SetTimeToLiveSeconds(int timeToLiveSeconds)
         {
             _timeToLiveSeconds = timeToLiveSeconds;
             return this;
         }
 
+        /// <inheritdoc />
         public override string ToString()
         {
             var sb = new StringBuilder("NearCacheConfig{");
@@ -181,9 +287,23 @@ public override string ToString()
             sb.Append(", maxIdleSeconds=").Append(_maxIdleSeconds);
             sb.Append(", invalidateOnChange=").Append(_invalidateOnChange);
             sb.Append(", inMemoryFormat=").Append(_inMemoryFormat);
-            sb.Append(", cacheLocalEntries=").Append(_cacheLocalEntries);
-            sb.Append('}');
             return sb.ToString();
         }
+
+#pragma warning disable CS1591
+        [Obsolete("This configuration is not used on client")]
+        public virtual bool IsCacheLocalEntries()
+        {
+            return _cacheLocalEntries;
+        }
+
+        [Obsolete("This configuration is not used on client")]
+        public virtual NearCacheConfig SetCacheLocalEntries(bool cacheLocalEntries)
+        {
+            _cacheLocalEntries = cacheLocalEntries;
+            return this;
+        }
+#pragma warning restore
+
     }
 }
\ No newline at end of file
diff --git a/Hazelcast.Net/Hazelcast.Config/NearCacheConfigReadOnly.cs b/Hazelcast.Net/Hazelcast.Config/NearCacheConfigReadOnly.cs
index 9545e9f540..9d16c48c2f 100644
--- a/Hazelcast.Net/Hazelcast.Config/NearCacheConfigReadOnly.cs
+++ b/Hazelcast.Net/Hazelcast.Config/NearCacheConfigReadOnly.cs
@@ -16,47 +16,83 @@
 
 namespace Hazelcast.Config
 {
+    /// <summary>
+    /// Readonly version of <see cref="NearCacheConfig"/>
+    /// </summary>
     public class NearCacheConfigReadOnly : NearCacheConfig
     {
+
         public NearCacheConfigReadOnly(NearCacheConfig config) : base(config)
         {
         }
 
+        /// <summary>
+        /// Not supported function in readonly config, throws <exception cref="NotSupportedException"></exception>
+        /// </summary>
+        /// <exception cref="NotSupportedException"></exception>
         public override NearCacheConfig SetEvictionPolicy(string evictionPolicy)
         {
             throw new NotSupportedException("This config is read-only");
         }
 
+        /// <summary>
+        /// Not supported function in readonly config, throws <exception cref="NotSupportedException"></exception>
+        /// </summary>
+        /// <exception cref="NotSupportedException"></exception>
         public override NearCacheConfig SetInMemoryFormat(InMemoryFormat inMemoryFormat)
         {
             throw new NotSupportedException("This config is read-only");
         }
 
+        /// <summary>
+        /// Not supported function in readonly config, throws <exception cref="NotSupportedException"></exception>
+        /// </summary>
+        /// <exception cref="NotSupportedException"></exception>
         public override NearCacheConfig SetInMemoryFormat(string inMemoryFormat)
         {
             throw new NotSupportedException("This config is read-only");
         }
 
+        /// <summary>
+        /// Not supported function in readonly config, throws <exception cref="NotSupportedException"></exception>
+        /// </summary>
+        /// <exception cref="NotSupportedException"></exception>
         public override NearCacheConfig SetInvalidateOnChange(bool invalidateOnChange)
         {
             throw new NotSupportedException("This config is read-only");
         }
 
+        /// <summary>
+        /// Not supported function in readonly config, throws <exception cref="NotSupportedException"></exception>
+        /// </summary>
+        /// <exception cref="NotSupportedException"></exception>
         public override NearCacheConfig SetMaxIdleSeconds(int maxIdleSeconds)
         {
             throw new NotSupportedException("This config is read-only");
         }
 
+        /// <summary>
+        /// Not supported function in readonly config, throws <exception cref="NotSupportedException"></exception>
+        /// </summary>
+        /// <exception cref="NotSupportedException"></exception>
         public override NearCacheConfig SetMaxSize(int maxSize)
         {
             throw new NotSupportedException("This config is read-only");
         }
 
+        /// <summary>
+        /// Not supported function in readonly config, throws <exception cref="NotSupportedException"></exception>
+        /// </summary>
+        /// <exception cref="NotSupportedException"></exception>
         public override NearCacheConfig SetName(string name)
         {
             throw new NotSupportedException("This config is read-only");
         }
 
+        /// <summary>
+        /// Not supported function in readonly config, throws <exception cref="NotSupportedException"></exception>
+        /// </summary>
+        /// <exception cref="NotSupportedException"></exception>
         public override NearCacheConfig SetTimeToLiveSeconds(int timeToLiveSeconds)
         {
             throw new NotSupportedException("This config is read-only");
diff --git a/Hazelcast.Net/Hazelcast.Config/ProxyFactoryConfig.cs b/Hazelcast.Net/Hazelcast.Config/ProxyFactoryConfig.cs
index 62165b4cbd..77ab0342ad 100644
--- a/Hazelcast.Net/Hazelcast.Config/ProxyFactoryConfig.cs
+++ b/Hazelcast.Net/Hazelcast.Config/ProxyFactoryConfig.cs
@@ -14,6 +14,9 @@
 
 namespace Hazelcast.Config
 {
+    /// <summary>
+    /// This class is related to SPI; it is used to register custom services to client.
+    /// </summary>
     public class ProxyFactoryConfig
     {
         private string _className;
@@ -29,21 +32,37 @@ public ProxyFactoryConfig(string className, string service)
             _service = service;
         }
 
+        /// <summary>
+        /// Gets class name of proxy factory
+        /// </summary>
+        /// <returns>class name of proxy factory</returns>
         public virtual string GetClassName()
         {
             return _className;
         }
 
+        /// <summary>
+        /// Gets service name of related proxy factory
+        /// </summary>
+        /// <returns>service name of related proxy factory</returns>
         public virtual string GetService()
         {
             return _service;
         }
 
+        /// <summary>
+        /// Sets class name of proxy factory
+        /// </summary>
+        /// <param name="className">class name of proxy factory</param>
         public virtual void SetClassName(string className)
         {
             _className = className;
         }
 
+        /// <summary>
+        /// Sets service name of related proxy factory
+        /// </summary>
+        /// <param name="service">service name of related proxy factory</param>
         public virtual void SetService(string service)
         {
             _service = service;
diff --git a/Hazelcast.Net/Hazelcast.Config/SSLConfig.cs b/Hazelcast.Net/Hazelcast.Config/SSLConfig.cs
index 22dc700d8e..77af489927 100644
--- a/Hazelcast.Net/Hazelcast.Config/SSLConfig.cs
+++ b/Hazelcast.Net/Hazelcast.Config/SSLConfig.cs
@@ -79,6 +79,7 @@ internal string GetCertificateName()
             return GetProperty(CertificateName);
         }
 
+        /// <inheritdoc />
         public override string ToString()
         {
             var sb = new StringBuilder();
diff --git a/Hazelcast.Net/Hazelcast.Config/SerializationConfig.cs b/Hazelcast.Net/Hazelcast.Config/SerializationConfig.cs
index 96cf9f20e4..8c36478fe2 100644
--- a/Hazelcast.Net/Hazelcast.Config/SerializationConfig.cs
+++ b/Hazelcast.Net/Hazelcast.Config/SerializationConfig.cs
@@ -21,6 +21,12 @@
 
 namespace Hazelcast.Config
 {
+    /// <summary>
+    /// Contains the serialization configuration
+    /// </summary>
+    /// <remarks>
+    /// <see cref="IIdentifiedDataSerializable"/>, <see cref="IPortable"/>, custom serializers, and global serializer can be configured using this config. 
+    /// </remarks>
     public class SerializationConfig
     {
         private ByteOrder _byteOrder = ByteOrder.BigEndian;
@@ -41,6 +47,11 @@ public class SerializationConfig
 
         private bool _useNativeByteOrder;
 
+        /// <summary>
+        /// Adds a <see cref="IPortable"/> class definition to be registered
+        /// </summary>
+        /// <param name="classDefinition"><see cref="IPortable"/> class definition</param>
+        /// <returns>configured <see cref="SerializationConfig"/> for chaining</returns>
         public virtual SerializationConfig AddClassDefinition(IClassDefinition classDefinition)
         {
             if (GetClassDefinitions().Contains(classDefinition))
@@ -52,6 +63,12 @@ public virtual SerializationConfig AddClassDefinition(IClassDefinition classDefi
             return this;
         }
 
+        /// <summary>
+        /// Adds a <see cref="IDataSerializableFactory"/> mapped with a factory id to be registered
+        /// </summary>
+        /// <param name="factoryId">factory ID of <see cref="IDataSerializableFactory"/> to be registered</param>
+        /// <param name="dataSerializableFactory"><see cref="IDataSerializableFactory"/>object to be registered</param>
+        /// <returns>configured <see cref="SerializationConfig"/> for chaining</returns>
         public virtual SerializationConfig AddDataSerializableFactory(int factoryId,
             IDataSerializableFactory dataSerializableFactory)
         {
@@ -59,6 +76,12 @@ public virtual SerializationConfig AddDataSerializableFactory(int factoryId,
             return this;
         }
 
+        /// <summary>
+        /// Adds a <see cref="IDataSerializableFactory"/> mapped with a factory id to be registered
+        /// </summary>
+        /// <param name="factoryId">factory ID of <see cref="IDataSerializableFactory"/> to be registered</param>
+        /// <param name="dataSerializableFactoryClass">class name of the factory</param>
+        /// <returns>configured <see cref="SerializationConfig"/> for chaining</returns>
         public virtual SerializationConfig AddDataSerializableFactoryClass(int factoryId,
             string dataSerializableFactoryClass)
         {
@@ -67,6 +90,12 @@ public virtual SerializationConfig AddDataSerializableFactoryClass(int factoryId
             return this;
         }
 
+        /// <summary>
+        /// Adds a <see cref="IDataSerializableFactory"/> mapped with a factory id to be registered
+        /// </summary>
+        /// <param name="factoryId">factory ID of <see cref="IDataSerializableFactory"/> to be registered</param>
+        /// <param name="dataSerializableFactoryClass">Type of the factory</param>
+        /// <returns>configured <see cref="SerializationConfig"/> for chaining</returns>
         public virtual SerializationConfig AddDataSerializableFactoryClass(int factoryId,
             Type dataSerializableFactoryClass)
         {
@@ -76,12 +105,24 @@ public virtual SerializationConfig AddDataSerializableFactoryClass(int factoryId
             return AddDataSerializableFactoryClass(factoryId, factoryClassName);
         }
 
+        /// <summary>
+        /// Adds a <see cref="IPortableFactory"/> mapped with a factory id to be registered
+        /// </summary>
+        /// <param name="factoryId">factory ID of <see cref="IPortableFactory"/> to be registered</param>
+        /// <param name="portableFactory">factory instance to be registered</param>
+        /// <returns>configured <see cref="SerializationConfig"/> for chaining</returns>
         public virtual SerializationConfig AddPortableFactory(int factoryId, IPortableFactory portableFactory)
         {
             GetPortableFactories().Add(factoryId, portableFactory);
             return this;
         }
 
+        /// <summary>
+        /// Adds a <see cref="IPortableFactory"/> mapped with a factory id to be registered
+        /// </summary>
+        /// <param name="factoryId">factory ID of <see cref="IPortableFactory"/> to be registered</param>
+        /// <param name="portableFactoryClass">Type of the factory</param>
+        /// <returns>configured <see cref="SerializationConfig"/> for chaining</returns>
         public virtual SerializationConfig AddPortableFactoryClass(int factoryId, Type portableFactoryClass)
         {
             var portableFactoryClassName =
@@ -89,23 +130,42 @@ public virtual SerializationConfig AddPortableFactoryClass(int factoryId, Type p
             return AddPortableFactoryClass(factoryId, portableFactoryClassName);
         }
 
+        /// <summary>
+        /// Adds a <see cref="IPortableFactory"/> mapped with a factory id to be registered
+        /// </summary>
+        /// <param name="factoryId">factory ID of <see cref="IPortableFactory"/> to be registered</param>
+        /// <param name="portableFactoryClass">class name of the factory</param>
+        /// <returns>configured <see cref="SerializationConfig"/> for chaining</returns>
         public virtual SerializationConfig AddPortableFactoryClass(int factoryId, string portableFactoryClass)
         {
             GetPortableFactoryClasses().Add(factoryId, portableFactoryClass);
             return this;
         }
 
+        /// <summary>
+        /// Adds a <see cref="SerializationConfig"/>
+        /// </summary>
+        /// <param name="serializerConfig"><see cref="SerializationConfig"/></param>
+        /// <returns>configured <see cref="SerializationConfig"/> for chaining</returns>
         public virtual SerializationConfig AddSerializerConfig(SerializerConfig serializerConfig)
         {
             GetSerializerConfigs().Add(serializerConfig);
             return this;
         }
 
+        /// <summary>
+        /// Gets the configured <see cref="ByteOrder"/>
+        /// </summary>
+        /// <returns><see cref="ByteOrder"/></returns>
         public virtual ByteOrder GetByteOrder()
         {
             return _byteOrder;
         }
 
+        /// <summary>
+        /// Gets all registered <see cref="IClassDefinition"/>s
+        /// </summary>
+        /// <returns>collection of <see cref="IClassDefinition"/></returns>
         public virtual ICollection<IClassDefinition> GetClassDefinitions()
         {
             if (_classDefinitions == null)
@@ -115,6 +175,10 @@ public virtual ICollection<IClassDefinition> GetClassDefinitions()
             return _classDefinitions;
         }
 
+        /// <summary>
+        /// Gets the dictionary of factoryId to <see cref="IDataSerializableFactory"/> mapping
+        /// </summary>
+        /// <returns>dictionary of <see cref="IDataSerializableFactory"/></returns>
         public virtual IDictionary<int, IDataSerializableFactory> GetDataSerializableFactories()
         {
             if (_dataSerializableFactories == null)
@@ -124,6 +188,10 @@ public virtual IDictionary<int, IDataSerializableFactory> GetDataSerializableFac
             return _dataSerializableFactories;
         }
 
+        /// <summary>
+        /// Gets the dictionary of factoryId to <see cref="IDataSerializableFactory"/> class names mapping
+        /// </summary>
+        /// <returns>dictionary of factory ID and corresponding IDataSerializableFactory names</returns>
         public virtual IDictionary<int, string> GetDataSerializableFactoryClasses()
         {
             if (_dataSerializableFactoryClasses == null)
@@ -133,11 +201,19 @@ public virtual IDictionary<int, string> GetDataSerializableFactoryClasses()
             return _dataSerializableFactoryClasses;
         }
 
+        /// <summary>
+        /// Gets <see cref="GlobalSerializerConfig"/>
+        /// </summary>
+        /// <returns><see cref="GlobalSerializerConfig"/></returns>
         public virtual GlobalSerializerConfig GetGlobalSerializerConfig()
         {
             return _globalSerializerConfig;
         }
 
+        /// <summary>
+        /// Gets the dictionary of factoryId to <see cref="IPortableFactory"/> mapping
+        /// </summary>
+        /// <returns>dictionary of <see cref="IPortableFactory"/></returns>
         public virtual IDictionary<int, IPortableFactory> GetPortableFactories()
         {
             if (_portableFactories == null)
@@ -147,6 +223,10 @@ public virtual IDictionary<int, IPortableFactory> GetPortableFactories()
             return _portableFactories;
         }
 
+        /// <summary>
+        /// Gets the dictionary of factoryId to <see cref="IPortableFactory"/> class names mapping
+        /// </summary>
+        /// <returns>dictionary of factory ID and corresponding portable factory names</returns>
         public virtual IDictionary<int, string> GetPortableFactoryClasses()
         {
             if (_portableFactoryClasses == null)
@@ -156,11 +236,20 @@ public virtual IDictionary<int, string> GetPortableFactoryClasses()
             return _portableFactoryClasses;
         }
 
+        /// <summary>
+        /// Gets the configured Portable version that will be used to differentiate two versions of the same class 
+        /// that have changes on the class, like adding/removing a field or changing a type of a field.
+        /// </summary>
+        /// <returns>version of portable classes</returns>
         public virtual int GetPortableVersion()
         {
             return _portableVersion;
         }
 
+        /// <summary>
+        /// Gets all <see cref="SerializationConfig"/>s
+        /// </summary>
+        /// <returns>collection of <see cref="SerializerConfig"/></returns>
         public virtual ICollection<SerializerConfig> GetSerializerConfigs()
         {
             if (_serializerConfigs == null)
@@ -170,44 +259,84 @@ public virtual ICollection<SerializerConfig> GetSerializerConfigs()
             return _serializerConfigs;
         }
 
+        /// <summary>
+        /// When enabled, serialization system will check for class definitions error at start 
+        /// and throw an Serialization Exception with error definition or not.
+        /// <br/>
+        /// Default value is <c>true</c>
+        /// </summary>
+        /// <returns><c>true</c> if enables <c>false</c> otherwise</returns>
         public virtual bool IsCheckClassDefErrors()
         {
             return _checkClassDefErrors;
         }
 
+        /// <summary>
+        /// Not used
+        /// </summary>
+        [Obsolete("This configuration is not used in .net client")]
         public virtual bool IsEnableCompression()
         {
             return _enableCompression;
         }
 
+        /// <summary>
+        /// Not used
+        /// </summary>
+        [Obsolete("This configuration is not used in .net client")]
         public virtual bool IsEnableSharedObject()
         {
             return _enableSharedObject;
         }
 
+        /// <summary>
+        /// 
+        /// </summary>
+        /// <returns><c>true</c> if serialization is configured to use native byte order of the underlying platform</returns>
         public virtual bool IsUseNativeByteOrder()
         {
             return _useNativeByteOrder;
         }
 
+        /// <summary>
+        /// Sets the serialization's <see cref="ByteOrder"/>
+        /// </summary>
+        /// <param name="byteOrder">the <see cref="ByteOrder"/> that serialization will use</param>
+        /// <returns>configured <see cref="SerializationConfig"/> for chaining</returns>
         public virtual SerializationConfig SetByteOrder(ByteOrder byteOrder)
         {
             _byteOrder = byteOrder;
             return this;
         }
 
+        /// <summary>
+        /// When enabled, serialization system will check for class definitions error at start 
+        /// and throw an Serialization Exception with error definition or not.
+        /// </summary>
+        /// <param name="checkClassDefErrors">set to <c>false</c> to disable</param>
+        /// <returns>configured <see cref="SerializationConfig"/> for chaining</returns>
         public virtual SerializationConfig SetCheckClassDefErrors(bool checkClassDefErrors)
         {
             _checkClassDefErrors = checkClassDefErrors;
             return this;
         }
 
+        /// <summary>
+        /// Sets all <see cref="IClassDefinition"/>s
+        /// </summary>
+        /// <param name="classDefinitions">collection of <see cref="IClassDefinition"/>s</param>
+        /// <returns>configured <see cref="SerializationConfig"/> for chaining</returns>
         public virtual SerializationConfig SetClassDefinitions(ICollection<IClassDefinition> classDefinitions)
         {
             _classDefinitions = classDefinitions;
             return this;
         }
 
+        /// <summary>
+        /// Sets the dictionary of factory ID and corresponding <see cref="IDataSerializableFactory"/>s
+        /// </summary>
+        /// <param name="dataSerializableFactories">dictionary of factory ID and corresponding <see cref="IDataSerializableFactory"/>s</param>
+        /// <returns>configured <see cref="SerializationConfig"/> for chaining</returns>
         public virtual SerializationConfig SetDataSerializableFactories(
             IDictionary<int, IDataSerializableFactory> dataSerializableFactories)
         {
@@ -215,6 +344,11 @@ public virtual SerializationConfig SetDataSerializableFactories(
             return this;
         }
 
+        /// <summary>
+        /// Sets the dictionary of factory ID and corresponding factory class names
+        /// </summary>
+        /// <param name="dataSerializableFactoryClasses">dictionary of factory ID and corresponding factory class names</param>
+        /// <returns>configured <see cref="SerializationConfig"/> for chaining</returns>
         public virtual SerializationConfig SetDataSerializableFactoryClasses(
             IDictionary<int, string> dataSerializableFactoryClasses)
         {
@@ -222,36 +356,67 @@ public virtual SerializationConfig SetDataSerializableFactoryClasses(
             return this;
         }
 
+        /// <summary>
+        /// Not used
+        /// </summary>
+        /// <returns>configured <see cref="SerializationConfig"/> for chaining</returns>
+        [Obsolete("This configuration is not used in .net client")]
         public virtual SerializationConfig SetEnableCompression(bool enableCompression)
         {
             _enableCompression = enableCompression;
             return this;
         }
 
+        /// <summary>
+        /// Not used
+        /// </summary>
+        /// <returns>configured <see cref="SerializationConfig"/> for chaining</returns>
+        [Obsolete("This configuration is not used in .net client")]
         public virtual SerializationConfig SetEnableSharedObject(bool enableSharedObject)
         {
             _enableSharedObject = enableSharedObject;
             return this;
         }
 
+        /// <summary>
+        /// Sets <see cref="GlobalSerializerConfig"/>
+        /// </summary>
+        /// <param name="globalSerializerConfig"><see cref="GlobalSerializerConfig"/></param>
+        /// <returns>configured <see cref="SerializationConfig"/> for chaining</returns>
         public virtual SerializationConfig SetGlobalSerializerConfig(GlobalSerializerConfig globalSerializerConfig)
         {
             _globalSerializerConfig = globalSerializerConfig;
             return this;
         }
 
+        /// <summary>
+        /// Sets the dictionary of factory ID and corresponding <see cref="IPortableFactory"/>s
+        /// </summary>
+        /// <param name="portableFactories">dictionary of factory ID and corresponding <see cref="IPortableFactory"/>s</param>
+        /// <returns>configured <see cref="SerializationConfig"/> for chaining</returns>
         public virtual SerializationConfig SetPortableFactories(IDictionary<int, IPortableFactory> portableFactories)
         {
             _portableFactories = portableFactories;
             return this;
         }
 
+        /// <summary>
+        /// Sets the dictionary of factory ID and corresponding factory class names
+        /// </summary>
+        /// <param name="portableFactoryClasses">dictionary of factory ID and corresponding factory class names</param>
+        /// <returns>configured <see cref="SerializationConfig"/> for chaining</returns>
         public virtual SerializationConfig SetPortableFactoryClasses(IDictionary<int, string> portableFactoryClasses)
         {
             _portableFactoryClasses = portableFactoryClasses;
             return this;
         }
 
+        /// <summary>
+        /// Sets the version of portable classes
+        /// </summary>
+        /// <param name="portableVersion">version of portable classes</param>
+        /// <returns>configured <see cref="SerializationConfig"/> for chaining</returns>
+        /// <exception cref="ArgumentException">if portableVersion is less than 0</exception>
         public virtual SerializationConfig SetPortableVersion(int portableVersion)
         {
             if (portableVersion < 0)
@@ -262,18 +427,29 @@ public virtual SerializationConfig SetPortableVersion(int portableVersion)
             return this;
         }
 
+        /// <summary>
+        /// Sets all <see cref="SerializationConfig"/>s
+        /// </summary>
+        /// <param name="serializerConfigs">collection of <see cref="SerializationConfig"/>s</param>
+        /// <returns>configured <see cref="SerializationConfig"/> for chaining</returns>
         public virtual SerializationConfig SetSerializerConfigs(ICollection<SerializerConfig> serializerConfigs)
         {
             _serializerConfigs = serializerConfigs;
             return this;
         }
 
+        /// <summary>
+        /// Sets to use native byte order of the underlying platform
+        /// </summary>
+        /// <param name="useNativeByteOrder">set to <c>true</c> to use native byte order of the underlying platform</param>
+        /// <returns>configured <see cref="SerializationConfig"/> for chaining</returns>
         public virtual SerializationConfig SetUseNativeByteOrder(bool useNativeByteOrder)
         {
             _useNativeByteOrder = useNativeByteOrder;
             return this;
         }
 
+        /// <inheritdoc />
         public override string ToString()
         {
             var sb = new StringBuilder("SerializationConfig{");
diff --git a/Hazelcast.Net/Hazelcast.Config/SerializerConfig.cs b/Hazelcast.Net/Hazelcast.Config/SerializerConfig.cs
index e28f51a5b6..5e06f9dfef 100644
--- a/Hazelcast.Net/Hazelcast.Config/SerializerConfig.cs
+++ b/Hazelcast.Net/Hazelcast.Config/SerializerConfig.cs
@@ -18,6 +18,9 @@
 
 namespace Hazelcast.Config
 {
+    /// <summary>
+    /// Contains the serialization configuration for a particular class.
+    /// </summary>
     public class SerializerConfig
     {
         private string _className;
@@ -82,6 +85,7 @@ public virtual SerializerConfig SetTypeClassName(string typeClassName)
             return this;
         }
 
+        /// <inheritdoc />
         public override string ToString()
         {
             var sb = new StringBuilder("SerializerConfig{");
diff --git a/Hazelcast.Net/Hazelcast.Config/SocketInterceptorConfig.cs b/Hazelcast.Net/Hazelcast.Config/SocketInterceptorConfig.cs
index fed9d09a2c..82dc8be3e7 100644
--- a/Hazelcast.Net/Hazelcast.Config/SocketInterceptorConfig.cs
+++ b/Hazelcast.Net/Hazelcast.Config/SocketInterceptorConfig.cs
@@ -19,6 +19,9 @@
 
 namespace Hazelcast.Config
 {
+    /// <summary>
+    /// Contains the configuration for interceptor socket.
+    /// </summary>
     public class SocketInterceptorConfig
     {
         private string _className;
@@ -142,6 +145,7 @@ public virtual SocketInterceptorConfig SetProperty(string name, string value)
             return this;
         }
 
+        /// <inheritdoc />
         public override string ToString()
         {
             var sb = new StringBuilder();
diff --git a/Hazelcast.Net/Hazelcast.Config/SocketOptions.cs b/Hazelcast.Net/Hazelcast.Config/SocketOptions.cs
index a39a15cbe1..04f296fd6c 100644
--- a/Hazelcast.Net/Hazelcast.Config/SocketOptions.cs
+++ b/Hazelcast.Net/Hazelcast.Config/SocketOptions.cs
@@ -12,10 +12,14 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
+using System;
 using Hazelcast.Client.Connection;
 
 namespace Hazelcast.Config
 {
+    /// <summary>
+    /// TCP Socket options
+    /// </summary>
     public class SocketOptions
     {
         private int _bufferSize = 32;
@@ -38,6 +42,7 @@ public virtual int GetLingerSeconds()
             return _lingerSeconds;
         }
 
+        [Obsolete("This configuration is not used.")]
         public virtual ISocketFactory GetSocketFactory()
         {
             return _socketFactory;
@@ -89,6 +94,7 @@ public virtual SocketOptions SetReuseAddress(bool reuseAddress)
             return this;
         }
 
+        [Obsolete("This configuration is not used.")]
         public virtual SocketOptions SetSocketFactory(ISocketFactory socketFactory)
         {
             _socketFactory = socketFactory;
diff --git a/Hazelcast.Net/Hazelcast.Config/XmlClientConfigBuilder.cs b/Hazelcast.Net/Hazelcast.Config/XmlClientConfigBuilder.cs
index c8db8b1fe6..11bbe2451a 100644
--- a/Hazelcast.Net/Hazelcast.Config/XmlClientConfigBuilder.cs
+++ b/Hazelcast.Net/Hazelcast.Config/XmlClientConfigBuilder.cs
@@ -22,6 +22,9 @@
 
 namespace Hazelcast.Config
 {
+    /// <summary>
+    /// Loads the <see cref="ClientConfig"/> using XML.
+    /// </summary>
     public class XmlClientConfigBuilder : AbstractXmlConfigHelper
     {
         private static readonly ILogger Logger = Logging.Logger.GetLogger(typeof (XmlClientConfigBuilder));
@@ -96,16 +99,30 @@ private XmlClientConfigBuilder(string configFile = null)
             }
         }
 
+        /// <summary>
+        /// Build a <see cref="ClientConfig"/> from an XML file
+        /// </summary>
+        /// <param name="configFile">hazelcast client XML config file</param>
+        /// <returns>ClientConfig</returns>
         public static ClientConfig Build(string configFile = null)
         {
             return new XmlClientConfigBuilder(configFile).Init();
         }
 
+        /// <summary>
+        /// Build a <see cref="ClientConfig"/> from an XML file
+        /// </summary>
+        /// <param name="reader">Text reader to provide hazelcast client XML</param>
+        /// <returns>ClientConfig</returns>
         public static ClientConfig Build(TextReader reader)
         {
             return new XmlClientConfigBuilder(reader).Init();
         }
 
+        /// <summary>
+        /// Creates a <see cref="ClientConfig"/> using the XML content 
+        /// </summary>
+        /// <returns></returns>
         protected ClientConfig Init()
         {
             _clientConfig = new ClientConfig();
diff --git a/Hazelcast.Net/Hazelcast.Core/IMap.cs b/Hazelcast.Net/Hazelcast.Core/IMap.cs
index a2d8911360..e860029682 100644
--- a/Hazelcast.Net/Hazelcast.Core/IMap.cs
+++ b/Hazelcast.Net/Hazelcast.Core/IMap.cs
@@ -926,13 +926,13 @@ public interface IMap<TKey, TValue> : IDistributedObject
         TValue PutIfAbsent(TKey key, TValue value, long ttl, TimeUnit timeunit);
 
         /// <summary>
-        ///     Same as <see cref="IMap{K, V}.Put(TKey, TValue, long, TimeUnit)" />
+        ///     Same as <see cref="IMap{TKey, TValue}.Put(TKey, TValue, long, TimeUnit)" />
         ///     but MapStore, if defined,
         ///     will not be called to store/persist the entry.  If ttl is 0, then
         ///     the entry lives forever.
         /// </summary>
         /// <remarks>
-        ///     Same as <see cref="IMap{K, V}.Put(TKey, TValue, long, TimeUnit)" />
+        ///     Same as <see cref="IMap{TKey, TValue}.Put(TKey, TValue, long, TimeUnit)" />
         ///     but MapStore, if defined,
         ///     will not be called to store/persist the entry.  If ttl is 0, then
         ///     the entry lives forever.
diff --git a/Hazelcast.Test/Hazelcast.Client.Test/AggregatorAndProjectionTest.cs b/Hazelcast.Test/Hazelcast.Client.Test/AggregatorAndProjectionTest.cs
index e8b076cf89..cc164c42c0 100644
--- a/Hazelcast.Test/Hazelcast.Client.Test/AggregatorAndProjectionTest.cs
+++ b/Hazelcast.Test/Hazelcast.Client.Test/AggregatorAndProjectionTest.cs
@@ -24,6 +24,7 @@
 namespace Hazelcast.Client.Test
 {
     [TestFixture]
+    [Category("3.8")]
     public class AggregatorAndProjectionTest : SingleMemberBaseTest
     {
         internal static IMap<object, object> map;
diff --git a/Hazelcast.Test/Hazelcast.Client.Test/ClientMapTest.cs b/Hazelcast.Test/Hazelcast.Client.Test/ClientMapTest.cs
index 58d8b8b741..874a1d9d21 100644
--- a/Hazelcast.Test/Hazelcast.Client.Test/ClientMapTest.cs
+++ b/Hazelcast.Test/Hazelcast.Client.Test/ClientMapTest.cs
@@ -1005,6 +1005,7 @@ public void TestRemoveInterceptor()
         }
 
         [Test]
+        [Category("3.8")]
         public void TestRemoveAllWithPredicate()
         {
             FillMap();
diff --git a/Hazelcast.Test/Hazelcast.Client.Test/ClientNearCacheTest.cs b/Hazelcast.Test/Hazelcast.Client.Test/ClientNearCacheTest.cs
index 4b8d540e35..d246b5d8d8 100644
--- a/Hazelcast.Test/Hazelcast.Client.Test/ClientNearCacheTest.cs
+++ b/Hazelcast.Test/Hazelcast.Client.Test/ClientNearCacheTest.cs
@@ -247,6 +247,7 @@ public void TestNearCacheInvalidationOnClear()
         }
 
         [Test]
+        [Category("3.8")]
         public void TestNearCacheInvalidationOnRemoveAllPredicate()
         {
             var map = Client.GetMap<string, string>("nearCacheMapInvalidate-" + TestSupport.RandomString());
diff --git a/Hazelcast.Test/Hazelcast.Client.Test/PartitionPredicateTest.cs b/Hazelcast.Test/Hazelcast.Client.Test/PartitionPredicateTest.cs
index 8b4a6f280d..6e77b44487 100644
--- a/Hazelcast.Test/Hazelcast.Client.Test/PartitionPredicateTest.cs
+++ b/Hazelcast.Test/Hazelcast.Client.Test/PartitionPredicateTest.cs
@@ -25,6 +25,7 @@
 namespace Hazelcast.Client.Test
 {
     [TestFixture]
+    [Category("3.9")]
     public class PartitionPredicateTest : SingleMemberBaseTest
     {
         private const int ItemsPerPartition = 10;
diff --git a/Hazelcast.Test/Hazelcast.Test.csproj b/Hazelcast.Test/Hazelcast.Test.csproj
index 9b35b891c0..4cf7512892 100644
--- a/Hazelcast.Test/Hazelcast.Test.csproj
+++ b/Hazelcast.Test/Hazelcast.Test.csproj
@@ -8,7 +8,7 @@
     <OutputType>Library</OutputType>
     <AppDesignerFolder>Properties</AppDesignerFolder>
     <LangVersion>4</LangVersion>
-    <RootNamespace/>
+    <RootNamespace />
   </PropertyGroup>
   <PropertyGroup Label="sign">
     <SignAssembly>true</SignAssembly>
@@ -20,7 +20,6 @@
     <PackageReference Include="NUnit3TestAdapter" Version="3.9.0" />
   </ItemGroup>
   <ItemGroup>
-    <None Remove="Resources\hazelcast-client-full.xml" />
     <None Remove="Resources\hazelcast-delay.xml" />
     <None Remove="Resources\hazelcast-ssl.xml" />
     <None Remove="Resources\hazelcast.xml" />
@@ -46,7 +45,4 @@
       <CustomToolNamespace>Hazelcast.Test</CustomToolNamespace>
     </EmbeddedResource>
   </ItemGroup>
-  <ItemGroup>
-    <Folder Include="Resources\" />
-  </ItemGroup>
 </Project>
\ No newline at end of file
diff --git a/docs/hazelcastdoc.shfbproj b/docs/hazelcastdoc.shfbproj
index ade5d8f349..ed1e6c563e 100644
--- a/docs/hazelcastdoc.shfbproj
+++ b/docs/hazelcastdoc.shfbproj
@@ -3,7 +3,7 @@
   <PropertyGroup>
     <!-- The configuration and platform will be used to determine which assemblies to include from solution and
 				 project documentation sources -->
-    <Configuration Condition=" '$(Configuration)' == '' ">Debug</Configuration>
+    <Configuration Condition=" '$(Configuration)' == '' ">Release</Configuration>
     <Platform Condition=" '$(Platform)' == '' ">AnyCPU</Platform>
     <SchemaVersion>2.0</SchemaVersion>
     <ProjectGuid>{9588f8fa-c516-4bb7-abc2-24e02dca5848}</ProjectGuid>
@@ -13,15 +13,16 @@
     <RootNamespace>Documentation</RootNamespace>
     <Name>Documentation</Name>
     <!-- SHFB properties -->
-    <FrameworkVersion>.NET Framework 4.0</FrameworkVersion>
+    <FrameworkVersion>.NET Framework 4.5</FrameworkVersion>
     <OutputPath>output\</OutputPath>
     <HtmlHelpName>HazelcastClientDoc</HtmlHelpName>
     <Language>en-US</Language>
     <DocumentationSources>
-      <DocumentationSource sourceFile="..\Hazelcast.Net\Hazelcast.Net.csproj" configuration="Release" />
+      <DocumentationSource sourceFile="..\Hazelcast.Net\bin\Release\net40\Hazelcast.Net.xml" />
+      <DocumentationSource sourceFile="..\Hazelcast.Net\bin\Release\net40\Hazelcast.Net.dll" />
     </DocumentationSources>
     <BuildAssemblerVerbosity>OnlyErrors</BuildAssemblerVerbosity>
-    <HelpFileFormat>HtmlHelp1, Website</HelpFileFormat>
+    <HelpFileFormat>Website</HelpFileFormat>
     <IndentHtml>False</IndentHtml>
     <KeepLogFile>True</KeepLogFile>
     <DisableCodeBlockComponent>False</DisableCodeBlockComponent>
@@ -35,9 +36,9 @@
     <SyntaxFilters>Standard</SyntaxFilters>
     <SdkLinkTarget>Blank</SdkLinkTarget>
     <RootNamespaceContainer>False</RootNamespaceContainer>
-    <PresentationStyle>VS2010</PresentationStyle>
+    <PresentationStyle>VS2013</PresentationStyle>
     <Preliminary>False</Preliminary>
-    <NamingMethod>Guid</NamingMethod>
+    <NamingMethod>MemberName</NamingMethod>
     <HelpTitle>Hazelcast .Net Client Class Library</HelpTitle>
     <ContentPlacement>AboveNamespaces</ContentPlacement>
     <VisibleItems>InheritedMembers, InheritedFrameworkMembers</VisibleItems>
@@ -59,6 +60,8 @@
     <RootNamespaceTitle>Hazelcast-Client</RootNamespaceTitle>
     <HeaderText>
     </HeaderText>
+    <HelpFileVersion>1.0.0.0</HelpFileVersion>
+    <SaveComponentCacheCapacity>100</SaveComponentCacheCapacity>
   </PropertyGroup>
   <!-- There are no properties for these groups.  AnyCPU needs to appear in order for Visual Studio to perform
 			 the build.  The others are optional common platform types that may appear. -->