anchor.diff:      /// Collection of native serializer function, to avoid reinstall same serializer 
       member val internal NativeSerializerCollection = ConcurrentDictionary<Guid,string>() with get
       /// Collection of native deserializer function, to avoid reinstall same deserializer
  -    member val internal NativeDeserializerCollection = ConcurrentDictionary<Guid,Object>() with get
  +    member val internal NativeDeserializerCollection = ConcurrentDictionary<Guid,string>() with get
   
       /// <summary>
       /// Install a customized Memory Manager. 
  
positive.code:     /// <param name="bAllowReplicate"> should be false, does not allow multiple serializer with same Guid.  </param>
      member x.InstallDeserializer<'Type>( id: Guid, decodeFunc: Stream -> 'Type, info:string, bAllowReplicate ) = 
          let bNewFunc = ref false
          let decodeFuncObj = decodeFunc :> Object
          let retObj = x.NativeDeserializerCollection.AddOrUpdate( id, ( fun id ->  bNewFunc := true
                                                                                    decodeFuncObj ),
                                                                       ( fun id oldObj -> oldObj ) )
          if !bNewFunc && Object.ReferenceEquals( retObj, decodeFuncObj ) then 
              // A new function is to be installed 
              let wrappedDecodeFunc (ms) = 
                  decodeFunc ( ms ) :> Object
  
negative.code:         let retInfo = x.NativeSerializerCollection.AddOrUpdate( id, ( fun id ->  bNewFunc := true
                                                                                   encodeInfo ),
                                                                       ( fun id oldObj -> oldObj ) )
          if !bNewFunc && String.CompareOrdinal( encodeInfo, retInfo )=0 then 
              // A new function is to be installed 
              let wrappedEncodeFunc (o:Object, ms ) = 
                  encodeFunc ( o :?> 'Type, ms ) 
  