F# 从可见光中创建TcpListener是个好主意吗？

我一直在玩FSharp.Control.Reactive库，同时尝试学习一些反应式编程的应用程序。使用.NET TcpListener类监听客户机是一个被动的过程，因此我决定使用可观察对象在F#中创建一个服务器（松散地说）。我的测试用例是来自天文学程序（Stellarium）的单客户端连接，该程序以20字节的tcp套接字流发送恒星的天体坐标。我下面的代码片段可以工作，但使用Observable订阅TcpListener和任何最终连接的客户机流是一个好主意还是一种实用方法？优势和劣势是什么

open System
open System.Net
open System.Net.Sockets
open System.Threading
open System.Reactive
open System.Reactive.Linq
open System.Reactive.Concurrency
open System.Reactive.Disposables
open FSharp.Control.Reactive.Builders
open FSharp.Control.Reactive.Observable
open FSharp.Control.Reactive.Disposables

type TcpListener with
    member l.AcceptClientAsync = async {
        let! client = Async.AwaitTask <| l.AcceptSocketAsync()
        return client
    }

let readCoordinates(coords : byte[]) =
    let raInt = BitConverter.ToUInt32(coords, 12)
    let decInt = BitConverter.ToInt32(coords, 16)

    let ra_h = float raInt * 12.0 / 2147483648.0
    let dec_h = float decInt * 90.0 / 1073741824.0

    if (coords.Length > 0) then
        Some (ra_h, dec_h)
    else
        None

let listen() = 
    let ipAddr = IPAddress.Any
    let endpoint = IPEndPoint(ipAddr, 10001)
    let listener = TcpListener(endpoint)

    listener.Start()

    observe.While ((fun () -> true), ofAsync(listener.AcceptClientAsync))
    |> bind( (fun socket -> observe.Yield(new NetworkStream(socket))) )
    |> bind(fun stream -> observe.While( (fun _ -> true), ofAsync(stream.AsyncRead(20)) ))
    |> map (fun bytes -> readCoordinates bytes)


[<EntryPoint>]
let main argv = 

    listen()
    |> subscribe (fun coords -> printfn "Target Coordinates %A" coords)
    |> ignore


    printfn "Hit enter to continue"
    Console.Read() |> ignore

    0 

开放系统
开放系统.Net
开放式System.Net.Sockets
开放系统。线程
开放系统，反应式
开放系统.Reactive.Linq
开放系统.反应性.并发性
开放式系统、反应式、一次性
打开FSharp.Control.Reactive.Builders
打开FSharp.Control.Reactive.Observable
打开FSharp.Control.Reactive.Disposables
带有
成员l.AcceptClientAsync=async{
让！client=Async.0）然后
一些（ra_h，dec_h）
其他的
没有一个
让我们听一听
让ipAddr=IPAddress.Any
让端点=IPEndPoint（ipAddr，10001）
let listener=TcpListener（端点）
listener.Start（）
观察.While（（fun（）->true），ofAsync（listener.AcceptClientAsync））
|>绑定（（有趣的套接字->观察.Yield（新的网络流（套接字）））
|>绑定（fun stream->observe.While（（fun\uu->true），ofAsync（stream.AsyncRead（20）））
|>地图（趣味字节->读取坐标字节）
[]
让主argv=
听
|>订阅（趣味坐标->打印fn“目标坐标%A”坐标）
|>忽略
printfn“点击回车键继续”
Console.Read（）|>忽略
0