Add durability and CAS examples

Author: Branor

README.md

@@ -74,7 +74,7 @@ This example should show how to initialize and update a counter
 [C](c/counter.cc) |
 [Python](python/counter.py) |
 [Java](java/src/main/java/com/couchbase/devguide/Counter.java) |
-.NET |
+[.NET](dotnet/Counter.cs) |
 [Go](go/counter.go) |
 [node.js](nodejs/counter.js)
 
@@ -84,7 +84,7 @@ This example should show how to initialize a document with an Expiry or "ttl" -
 [C](c/expiration.cc) |
 [Python](python/expiration.py) |
 [Java](java/src/main/java/com/couchbase/devguide/Expiration.java) |
-.NET |
+[.NET](dotnet/Expiration.cs) |
 [Go](go/expiration.go) |
 [node.js](nodejs/expiration.js)
 
@@ -158,7 +158,7 @@ all mutations remain in tact
 [C](c/cas.cc) |
 [Python](python/cas.py) |
 [Java](java/src/main/java/com/couchbase/devguide/Cas.java) |
-.NET |
+[.NET](dotnet/Cas.cs) |
 Go |
 node.js
 
@@ -171,6 +171,6 @@ Some SDKs provide APIs to determine how many nodes are in the cluster, while som
 [C](c/durability.cc) |
 [Python](python/durability.py) |
 [Java](java/src/main/java/com/couchbase/devguide/Durability.java) |
-.NET |
+[.NET](dotnet/Durability.cs) |
 Go |
 node.js

dotnet/Cas.cs

@@ -0,0 +1,92 @@
+using Couchbase;
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace DevGuide
+{
+    public class Cas : ConnectionBase
+    {
+        public override async Task ExecuteAsync()
+        {
+            var key = "dotnetDevguideExampleCas-" + DateTime.Now.Ticks;
+            var data = new Data
+            {
+                Number = 0
+            };
+
+            // Set the inital number value to 0
+            await _bucket.UpsertAsync(key, data);
+
+            // Try to increment the number 1000 times without using CAS (10 threads x 100 increments)
+            // We would expect the result to be Number == 1000 at the end of the process.
+            var tasksWithoutCas = Enumerable.Range(1, 10).Select(i => UpdateNumberWithoutCas(key, 100));
+            await Task.WhenAll(tasksWithoutCas);
+
+            // Check if the actual result is 1000 as expected
+            var result = await _bucket.GetAsync<Data>(key);
+            Console.WriteLine("Expected number = 1000, actual number = " + result.Value.Number);
+
+
+            // Set the inital number value back to 0
+            await _bucket.UpsertAsync(key, data);
+
+            // Now try to increment the number 1000 times with CAS
+            var tasksWithCas = Enumerable.Range(1, 10).Select(i => UpdateNumberWithCas(key, 100));
+            await Task.WhenAll(tasksWithCas);
+
+            // Check if the actual result is 1000 as expected
+            var result2 = await _bucket.GetAsync<Data>(key);
+            Console.WriteLine("Expected number = 1000, actual number = " + result2.Value.Number);
+        }
+
+        private Task UpdateNumberWithoutCas(string key, int count)
+        {
+            return Task.Run(async () =>
+            {
+                for (int i = 0; i < count; i++)
+                {
+                    // Get the document
+                    var result = await _bucket.GetAsync<Data>(key);
+                    // Update the document
+                    result.Value.Number++;
+                    // Store the document back without CAS
+                    await _bucket.ReplaceAsync(key, result.Value);
+                }
+            });
+        }
+
+        private Task UpdateNumberWithCas(string key, int count)
+        {
+            return Task.Run(async () =>
+            {
+                for (int i = 0; i < count; i++)
+                {
+                    IOperationResult<Data> result = null;
+                    var retries = 100;
+                    do
+                    {
+                        // Get the document
+                        result = await _bucket.GetAsync<Data>(key);
+                        // Update the document
+                        result.Value.Number++;
+                        // Store the document back without CAS
+                        result = await _bucket.ReplaceAsync(key, result.Value, result.Cas);
+                    }
+                    while (result != null && 
+                           !result.Success && 
+                           // The .NET SDK returns a KeyExists status when the provided CAS doesn't match
+                           result.Status == Couchbase.IO.ResponseStatus.KeyExists &&
+                           retries-- > 0);
+                }
+            });
+        }
+
+        static void Main(string[] args)
+        {
+            new Cas().ExecuteAsync().Wait();
+        }
+    }
+}

dotnet/DevGuide.csproj

@@ -33,7 +33,7 @@
     <WarningLevel>4</WarningLevel>
   </PropertyGroup>
   <PropertyGroup>
-    <StartupObject>DevGuide.Expiration</StartupObject>
+    <StartupObject>DevGuide.Cas</StartupObject>
   </PropertyGroup>
   <ItemGroup>
     <Reference Include="Common.Logging, Version=3.1.0.0, Culture=neutral, PublicKeyToken=af08829b84f0328e, processorArchitecture=MSIL">
@@ -71,6 +71,8 @@
     <Compile Include="BulkInsert.cs" />
     <Compile Include="BulkGet.cs" />
     <Compile Include="Counter.cs" />
+    <Compile Include="Durability.cs" />
+    <Compile Include="Cas.cs" />
     <Compile Include="Update.cs" />
     <Compile Include="Retrieve.cs" />
   </ItemGroup>

dotnet/Durability.cs

@@ -0,0 +1,51 @@
+using Couchbase;
+using Couchbase.IO;
+using System;
+using System.Threading.Tasks;
+
+namespace DevGuide
+{
+    public class Durability : ConnectionBase
+    {
+        public override async Task ExecuteAsync()
+        {
+            var key = "dotnetDevguideExampleDurability-" + DateTime.Now.Ticks;
+            var data = new Data
+            {
+                Number = 42,
+                Text = "Life, the Universe, and Everything",
+                Date = DateTime.UtcNow
+            };
+            
+            // The ReplicateTo parameter must be less than or equal to the number of replicas 
+            // you have configured. Assuming that 3 replicas are configured, the following call
+            // waits for replication to 3 replicas and persistence to 4 nodes in total.
+            var result = await _bucket.UpsertAsync(key, data, ReplicateTo.Three, PersistTo.Four);
+            Console.WriteLine("Durability status: " + result.Durability);
+
+            if(!result.Success)
+            {
+                if (result.Status == ResponseStatus.NoReplicasFound)
+                    Console.WriteLine("Write failed - not enough replicas configured to satisfy durability requirements");
+                else
+                    Console.WriteLine("An error has occured: {0}\r\n{1}", result.Message, result.Exception.ToString());
+            }
+            else
+            {
+                // It's possible for a write to succeed, but not satisfy durability.
+                // For example, writing with PersistTo.Two and ReplicateTo.Zero on a 1-node cluster.
+                if (result.Durability == Couchbase.IO.Operations.Durability.NotSatisfied)
+                    Console.WriteLine("Write succeeded, but some durability requirements were not satisfied.");
+            }
+
+            // Wait for the write to be persisted to disk on one (normally the master) node.
+            var result2 = await _bucket.UpsertAsync(key, data, ReplicateTo.Zero, PersistTo.One);
+            Console.WriteLine("Durability status: " + result.Durability);
+        }
+
+        static void Main(string[] args)
+        {
+            new Durability ().ExecuteAsync().Wait();
+        }
+    }
+}