发送通过Socket动态阵列（内记录）？(Sending a Dynamic array (Insi

2019-08-02 09:41发布

站内文章 / 前端开发
60 0 0

我试图从服务器传输记录到客户端，直接使用.SendBuf（）。

然而，这个纪录有一个成员是一个动态数组，和我（在这里SOF）在发送记录时，会员必须是静态的（固定长度）的地方阅读，但问题是......我不能确定如何很多争论，我要送（在未来）。

我怎么解决这个问题 ？ 

procedure TServerClass.SendBufToSocket(const vmName: TVMNames; const vmArgs: Array of TValue);
var
  // this record is sent to client
  // vmName = method to be called [in]
  // vmArgs = Argument for the method [in, optional]
  BufRec: packed record
    vmName: array[0..49] of char;
    vmArgs: Array of TValue;
  end;

  s: string;
  i: integer;
begin
  // convert enum method name to string
  s:= GetEnumName(TypeInfo(TVMNames), Integer(vmName));

  // copy method name to record
  lstrcpy(BufRec.vmName, pChar(s));

  // copy arg array to record
  SetLength(BufRec.vmArgs, length(vmArgs));

  for i:=0 to high(vmArgs)
    do BufRec.vmArgs[i] := vmArgs[i];

  // send record
  ServerSocket.Socket.Connections[idxSocket].SendBuf(PByte(@BufRec)^, SizeOf(BufRec));
end;

：我从我读过它，在这里发现了ReceiveBuf从TCustomWinSocket不会为缓冲区动态数组工作

Answer 1:

您将无法发送记录原样，所以实际上你甚至不需要使用记录都没有。 你必须序列数据成扁平格式，适合通过网络传输。 例如，在发送的字符串时，在发送数据串之前发送字符串长度。 同样，发送的阵列时，在发送数组项之前发送所述阵列的长度。 至于项目本身，因为TValue是动态的，你必须把它序列化到扁平格式为好。

尝试这样的事情在发送端： 

procedure TServerClass.SendBufToSocket(const vmName: TVMNames; const vmArgs: Array of TValue);
var
  I: integer;

  procedure SendRaw(Data: Pointer; DataLen: Integer);
  var
    DataPtr: PByte;
    Socket: TCustomWinSocket;
    Sent, Err: Integer;
  begin
    DataPtr := PByte(Data);
    Socket := ServerSocket.Socket.Connections[idxSocket];
    while DataLen > 0 do
    begin
      Sent := Socket.SendBuf(DataPtr^, DataLen);
      if Sent > 0 then
      begin
        Inc(DataPtr, Sent);
        Dec(DataLen, Sent)
      end else
      begin
        Err := WSAGetLastError();
        if Err <> WSAEWOULDBLOCK then
          raise Exception.CreateFmt('Unable to sent data. Error: %d', [Err]);
        Sleep(10);
      end;
    end;
  end;

  procedure SendInteger(Value: Integer);
  begin
    Value := htonl(Value);
    SendRaw(@Value, SizeOf(Value));
  end;

  procedure SendString(const Value: String);
  var
    S: UTF8string;
    Len: Integer;
  begin
    S := Value;
    Len := Length(S);
    SendInteger(Len);
    SendRaw(PAnsiChar(S), Len);
  end;

begin
  SendString(GetEnumName(TypeInfo(TVMNames), Integer(vmName)));
  SendInteger(Length(vmArgs));
  for I := Low(vmArgs) to High(vmArgs) do
    SendString(vmArgs[I].ToString);
end;

然后在接收端： 

type
  TValueArray := array of TValue;

procedure TServerClass.ReadBufFromSocket(var vmName: TVMNames; var vmArgs: TValueArray);
var
  Cnt, I: integer;
  Tmp: String;

  procedure ReadRaw(Data: Pointer; DataLen: Integer);
  var
    DataPtr: PByte;
    Socket: TCustomWinSocket;
    Read, Err: Integer;
  begin
    DataPtr := PByte(Data);
    Socket := ClientSocket.Socket;
    while DataLen > 0 do
    begin
      Read := Socket.ReceiveBuf(DataPtr^, DataLen);
      if Read > 0 then
      begin
        Inc(DataPtr, Read);
        Dec(DataLen, Read);
      end
      else if Read = 0 then
      begin
        raise Exception.Create('Disconnected');
      end else
      begin
        Err := WSAGetLastError();
        if Err <> WSAEWOULDBLOCK then
          raise Exception.CreateFmt('Unable to read data. Error: %d', [Err]);
        Sleep(10);
      end;
    end;
  end;

  function ReadInteger: Integer;
  begin
    ReadRaw(@Result, SizeOf(Result));
    Result := ntohl(Result);
  end;

  function ReadString: String;
  var
    S: UTF8String;
    Len: Integer;
  begin
    Len := ReadInteger;
    SetLength(S, Len);
    ReadRaw(PAnsiChar(S), Len);
    Result := S;
  end;

begin
  vmName := TVMNames(GetEnumValue(TypeInfo(TVMNames), ReadString));
  Cnt := ReadInteger;
  SetLength(vmArgs, Cnt);
  for I := 0 to Cnt-1 do
  begin
    Tmp := ReadString;
    // convert to TValue as needed...
    vmArgs[I] := ...;
  end;
end;

随着中说，注意socket编程的复杂得多，这个简单的例子说明。 你必须做正确的错误处理。 你必须考虑到部分数据发送和接收。 如果你正在使用非阻塞插座，如果插座进入阻塞状态，那么你必须等待它再次进入可读/写状态前，你可以尝试读取仍悬而未决/写数据。 你没有做任何的那个呢。 你需要让自己有效的套接字编程的一本好书。

更新 ：如果你想利用OnRead和OnWrite插座组件的事件，你必须采取不同的方法： 

procedure TServerClass.ClientConnect(Sender: TObject; Socket: TCustomWinSocket);
begin
  Socket.Data := TMemoryStream.Create;
end;

procedure TServerClass.ClientDisconnect(Sender: TObject; Socket: TCustomWinSocket);
begin
  TMemoryStream(Socket.Data).Free;
  Socket.Data := nil;
end;

procedure TServerClass.ClientWrite(Sender: TObject; Socket: TCustomWinSocket);
var
  OutBuffer: TMemoryStream;
  Ptr: PByte;
  Sent, Len: Integer;
begin
  OutBufer := TMemoryStream(Socket.Data);
  if OutBuffer.Size = 0 then Exit;

  OutBuffer.Position := 0;
  Ptr := PByte(OutBuffer.Memory);

  Len := OutBuffer.Size - OutBuffer.Position;
  while Len > 0 do
  begin
    Sent := Socket.SendBuf(Ptr^, Len);
    if Sent <= 0 then Break;
    Inc(Ptr, Sent);
    Dec(Len, Sent)
  end;

  if OutBuffer.Position > 0 then
  begin
    if OutBuffer.Position >= OutBuffer.Size then
      OutBuffer.Clear
    else
    begin
      Move(Ptr^, OutBuffer.Memory^, Len);
      OutBuffer.Size := Len;
    end;
  end;
end;

procedure TServerClass.SendBufToSocket(const vmName: TVMNames; const vmArgs: Array of TValue);
var
  I: integer;
  Socket: TCustomWinSocket;
  OutBuffer: TMemoryStream;

  procedure SendRaw(Data: Pointer; DataLen: Integer);
  var
    DataPtr: PByte;
    Sent: Integer;
  begin
    if DataLen < 1 then Exit;
    DataPtr := PByte(Data);
    if OutBuffer.Size = 0 then
    begin
      repeat
        Sent := Socket.SendBuf(DataPtr^, DataLen);
        if Sent < 1 then Break;
        Inc(DataPtr, Sent);
        Dec(DataLen, Sent)
      until DataLen < 1;
    end;
    if DataLen > 0 then
    begin
      OutBuffer.Seek(0, soEnd);
      OutBuffer.WriteBuffer(DataPtr^, DataLen);
    end;
  end;

  procedure SendInteger(Value: Integer);
  begin
    Value := htonl(Value);
    SendRaw(@Value, SizeOf(Value));
  end;

  procedure SendString(const Value: String);
  var
    S: UTF8string;
    Len: Integer;
  begin
    S := Value;
    Len := Length(S);
    SendInteger(Len);
    SendRaw(PAnsiChar(S), Len);
  end;

begin
  Socket := ServerSocket.Socket.Connections[idxSocket];
  OutBuffer := TMemoryStream(Socket.Data);

  SendString(GetEnumName(TypeInfo(TVMNames), Integer(vmName)));
  SendInteger(Length(vmArgs));
  for I := Low(vmArgs) to High(vmArgs) do
    SendString(vmArgs[I].ToString);
end;

然后在接收端： 

procedure TServerClass.ClientConnect(Sender: TObject; Socket: TCustomWinSocket);
begin
  Socket.Data := TMemoryStream.Create;
end;

procedure TServerClass.ClientDisconnect(Sender: TObject; Socket: TCustomWinSocket);
begin
  TMemoryStream(Socket.Data).Free;
  Socket.Data := nil;
end;

procedure TServerClass.ClientRead(Sender: TObject; Socket: TCustomWinSocket);
var
  InBuffer: TMemoryStream;      
  Ptr: PByte;
  OldSize, Pos, Read: Integer;

  function HasAvailable(DataLen: Integer): Boolean;
  being
    Result := (InBuffer.Size - InBuffer.Position) >= DataLen;
  end;

  function ReadInteger(var Value: Integer);
  begin
    Result := False;
    if HasAvailable(SizeOf(Integer)) then
    begin
      InBuffer.ReadBuffer(Value, SizeOf(Integer));
      Value := ntohl(Value);
      Result := True;
    end;
  end;

  function ReadString(var Value: String);
  var
    S: UTF8String;
    Len: Integer;
  begin
    Result := False;
    if not ReadInteger(Len) then Exit;
    if not HasAvailable(Len) then Exit;
    SetLength(S, Len);
    InBuffer.ReadBuffer(PAnsiChar(S)^, Len);
    Value := S;
    Result := True;
  end;

  function ReadNames: Boolean;
  var
    S: String;
    vmName: TVMNames;
    vmArgs: TValueArray;
  begin
    Result := False;
    if not ReadString(S) then Exit;
    vmName := TVMNames(GetEnumValue(TypeInfo(TVMNames), S));
    if not ReadInteger(Cnt) then Exit;
    SetLength(vmArgs, Cnt);
    for I := 0 to Cnt-1 do
    begin
      if not ReadString(S) then Exit;
      // convert to TValue as needed...
      vmArgs[I] := ...;
    end;
    // use vmArgs as needed...
    Result := True;
  end;

begin
  InBuffer := TMemoryStream(Socket.Data);

  Read := Socket.ReceiveLength;
  if Read <= 0 then Exit;

  OldSize := InBuffer.Size;
  InBuffer.Size := OldSize + Read;

  try
    Ptr := PByte(InBuffer.Memory);
    Inc(Ptr, OldSize);
    Read := Socket.ReceiveBuf(Ptr^, Read);
  except
    Read := -1;
  end;

  if Read < 0 then Read := 0;
  InBuffer.Size := OldSize + Read;
  if Read = 0 then Exit;

  InBuffer.Position := 0;

  repeat
    Pos := InBuffer.Position;
  until not ReadNames;

  InBuffer.Position := Pos;
  Read := InBuffer.Size - InBuffer.Position;
  if Read < 1 then
    InBuffer.Clear
  else
  begin
    Ptr := PByte(InBuffer.Memory);
    Inc(Ptr, InBuffer.Position);
    Move(Ptr^, InBuffer.Memory^, Read);
    InBuffer.Size := Read;
  end;
end;


Answer 2:

正如一些评论所提到的，系列化你记录一个流，然后通过网络发送的数据流内容。 我用kbLib在我的一些项目和它的作品真的很好。 你可以在你的记录使用任何动态类型如字符串，数组。

小例子： 

type 
  TMyRecord = record
    str : string;
  end;

procedure Test;

var
 FStream : TMemoryStream;
 MYrecord : TMyRecord;
 MYrecord1 : TMyRecord;

begin
 FStream := TMemoryStream.Create;
 try
  MyRecord.Str := 'hello world';
  // save record to stream 
  TKBDynamic.WriteTo(FStream, MyRecord, TypeInfo(TMyRecord)); 
  FStream.Position := 0;
  // read record from stream
  TKBDynamic.ReadFrom(FStream, MyRecord1, TypeInfo(TMyRecord));  
  If MyRecord1.Str <> MyRecord.Str then
   ShowMessage('this should not happen!');
  finally
   FStream.Free; 
  end;
end;


文章来源: Sending a Dynamic array (Inside a record) through Socket?
标签： delphi sockets winsock
举报

收藏的人(0)

Ta的文章 更多文章
登录 后发表评论
0条评论
还没有人评论过~