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:                 return e <> null
              }
          
          member this.Count: Local<int64> = Cloud.Raise(new NotSupportedException("Count property not supported."))
          
          member this.Size: Local<int64> = Cloud.Raise(new NotSupportedException("Size property not supported."))
  
          member this.Dispose(): Local<unit> = 
              async {
                  let! _ = client.GetTableReference(tableName).DeleteAsync()
                           |> Async.AwaitTask
                  return ()
              } |> Cloud.OfAsync
          
          member this.Id: string = tableName
          
  
negative.code:     [<OnDeserialized>]
      let _onDeserialized (_ : StreamingContext) =
          client <- Table.getClient(CloudStorageAccount.Parse connectionString)
  
      let getSeqAsync() = 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())))
      }
  
      let getSeq() = getSeqAsync() |> Async.RunSync
  
      interface seq<KeyValuePair<string,'T>> with
          member __.GetEnumerator() = getSeq().GetEnumerator() :> IEnumerator
          member __.GetEnumerator() = getSeq().GetEnumerator()
          
      interface CloudDictionary<'T> with
          member x.IsKnownCount: bool = false
          member x.IsMaterialized : bool = false
          member x.IsKnownSize: bool = false
          
          member this.Add(key: string, value : 'T): Async<unit> = 
  