如何处理TCPClient中接收到的数据？ （德尔福 - 印地）

Question

当我从 TCPClient 向 TCPServer 发送消息时，它将使用服务器中的 OnExecute 事件进行处理。现在我想处理客户端中收到的消息，但 TCPClient 没有任何事件。所以我必须创建一个线程来手动处理它们。我该怎么办？

Answer 1

正如其他人在回答您的问题时所说的那样，TCP 不是面向消息的协议，而是一种流协议。我将向您展示如何写入和读取一个非常简单的回显服务器（这是我本周为回答其他问题而做的服务器的稍微修改版本）：

服务器 OnExecute 方法如下所示：

procedure TForm2.IdTCPServer1Execute(AContext: TIdContext);
var
  aByte: Byte;
begin
  AContext.Connection.IOHandler.Writeln('Write anything, but A to exit');
  repeat
    aByte := AContext.Connection.IOHandler.ReadByte;
    AContext.Connection.IOHandler.Write(aByte);
  until aByte = 65;
  AContext.Connection.IOHandler.Writeln('Good Bye');
  AContext.Connection.Disconnect;
end;

此服务器以欢迎词开头消息，然后只读取每个字节的连接字节。服务器回复相同的字节，直到接收到的字节为 65（断开连接命令）65 = 0x41 或 $41。然后服务器以一条再见消息结束。

您可以在客户端中执行此操作：

procedure TForm3.Button1Click(Sender: TObject);
var
  AByte: Byte;
begin
  IdTCPClient1.Connect;
  Memo1.Lines.Add(IdTCPClient1.IOHandler.ReadLn);  //we know there must be a welcome message!
  Memo1.Lines.Add('');// a new line to write in!
  AByte := 0;
  while (IdTCPClient1.Connected) and (AByte <> 65) do
  begin
    AByte := NextByte;
    IdTCPClient1.IOHandler.Write(AByte);
    AByte := IdTCPClient1.IOHandler.ReadByte;
    Memo1.Lines[Memo1.Lines.Count - 1] :=  Memo1.Lines[Memo1.Lines.Count - 1] + Chr(AByte);
  end;
  Memo1.Lines.Add(IdTCPClient1.IOHandler.ReadLn);  //we know there must be a goodbye message!
  IdTCPClient1.Disconnect;
end;

下一个字节过程可以是您想要提供字节的任何内容。例如，要获取用户的输入，您可以将表单的 KeyPreview 设置为 true，并编写一个 OnKeyPress 事件处理程序和 NextByte 函数，如下所示：

procedure TForm3.FormKeyPress(Sender: TObject; var Key: Char);
begin
  FCharBuffer := FCharBuffer + Key;
end;

function TForm3.NextByte: Byte;
begin
  Application.ProcessMessages;
  while FCharBuffer = '' do  //if there is no input pending, just waint until the user adds input
  begin
    Sleep(10);
    //this will allow the user to write the next char and the application to notice that
    Application.ProcessMessages;
  end;  
  Result := Byte(AnsiString(FCharBuffer[1])[1]);  //just a byte, no UnicodeChars support
  Delete(FCharBuffer, 1, 1);
end;

用户在表单中写入的任何内容都将发送到服务器，然后从服务器读取那里并添加到 memo1 中。如果输入焦点已位于 Memo1 中，您将看到每个字符两次，一个来自键盘，另一个来自服务器。

因此，为了编写一个从服务器获取信息的简单客户端，您必须知道对服务器的期望。是字符串吗？多个字符串？整数？大批？二进制文件？编码文件？是否有连接结束的标记？如果您要创建自定义服务器/客户端对，这些内容通常在协议中定义或由您定义。

在事先不知道要从服务器获取什么内容的情况下编写通用 TCP 是可能的，但由于协议中的此级别没有通用消息抽象这一事实而变得复杂。

不要对存在传输消息的事实感到困惑，但是单个服务器响应可以分为多个传输消息，然后在客户端重新组装，您的应用程序不会不控制这个。从应用程序的角度来看，套接字是传入字节的流（流）。您将其解释为消息、命令或来自服务器的任何类型的响应的方式取决于您。这同样适用于服务器端......例如 onExecute 事件是一张白纸，您也没有消息抽象。

也许您将消息抽象与命令抽象混合在一起......在基于命令的协议上，客户端发送包含命令的字符串，服务器回复包含响应的字符串（然后可能是更多数据）。看一下 TIdCmdTCPServer/Client 组件。

编辑

在评论中，OP声明她/他想在线程上完成这项工作，我不确定她/他遇到的问题是什么，但我添加了一个线程示例。服务器与之前所示的相同，只是这个简单服务器的客户端部分：

首先，我正在使用的线程类：

type
  TCommThread = class(TThread)
  private
    FText: string;
  protected
    procedure Execute; override;
    //this will hold the result of the communication
    property Text: string read FText;
  end;

procedure TCommThread.Execute;
const
  //this is the message to be sent. I removed the A because the server will close 
  //the connection on the first A sent.  I'm adding a final A to close the channel.
  Str: AnsiString = 'HELLO, THIS IS _ THRE_DED CLIENT!A';
var
  AByte: Byte;
  I: Integer;
  Client: TIdTCPClient;
  Txt: TStringList;
