anchor.diff:                ?maxReceived : int,
                 ?concurrency : int,
                 ?mfEveryNthConcurrentAsync : int) =
  +  
     /// Field denoting whether the receiver is in the started state or, if false, in the stopped state.
     let mutable started = false
  +
  +  /// The 'scratch' buffer that tunnels messages from the ASB receivers
  +  /// to the consumers of the Receiver class.
  +  let messages = new BlockingCollection<_>(defaultArg maxReceived 50)
  +  
     let logger = MassTransit.Logging.Logger.Get(typeof<Receiver>)
  -  
  -  let queueSize = defaultArg maxReceived 50
  -
  -  /// Field that contains the collection of messages
  -  let messages = new BlockingCollection<_>(queueSize)
  -  
     let timeout = TimeSpan.FromMilliseconds 50.0
     let concurrency = defaultArg concurrency 250
     let nthAsync = defaultArg mfEveryNthConcurrentAsync 100 // in initAsyncs
  -
     let azQDesc = desc.Inner
   
  +  /// creates an async workflow worker, given a message receiver client
     let worker client =
         async {
           let! cancelled = Async.CancellationToken
  
positive.code:       | _ ->
          return! initAsyncs desc newMf stop (curr+1) recvs }
  
    let mfAndRecvsColl = Async.RunSynchronously (initAsyncs desc newMf (concurrency+1) 1 [])
  
    /// Closes the receivers and message factories created
    let closeColl () =
  
negative.code:       if not(recv.IsClosed) then
          try recv.Close()
          with | x -> logger.Error("could not close receiver", x)
          
    /// cleans out the message buffer and disposes all messages therein
    let clearLocks () = 
      while messages.Count > 0 do
        async {
          let m = ref null
          if messages.TryTake(m, TimeSpan.FromMilliseconds(4.0)) then 
            try 
              do! Async.FromBeginEnd((!m).BeginAbandon, (!m).EndAbandon)
              (!m).Dispose()
            with 
            | x ->
              let entry = sprintf "could not abandon message#%s" <| (!m).MessageId
              logger.Error(entry, x) }
          |> Async.Start
  
  
    /// Starts the receiver which starts the consuming from the service bus
    /// and creates the queue if it doesn't exist
    member x.Start () =
      logger.InfoFormat("start called for queue '{0}'", desc)
      if started then ()
      else started <- true
      start ()
  
    /// Stops the receiver; allowing it to start once again.
    member x.Stop () =
      logger.InfoFormat("stop called for queue '{0}'", desc)
      if not(started) then ()
      else 
        started <- false
        Async.CancelDefaultToken ()
  
    /// Returns a message if one was added to the buffer within the timeout specified,
    /// or otherwise returns null.
    member x.Get(timeout : TimeSpan) =
      let mutable item = null
      let _ = messages.TryTake(&item, timeout.Milliseconds)
      item
  
    /// Tries to take an item from the list of messages
    member internal __.TryTake(?timeout) =
      let timeout = defaultArg timeout <| TimeSpan.FromMilliseconds 50.0
      let mutable item = null
      if messages.TryTake(&item, timeout.Milliseconds)
  