geode-commits mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From dbar...@apache.org
Subject [19/25] geode-native git commit: Simplify doc directory structure - remove redundant top layer
Date Tue, 14 Feb 2017 20:11:20 GMT
http://git-wip-us.apache.org/repos/asf/geode-native/blob/87b6e035/docs/geode-native-docs/dotnet-caching-api/csharp-dotnet-naming-conventions.html.md.erb
----------------------------------------------------------------------
diff --git a/docs/geode-native-docs/dotnet-caching-api/csharp-dotnet-naming-conventions.html.md.erb b/docs/geode-native-docs/dotnet-caching-api/csharp-dotnet-naming-conventions.html.md.erb
new file mode 100644
index 0000000..51f27f9
--- /dev/null
+++ b/docs/geode-native-docs/dotnet-caching-api/csharp-dotnet-naming-conventions.html.md.erb
@@ -0,0 +1,15 @@
+---
+title:  .NET Naming and Usage Conventions
+---
+
+Unless noted, the .NET API classes and functions have the same names as their C++ counterparts in the namespace `GemStone::GemFire::Cache`. In .NET, all method names start with a capital letter.
+
+The .NET interface names match those of comparable C++ interfaces, but with an ’I’ prepended to satisfy .NET naming conventions. For example, the .NET equivalent of the C++ `CacheLoader` interface is `ICacheLoader`.
+
+The name of the Geode `Serializable` interface is `IGFSerializable` because `ISerializable` is a .NET built-in type.
+
+Where possible, get\* and set\* functions are replaced by .NET properties.
+
+You can implement the Geode .NET interfaces. You cannot extend any of the classes because they are marked as sealed.
+
+