begin
  try
    Client := TIdTCPClient.Create(nil);
    try
      Client.Host := 'localhost';
      Client.Port := 1025;
      Client.Connect;
      Txt := TStringList.Create;
      try
        Txt.Add(Client.IOHandler.ReadLn);  //we know there must be a welcome message!
        Txt.Add('');// a new line to write in!
        AByte := 0;
        I := 0;
        while (Client.Connected) and (AByte <> 65) do
        begin
          Inc(I);
          AByte := Ord(Str[I]);
          Client.IOHandler.Write(AByte);
          AByte := Client.IOHandler.ReadByte;
          Txt[Txt.Count - 1] :=  Txt[Txt.Count - 1] + Chr(AByte);
        end;
        Txt.Add(Client.IOHandler.ReadLn);  //we know there must be a goodbye message!
        FText := Txt.Text;
      finally
        Txt.Free;
      end;
      Client.Disconnect;
    finally
      Client.Free;
    end;
  except
    on E:Exception do
      FText := 'Error! ' + E.ClassName + '||' + E.Message;
  end;
end;

然后，我将这两个方法添加到表单中：

//this will collect the result of the thread execution on the Memo1 component.
procedure TForm3.AThreadTerminate(Sender: TObject);
begin
  Memo1.Lines.Text := (Sender as TCommThread).Text;
end;

//this will spawn a new thread on a Create and forget basis. 
//The OnTerminate event will fire the result collect.
procedure TForm3.Button2Click(Sender: TObject);
var
  AThread: TCommThread;
begin
  AThread := TCommThread.Create(True);
  AThread.FreeOnTerminate := True;
  AThread.OnTerminate := AThreadTerminate;
  AThread.Start;
end;

Answer 2

TCP 不使用消息进行操作。那是基于流的接口。因此，不要期望您会在接收器上收到“消息”。相反，您从套接字读取传入的数据流并根据高级协议对其进行解析。

Answer 3

这是我用 Delphi 7 读取/写入的代码。使用 Tcp 事件读取。

unit Unit1;

interface

uses
  Windows, Messages, SysUtils, Variants, Classes, Graphics, Controls, Forms,
  Dialogs, StdCtrls, ScktComp;

type
  TForm1 = class(TForm)
    ClientSocket1: TClientSocket;
    Button1: TButton;
    ListBox1: TListBox;
    Edit1: TEdit;
    Edit2: TEdit;
    procedure Button1Click(Sender: TObject);
    procedure ClientSocket1Read(Sender: TObject; Socket: TCustomWinSocket);
    procedure ClientSocket1Error(Sender: TObject; Socket: TCustomWinSocket;
      ErrorEvent: TErrorEvent; var ErrorCode: Integer);
  private
    { Private declarations }
  public
    { Public declarations }
  end;

var
  Form1: TForm1;

implementation

{$R *.dfm}

procedure TForm1.Button1Click(Sender: TObject);
var
 UsePort: Integer;
 UseHost: String;

begin
UseHost := Edit1.Text;
UsePort := STRTOINT(Edit2.Text);
ClientSocket1.Port :=  UsePort;
ClientSocket1.Host :=  UseHost;
ClientSocket1.Active :=  true;
end;

procedure TForm1.ClientSocket1Read(Sender: TObject;
  Socket: TCustomWinSocket);
begin
ListBox1.Items.Add(ClientSocket1.Socket.ReceiveText);

end;

procedure TForm1.ClientSocket1Error(Sender: TObject;
  Socket: TCustomWinSocket; ErrorEvent: TErrorEvent;
  var ErrorCode: Integer);
begin
  ErrorCode:=0;
  ClientSocket1.Active := False;
end;

procedure TForm1.BitBtn1Click(Sender: TObject);
begin
  ClientSocket1.Socket.SendText(Edit1.Text);
end;

end.

Answer 4

如果您需要 Indy 客户端处理传入的“消息”（“消息”的定义取决于所使用的协议），我建议您查看协议\IdTelnet 单元中 TIdTelnet 的实现。

该组件使用基于 TIdThread 的接收线程，该线程从 Telnet 服务器异步接收消息，并将它们传递给消息处理程序例程。如果您有类似的协议，这可能是一个很好的起点。

更新：更具体地说，IdTelnet.pas 中的过程 TIdTelnetReadThread.Run; 是异步客户端“魔法”发生的地方，您可以看到它使用 Synchronize 在主线程中运行数据处理- 但是当然您的应用程序也可以在接收线程中进行数据处理，或者将其传递给工作线程以保持主线程不变。该过程不使用循环，因为循环/暂停/重新启动是在 IdThread 中实现的。

Answer 5

添加一个TTimer。
将其Interval 设置为1。
在OnTimer事件中写入：

procedure TForm1.Timer1Timer(Sender: TObject);
var
s: string;
begin
if not IdTCPClient1.Connected then Exit;
if IdTCPClient1.IOHandler.InputBufferIsEmpty then Exit;
s := IdTCPClient1.IOHandler.InputBufferAsString;
Memo1.Lines.Add('Received: ' + s);
end;

不要将Timer.Interval设置为其他1。
因为，接收到的数据会在几毫秒后删除。