anchor.diff:          result
       
       abstract AllFull : int * int * seq<Sort> * Filter * Expression<Func<'TEntity, bool>> -> DataSourceResult<'TDTO>
  +    
       override this.AllFull(take, skip, sort, filter, whereFunc) = 
           let queryResult = this.All(whereFunc).OrderBy(fun t -> t.ID).ToDataSourceResult(take, skip, sort, filter)
           let result = DataSourceResult<'TDTO>()
  
positive.code:         | _ -> this.Set().Where(whereExpr)
      
      abstract All : int * int * seq<Sort> * Filter * Expression<Func<'TEntity, bool>> -> DataSourceResult<'TDTO>
      override this.All(take, skip, sort, filter, whereFunc) = 
          let queryResult = this.All(whereFunc).OrderBy(fun t -> t.ID).ToDataSourceResult(take, skip, sort, filter)
          let result = DataSourceResult<'TDTO>()
  
negative.code:     override this.BuildFull(source, destination) = this.Build(source, destination)
      abstract BuildFullList : seq<'TSource> -> seq<'TDestination>
      override this.BuildFullList(sourceList) = sourceList |> Seq.map (fun t -> this.BuildFull(t))
      member this.BuildFullAsync(source) = async { return this.BuildFull(source) } |> Async.StartAsTask
      member this.BuildFullAsync(source, destination) = 
          async { return this.BuildFull(source, ref destination) } |> Async.StartAsTask
      member this.BuildFullListAsync(source) = async { return this.BuildFullList(source) } |> Async.StartAsTask
      
      override this.AfterBuild(source, destination) = 
          base.AfterBuild(source, destination)
          let destType = typedefof<'TDestination>
          let sourceType = typedefof<'TSource>
          let properties = 
              destType.GetProperties(BindingFlags.Public ||| BindingFlags.Instance) 
              |> Seq.filter 
                     (fun t -> 
                     (t.PropertyType.IsPrimitive || t.PropertyType.IsValueType || t.PropertyType.Equals(typedefof<string>)) = false 
                     && t.PropertyType.IsEnumerableType() = false)
          for prop in properties do
              if Mapper.FindTypeMapFor<'TSource, 'TDestination>().GetPropertyMaps()
                     .Any(fun t -> t.IsIgnored() && t.DestinationProperty.Name = prop.Name) = false then 
                  let sourceProp = sourceType.GetProperty(prop.Name, BindingFlags.Public ||| BindingFlags.Instance)
                  if sourceProp <> null then 
                      if sourceProp.PropertyType.GetInterfaces().Contains(typedefof<IEntity>) 
                         && prop.PropertyType.GetInterfaces().Contains(typedefof<IDTO>) then 
                          let builderGenerator = 
                              (typedefof<GenericBusinessBuilder>)
                                  .GetMethod("GenericDTOBuilder", BindingFlags.Public ||| BindingFlags.Static)
                                  .MakeGenericMethod(sourceProp.PropertyType, prop.PropertyType)
                          let builder = builderGenerator.Invoke(null, null)
                          let buildMethod = 
                              builder.GetType().GetMethods(BindingFlags.Public ||| BindingFlags.Instance)
                                     .Single(fun t -> t.GetParameters().Count() = 1 && t.Name = "Build")
                          let sourceValue = sourceProp.GetValue(source, null)
                          if (sourceValue <> null) then 
                              let destValue = buildMethod.Invoke(builder, [| sourceValue |])
                              prop.SetValue(!destination, destValue)
                      else 
                          let builderGenerator = 
                              (typedefof<GenericBuilder>).GetMethod("Create", BindingFlags.Public ||| BindingFlags.Static)
                                  .MakeGenericMethod(sourceProp.PropertyType, prop.PropertyType)
                          let builder = builderGenerator.Invoke(null, null)
                          let buildMethod = 
                              builder.GetType().GetMethods(BindingFlags.Public ||| BindingFlags.Instance)
                                     .Single(fun t -> t.GetParameters().Count() = 1 && t.Name = "Build")
                          let sourceValue = sourceProp.GetValue(source, null)
                          if (sourceValue <> null) then 
                              let destValue = buildMethod.Invoke(builder, [| sourceValue |])
                              prop.SetValue(!destination, destValue)
      
      override this.AddMappingConfigurations(mappingExpression) = 
          base.AddMappingConfigurations(mappingExpression)
  