http://git-wip-us.apache.org/repos/asf/geode-native/blob/87b6e035/docs/geode-native-docs/dotnet-caching-api/custom-class-igfserializable.html.md.erb
----------------------------------------------------------------------
diff --git a/docs/geode-native-docs/dotnet-caching-api/custom-class-igfserializable.html.md.erb b/docs/geode-native-docs/dotnet-caching-api/custom-class-igfserializable.html.md.erb
new file mode 100644
index 0000000..9cefe3c
--- /dev/null
+++ b/docs/geode-native-docs/dotnet-caching-api/custom-class-igfserializable.html.md.erb
@@ -0,0 +1,136 @@
+---
+title:  Using a Custom Class With IGFSerializable
+---
+
+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 : IGFSerializable   
+   {
+      #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 IGFSerializable CreateInstance()
+      {
+         return new AccountHistory();
+      }
+      #region IGFSerializable Members
+      public IGFSerializable 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
+      }
+```
+
+

http://git-wip-us.apache.org/repos/asf/geode-native/blob/87b6e035/docs/geode-native-docs/dotnet-caching-api/data-serialization-apis.html.md.erb
----------------------------------------------------------------------
diff --git a/docs/geode-native-docs/dotnet-caching-api/data-serialization-apis.html.md.erb b/docs/geode-native-docs/dotnet-caching-api/data-serialization-apis.html.md.erb
new file mode 100644
index 0000000..d509b21
--- /dev/null
+++ b/docs/geode-native-docs/dotnet-caching-api/data-serialization-apis.html.md.erb
@@ -0,0 +1,23 @@
+---
+title:  Data Serialization APIs
+---
+
+Use either `IPdxSerializable` or `IGFSerializable` for each region. Do not mix the two.
+
+For more information on these options, see [Data Serialization](dotnet-data-serialization.html#concept_28A7797A0342447ABF6A5014E0DCB05F).
+
+-   **IPdxSerializable interface**. Provides a flexible way to serialize your domain objects for cache storage and transfer to the servers. This is a Geode built-in serialization framework. See [Data Serialization](dotnet-data-serialization.html#concept_28A7797A0342447ABF6A5014E0DCB05F).
+-   **IPdxReader**. Supplies operations for reading data from Geode IPDXSerializable types.
+-   **IPdxWriter**. Provides operations for writing data into Geode IPDXSerializable types.
+-   **IPdxInstance**. Instance of a PDX serialized object that you can use to access the object’s data without having to deserialize the object first.
+-   **IPdxInstanceFactory**. Allows you to build an IPdxInstance using raw data.
+-   **IPdxTypeMapper interface**. Allows you to map .NET type names to Java type names when using PDX serialization.
+-   **IGFSerializable interface**. Superclass of one set of user objects that can be serialized and stored in the cache. These are Geode built-in serializable types. See [Data Serialization](dotnet-data-serialization.html#concept_28A7797A0342447ABF6A5014E0DCB05F).
+-   **Serializable class**. Wraps the native C++ `gemfire::Serializable` objects as managed `IGFSerializable` objects. Whenever native C++ clients and .NET clients interoperate and are part of the same distributed system, the user-defined types that are put by the native C++ clients that have not been defined in .NET are returned as objects of this class.
+
+    The API contains overloads for most Region methods and other methods that take `Serializable` as a value and that are more optimized than the more generic `IGFSerializable` overloads. The application prefers using these overloads whenever the base class of an object is `Serializable`.
+
+-   **DataInput**. Supplies operations for reading primitive data values and user-defined objects from a byte stream.
+-   **DataOutput**. Provides operations for writing primitive data values and user-defined objects implementing `IGFSerializable` to an integer.
+
+

http://git-wip-us.apache.org/repos/asf/geode-native/blob/87b6e035/docs/geode-native-docs/dotnet-caching-api/dotnet-accessing-an-entry.html.md.erb
----------------------------------------------------------------------
diff --git a/docs/geode-native-docs/dotnet-caching-api/dotnet-accessing-an-entry.html.md.erb b/docs/geode-native-docs/dotnet-caching-api/dotnet-accessing-an-entry.html.md.erb
new file mode 100644
index 0000000..7ba4a4a
--- /dev/null
+++ b/docs/geode-native-docs/dotnet-caching-api/dotnet-accessing-an-entry.html.md.erb
@@ -0,0 +1,34 @@
+---
+title:  Accessing an Entry
+---
+
+The region entry retrieval methods return the value associated with the specified key, and pass the callback argument to any cache loaders or cache writers that are invoked during the operation.
+
+If the value is not available locally, it is requested from the server. If the server request is unsuccessful, a local cache loader is invoked, if one is available. The operation throws `keyNotFoundException` if the `Region` is unable to retrieve a value through any of these means.
+
+## Using the Region API to Retrieve Values From the Cache
+
+Here, the program retrieves two entries from the region.
+
+``` pre
+string value1 = region1["Key1"];
+string value2 = region1["Key2"];
+ 
+int valueA = region2["KeyA"];
+int valueB = region2["KeyB"];
+ 
+string valueQ = region.Get(111, null);
+string valueR = region.Get(222, null);
+```
+
+## Batch Operations—Using getAll to Return Values from Multiple Entries
+
+The `GetAll` region API returns values for collection of keys from the local cache or server.
+
+If value for a key is not present locally, then it is requested from the Java server. The value returned is not copied, so multi-threaded applications should not modify the value directly but should use the update methods.
+
+This method is not applicable to local region instances.
+
+This operation updates the `CacheStatistics.LastAccessedTime`, `CacheStatistics.HitCount` statistics and `CacheStatistics.MissCount` for this region and the returned entries.
+
+

http://git-wip-us.apache.org/repos/asf/geode-native/blob/87b6e035/docs/geode-native-docs/dotnet-caching-api/dotnet-adding-entry-to-cache.html.md.erb
----------------------------------------------------------------------
diff --git a/docs/geode-native-docs/dotnet-caching-api/dotnet-adding-entry-to-cache.html.md.erb b/docs/geode-native-docs/dotnet-caching-api/dotnet-adding-entry-to-cache.html.md.erb
new file mode 100644
index 0000000..f633e56
--- /dev/null
+++ b/docs/geode-native-docs/dotnet-caching-api/dotnet-adding-entry-to-cache.html.md.erb
@@ -0,0 +1,29 @@
+---
+title:  Adding an Entry to the Cache
+---
+
+You populate a native client region with cache entries by using the generic `IDictionary` API or by using the .NET `Region.Put` or the `Region.Create` API functions.
+
+The `Put` function places a new value into a region entry with the specified key, while the `Create` function creates a new entry in the region. The `Put` and `Create` functions provide a user-defined parameter object to any cache writer invoked in the process.
+
+If a value for the entry key already exists in the cache when you add an entry, Geode overwrites the previously cached value. New values in the cache are propagated to the connected cache server.
+
+The .NET Generics provide type safety, so you cannot change your entry key and value types once you have begun to populate the region. If you need to use different types for the same region, store them all inside objects in the region.
+
+## Using the API to Put Values Into the Cache
+
+In this example, the program puts entries into the cache with string values.
+
+``` pre
+region1["Key1"] = "Value1";
+region1["Key2"] = "Value2";
+ 
+region2["KeyA"] = 123;
+region2["KeyB"] = 100;
+region3.Put(111, "Value1", null);
+region3.Put(222, "Value2", null);
+```
+
+## <a id="concept_51D1C2475B394B10868CE6ED8DC5E542__section_8DAEA246DA464BD1B9654827A84A93BF" class="no-quick-link"></a>Batch Operations—Using PutAll to Add Multiple Entries
+
+You can batch up multiple key/value pairs into a hashmap and put them into the cache with a single operation using the .NET `Region.PutAll` API function. Each entry is processed for interest registration on the server, so each entry requires its own unique event ID. Updates and creates can be mixed in a `PutAll` operation, so those events need to be addressed on the cache server for appropriate cache listener invocation on distributed system members. Map entries retain their original order when they are processed at the server.

http://git-wip-us.apache.org/repos/asf/geode-native/blob/87b6e035/docs/geode-native-docs/dotnet-caching-api/dotnet-application-domains.html.md.erb
----------------------------------------------------------------------
diff --git a/docs/geode-native-docs/dotnet-caching-api/dotnet-application-domains.html.md.erb b/docs/geode-native-docs/dotnet-caching-api/dotnet-application-domains.html.md.erb
new file mode 100644
index 0000000..574f56c
--- /dev/null
+++ b/docs/geode-native-docs/dotnet-caching-api/dotnet-application-domains.html.md.erb
@@ -0,0 +1,11 @@
+---
+title:  .NET Application Domains
+---
+
+Application domains, or `AppDomain`s, are units of isolation, security boundaries, and loading and unloading for applications in the .NET runtime. Multiple application domains can run in a single process. Each can have one or many threads, and a thread can switch application domains at runtime.
+
+**Note:**
+Before you use application domains with Geode, make sure you understand how to use them generally in your .NET programming.
+
+The .NET managed assemblies require interface methods invoked by the native C++ layer to be in the same `AppDomain` as that of the .NET DLL. If not, an exception is thrown because the thread is unable to cross `AppDomain` boundaries.
+

http://git-wip-us.apache.org/repos/asf/geode-native/blob/87b6e035/docs/geode-native-docs/dotnet-caching-api/dotnet-caching-api.html.md.erb
----------------------------------------------------------------------
diff --git a/docs/geode-native-docs/dotnet-caching-api/dotnet-caching-api.html.md.erb b/docs/geode-native-docs/dotnet-caching-api/dotnet-caching-api.html.md.erb
new file mode 100644
index 0000000..d036365
--- /dev/null
+++ b/docs/geode-native-docs/dotnet-caching-api/dotnet-caching-api.html.md.erb
@@ -0,0 +1,65 @@
+---
+title:  Pivotal GemFire Native Client .NET API
+---
+
+This section describes the primary classes, usage conventions, and C++ to .NET class mappings of the native client .NET API. It demonstrates how to use the API to create caches and perform data serialization.
+
+The .NET API documentation is available at [http://gemfire-apis.docs.pivotal.io](http://gemfire-apis.docs.pivotal.io).
+
+-   **[About the Native Client .NET API](csharp-dotnet-api.html)**
+
+    The Microsoft .NET Framework interface for the Apache Geode native client provides complete access to the native client C++ functionality from any .NET Framework language (C\#, C++/CLI, VB.NET, and J\#). This enables clients using C\# and other .NET languages to use the capabilities provided by the Geode C++ API.
+
+-   **[C++ Class to .NET Class Mappings](cpp-class-to-dotnet-class-mappings.html)**
+
+    Wherever the native C++ class methods use pass-by-reference semantics to return data, the corresponding .NET methods return the object instead of using pass-by-reference semantics.
+
+-   **[Java to .NET Type Mapping Table](java-to-dotnet-type-mapping.html)**
+
+    The following table provides a mapping between Java and .NET types.
+
+-   **[Object Lifetimes](object-lifetimes.html)**
+
+    The .NET API provides a managed set of assemblies for the C++ API. The underlying C++ object will stay in memory until the .NET object is garbage-collected.
+
+-   **[.NET Application Domains](dotnet-application-domains.html)**
+
+    Application domains, or `AppDomain`s, are units of isolation, security boundaries, and loading and unloading for applications in the .NET runtime. Multiple application domains can run in a single process. Each can have one or many threads, and a thread can switch application domains at runtime.
+
+-   **[Creating a Cache](creating-a-cache.html)**
+
+    You create a cache using the Geode `CacheFactory.Create` call. Cache creation initializes the distributed system and creates the cache using your `gfcpp.properties` and `cache.xml` file settings and any additional properties you provide to the call.
+
+-   **[Creating a Region](creating-a-region.html)**
+
+    To create a region, you create a `RegionFactory` using the `RegionShortcut` that most closely fits your region configuration.
+
+-   **[Adding an Entry to the Cache](dotnet-adding-entry-to-cache.html)**
+
+    You populate a native client region with cache entries by using the generic `IDictionary` API or by using the .NET `Region.Put` or the `Region.Create` API functions.
+
+-   **[Accessing an Entry](dotnet-accessing-an-entry.html)**
+
+    The region entry retrieval methods return the value associated with the specified key, and pass the callback argument to any cache loaders or cache writers that are invoked during the operation.
+
+-   **[Removing an Entry](removing-entry.html)**
+
+    The standard `Region::Remove` API removes the entry with specified key and provides a user-defined parameter object to any `CacheWriter` or `CacheListener` invoked in the process.
+
+-   **[Data Serialization](dotnet-data-serialization.html)**
+
+    All data that Geode moves out of the local cache must be serializable.
+
+-   **[Application Callbacks](application-callbacks.html)**
+
+    For region-level events, an application can use `AttributesFactory.SetCache*` methods to implement and register the `ICacheLoader`, `ICacheWriter`, and `ICacheListener` interfaces to perform custom actions.
+
+-   **[A Simple C\# Example](simple-csharp-example.html)**
+
+    An example shows how to connect to Geode, create a cache and region, put and get keys and values, and disconnect.
+
+-   **[Troubleshooting .NET Applications](troubleshooting-dotnet-applications.html)**
+
+    The .NET Framework does not find managed DLLs using the conventional `PATH` environment variable. In order for your assembly to find and load a managed DLL, it must either be loaded as a private assembly using `assemblyBinding`, or it must be installed into the Global Assembly Cache (GAC).
+
+

http://git-wip-us.apache.org/repos/asf/geode-native/blob/87b6e035/docs/geode-native-docs/dotnet-caching-api/dotnet-data-serialization-options.html.md.erb
----------------------------------------------------------------------
diff --git a/docs/geode-native-docs/dotnet-caching-api/dotnet-data-serialization-options.html.md.erb b/docs/geode-native-docs/dotnet-caching-api/dotnet-data-serialization-options.html.md.erb
new file mode 100644
index 0000000..988ec1b
--- /dev/null
+++ b/docs/geode-native-docs/dotnet-caching-api/dotnet-data-serialization-options.html.md.erb
@@ -0,0 +1,64 @@
+---
+title:  Data Serialization Options
+---
+
+Built-in .NET types are serialized automatically into the cache and can be retrieved by Java servers and other Geode clients. For domain objects that are not simple types, you have three Geode serialization options.
+
+The options give good performance and flexibility for data storage, transfers, and language types. The Geode options can also improve performance in serializing and deserializing built-in types.
+
+The simplest option is to use perform automatic serialization by registering the Geode .NET PDX reflection-based autoserializer in your application. When you have this registered, Geode uses it for all domain objects that are not custom serialized.
+
+You can also custom serialize your objects by implementing one of the Geode .NET interfaces, `GemStone::GemFire::Cache::Generic::IPdxSerializable` or `GemStone::GemFire::Cache::IGFSerializable`.
+
+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`.
+
+Geode .NET PDX serialization has more bytes in overhead than Geode .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>IGFSerializable</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 Geode - 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 (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 Geode delta propagation with PDX serialization. However, delta propagation will not work if you have set the Geode 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 `fromDelta` method required for delta propagation. You will also require the Java domain class on the server similar to the you would need the .NET PDX Delta domain class.
+
+For detailed information on the interfaces, see the API documentation at [http://gemfire-apis.docs.pivotal.io](http://gemfire-apis.docs.pivotal.io).
+
+

http://git-wip-us.apache.org/repos/asf/geode-native/blob/87b6e035/docs/geode-native-docs/dotnet-caching-api/dotnet-data-serialization.html.md.erb
----------------------------------------------------------------------
diff --git a/docs/geode-native-docs/dotnet-caching-api/dotnet-data-serialization.html.md.erb b/docs/geode-native-docs/dotnet-caching-api/dotnet-data-serialization.html.md.erb
new file mode 100644
index 0000000..a325d92
--- /dev/null
+++ b/docs/geode-native-docs/dotnet-caching-api/dotnet-data-serialization.html.md.erb
@@ -0,0 +1,18 @@
+---
+title:  Data Serialization
+---
+
+All data that Geode moves out of the local cache must be serializable.
+
+Region data that must be serializable falls under the following categories:
+
+-   Partitioned regions (except functions that add data locally to a partitioned region use the deserialized form).
+-   Distributed regions.
+-   Regions that are persisted or overflowed to disk.
+-   Server or client regions in a client/server installation.
+-   Regions distributed between gateways in a multi-site installation.
+-   Regions that receive events from remote caches.
+-   Regions that provide function arguments and results.
+
+To minimize the cost of serialization and deserialization, Geode avoids changing the data format whenever possible. This means your data may be stored in the cache in serialized or deserialized form, depending on how you use it. For example, if a server acts only as a storage location for data distribution between clients, it makes sense to leave the data in serialized form, ready to be transmitted to clients that request it. Partitioned region data is always stored in serialized form with one exception—functions that add data to a partitioned region locally use the deserialized form.
+

http://git-wip-us.apache.org/repos/asf/geode-native/blob/87b6e035/docs/geode-native-docs/dotnet-caching-api/dotnet-pdx-autoserializer.html.md.erb
----------------------------------------------------------------------
diff --git a/docs/geode-native-docs/dotnet-caching-api/dotnet-pdx-autoserializer.html.md.erb b/docs/geode-native-docs/dotnet-caching-api/dotnet-pdx-autoserializer.html.md.erb
new file mode 100644
index 0000000..b6268d6
--- /dev/null
+++ b/docs/geode-native-docs/dotnet-caching-api/dotnet-pdx-autoserializer.html.md.erb
@@ -0,0 +1,57 @@
+---
+title:  Serialize Using the Geode PDX Autoserializer
+---
+
+When you register the reflection-based serializer, Geode uses it to serialize all objects that do not implement `IPdxSerializable` or `IGFSerializable`. 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 GemStone.GemFire.Cache.Generic;
+    ...
+    // 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 Geode 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.
+
+

http://git-wip-us.apache.org/repos/asf/geode-native/blob/87b6e035/docs/geode-native-docs/dotnet-caching-api/dotnet-pdx-serialization-features.html.md.erb
----------------------------------------------------------------------
diff --git a/docs/geode-native-docs/dotnet-caching-api/dotnet-pdx-serialization-features.html.md.erb b/docs/geode-native-docs/dotnet-caching-api/dotnet-pdx-serialization-features.html.md.erb
new file mode 100644
index 0000000..14d27f4
--- /dev/null
+++ b/docs/geode-native-docs/dotnet-caching-api/dotnet-pdx-serialization-features.html.md.erb
@@ -0,0 +1,27 @@
+---
+title:  Geode PDX Serialization Features
+---
+
+Geode 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.
+
+Geode maintains a central registry of the PDX domain object metadata. Using the registry, Geode 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 one or more fields according to the member's version, Geode assigns the .NET default values for the field types to the missing fields.
+
+## <a id="concept_E8DCAA3027B64C0C8213A0DF2D773BF4__section_4CD0072C619F4F0496B73597B92B2289" class="no-quick-link"></a>Portability of PDX Serializable Objects
+
+When you create an `IPdxSerializable` object, Geode 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 code your .NET clients to manage data using Java servers without having to create Java implementations of your .NET domain objects.
+
+## <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.

http://git-wip-us.apache.org/repos/asf/geode-native/blob/87b6e035/docs/geode-native-docs/dotnet-caching-api/dotnet-pdx-serialization.html.md.erb
----------------------------------------------------------------------
diff --git a/docs/geode-native-docs/dotnet-caching-api/dotnet-pdx-serialization.html.md.erb b/docs/geode-native-docs/dotnet-caching-api/dotnet-pdx-serialization.html.md.erb
new file mode 100644
index 0000000..7837071
--- /dev/null
+++ b/docs/geode-native-docs/dotnet-caching-api/dotnet-pdx-serialization.html.md.erb
@@ -0,0 +1,11 @@
+---
+title:  Serialize with PDX Serialization
+---
+
+Geode'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.
+
+PDX serialization is supported by C++ clients. If you have C++ clients that may receive events for a region, you can now use PDX serialization on the region's entries.
+
+You have two options for Geode PDX serialization when using the .NET caching API. You can program your domain objects using the `IPdxSerializable` interface, or you can use Geode’s reflection-based autoserializer.
+
+

http://git-wip-us.apache.org/repos/asf/geode-native/blob/87b6e035/docs/geode-native-docs/dotnet-caching-api/event-handling-apis.html.md.erb
----------------------------------------------------------------------
diff --git a/docs/geode-native-docs/dotnet-caching-api/event-handling-apis.html.md.erb b/docs/geode-native-docs/dotnet-caching-api/event-handling-apis.html.md.erb
new file mode 100644
index 0000000..0aa0b4e
--- /dev/null
+++ b/docs/geode-native-docs/dotnet-caching-api/event-handling-apis.html.md.erb
@@ -0,0 +1,15 @@
+---
+title:  Event Handling APIs
+---
+
+Code your event handlers to do minimal work before returning control to Geode.
+
+For example, a listener implementation may hand off the event to a thread pool that processes the event on its thread rather than the listener thread. Exceptions thrown by the listeners are caught by Geode and logged.
+
+-   **RegionEvent class**. Provides information about the event, such as what region the event originated in, whether the event originated in a cache remote to the event handler, and whether the event resulted from a distributed operation.
+-   **EntryEvent class**. Provides all available information for the `RegionEvent` . It also provides entry-specific information, such as the old and new entry values and whether the event resulted from a load operation.
+-   **ICacheLoader application callback interface**. Loads data into a region.
+-   **ICacheWriter application callback interface**. Synchronously handles region and entry events before the events occur. Entry events are `create`, `update`, `invalidate`, and `destroy`. Region events are invalidate and destroy. This class has the ability to abort events.
+-   **ICacheListener application callback interface**. Asynchronously handles region and entry events. Listeners receive notifications when entries in a region change, or when changes occur to the region attributes themselves. Entry events are `create`, `update`, `invalidate`, and `destroy`. Region events are `invalidate` and `destroy`. Multiple events can cause concurrent invocation of `ICacheListener` methods. If event A occurs before event B, there is no guarantee that their corresponding ICacheListener method invocations will occur in the same order.
+
+

http://git-wip-us.apache.org/repos/asf/geode-native/blob/87b6e035/docs/geode-native-docs/dotnet-caching-api/extending-pdx-autoserializer.html.md.erb
----------------------------------------------------------------------
diff --git a/docs/geode-native-docs/dotnet-caching-api/extending-pdx-autoserializer.html.md.erb b/docs/geode-native-docs/dotnet-caching-api/extending-pdx-autoserializer.html.md.erb
new file mode 100644
index 0000000..bc1b765
--- /dev/null
+++ b/docs/geode-native-docs/dotnet-caching-api/extending-pdx-autoserializer.html.md.erb
@@ -0,0 +1,59 @@
+---
+title:  Extend the PDX Autoserializer
+---
+
+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);
+    }
+}
+```
+
+

http://git-wip-us.apache.org/repos/asf/geode-native/blob/87b6e035/docs/geode-native-docs/dotnet-caching-api/how-igfserializable-works.html.md.erb
----------------------------------------------------------------------
diff --git a/docs/geode-native-docs/dotnet-caching-api/how-igfserializable-works.html.md.erb b/docs/geode-native-docs/dotnet-caching-api/how-igfserializable-works.html.md.erb
new file mode 100644
index 0000000..55d7299
--- /dev/null
+++ b/docs/geode-native-docs/dotnet-caching-api/how-igfserializable-works.html.md.erb
@@ -0,0 +1,19 @@
+---
+title:  How Serialization Works with IGFSerializable
+---
+
+When your application puts an object into the cache for distribution, Geode 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, Geode 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.
+
+

http://git-wip-us.apache.org/repos/asf/geode-native/blob/87b6e035/docs/geode-native-docs/dotnet-caching-api/implementing-igfserializable.html.md.erb
----------------------------------------------------------------------
diff --git a/docs/geode-native-docs/dotnet-caching-api/implementing-igfserializable.html.md.erb b/docs/geode-native-docs/dotnet-caching-api/implementing-igfserializable.html.md.erb
new file mode 100644
index 0000000..e9e1cea
--- /dev/null
+++ b/docs/geode-native-docs/dotnet-caching-api/implementing-igfserializable.html.md.erb
@@ -0,0 +1,122 @@
+---
+title:  Implement the IGFSerializable Interface
+---
+
+To store your own data types in the cache, you implement the Geode `IGFSerializable` 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. For details, see the API documentation for `DataOutput` at [http://gemfire-apis.docs.pivotal.io](http://gemfire-apis.docs.pivotal.io).
+
+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`. For more about this, see the API documentation for `DataInput` at [http://gemfire-apis.docs.pivotal.io](http://gemfire-apis.docs.pivotal.io).
+
+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 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 `IGFSerializable` interface as shown in this example:
+
+``` pre
+public class BankAccount : IGFSerializable
+   {
+   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 IGFSerializable CreateInstance()
+   {
+      return new BankAccount(0, 0);
+   }
+   #region IGFSerializable Members
+   public void ToData(DataOutput output)
+   {
+      output.WriteInt32(m_customerId);
+      output.WriteInt32(m_accountId);
+   }
+   public IGFSerializable 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));
+      }
+   }
+}
+```
+
+

http://git-wip-us.apache.org/repos/asf/geode-native/blob/87b6e035/docs/geode-native-docs/dotnet-caching-api/implementing-shared-assembly.html.md.erb
----------------------------------------------------------------------
diff --git a/docs/geode-native-docs/dotnet-caching-api/implementing-shared-assembly.html.md.erb b/docs/geode-native-docs/dotnet-caching-api/implementing-shared-assembly.html.md.erb
new file mode 100644
index 0000000..733e4f6
--- /dev/null
+++ b/docs/geode-native-docs/dotnet-caching-api/implementing-shared-assembly.html.md.erb
@@ -0,0 +1,21 @@
+---
+title:  Implementing the Shared Assembly
+---
+
+Follow these steps to install the shared assembly into the Global Assembly Cache (GAC).
+
+1.  Go to the `NativeClient_xxxx` directory.
+
+    ``` pre
+    cd %GFCPP%
+    ```
+
+2.  Run the GAC utility to install `GemStone.GemFire.Cache.dll` into the GAC.
+
+    ``` pre
+    gacutil.exe /if GemStone.GemFire.Cache.dll
+    ```
+
+When you are ready to uninstall, use the `/u` switch. More information on the GAC utility can be found at [http://www.msdn.com](https://msdn.microsoft.com), or by using `gacutil.exe                 /?`.
+
+

http://git-wip-us.apache.org/repos/asf/geode-native/blob/87b6e035/docs/geode-native-docs/dotnet-caching-api/java-to-dotnet-type-mapping.html.md.erb
----------------------------------------------------------------------
diff --git a/docs/geode-native-docs/dotnet-caching-api/java-to-dotnet-type-mapping.html.md.erb b/docs/geode-native-docs/dotnet-caching-api/java-to-dotnet-type-mapping.html.md.erb
new file mode 100644
index 0000000..3bb303d
--- /dev/null
+++ b/docs/geode-native-docs/dotnet-caching-api/java-to-dotnet-type-mapping.html.md.erb
@@ -0,0 +1,146 @@
+---
+title:  Java to .NET Type Mapping Table
+---
+
+The following table provides a mapping between Java and .NET types.
+
+<a id="concept_24D0AAC71FF1483AB47A7772DA018966__table_F85EC7AA1E1140E9888B753E812E65E4"></a>
+
+<table>
+<caption><span class="tablecap">Table 1. Java types and .NET types</span></caption>
+<colgroup>
+<col width="50%" />
+<col width="50%" />
+</colgroup>
+<thead>
+<tr class="header">
+<th>Java Type</th>
+<th>.NET Type</th>
+</tr>
+</thead>
+<tbody>
+<tr class="odd">
+<td><p>instances of <code class="ph codeph">PdxSerializable</code></p></td>
+<td><p>.NET class of same name</p></td>
+</tr>
+<tr class="even">
+<td><p>instances of <code class="ph codeph">PdxInstance</code></p></td>
+<td><p>.NET class of same name</p></td>
+</tr>
+<tr class="odd">
+<td><p>instances serialized by a <code class="ph codeph">PdxSerializer</code></p></td>
+<td><p>.NET class of same name</p></td>
+</tr>
+<tr class="even">
+<td><p><code class="ph codeph">java.lang.Byte </code></p></td>
+<td><p><code class="ph codeph">System.SByte </code></p></td>
+</tr>
+<tr class="odd">
+<td><p><code class="ph codeph">java.lang.Boolean </code></p></td>
+<td><p><code class="ph codeph">System.Boolean </code></p></td>
+</tr>
+<tr class="even">
+<td><p><code class="ph codeph">java.lang.Character </code></p></td>
+<td><p><code class="ph codeph">System.Char </code></p></td>
+</tr>
+<tr class="odd">
+<td><p><code class="ph codeph">java.lang.Short </code></p></td>
+<td><p><code class="ph codeph">System.Int16 </code></p></td>
+</tr>
+<tr class="even">
+<td><p><code class="ph codeph">java.lang.Integer </code></p></td>
+<td><p><code class="ph codeph">System.Int32 </code></p></td>
+</tr>
+<tr class="odd">
+<td><p><code class="ph codeph">java.lang.Long </code></p></td>
+<td><p><code class="ph codeph">System.Int64 </code></p></td>
+</tr>
+<tr class="even">
+<td><p><code class="ph codeph">java.lang.Float </code></p></td>
+<td><p><code class="ph codeph">System.Float </code></p></td>
+</tr>
+<tr class="odd">
+<td><p><code class="ph codeph">java.lang.Double </code></p></td>
+<td><p><code class="ph codeph">System.Double </code></p></td>
+</tr>
+<tr class="even">
+<td><p><code class="ph codeph">java.lang.String </code></p></td>
+<td><p><code class="ph codeph">System.String </code></p></td>
+</tr>
+<tr class="odd">
+<td><p><code class="ph codeph">java.util.Date </code></p></td>
+<td><p><code class="ph codeph">System.DateTime </code></p></td>
+</tr>
+<tr class="even">
+<td><p><code class="ph codeph">byte[] </code></p></td>
+<td><p><code class="ph codeph">System.Byte[] </code></p></td>
+</tr>
+<tr class="odd">
+<td><p><code class="ph codeph">boolean[] </code></p></td>
+<td><p><code class="ph codeph">System.Boolean[] </code></p></td>
+</tr>
+<tr class="even">
+<td><p><code class="ph codeph">char[] </code></p></td>
+<td><p><code class="ph codeph">System.Char[] </code></p></td>
+</tr>
+<tr class="odd">
+<td><p><code class="ph codeph">short[] </code></p></td>
+<td><p><code class="ph codeph">System.Int16[] </code></p></td>
+</tr>
+<tr class="even">
+<td><p><code class="ph codeph">int[] </code></p></td>
+<td><p><code class="ph codeph">System.Int32[] </code></p></td>
+</tr>
+<tr class="odd">
+<td><p><code class="ph codeph">long[] </code></p></td>
+<td><p><code class="ph codeph">System.Int64[] </code></p></td>
+</tr>
+<tr class="even">
+<td><p><code class="ph codeph">float[] </code></p></td>
+<td><p><code class="ph codeph">System.Float[] </code></p></td>
+</tr>
+<tr class="odd">
+<td><p><code class="ph codeph">double[] </code></p></td>
+<td><p><code class="ph codeph">System.Double[] </code></p></td>
+</tr>
+<tr class="even">
+<td><p><code class="ph codeph">String[] </code></p></td>
+<td><p><code class="ph codeph">System.String[] </code></p></td>
+</tr>
+<tr class="odd">
+<td><p><code class="ph codeph">byte[][] </code></p></td>
+<td><p><code class="ph codeph">System.Byte[][] </code></p></td>
+</tr>
+<tr class="even">
+<td><p><code class="ph codeph">Object[] </code></p></td>
+<td><p><code class="ph codeph">system.Collections.Generic.List&lt;Object&gt; </code></p></td>
+</tr>
+<tr class="odd">
+<td><p><code class="ph codeph">java.util.HashMap </code></p></td>
+<td><p><code class="ph codeph">System.Collections.Generics.IDictionary&lt;Object,                                     Object&gt; </code></p></td>
+</tr>
+<tr class="even">
+<td><p><code class="ph codeph">java.util.Hashtable </code></p></td>
+<td><p><code class="ph codeph">System.Collections.Hashtable </code></p></td>
+</tr>
+<tr class="odd">
+<td><p><code class="ph codeph">java.util.ArrayList </code></p></td>
+<td><p><code class="ph codeph">System.Collections.Generic.IList&lt;Object&gt; </code></p></td>
+</tr>
+<tr class="even">
+<td><p><code class="ph codeph">java.util.Vector </code></p></td>
+<td><p><code class="ph codeph">Collections.ArrayList </code></p></td>
+</tr>
+<tr class="odd">
+<td><p><code class="ph codeph">java.util.HashSet </code></p></td>
+<td><p><code class="ph codeph">CacheableHashSet </code></p></td>
+</tr>
+<tr class="even">
+<td><p><code class="ph codeph">java.util.LinkedHashSet </code></p></td>
+<td><p><code class="ph codeph">CacheableLinkedHashSet </code></p></td>
+</tr>
+</tbody>
+</table>
+
+
+

http://git-wip-us.apache.org/repos/asf/geode-native/blob/87b6e035/docs/geode-native-docs/dotnet-caching-api/mapping-dotnet-domain-type-names.html.md.erb
----------------------------------------------------------------------
diff --git a/docs/geode-native-docs/dotnet-caching-api/mapping-dotnet-domain-type-names.html.md.erb b/docs/geode-native-docs/dotnet-caching-api/mapping-dotnet-domain-type-names.html.md.erb
new file mode 100644
index 0000000..273d19d
--- /dev/null
+++ b/docs/geode-native-docs/dotnet-caching-api/mapping-dotnet-domain-type-names.html.md.erb
@@ -0,0 +1,25 @@
+---
+title:  Map .NET Domain Type Names to PDX Type Names with IPdxTypeMapper
+---
+
+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](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_"
+    }
+}
+```
+
+

http://git-wip-us.apache.org/repos/asf/geode-native/blob/87b6e035/docs/geode-native-docs/dotnet-caching-api/object-lifetimes.html.md.erb
----------------------------------------------------------------------
diff --git a/docs/geode-native-docs/dotnet-caching-api/object-lifetimes.html.md.erb b/docs/geode-native-docs/dotnet-caching-api/object-lifetimes.html.md.erb
new file mode 100644
index 0000000..43c687a
--- /dev/null
+++ b/docs/geode-native-docs/dotnet-caching-api/object-lifetimes.html.md.erb
@@ -0,0 +1,37 @@
+---
+title:  Object Lifetimes
+---
+
+The .NET API provides a managed set of assemblies for the C++ API. The underlying C++ object will stay in memory until the .NET object is garbage-collected.
+
+The underlying C++ API employs reference counting using smart pointers for most classes. This means that all API operations with those objects return a reference to the underlying object and not a copy. Consequently, the underlying object will not be freed as long as the .NET application holds a reference to an object. In other words, the underlying object will stay in memory until the .NET object is garbage-collected. As long as a reference to an object is alive, the artifacts it maintains will also be alive.
+
+For example, as long as a `Region` object is not garbage-collected, then the destructor of the C++ native persistence manager (if any) for the region is not invoked.
+
+In the C++ API, the references to an object are reduced when the object goes out of scope for stack allocation, or is deleted explicitly for heap allocation. The object is destroyed when its reference count reaches zero. In the .NET API, the references are reduced when the object is garbage-collected or is explicitly disposed with the .NET `using` statement.
+
+Because a reference to the object is returned, any change to the object also immediately changes the object as stored internally. For example, if an object is put into the cache using `Region.Put`, a reference of the object is stored in the internal structures. If you modify the object, the internal object also changes. However, it is not distributed to other members of the distributed system until another `Region.Put` is done.
+
+To find out if a class is reference counted, look at the API documentation for the class at [http://gemfire-apis.docs.pivotal.io](http://gemfire-apis.docs.pivotal.io). If the class is wrapped by `UMWrap` or `SBWrap`, the class is reference counted.
+
+These are examples of classes that are reference counted:
+
+-   `Cache`
+-   `CacheStatistics`
+-   `DistributedSystem`
+-   `Properties`
+-   `RegionAttributes`
+-   `AttributesMutator`
+-   `RegionEntry`
+-   `Region`
+-   `EntryEvent`
+-   `RegionEvent`
+
+These are examples of classes that are not reference counted:
+
+-   `AttributesFactory`
+-   `DataInput`
+-   `DataOutput`
+-   `SystemProperties`
+
+

http://git-wip-us.apache.org/repos/asf/geode-native/blob/87b6e035/docs/geode-native-docs/dotnet-caching-api/other-apis.html.md.erb
----------------------------------------------------------------------
diff --git a/docs/geode-native-docs/dotnet-caching-api/other-apis.html.md.erb b/docs/geode-native-docs/dotnet-caching-api/other-apis.html.md.erb
new file mode 100644
index 0000000..89c34e4
--- /dev/null
+++ b/docs/geode-native-docs/dotnet-caching-api/other-apis.html.md.erb
@@ -0,0 +1,14 @@
+---
+title:  Property Collections and Logging APIs
+---
+
+This section describes classes for property collections and logging.
+
+-   **Properties** **class**. Provides a collection of properties, each of which is a key/value pair. Each key is a string, and the value can be a string or an integer.
+-   **Log class**. Defines methods available to clients that need to write a log message to their Geode system shared log file. Any attempt to use an instance after its connection is disconnected throws a **NotConnectedException**. For any logged message the log file contains:
+    -   The log level of the message.
+    -   The time the message was logged.
+    -   The ID of the connection and thread that logged the message.
+    -   The message itself, possibly with an exception including its stack trace.
+
+

http://git-wip-us.apache.org/repos/asf/geode-native/blob/87b6e035/docs/geode-native-docs/dotnet-caching-api/primary-apis-cache-generic.html.md.erb
----------------------------------------------------------------------
diff --git a/docs/geode-native-docs/dotnet-caching-api/primary-apis-cache-generic.html.md.erb b/docs/geode-native-docs/dotnet-caching-api/primary-apis-cache-generic.html.md.erb
new file mode 100644
index 0000000..ab1f0b3
--- /dev/null
+++ b/docs/geode-native-docs/dotnet-caching-api/primary-apis-cache-generic.html.md.erb
@@ -0,0 +1,30 @@
+---
+title:  Primary APIs
+---
+
+These are the main APIs within `GemStone::GemFire::Cache::Generic` used for cache, region, and data entry management in Geode .NET. For details, see the .NET API documentation at [http://gemfire-apis.docs.pivotal.io](http://gemfire-apis.docs.pivotal.io).
+
+**Note:**
+Declarative configuration via XML of application plug-ins such as cache listener, cache writer, cache loader and partition resolver is not supported when clients are operated in the new .NET Generic API.
+
+-   **[Cache APIs](cache-apis.html)**
+
+    This section describes the `CacheFactory` and `Cache` classes.
+
+-   **[Region and Entry APIs](region-entry-apis.html)**
+
+    This section describes classes for working with Geode regions and region entries.
+
+-   **[Data Serialization APIs](data-serialization-apis.html)**
+
+    Use either `IPdxSerializable` or `IGFSerializable` for each region. Do not mix the two.
+
+-   **[Event Handling APIs](event-handling-apis.html)**
+
+    Code your event handlers to do minimal work before returning control to Geode.
+
+-   **[Property Collections and Logging APIs](other-apis.html)**
+
+    This section describes classes for property collections and logging.
+
+

http://git-wip-us.apache.org/repos/asf/geode-native/blob/87b6e035/docs/geode-native-docs/dotnet-caching-api/private-assembly.html.md.erb
----------------------------------------------------------------------
diff --git a/docs/geode-native-docs/dotnet-caching-api/private-assembly.html.md.erb b/docs/geode-native-docs/dotnet-caching-api/private-assembly.html.md.erb
new file mode 100644
index 0000000..e3aa34e
--- /dev/null
+++ b/docs/geode-native-docs/dotnet-caching-api/private-assembly.html.md.erb
@@ -0,0 +1,39 @@
+---
+title:  Using GemStone.GemFire.Cache.dll As a Private Assembly
+---
+
+To access `GemStone.GemFire.Cache.dll` as a private assembly, you need to specify a `.config` file for your application.
+
+The file needs to be the same name as your application, with a `.config` suffix. For example, the `.config` file for `main.exe` would be `main.exe.config`. The two files must reside in the same directory.
+
+Follow these steps to create a `.config` file:
+
+1.  Copy `%GFCPP%/docs/default.exe.config` to the appropriate location.
+2.  Rename `default.exe.config` to the name of your application.
+3.  Change the `href` attribute of the `CodeBase` element to point to your `GemStone.GemFire.Cache.dll` file. Any of three path types – http, relative, or absolute – will work.
+
+## A Sample .config File
+
+The following example shows an excerpt of a `.config` file. The `PublicKeyToken` value is only an example, and the codebase version value is not set correctly. See `%GFCPP%/docs/default.exe.config` for an actual example for this release.
+
+``` pre
+<configuration>
+   <runtime>
+      <assemblyBinding
+         xmlns="urn:schemas-microsoft-com:asm.v1">
+         <dependentAssembly>
+            <assemblyIdentity name="GemStone.GemFire.Cache"
+               publicKeyToken="126e6338d9f55e0c"
+               culture="neutral" />
+            <codeBase version="0.0.0.0"
+               href="../../bin/GemStone.GemFire.Cache.dll"/>
+         </dependentAssembly>
+      </assemblyBinding>
+   </runtime>
+</configuration>
+```
+
+**Note:**
+If the `.config` file contain errors, no warning or error messages are issued. The application runs as if no `.config` file is present.
+
+

http://git-wip-us.apache.org/repos/asf/geode-native/blob/87b6e035/docs/geode-native-docs/dotnet-caching-api/problem-scenarios.html.md.erb
----------------------------------------------------------------------
diff --git a/docs/geode-native-docs/dotnet-caching-api/problem-scenarios.html.md.erb b/docs/geode-native-docs/dotnet-caching-api/problem-scenarios.html.md.erb
new file mode 100644
index 0000000..4d7c4ec
--- /dev/null
+++ b/docs/geode-native-docs/dotnet-caching-api/problem-scenarios.html.md.erb
@@ -0,0 +1,24 @@
+---
+title:  Problem Scenarios
+---
+
+These scenarios describe processes and implementations that should be avoided when using `AppDomains`.
+
+
+## <a id="concept_025AAAF8896C4F4CB4530EE9CEEF4BAE__section_FFC3E18AD8F042DA9EFB42852242AAE0" class="no-quick-link"></a>Using Application Callbacks
+
+**Scenario:** A .NET thread loads the Geode DLL in application domain `AD1`. This thread may have access to the other domains in the application if code access security allows it. This thread can then call `AppDomain.CreateInstance` to create a callback object ( `ICacheListener`, `ICacheLoader`, or `ICacheWriter`) in another domain called `AD2`. If the callback object is marshaled by reference, the callback is executed in the domain where it is created (`AD2`). The thread that loads the Geode DLL in domain `AD1` runs the callback methods in the second domain, `AD2`. An exception is thrown when the callback method is invoked because the native code that invokes the callback is not allowed to cross the `AppDomain` boundary.
+
+**Resolution:** When an application creates and unloads application domains it should ensure that the application domain where the Geode .NET DLL is loaded is the same domain where the application callback and `IGFSerializable` objects are created.
+
+## <a id="concept_025AAAF8896C4F4CB4530EE9CEEF4BAE__section_9FEC4666F4FD467AA57AD70943703F00" class="no-quick-link"></a>Loading an Application DLL in Multiple AppDomains
+
+**Scenario:** the application loads the Geode DLL in one application domain, then reloads the Geode DLL in another application domain (with or without unloading the previous `AppDomain` ). The callbacks, as well as other interface implementations, like `IPdxSerializable` and `IGFSerializable`, throw exceptions because the native C++ code does not know about `AppDomains` and is loaded only once in the initial `AppDomain`.
+
+**Resolution:** The application should always use the first `AppDomain` to load the Geode DLL, or it should not load the Geode DLL multiple times.
+
+## <a id="concept_025AAAF8896C4F4CB4530EE9CEEF4BAE__section_646373554C764DD3A919A906A5F05EE9" class="no-quick-link"></a>Native Client inside IIS
+
+**Scenario:** When you deploy more than one web application inside an Internet Information Service (IIS), the IIS creates an appdomain subprocess for each web application in the single process, but the native client C++ cache instance remains a singleton in the process. Because of this, you can run into conflicts between cache creation and closure by the different appdomains. For example, if one appdomain calls `cache.close`, it closes the cache for the entire process. Any further cache access operations by the other appdomains return cache closed exceptions.
+
+**Resolution:** `Cache create`/`close` provides reference counting of `Cache` `create` and `close`. Each process can use the counter to make sure it creates the `Cache` once and closes it once. To enable this, set the Geode system property, `appdomain-enabled` to true .

http://git-wip-us.apache.org/repos/asf/geode-native/blob/87b6e035/docs/geode-native-docs/dotnet-caching-api/programming-ipdxinstance.html.md.erb
----------------------------------------------------------------------
diff --git a/docs/geode-native-docs/dotnet-caching-api/programming-ipdxinstance.html.md.erb b/docs/geode-native-docs/dotnet-caching-api/programming-ipdxinstance.html.md.erb
new file mode 100644
index 0000000..3e6ff68
--- /dev/null
+++ b/docs/geode-native-docs/dotnet-caching-api/programming-ipdxinstance.html.md.erb
@@ -0,0 +1,45 @@
+---
+title:  Program Your Application to Use IPdxInstance
+---
+
+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.
+
+

http://git-wip-us.apache.org/repos/asf/geode-native/blob/87b6e035/docs/geode-native-docs/dotnet-caching-api/region-entry-apis.html.md.erb
----------------------------------------------------------------------
diff --git a/docs/geode-native-docs/dotnet-caching-api/region-entry-apis.html.md.erb b/docs/geode-native-docs/dotnet-caching-api/region-entry-apis.html.md.erb
new file mode 100644
index 0000000..c8cd483
--- /dev/null
+++ b/docs/geode-native-docs/dotnet-caching-api/region-entry-apis.html.md.erb
@@ -0,0 +1,18 @@
+---
+title:  Region and Entry APIs
+---
+
+This section describes classes for working with Geode regions and region entries.
+
+-   **RegionFactory class**. Creates a `Region` instance based on the provided configuration.
+-   **IRegion class**. Provides functions for managing regions and cached data. The `Region` interface implements the generic .NET `IDictionary` interface. In the Geode APIs, `IRegion` implements `IDictionary` and `Region` inherits `IRegion`, giving you access to the full range of .NET `Generic` collection functions. Use the functions in this class to perform the following actions:
+    -   Retrieve information about the region, such as its parent region and region attribute objects.
+    -   Invalidate or destroy the region.
+    -   Add, update, invalidate, and remove region entries.
+    -   Determine, individually or as entire sets, the region's entry keys, entry values, and `RegionEntry` objects.
+-   **RegionEntry class**. Contains the key and value for the entry, and provides all non-distributed entry operations. The operations of this object are not distributed and do not affect statistics.
+-   **RegionShortcut class**. Holds `enum` definitions for the most common region configurations. Start your region configuration with a shortcut setting in the region attribute, `refid`. Then customize further using the `RegionAttributes`.
+-   **RegionAttributes class**. Holds all attribute values for a region and provides functions for retrieving all attribute settings. This class can only be modified by the `AttributesFactory` class before region creation, and the `AttributesMutator` class after region creation.
+-   **AttributesMutator class**. Allows modification of an existing region's attributes for application plug-ins and expiration actions. Each region has an `AttributesMutator` instance.
+
+

http://git-wip-us.apache.org/repos/asf/geode-native/blob/87b6e035/docs/geode-native-docs/dotnet-caching-api/registering-the-type.html.md.erb
----------------------------------------------------------------------
diff --git a/docs/geode-native-docs/dotnet-caching-api/registering-the-type.html.md.erb b/docs/geode-native-docs/dotnet-caching-api/registering-the-type.html.md.erb
new file mode 100644
index 0000000..098bb6d
--- /dev/null
+++ b/docs/geode-native-docs/dotnet-caching-api/registering-the-type.html.md.erb
@@ -0,0 +1,27 @@
+---
+title:  Register the Type
+---
+
+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 numbers, with such noticeable improvements as faster cache access and smaller payloads.
+
+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 native client that is used with a Java cache server.
+
+To extend a type that implements `IPdxSerializable` or `IGFSerializable` for your key, override and implement the `HashCode` and `Equals` methods in the key as needed.

http://git-wip-us.apache.org/repos/asf/geode-native/blob/87b6e035/docs/geode-native-docs/dotnet-caching-api/removing-entry.html.md.erb
----------------------------------------------------------------------
diff --git a/docs/geode-native-docs/dotnet-caching-api/removing-entry.html.md.erb b/docs/geode-native-docs/dotnet-caching-api/removing-entry.html.md.erb
new file mode 100644
index 0000000..9d76124
--- /dev/null
+++ b/docs/geode-native-docs/dotnet-caching-api/removing-entry.html.md.erb
@@ -0,0 +1,21 @@
+---
+title:  Removing an Entry
+---
+
+The standard `Region::Remove` API removes the entry with specified key and provides a user-defined parameter object to any `CacheWriter` or `CacheListener` invoked in the process.
+
+The `Remove` call not only removes the value, but also the key and entry from this region. The remove operation is propagated to the Geode cache server that the native client is connected to. If the destroy operation fails due to an exception on the server (for example, a `CacheServerException` or security exception), then the local entry is still removed.
+
+The `Remove` operation updates `CacheStatistics::LastAccessedTime`, `CacheStatistics::HitCount`, and `CacheStatistics::MissCount` for this region and the entry.
+
+The `Remove` API returns true if the entry (key, value) has been removed or false if the entry (key, value) has not been removed.
+
+## Bulk Remove Operations Using removeAll
+
+You can use the `Region::removeAll` API to remove all entries for a colleciton of specified keys from the region. The effect of this call is equivalent to that of calling `destroy` on this region once for each key in the specified collection. If an entry does not exist, then that key is skipped. Note that an `EntryNotFoundException` is not thrown.
+
+The `RemoveAll` operation updates `CacheStatistics::LastAccessedTime`, `CacheStatistics::HitCount`, and `CacheStatistics::MissCount` for this region and the entries that are removed.
+
+The `RemoveAll` API also supports providing a callback argument to any cache loaders or cache writers that are invoked in the operation. See the Region `RemoveAll` API documentation within [http://gemfire-apis.docs.pivotal.io](http://gemfire-apis.docs.pivotal.io).
+
+

http://git-wip-us.apache.org/repos/asf/geode-native/blob/87b6e035/docs/geode-native-docs/dotnet-caching-api/resolving-the-error.html.md.erb
----------------------------------------------------------------------
diff --git a/docs/geode-native-docs/dotnet-caching-api/resolving-the-error.html.md.erb b/docs/geode-native-docs/dotnet-caching-api/resolving-the-error.html.md.erb
new file mode 100644
index 0000000..65cc0cc
--- /dev/null
+++ b/docs/geode-native-docs/dotnet-caching-api/resolving-the-error.html.md.erb
@@ -0,0 +1,9 @@
+---
+title:  Resolving the Error
+---
+
+Each computer where the common language runtime is installed has a machine-wide code cache called the Global Assembly Cache (GAC). The global assembly cache stores assemblies specifically designated to be shared by several applications on the computer.
+
+As a general guideline, keep assembly dependencies private, and locate assemblies in the application directory unless sharing an assembly is explicitly required. Share assemblies by installing them into the global assembly cache only when necessary.
+
+

http://git-wip-us.apache.org/repos/asf/geode-native/blob/87b6e035/docs/geode-native-docs/dotnet-caching-api/serializable-types.html.md.erb
----------------------------------------------------------------------
diff --git a/docs/geode-native-docs/dotnet-caching-api/serializable-types.html.md.erb b/docs/geode-native-docs/dotnet-caching-api/serializable-types.html.md.erb
new file mode 100644
index 0000000..f57a871
--- /dev/null
+++ b/docs/geode-native-docs/dotnet-caching-api/serializable-types.html.md.erb
@@ -0,0 +1,20 @@
+---
+title:  Generic and Custom Serializable Types
+---
+
+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 `IGFSerializable`. 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 `IGFSerializable`.
+
+## <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 Geode `IGFSerializable` 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.
+
+For more information, see the API documentation for `DataOutput` and `DataInput` at [http://gemfire-apis.docs.pivotal.io](http://gemfire-apis.docs.pivotal.io).

http://git-wip-us.apache.org/repos/asf/geode-native/blob/87b6e035/docs/geode-native-docs/dotnet-caching-api/serialize-using-igfserializable.html.md.erb
----------------------------------------------------------------------
diff --git a/docs/geode-native-docs/dotnet-caching-api/serialize-using-igfserializable.html.md.erb b/docs/geode-native-docs/dotnet-caching-api/serialize-using-igfserializable.html.md.erb
new file mode 100644
index 0000000..dde87e8
--- /dev/null
+++ b/docs/geode-native-docs/dotnet-caching-api/serialize-using-igfserializable.html.md.erb
@@ -0,0 +1,23 @@
+---
+title:  Serialize with the Geode IGFSerializable Interface
+---
+
+The .NET `IGFSerializable` 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 IGFSerializable](how-igfserializable-works.html)**
+
+    When your application puts an object into the cache for distribution, Geode serializes the data by taking these steps.
+
+-   **[Implement the IGFSerializable Interface](implementing-igfserializable.html)**
+
+    To store your own data types in the cache, you implement the Geode `IGFSerializable` 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.`
+
+

