1:
2:
3:
4:
5:
6:
7:
8:
9:
10:

var
  a: string[10];

begin
  a := 'A1234';
  writeln('Laenge: ', pByte(@a)^, ' - erstes Zeichen: ', pAnsiChar(integer(@a) + 1)^);
  writeln(SizeOf(A));
  a := 'B234512345';
  writeln('Laenge: ', pByte(@a)^, ' - erstes Zeichen: ', pAnsiChar(integer(@a) + 1)^);
  writeln(SizeOf(A));                    

1:
2:
3:
4:
5:
6:

TMyRec = packed record
  SomeNr: Integer;
  SomeOtherNr: Single;
  FirstDynamicField: Array of Byte;
  SecondDynamicField: String;
end;                    

1:
2:
3:
4:
5:
6:

<SomeNr|4 Bytes>
<SomeOtherNr|4 Bytes>
<Length(FirstDynamicField)|2 Bytes>
<FirstDynamicField|x Bytes>
<Length(SecondDynamicField)|2 Bytes>
<SecondDynamicField|y Bytes>                    

1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:
15:
16:
17:
18:
19:
20:

type TMyRec1 = record
  a : Word;
  b : integer;
end;

type TMyRec2 = packed record
  a : Word;
  b : integer;
end;

[ ... ]

procedure TForm1.Button2Click(Sender: TObject);
var
  X : TMyRec1;
  Y : TMyRec2;
begin
  ShowMessage(IntToStr(SizeOf(X)));
  ShowMessage(IntToStr(SizeOf(Y)));
end;                    

1:
2:
3:
4:
5:
6:

type TMyRec = record
  a : word;
  b : word;
  c : word;
  d : int64;
end;                    

1:
2:
3:
4:
5:
6:

type TMyRec = record
  a : word;
  b : word;
  d : int64;
  c : word;
end;                    

1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:
15:
16:
17:
18:
19:
20:
21:
22:
23:
24:
25:
26:
27:
28:
29:
30:
31:
32:
33:
34:
35:
36:
37:
38:
39:
40:
41:
42:
43:
44:
45:
46:
47:
48:
49:

  TBitSet<T, K: record> = record
  private
    function GetBit(const AIndex: Integer): Boolean;
    procedure SetBit(const AIndex: Integer; const AValue: Boolean);
  public
    class operator implicit(const AValue: T): TBitSet<T, K>;
    class operator implicit(const AValue: TBitSet<T, K>): T;
    property Bit[const AIndex: Integer]: Boolean read GetBit write SetBit; default;
    case Boolean of
      True:   (Value: T);
      False:  (Lo: K; Hi: K);
  end;

  TWordBitSet = TBitSet<Word, Byte>;
  TLongIntBitSet = TBitSet<LongInt, TWordBitSet>;

// ...
function TBitSet<T, K>.GetBit(const AIndex: Integer): Boolean;
begin
  Result := PInteger(@Value)^ or (1 shl AIndex) > 0;
end;

class operator TBitSet<T, K>.implicit(const AValue: T): TBitSet<T, K>;
begin
  Result.Value := AValue;
end;

class operator TBitSet<T, K>.implicit(const AValue: TBitSet<T, K>): T;
begin
  Result := AValue.Value;
end;

procedure TBitSet<T, K>.SetBit(const AIndex: Integer; const AValue: Boolean);
var
  ByteIndex: Integer;
  BytePointer: PByte;
begin
  ByteIndex := AIndex div 8;
  if SizeOf(T) > ByteIndex then
  begin
    BytePointer := @PByteArray(@Value)^[ByteIndex];
    if AValue then
      BytePointer^ := BytePointer^ or (1 shl (AIndex mod 8))
    else
      BytePointer^ := BytePointer^ and not (1 shl (AIndex mod 8));
  end
  else
    raise Exception.Create('Invalid bit index!');
end;                    

1:
2:
3:
4:
5:
6:
7:

var
  a: TLongIntBitSet;
begin
  a := $12345678;
  ShowMessage('$' + IntToHex(a.Lo.Hi, 8)); // $00000056
  a.Bit[12] := False;
  ShowMessage('$' + IntToHex(a.Lo.Hi, 8)); // $00000046                    

1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:

var pStream: TMemoryStream;
begin
pStream := TMemoryStream.create;

if GetASyncKeyState( Ord('W') )>0 then pStream.Write( WillSpringen, 1); //der einzeiler !

try
  Client.Socket.SendStream( pStream );
except
  if Assigned( pStream ) then pStream.Free;
  end;
end;                    

1:
2:
3:
4:
5:
6:
7:
8:
9:

while not Terminated do
begin
for C:=1 to AnzahlSpieler do //nicht AcitveConnections-1 sonst bemerkt man disconnections nicht
 begin
 //hat spieler was gesendet
 //wenn ja empfangen (evt Extra thread erstellen der das empfängt?)
 //also pro Client 1 thread der empfängt?? 
 end;
end;