Strukturen von C++ nach C# übersetzen

[Sanchez]

Hallo zusammen,
Ich versuche gerade auf einem WinCE-Gerät eine GPRS-Karte per RAS anzusprechen.
Dazu muss ich einige Strukturen von C nach C# zu übersetzen.

z.B.

Code:

typedef struct _RASCONN { 
  DWORD dwSize; 
  HRASCONN hrasconn; 
  TCHAR szEntryName[ RAS_MaxEntryName + 1 ]; 
} RASCONN;

hab ich spontan nach:

Code:

private struct RASCONN
{
   public int dwSize;
   public IntPtr hRasCon;
   public char[] szEntryName;
}

übersetzt. Direkt vor der Verwendung der Struktur setze ich die Größe von szEntryName:

Code:

  rasConn.szEntryName = new char[21];

Grundsätzlich scheint damit der Aufruf von RasEnumConnections auch zu funktionieren. Ich bekomme eine Verbindung zurück, wie es sein sollte. Allerdings steht in szEntryName nichts drinnen. Ich hab auf OpenNetCF.org einen Hinweis gelesen, dass die Char-Arrays eine fixe Länge haben müssen. Ich hab aber noch keinen Weg gefunden das zu machen.
Wie deklariere ich also so ein Char-Array mit fixer Länge?

grüße, daniel

[Binärbaum]

Zitat:

Zitat von Sanchez

Wie deklariere ich also so ein Char-Array mit fixer Länge?

Vielleicht so:

Code:

...
   public char[MY_LEN] szEntryName;
};

MY_LEN ist hierbei eine Konstante, die die Länge des Char-Array angibt.

MfG
Binärbaum

[Sanchez]

Nein, so gehts nicht.
Wenn ichs so hinschreibe, bekomme ich in der Zeile mit dem Array gleich 3 Fehler:
- Syntax error, ']' expected
- ; expected
- Invalid token ';' in class, struct, or interface member declaration

[Robert_G]

Eine Instanz eines char[] mit 3 Elementen bekommst du so.

Code:

struct MyStruct
{
    public char[] MyCharArray = new char[3];
    
}

Du musst aber aufpassen. Wenn du Instanzen von MyStruct per Reflection anlegst ist nicht sichergestellt, dass das Feld initialisiert wird.
Bei Klassen sollte man Felder deshalb niemals so initialisieren. Bei structs hast du da kaum eine andere Wahl. :?

Nachtrag: :wall: Das hast du ja schon oben geschrieben....

[Sanchez]

Das Problem ist, dass ich auf diese Weise kein Char-Array in meiner Structure habe, sondern eine Referenz auf das Array. Wenn ich dann mit Marshal.StructureToPtr einen IntPtr draus mache, steht dort nicht drinnen was ich möchte.

Ich versuche das Ganze jetzt über ein ByteArray anstatt über die Structure zu machen. Mal sehen, ob ich dort mehr Erfolg habe.

[Robert_G]

Jetzt hast du mich so früh am morgen erwischt. :oops:

Wenn es um's Marshaling geht, kann man char arrays prima als string behandeln. :)
Dem Marshaler sagst du einfach wie er es umfriemeln soll und gut ist:

Code:

using System;
using System.Runtime.InteropServices;
struct RASConnection 
{ 
    public int dwSize; 
    public IntPtr hRasCon; 
    [MarshalAs(UnmanagedType.ByValTStr, SizeConst=21)]
    public string szEntryName; 
}

[Sanchez]

Nein, leider nicht.
Das läuft im CompactFramework, dort gibts kein MarshalAs. Ich glaube ich muss alles zu Fuß erledigen.

Deshalb hab ich mir jetzt ne Basisklasse geschrieben:

Code:

   public abstract class StructMarshalBase
   {
      protected byte[] m_data = null;
      /// <summary>
      /// In Byte
      /// </summary>
      public const int RAS_MaxEntryName = 42;
      public StructMarshalBase() 
      {
         m_data = new byte[GetSize()];
      }
      public abstract int GetSize();
      public IntPtr ToIntPtr()
      {
         IntPtr Pointer = new IntPtr();
         Pointer = MarshalEx.AllocHLocal(GetSize());
         Marshal.Copy(m_data, 0, Pointer, GetSize());
         return Pointer;
      }
      public void LoadFromIntPtr(IntPtr _pointer)
      {
         Marshal.Copy(_pointer, m_data, 0, GetSize());
      }
   }

und davon leite ich mir jetzt meine Struct-Entsprechungen ab, die das Bytearray interpretieren, bzw. reinschreiben. z.B.

Code:

   public class RASCONN : StructMarshalBase
   {
      //int dwSize;
      //IntPtr hRasCon;
      //char[RAS_MaxEntryName + 1] szEntryName;
      public Int32 dwSize
      {
         get
         {
            return BitConverter.ToInt32(m_data, 0);
         }   
         set
         {
            Buffer.BlockCopy(BitConverter.GetBytes(value), 0,
               m_data, 0, BitConverter.GetBytes(value).Length);
         }
      }
      public IntPtr hRasCon
      {
         get {return new IntPtr (BitConverter.ToInt32(m_data, 4));}
         set
         {
            Buffer.BlockCopy(BitConverter.GetBytes(value.ToInt32()),
               0, m_data, 4, BitConverter.GetBytes(value.ToInt32()).Length);
         }
      }
      public string szEntryName
      {
         get 
         {
            byte[] Text = new byte[RAS_MaxEntryName];
            Array.Copy(m_data, 8, Text, 0, Text.Length);
            return xtox.byteArrayToString(Text);
         }
         set
         {
            if (value.Length <= RAS_MaxEntryName)
            {
               Buffer.BlockCopy(xtox.stringToByteArray(value),
                  0, m_data, 8, value.Length);
            }
            else
            {
               throw new Exception("szEntryName darf nicht größer als " + RAS_MaxEntryName.ToString() + " sein!");
            }
         }
      }
      public override int GetSize()
      {
         return 8 + RAS_MaxEntryName;
      }
   }

Nur ist dort leider noch ein Fehler drinnen. Die API-Funktion "RasEnumConnections" liefert jetzt den Fehler ERROR_INVALID_SIZE. Vorher gabs ne Erfolgsmeldung, nur die Strings wurden nicht "ge-marshallt".

[Sanchez]

Lustigerweise klappts, wenn ich die Größe von 50 auf 52 ändere.

Code:

public override int GetSize() 
{ 
   return 8 + RAS_MaxEntryName [color=#ff0000]+ 2[/color]; 
}

Ich hab aber keine Ahnung warum. Weiß da jemand die Antwort drauf?