http://git-wip-us.apache.org/repos/asf/geode-native/blob/87b6e035/docs/geode-native-docs/dotnet-caching-api/serialize-using-ipdxserializable.html.md.erb
----------------------------------------------------------------------
diff --git a/docs/geode-native-docs/dotnet-caching-api/serialize-using-ipdxserializable.html.md.erb b/docs/geode-native-docs/dotnet-caching-api/serialize-using-ipdxserializable.html.md.erb
new file mode 100644
index 0000000..a4138fa
--- /dev/null
+++ b/docs/geode-native-docs/dotnet-caching-api/serialize-using-ipdxserializable.html.md.erb
@@ -0,0 +1,103 @@
+---
+title:  Serialize Using the GemFire IPdxSerializable Interface
+---
+
+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 `GemStone::GemFire::Cache::Generic::IPdxSerializable`. Example:
+
+    ``` pre
+    using GemStone.GemFire.Cache.Generic;
+           ...
+           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. GemFire automatically provides `IPdxWriter` to the `ToData` function for `IPdxSerializable` objects.
+    2.  Call the `ToData markIdentifyField` function for each field GemFire 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. GemFire 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.
+
+

http://git-wip-us.apache.org/repos/asf/geode-native/blob/87b6e035/docs/geode-native-docs/dotnet-caching-api/serializing-domain-objects.html.md.erb
----------------------------------------------------------------------
diff --git a/docs/geode-native-docs/dotnet-caching-api/serializing-domain-objects.html.md.erb b/docs/geode-native-docs/dotnet-caching-api/serializing-domain-objects.html.md.erb
new file mode 100644
index 0000000..c25b28f
--- /dev/null
+++ b/docs/geode-native-docs/dotnet-caching-api/serializing-domain-objects.html.md.erb
@@ -0,0 +1,29 @@
+---
+title:  Serialize Your Domain Objects with IPdxSerializer
+---
+
+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 GemStone.GemFire.Cache.Generic;
+...
+// Register a PdxSerializer to serialize
+// domain objects using PDX serialization
+ 
+Serializable.RegisterPdxSerializer(new MyPdxSerializer());
+```
+
+

