4

有谁知道关于以下主题的“现有技术”：

  • 我的数据需要一些不错的时间才能加载。它们是各种股票的历史水平。
  • 我想以某种方式预加载它们，以避免使用我的应用程序时的延迟
  • 但是，在开始时将它们预加载到一个块中会使我的应用程序首先无响应，这对用户不友好

所以我不想加载我的数据....除非用户没有请求任何数据并使用他已经拥有的东西，在这种情况下我想一点一点地得到。所以它既不是“懒惰”也不是“渴望”，更多的是“当你需要时懒惰”和“当你可以时渴望”，因此是首字母缩写词 LWYNEWYC。

我做了以下似乎可行的方法，但我只是想知道是否有一种公认的和有福的方法来处理这种事情？

let r = LoggingFakeRepo () :> IQuoteRepository
r.getHisto "1" |> ignore  //prints Getting histo for 1 when called

let rc =  RepoCached (r) :> IQuoteRepository
rc.getHisto "1" |> ignore //prints Getting histo for 1 the first time only

let rcc =  RepoCachedEager (r) :> IQuoteRepository
rcc.getHisto "100" |> ignore  //prints Getting histo 1..100 by itself BUT
                              //prints Getting histo 100 immediately when called

和类

type IQuoteRepository = 
   abstract getUnderlyings : string seq
   abstract getHisto :  string -> string

type LoggingFakeRepo () =
   interface IQuoteRepository with 
      member x.getUnderlyings = printfn "getting underlyings"
                                [1 .. 100] |> List.map string :> _

      member x.getHisto udl = printfn "getting histo for %A" udl
                              "I am a historical dataset in a disguised party"

type RepoCached (rep : IQuoteRepository) =
   let memoize f =
     let cache = new System.Collections.Generic.Dictionary<_, _>()
     fun x ->
        if cache.ContainsKey(x) then cache.[x]
        else let res = f x
             cache.[x] <- res
             res
   let udls = lazy (rep.getUnderlyings )
   let gethistom = memoize rep.getHisto

   interface IQuoteRepository with 
      member x.getUnderlyings = udls.Force()
      member x.getHisto udl = gethistom udl

type Message = string * AsyncReplyChannel<UnderlyingWrap>
type RepoCachedEager (rep : IQuoteRepository) =
   let udls = rep.getUnderlyings

   let agent = MailboxProcessor<Message>.Start(fun inbox ->
      let repocached = RepoCached (rep) :> IQuoteRepository
      let rec loop l =
         async {  try
                     let timeout = if l|> List.isEmpty  then -1 else 50
                     let! (udl, replyChannel) = inbox.Receive(timeout)
                     replyChannel.Reply(repocached.getHisto udl)
                     do! loop l
                  with 
                  | :? System.TimeoutException -> 
                     let udl::xs = l
                     repocached.getHisto udl |> ignore
                     do! loop xs
          }
      loop (udls |> Seq.toList))

   interface IQuoteRepository with 
      member x.getUnderlyings = udls
      member x.getHisto udl = agent.PostAndReply(fun reply -> udl, reply)
4

1 回答 1

4

我喜欢你的解决方案。我认为使用代理来实现一些带有超时的后台加载是一个很好的方法——代理可以很好地封装可变状态，所以它显然是安全的，你可以很容易地编码你想要的行为。

我认为异步序列可能是另一个有用的抽象（如果我是正确的，它们现在在 FSharpX 中可用）。异步序列表示异步生成更多值的计算，因此它们可能是将数据加载器与其余代码分开的好方法。

我认为您在某些时候仍然需要一个代理来同步，但是您可以使用异步序列很好地分离不同的关注点。

加载数据的代码可能如下所示：

let loadStockPrices repo = asyncSeq {
  // TODO: Not sure how you detect that the repository has no more data...
  while true do
    // Get next item from the repository, preferably asynchronously!
    let! data = repo.AsyncGetNextHistoricalValue()
    // Return the value to the caller...
    yield data }

此代码表示数据加载器，并将其与使用它的代码分开。通过使用数据源的代理，您可以使用AsyncSeq.iterAsync这些值并对其进行处理。

使用iterAsync，您指定为使用者的函数是异步的。它可能会阻塞（即使用Sleep），当它阻塞时，源——即你的加载器——也被阻塞。这是从使用数据的代码中控制加载器的非常好的隐式方法。

一个尚未在库中的特性（但会很有用）是一个部分急切的评估器，它接受AsyncSeq<'T>并返回一个新的AsyncSeq<'T>但尽快从源获取一定数量的元素并缓存它们（这样消费者就不会当它要求一个值时必须等待，只要源可以足够快地产生值）。

于 2012-09-16T19:03:42.650 回答