.NET Pointer auf Records

[Gruber_Hans_12345]

Hi

Da ich mich vor kurzem mal über die Indy Komponenten geärgert habe, das man bei denen keinen Pointer angeben kann, um Daten zu senden, wollte ich einfach mal fragen, wie würde man sowas eigentlich dann in einer .NET Sprache handeln?

ich definiere mir immer meine Strukturen, die übers Netz gesendet werden sollen folgend

Delphi-Quellcode:

type
    TTerminalTransferData = packed record
        Cmd             : Word;
        Size            : integer;
        Crc             : integer;
    end;
    PTerminalTransferData = ^TTerminalTransferData;

    TTerminalInfo = packed record
        Header          : TTerminalTransferData;
        Serial          : TTINISerial;
        ID              : integer;
        SWVer           : integer;
    end;
    PTerminalInfo = ^TTerminalInfo;

wenn ich jetzt was versenden will, habe ich eine funktion, die einen PTerminalTransferData Pointer etgegen nimmt, und dann anhand der Size die CRC berechnet, und dann die Daten weiterschickt

Delphi-Quellcode:

function TTerminal.SendCmdToTerminal(Data : PTerminalTransferData; DoFreeData : Boolean) : Boolean;
begin
    Result := FALSE;
    try
       Data^.Crc  := CalcCRC32(Data, Data^.Size);
       SendDataToTerminal(IP, Data);
       Result := TRUE;
    finally
      if DoFreeData then FreeMem(Data, Data^.Size);
    end;
end;

diese Funktion kann so mit allen Records umgehen, die den gleichen Header haben, und das sind alle, da der Header ja der Grudstock des Protokolles darstellt.

Wie löst man solche Aufgaben in .NET also ohne Pointer?

[OregonGhost]

Eine Möglichkeit, die ich mal irgendwo gesehen und selbst ausprobiert habe, ist die folgende (hier in C#).

Code:

protected object ReadStruct(NetworkStream stream, Type type)
{
    byte[] buffer = new byte[Marshal.SizeOf(type)];
    stream.Read(buffer, 0, Marshal.SizeOf(type));
    GCHandle handle = GCHandle.Alloc(buffer, GCHandleType.Pinned);
    object value = Marshal.PtrToStructure(handle.AddrOfPinnedObject(), type);
    handle.Free();
    return value;
}

protected void WriteStruct(NetworkStream stream, Type type, object value)
{
    byte[] buffer = new byte[Marshal.SizeOf(type)];
    GCHandle handle = GCHandle.Alloc(buffer, GCHandleType.Pinned);
    Marshal.StructureToPtr(value, handle.AddrOfPinnedObject(), false);
    stream.Write(buffer, 0, Marshal.SizeOf(type));
    handle.Free();
}

Ich bin ehrlich gesagt nicht sicher, ob diese Lösung gut ist, aber zumindest funktioniert sie. Wenn deine Struktur also zum Beispiel TerminalTransferData heißt, wäre der Aufruf in C# wie folgt:

Code:

WriteStruct(stream, typeof(TerminalTransferData), data);

Grundsätzlich müsste man auch einfach innerhalb der Funktion value.GetType() aufrufen können, um an den Type zu kommen.

[Dax]

Was hindert euch eigentlich daran, Serialization und BinaryFormatter zu benutzen?

[Khabarakh]

Sogar Letzteres nimmt einem .Net ab .
Per WCF sollte das Ganze wirklich nicht komplizierter als jeder andere Code aussehen:

Code:

// Create a client.
CalculatorClient client = new CalculatorClient();

// Call the Add service operation.
double value1 = 100.00D;
double value2 = 15.99D;
double result = client.Add(value1, value2);  // Wird auf dem Server ausgeführt!
Console.WriteLine("Add({0},{1}) = {2}", value1, value2, result);

Hm, ist ja richtig langweilig *g* .