http://git-wip-us.apache.org/repos/asf/geode-native/blob/87b6e035/docs/geode-native-docs/dotnet-caching-api/simple-csharp-example.html.md.erb
----------------------------------------------------------------------
diff --git a/docs/geode-native-docs/dotnet-caching-api/simple-csharp-example.html.md.erb b/docs/geode-native-docs/dotnet-caching-api/simple-csharp-example.html.md.erb
new file mode 100644
index 0000000..d9f9949
--- /dev/null
+++ b/docs/geode-native-docs/dotnet-caching-api/simple-csharp-example.html.md.erb
@@ -0,0 +1,43 @@
+---
+title:  A Simple C# Example
+---
+
+An example shows how to connect to Geode, create a cache and region, put and get keys and values, and disconnect.
+
+## Simple C\# Code
+
+``` pre
+class BasicOperations
+{
+   public static void Main(string[] args)
+   {
+      try
+      {
+         // 1. Create a cache
+         CacheFactory cacheFactory = CacheFactory.CreateCacheFactory();
+         Cache cache = cacheFactory.Create();
+
+         // 2. Create default region attributes using region factory
+         RegionFactory regionFactory =
+            cache.CreateRegionFactory(RegionShortcut.CACHING_PROXY);
+
+         // 3. Create a region
+         IRegion<int, string> region =
+            regionFactory.Create<int, string>("exampleRegion");
+
+         // 4. Put some entries
+         region[111] = "Value1";
+         region[123] = "123";
+
+         // 5. Get the entries
+         string result1 = region[111];
+         string result2 = region[123];
+
+         // 6. Close cache
+         cache.Close();
+      }
+   }
+}
+```
+
+


Mime
View raw message