Existe-t-il un meilleur moyen d'écrire des pipes nommés dans F #?

Question

Je suis nouveau à F #. J'essaie de communiquer avec java de F # en utilisant un tube nommé. Le code ci-dessous fonctionne mais je ne suis pas sûr s'il y a une meilleure façon de le faire (je sais que la boucle infinie est une mauvaise idée mais ce n'est qu'une preuve de concept) si quelqu'un a une idée pour améliorer ce code .

Merci à l'avance Sudaly

open System.IO 
open System.IO.Pipes 
exception OuterError of string 


let continueLooping = true 
while continueLooping do 
    let pipeServer = new NamedPipeServerStream("testpipe", PipeDirection.InOut, 4) 
    printfn "[F#] NamedPipeServerStream thread created." 

    //wait for connection 
    printfn "[F#] Wait for a client to connect" 
    pipeServer.WaitForConnection() 

    printfn "[F#] Client connected." 
    try 
     // Stream for the request. 
     let sr = new StreamReader(pipeServer) 
     // Stream for the response. 
     let sw = new StreamWriter(pipeServer) 
     sw.AutoFlush <- true; 

     // Read request from the stream. 
     let echo = sr.ReadLine(); 

     printfn "[F#] Request message: %s" echo 

     // Write response to the stream. 
     sw.WriteLine("[F#]: " + echo) 

     pipeServer.Disconnect() 

    with 
    | OuterError(str) -> printfn "[F#]ERROR: %s" str 

    printfn "[F#] Client Closing." 
    pipeServer.Close() 

Answer 1

Eh bien, il ne ressemble pas à quoi que ce soit jette OuterError, donc je supprimer ce type d'exception et le traitement utilisé.

Je ne suis pas sûr de votre niveau d'expérience ou du type de «mieux» que vous recherchez. Vous voulez lire F# async on the server pour en savoir plus sur async et éviter les threads bloquants.

Answer 2

Ci-dessous vous trouverez quelques modifications à votre code. Votre question est assez vague, donc je ne peux pas dire exactement où vous voulez améliorer votre code, mais ma suggestion utilise la récursivité au lieu de la boucle while (ne vous inquiétez pas des débordements de pile, F # peut très bien gérer la récursivité bit récursif sera optimisé en une boucle au moment de la compilation), utilise le mot-clé et utilise le mot-clé (comme l'utilisation de C#) et avalera toute exception se produisant dans le processus de communication avec le client. Si une exception se produit, le serveur n'écoute pas les autres connexions.

open System.IO 
open System.IO.Pipes 

let main() = 
    printfn "[F#] NamedPipeServerStream thread created." 
    let pipeServer = new NamedPipeServerStream("testpipe", PipeDirection.InOut, 4) 
    let rec loop() = 
     //wait for connection 
     printfn "[F#] Wait for a client to connect" 
     pipeServer.WaitForConnection() 

     printfn "[F#] Client connected." 
     try 
      // Stream for the request. 
      use sr = new StreamReader(pipeServer) 
      // Stream for the response. 
      use sw = new StreamWriter(pipeServer, AutoFlush = true) 

      // Read request from the stream. 
      let echo = sr.ReadLine(); 

      printfn "[F#] Request message: %s" echo 

      // Write response to the stream. 
      echo |> sprintf "[F#]: %s" |> sw.WriteLine 

      pipeServer.Disconnect() 
      if [A CONDITION WHICH TELLS YOU THAT YOU WANT ANOTHER CONNECTION FROM THE CLIENT] then loop() 
     with 
     | _ as e -> printfn "[F#]ERROR: %s" e.Message 
    loop() 
    printfn "[F#] Client Closing." 
    pipeServer.Close() 

s'il vous plaît également remarquer comment le AutoFlush est situé dans l'appel au constructeur et comment l'opérateur de pipeline permet d'écrire l'écho à la conduite, ce qui dans ce qui ressemble (à mon avis) comme un code plus propre.