geode-commits mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From dbar...@apache.org
Subject [geode-native] branch develop updated: GEODE-7303: Simplify nc ug builds - remove some redundant files (#540)
Date Mon, 21 Oct 2019 16:44:28 GMT
This is an automated email from the ASF dual-hosted git repository.

dbarnes pushed a commit to branch develop
in repository https://gitbox.apache.org/repos/asf/geode-native.git


The following commit(s) were added to refs/heads/develop by this push:
     new bf7b273  GEODE-7303: Simplify nc ug builds - remove some redundant files (#540)
bf7b273 is described below

commit bf7b27371ac8e48059ef4e240d296c9bb14d32d7
Author: Dave Barnes <dbarnes@pivotal.io>
AuthorDate: Mon Oct 21 09:44:19 2019 -0700

    GEODE-7303: Simplify nc ug builds - remove some redundant files (#540)
---
 .../app-dev-walkthrough-cpp.html.md.erb            |   2 +-
 .../app-dev-walkthrough-dotnet.html.md.erb         | 130 ----------
 .../custom-class-igfserializable.html.md.erb       | 153 ------------
 .../dotnet-data-serialization-options.html.md.erb  |  79 ------
 .../dotnet-data-serialization.html.md.erb          |  55 -----
 .../dotnet-pdx-autoserializer.html.md.erb          |  72 ------
 .../dotnet-pdx-serialization-features.html.md.erb  |  42 ----
 .../dotnet-pdx-serialization.html.md.erb           |  35 ---
 .../extending-pdx-autoserializer.html.md.erb       |  76 ------
 .../how-igfserializable-works.html.md.erb          |  36 ---
 .../implementing-igfserializable.html.md.erb       | 139 -----------
 .../mapping-dotnet-domain-type-names.html.md.erb   |  42 ----
 .../programming-ipdxinstance.html.md.erb           |  62 -----
 .../registering-the-type.html.md.erb               |  44 ----
 .../serializable-types.html.md.erb                 |  36 ---
 .../serialize-using-igfserializable.html.md.erb    |  40 ---
 .../serialize-using-ipdxserializable.html.md.erb   | 120 ---------
 .../serializing-domain-objects.html.md.erb         |  46 ----
 .../using-ipdxinstancefactory.html.md.erb          |  26 --
 .../app-dev-walkthrough-cpp.html.md.erb            | 130 ----------
 .../app-dev-walkthrough-dotnet.html.md.erb         |   2 +-
 .../security/SampleAuth.cpp                        |  92 -------
 .../cpp-serialization/data-as-blob.html.md.erb     |  25 --
 .../cpp-serialization/object-graphs.html.md.erb    |  23 --
 .../pdx-ignore-unread-fields.html.md.erb           |  37 ---
 .../pdx-serialization.html.md.erb                  |  59 -----
 .../pdx-with-delta-propagation.html.md.erb         |  45 ----
 .../pdxserializable-example.html.md.erb            | 151 ------------
 .../pdxserializable-interface.html.md.erb          | 114 ---------
 .../performing-ops-with-pdx-object.html.md.erb     |  60 -----
 .../serialization-options.html.md.erb              |  85 -------
 .../serialization-overview.html.md.erb             |  47 ----
 .../serialization-using-serializable.html.md.erb   | 271 ---------------------
 .../using-enum-type-with-pdx.html.md.erb           | 130 ----------
 .../using-pdxinstance.html.md.erb                  |  59 -----
 .../using-pdxinstancefactory.html.md.erb           | 134 ----------
 .../using-pdxserialization.html.md.erb             |  70 ------
 .../using-pdxserializer.html.md.erb                | 119 ---------
 38 files changed, 2 insertions(+), 2886 deletions(-)

diff --git a/docs/geode-native-docs-cpp/getting-started/app-dev-walkthrough-cpp.html.md.erb b/docs/geode-native-docs-cpp/getting-started/app-dev-walkthrough-cpp.html.md.erb
index 707e61c..ddaa413 100644
--- a/docs/geode-native-docs-cpp/getting-started/app-dev-walkthrough-cpp.html.md.erb
+++ b/docs/geode-native-docs-cpp/getting-started/app-dev-walkthrough-cpp.html.md.erb
@@ -8,7 +8,7 @@ This section describes how to set up a native client development environment usi
 This walkthrough assumes that certain components are in place:
 
 - The **<%=vars.product_name%> Native Client libraries**. Install the Native Client as described in
-  [Getting Started with the Native Client](getting-started-nc-client.html). Follow the ease-of-use
+  [Getting Started with the Native Library](getting-started-nc-client.html). Follow the ease-of-use
   recommendations by installing the Native Client in a well-known location and renaming it.
 
 | System | Native Client Library Well-Known Location |
diff --git a/docs/geode-native-docs-cpp/getting-started/app-dev-walkthrough-dotnet.html.md.erb b/docs/geode-native-docs-cpp/getting-started/app-dev-walkthrough-dotnet.html.md.erb
deleted file mode 100644
index d1198e6..0000000
--- a/docs/geode-native-docs-cpp/getting-started/app-dev-walkthrough-dotnet.html.md.erb
+++ /dev/null
@@ -1,130 +0,0 @@
----
-title:  .NET Application Development Walkthrough
----
-
-This section describes how to set up a .NET native client development environment using C# and CMake.
-
-## <a id="prerequisites_dotnet"></a>Prerequisites
-This walkthrough assumes that certain components are in place:
-
-- The **<%=vars.product_name%> Native Client libraries**. Install the Native Client as described in
-  [Getting Started with the Native Client](getting-started-nc-client.html). Follow the ease-of-use
-  recommendations by installing the Native Client in `C:\Program Files\nativeclient`.
-
-- The **CMake** tool suite. Download and install CMake, following the instructions on [cmake.org] (https://cmake.org).
-
-- **Geode**: Install and configure Geode. See the [_Geode User's Guide_](http://geode.apache.org/docs/) for instructions and system requirements.
-
-- **Visual Studio 2015** or higher and **.NET 4.5.2**.
-
-To develop a Native Client application using .NET and CMake:
-
-  - Create a project directory structure
-  - Populate the project directories with C# source code
-  - Configure the CMake build environment
-  - Run CMake to configure your application
-  - Build and run your application using Visual Studio
-
-## <a id="setting_up_dirs_dotnet"></a>Setting up Directories and Sources
-
-1. Create a project directory structure. In this example, the project is called MyProject. The
-directory structure provides a place for your application source files and a `cmake` modules
-directory for project-specific CMake files:
-
-    ```
-    MyProject\
-      cmake\
-        Find<%=vars.product_name%>Native.cmake
-      CMakeLists.txt
-      Program.cs
-    ```
-
-1. Change directory to MyProject and create your application sources. In this example, we have one
-source file, `Program.cs`.
-
-## <a id="configuring_cmake_dotnet"></a>Configuring CMake
-
-1. Copy the `Find<%=vars.product_name%>Native.cmake` script from one of the Native Client examples to the `cmake` subdirectory.
-
-1. Create CMakeLists.txt. Copy the file from an example, if you like, as a starting point. The CMakeLists.txt file
-should contain the following CMake instructions:
-
-  - CMake minimum version
-
-    ```
-    cmake_minimum_required(VERSION 3.10)
-    ```
-
-  - Your project name and language
-
-    ```
-    project(MyProject LANGUAGES CSharp)
-    ```
-
-  - Path to the CMake modules directory where the `Find<%=vars.product_name%>Native.cmake` script is located and an instruction
-    telling CMake to use it:
-
-    ```
-    set(CMAKE_MODULE_PATH ${PROJECT_SOURCE_DIR}/cmake)
-    find_package(<%=vars.product_name%>Native REQUIRED COMPONENTS dotnet)
-    ```
-
-  - The compilation target and the source(s) to be compiled
-
-    ```
-    add_executable(MyProject Program.cs)
-
-    target_link_libraries(MyProject
-      PUBLIC
-        <%=vars.product_name%>Native::dotnet)
-
-    set_target_properties(MyProject PROPERTIES
-        VS_DOTNET_TARGET_FRAMEWORK_VERSION "v4.5.2"
-        VS_DOTNET_REFERENCES "System;${<%=vars.product_name%>Native_DOTNET_LIBRARY}")
-    ```
-
-Combined, the above elements comprise the following CMakeLists.txt:
-
-```
-# CMakeLists.txt for .NET Native Client App
-cmake_minimum_required(VERSION 3.10)
-
-project(MyProject LANGUAGES CSharp)
-
-set(CMAKE_MODULE_PATH ${PROJECT_SOURCE_DIR}/cmake)
-
-find_package(<%=vars.product_name%>Native REQUIRED COMPONENTS dotnet)
-
-add_executable(MyProject Program.cs)
-
-target_link_libraries(MyProject
-  PUBLIC
-    <%=vars.product_name%>Native::dotnet)
-
-set_target_properties(MyProject PROPERTIES
-    VS_DOTNET_TARGET_FRAMEWORK_VERSION "v4.5.2"
-    VS_DOTNET_REFERENCES "System;${<%=vars.product_name%>Native_DOTNET_LIBRARY}")
-```
-
-## <a id="building_the_app_dotnet"></a>Configuring the App
-
-1. Create a build directory and set it as your current directory:
-
-    ```
-    $ mkdir build
-    $ cd build
-    ```
-
-1. Run CMake to configure the build:
-
-    ```
-    $ cmake ..
-    ```
-
-This creates a Visual Studio solution for your .NET application. For example, `MyProject.sln`.
-
-## <a id="building_and_running_dotnet"></a>Building and Running the App
-
-Open the solution file in Visual Studio and build the project.
-
-
diff --git a/docs/geode-native-docs-cpp/serialization/dotnet-serialization/custom-class-igfserializable.html.md.erb b/docs/geode-native-docs-cpp/serialization/dotnet-serialization/custom-class-igfserializable.html.md.erb
deleted file mode 100644
index 1489566..0000000
--- a/docs/geode-native-docs-cpp/serialization/dotnet-serialization/custom-class-igfserializable.html.md.erb
+++ /dev/null
@@ -1,153 +0,0 @@
----
-title:  Using a Custom Class With IDataSerializable
----
-
-<!--
-Licensed to the Apache Software Foundation (ASF) under one or more
-contributor license agreements.  See the NOTICE file distributed with
-this work for additional information regarding copyright ownership.
-The ASF licenses this file to You under the Apache License, Version 2.0
-(the "License"); you may not use this file except in compliance with
-the License.  You may obtain a copy of the License at
-
-     http://www.apache.org/licenses/LICENSE-2.0
-
-Unless required by applicable law or agreed to in writing, software
-distributed under the License is distributed on an "AS IS" BASIS,
-WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-See the License for the specific language governing permissions and
-limitations under the License.
--->
-
-An example shows how to use the `BankAccount` custom key type and the `AccountHistory` value type that were previously defined.
-
-## Using a BankAccount Object
-
-``` pre
-class AccountHistory : IDataSerializable   
-   {
-      #region Private members
-      private List<string> m_history;
-      #endregion
-      public AccountHistory()
-      {
-         m_history = new List<string>();
-      }
-      public void ShowAccountHistory()
-      {
-         Console.WriteLine("AccountHistory:");
-         foreach (string hist in m_history) {
-           Console.WriteLine("\t{0}", hist);
-         }
-      }
-      public void AddLog(string entry)
-      {
-         m_history.Add(entry);
-      }
-         public static IDataSerializable CreateInstance()
-      {
-         return new AccountHistory();
-      }
-      #region IDataSerializable Members
-      public void FromData(DataInput input)
-      {
-         int len = input.ReadInt32();
-         m_history.Clear();
-         for (int i = 0; i < len; i++) {
-            m_history.Add(input.ReadUTF());
-         }
-         return this;
-      }
-      public void ToData(DataOutput output)
-      {
-         output.WriteInt32(m_history.Count);
-         foreach (string hist in m_history) {
-            output.WriteUTF(hist);
-         }
-      }
-         public UInt32 ClassId
-      {
-         get
-         {
-            return 0x05;
-         }
-      }
-      public UInt32 ObjectSize
-      {
-         get
-         {
-            UInt32 objectSize = 0;
-            foreach (string hist in m_history) {
-              objectSize += (UInt32)(hist == null ? 0 : sizeof(char) * hist.Length);
-            }
-            return objectSize;
-         }
-      }
-      #endregion
-   }
-      public class TestBankAccount
-      {
-         public static void Main()
-         {
-            // Register the user-defined serializable type.
-            Serializable.RegisterType(AccountHistory.CreateInstance);
-            Serializable.RegisterType(BankAccountKey.CreateInstance);
-            // Create a cache.
-            CacheFactory cacheFactory = CacheFactory.CreateCacheFactory(null);
-            Cache cache = cacheFactory.Create();
-            // Create a region.
-            RegionFactory regionFactory =
-            cache.CreateRegionFactory(RegionShortcut.CACHING_PROXY);
-            Region region = regionFactory.Create("BankAccounts");
-            // Place some instances of BankAccount cache region.
-            BankAccountKey baKey = new BankAccountKey(2309, 123091);
-            AccountHistory ahVal = new AccountHistory();
-            ahVal.AddLog("Created account");
-            region.Put(baKey, ahVal);
-            Console.WriteLine("Put an AccountHistory in cache keyed with
-            BankAccount.");
-            // Display the BankAccount information.
-            Console.WriteLine(baKey.ToString());
-            // Call custom behavior on instance of AccountHistory.
-            ahVal.ShowAccountHistory();
-            // Get a value out of the region.
-            AccountHistory history = region.Get(baKey) as AccountHistory;
-            if (history != null)
-            {
-               Console.WriteLine("Found AccountHistory in the cache.");
-               history.ShowAccountHistory();
-               history.AddLog("debit $1,000,000.");
-               region.Put(baKey, history);
-               Console.WriteLine("Updated AccountHistory in the cache.");
-            }
-            // Look up the history again.
-            history = region.Get(baKey) as AccountHistory;
-            if (history != null)
-            {
-               Console.WriteLine("Found AccountHistory in the cache.");
-               history.ShowAccountHistory();
-            }
-            // Close the cache.
-            cache.Close();
-         }
-      }
-
-      //Example 5.12 Using ICacheLoader to Load New Integers in the Region
-      class ExampleLoaderCallback : ICacheLoader
-      {
-         #region Private members
-         private int m_loads = 0;
-         #endregion
-         #region Public accessors
-         public int Loads
-         {
-            get
-            {
-               return m_loads;
-            }
-         }
-         #endregion
-      }
-```
-
-
diff --git a/docs/geode-native-docs-cpp/serialization/dotnet-serialization/dotnet-data-serialization-options.html.md.erb b/docs/geode-native-docs-cpp/serialization/dotnet-serialization/dotnet-data-serialization-options.html.md.erb
deleted file mode 100644
index 3c92503..0000000
--- a/docs/geode-native-docs-cpp/serialization/dotnet-serialization/dotnet-data-serialization-options.html.md.erb
+++ /dev/null
@@ -1,79 +0,0 @@
----
-title:  Data Serialization Options
----
-
-<!--
-Licensed to the Apache Software Foundation (ASF) under one or more
-contributor license agreements.  See the NOTICE file distributed with
-this work for additional information regarding copyright ownership.
-The ASF licenses this file to You under the Apache License, Version 2.0
-(the "License"); you may not use this file except in compliance with
-the License.  You may obtain a copy of the License at
-
-     http://www.apache.org/licenses/LICENSE-2.0
-
-Unless required by applicable law or agreed to in writing, software
-distributed under the License is distributed on an "AS IS" BASIS,
-WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-See the License for the specific language governing permissions and
-limitations under the License.
--->
-
-Built-in .NET types are serialized automatically into the cache and can be retrieved by Java servers and other <%=vars.product_name%> clients. For domain objects that are not simple types, you have three <%=vars.product_name%> serialization options.
-
-The options give good performance and flexibility for data storage, transfers, and language types. The <%=vars.product_name%> options can also improve performance in serializing and deserializing built-in types.
-
-The simplest option is to use perform automatic serialization by registering the <%=vars.product_name%> .NET PDX reflection-based autoserializer in your application. When you have this registered, <%=vars.product_name%> uses it for all domain objects that are not custom serialized.
-
-You can also custom serialize your objects by implementing one of the <%=vars.product_name%> .NET interfaces, `Apache.Geode.Client.IPdxSerializable` or `Apache.Geode.Client.IDataSerializable`.
-
-You also have the option of using default .NET serialization, but you cannot use it unless you also use helper classes. The helper classes you must use are `CacheableObject` and `CacheableObjectXml`.
-
-<%=vars.product_name%> .NET PDX serialization has more bytes in overhead than <%=vars.product_name%> .NET Data serialization, but using PDX serialization helps you avoid the performance costs of deserialization when performing queries. Applications can use `PdxInstances` in functions to avoid the deserialization of entire objects.
-
-<a id="concept_6DC3DD288F6C4190AEA07DEDE76DD867__table_D61A94C4BFBE4712835F632F30BB488E"></a>
-
-<table>
-<caption><span class="tablecap">Table 1. Serialization Options—Comparison of Features</span></caption>
-<colgroup>
-<col width="33%" />
-<col width="33%" />
-<col width="34%" />
-</colgroup>
-<thead>
-<tr class="header">
-<th>Capability</th>
-<th>IDataSerializable</th>
-<th>IPdxSerializable and PDX reflection-based autoserializer</th>
-</tr>
-</thead>
-<tbody>
-<tr class="odd">
-<td><p>Handles multiple versions of domain objects*</p></td>
-<td></td>
-<td>X</td>
-</tr>
-<tr class="even">
-<td><p>Provides single field access on servers of serialized data, without full deserialization. Supported also for OQL queries.</p></td>
-<td></td>
-<td>X</td>
-</tr>
-<tr class="odd">
-<td><p>Automatically ported to other languages by <%=vars.product_name%> - no need to program Java-side implementation</p></td>
-<td></td>
-<td>X</td>
-</tr>
-<tr class="even">
-<td><p>Works with <%=vars.product_name%> delta propagation</p></td>
-<td>X</td>
-<td>X (See explanation below.)</td>
-</tr>
-</tbody>
-</table>
-
-
-\*You can mix domain object versions where the differences between versions are the addition and removal of object fields.
-
-By default, you can use <%=vars.product_name%> delta propagation with PDX serialization. However, delta propagation will not work if you have set the <%=vars.product_name%> property read-serialized to "true". In terms of deserialization, to apply a change delta propagation requires a domain class instance and the `fromDelta` method. If you have set read-serialized to true, you will receive an `IPdxInstance` instead of a domain class instance and `IPdxInstance` does not have the `fromDelt [...]
-
-
diff --git a/docs/geode-native-docs-cpp/serialization/dotnet-serialization/dotnet-data-serialization.html.md.erb b/docs/geode-native-docs-cpp/serialization/dotnet-serialization/dotnet-data-serialization.html.md.erb
deleted file mode 100644
index 6e4de50..0000000
--- a/docs/geode-native-docs-cpp/serialization/dotnet-serialization/dotnet-data-serialization.html.md.erb
+++ /dev/null
@@ -1,55 +0,0 @@
----
-title:  Data Serialization &ndash; .NET
----
-
-<!--
-Licensed to the Apache Software Foundation (ASF) under one or more
-contributor license agreements.  See the NOTICE file distributed with
-this work for additional information regarding copyright ownership.
-The ASF licenses this file to You under the Apache License, Version 2.0
-(the "License"); you may not use this file except in compliance with
-the License.  You may obtain a copy of the License at
-
-     http://www.apache.org/licenses/LICENSE-2.0
-
-Unless required by applicable law or agreed to in writing, software
-distributed under the License is distributed on an "AS IS" BASIS,
-WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-See the License for the specific language governing permissions and
-limitations under the License.
--->
-
-All data moving out of the client cache must be serializable.
-
-
-  - <%=vars.product_name%> Portable Data eXchange (PDX) serialization
-  - `DataSerializable` interface serialization
-
-The `DataSerializable` interface can be a good option performance-wise if the size of your objects
-is small, but do not as readily support code that executes on the server, such as queries and functions.
-
-Each of these serialization methods provides two options:
-
-  - PDXSerializable / DataSerializable for objects under your control, that is, objects you can modify to incorporate their own serialization and deserialization code
-  - PDXSerializer / DataSerializer for objects not under your control, that is, objects for which serialization and deserialization must be specified separately from the objects themselves.
-
-For .NET, a reflection-based autoserialization option is also available, but it is limited to cases in which the objects being serialized (a) contain no transient state and (b) are composed only of primitive types.
-
-
-# .NET Data Serialization Options
-
-The .NET client API provides an option not available to the C++ API, as .NET objects are capable of reflection.
-The recommended choice is iPDXSerializable.
-
-With reflection-based autoserialization, built-in .NET types are serialized automatically into the
-cache and can be retrieved by <%=vars.product_name%> servers and other <%=vars.product_name%> clients. For domain
-objects that are not simple types, you have three <%=vars.product_name%> serialization options.
-
-  - The simplest option is to use automatic serialization by registering the <%=vars.product_name%> .NET PDX
-reflection-based autoserializer in your application. When you have this registered, <%=vars.product_name%> uses it
-for all domain objects that are not custom serialized.
-
-  - You can custom serialize your objects by implementing the <%=vars.product_name%> `IDataSerializable` .NET interface.
-
-  - You also have the option of using default .NET serialization, but you cannot use it unless you also
-use helper classes. The helper classes you must use are `CacheableObject` and `CacheableObjectXml`.
diff --git a/docs/geode-native-docs-cpp/serialization/dotnet-serialization/dotnet-pdx-autoserializer.html.md.erb b/docs/geode-native-docs-cpp/serialization/dotnet-serialization/dotnet-pdx-autoserializer.html.md.erb
deleted file mode 100644
index 3019187..0000000
--- a/docs/geode-native-docs-cpp/serialization/dotnet-serialization/dotnet-pdx-autoserializer.html.md.erb
+++ /dev/null
@@ -1,72 +0,0 @@
-<% set_title("Serialize Using the", product_name, "PDX Autoserializer") %>
-
-<!--
-Licensed to the Apache Software Foundation (ASF) under one or more
-contributor license agreements.  See the NOTICE file distributed with
-this work for additional information regarding copyright ownership.
-The ASF licenses this file to You under the Apache License, Version 2.0
-(the "License"); you may not use this file except in compliance with
-the License.  You may obtain a copy of the License at
-
-     http://www.apache.org/licenses/LICENSE-2.0
-
-Unless required by applicable law or agreed to in writing, software
-distributed under the License is distributed on an "AS IS" BASIS,
-WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-See the License for the specific language governing permissions and
-limitations under the License.
--->
-
-When you register the reflection-based serializer, <%=vars.product_name%> uses it to serialize all objects that do not implement `IPdxSerializable` or `IDataSerializable`. You can customize the auto-serialization behavior for your domain objects by adding serialization attributes to your object’s fields.
-
-**Procedure**
-
-1.  If you have not already registered the PDX reflection-based autoserializer, add the registration code to your application.
-
-    For example:
-
-    ``` pre
-    using Apache.Geode.Client;
-    ...
-    // Register reflection-based autoserializer to serialize
-    // domain objects using PDX serialization
-    Serializable.RegisterPdxSerializer(new ReflectionBasedAutoSerializer());
-    ```
-
-    This can only be configured in the application code. It cannot be configured declaratively in `cache.xml`.
-
-2.  (Optional) For each object you intend to have autoserialized, customize the serialization as needed.  **Note:** If you also use PDX serialization in Java for the object, customize your serialization the same for both languages.
-
-    1.  The following extension methods apply to autoserialization:
-        -   **WriteTransform**. Controls what field value is written during auto serialization.
-        -   **ReadTransform**. Controls what field value is read during auto deserialization.
-        -   **GetFieldType**. Defines the specific field names that will be generated during autoserialization.
-        -   **IsIdentityField**. Controls which field is marked as the identity field. Identity fields are used when a `PdxInstance` computes its hash code to determine whether it is equal to another object.
-        -   **GetFieldType**. Determines the field type that will be used when autoserializing the given field.
-        -   **IsFieldIncluded**. Specifies which fields of a class to autoserialize.
-
-        See [Extending the Autoserializer](extending-pdx-autoserializer.html#concept_87701FF3FAE74F3193BE3FB349CE0086) for sample usage.
-
-    2.  If you are writing a Java application, you can use the `IPdxType` Mapper to map Java types to .NET types. Note that you only need to use the `IPdxTypeMapper` if you are writing Java applications.
-
-        See [Map .NET Domain Type Names to PDX Type Names with IPdxTypeMapper](mapping-dotnet-domain-type-names.html#concept_63F4164F1AE242A9BA309738F484182D) for sample usage.
-
-    3.  To specify an identifier field in your domain object, add the attribute `PdxIdentityField` to the field.
-
-        For example:
-
-        ``` pre
-        [PdxIdentityField] private int id;
-        ```
-
-    4.  To exclude a field from serialization, add the .NET attribute `NonSerialized` to the field.
-
-        For example:
-
-        ``` pre
-        [NonSerialized] private int myLocalData;
-        ```
-
-For each domain class <%=vars.product_name%> serializes using the autoserializer, all fields are considered for serialization except those defined as `static`, `literal` or `readonly` and those you explicitly exclude using the .NET `NonSerialized` attribute.
-
-
diff --git a/docs/geode-native-docs-cpp/serialization/dotnet-serialization/dotnet-pdx-serialization-features.html.md.erb b/docs/geode-native-docs-cpp/serialization/dotnet-serialization/dotnet-pdx-serialization-features.html.md.erb
deleted file mode 100644
index 6684bf9..0000000
--- a/docs/geode-native-docs-cpp/serialization/dotnet-serialization/dotnet-pdx-serialization-features.html.md.erb
+++ /dev/null
@@ -1,42 +0,0 @@
-<% set_title(product_name, "PDX Serialization Features") %>
-
-<!--
-Licensed to the Apache Software Foundation (ASF) under one or more
-contributor license agreements.  See the NOTICE file distributed with
-this work for additional information regarding copyright ownership.
-The ASF licenses this file to You under the Apache License, Version 2.0
-(the "License"); you may not use this file except in compliance with
-the License.  You may obtain a copy of the License at
-
-     http://www.apache.org/licenses/LICENSE-2.0
-
-Unless required by applicable law or agreed to in writing, software
-distributed under the License is distributed on an "AS IS" BASIS,
-WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-See the License for the specific language governing permissions and
-limitations under the License.
--->
-
-<%=vars.product_name%> PDX serialization offers several advantages.
-
-## <a id="concept_E8DCAA3027B64C0C8213A0DF2D773BF4__section_8F8D96A0DAC3416DA90622D0E240F54A" class="no-quick-link"></a>Application Versioning of PDX Domain Objects
-
-Domain objects evolve along with your application code. You may create an address object with two address lines, then realize later that a third line is required for some situations. Or you may realize that a particular field is not used and want to get rid of it.
-
-With PDX, you can use old and new versions of domain objects together in a distributed system if the versions differ by the addition or removal of fields. This compatibility lets you gradually introduce modified code and data into the system, without bringing the system down.
-
-<%=vars.product_name%> maintains a central registry of the PDX domain object metadata. Using the registry, <%=vars.product_name%> preserves fields in each member's cache regardless of whether the member has the field defined. When a member receives an object that has a field registered that the member is not aware of, the member does not access the field, but preserves it and passes it along with the rest of the object to other members. When a member receives an object that is missing on [...]
-
-## <a id="concept_E8DCAA3027B64C0C8213A0DF2D773BF4__section_4CD0072C619F4F0496B73597B92B2289" class="no-quick-link"></a>Portability of PDX Serializable Objects
-
-When you create an `IPdxSerializable` object, <%=vars.product_name%> stores the object's type information in a central registry. The information is passed between peers, between clients and servers, and between distributed systems.
-
-This offers a notable advantage to the .NET client, which shares data with Java cache servers. Clients automatically pass registry information to servers when they store an `IPdxSerializable` object. Clients can run queries and functions against the data in the servers without the servers needing to know anything about the stored objects. One client can store data on the server to be retrieved by another client, with the server never needing to know the object type. This means you can co [...]
-
-## <a id="concept_E8DCAA3027B64C0C8213A0DF2D773BF4__section_0437E67A0DDE4F92A24658DAB48DD76C" class="no-quick-link"></a>Reduced Deserialization of Serialized Objects
-
-The access methods for `IPdxSerializable` objects allow you to examine specific fields of your domain object without deserializing the entire object. This can reduce serialization and deserialization costs significantly. .NET clients can run queries and execute functions against the objects in the server caches without deserializing the entire object on the server side. The query engine automatically recognizes PDX objects and uses only the fields it needs.
-
-Clients can execute Java functions on server data that only access parts of the domain objects by using `PdxInstance.`
-
-Likewise, peers can access just the fields needed from the serialized object, keeping the object stored in the cache in serialized form.
diff --git a/docs/geode-native-docs-cpp/serialization/dotnet-serialization/dotnet-pdx-serialization.html.md.erb b/docs/geode-native-docs-cpp/serialization/dotnet-serialization/dotnet-pdx-serialization.html.md.erb
deleted file mode 100644
index 2818d86..0000000
--- a/docs/geode-native-docs-cpp/serialization/dotnet-serialization/dotnet-pdx-serialization.html.md.erb
+++ /dev/null
@@ -1,35 +0,0 @@
----
-title:  Serialize with PDX Serialization
----
-
-<!--
-Licensed to the Apache Software Foundation (ASF) under one or more
-contributor license agreements.  See the NOTICE file distributed with
-this work for additional information regarding copyright ownership.
-The ASF licenses this file to You under the Apache License, Version 2.0
-(the "License"); you may not use this file except in compliance with
-the License.  You may obtain a copy of the License at
-
-     http://www.apache.org/licenses/LICENSE-2.0
-
-Unless required by applicable law or agreed to in writing, software
-distributed under the License is distributed on an "AS IS" BASIS,
-WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-See the License for the specific language governing permissions and
-limitations under the License.
--->
-
-<%=vars.product_name%>'s Portable Data eXchange (PDX) is a cross-language data format that can reduce the cost of distributing and serializing your objects. PDX stores data in named fields that you can access individually, to avoid the cost of deserializing the entire data object. PDX also allows you to mix versions of objects where you have added or removed fields.
-
-You have two options for <%=vars.product_name%> PDX serialization when using the .NET caching API. You can program your domain objects using the `IPdxSerializable` interface, or you can use <%=vars.product_name%>’s reflection-based autoserializer.
-
-- [Geode PDX Serialization Features](dotnet-pdx-serialization-features.html)
-- [Serialize Using the Geode PDX Autoserializer](dotnet-pdx-autoserializer.html)
-- [Extend the PDX Autoserializer](extending-pdx-autoserializer.html)
-- [Serialize Your Domain Objects with IPdxSerializer](serializing-domain-objects.html)
-- [Serialize Using the IPdxSerializable Interface](serialize-using-ipdxserializable.html)
-- [Program Your Application to Use IPdxInstance](programming-ipdxinstance.html)
-- [Use the IPdxInstanceFactory to Create IPdxInstances](using-ipdxinstancefactory.html)
-- [Map .NET Domain Type Names to PDX Type Names with IPdxTypeMapper](mapping-dotnet-domain-type-names.html)
-- [Data Serialization Options](dotnet-data-serialization-options.html)
-- [Serialize with PDX Serialization](dotnet-pdx-serialization.html)
diff --git a/docs/geode-native-docs-cpp/serialization/dotnet-serialization/extending-pdx-autoserializer.html.md.erb b/docs/geode-native-docs-cpp/serialization/dotnet-serialization/extending-pdx-autoserializer.html.md.erb
deleted file mode 100644
index 3a72f72..0000000
--- a/docs/geode-native-docs-cpp/serialization/dotnet-serialization/extending-pdx-autoserializer.html.md.erb
+++ /dev/null
@@ -1,76 +0,0 @@
----
-title:  Extend the PDX Autoserializer
----
-
-<!--
-Licensed to the Apache Software Foundation (ASF) under one or more
-contributor license agreements.  See the NOTICE file distributed with
-this work for additional information regarding copyright ownership.
-The ASF licenses this file to You under the Apache License, Version 2.0
-(the "License"); you may not use this file except in compliance with
-the License.  You may obtain a copy of the License at
-
-     http://www.apache.org/licenses/LICENSE-2.0
-
-Unless required by applicable law or agreed to in writing, software
-distributed under the License is distributed on an "AS IS" BASIS,
-WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-See the License for the specific language governing permissions and
-limitations under the License.
--->
-
-This example code demonstrates how to extend the autoserializer to customize serialization.
-
-## Extending the Autoserializer
-
-``` pre
-public class AutoSerializerEx : ReflectionBasedAutoSerializer
-{
-   public override object WriteTransform(FieldInfo fi, Type type, object originalValue) {
-      if (fi.FieldType.Equals(Type.GetType("System.Guid"))) {
-        return originalValue.ToString();
-      } else if (fi.FieldType.Equals(Type.GetType("System.Decimal"))) {
-        return originalValue.ToString();
-      } else
-        return base.WriteTransform(fi, type, originalValue);
-    }
-
-    public override object ReadTransform(FieldInfo fi, Type type, object serializeValue) {
-      if (fi.FieldType.Equals(Type.GetType("System.Guid"))) {
-        Guid g = new Guid((string)serializeValue);
-        return g;
-      } else if (fi.FieldType.Equals(Type.GetType("System.Decimal"))) {
-        return Convert.ToDecimal((string)serializeValue);
-      } else
-        return base.ReadTransform(fi, type, serializeValue);
-    }
-
-   public override FieldType GetFieldType(FieldInfo fi, Type type) {
-      if (fi.FieldType.Equals(Type.GetType("System.Guid")) ||
-              fi.FieldType.Equals(Type.GetType("System.Decimal")))
-        return FieldType.STRING;
-      return base.GetFieldType(fi, type);
-   }
-
-   public override bool IsIdentityField(FieldInfo fi, Type type) {
-      if (fi.Name == "_identityField")
-        return true;
-      return base.IsIdentityField(fi, type);
-   }
-
-   public override string GetFieldName(FieldInfo fi, Type type) {
-      if (fi.Name == "_nameChange")
-        return fi.Name + "NewName";
-      return fi.Name;
-    }
- 
-   public override bool IsFieldIncluded(FieldInfo fi, Type type)
-   {
-      if (fi.Name == "_notInclude")
-        return false;
-      return base.IsFieldIncluded(fi, type);
-    }
-}
-```
-
-
diff --git a/docs/geode-native-docs-cpp/serialization/dotnet-serialization/how-igfserializable-works.html.md.erb b/docs/geode-native-docs-cpp/serialization/dotnet-serialization/how-igfserializable-works.html.md.erb
deleted file mode 100644
index 5efba97..0000000
--- a/docs/geode-native-docs-cpp/serialization/dotnet-serialization/how-igfserializable-works.html.md.erb
+++ /dev/null
@@ -1,36 +0,0 @@
----
-title:  How Serialization Works with IDataSerializable
----
-
-<!--
-Licensed to the Apache Software Foundation (ASF) under one or more
-contributor license agreements.  See the NOTICE file distributed with
-this work for additional information regarding copyright ownership.
-The ASF licenses this file to You under the Apache License, Version 2.0
-(the "License"); you may not use this file except in compliance with
-the License.  You may obtain a copy of the License at
-
-     http://www.apache.org/licenses/LICENSE-2.0
-
-Unless required by applicable law or agreed to in writing, software
-distributed under the License is distributed on an "AS IS" BASIS,
-WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-See the License for the specific language governing permissions and
-limitations under the License.
--->
-
-When your application puts an object into the cache for distribution, <%=vars.product_name%> serializes the data by taking these steps.
-
-1.  Calls the appropriate `ClassId` function and creates the `TypeId` from it.
-2.  Writes the `TypeId` for the instance.
-3.  Invokes the `ToData` function for the instance.
-
-When your application subsequently receives a byte array, <%=vars.product_name%> takes the following steps:
-
-1.  Decodes the `TypeId` and creates an object of the designated type, using the registered factory functions.
-2.  Invokes the `FromData` function with input from the data stream.
-3.  Decodes the data and then populates the data fields.
-
-The `TypeId` is an integer of four bytes, which is a combination of `ClassId` integer and `0x27`, which is an indicator of user-defined type.
-
-
diff --git a/docs/geode-native-docs-cpp/serialization/dotnet-serialization/implementing-igfserializable.html.md.erb b/docs/geode-native-docs-cpp/serialization/dotnet-serialization/implementing-igfserializable.html.md.erb
deleted file mode 100644
index aa069c1..0000000
--- a/docs/geode-native-docs-cpp/serialization/dotnet-serialization/implementing-igfserializable.html.md.erb
+++ /dev/null
@@ -1,139 +0,0 @@
----
-title:  Implement the IDataSerializable Interface
----
-
-<!--
-Licensed to the Apache Software Foundation (ASF) under one or more
-contributor license agreements.  See the NOTICE file distributed with
-this work for additional information regarding copyright ownership.
-The ASF licenses this file to You under the Apache License, Version 2.0
-(the "License"); you may not use this file except in compliance with
-the License.  You may obtain a copy of the License at
-
-     http://www.apache.org/licenses/LICENSE-2.0
-
-Unless required by applicable law or agreed to in writing, software
-distributed under the License is distributed on an "AS IS" BASIS,
-WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-See the License for the specific language governing permissions and
-limitations under the License.
--->
-
-To store your own data types in the cache, you implement the <%=vars.product_name%> `IDataSerializable` interface.
-
-Examples follow the procedure.
-
-**Procedure**
-
-1.  Implement the `ToData` function that serializes your data:
-
-    ``` pre
-    void ToData(DataOutput output)
-    ```
-
-    The `ToData` function is responsible for copying all of the data fields for the object to the object stream. The `DataOutput` class represents the output stream and provides methods for writing the primitives in a network byte order.
-
-2.  Implement the `FromData` function that consumes a data input stream and repopulates the data fields for the object:
-
-    ``` pre
-    void fromData (DataInput& input)
-    ```
-
-    The `DataInput` class represents the input stream and provides methods for reading input elements. The `FromData` function must read the elements of the input stream in the same order that they were written by `ToData`.
-
-3.  Implement the `ClassId` function to return an integer which is unique for your class (in the set of all of your user-defined classes).
-
-## Simple BankAccount Class
-
-This example shows a simple class, `BankAccount`, that encapsulates the two `ints`, `customerId` and `accountId`:
-
-``` pre
-public class BankAccount
-{
-   private int m_customerId;
-   private int m_accountId;
-   public int Customer
-   {
-      get
-      {
-         return m_customerId;
-      }
-   }
-   public int Account
-   {
-      get
-      {
-         return m_accountId;
-      }
-   }
-   public BankAccount(int customer, int account)
-   {
-      m_customerId = customer;
-      m_accountId = account;
-   }
-}
-```
-
-## Implementing a Serializable Class
-
-To make `BankAccount` serializable, you implement the `IDataSerializable` interface as shown in this example:
-
-``` pre
-public class BankAccount : IDataSerializable
-   {
-   private int m_customerId;
-   private int m_accountId;
-   public int Customer
-   {
-      get
-      {
-         return m_customerId;
-      }
-   }
-   public int Account
-   {
-      get
-      {
-         return m_accountId;
-      }
-   }
-   public BankAccount(int customer, int account)
-   {
-      m_customerId = customer;
-      m_accountId = account;
-   }
-   // Our TypeFactoryMethod
-   public static IDataSerializable CreateInstance()
-   {
-      return new BankAccount(0, 0);
-   }
-   #region IDataSerializable Members
-   public void ToData(DataOutput output)
-   {
-      output.WriteInt32(m_customerId);
-      output.WriteInt32(m_accountId);
-   }
-   public void FromData(DataInput input)
-   {
-      m_customerId = input.ReadInt32();
-      m_accountId = input.ReadInt32();
-      return this;
-   }
-   public UInt32 ClassId
-   {
-      get
-      {
-         return 11;
-      }
-   }
-   public UInt32 ObjectSize
-   {
-      get
-      {
-         return (UInt32)(sizeof(Int32) + sizeof(Int32));
-      }
-   }
-}
-```
-
-
diff --git a/docs/geode-native-docs-cpp/serialization/dotnet-serialization/mapping-dotnet-domain-type-names.html.md.erb b/docs/geode-native-docs-cpp/serialization/dotnet-serialization/mapping-dotnet-domain-type-names.html.md.erb
deleted file mode 100644
index c925faa..0000000
--- a/docs/geode-native-docs-cpp/serialization/dotnet-serialization/mapping-dotnet-domain-type-names.html.md.erb
+++ /dev/null
@@ -1,42 +0,0 @@
----
-title:  Map .NET Domain Type Names to PDX Type Names with IPdxTypeMapper
----
-
-<!--
-Licensed to the Apache Software Foundation (ASF) under one or more
-contributor license agreements.  See the NOTICE file distributed with
-this work for additional information regarding copyright ownership.
-The ASF licenses this file to You under the Apache License, Version 2.0
-(the "License"); you may not use this file except in compliance with
-the License.  You may obtain a copy of the License at
-
-     http://www.apache.org/licenses/LICENSE-2.0
-
-Unless required by applicable law or agreed to in writing, software
-distributed under the License is distributed on an "AS IS" BASIS,
-WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-See the License for the specific language governing permissions and
-limitations under the License.
--->
-
-PDX serialized instances in Java map to .NET types with the same name. If you need to adjust the .NET name, then you need to use the IPdxTypeMapper.
-
-See the [Java to .NET Type Mapping Table](../../dotnet-caching-api/java-to-dotnet-type-mapping.html#concept_24D0AAC71FF1483AB47A7772DA018966) for current mappings.
-
-## Using IPdxTypeMapper
-
-``` pre
-//This demonstrates, how to map .NET type to pdx type or java type
-public class PdxTypeMapper : IPdxTypeMapper {
-    
-    public string ToPdxTypeName(string localTypeName) {
-        return "pdx_" + localTypeName;
-    }
-
-    public string FromPdxTypeName(string pdxTypeName) {
-        return pdxTypeName.Substring(4);//need to extract "pdx_"
-    }
-}
-```
-
-
diff --git a/docs/geode-native-docs-cpp/serialization/dotnet-serialization/programming-ipdxinstance.html.md.erb b/docs/geode-native-docs-cpp/serialization/dotnet-serialization/programming-ipdxinstance.html.md.erb
deleted file mode 100644
index 5b01482..0000000
--- a/docs/geode-native-docs-cpp/serialization/dotnet-serialization/programming-ipdxinstance.html.md.erb
+++ /dev/null
@@ -1,62 +0,0 @@
----
-title:  Program Your Application to Use IPdxInstance
----
-
-<!--
-Licensed to the Apache Software Foundation (ASF) under one or more
-contributor license agreements.  See the NOTICE file distributed with
-this work for additional information regarding copyright ownership.
-The ASF licenses this file to You under the Apache License, Version 2.0
-(the "License"); you may not use this file except in compliance with
-the License.  You may obtain a copy of the License at
-
-     http://www.apache.org/licenses/LICENSE-2.0
-
-Unless required by applicable law or agreed to in writing, software
-distributed under the License is distributed on an "AS IS" BASIS,
-WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-See the License for the specific language governing permissions and
-limitations under the License.
--->
-
-An `IPdxInstance` is a lightweight wrapper around PDX serialized bytes. It provides applications with run-time access to fields of a PDX serialized object.
-
-You can configure your cache to return an `IPdxInstance` when a PDX serialized object is deserialized instead of deserializing the object to a domain class. You can then program your application code that reads your entries to handle `IPdxInstances` fetched from the cache.
-
-**Note:**
-This option applies only to entry retrieval that you explicitly code using methods like `EntryEvent.getNewValue` and `Region.get`, as you do inside functions or in cache listener code. This does not apply to querying because the query engine retrieves the entries and handles object access for you.
-
-**Note:**
-`IPdxInstance` overrides any custom implementation you might have coded for your object's `equals` and `hashcode` methods.
-
-**Procedure**
-
-1.  In the `cache.xml` file of the server member where entry fetches are run, set the `<pdx>` read-serialized attribute to true.
-
-    Data is not necessarily accessed on the member that you have coded for it. For example, if a client application runs a function on a server, the actual data access is done on the server, so you set read-serialized to true on the server.
-
-    For example:
-
-    ``` pre
-    // Cache configuration setting PDX read behavior
-                  <cache>
-                    <pdx read-serialized="true" />
-    ... </cache>
-    ```
-
-2.  Write the application code that fetches data from the cache to handle a `IPdxInstance`. If you are sure you will only retrieve `IPdxInstances` from the cache, you can code only for that. In many cases, a `IPdxInstance` or a domain object may be returned from your cache entry retrieval operation, so you should check the object type and handle each possible type.
-
-    See [Creating an IPdxInstance with IPdxInstanceFactory](using-ipdxinstancefactory.html#concept_8FA31D0D022146CE8DE2197006507AFF__example_89B7EDD2BE27423BA0CAB9B0270348B5) for an example of this.
-
-If you configure your cache to allow PDX serialized reads, cache fetches return the data in the form it is found. If the object is not serialized, the fetch returns the domain object. If the object is serialized, the fetch returns the `PdxInstance` for the object.
-
-**Note:**
-If you are using `IPdxInstances`, you cannot use delta propagation to apply changes to PDX serialized objects.
-
-For example, in client/server applications that are programmed and configured to handle all data activity from the client, PDX serialized reads done on the server side will always return the `IPdxInstance`. This is because all of data is serialized for transfer from the client and you are not performing any server-side activities that would deserialize the objects in the server cache.
-
-In mixed situations, such as where a server cache is populated from client operations and also from data loads done on the server side, fetches done on the server can return a mix of `IPdxInstances` and domain objects.
-
-When fetching data in a cache with PDX serialized reads enabled, the safest approach is to code to handle both types, receiving an Object from the fetch operation, checking the type and casting as appropriate.
-
-
diff --git a/docs/geode-native-docs-cpp/serialization/dotnet-serialization/registering-the-type.html.md.erb b/docs/geode-native-docs-cpp/serialization/dotnet-serialization/registering-the-type.html.md.erb
deleted file mode 100644
index 846ce56..0000000
--- a/docs/geode-native-docs-cpp/serialization/dotnet-serialization/registering-the-type.html.md.erb
+++ /dev/null
@@ -1,44 +0,0 @@
----
-title:  Register the Type
----
-
-<!--
-Licensed to the Apache Software Foundation (ASF) under one or more
-contributor license agreements.  See the NOTICE file distributed with
-this work for additional information regarding copyright ownership.
-The ASF licenses this file to You under the Apache License, Version 2.0
-(the "License"); you may not use this file except in compliance with
-the License.  You may obtain a copy of the License at
-
-     http://www.apache.org/licenses/LICENSE-2.0
-
-Unless required by applicable law or agreed to in writing, software
-distributed under the License is distributed on an "AS IS" BASIS,
-WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-See the License for the specific language governing permissions and
-limitations under the License.
--->
-
-To use the `BankAccount` type, you must register it with the type system. Then, when an incoming stream contains a `BankAccount`, it can be manufactured from the associated `TypeFactoryMethod.`
-
-``` pre
-Serializable.RegisterType(BankAccount.CreateInstance);
-```
-
-Typically, you would register the type before creating the system.
-
-## <a id="concept_FFFB0AAA131E46D09065F910EFF218CB__section_1B68CDA7392E45CAA413362F42CCF829" class="no-quick-link"></a>Using ClassId
-
-A `ClassId` is an integer that returns the `ClassId` of the instance being serialized. The `ClassId` is used by deserialization to determine what instance type to create and deserialize into.
-
-## <a id="concept_FFFB0AAA131E46D09065F910EFF218CB__section_8A63DBA039744DCCB6840A7F1F5734DA" class="no-quick-link"></a>Using DSFID
-
-A `DSFID` is an integer that returns the data serialization fixed ID type. `DSFID` is used to determine what instance type to create and deserialize into. `DSFID` should not be overridden by custom implementations, and it is reserved only for built-in serializable types.
-
-## <a id="concept_FFFB0AAA131E46D09065F910EFF218CB__section_A02B5E61D03B4B0893DFF3D21F2346F9" class="no-quick-link"></a>Using Custom Key Types
-
-If your application uses its own key types that are too complex to easily force into string, you can probably improve performance by using a custom type and implementing `HashCode` and `Equals` functions. For example, if you have hybrid data types such as floating point numbers, you can implement your own type that encapsulates the floating point number. Comparing floating point numbers in this way provides greater performance than comparing a string representation of the floating point  [...]
-
-See [Serialization in Native Client Mode with a Java Server](../cpp-caching-api/serialization-using-serializable.html#concept_696AB5206C3E45898CC1A24CDD93D003__section_AFB685227E4048BF9FB4FD7C55AED274) for information about implementing key types for a client that is used with a Java cache server.
-
-To extend a type that implements `IPdxSerializable` or `IDataSerializable` for your key, override and implement the `HashCode` and `Equals` methods in the key as needed.
diff --git a/docs/geode-native-docs-cpp/serialization/dotnet-serialization/serializable-types.html.md.erb b/docs/geode-native-docs-cpp/serialization/dotnet-serialization/serializable-types.html.md.erb
deleted file mode 100644
index f213da6..0000000
--- a/docs/geode-native-docs-cpp/serialization/dotnet-serialization/serializable-types.html.md.erb
+++ /dev/null
@@ -1,36 +0,0 @@
----
-title:  Generic and Custom Serializable Types
----
-
-<!--
-Licensed to the Apache Software Foundation (ASF) under one or more
-contributor license agreements.  See the NOTICE file distributed with
-this work for additional information regarding copyright ownership.
-The ASF licenses this file to You under the Apache License, Version 2.0
-(the "License"); you may not use this file except in compliance with
-the License.  You may obtain a copy of the License at
-
-     http://www.apache.org/licenses/LICENSE-2.0
-
-Unless required by applicable law or agreed to in writing, software
-distributed under the License is distributed on an "AS IS" BASIS,
-WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-See the License for the specific language governing permissions and
-limitations under the License.
--->
-
-All built-in generics are automatically registered at initialization. You have a couple of options for complex key types.
-
-If your application uses more complex key types that you want to make more accessible or easier to handle, you can derive a new class from `IDataSerializable`. Another option is for the application to do its own object serialization using `Byte[]` or a custom type.
-
-## <a id="concept_5D520C87F65B48AFA4240615190B0150__section_DA3BCFFFCB974C65BEE953DF3FAA8442" class="no-quick-link"></a>Blobs
-
-If you have data that is best handled as a blob, such as structs that do not contain pointers, use a `Byte[]` or, if you need something more complex than `Byte[]`, implement a custom type using either `IPdxSerializable` or `IDataSerializable`.
-
-## <a id="concept_5D520C87F65B48AFA4240615190B0150__section_D49865F1CF5F467A9FFAD244D990F3F5" class="no-quick-link"></a>Object Graphs
-
-If you have a graph of objects in which each node can be serializable, the parent node calls `DataOutput.WriteObject` to delegate the serialization responsibility to its child nodes. Similarly, your application calls `DataInput.ReadObject` to deserialize the object graph.
-
-**Note:**
-The <%=vars.product_name%> `IDataSerializable` interface does not support object graphs with multiple references to the same object. If your application uses these types of circular graphs, you must address this design concern explicitly.
-
diff --git a/docs/geode-native-docs-cpp/serialization/dotnet-serialization/serialize-using-igfserializable.html.md.erb b/docs/geode-native-docs-cpp/serialization/dotnet-serialization/serialize-using-igfserializable.html.md.erb
deleted file mode 100644
index 7f2bd8d..0000000
--- a/docs/geode-native-docs-cpp/serialization/dotnet-serialization/serialize-using-igfserializable.html.md.erb
+++ /dev/null
@@ -1,40 +0,0 @@
----
-title:  Serialize with the IDataSerializable Interface
----
-
-<!--
-Licensed to the Apache Software Foundation (ASF) under one or more
-contributor license agreements.  See the NOTICE file distributed with
-this work for additional information regarding copyright ownership.
-The ASF licenses this file to You under the Apache License, Version 2.0
-(the "License"); you may not use this file except in compliance with
-the License.  You may obtain a copy of the License at
-
-     http://www.apache.org/licenses/LICENSE-2.0
-
-Unless required by applicable law or agreed to in writing, software
-distributed under the License is distributed on an "AS IS" BASIS,
-WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-See the License for the specific language governing permissions and
-limitations under the License.
--->
-
-The .NET `IDataSerializable` interface provides fast and compact data serialization.
-
--   **[Generic and Custom Serializable Types](serializable-types.html)**
-
-    All built-in generics are automatically registered at initialization. You have a couple of options for complex key types.
-
--   **[How Serialization Works with IDataSerializable](how-igfserializable-works.html)**
-
-    When your application puts an object into the cache for distribution, <%=vars.product_name%> serializes the data by taking these steps.
-
--   **[Implement the IDataSerializable Interface](implementing-igfserializable.html)**
-
-    To store your own data types in the cache, you implement the <%=vars.product_name%> `IDataSerializable` interface.
-
--   **[Register the Type](registering-the-type.html)**
-
-    To use the `BankAccount` type, you must register it with the type system. Then, when an incoming stream contains a `BankAccount`, it can be manufactured from the associated `TypeFactoryMethod.`
-
-
diff --git a/docs/geode-native-docs-cpp/serialization/dotnet-serialization/serialize-using-ipdxserializable.html.md.erb b/docs/geode-native-docs-cpp/serialization/dotnet-serialization/serialize-using-ipdxserializable.html.md.erb
deleted file mode 100644
index cddda23..0000000
--- a/docs/geode-native-docs-cpp/serialization/dotnet-serialization/serialize-using-ipdxserializable.html.md.erb
+++ /dev/null
@@ -1,120 +0,0 @@
----
-title:  Serialize Using the IPdxSerializable Interface
----
-
-<!--
-Licensed to the Apache Software Foundation (ASF) under one or more
-contributor license agreements.  See the NOTICE file distributed with
-this work for additional information regarding copyright ownership.
-The ASF licenses this file to You under the Apache License, Version 2.0
-(the "License"); you may not use this file except in compliance with
-the License.  You may obtain a copy of the License at
-
-     http://www.apache.org/licenses/LICENSE-2.0
-
-Unless required by applicable law or agreed to in writing, software
-distributed under the License is distributed on an "AS IS" BASIS,
-WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-See the License for the specific language governing permissions and
-limitations under the License.
--->
-
-Use this procedure to program your domain object for PDX serialization using the `IPdxSerializable` Interface. When you write objects using PDX serialization, they are distributed to the server tier in PDX serialized form. When you run queries against the objects on the servers, only the fields you specify are deserialized.
-
-**Procedure**
-
-1.  In your domain class, implement `Apache.Geode.Client.IPdxSerializable`. Example:
-
-    ``` pre
-    using Apache.Geode.Client;
-           ...
-           public class PortfolioPdx : IPdxSerializable
-    ```
-
-2.  If your domain class does not have a zero-arg constructor, create one for it.
-
-    If you also use PDX serialization in Java for the object, serialize the object in the same way for each language. Serialize the same fields in the same order and mark the same identify fields.
-
-3.  Program the `IPdxSerializable ToData` function to serialize your object as required by your application.
-    1.  Write your domain class's standard .NET data fields using the `IPdxWriter` write methods. <%=vars.product_name%> automatically provides `IPdxWriter` to the `ToData` function for `IPdxSerializable` objects.
-    2.  Call the `ToData markIdentifyField` function for each field <%=vars.product_name%> should use to identify your object. This is used to compare objects for operations like `DISTINCT` queries. The `markIdentifyField` call must come after the associated field write methods.
-
-        Example:
-
-        ``` pre
-        // object fields
-        private int m_id;
-        private string m_pkid;
-        private PositionPdx m_position1;
-        private PositionPdx m_position2;
-        private Hashtable m_positions;
-        private string m_type;
-        private string m_status;
-        private string[] m_names;
-        private byte[] m_newVal;
-        private DateTime m_creationDate;
-        private byte[] m_arrayZeroSize;
-        private byte[] m_arrayNull;
-        // ToData
-        public void ToData(IPdxWriter writer)
-        {
-           writer.WriteInt("id", m_id)
-           //identity field
-              .MarkIdentityField("id")
-              .WriteString("pkid", m_pkid)
-              .WriteObject("position1", m_position1)
-              .WriteObject("position2", m_position2)
-        .WriteObject("positions", m_positions)
-        .WriteString("type", m_type)
-        .WriteString("status", m_status)
-        .WriteStringArray("names", m_names)
-        .WriteByteArray("newVal", m_newVal)
-        .WriteDate("creationDate", m_creationDate)
-        .WriteByteArray("arrayNull", m_arrayNull)
-        .WriteByteArray("arrayZeroSize", m_arrayZeroSize);
-        }
-        ```
-
-4.  Program `IPdxSerializable FromData` to read your data fields from the serialized form into the object's fields using the `IPdxReader` read methods. <%=vars.product_name%> automatically provides `IPdxReader` to the `FromData` function for `IPdxSerializable` objects.
-
-    Use the same names as you did in `ToData` and call the read operations in the same order as you called the write operations in your `ToData` implementation.
-
-    Example:
-
-    ``` pre
-    public void FromData(IPdxReader reader)
-       {
-          m_id = reader.ReadInt("id");
-     
-          bool isIdentity = reader.IsIdentityField("id");
-     
-          if (isIdentity == false)
-             throw new IllegalStateException("Portfolio id is identity field");
-     
-          bool isId = reader.HasField("id");
-     
-          if (isId == false)
-             throw new IllegalStateException("Portfolio id field not found");
-     
-          bool isNotId = reader.HasField("ID");
-     
-          if (isNotId == true)
-             throw new IllegalStateException("Portfolio isNotId field found");
-     
-          m_pkid = reader.ReadString("pkid");
-          m_position1 = (PositionPdx)reader.ReadObject("position1");
-          m_position2 = (PositionPdx)reader.ReadObject("position2");
-          m_positions = (Hashtable)reader.ReadObject("positions");
-          m_type = reader.ReadString("type");
-          m_status = reader.ReadString("status");
-          m_names = reader.ReadStringArray("names");
-          m_newVal = reader.ReadByteArray("newVal");
-          m_creationDate = reader.ReadDate("creationDate");
-          m_arrayNull = reader.ReadByteArray("arrayNull");
-          m_arrayZeroSize = reader.ReadByteArray("arrayZeroSize");
-    }
-    ```
-
-5.  Optionally, program your domain object's equals and hashcode methods.
-
-
diff --git a/docs/geode-native-docs-cpp/serialization/dotnet-serialization/serializing-domain-objects.html.md.erb b/docs/geode-native-docs-cpp/serialization/dotnet-serialization/serializing-domain-objects.html.md.erb
deleted file mode 100644
index d3e571a..0000000
--- a/docs/geode-native-docs-cpp/serialization/dotnet-serialization/serializing-domain-objects.html.md.erb
+++ /dev/null
@@ -1,46 +0,0 @@
----
-title:  Serialize Your Domain Objects with IPdxSerializer
----
-
-<!--
-Licensed to the Apache Software Foundation (ASF) under one or more
-contributor license agreements.  See the NOTICE file distributed with
-this work for additional information regarding copyright ownership.
-The ASF licenses this file to You under the Apache License, Version 2.0
-(the "License"); you may not use this file except in compliance with
-the License.  You may obtain a copy of the License at
-
-     http://www.apache.org/licenses/LICENSE-2.0
-
-Unless required by applicable law or agreed to in writing, software
-distributed under the License is distributed on an "AS IS" BASIS,
-WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-See the License for the specific language governing permissions and
-limitations under the License.
--->
-
-For domain objects that you cannot or do not want to modify, use the `IPdxSerializer` class to serialize and deserialize the object's fields.
-
-You use one `IPdxSerializer` implementation for the entire cache, programming it for all of the domain objects that you handle in this way. This way you do not have to implement the `IPdxSerializable` interface for each domain class.
-
-With `IPdxSerializer`, you leave your domain object as-is and handle the serialization and deserialization in the separate serializer. You register the serializer in your cache PDX configuration. Then program the serializer to handle all of the domain objects you need.
-
-If you write your own `IPdxSerializer` and you also use the `ReflectionBasedAutoSerializer`, then the `IPdxSerializer` needs to own the `ReflectionBasedAutoSerializer` and delegate to it. A cache can only have a single `IPdxSerializer` instance.
-
-**Note:**
-The `IPdxSerializer` `toData` and `fromData` methods differ from those for `IPdxSerializable`. They have different parameters and results.
-
-To register an `IPdxSerializer`, you can use the following code. Note that you can only register the `IPdxSerializer` in the application code. It cannot be configured declaratively in `cache.xml`.
-
-Example:
-
-``` pre
-using Apache.Geode.Client;
-...
-// Register a PdxSerializer to serialize
-// domain objects using PDX serialization
- 
-Serializable.RegisterPdxSerializer(new MyPdxSerializer());
-```
-
-
diff --git a/docs/geode-native-docs-cpp/serialization/dotnet-serialization/using-ipdxinstancefactory.html.md.erb b/docs/geode-native-docs-cpp/serialization/dotnet-serialization/using-ipdxinstancefactory.html.md.erb
deleted file mode 100644
index 6534090..0000000
--- a/docs/geode-native-docs-cpp/serialization/dotnet-serialization/using-ipdxinstancefactory.html.md.erb
+++ /dev/null
@@ -1,26 +0,0 @@
----
-title:  Use the IPdxInstanceFactory to Create IPdxInstances
----
-
-<!--
-Licensed to the Apache Software Foundation (ASF) under one or more
-contributor license agreements.  See the NOTICE file distributed with
-this work for additional information regarding copyright ownership.
-The ASF licenses this file to You under the Apache License, Version 2.0
-(the "License"); you may not use this file except in compliance with
-the License.  You may obtain a copy of the License at
-
-     http://www.apache.org/licenses/LICENSE-2.0
-
-Unless required by applicable law or agreed to in writing, software
-distributed under the License is distributed on an "AS IS" BASIS,
-WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-See the License for the specific language governing permissions and
-limitations under the License.
--->
-
-You can use the `IPdxInstanceFactory` to create an `IPdxInstance` from raw data when the domain class is not available on the server.
-
-This option can be useful when you need an instance of a domain class for plug-in code such as a function or a loader. If you have the raw data for the domain object (the class name and each field's type and data), then you can explicitly create a `IPdxInstance`. The `IPdxInstanceFactory` is very similar to the `IPdxWriter` except that after writing each field, you need to call the create method which returns the created `IPdxInstance.`
-
-
diff --git a/docs/geode-native-docs-dotnet/getting-started/app-dev-walkthrough-cpp.html.md.erb b/docs/geode-native-docs-dotnet/getting-started/app-dev-walkthrough-cpp.html.md.erb
deleted file mode 100644
index 707e61c..0000000
--- a/docs/geode-native-docs-dotnet/getting-started/app-dev-walkthrough-cpp.html.md.erb
+++ /dev/null
@@ -1,130 +0,0 @@
----
-title:  C++ Application Development Walkthrough
----
-
-This section describes how to set up a native client development environment using C++ and CMake.
-
-## <a id="prerequisites_cpp"></a>Prerequisites
-This walkthrough assumes that certain components are in place:
-
-- The **<%=vars.product_name%> Native Client libraries**. Install the Native Client as described in
-  [Getting Started with the Native Client](getting-started-nc-client.html). Follow the ease-of-use
-  recommendations by installing the Native Client in a well-known location and renaming it.
-
-| System | Native Client Library Well-Known Location |
-|-----|-----|
-| Linux | /usr/local/nativeclient |
-| Windows | C:\Program Files\nativeclient |
-
-
-- The **CMake** tool suite. Download and install CMake, following the instructions on [cmake.org] (https://cmake.org).
-
-- **Geode**: Install and configure Geode. See the [_Geode User's Guide_](http://geode.apache.org/docs/) for instructions and system requirements.
-
-To develop a Native Client application using C++ and CMake:
-
-  - Create a project directory structure
-  - Populate the project directories with C++ source code
-  - Configure the CMake build environment
-  - Run CMake to build your application
-  - Run your application
-
-## <a id="setting_up_dirs_cpp"></a>Setting up Directories and Sources
-
-1. Create a project directory structure. In this example, the project is called MyProject. The
-directory structure provides a place for your application source files and a `cmake` modules
-directory for project-specific CMake files:
-
-    ```
-    MyProject/
-      cmake/
-        Find<%=vars.product_name%>Native.cmake
-      CMakeLists.txt
-      main.cpp
-    ```
-
-1. Change directory to MyProject and create your application sources. In this example, we have one
-source file, `main.cpp`.
-
-## <a id="configuring_cmake_cpp"></a>Configuring CMake
-
-1. Copy the `Find<%=vars.product_name%>Native.cmake` script from one of the Native Client examples to the `cmake` subdirectory.
-
-1. Create CMakeLists.txt. Copy the file from an example, if you like, as a starting point. The CMakeLists.txt file
-should contain the following CMake instructions:
-
-  - CMake minimum version
-
-    ```
-    cmake_minimum_required(VERSION 3.10)
-    ```
-
-  - Your project name and language
-
-    ```
-    project(MyProject LANGUAGES CXX)
-    ```
-
-  - Minimum language version. For the Native Client, the minimum C++ version is 11.
-
-    ```
-    set(CMAKE_CXX_STANDARD 11)
-    ```
-
-  - Path to the CMake modules directory where the `Find<%=vars.product_name%>Native.cmake` script is located and an instruction
-    telling CMake to use it:
-
-    ```
-    set(CMAKE_MODULE_PATH ${PROJECT_SOURCE_DIR}/cmake)
-    find_package(<%=vars.product_name%>Native REQUIRED COMPONENTS cpp)
-    ```
-
-  - The compilation target and the source(s) to be compiled
-
-    ```
-    add_executable(MyProject main.cpp)
-
-    target_link_libraries(MyProject
-      PUBLIC
-        <%=vars.product_name%>Native::cpp)
-    ```
-
-Combined, the above elements comprise the following CMakeLists.txt:
-
-```
-# CMakeLists.txt for C++ Native Client App
-cmake_minimum_required(VERSION 3.10)
-
-project(MyProject LANGUAGES CXX)
-
-set(CMAKE_CXX_STANDARD 11)
-
-set(CMAKE_MODULE_PATH ${PROJECT_SOURCE_DIR}/cmake)
-
-find_package(<%=vars.product_name%>Native REQUIRED COMPONENTS cpp)
-
-add_executable(MyProject main.cpp)
-
-target_link_libraries(MyProject
-  PUBLIC
-    <%=vars.product_name%>Native::cpp)
-```
-
-## <a id="building_the_app_cpp"></a>Building the App
-
-1. Create a build directory and set it as your current directory:
-
-    ```
-    $ mkdir build
-    $ cd build
-    ```
-
-1. Run CMake twice, once to configure the build, then again to perform the build, generating the executable application.
-
-    ```
-    $ cmake ..
-    $ cmake --build .
-    ```
-
-This creates the executable application in your build directory.
-
diff --git a/docs/geode-native-docs-dotnet/getting-started/app-dev-walkthrough-dotnet.html.md.erb b/docs/geode-native-docs-dotnet/getting-started/app-dev-walkthrough-dotnet.html.md.erb
index d1198e6..7e815fe 100644
--- a/docs/geode-native-docs-dotnet/getting-started/app-dev-walkthrough-dotnet.html.md.erb
+++ b/docs/geode-native-docs-dotnet/getting-started/app-dev-walkthrough-dotnet.html.md.erb
@@ -8,7 +8,7 @@ This section describes how to set up a .NET native client development environmen
 This walkthrough assumes that certain components are in place:
 
 - The **<%=vars.product_name%> Native Client libraries**. Install the Native Client as described in
-  [Getting Started with the Native Client](getting-started-nc-client.html). Follow the ease-of-use
+  [Getting Started with the Native Library](getting-started-nc-client.html). Follow the ease-of-use
   recommendations by installing the Native Client in `C:\Program Files\nativeclient`.
 
 - The **CMake** tool suite. Download and install CMake, following the instructions on [cmake.org] (https://cmake.org).
diff --git a/docs/geode-native-docs-dotnet/security/SampleAuth.cpp b/docs/geode-native-docs-dotnet/security/SampleAuth.cpp
deleted file mode 100644
index 026f86f..0000000
--- a/docs/geode-native-docs-dotnet/security/SampleAuth.cpp
+++ /dev/null
@@ -1,92 +0,0 @@
-/*
- * Licensed to the Apache Software Foundation (ASF) under one or more
- * contributor license agreements.  See the NOTICE file distributed with
- * this work for additional information regarding copyright ownership.
- * The ASF licenses this file to You under the Apache License, Version 2.0
- * (the "License"); you may not use this file except in compliance with
- * the License.  You may obtain a copy of the License at
- *
- *      http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-#include <iostream>
-
-#include <geode/CacheFactory.hpp>
-#include <geode/PoolManager.hpp>
-#include <geode/RegionFactory.hpp>
-#include <geode/RegionShortcut.hpp>
-#include <geode/AuthInitialize.hpp>
-
-using namespace apache::geode::client;
-
-constexpr auto SECURITY_USERNAME = "security-username";
-constexpr auto SECURITY_PASSWORD = "security-password";
-
-class UserPasswordAuthInit : public AuthInitialize {
-public:
-  UserPasswordAuthInit() = default;
-  
-  ~UserPasswordAuthInit() noexcept override = default;
-  
-  std::shared_ptr<Properties> getCredentials(
-    const std::shared_ptr<Properties> &securityprops,
-    const std::string &) override {
-    std::shared_ptr<Cacheable> userName;
-    if (securityprops == nullptr ||
-      (userName = securityprops->find(SECURITY_USERNAME)) == nullptr) {
-      throw AuthenticationFailedException(
-      "UserPasswordAuthInit: user name "
-      "property [SECURITY_USERNAME] not set.");
-    }
-  
-    auto credentials = Properties::create();
-    credentials->insert(SECURITY_USERNAME, userName->toString().c_str());
-    auto passwd = securityprops->find(SECURITY_PASSWORD);
-    if (passwd == nullptr) {
-      passwd = CacheableString::create("");
-    }
-    credentials->insert(SECURITY_PASSWORD, passwd->value().c_str());
-    return credentials;
-  }
-
-  void close() override { return; }
-};
-
-int main(int argc, char** argv) {
-  auto config = Properties::create();
-  config->insert(SECURITY_USERNAME, "root");
-  config->insert(SECURITY_PASSWORD, "root");
-
-  auto cacheFactory = CacheFactory(config);
-  auto authInitialize = std::make_shared<UserPasswordAuthInit>();
-  cacheFactory.set("log-level", "none");
-  cacheFactory.setAuthInitialize(authInitialize);
-
-  auto cache = cacheFactory.create();
-  auto poolFactory = cache.getPoolManager().createFactory();
-
-  poolFactory.addLocator("localhost", 10334);
-  auto pool = poolFactory.create("pool");
-  auto regionFactory = cache.createRegionFactory(RegionShortcut::PROXY);
-  auto region = regionFactory.setPoolName("pool").create("example_userinfo");
-
-  region->put("rtimmons", "Robert Timmons");
-  region->put("scharles", "Sylvia Charles");
-
-  auto user1 = region->get("rtimmons");
-  auto user2 = region->get("scharles");
-  std::cout << "  rtimmons = "
-            << std::dynamic_pointer_cast<CacheableString>(user1)->value()
-            << std::endl;
-  std::cout << "  scharles = "
-            << std::dynamic_pointer_cast<CacheableString>(user2)->value()
-            << std::endl;
-
-  cache.close();
-}
diff --git a/docs/geode-native-docs-dotnet/serialization/cpp-serialization/data-as-blob.html.md.erb b/docs/geode-native-docs-dotnet/serialization/cpp-serialization/data-as-blob.html.md.erb
deleted file mode 100644
index e3c45f2..0000000
--- a/docs/geode-native-docs-dotnet/serialization/cpp-serialization/data-as-blob.html.md.erb
+++ /dev/null
@@ -1,25 +0,0 @@
----
-title:  Serializing and Accessing Data as a Blob
----
-
-<!--
-Licensed to the Apache Software Foundation (ASF) under one or more
-contributor license agreements.  See the NOTICE file distributed with
-this work for additional information regarding copyright ownership.
-The ASF licenses this file to You under the Apache License, Version 2.0
-(the "License"); you may not use this file except in compliance with
-the License.  You may obtain a copy of the License at
-
-     http://www.apache.org/licenses/LICENSE-2.0
-
-Unless required by applicable law or agreed to in writing, software
-distributed under the License is distributed on an "AS IS" BASIS,
-WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-See the License for the specific language governing permissions and
-limitations under the License.
--->
-
-If you have data that is best handled as a blob, such as structs that do not contain pointers, use the serializable type `CacheableBytes` . `CacheableBytes` is a blob class that implements the serialization for you.
-
-`CacheableBytes` also provides direct access to the blob data. Because it is not derived from the `CacheableKey` interface, `CacheableBytes` enables you to modify data in place and then put it into the region again to distribute the change.
-
diff --git a/docs/geode-native-docs-dotnet/serialization/cpp-serialization/object-graphs.html.md.erb b/docs/geode-native-docs-dotnet/serialization/cpp-serialization/object-graphs.html.md.erb
deleted file mode 100644
index 182b72d..0000000
--- a/docs/geode-native-docs-dotnet/serialization/cpp-serialization/object-graphs.html.md.erb
+++ /dev/null
@@ -1,23 +0,0 @@
----
-title:  Serializing Object Graphs
----
-
-<!--
-Licensed to the Apache Software Foundation (ASF) under one or more
-contributor license agreements.  See the NOTICE file distributed with
-this work for additional information regarding copyright ownership.
-The ASF licenses this file to You under the Apache License, Version 2.0
-(the "License"); you may not use this file except in compliance with
-the License.  You may obtain a copy of the License at
-
-     http://www.apache.org/licenses/LICENSE-2.0
-
-Unless required by applicable law or agreed to in writing, software
-distributed under the License is distributed on an "AS IS" BASIS,
-WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-See the License for the specific language governing permissions and
-limitations under the License.
--->
-
-If you have a graph of objects where each node can be serializable, the parent node can call `DataOutput::writeObject` to delegate the serialization responsibility to its child nodes. Similarly, your application can call `DataInput::readObject` to deserialize the object graph.
-
diff --git a/docs/geode-native-docs-dotnet/serialization/cpp-serialization/pdx-ignore-unread-fields.html.md.erb b/docs/geode-native-docs-dotnet/serialization/cpp-serialization/pdx-ignore-unread-fields.html.md.erb
deleted file mode 100644
index 1149494..0000000
--- a/docs/geode-native-docs-dotnet/serialization/cpp-serialization/pdx-ignore-unread-fields.html.md.erb
+++ /dev/null
@@ -1,37 +0,0 @@
----
-title:  Configuring PDX to Ignore Unread Fields During Deserialization
----
-
-<!--
-Licensed to the Apache Software Foundation (ASF) under one or more
-contributor license agreements.  See the NOTICE file distributed with
-this work for additional information regarding copyright ownership.
-The ASF licenses this file to You under the Apache License, Version 2.0
-(the "License"); you may not use this file except in compliance with
-the License.  You may obtain a copy of the License at
-
-     http://www.apache.org/licenses/LICENSE-2.0
-
-Unless required by applicable law or agreed to in writing, software
-distributed under the License is distributed on an "AS IS" BASIS,
-WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-See the License for the specific language governing permissions and
-limitations under the License.
--->
-
-Use the `setPdxIgnoreUnreadFields` API to control whether PDX ignores fields that were unread during deserialization.
-
-The default is to preserve unread fields by including their data during serialization. However, if you configure the cache to ignore unread fields then their data will be lost during serialization.
-
-You should only set this attribute to `true` if you know this member will only be reading cache data. In this use case you do not need to pay the cost of preserving unread fields since you will never reserialize the PDX data.
-
-For example:
-
-``` pre
-CacheFactoryPtr cfPtr = CacheFactory::createCacheFactory(PropertiesObj);
-cfPtr->setPdxReadSerialized(tue);
-cfPtr->setPdxIgnoreUnreadFields(false);
-cachePtr = cfPtr->create();
-```
-
-
diff --git a/docs/geode-native-docs-dotnet/serialization/cpp-serialization/pdx-serialization.html.md.erb b/docs/geode-native-docs-dotnet/serialization/cpp-serialization/pdx-serialization.html.md.erb
deleted file mode 100644
index e39ab50..0000000
--- a/docs/geode-native-docs-dotnet/serialization/cpp-serialization/pdx-serialization.html.md.erb
+++ /dev/null
@@ -1,59 +0,0 @@
----
-title:  Serializing Data with PDX Serialization
----
-
-<!--
-Licensed to the Apache Software Foundation (ASF) under one or more
-contributor license agreements.  See the NOTICE file distributed with
-this work for additional information regarding copyright ownership.
-The ASF licenses this file to You under the Apache License, Version 2.0
-(the "License"); you may not use this file except in compliance with
-the License.  You may obtain a copy of the License at
-
-     http://www.apache.org/licenses/LICENSE-2.0
-
-Unless required by applicable law or agreed to in writing, software
-distributed under the License is distributed on an "AS IS" BASIS,
-WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-See the License for the specific language governing permissions and
-limitations under the License.
--->
-
-PDX is a cross-language data format that can reduce the cost of
-distributing and serializing your objects. PDX stores data in named
-fields that you can access individually to avoid the cost of
-deserializing the entire data object. When you use PDX serialization
-with the C++ client API, you can implement PDX serialization for each
-domain object or register a `PdxSerializer` for the entire cache.
-
-You can also set the object preference of the cache to the `PdxInstance` type, which allows you to access fields of a PDX object without deserializing the entire object.
-
--   **[Serialize Using the PdxSerializable Class](pdxserializable-interface.html)**
-
-    Domain classes need to inherit the `PdxSerializable` abstract class to serialize and de-serialize the object. When you write objects using PDX serialization, they are distributed to the server tier in PDX serialized form.
-
--   **[Serialize Your Domain Objects with PdxSerializer and PdxWrapper](using-pdxserializer.html)**
-
-    For domain objects that you cannot or do not want to modify, use the `PdxSerializer` and the `PdxWrapper` classes to serialize and deserialize the object's fields.
-
--   **[Programming Your Application to Use PdxInstances](using-pdxinstance.html)**
-
-    A `PdxInstance` is a lightweight wrapper around the raw bytes of the PDX serialized objects kept in the cache. It provides applications with run-time access to files of a PDX serialized object. <%=vars.product_name%> provides the implementation of the `PdxInstance` class.
-
--   **[Configuring PDX to Ignore Unread Fields During Deserialization](pdx-ignore-unread-fields.html)**
-
-    Use the `setPdxIgnoreUnreadFields` API to control whether PDX ignores fields that were unread during deserialization.
-
--   **[Using PdxInstanceFactory to Create PdxInstances](using-pdxinstancefactory.html)**
-
-    You can use the `PdxInstanceFactory` API to create a `PdxInstance` from raw data when the domain class is not available on the server.
-
--   **[Using C++ Enum Type with PDX Serialization](using-enum-type-with-pdx.html)**
-
-    Because there is no "object" base type in C++, enums cannot be directly passed as parameters to the `writeObject` and `readObject` API.
-
--   **[Using PDX Serialization with Delta Propagation](pdx-with-delta-propagation.html)**
-
-    To use delta propagation with PDX serialization, you must implement the `Delta` interface methods.
-
-
diff --git a/docs/geode-native-docs-dotnet/serialization/cpp-serialization/pdx-with-delta-propagation.html.md.erb b/docs/geode-native-docs-dotnet/serialization/cpp-serialization/pdx-with-delta-propagation.html.md.erb
deleted file mode 100644
index 4f9bbf4..0000000
--- a/docs/geode-native-docs-dotnet/serialization/cpp-serialization/pdx-with-delta-propagation.html.md.erb
+++ /dev/null
@@ -1,45 +0,0 @@
----
-title:  Using PDX Serialization with Delta Propagation
----
-
-<!--
-Licensed to the Apache Software Foundation (ASF) under one or more
-contributor license agreements.  See the NOTICE file distributed with
-this work for additional information regarding copyright ownership.
-The ASF licenses this file to You under the Apache License, Version 2.0
-(the "License"); you may not use this file except in compliance with
-the License.  You may obtain a copy of the License at
-
-     http://www.apache.org/licenses/LICENSE-2.0
-
-Unless required by applicable law or agreed to in writing, software
-distributed under the License is distributed on an "AS IS" BASIS,
-WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-See the License for the specific language governing permissions and
-limitations under the License.
--->
-
-<a id="concept_F33AC930A8F14F0A9EE07AC31FFD8C8F__section_6C08121D7A034993A7422985FBC9A0D9"></a>
-You can include delta propagation support with PDX serialization by implementing the `Delta` interface methods. 
-However, using delta propagation with PDX will require that you implement Java side classes. The objects will remain in deserialized form at all times on the server and you will lose one of the main benefits of PDX.
-
-In addition, you must set `read-serialized` to `false`. Otherwise, Java objects will be deserialized to instances of `PdxInstance`, which never implements deltas.
-
-The following code snippet is a sample implementation of the Delta interface methods for using with PDX serialization.
-
-``` pre
-class PdxWithDelta : public PdxSerializable, public Delta
-{
-public:
-
-  bool hasDelta();
-  void toDelta(DataOutput& output);
-  void fromDelta(DataInput& input);
-  DeltaPtr clone();
-
-// other PdxSerializable methods here...
-
-};
-```
-
-
diff --git a/docs/geode-native-docs-dotnet/serialization/cpp-serialization/pdxserializable-example.html.md.erb b/docs/geode-native-docs-dotnet/serialization/cpp-serialization/pdxserializable-example.html.md.erb
deleted file mode 100644
index 714980c..0000000
--- a/docs/geode-native-docs-dotnet/serialization/cpp-serialization/pdxserializable-example.html.md.erb
+++ /dev/null
@@ -1,151 +0,0 @@
----
-title:  PdxSerializable Example
----
-
-<!--
-Licensed to the Apache Software Foundation (ASF) under one or more
-contributor license agreements.  See the NOTICE file distributed with
-this work for additional information regarding copyright ownership.
-The ASF licenses this file to You under the Apache License, Version 2.0
-(the "License"); you may not use this file except in compliance with
-the License.  You may obtain a copy of the License at
-
-     http://www.apache.org/licenses/LICENSE-2.0
-
-Unless required by applicable law or agreed to in writing, software
-distributed under the License is distributed on an "AS IS" BASIS,
-WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-See the License for the specific language governing permissions and
-limitations under the License.
--->
-
-## Order.cpp:
-
-Front matter:
-
-    #include "Order.hpp"
-
-`PdxReader` & `PdxWriter` are used for `fromData()` & `toData()`:
-
-    #include <geode/PdxReader.hpp>
-    #include <geode/PdxWriter.hpp>
-
-    namespace customserializable {
-
-- Must provide `fromData()` and `toData()`.
-- Specify the keys in the same order in `fromData()` and `toData()`. Use `PdxReader` and `PdxWriter`:
-
-    ```
-    void Order::fromData(PdxReader& pdxReader) {
-      order_id_ = static_cast<uint32_t>(pdxReader.readLong(ORDER_ID_KEY_));
-      name_ = pdxReader.readString(NAME_KEY_);
-      quantity_ = static_cast<uint16_t>(pdxReader.readInt(QUANTITY_KEY_));
-    }
-
-    void Order::toData(PdxWriter& pdxWriter) const {
-      pdxWriter.writeLong(ORDER_ID_KEY_, order_id_);
-      pdxWriter.markIdentityField(ORDER_ID_KEY_);
-
-      pdxWriter.writeString(NAME_KEY_, name_);
-      pdxWriter.markIdentityField(NAME_KEY_);
-
-      pdxWriter.writeInt(QUANTITY_KEY_, quantity_);
-      pdxWriter.markIdentityField(QUANTITY_KEY_);
-    }
-    ```
-
-Optionally override and add detailed methods as needed. In this example, we override `toString()` and implement `size()` and `classname()`.
-
-    std::string Order::toString() const {
-      return "OrderID: " + std::to_string(order_id_) + " Product Name: " + name_ +
-	     " Quantity: " + std::to_string(quantity_);
-    }
-
-
-    size_t Order::objectSize() const {
-      auto objectSize = sizeof(Order);
-      objectSize += name_.capacity();
-      return objectSize;
-    }
-
-
-    const std::string& Order::getClassName() const {
-      static const std::string CLASS_NAME = "com.example.Order";
-      return CLASS_NAME;
-    }
-
-Provide a constructor in a parameter-less wrapper that can be called to create a prototypical instance (called `createDeserializable()` here).
-
-    std::shared_ptr<PdxSerializable> Order::createDeserializable() {
-      return std::make_shared<Order>(0, "", 0);
-    }
-
-    const std::string Order::ORDER_ID_KEY_ = "order_id";
-    const std::string Order::NAME_KEY_ = "name";
-    const std::string Order::QUANTITY_KEY_ = "quantity";
-
-    }  // namespace customserializable
-
-## main.cpp
-
-Front matter. You will need `TypeRegistry` to register your PdxSerializable class. Bring in the customary includes for I/O and cache, pool, and region creation.
-
-    #include <iostream>
-    #include <sstream>
-
-    #include <geode/CacheFactory.hpp>
-    #include <geode/PoolManager.hpp>
-    #include <geode/RegionFactory.hpp>
-    #include <geode/RegionShortcut.hpp>
-    #include <geode/TypeRegistry.hpp>
-
-    #include "Order.hpp"
-
-    using namespace apache::geode::client;
-    using namespace customserializable;
-
-
-    int main(int argc, char** argv) {
-      auto cacheFactory = CacheFactory();
-      cacheFactory.set("log-level", "none");
-      auto cache = cacheFactory.create();
-
-      auto poolFactory = cache.getPoolManager().createFactory();
-      poolFactory.addLocator("localhost", 10334);
-      auto pool = poolFactory.create("pool");
-
-      auto regionFactory = cache.createRegionFactory(RegionShortcut::PROXY);
-      auto region = regionFactory.setPoolName("pool").create("custom_orders");
-
-
-      cache.getTypeRegistry().registerPdxType(Order::createDeserializable);
-
-
-      std::cout << "Create orders" << std::endl;
-      auto order1 = std::make_shared<Order>(1, "product x", 23);
-      auto order2 = std::make_shared<Order>(2, "product y", 37);
-
-      std::cout << "Storing orders in the region" << std::endl;
-      region->put("Customer1", order1);
-      region->put("Customer2", order2);
-
-      std::cout << "Getting the orders from the region" << std::endl;
-
-      if (auto order1retrieved =
-	      std::dynamic_pointer_cast<Order>(region->get("Customer1"))) {
-	std::cout << "OrderID: " << order1retrieved->getOrderId() << std::endl;
-	std::cout << "Product Name: " << order1retrieved->getName() << std::endl;
-	std::cout << "Quantity: " << order1retrieved->getQuantity() << std::endl;
-      } else {
-	std::cout << "Order 1 not found." << std::endl;
-      }
-
-      if (auto order2retrieved = region->get("Customer2")) {
-	std::cout << order2retrieved->toString() << std::endl;
-      } else {
-	std::cout << "Order 2 not found." << std::endl;
-      }
-
-
-      cache.close();
-    }
diff --git a/docs/geode-native-docs-dotnet/serialization/cpp-serialization/pdxserializable-interface.html.md.erb b/docs/geode-native-docs-dotnet/serialization/cpp-serialization/pdxserializable-interface.html.md.erb
deleted file mode 100644
index 56cb7fa..0000000
--- a/docs/geode-native-docs-dotnet/serialization/cpp-serialization/pdxserializable-interface.html.md.erb
+++ /dev/null
@@ -1,114 +0,0 @@
----
-title:  Serialize Using the PdxSerializable Class
----
-
-<!--
-Licensed to the Apache Software Foundation (ASF) under one or more
-contributor license agreements.  See the NOTICE file distributed with
-this work for additional information regarding copyright ownership.
-The ASF licenses this file to You under the Apache License, Version 2.0
-(the "License"); you may not use this file except in compliance with
-the License.  You may obtain a copy of the License at
-
-     http://www.apache.org/licenses/LICENSE-2.0
-
-Unless required by applicable law or agreed to in writing, software
-distributed under the License is distributed on an "AS IS" BASIS,
-WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-See the License for the specific language governing permissions and
-limitations under the License.
--->
-
-When you write objects using PDX serialization, they are distributed to the server tier in PDX serialized form.
-Domain classes need to inherit the `PdxSerializable` abstract class to serialize and de-serialize the object.
-
-When you run queries against the objects on the servers, only the fields you specify are deserialized.
-A domain class should serialize and de-serialize all its member fields in the same order in its `toData` and `fromData` methods.
-
-Use this procedure to program your domain object for PDX serialization using the `PdxSerializable` abstract class.
-
-1.  In your domain class, implement `PdxSerializable`. Example:
-
-    ``` pre
-    class PdxObject: public PdxSerializable
-    ```
-
-2.  Program the `toData` function to serialize your object as required by your application.
-    <br><br>
-    If you also use PDX serialization in Java or .NET for the object, serialize the object in the same way for each language. Serialize the same fields in the same order and mark the same identity fields.
-
-3.  Program the `fromData` method to read your data fields from the serialized form into the object's fields.
-    <br><br>
-    In your `fromData` implementation, use the same name as you did in `toData` and call the read operations in the same order as you called the write operations in your `toData` implementation.
-
-4.  Optionally, program your domain object's `hashCode` and equality methods.
-    <br><br>
-    Use the `markIdentityField` method to indicate that the given field name should be included in `hashCode` and equality checks of this object on a server.
-    <br><br>
-    The fields that are marked as identity fields are used to generate the `hashCode` and equality methods of PdxInstance. Because of this, the identity fields should themselves either be primitives, or implement `hashCode` and equals.
-    <br><br>
-    If no fields are set as identity fields, then all fields will be used in `hashCode` and equality checks. The identity fields should make marked after they are written using a `write*` method.
-
-## <a class="no-quick-link" id="pdx-serializable-example"></a>PdxSerializable Example
-
-``` pre
-class PdxObject: public PdxSerializable {
-
-private:
-    uint32_t m_id;
-    char* m_str;
-
-public:
-    PdxObject(){};
-    PdxObject(uint32_t id, char* str);
-    virtual ~PdxObject();
-
-    uint32_t getID() {
-        return m_id;
-    }
-
-    char* getStr(){
-        return m_str;
-    }
-
-    virtual void toData(PdxWriterPtr pw) const;
-    virtual void fromData(PdxReaderPtr pr);
-    CacheableStringPtr toString() const;
-    virtual char* getClassName() const;
-    static Cacheable* createDeserializable() {
-        return new PdxObject();
-    }
-};
-
-PdxObject::PdxObject(uint32_t i, char* str) {
-    m_id = i;
-    m_str = str;
-}
-
-PdxObject::~PdxObject() {
-}
-
-void PdxObject::toData( PdxWriterPtr pw ) const {
-    pw->writeInt("id", m_id);
-       pw->markIdentityField("id");
-    pw->writeString("str", m_str);
-}
-
-void  PdxObject::fromData( PdxReaderPtr pr )
-{
-    m_id = pr->readInt("id");
-    m_str = pr->readString("str");
-}
-
-char* getClassName() const{
-{
-    return "com.example.PdxType";
-}
-
-CacheableStringPtr PdxObject::toString() const {
-       char idbuf[1024];
-       sprintf(idbuf,"PdxObject: [ ID=%d ]",m_id);
-       return CacheableString::create( idbuf );
-}
-```
-
diff --git a/docs/geode-native-docs-dotnet/serialization/cpp-serialization/performing-ops-with-pdx-object.html.md.erb b/docs/geode-native-docs-dotnet/serialization/cpp-serialization/performing-ops-with-pdx-object.html.md.erb
deleted file mode 100644
index f9c8ec4..0000000
--- a/docs/geode-native-docs-dotnet/serialization/cpp-serialization/performing-ops-with-pdx-object.html.md.erb
+++ /dev/null
@@ -1,60 +0,0 @@
----
-title:  Performing put, get, and localDestroy Operations with a PDX Domain Object
----
-
-<!--
-Licensed to the Apache Software Foundation (ASF) under one or more
-contributor license agreements.  See the NOTICE file distributed with
-this work for additional information regarding copyright ownership.
-The ASF licenses this file to You under the Apache License, Version 2.0
-(the "License"); you may not use this file except in compliance with
-the License.  You may obtain a copy of the License at
-
-     http://www.apache.org/licenses/LICENSE-2.0
-
-Unless required by applicable law or agreed to in writing, software
-distributed under the License is distributed on an "AS IS" BASIS,
-WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-See the License for the specific language governing permissions and
-limitations under the License.
--->
-
-This topic demonstrates how you can perform operations on a PDX domain object after you have implemented PDX serializable in your domain class.
-
-For example, you can perform operations like put, get, and localDestroy with the domain class you defined for PDX serialization in the [PdxSerializable Example](pdxserializable-interface.html#pdx-serializable-example).
-
-To perform operations, you could write the following application code:
-
-1.  Register the PDX domain class.
-
-    ``` pre
-    Serializable::registerPdxType(PdxObject::createDeserializable);
-    ```
-
-2.  Create the PDX domain object `PdxObject`.
-
-    ``` pre
-    CacheablePtr pdxobj(new PdxObject(100, "Value-1"));
-    CacheableKeyPtr keyport = CacheableKey::create("ABC");
-    ```
-
-3.  Here's an example of a put operation.
-
-    ``` pre
-    rptr->put(keyport, pdxobj);
-    ```
-
-4.  Here's an example of locally destroying the entry.
-
-    ``` pre
-    rptr->localDestroy(keyport);
-    ```
-
-5.  Here's an example of a get operation.
-
-    ``` pre
-    PdxObject *obj2 = dynamic_cast<PdxObject *> ((rptr->get(keyport)).ptr());
-    LOGINFO("Debug:Returned ID = %d", obj2->getID());
-    ```
-
-
diff --git a/docs/geode-native-docs-dotnet/serialization/cpp-serialization/serialization-options.html.md.erb b/docs/geode-native-docs-dotnet/serialization/cpp-serialization/serialization-options.html.md.erb
deleted file mode 100644
index 1e49872..0000000
--- a/docs/geode-native-docs-dotnet/serialization/cpp-serialization/serialization-options.html.md.erb
+++ /dev/null
@@ -1,85 +0,0 @@
----
-title:  Data Serialization Options
----
-
-<!--
-Licensed to the Apache Software Foundation (ASF) under one or more
-contributor license agreements.  See the NOTICE file distributed with
-this work for additional information regarding copyright ownership.
-The ASF licenses this file to You under the Apache License, Version 2.0
-(the "License"); you may not use this file except in compliance with
-the License.  You may obtain a copy of the License at
-
-     http://www.apache.org/licenses/LICENSE-2.0
-
-Unless required by applicable law or agreed to in writing, software
-distributed under the License is distributed on an "AS IS" BASIS,
-WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-See the License for the specific language governing permissions and
-limitations under the License.
--->
-
-The C++ client API gives two serialization options: <%=vars.product_name%> PDX serialization and the `apache::geode::client::DataSerializable` interface.
-
-<%=vars.product_name%> Portable Data eXchange (PDX) serialization is the recommended option. PDX
-serialization provides portability for PDX serializable objects so that clients can share data with
-Java servers and other non-C++ clients. PDX is a cross-language data format that can reduce the cost
-of distributing and serializing your objects. PDX stores data in named fields that you can access
-individually in order to avoid the cost of deserializing the entire data object. PDX also allows you
-to mix versions of objects where you have added or removed fields.
-
-When using PDX serialization, you can use either `PdxSerializable` (for a specific domain object) or `PdxSerializer` (for all your domain objects).
-
-`PdxSerializable` is used when the domain class that a user wants to serialize/deserialize is inherited from the `PdxSerializable` interface, and the user has registered the domain class using the `registerPdxType(domainClass)` API.
-
-`PdxSerializer` is used when a user has registered a domain class for serialization in the cache using the `registerPdxSerializer` API.
-
-The non-PDX serialization option is to use the `apache::geode::client::DataSerializable` interface. This
-`DataSerializable` interface can be a good option performance-wise if the size of your objects is
-small. `DataSerializable` is used whenever a user domain class is not inherited by `PdxSerializable`,
-but the user has registered the class with the `registerType` API.
-
-<table>
-<caption><span class="tablecap">Table 1. Serialization Options—Comparison of Features</span></caption>
-<colgroup>
-<col width="50%" />
-<col width="25%" />
-<col width="25%" />
-</colgroup>
-<thead>
-<tr class="header">
-<th>Capability</th>
-<th>DataSerializable</th>
-<th>PdxSerializable</th>
-</tr>
-</thead>
-<tbody>
-<tr class="odd">
-<td><p>Handles multiple versions of domain objects</p></td>
-<td></td>
-<td>X</td>
-</tr>
-<tr class="even">
-<td><p>Provides single field access on servers of serialized data, without full deserialization. Supported also for OQL queries.</p></td>
-<td></td>
-<td>X</td>
-</tr>
-<tr class="odd">
-<td><p>Automatically ported to other languages by <%=vars.product_name%> - no need to program Java-side implementation</p></td>
-<td></td>
-<td>X</td>
-</tr>
-<tr class="even">
-<td><p>Works with Geode delta propagation</p></td>
-<td>X</td>
-<td>X</td>
-</tr>
-</tbody>
-</table>
-
-<span class="tablecap">**Table 1.** Serialization Options—Comparison of Features</span>
-
-## Important points to remember when using DataSerializable
-
-1. Make sure to register the proper typeId when registering custom classes that have a corresponding server side jar (e.g. Portfolio and Position)
-2. Make sure to register any custom types in each process that uses those types. The cppcache framework uses four separate processes.
diff --git a/docs/geode-native-docs-dotnet/serialization/cpp-serialization/serialization-overview.html.md.erb b/docs/geode-native-docs-dotnet/serialization/cpp-serialization/serialization-overview.html.md.erb
deleted file mode 100644
index 6c5ba24..0000000
--- a/docs/geode-native-docs-dotnet/serialization/cpp-serialization/serialization-overview.html.md.erb
+++ /dev/null
@@ -1,47 +0,0 @@
----
-title:  Data Serialization &ndash; C++
----
-
-<!--
-Licensed to the Apache Software Foundation (ASF) under one or more
-contributor license agreements.  See the NOTICE file distributed with
-this work for additional information regarding copyright ownership.
-The ASF licenses this file to You under the Apache License, Version 2.0
-(the "License"); you may not use this file except in compliance with
-the License.  You may obtain a copy of the License at
-
-     http://www.apache.org/licenses/LICENSE-2.0
-
-Unless required by applicable law or agreed to in writing, software
-distributed under the License is distributed on an "AS IS" BASIS,
-WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-See the License for the specific language governing permissions and
-limitations under the License.
--->
-
-All data moving out of the client cache must be serializable.
-
--   **[Data Serialization Options](serialization-options.html)**
-
-    The C++ client API provides two serialization options:  <%=vars.product_name%> PDX serialization and the `apache::geode::client::DataSerializable` interface.
-
--   **[Using PDX Serialization](pdx-serialization.html)**
-
-    PDX is a cross-language data format that can reduce the cost of distributing and serializing your
-objects. PDX stores data in named fields that you can access individually to avoid the cost of
-deserializing the entire data object. When you use PDX serialization with a C++ client, you can
-implement PDX serialization for each domain object or register a PdxSerializer for the entire cache.
-
--   **[Serializing Data with the DataSerializable Interface](serialization-using-serializable.html)**
-
-    The C++ client API provides a `DataSerializable` interface that you can use for fast and compact data serialization. This section discusses the <%=vars.product_name%> DataSerializable interface and presents implementation examples.
-
--   **[Serializing Object Graphs](object-graphs.html)**
-
-    If you have a graph of objects where each node can be serializable, the parent node can call `DataOutput::writeObject` to delegate the serialization responsibility to its child nodes. Similarly, your application can call `DataInput::readObject` to deserialize the object graph.
-
--   **[Serializing and Accessing Data as a Blob](data-as-blob.html)**
-
-    If you have data that is best handled as a blob, such as structs that do not contain pointers, use the serializable type `CacheableBytes` . `CacheableBytes` is a blob class that implements the serialization for you.
-
-
diff --git a/docs/geode-native-docs-dotnet/serialization/cpp-serialization/serialization-using-serializable.html.md.erb b/docs/geode-native-docs-dotnet/serialization/cpp-serialization/serialization-using-serializable.html.md.erb
deleted file mode 100644
index 5ba377d..0000000
--- a/docs/geode-native-docs-dotnet/serialization/cpp-serialization/serialization-using-serializable.html.md.erb
+++ /dev/null
@@ -1,271 +0,0 @@
----
-title:  Serializing Data with the DataSerializable Interface
----
-
-<!--
-Licensed to the Apache Software Foundation (ASF) under one or more
-contributor license agreements.  See the NOTICE file distributed with
-this work for additional information regarding copyright ownership.
-The ASF licenses this file to You under the Apache License, Version 2.0
-(the "License"); you may not use this file except in compliance with
-the License.  You may obtain a copy of the License at
-
-     http://www.apache.org/licenses/LICENSE-2.0
-
-Unless required by applicable law or agreed to in writing, software
-distributed under the License is distributed on an "AS IS" BASIS,
-WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-See the License for the specific language governing permissions and
-limitations under the License.
--->
-
-The C++ client API provides a `DataSerializable` interface that you can use for fast and compact
-data serialization. 
-
-<%=vars.product_name%> Portable Data eXchange (PDX) serialization is the recommended option,
-but the `DataSerializable` interface can be a good option performance-wise if the size of your objects
-is small. 
-
-This section discusses the <%=vars.product_name%> `DataSerializable` interface, and
-presents implementation examples.
-
-## <a id="concept_696AB5206C3E45898CC1A24CDD93D003__section_8143F965A8C6495E8AB104FD36DA366A" class="no-quick-link"></a>How Serialization Works
-
-When your application puts an object into the cache for subsequent distribution, <%=vars.product_name%> serializes the data by taking these steps:
-
-1.  Calls the appropriate `classId` function.
-2.  Writes the full `typeId` using the `classId` for the instance.
-3.  Invokes the instance’s `toData` function.
-
-When your application subsequently receives a byte array, <%=vars.product_name%> takes the following steps:
-
-1.  Decodes the `typeId`, extracts the `classId` from the `typeId`, then creates an object of the designated type using the registered factory functions.
-
-2.  Invokes the `fromData` function with input from the data stream.
-3.  Decodes the data, then populates the data fields.
-
-## <a id="concept_696AB5206C3E45898CC1A24CDD93D003__section_786CF85FD80E4FE391135460E04D46CC" class="no-quick-link"></a>Implementing the DataSerializable Interface
-
-To store your own data types in the cache, you need to derive a new subclass from the `DataSerializable`
-interface. In practical terms, this means that you need to implement a small set of helper
-functions:
-
-1.  Write a `toData` function that serializes your data.
-
-    ``` pre
-    void toData (DataOutput& output)
-    ```
-
-    The `toData` function is responsible for copying all of the object’s data fields to the object stream.
-    The `DataOutput` class represents the output stream and provides methods for writing the primitives in a network byte order.
-
-2.  Write a `fromData` function that consumes a data input stream and repopulates the object’s data fields.
-
-    ``` pre
-    void fromData (DataInput& input)
-    ```
-
-    The `DataInput` class represents the input stream and provides methods for reading input
-    elements. The `fromData` function must read the elements of the input stream in the same order
-    that they were written by `toData`.
-
-## Example 1. The Simple Class BankAccount
-
-This example demonstrates a simple `BankAccount` class that encapsulates two `ints`, `ownerId` and `accountId`:
-
-``` pre
-class BankAccount
-{
-   private:
- 
-   int m_ownerId;
-   int m_accountId;
- 
-   public:
- 
-   BankAccount( int owner, int account ): m_ownerId( owner ),
-     m_accountId( account ) {}
- 
-   int getOwner( )
-   {
-      return m_ownerId;
-   }
- 
-   int getAccount( )
-   {
-      return m_accountId;
-   }
- 
-};
-```
-
-To make `BankAccount` serializable, you would need to derive the class from `DataSerializable` and implement the following:
-
--   `toData` — a function to serialize the data.
--   `fromData` — a function to deserialize the data.
--   `getClassId` — a function to provide a unique integer for the class.
--   `TypeFactoryMethod` — a pointer to a function that returns a `DataSerializable*` to an uninitialized instance of the type.
-
-## Example 2. Implementing a DataSerializable Class
-
-This example shows a code sample that demonstrates how to implement a serializable class.
-
-``` pre
-class BankAccount : public DataSerializable
-{
-   private:
-   int m_ownerId; 
-   int m_accountId;
-   public:
-   BankAccount( int owner, int account ) : m_ownerId( owner ),
-      m_accountId( account ) {}
-
-int getOwner( )
-{
-    return m_ownerId;
-}
-
-int getAccount( )
-{
-    return m_accountId;
-}
-
-// Add the following for the DataSerializable interface
-// Our TypeFactoryMethod
-static DataSerializable* createInstance( )
-{
-    return new BankAccount( 0, 0 );
-}
-
-int32_t getClassId( )
-{
-    return 10; // must be unique per class.
-}
-
-void toData( DataOutput& output )
-{
-    output.writeInt( m_ownerId );
-    output.writeInt( m_accountId );
-}
-
-DataSerializable* fromData( DataInput& input )
-{
-    input.readInt( &m_ownerId );
-    input.readInt( &m_accountId );
-    return this;
-}
-};
-```
-
-## <a id="concept_696AB5206C3E45898CC1A24CDD93D003__section_108942E549CE4DE68FF3956712DEC7AF" class="no-quick-link"></a>Registering the Type
-
-To be able to use the `BankAccount` type, you must register it with the type system so that when an
-incoming stream contains a `BankAccount`, it can be manufactured from the associated
-`TypeFactoryMethod`.
-
-``` pre
-DataSerializable::registerType( BankAccount::createInstance );
-```
-
-Typically, you would register the type before calling the function `DistributedSystem::connect`.
-
-**Note:**
-Type IDs must be unique to only one class.
-
-## <a id="concept_696AB5206C3E45898CC1A24CDD93D003__section_311C3661023C46328B406F26F4F16808" class="no-quick-link"></a>Custom Key Types
-
-If your application uses key types that are too complex to easily force into `CacheableString`, you
-can likely improve performance by deriving a new class from `CacheableKey`. If you have hybrid data
-types you can implement your own derivation of `CacheableKey` that encapsulates the data type.
-
-See below for information about implementing key types for a client that is used with a Java cache server.
-
-To extend a `DataSerializable` class to be a `CacheableKey`, you need to modify the class definition as follows:
-
--   Change the class so that it derives from `CacheableKey` rather than `DataSerializable`.
-
--   Implement `operator==` and `hashcode` functions.
-
-## Example 3. Extending a DataSerializable Class To Be a CacheableKey
-
-This example shows how to extend a serializable class to be a cacheable key.
-
-``` pre
-class BankAccount
-: public CacheableKey
-{
-   private:
-   int m_ownerId;
-   int m_accountId;
-   public:
-   BankAccount( int owner, int account ) : m_ownerId( owner ),
-      m_accountId( account ) {}
-
-int getOwner( )
-{
-    return m_ownerId;
-}
-
-int getAccount( )
-{
-    return m_accountId;
-}
-
-// Our TypeFactoryMethod
-static DataSerializable* createInstance( )
-{
-    return new BankAccount( 0, 0 );
-}
-
-int32_t typeId( )
-{
-    return 1000; // must be unique per class.
-}
-
-void toData( DataOutput& output )
-{
-    output.writeInt( m_ownerId );
-    output.writeInt( m_accountId );
-}
-
-DataSerializable* fromData( DataInput& input )
-{
-    input.readInt( &m_ownerId );
-    input.readInt( &m_accountId );
-    return this;
-}
-
-// Add the following for the CacheableKey interface
-bool operator == ( const CacheableKey& other ) const
-{
-    const BankAccount& otherBA =
-    static_cast<const BankAccount&>( other );
-    return (m_ownerId == otherBA.m_ownerId) && (m_accountId == otherBA.m_accountId);
-}
-
-uint32_t hashcode( ) const
-{
-    return m_ownerId;
-}
-
-virtual int32_t classId( )const
-{
-    return 10; // must be unique per class.
-}
- 
-virtual size_t objectSize() const
-{
-    return 10;
-} 
-};
-```
-
-## <a id="concept_696AB5206C3E45898CC1A24CDD93D003__section_AFB685227E4048BF9FB4FD7C55AED274" class="no-quick-link"></a>Serialization in Native Client Mode with a Java Server
-
-Primitive object types supported in all languages (`CacheableInt32`, `CacheableString`,
-`CacheableBytes`) function without requiring custom definitions with the Java cache server. For the
-keys, the Java cache server has to deserialize them and locate the hashcode to be able to insert the
-internal maps. Because of this, key types for C++ clients used with a Java server are required to be
-registered on the Java server, but the value types do not need to be registered. This needs to be
-done even if there are no Java clients.
-
diff --git a/docs/geode-native-docs-dotnet/serialization/cpp-serialization/using-enum-type-with-pdx.html.md.erb b/docs/geode-native-docs-dotnet/serialization/cpp-serialization/using-enum-type-with-pdx.html.md.erb
deleted file mode 100644
index b8d520e..0000000
--- a/docs/geode-native-docs-dotnet/serialization/cpp-serialization/using-enum-type-with-pdx.html.md.erb
+++ /dev/null
@@ -1,130 +0,0 @@
----
-title:  Using C++ Enum Type with PDX Serialization
----
-
-<!--
-Licensed to the Apache Software Foundation (ASF) under one or more
-contributor license agreements.  See the NOTICE file distributed with
-this work for additional information regarding copyright ownership.
-The ASF licenses this file to You under the Apache License, Version 2.0
-(the "License"); you may not use this file except in compliance with
-the License.  You may obtain a copy of the License at
-
-     http://www.apache.org/licenses/LICENSE-2.0
-
-Unless required by applicable law or agreed to in writing, software
-distributed under the License is distributed on an "AS IS" BASIS,
-WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-See the License for the specific language governing permissions and
-limitations under the License.
--->
-
-Because there is no "object" base type in C++, enums cannot be directly passed as parameters to the `writeObject` and `readObject` API.
-
-To use the C++ enum type with PDX serialization, you have to wrap the `enum` in the `CacheableEnum` class type by specifying classname, enumname and ordinal.
-
-``` pre
-enum enumQuerytest { id1, id2, id3 };
- class TESTOBJECT_EXPORT PdxEnumTestClass :public PdxSerializable
-  {
-  private:
-    int m_id;
-    CacheableEnumPtr m_enumid;
-
-  public:
-    int getID(){
-      return m_id;
-    }
-
-    CacheableEnumPtr getEnumID() {
-      return m_enumid;
-    }
-
-    PdxEnumTestClass(int id)
-    {
-      m_id = id;
-      switch (m_id) {
-        case 0:
-          m_enumid = CacheableEnum::create("enumQuerytest", "id1", id1);
-          break;
-        case 1:
-          m_enumid = CacheableEnum::create("enumQuerytest", "id2", id2);
-          break;
-        case 2:
-          m_enumid = CacheableEnum::create("enumQuerytest", "id3", id3);
-          break;
-        default:
-          m_enumid = CacheableEnum::create("enumQuerytest", "id1", id1);
-          break;
-      }
-    }
-
-    PdxEnumTestClass() { }
-
-    void toData(PdxWriterPtr pw) {
-      pw->writeInt("m_id", m_id);
-      pw->writeObject("m_enumid", m_enumid);
-    }
-
-    void fromData(PdxReaderPtr pr) {
-      m_id = pr->readInt("m_id");
-      m_enumid = pr->readObject("m_enumid");
-    }
-
-    CacheableStringPtr toString() const {
-      return CacheableString::create("PdxEnumTestClass");
-    }
-
-    char* GetClassName() const {
-      return "com.example.PdxEnumTestClass";
-    }
-
-    static PdxSerializable* createDeserializable() {
-      return new PdxEnumTestClass();
-    }
-  };
-```
-
-## <a id="concept_F38FDBC327204B4EB1E0BC74B4C95409__section_3491F76DB8C0464D89418B89372BBAEA" class="no-quick-link"></a>How Puts and Queries Work on Enums
-
-The following code sample demonstrates how put and query operations work when using the C++ enum Type with PDX serialization:
-
-``` pre
-//Creating objects of type PdxEnumTestClass
-PdxEnumTestClassPtr pdxobj1(new PdxEnumTestClass(0));
-PdxEnumTestClassPtr pdxobj2(new PdxEnumTestClass(1));
-PdxEnumTestClassPtr pdxobj3(new PdxEnumTestClass(2));
-
-RegionPtr rptr = getHelper()->getRegion( "DistRegionAck" );
-
-//PUT Operations
-rptr->put( CacheableInt32::create(0), pdxobj1 );
-LOG( "pdxPut 1 completed " );
-
-rptr->put( CacheableInt32::create(1), pdxobj2 );
-LOG( "pdxPut 2 completed " );
-
-rptr->put( CacheableInt32::create(2), pdxobj3 );
-LOG( "pdxPut 3 completed " );
-
-
-//Query
-try {
-    Serializable::registerPdxType(PdxEnumTestClass::createDeserializable);
-    LOG("PdxEnumTestClass Registered Successfully....");
-} catch (geode::IllegalStateException&/* ex*/) {
-    LOG("PdxEnumTestClass IllegalStateException");
-}
-
-RegionPtr rptr = getHelper()->getRegion( "DistRegionAck" );
-SelectResultsPtr results = rptr->query("m_enumid.name = 'id2'");  
-ASSERT(results->size()== 1 , "query result should have one item");
-ResultSetPtr rsptr = dynCast<ResultSetPtr>(results);
-SelectResultsIterator iter = rsptr->getIterator();  
-while (iter.moveNext()) {
-    PdxEnumTestClassPtr re = dynCast<PdxEnumTestClassPtr>(iter.current());
-    ASSERT(re->getID()== 1 , "query should have returned id 1");
-}    
-```
-
-
diff --git a/docs/geode-native-docs-dotnet/serialization/cpp-serialization/using-pdxinstance.html.md.erb b/docs/geode-native-docs-dotnet/serialization/cpp-serialization/using-pdxinstance.html.md.erb
deleted file mode 100644
index e152ee5..0000000
--- a/docs/geode-native-docs-dotnet/serialization/cpp-serialization/using-pdxinstance.html.md.erb
+++ /dev/null
@@ -1,59 +0,0 @@
----
-title:  Programming Your Application to Use PdxInstances
----
-
-<!--
-Licensed to the Apache Software Foundation (ASF) under one or more
-contributor license agreements.  See the NOTICE file distributed with
-this work for additional information regarding copyright ownership.
-The ASF licenses this file to You under the Apache License, Version 2.0
-(the "License"); you may not use this file except in compliance with
-the License.  You may obtain a copy of the License at
-
-     http://www.apache.org/licenses/LICENSE-2.0
-
-Unless required by applicable law or agreed to in writing, software
-distributed under the License is distributed on an "AS IS" BASIS,
-WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-See the License for the specific language governing permissions and
-limitations under the License.
--->
-
-A `PdxInstance` is a lightweight wrapper around the raw bytes of the PDX serialized objects kept in the cache. It provides applications with run-time access to files of a PDX serialized object. <%=vars.product_name%> provides the implementation of the `PdxInstance` class.
-
-You can configure your cache to return a `PdxInstance` when a PDX serialized object is deserialized instead of deserializing the object to a domain class. Preventing deserialization saves both time and memory and does not require you deserialize the object to the domain class.
-
-This configuration can be done in cache.xml by setting the attribute `read-serialized` to `true` on the &lt;pdx&gt; element, or it can be done programmatically using the `CacheFactory::setPdxReadSerialized(bool)` method.
-
-After this preference is configured, any time a PDX object is deserialized, it is deserialized into a `PdxInstance`.
-
-The following is a code sample of using the `setField` API of `PdxInstance` to modify fields:
-
-``` pre
-RegionPtr rptr = getHelper()->getRegion( regionNames[0] );
-CacheableKeyPtr keyport = CacheableKey::create("pdxput");
-CacheableKeyPtr keyport1 = CacheableKey::create("pdxput2");
-
-PdxInstancePtr pIPtr = dynCast<PdxInstancePtr>(rptr->get(keyport));
-LOG( "modifyPdxInstance get complete." );
-
-WritablePdxInstancePtr wpiPtr( pIPtr->createWriter());
-
-ASSERT(pIPtr != NULLPTR, "pIPtr != NULLPTR expected");   
-int val = 0;
-int newVal = 0;
-ASSERT(pIPtr->hasField("m_int32") == true, "m_id1 = true expected");
-pIPtr->getField("m_int32", val);
-wpiPtr->setField("m_int32", val + 1);
-rptr->put(keyport, wpiPtr);  
-PdxInstancePtr newPiPtr = dynCast<PdxInstancePtr>(rptr->get(keyport));  
-ASSERT(newPiPtr->hasField("m_int32") == true, "m_int32 = true expected");
-newPiPtr->getField("m_int32", newVal);  
-ASSERT(val + 1 == newVal, "val + 1 == newVal expected");  
-ASSERT((*pIPtr.ptr() == *newPiPtr.ptr()) == false, 
-       "PdxInstance should not be equal");
-```
-
-In addition to field access, `PdxInstance` also supports field modification using the `setField(fieldName)` method. The `setField` method has copy-on-write semantics. So for the modifications to be stored in the cache, the `PdxInstance` must be put into a region after `setField` has been called one or more times.
-
-
diff --git a/docs/geode-native-docs-dotnet/serialization/cpp-serialization/using-pdxinstancefactory.html.md.erb b/docs/geode-native-docs-dotnet/serialization/cpp-serialization/using-pdxinstancefactory.html.md.erb
deleted file mode 100644
index f1d755b..0000000
--- a/docs/geode-native-docs-dotnet/serialization/cpp-serialization/using-pdxinstancefactory.html.md.erb
+++ /dev/null
@@ -1,134 +0,0 @@
----
-title:  Using PdxInstanceFactory to Create PdxInstances
----
-
-<!--
-Licensed to the Apache Software Foundation (ASF) under one or more
-contributor license agreements.  See the NOTICE file distributed with
-this work for additional information regarding copyright ownership.
-The ASF licenses this file to You under the Apache License, Version 2.0
-(the "License"); you may not use this file except in compliance with
-the License.  You may obtain a copy of the License at
-
-     http://www.apache.org/licenses/LICENSE-2.0
-
-Unless required by applicable law or agreed to in writing, software
-distributed under the License is distributed on an "AS IS" BASIS,
-WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-See the License for the specific language governing permissions and
-limitations under the License.
--->
-
-You can use the `PdxInstanceFactory` API to create a `PdxInstance` from raw data when the domain class is not available on the server.
-
-Creating a `PdxInstance` can be particularly useful when you need an instance of a domain class for plug-in code such as a function or a loader. If you have raw data for the domain object (the class name and each field's type and data), then you can explicitly create a `PdxInstance`. The `PdxInstanceFactory` API is very similar to the `PdxWriter` API except that after writing each field, you need to call the create method which returns the created `PdxInstance`.
-
-## PdxInstance Example
-
-The following is a code example of creating a `PdxInstance`.
-
-``` pre
-class Person
-{
-private:
-  char* m_name;    
-  int m_id;
-  int m_age;
-
-public:
-  Person() { }
-
-  Person(char* name, int id, int age)
-  {
-    m_name = name;
-    m_id = id;
-    m_age = age;
-  }
-
-  char* getName() const
-  {
-    return m_name;
-  }
-  int getID()
-  {
-    return m_id;
-  }
-  int getAge()
-  {
-    return m_age;
-  }
-};
-
-int main(int argc, char ** argv)
-{
-  try
-  {
-    // Create a Cache.
-    CacheFactoryPtr cacheFactory = CacheFactory::createCacheFactory();
-
-    CachePtr cachePtr = cacheFactory->set("cache-xml-file", 
-                "XMLs/clientPdxInstance.xml")->create();          
-
-    LOGINFO("Created the <%=vars.product_name%> Cache");
-
-    // Get the example Region from the Cache which is declared in the 
-    // Cache XML file.
-    RegionPtr regionPtr = cachePtr->getRegion("Person");       
-
-    LOGINFO("Obtained the Region from the Cache.");
- 
-    Person* p = new Person("Jack", 7, 21);
-
-    //PdxInstanceFactory for Person class
-    PdxInstanceFactoryPtr pif = cachePtr->createPdxInstanceFactory("Person");
-    LOGINFO("Created PdxInstanceFactory for Person class");
-
-    pif->writeString("m_name", p->getName());
-    pif->writeInt("m_id", p->getID());
-    pif->markIdentityField("m_id");
-    pif->writeInt("m_age", p->getAge());
-
-    PdxInstancePtr pdxInstance = pif->create();
-
-    LOGINFO("Created PdxInstance for Person class");
-
-    regionPtr->put("Key1", pdxInstance);    
-
-    LOGINFO("Populated PdxInstance Object");
-
-    PdxInstancePtr retPdxInstance = regionPtr->get("Key1");
-
-    LOGINFO("Got PdxInstance Object");
-
-    int id = 0;
-    retPdxInstance->getField("m_id", id);
-
-    int age = 0;
-    retPdxInstance->getField("m_age", age);
-
-    char* name = NULL;
-    retPdxInstance->getField("m_name", &name);
-
-    if (id == p->getID()&& age == p->getAge() && strcmp(name, p->getName()) == 0
-      && retPdxInstance->isIdentityField("m_id") == true)
-      LOGINFO("PdxInstance returns all fields value expected");
-    else
-      LOGINFO("PdxInstance doesn't returns all fields value expected");
-
-    delete p;
-
-    // Close the Cache.
-    cachePtr->close();
-
-    LOGINFO("Closed the Cache");
-
-  }
-  // An exception should not occur
-  catch(const Exception & geodeExcp)
-  {    
-    LOGERROR("PdxInstance Exception: %s", geodeExcp.getMessage());
-  }
-}
-```
-
-
diff --git a/docs/geode-native-docs-dotnet/serialization/cpp-serialization/using-pdxserialization.html.md.erb b/docs/geode-native-docs-dotnet/serialization/cpp-serialization/using-pdxserialization.html.md.erb
deleted file mode 100644
index 23a5cd9..0000000
--- a/docs/geode-native-docs-dotnet/serialization/cpp-serialization/using-pdxserialization.html.md.erb
+++ /dev/null
@@ -1,70 +0,0 @@
----
-title:  Using PDX Serialization
----
-
-<!--
-Licensed to the Apache Software Foundation (ASF) under one or more
-contributor license agreements.  See the NOTICE file distributed with
-this work for additional information regarding copyright ownership.
-The ASF licenses this file to You under the Apache License, Version 2.0
-(the "License"); you may not use this file except in compliance with
-the License.  You may obtain a copy of the License at
-
-     http://www.apache.org/licenses/LICENSE-2.0
-
-Unless required by applicable law or agreed to in writing, software
-distributed under the License is distributed on an "AS IS" BASIS,
-WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-See the License for the specific language governing permissions and
-limitations under the License.
--->
-
-<%=vars.product_name%> Portable Data eXchange (PDX) serialization provides portability for PDX serializable objects so that clients can share data with
-Java servers and other non-C++ clients. PDX stores data in named fields that you can access
-individually in order to avoid the cost of deserializing the entire data object. PDX also allows you
-to mix versions of objects where you have added or removed fields.
-
-When using PDX serialization, you can use either `PdxSerializable` (for a specific domain object) or `PdxSerializer` (for all your domain objects).
-
-**Use `PdxSerializable`** when the object is one whose definition you control. You can embed the serialization/deserialization capability within
-the object, so its conversion from one format to the other is self-contained. You do this by defining an object that inherits from the `PdxSerializable`
-interface, and you register the domain class using the `registerPdxType(domainClass)` API.
-
-**Use `PdxSerializer`** when you cannot or do not wish to modify the object definition, for example, when the object is provided by a third-party.
-You define the serialization/deserialization capability in a separate place, then register the domain class for serialization in the cache using 
-the `registerPdxSerializer` API.
-
-You can also set the object preference of the cache to the `PdxInstance` type, which allows you to access fields of a PDX object without deserializing the entire object.
-
--   **[Serialize Using the PdxSerializable Class](pdxserializable-interface.html)**
-
-    Domain classes need to inherit the `PdxSerializable` abstract class to serialize and de-serialize the object. When you write objects using PDX serialization, they are distributed to the server tier in PDX serialized form.
-
--   **[Performing put, get, and localDestroy Operations with a PDX Domain Object](performing-ops-with-pdx-object.html)**
-    This topic demonstrates how you can perform operations on a PDX domain object after you have implemented PDX serializable in your domain class.
-
--   **[Serialize Your Domain Objects with PdxSerializer and PdxWrapper](using-pdxserializer.html)**
-
-    For domain objects that you cannot or do not want to modify, use the `PdxSerializer` and the `PdxWrapper` classes to serialize and deserialize the object's fields.
-
--   **[Programming Your Application to Use PdxInstances](using-pdxinstance.html)**
-
-    A `PdxInstance` is a lightweight wrapper around the raw bytes of the PDX serialized objects kept in the cache. It provides applications with run-time access to files of a PDX serialized object. <%=vars.product_name%> provides the implementation of the `PdxInstance` class.
-
--   **[Configuring PDX to Ignore Unread Fields During Deserialization](pdx-ignore-unread-fields.html)**
-
-    Use the `setPdxIgnoreUnreadFields` API to control whether PDX ignores fields that were unread during deserialization.
-
--   **[Using PdxInstanceFactory to Create PdxInstances](using-pdxinstancefactory.html)**
-
-    You can use the `PdxInstanceFactory` API to create a `PdxInstance` from raw data when the domain class is not available on the server.
-
--   **[Using C++ Enum Type with PDX Serialization](using-enum-type-with-pdx.html)**
-
-    Because there is no "object" base type in C++, enums cannot be directly passed as parameters to the `writeObject` and `readObject` API.
-
--   **[Using PDX Serialization with Delta Propagation](pdx-with-delta-propagation.html)**
-
-    To use delta propagation with PDX serialization, you must implement the `Delta` interface methods.
-
-
diff --git a/docs/geode-native-docs-dotnet/serialization/cpp-serialization/using-pdxserializer.html.md.erb b/docs/geode-native-docs-dotnet/serialization/cpp-serialization/using-pdxserializer.html.md.erb
deleted file mode 100644
index 20afe61..0000000
--- a/docs/geode-native-docs-dotnet/serialization/cpp-serialization/using-pdxserializer.html.md.erb
+++ /dev/null
@@ -1,119 +0,0 @@
----
-title:  Serialize Your Domain Objects with PdxSerializer and PdxWrapper
----
-
-<!--
-Licensed to the Apache Software Foundation (ASF) under one or more
-contributor license agreements.  See the NOTICE file distributed with
-this work for additional information regarding copyright ownership.
-The ASF licenses this file to You under the Apache License, Version 2.0
-(the "License"); you may not use this file except in compliance with
-the License.  You may obtain a copy of the License at
-
-     http://www.apache.org/licenses/LICENSE-2.0
-
-Unless required by applicable law or agreed to in writing, software
-distributed under the License is distributed on an "AS IS" BASIS,
-WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-See the License for the specific language governing permissions and
-limitations under the License.
--->
-
-For domain objects that you cannot or do not want to modify, use the `PdxSerializer` and the `PdxWrapper` classes to serialize and deserialize the object's fields.
-
-You register a `PdxSerializer` implementation for the entire cache, programming it for all of the domain objects that you handle in this way. This way you do not have to implement the `PdxSerializable` interface for each domain class.
-
-The `PdxSerializer` allows domain classes to be serialized and deserialized as PDXs without modification of the domain class. It requires only that the domain class have a constructor accessible to the `PdxSerializer` to create an instance. The domain class will be held in a wrapper class, `PdxWrapper`.
-
-`PdxSerializer` has the following methods:
-
--   The `toData` method returns true if the PdxSerializer was able to serialize the user object, false if not.
--   If the PdxSerializer was able to deserialize the object, the `fromData` method returns a void pointer to the user object to be wrapped in a `PdxWrapper`.
-
-When you later reference the user object, use the `PdxWrapper` class. `PdxWrapper` holds a shared reference to the object in the local cache and is used during serialization and deserialization. `PdxWrapper` acts as a container for the user domain object and needs to wrap every instance of the object that uses a registered `PdxSerializer`. The object instance will not be modified. In addition, when using `PdxWrapper`, you will need to provide a function pointer to a "deallocator", which  [...]
-
-The following code example defines a user object and a `PdxSerializer`. It then registers the new `PdxSerializer` and then uses `PdxWrapper` to put the object in a region and retrieve the object from a region.
-
-``` pre
-class UserClass
-{
-public:
-
-  int m_int;
-  string m_string;
-
-  UserClass(int intVal, string stringVal)
-  {
-    m_int = intVal;
-    m_string = stringVal;
-  }
-
-  static void deallocate(void * object, char * className)
-  {
-    if (strcmp(className, "com.example.UserClass") == 0) {
-      UserClass * userObject = reinterpret_cast<UserClass*>(object);
-      delete userObject;
-    }
-  }
-};
-
-class UserPdxSerializer : public PdxSerializer
-{
-public:
-
-  void* fromData(char * className, PdxReaderPtr pdxReader)
-  {
-    if (strcmp(className, "com.example.UserClass") != 0) {
-      return NULL;
-    }
-
-    int intVal = pdxReader->readInt("m_int");
-    string stringVal = pdxReader->readString("m_string");
-
-    UserClass * userObject = new UserClass(intVal, stringVal);
-
-    return (void*) userObject;
-  }
-
-  bool toData(void * object, char * className, PdxWriterPtr pdxWriter)
-  {
-    if (strcmp(className, "com.example.UserClass") != 0) {
-      return false;
-    }
-
-    UserClass * userObject = reinterpret_cast<UserClass*>(object);
-
-    pdxWriter->writeInt("m_int", userObject->m_int);
-    pdxWriter->writeString("m_string", userObject->m_string);
-
-    return true;
-  }
-
-  UserDeallocator getDeallocator(char * className)
-  {
-    if (strcmp(className, "com.example.UserClass") == 0) {
-      return UserClass::deallocate;
-    } else {
-      return NULL;
-    }
-  }
-};
-
-// Register a user PDX serializer
-
-Serializable::registerPdxSerializer(new UserPdxSerializer);
-
-// Put a user object into a region.
-
-UserClass * userObject = new UserClass(123, "someValue");
-PdxWrapperPtr pdxWrapper = new PdxWrapper(userObject, "com.example.UserClass", 
-                                          UserClass::deallocate);
-region->put("key", pdxWrapper);
-
-// Get a user object from a region.
-
-pdxWrapper = dynCast<PdxWrapperPtr>(region->get("key"));
-UserClass * userObject = reinterpret_cast<UserClass*>(pdxWrapper->getObject());
-```
-
-


Mime
View raw message