我发现您的 Delphi 代码存在许多问题：

• 您在多个调用中重用了一个TCP连接，而C#代码在每个调用中，甚至在外部循环的每个迭代中，都创建了一个新的TCP连接。
• 您的代码假设wLength始终〈65535。您不允许更大的消息。如果wLength碰巧〉= 65535，则您根本没有将wLength复制到wSendBytes中，也没有将wMsg复制到wSendBytes的正确偏移量中。因此wSendBytes将被损坏。
• 您没有发送放入wSendBytes中的所有字节。您跳过了前2个字节。此语句：

TCPClient.IOHandler.Write(wSendBytes,Length(wSendBytes),2);
需要改为：
TCPClient.IOHandler.Write(wSendBytes);

• 不需要调用IOHandler.WriteBuffer(Open|Close|Cancel)，因为您在它们之间只进行了1次IOHandler.Write()调用，因此不需要缓冲数据。
• 您没有处理IOHandler.ReadLnWait()超时的可能性，这与C#代码处理s.Receive()超时的方式相同。此外，C#代码中甚至没有指示IOHandler.ReadLnWait()是用于 Delphi 代码的正确方法。C#代码阅读的是任意字节，而不是基于行的文本数据。
• 就此而言，假设响应数据是XML，您应该从套接字阅读，直到收到XML文档的最后一个结束标记，然后处理响应（基于推的XML解析器最适合于此。您可以将任意字节推到其中，并且它将为完全解析的XML元素给予事件）。 Delphi 代码假设整个XML文档将出现在套接字的单个读取中，但这不是TCP的工作方式。
• 在接收到wResponseStringData之后，但在处理它之前，您将其覆盖。首先，您使用IOHandler.ReadLnWait()接收它，但随后您再次从IndyTextEncoding_ASCII.GetString(wResponseBytes)接收它，尽管您已经注解掉了将字节读入wResponseBytes的代码。因此，每次处理它时，wResponseStringData最终都是空的。
• 您根本不会像C#代码那样响应任何接收到的事件（另外，仅供参考，C#代码发送cashbackMessage两次，每次都在不同的TCP连接上，这看起来很奇怪。但更重要的是，它没有调整sendbytes的报头以指定cashbackMessage的正确长度）。

也就是说，我会将C#代码翻译成 Delphi +Indy，更像下面这样：

uses
  ..., IdGlobal, IdStack, IdExceptionCore, IdTCPClient, SysUtils;
  
function SendXML(const xmlMessage: String; cashbackAmount: Integer; jumpOut: Boolean = False): String;
var
  responseStringData: String;
  responsebytes: TIdBytes;
  bytesRec: Integer;
  client: TIdTCPClient;
  isEvent: Boolean;
  didContainEvent: Boolean;
  wasCashbackEvent: Boolean;
  cashbackMessage: String;

  function EncodeMessage(const AMsg: String): TIdBytes;
  var
    length: Integer;
    headerOffset: Integer;
  begin
    length := IndyTextEncoding_ASCII.GetByteCount(AMsg);
    if length < 65535 then
    begin
      SetLength(Result, length + 2);
      CopyTIdUInt16(GStack.HostToNetwork(UInt16(length)), Result, 0);
      headerOffset := 2;
    end
    else
    begin
      SetLength(Result, length + 6);
      Result[0] := $FF;
      Result[1] := $FF;
      CopyTIdUInt32(GStack.HostToNetwork(UInt32(length)), Result, 2);
      headerOffset := 6;
    end;
    CopyTIdString(AMsg, Result, headerOffset, length, IndyTextEncoding_ASCII);
  end;

