NamedPipes - Nachricht von Client an Server wird nicht im Server angezeigt/kommt nicht an(?)

  • C#

Es gibt 9 Antworten in diesem Thema. Der letzte Beitrag () ist von ClonkAndre.

    NamedPipes - Nachricht von Client an Server wird nicht im Server angezeigt/kommt nicht an(?)

    Hi,

    ich habe eine Konsolenanwendung, und ein Script (DLL) das als Mod für ein Spiel dient.
    Nun würde ich gerne zwischen Konsole und Script Daten austauschen.
    Ich habe mich für NamedPipes entschieden.

    Wenn ich nun einen string von Client zu Server schicke, dann wird in meiner Konsole nichts angezeigt das etwas empfangen wurde.
    Wenn ich jedoch von meinem Server eine Nachricht zum Client schicke, dann wird meine Nachricht die ich vom Client zum Server geschickt habe auf einmal doch in der Konsole angezeigt.

    Ich bin neu in der Entwicklung mit NamedPipes also könnte ich eure Ratschläge gut gebrauchen.

    Hier mal mein momentaner Code vom Server:
    Spoiler anzeigen

    C#-Quellcode

    1. namespace PipeServerTest {
    2. class Program {
    4. private static NamedPipeServerStream server;
    5. private static StreamReader sr;
    6. private static StreamWriter sw;
    8. static void Main(string[] args)
    9. {
    10. try
    11. {
    12. server = new NamedPipeServerStream("testPipe123", PipeDirection.InOut, 1);
    13. while (true)
    14. {
    15. server.WaitForConnection();
    16. sr = new StreamReader(server);
    17. sw = new StreamWriter(server);
    19. // Ich habe auch schon versucht diesen Block auszukommentieren
    20. string input = Console.ReadLine();
    21. if (!string.IsNullOrWhiteSpace(input))
    22. {
    23. sw.WriteLine(input);
    24. sw.Flush();
    25. }
    26. //
    28. if (sr.Peek() > 0) {
    29. string msg = sr.ReadLine();
    30. Console.WriteLine("Message: " + msg);
    31. }
    33. server.Disconnect();
    34. }
    35. }
    36. catch (Exception ex)
    37. {
    38. Console.WriteLine("Error: " + ex.Message);
    39. }
    40. }
    42. }
    43. }



    Und hier der aktuelle Code vom Client:
    Spoiler anzeigen

    C#-Quellcode

    1. private bool Pipe_IsRunning;
    2. private bool Pipe_IsConnected;
    3. private string Pipe_Name;
    4. private NamedPipeClientStream Pipe_Client;
    5. private StreamReader Pipe_sr;
    6. private StreamWriter Pipe_sw;
    8. #region Methods
    9. private bool StartPipe(string pipeName)
    10. {
    11. if (!Pipe_IsRunning) {
    12. Pipe_Name = pipeName;
    13. Pipe_IsRunning = true;
    14. Pipe_Process();
    15. return true;
    16. }
    17. return false;
    18. }
    19. private bool StopPipe()
    20. {
    21. try {
    22. if (Pipe_IsRunning) {
    23. Pipe_IsRunning = false;
    25. if (Pipe_sr != null) {
    26. Pipe_sr.Dispose();
    27. Pipe_sr = null;
    28. }
    29. if (Pipe_sw != null) {
    30. Pipe_sw.Dispose();
    31. Pipe_sw = null;
    32. }
    34. return true;
    35. }
    36. return false;
    37. }
    38. catch (Exception ex) {
    39. Game.Console.Print("Pipe stop error. Details: " + ex.Message);
    40. return false;
    41. }
    42. }
    44. private bool WritePipe(string input)
    45. {
    46. try {
    47. if (Pipe_sw != null) {
    48. // Wenn ich "Task.Run" rausnehme, dann friert das Spiel komischerweiße ein, erst wenn ich den server schließe läuft das Spiel normal weiter
    49. Task.Run(() => {
    50. Pipe_sw.WriteLine(input);
    51. Pipe_sw.Flush();
    52. Pipe_Client.WaitForPipeDrain();
    53. });
    54. //
    55. return true;
    56. }
    57. return false;
    58. }
    59. catch (Exception) {
    60. return false;
    61. }
    62. }
    63. #endregion
    65. private void Pipe_Process()
    66. {
    67. Task.Run(() => {
    68. while (Pipe_IsRunning) {
    69. if (Pipe_IsRunning) {
    70. using (NamedPipeClientStream client = new NamedPipeClientStream("localhost", Pipe_Name, PipeDirection.InOut)) {
    71. try {
    72. client.Connect();
    73. Pipe_Client = client;
    74. Pipe_sr = new StreamReader(client);
    75. Pipe_sw = new StreamWriter(client);
    77. if (Pipe_sr.Peek() > 0) {
    78. string msg = Pipe_sr.ReadLine();
    79. Game.DisplayText(msg);
    80. }
    81. }
    82. catch (IOException) {
    83. // ...
    84. break;
    85. }
    86. }
    87. }
    89. }
    90. });
    91. }



    Woran könnte es liegen?

    Falls noch weitere Fragen bestehen stellt diese gerne.
    Wenn ich dir auf irgendeiner Art und Weise helfen konnte, drück doch bitte den "Hilfreich" Button :thumbup:

    Für VB.NET Entwickler: Option Strict On nicht vergessen!

    Welche Logik steckt hinter

    C#-Quellcode

    1. while (Pipe_IsRunning) {
    2. if (Pipe_IsRunning) {

    Der ganze Pipe_Process kommt mir komisch vor. Da wird ja alle x Mikrosekunden nach jeder Servernachricht die Verbindung aufgebaut und wieder getrennt, Dank des using-Blocks. Das ist doch nicht Sinn der Sache, oder?
    Dieser Beitrag wurde bereits 5 mal editiert, zuletzt von „VaporiZed“, mal wieder aus Grammatikgründen.

    Aufgrund spontaner Selbsteintrübung sind all meine Glaskugeln beim Hersteller. Lasst mich daher bitte nicht den Spekulatiusbackmodus wechseln.

    VaporiZed schrieb:

    Welche Logik steckt hinter
    C#-Quellcode
    while (Pipe_IsRunning) {
    if (Pipe_IsRunning) {

    Habs vergessen rauszunehmen. :whistling:

    VaporiZed schrieb:

    Das ist doch nicht Sinn der Sache, oder?


    Ne, da hast Du Recht, das ist nicht Sinn der Sache. Ich werde es mal ändern, mal schauen was ich für ein Ergebniss bekomme.
    Wenn ich dir auf irgendeiner Art und Weise helfen konnte, drück doch bitte den "Hilfreich" Button :thumbup:

    Für VB.NET Entwickler: Option Strict On nicht vergessen!

    Ich habe den Code von Server und Client etwas geändert.

    Server sieht nun so aus:
    Spoiler anzeigen

    C#-Quellcode

    1. static void Main(string[] args)
    2. {
    3. try
    4. {
    5. server = new NamedPipeServerStream("testPipe123", PipeDirection.InOut, 1);
    6. server.WaitForConnection();
    7. sr = new StreamReader(server);
    8. sw = new StreamWriter(server);
    9. while (true)
    10. {
    11. string input = Console.ReadLine();
    12. if (!string.IsNullOrWhiteSpace(input)) {
    13. sw.WriteLine(input);
    14. sw.Flush();
    15. }
    17. if (sr.Peek() > 0) {
    18. string msg = sr.ReadLine();
    19. Console.WriteLine("Message: " + msg);
    20. }
    21. }
    22. }
    23. catch (Exception ex)
    24. {
    25. Console.WriteLine("Error: " + ex.Message);
    26. }
    27. }



    Client sieht nun so aus:
    Spoiler anzeigen

    C#-Quellcode

    1. private void Pipe_Process()
    2. {
    3. Task.Run(() => {
    4. Pipe_Client.Connect();
    5. Pipe_sr = new StreamReader(Pipe_Client);
    6. Pipe_sw = new StreamWriter(Pipe_Client);
    7. while (Pipe_IsRunning) {
    8. try {
    9. if (Pipe_sr.Peek() > 0) {
    10. string msg = Pipe_sr.ReadLine();
    11. //PipeDataReceived(msg);
    12. Game.DisplayText(msg, 3500);
    13. }
    14. }
    15. catch (IOException ex) {
    16. Game.Console.Print(ex.Message);
    17. break;
    18. }
    19. }
    20. });
    21. }



    Ich hoffe es ist ein bisschen besser geworden ;)

    Problem mit diesem Code ist jedoch nun: Client und Server können sich jeweils nur noch eine Nachricht gegenseitig schicken, danach können keine Nachrichten mehr versendet werden. (Zumindest vom Server aus nicht weil ich kann dann nichts mehr in der Console eingeben.)
    Wenn ich dir auf irgendeiner Art und Weise helfen konnte, drück doch bitte den "Hilfreich" Button :thumbup:

    Für VB.NET Entwickler: Option Strict On nicht vergessen!

    @ClonkAndre Du kannst doch das Studio zwei Mal öffnen und in jedem einen Teil Deiner Kommunikation laufen lassen.
    Das Debuggen ist da zwar etwas schwierig, aber es ist möglich.
    Falls Du diesen Code kopierst, achte auf die C&P-Bremse.
    Jede einzelne Zeile Deines Programms, die Du nicht explizit getestet hast, ist falsch :!:
    Ein guter .NET-Snippetkonverter (der ist verfügbar).
    Programmierfragen über PN / Konversation werden ignoriert!

    Ich find's gerade (wohl aufgrund von Unwissenheit) interessant:
    Server

    C#-Quellcode

    1. using System;
    2. using System.IO;
    3. using System.IO.Pipes;
    5. namespace PipeServerTest
    6. {
    7. class Program
    8. {
    9. private static NamedPipeServerStream server;
    10. private static StreamWriter sw;
    11. static void Main(string[] args)
    12. {
    13. try
    14. {
    15. server = new NamedPipeServerStream("testPipe123", PipeDirection.InOut, 1);
    16. server.WaitForConnection();
    17. sw = new StreamWriter(server);
    18. while (true)
    19. {
    20. string input = Console.ReadLine();
    21. if (!string.IsNullOrWhiteSpace(input))
    22. {
    23. sw.WriteLine(input);
    24. sw.Flush();
    25. }
    26. }
    27. }
    28. catch (Exception ex)
    29. {
    30. Console.WriteLine("Error: " + ex.Message);
    31. }
    32. }
    33. }
    34. }

    Client

    C#-Quellcode

    1. using System;
    2. using System.IO;
    3. using System.IO.Pipes;
    5. namespace PipeClientCS
    6. {
    7. class Program
    8. {
    9. private bool Pipe_IsConnected;
    10. private string Pipe_Name;
    11. private NamedPipeClientStream Pipe_Client;
    12. private StreamReader Pipe_sr;
    13. private StreamWriter Pipe_sw;
    15. private void ConnectPipe(string pipeName)
    16. {
    17. if (Pipe_IsConnected) return;
    19. InitializePipe(pipeName);
    20. CommunicateWithPipeServer();
    21. }
    23. private void InitializePipe(string pipeName)
    24. {
    25. Pipe_Name = pipeName;
    26. Pipe_IsConnected = true;
    27. }
    29. private void CommunicateWithPipeServer()
    30. {
    31. Pipe_Client = new NamedPipeClientStream("localhost", Pipe_Name, PipeDirection.InOut);
    32. Pipe_Client.Connect();
    33. Pipe_sr = new StreamReader(Pipe_Client);
    34. Pipe_sw = new StreamWriter(Pipe_Client);
    35. while (Pipe_IsConnected)
    36. {
    37. try
    38. {
    39. while (Pipe_sr.Peek() == -1) ;
    40. string msg = Pipe_sr.ReadLine();
    41. Console.WriteLine("got a message from server: " + msg);
    42. if (Pipe_sr.EndOfStream) Console.WriteLine("Ende der Verbindung");
    43. }
    44. catch (IOException ex)
    45. {
    46. Console.WriteLine(ex.Message);
    47. break;
    48. }
    49. }
    50. }
    52. private void DisconnectPipe()
    53. {
    54. if (!Pipe_IsConnected) return;
    56. Pipe_IsConnected = false;
    57. if (Pipe_sr != null)
    58. {
    59. Pipe_sr.Dispose();
    60. Pipe_sr = null;
    61. }
    62. if (Pipe_sw != null)
    63. {
    64. Pipe_sw.Dispose();
    65. Pipe_sw = null;
    66. }
    67. }
    69. static void Main(string[] args)
    70. {
    71. Program Program = new Program();
    72. Program.ConnectPipe("testPipe123");
    73. Program.DisconnectPipe();
    74. }
    75. }
    76. }

    So kann ich Nachrichten vom Server an den Client schicken. Kommentiere ich aber Z#42 beim Client aus, klappt es nicht mehr. ?(
    Dieser Beitrag wurde bereits 5 mal editiert, zuletzt von „VaporiZed“, mal wieder aus Grammatikgründen.

    Aufgrund spontaner Selbsteintrübung sind all meine Glaskugeln beim Hersteller. Lasst mich daher bitte nicht den Spekulatiusbackmodus wechseln.

    Hey,

    warum das Rumgefummel mit StreamReader.Peek()? Man hat einen NamedPipeServerStream, aus dem jeweils ein StreamReader und StreamWriter erzeugt wird. Nutzt man StreamReader.ReadLine(), so blockiert dieser solange, bis auf der anderen Seite StreamWriter.WriteLine() aufgerufen wird. Wichtig ist hier, dass StreamWriter.Flush() genutzt wird. Oder man erzeugt das StreamWrtier-Objekt gleich mit AutoFlush = true.

    Hier mein Beispiel für dieses Problem, welches auch mehr als einen Client handeln kann.

    Spoiler anzeigen

    C#-Quellcode

    1. using System;
    2. using System.Collections.Generic;
    3. using System.IO;
    4. using System.Net;
    5. using System.Net.Sockets;
    6. using System.IO.Pipes;
    7. using System.Threading.Tasks;
    9. namespace NET5Console2
    10. {
    11. class Program
    12. {
    13. static void Main(string[] args)
    14. {
    15. Task.Run(Connect);
    16. Console.ReadLine();
    17. }
    19. static void Connect()
    20. {
    21. NamedPipeServerStream server = new NamedPipeServerStream("test", PipeDirection.InOut, 50);
    22. server.WaitForConnection();
    23. Task.Run(Connect);
    24. Task.Run(() => HandleConnection(server));
    25. }
    27. static void HandleConnection(NamedPipeServerStream server)
    28. {
    29. StreamReader sR = new StreamReader(server);
    30. StreamWriter sW = new StreamWriter(server) { AutoFlush = true };
    32. Console.WriteLine("New client.");
    34. while (true)
    35. {
    36. try
    37. {
    38. string message = sR.ReadLine();
    39. sW.WriteLine(message);
    40. }
    41. catch
    42. {
    43. Console.WriteLine("Client disconnected");
    44. server.Disconnect();
    45. server.Dispose();
    46. break;
    47. }
    48. }
    49. }
    50. }
    51. }



    Spoiler anzeigen

    C#-Quellcode

    1. using System;
    2. using System.Collections.Generic;
    3. using System.IO;
    4. using System.Net;
    5. using System.Net.Sockets;
    6. using System.IO.Pipes;
    8. namespace NET5Console3
    9. {
    10. class Program
    11. {
    12. static void Main(string[] args)
    13. {
    14. NamedPipeClientStream client = new NamedPipeClientStream("test");
    15. StreamReader sR;
    16. StreamWriter sW;
    18. try
    19. {
    20. client.Connect();
    21. sR = new StreamReader(client);
    22. sW = new StreamWriter(client) { AutoFlush = true };
    23. }
    24. catch
    25. {
    26. Console.WriteLine("Could not connect.");
    27. Console.ReadLine();
    28. return;
    29. }
    31. while (true)
    32. {
    33. try
    34. {
    35. string input = Console.ReadLine();
    37. if (input == "exit")
    38. {
    39. throw new Exception();
    40. }
    42. sW.WriteLine(input);
    43. Console.WriteLine(sR.ReadLine());
    44. }
    45. catch
    46. {
    47. Console.WriteLine("Communication error.");
    48. client.Close();
    49. client.Dispose();
    50. break;
    51. }
    52. }
    53. }
    54. }
    55. }



    Ein einfacher Echo-Server, der das Gesendete einfach an den Client zurück schickt. Jede Server-Instanz läuft bei mir in einem eigenen Thread, um mehrere Clients handeln zu können.
    Die Unendlichkeit ist weit. Vor allem gegen Ende. ?(
    Manche Menschen sind gar nicht dumm. Sie haben nur Pech beim Denken. 8o

    @SpaceyX
    Vielen Dank für dein Beispiel. Es funktioniert soweit sehr sehr gut.
    Also... lag es wirklich an StreamReader.Peek()? Wenn ich zuerst checke, ob der Peek größer als 0 ist, dann kann ich eine Nachricht an den Server schicken (und der Server sendet diese auch zurück), bei der nächsten Nachricht aber, wird die Nachricht nicht mehr vom Server zurück gesendet und ich kann im Client nichts mehr in die Konsole eingeben.
    Wenn ich dir auf irgendeiner Art und Weise helfen konnte, drück doch bitte den "Hilfreich" Button :thumbup:

    Für VB.NET Entwickler: Option Strict On nicht vergessen!

    Hier habich mich mal mit NamedPipes beschäftigt, im Zusammenhang der Server-Client-Architektur eines primitiven BroadCast Chats: VersuchsChat mit leistungsfähigem Server

    BroadCast bedeutet: eine Nachricht wird an alle verstreut. Antworten werden nicht erwartet.

    BroadCast ist aber nur eine Form der Kommunikation. Eine andere ist Peer to Peer, wo Nachrichten nur zw. 2 Partnern ausgetauscht werden.

    Noch eine Dimension ist Responsibilität, wo Nachrichten eine direkte Antwort erwarten.

    Daher ist deine Problembeschreibung uneindeutig, weil man muss jeweils spezifisch vorgehen.
    Deine Versuche mit StreamReader.Peek() deuten für mich aber darauf hin, dass du iwas mit Responsibilität versuchst.

    Da habe ich auch einen Ansatz für - aber auf einem anderen Blatt.

    Die Beispiele von @SpaceyX haben bei mir wunderbar funktioniert! Danke dafür :).
    Ich habe es zuerst mit 2 Konsolen Anwendungen getestet (Server/Client). Nun benutzte ich es zwischen einer DLL-Datei (welche eine Mod für ein Spiel ist) und einer Windows Forms Anwendung.

    @ErfinderDesRades
    Richtig, Responsibilität war mein vorhaben. Der Client soll zum Server zum Beispiel: get:username senden, der Server Antwortet mit username:NAME (Was Server und Client nun auch erfolgreich tun).
    Wenn ich dir auf irgendeiner Art und Weise helfen konnte, drück doch bitte den "Hilfreich" Button :thumbup:

    Für VB.NET Entwickler: Option Strict On nicht vergessen!