anchor.diff:                                 | null -> (this :> IRepository<'TEntity, 'TDTO>).DTOBuilder()
                                  | _ -> this.DTOBuilder(this.DTOMapper)
       member this.EntityBuilder() = match this.EntityMapper with 
  -                               | null -> (this :> IRepository<'TEntity, 'TDTO>).EntityBuilder()
  -                               | _ -> this.EntityBuilder(this.EntityMapper)
  +                                  | null -> (this :> IRepository<'TEntity, 'TDTO>).EntityBuilder()
  +                                  | _ -> this.EntityBuilder(this.EntityMapper)
       member this.Set() = (this :> IRepository<'TEntity, 'TDTO>).Set()
       member this.Single([<ParamArray>] ids : obj []) = (this :> IRepository<'TEntity, 'TDTO>).Single(ids)
       member this.Single(expr : Expression<Func<'TEntity, bool>>) = (this :> IRepository<'TEntity, 'TDTO>).Single(expr)
  
positive.code:     
      member private this.All(take : int, skip : int, sort : seq<Sort>, filter : Filter, 
                              whereFunc : Expression<Func<'TEntity, bool>>, buildFunc : seq<'TEntity> -> seq<'TDTO>) = 
          let queryResult = 
              (match query { 
                         for item in (typeof<'TEntity>).GetProperties(BindingFlags.Instance ||| BindingFlags.Public) 
                                     |> Seq.map (fun t -> t.Name) do
                             select item
                             headOrDefault
                     } with
               | null -> this.All(whereFunc)
               | defaultSort -> this.All(whereFunc).OrderBy(defaultSort)).ToDataSourceResult(take, skip, sort, filter)
          DataSourceResult<'TDTO>(Data = buildFunc (queryResult.Data), Total = queryResult.Total)
  
      member this.All(take, skip, sort, filter, whereFunc) = 
          (this :> IRepository<'TEntity, 'TDTO>).All(take, skip, sort, filter, whereFunc)
      member this.Insert(dto : 'TDTO) = (this :> IRepository<'TEntity, 'TDTO>).Insert(dto)
      member this.Insert(entity : 'TEntity) = (this :> IRepository<'TEntity, 'TDTO>).Insert(entity)
      member this.Update(dto : 'TDTO, [<ParamArray>] ids) = (this :> IRepository<'TEntity, 'TDTO>).Update(dto, ids)
      member this.Update(entity : 'TEntity, [<ParamArray>] ids) = 
          (this :> IRepository<'TEntity, 'TDTO>).Update(entity, ids)
      member this.Delete(dto : 'TDTO, [<ParamArray>] ids) = (this :> IRepository<'TEntity, 'TDTO>).Delete(dto, ids)
      member this.Delete(entity : 'TEntity, [<ParamArray>] ids) = 
          (this :> IRepository<'TEntity, 'TDTO>).Delete(entity, ids)
      member this.Delete([<ParamArray>] ids : obj []) = (this :> IRepository<'TEntity, 'TDTO>).Delete(ids)
      member this.InsertAsync(dto : 'TDTO) = async { this.Insert(dto) } |> Async.StartAsTask
      member this.UpdateAsync(dto : 'TDTO, ids) = async { this.Update(dto, ids) } |> Async.StartAsTask
      member this.InsertAsync(entity : 'TEntity) = async { this.Insert(entity) } |> Async.StartAsTask
      member this.UpdateAsync(entity : 'TEntity, ids) = async { this.Update(entity, ids) } |> Async.StartAsTask
      member this.DeleteAsync(dto : 'TDTO, [<ParamArray>] ids) = async { this.Delete(dto, ids) } |> Async.StartAsTask
      member this.DeleteAsync(entity : 'TEntity, [<ParamArray>] ids) = 
          async { this.Delete(entity, ids) } |> Async.StartAsTask
      member this.DeleteAsync(ids : obj []) = async { this.Delete(ids) } |> Async.StartAsTask
      member this.ListAsync(whereExpr : Expression<Func<'TEntity, bool>>) = 
          async { return this.List(whereExpr) } |> Async.StartAsTask
      member this.ListAsync() = async { return this.List() } |> Async.StartAsTask
      member this.AllAsync(take : int, skip : int, sort : seq<Sort>, filter : Filter, 
                           whereFunc : Expression<Func<'TEntity, bool>>) = 
          async { return this.All(take, skip, sort, filter, whereFunc) } |> Async.StartAsTask
      member this.SingleAsync([<ParamArray>] id : obj []) = async { return this.Single(id) } |> Async.StartAsTask
      member this.SingleAsync(expr : 'TEntity -> bool) = async { return this.Single(expr) } |> Async.StartAsTask
  
negative.code:         member __.EntityBuilder() = Builder<'TDTO, 'TEntity>()
          member this.Set() = (this.GetUnitOfWork() :?> UnitOfWork).DbSet() :> DbSet<'TEntity>
          member this.Single([<ParamArray>] ids) = this.DTOBuilder().Build(this.Set().Find(ids))
          member this.Single(expr) = 
              let entity = match expr with
                           | null -> this.Set().FirstOrDefault()
                           | _ -> this.Set().FirstOrDefault(expr)
              this.DTOBuilder().Build(entity)
          member this.List() = this.DTOBuilder().BuildList(this.All())
          member this.List whereExpr = this.DTOBuilder().BuildList(this.All(whereExpr))
          member this.All() = this.Set().AsQueryable()
          member this.All(take, skip, sort, filter, whereFunc) = this.All(take, skip, sort, filter, whereFunc, this.DTOBuilder().BuildList)
          member this.All(whereExpr) = 
              match whereExpr with
              | null -> this.All()
              | _ -> this.Set().Where(whereExpr).AsQueryable()
          member this.Insert(dto : 'TDTO) = this.Set().Add(this.EntityBuilder().Build(dto)) |> ignore
          member this.Insert(entity : 'TEntity) = this.Set().Add(entity) |> ignore
          member this.Update(dto : 'TDTO, [<ParamArray>] ids) = 
              let newEntity : ref<'TEntity> = ref null
              this.EntityBuilder().Build(dto, newEntity)
              (manager :?> UnitOfWork).Entry(this.Set().Find(ids)).CurrentValues.SetValues(!newEntity)
          member this.Update(entity : 'TEntity, [<ParamArray>] ids) = (manager :?> UnitOfWork).Entry(this.Set().Find(ids)).CurrentValues.SetValues(entity)
          member this.Delete(_ : 'TDTO, [<ParamArray>] ids) = this.Set().Remove(this.Set().Find(ids)) |> ignore
          member this.Delete(_ : 'TEntity, [<ParamArray>] ids) = this.Set().Remove(this.Set().Find(ids)) |> ignore
          member this.Delete([<ParamArray>] ids : obj []) = this.Delete(this.Single(ids), ids)
  
      member val DTOMapper : IMapper<'TEntity, 'TDTO> = null with get, set
  