Client, Server, Testapplikation

Question

Server_Client_Tool

Hallo,
ich suche so eine Applikation, das ich weiter entwickeln kann, sprich einfach Testantworten.

Idee:
   Man implementiert einfach Testbuttons und kann somit Anforderungen besser testen.

Testantworten senden oder eben Anfragen vom Server.

A) Kennt jemand so etwas in C#?

B) Anfrage:   COMMAND|id=1111|id=2222|id2=3333|id2=4444|process

    Antwort:    string inp = @"ANSWER|id=1111|id=2222|id2=3333|id2=4444|process=OK|station=MR0222|";

Wie kann ich sicherstellen, dass alles gesendet und alles empfangen wurde? Vielleicht hat jemand eine Beispielapplikation. Danke vorab.

  Viele Grüße Oliver

  

Answer 1

Hallo Oliver (oder doch eher Sandra),

leider fehlen doch wieder sämtliche wichtigen Informationen.

Welche Art von Anwendung soll auf der Serverseite erstellt werden? Webservice? TCP Client/Server? ...?

In welcher Form willst Du Daten senden? Per HttpRequest? Als Stream? ...?

Soll die Kommunikation immer synchron als Request/Response laufen?

Was verstehst Du unter "sicherstellen, dass alles gesendet und alles empfangen wurde"? Mit geeigneten Protokollen wie bspw. http musst Du dich nicht selbst darum kümmern. Entweder ist der Request vollständig gesendet, dann kommt auch eine ordentliche Antwort. Wenn nicht, dann nicht.

Warum willst Du ein solches Format für die Daten verwenden und nicht etwas, was sich millionenfach bewährt hat wie bspw. JSON, XML, ...?

Aber vor allen Dingen: Was ist so schwer daran, Peter Fleischers sehr guten Beispielcode in deinem vorherigen Thread Konzept - Protokoll als "Beispielapplikation" zu sehen und an der weiterzuarbeiten?

Du kannst dir nicht immer alles bis ins Detail vorkauen lassen. Aber das haben dir mehrere Leute ja schon x fach geschrieben.

 

---

Gruß, Stefan
Microsoft MVP - Visual Developer ASP/ASP.NET
http://www.asp-solutions.de/ - Consulting, Development
http://www.aspnetzone.de/ - ASP.NET Zone, die ASP.NET Community

Answer 2

Hallo,

 

>Welche Art von Anwendung soll auf der Serverseite erstellt werden? Webservice? TCP Client/Server? ...?

TCP Client/Server

>In welcher Form willst Du Daten senden? Per HttpRequest? Als Stream? ...?

Stream

>Soll die Kommunikation immer synchron als Request/Response laufen?

Ja, oder Timeout.

>Was verstehst Du unter "sicherstellen, dass alles gesendet und alles empfangen wurde"?

Die Länge der Message. Es kann ja sein, ist länger und es wird in Teilen gesendet.

 

Vorgabe, ich kann mir es nicht aussuchen.

 

Will nur wissen, wie ich es sicherstellen kann. Alles andere mache ich selber.

 

Viele Grüße Oliver

 

Answer 3

Hi Oliver,
ich hatte bereits hier Beispiel gepostet. Für Dich nochmals, da Deine Suche vermutlich nicht funktioniert:

using System;
using System.Net;
using System.Net.Sockets;
using System.Text;
using System.Threading;
using System.Threading.Tasks;
using System.Xml.Linq;

namespace ConsoleApp1
{
  class Program11
  {
    static void Main(string[] args)
    {
      try
      {
        Server s = new Server();
        s.Execute();
        Client c1 = new Client() { Name = "Client 1" };
        c1.Execute();
        Client c2 = new Client() { Name = "Client 2" };
        c2.Execute();
        Console.WriteLine("Weiter, beenden mit beliebiger Taste");
        Console.ReadKey();
        c2.Stop();
        c1.Stop();
        s.Stop();
      }
      catch (Exception ex) { Console.WriteLine(ex.ToString()); }
      Console.Write("Fertig, Abschluss mit beliebiger Taste");
      Console.ReadKey();
    }