begin
  SetLength(responsebytes, 1024 * 10);

  // Create a TCP/IP socket.
  client := TIdTCPClient.Create;
  try
    client.Host := 'localhost';
    client.Port := 23001;
    client.ReadTimeout := 30000;

    repeat
      try
        responseStringData := '';
        //responseString := '';

        // Connect the socket to the remote endpoint. Catch any errors.
        try
          // Connect to a Remote server
          // WriteLn('Attempting socket connection, Host: ', client.Host, ', Port: ', client.Port);

          // Connect to Remote EndPoint
          client.Connect;
          try
            // Encode the data string into a byte array.
            // Send the data through the socket.
            client.IOHandler.Write(EncodeMessage(xmlMessage));

            // Receive the response from the remote device.
            isEvent := True;
            didContainEvent := False;
            wasCashbackEvent := False;

            // since we are still connected, we can receive quite a few event responses and/or callbacks
            // we cannot close this IP connection until all data has come back to us, else this will cause issues
            // as for callbacks, they require a response, in this case we have to keep the IP connection open until
            // we have replied with a callback message
            repeat
              client.IOHandler.CheckForDataOnSource(s.ReadTimeout);
              client.IOHandler.CheckForDisconnect;
              if client.IOHandler.InputBufferIsEmpty then EIdReadTimeout.Create('');

              bytesRec := IndyMin(client.IOHandler.InputBuffer.Size, Length(responsebytes));
              if bytesRec > 0 then begin
                client.IOHandler.ReadBytes(responsebytes, bytesRec, False);
              end;

              responseStringData := IndyTextEncoding_ASCII.GetString(responsebytes, 0, bytesRec);
              responseStringData := Copy(responseStringData, 2, Length(responseStringData));
              responseStringData := StringReplace(responseStringData, #0'?', '', [rfReplaceAll]);

              WriteLn('Data Received = ', responseStringData);
              WriteLn;
              WriteLn;

              isEvent := (Pos('Esp:Event', responseStringData) <> 0) or (Pos('Esp:Callback', responseStringData) <> 0);
              if isEvent and (not jumpOut) then
              begin
                didContainEvent := True;
                if Pos('Esp:Callback', responseStringData) = 0 then
                  Continue;
                wasCashbackEvent := True;

                // Adding Cashback Callback Response Message
                cashbackMessage := '<?xml version="1.0" encoding="UTF-8"?><Esp:Interface Version="1.0" xmlns:Esp="http://www.mosaicsoftware.com/Postilion/eSocket.POS/"><Esp:Callback TerminalId="TR000002" EventId="DATA_REQUIRED" ResponseData="' + IntToStr(cashbackAmount) + '" /></Esp:Interface>';
                // Sending the cashback message with cashback amount to the callback
                ShowMessage(responseStringData);

                //SendXML(cashbackMessage, 0, True);

                // Encode the cashback data string into a byte array.
                // Send the data through the socket.
                client.IOHandler.Write(EncodeMessage(cashbackMessage));
              end;
              // Return the response 
              Result := responseStringData;
              Exit;
            until not isEvent;
          finally
            client.Disconnect;
            if client.IOHandler <> nil then begin
              client.IOHandler.InputBuffer.Clear;
            end;
          end;
        except
          // txtDisplayMessage.Text := 'Failed to connect to socket...';
          Result := responseStringData;
          Exit;
        end;
        // Continue;
        Result := responseStringData;
        Exit;
      except
        // txtDisplayMessage.Text := 'Failed to connect to socket...';
        Continue;
        // Result := responseStringData;
      end;
    until False;
  finally
    client.Free;
  end;
  // Result := '';
end;

我设法复制了它。如果有人需要它，下面是答案。

{------------------------------------------------------------------------------}
function TfrmEFT000.SendXML(xXMLMessage :String; xCashbackAmount :Integer = 0; xJumpOut :Boolean = False): string;
var
 wRespData, wCBReq                                                 :String;
 wHeaderOffset, wLength, wRemainder, wByteInt                      :Word;
 wBytesRec, wBytesSent                                             :Integer;
 wSendBytes, wResponseBytes, wMsg, wIntBytes, wResult, wCashMsg    :TIdBytes;
 wIsEvent, wDidContainEvent, wWasCashbackEvent                     :Boolean;
begin

 try
  wHeaderOffset := 2;
  wLength       := Length(xXMLMessage);

  SetLength(wSendBytes, wLength+2);
  SetLength(wResponseBytes, 1024 * 10);
  wRemainder := 0;
  wBytesRec  := 0;

  DivMod(wLength, 256, wByteInt, wRemainder);

  if (wLength < 65535) then
   begin
    wSendBytes[0] := Byte(wByteInt);
    wSendBytes[1] := Byte(wRemainder);
   end
  else
   begin
    wHeaderOffset := 6;
    wSendBytes[0] := $FF;
    wSendBytes[1] := $FF;

    wIntBytes := GetBytes(wLength);
    ReverseArray(wIntBytes);
    wResult := wIntBytes;

    CopyTIdBytes(wResult, 0, wSendBytes, 2, 4);
   end;

  try

   // Encode the data string into a byte array.
   wMsg := IndyTextEncoding_ASCII.GetBytes(xXMLMessage);
   CopyTIdBytes(wMsg, 0, wSendBytes, wHeaderOffset, Length(wMsg));

   // Send the data through the socket.
   SendToSocket(wSendBytes);

   wBytesSent := Length(wSendBytes);

   // Receive the response from the remote device.
   wIsEvent          := True;
   wDidContainEvent  := False;
   wWasCashbackEvent := False;
   wBytesRec         := 0;
   // since we are still connected, we can receive quite a few event responses and/or callbacks
   // we cannot close this IP connection until all data has come back to us, else this will cause issues
   // as for callbacks, they require a response, in this case we have to keep the IP connection open until
   // we have replied with a callback message
   while wIsEvent = True do begin

    TCPClient.Socket.CheckForDataOnSource(1000);

    wBytesRec := TCPClient.Socket.InputBuffer.Size;

    if (not TCPClient.Socket.InputBufferIsEmpty) then begin
     wRespData := TCPClient.Socket.InputBufferAsString(IndyTextEncoding_ASCII);
    end;

    if wRespData = '' then begin
     Next;
     Continue;
    end;

    //wRespData := IndyTextEncoding_ASCII.GetString(wResponseBytes,0,wBytesRec);
    wRespData := wRespData.Substring(2, wRespData.Length - 2);
    wRespData := wRespData.Replace('\0?', '');
    LogMessage(lmtInformation, ldIn, 'Data Received = {0}', memRequest);
    LogMessage(lmtInformation, ldIn, (wRespData), memRequest);

    wIsEvent := wRespData.Contains('Esp:Event') or wRespData.Contains('Esp:Callback');

    if (wIsEvent = True) then begin

     if (xJumpOut = False) then begin
      Result := wRespData;
      Exit;
     end;

     wDidContainEvent := True;

     if not (wRespData.Contains('Esp:Callback')) then begin
      Continue;
     end;

     wWasCashbackEvent := true;
     // Adding Cashback Callback Response Message
     wCBReq := '<?xml version="1.0" encoding="UTF-8"?>';
     wCBReq := wCBReq + '<Esp:Interface Version="1.0" xmlns:Esp="http://www.mosaicsoftware.com/Postilion/eSocket.POS/">';
     wCBReq := wCBReq + '<Esp:Callback TerminalId="TR000002" EventId="DATA_REQUIRED" ResponseData="{cashbackAmount}" />';
     wCBReq := wCBReq + '</Esp:Interface>';
     // Sending the cashback message with cashback amount to the callback
     ShowMessage(wRespData);
     SendXML(wCBReq, 0, True);
     // Encode the cashback data string into a byte array.
     wCashMsg := IndyTextEncoding_ASCII.GetBytes(wCBReq);
     CopyTIdBytes(wCashMsg, 0, wSendBytes, wHeaderOffset, Length(wCashMsg));
     // Send the data through the socket.
     SendToSocket(wSendBytes);
    end;
    // Return the response
    Result := wRespData;
   end;

  except
   on E:Exception do begin
    TCPClient.Socket.WriteBufferCancel;
    LogMessage(lmtError, ldIn, E.Message, memRequest);
    Exit;
   end;
  end;

 except
  on E: Exception do begin
   TCPClient.Socket.WriteBufferCancel;
   LogMessage(lmtError, ldIn, E.Message, memRequest);
   Exit;
  end;
 end;

end;