anchor.diff:          new CloudDictionaryProvider(connectionString)
   
       interface ICloudDictionaryProvider with
  -        member x.Create(): Async<ICloudDictionary<'T>> = 
  +        member x.Id = client.BaseUri.AbsolutePath
  +        member x.Name = "Table Store CloudDictionary Provider"
  +        member x.Create(): Async<CloudDictionary<'T>> = 
               async {
                   let tableName = Table.getRandomName()
                   let tableRef = client.GetTableReference(tableName)
                   let! _ = tableRef.CreateIfNotExistsAsync()
  -                return new CloudDictionary<'T>(tableName, connectionString) :> ICloudDictionary<'T>
  +                return new Dictionary<'T>(tableName, connectionString) :> CloudDictionary<'T>
               }
   
           member x.IsSupportedValue(value: 'T): bool = 
  
positive.code: ﻿namespace MBrace.Azure.Store
  
  open System
  open System.Runtime.Serialization
  open System.IO
  
  open Microsoft.WindowsAzure.Storage
  open Microsoft.WindowsAzure.Storage.Table
  
  open MBrace.Core
  open MBrace.Store
  open MBrace.Store.Internals
  open MBrace.Runtime.Vagabond
  
  open MBrace.Azure.Store.TableEntities
  open MBrace.Azure.Store.TableEntities.Table
  open System.Collections.Generic
  
  /// Azure Table store CloudDictionary implementation.
  [<AutoSerializable(true) ; Sealed; DataContract>]
  type CloudDictionary<'T> (tableName : string, connectionString) = 
      
      [<DataMember(Name = "ConnectionString")>]
      let connectionString = connectionString
  
negative.code:                     if NotFound ex then return false else return raise ex
              }
          
          member this.ToEnumerable(): Async<seq<Collections.Generic.KeyValuePair<string,'T>>> = 
              async {
                  let! entities = Table.readAll<FatEntity> client tableName
                  return entities
                         |> Seq.map (fun entity -> new KeyValuePair<_,_>(entity.PartitionKey, VagabondRegistry.Instance.Serializer.UnPickle<'T>(entity.GetPayload())))
              }
          
          member this.TryAdd(key: string, value: 'T): Async<bool> = 
              async {
                  try
                      do! (this :> CloudDictionary<'T>).Add(key, value)
                      return true
                  with ex ->
                      if Conflict ex then return false else return raise ex
  