    /// <summary>
    /// Klasse, die serverseitige Funktionen realisiert
    /// </summary>
    internal class Server
    {
      private int _listeningPort = 5000;
      CancellationTokenSource source = new CancellationTokenSource();
      CancellationToken token;
      SocketsSendReceive sck = new SocketsSendReceive();
      public Server() { token = source.Token; }
      internal Task Execute() { return (new TaskFactory(token)).StartNew(Start); }
      internal void Stop() { source.Cancel(); }
      // Ich finde diesen Server einfach überschaubar. 
      // Was haltert ihr von dem? Wenn's nicht geht, natürlich blöd.
      public async void Start()
      {
        IPAddress ipAddre = IPAddress.Loopback;
        TcpListener listener = new TcpListener(ipAddre, _listeningPort);
        listener.Start();
        LogMessage("Server is running");
        LogMessage("Listening on port " + _listeningPort);
        while (true)
        {
          LogMessage("Waiting for connections...");
          try
          {
            var tcpClient = await listener.AcceptTcpClientAsync();
            HandleConnectionAsync(tcpClient);
          }
          catch (Exception exp) { LogMessage(exp.ToString()); }
        }
      }


      /// <summary>
      /// mit aufgebauter Verbindung auf Sockets warten
      /// </summary>
      /// <param name="tcpClient">client connections for TCP network services</param>
      private async void HandleConnectionAsync(TcpClient tcpClient)
      {
        tcpClient.LingerState.Enabled = false;
        string clientInfo = tcpClient.Client.RemoteEndPoint.ToString();
        LogMessage(string.Format("Got connection request from {0}", clientInfo));
        try
        {
          XElement rec = new XElement("leer");
          while (rec != null)
          {
            rec = await sck.ReceiveSocket(tcpClient.Client);
            LogMessage($"Receive from Client:{Environment.NewLine}{rec.ToString()}");
            sck.SendSocket(tcpClient.Client, @"<response>" + rec.ToString() + "</response>");
          }
        }
        catch (Exception exp) { LogMessage(exp.Message); }
        finally
        {
          LogMessage(string.Format("Closing the client connection - {0}", clientInfo));
          tcpClient.Close();
        }
      }
      internal void LogMessage(string msg) => Console.WriteLine("Server: " + msg);
    }

    /// <summary>
    /// Klasse, die clientseitige Funktionen realisiert
    /// </summary>
    internal class Client
    {
      internal string Name { get; set; }
      private byte[] _host = new byte[] { 127, 0, 0, 1 };
      private int _port = 5000;
      CancellationTokenSource source = new CancellationTokenSource();
      CancellationToken token;
      SocketsSendReceive sck = new SocketsSendReceive();
      public Client() { token = source.Token; }
      internal Task Execute() { return (new TaskFactory(token)).StartNew(Start); }
      internal void Stop() { source.Cancel(); }
      public async void Start()
      {
        IPAddress[] IPs = new IPAddress[] { new IPAddress(_host) };
        Socket s2 = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);
        LogMessage($"Establishing Connection to {_host[0]}.{_host[1]}.{_host[2]}.{_host[3]}");
        s2.Connect(IPs[0], _port);
        LogMessage($"Connection established");
        for (int i = 1; i < 10; i++)
        {
          sck.SendSocket(s2, $"<command><notification>{Name} = {i}</notification></command>");
          XElement rec = await sck.ReceiveSocket(s2);
          LogMessage($"Receive from Server:{Environment.NewLine}{rec.ToString()}");
        }
        Thread.Sleep(200);
        LogMessage($"{Name}: alle Daten versendet.");
      }
      internal void LogMessage(string msg) => Console.WriteLine($"{Name}: " + msg);
    }

    internal class SocketsSendReceive
    {
      byte[] buffer = new byte[100];
      String receiveBuffer = string.Empty;
      int sizeReceive = -1;
      internal async Task<XElement> ReceiveSocket(Socket sck)
      {
        return await Task<XElement>.Run(() =>
        {
          while (sizeReceive != 0)
          {
            sizeReceive = sck.Receive(buffer, 0, buffer.Length, SocketFlags.None);
            receiveBuffer += Encoding.ASCII.GetString(buffer, 0, sizeReceive).Replace('\r', ' ').Replace('\n', ' ');
            int lengthFirstTag = receiveBuffer.IndexOf(">");
            if (lengthFirstTag <= 0) continue;
            string lastTag = "</" + receiveBuffer.Substring(1, lengthFirstTag);
            if (receiveBuffer.IndexOf(lastTag) >= 0)
            {
              string res = receiveBuffer.Substring(0, receiveBuffer.IndexOf(lastTag) + lastTag.Length);
              receiveBuffer = receiveBuffer.Substring(res.Length);
              return XElement.Parse(res);
            }
          }
          return null;
        });
      }

      internal async void SendSocket(Socket sck, string msg)
      {
        await Task.Run(() =>
        {
          byte[] buf1 = Encoding.Default.GetBytes(msg);
          sck.Send(buf1);
        });
      }
    }
  }
}

---

--
Viele Grüsse
Peter Fleischer (ehem. MVP)
Meine Homepage mit Tipps und Tricks