F#

F#

F# 开发者有两种替代方案：fszmq 和 FsNetMQ。fszmq 是 libzmq 的绑定，而 FsNetMQ 是 NetMQ 的一个轻量级 F# 封装，NetMQ 是 libzmq 到 C# 的纯移植。

FsNetMQ

Github https://github.com/NetMQ/FsNetMQ
Nuget https://nuget.net.cn/packages/FsNetMQ/

示例

use router = Socket.router ()
router.bind socket "tcp://*:6566"

use dealer = Socket.dealer ()
Socket.connect socket "tcp://127.0.0.1:6566"

Frame.send dealer "Hello"B

let frame,more = Frame.recv router

为多个套接字使用 Poller

Poller 使用 IObservable，因此每当您向 Poller 添加套接字时，您会获得一个可观察对象，您可以订阅该对象以接收新消息通知。

use poller = Poller.create ()
use dealer = Socket.dealer ()
use subscriber = Socker.sub ()

// Connecting and subscribing...

let dealerObservable =
  Poller.addSocket poller dealer
  |> Observable.map Frame.recv

let subObservable =
  Poller.addSocket poller subscriber
  |> Observable.map Frame.recv

use observer =
  Observable.merge dealerObservable subObservable
  |> Observable.subscribe (fun msg -> printfn "%A" msg)

Poller.run poller

Actor

Actor 是一个附加了套接字的线程，因此您可以向其发送消息并请求取消。与 Poller 结合使用，这是一个强大的概念。

// Actor is disposable, so whenever you call dispose
// on the actor the end message will be sent and the thread will exit
let actor =
  Actor.create (fun shim ->
    use poller = Poller.create ()

    // Registering for the end message which will cancel the actor
    use emObserver = Poller.registerEndMessage poller shim

    // Creating sockets and adding them to the poller
    ...

    // Signalling that the actor is ready, this will let the Actor.create function to return
    Actor.signal shim

    Poller.run poller

fszmq – **已弃用 (2021年2月10日)**

Githubhttps://github.com/zeromq/fszmq
网站http://zeromq.github.io/fszmq/
文档http://zeromq.github.io/fszmq/reference/index.html
Nugethttps://nuget.net.cn/packages/FsNetMQ/

先决条件

您需要安装 libzmq，请按照下载页面上的说明进行操作。

示例

open fszmq
open fszmq.Context
open fszmq.Socket

let server () =
  // create a ZMQ context
  use context = new Context()

  // create reply socket
  use server  = rep context
  // begin receiving connections
  bind server "tcp://*:5555"

  let rec loop () =
    // process request (i.e. 'recv' a message from our 'server')
    // NOTE: it's convenient to 'decode' the (binary) message into a string
    match server |> recv |> decode with
    | "hello"   ->  // valid request; send a reply back
                    // NOTE: "..."B is short-hand for a byte array of ASCII-encoded chars
                    "world"B |>> server
                    // wait for next request
                    loop()
    | _         ->  // invalid request; stop receiving connections
                    "goodbye"B |>> server

  // wait for next request
  loop ()

let client () =
  // create a ZMQ context
  use context = new Context()

  // create a request socket
  use client  = req context
  // connect to the server
  "tcp://localhost:5555" |> connect client

  for i in 1 .. 10 do
    // 'send' a request to the server
    let request = if i = 10 then "goodbye" else "hello"
    // NOTE: we need to 'encode' a string to binary (before transmission)
    request |> encode |> send client
    printfn "(%i) sent: %s" i request
    // receive and print a reply from the server
    let reply = (recv >> decode) client
    printfn "(%i) got: %s" i reply