Wie Glass eine native Interop-Struct rekonstruiert
StructLayout und MarshalAs werden nicht als benutzerdefinierte Attribute gespeichert, sondern leben in den Metadatentabellen ClassLayout und FieldMarshal. So liest Glass.NET diese Tabellen und rekonstruiert den exakten nativen Byte-Vertrag, den eine P/Invoke-Struct beschreibt.
Eine P/Invoke-Struct trägt einen Vertrag, der nirgends im C# steht, das Sie sehen. [StructLayout(LayoutKind.Sequential, Pack = 1)] und ein paar [MarshalAs(...)]-Attribute entscheiden bis aufs Byte genau, welchen Speicherblock die Laufzeit an nativen Code übergibt. Ist das Layout falsch, kompiliert der Aufruf trotzdem, läuft trotzdem und beschädigt den Speicher lautlos. Wenn Sie also ein unbekanntes Assembly öffnen, um eine Interop-Grenze zu verstehen — oder zu prüfen —, ist das Erste, was Sie zurückbrauchen, genau diese native Form.
Und hier die Überraschung: Diese Attribute sind nicht im Assembly. Jedenfalls nicht als Attribute.
Die eigentliche Frage
Öffnen Sie irgendeinen Decompiler auf einer mit [MarshalAs] dekorierten Struct, und er zeigt Ihnen die Attribute zurück. Das wirkt trivial: benutzerdefiniertes Attribut lesen, ausgeben. Aber die CLR hat nie ein benutzerdefiniertes Attribut gespeichert. StructLayoutAttribute, MarshalAsAttribute, FieldOffsetAttribute und eine Handvoll weitere sind Pseudo-Custom-Attribute: Der Compiler liest sie zur Buildzeit, löscht sie und schreibt ihre Bedeutung stattdessen in eigene Metadatentabellen. Es gibt keinen Blob in der CustomAttribute-Tabelle zum Ausgeben.
Die eigentliche Frage lautet also: Wenn das Attribut weg ist, wie bringt Glass es zurück — korrekt, mit dem richtigen SizeConst, dem richtigen UnmanagedType, der richtigen Zeichenbreite? Die Antwort ist eine kleine, exakte Rückabbildung aus zwei Metadatentabellen, und sie zu verstehen lohnt sich, weil sie zugleich das ist, was Ihnen den wahren nativen Vertrag verrät.
Eine Struct mit echter nativer Form
Nehmen wir eine Struct, die eine C-DeviceInfo spiegelt, die von einer Geräte-Enumerierungs-API zurückgegeben wird, deren Header Sie haben:
using System.Runtime.InteropServices;
[StructLayout(LayoutKind.Sequential, Pack = 1, CharSet = CharSet.Unicode)]
public struct DeviceInfo
{
public uint Size;
[MarshalAs(UnmanagedType.ByValTStr, SizeConst = 32)]
public string Name;
[MarshalAs(UnmanagedType.ByValArray, SizeConst = 6)]
public byte[] MacAddress;
[MarshalAs(UnmanagedType.I1)]
public bool IsOnline;
}
Der native Vertrag, den dies beschreibt, ist präzise:
#pragma pack(1)
struct DeviceInfo {
uint32_t Size; // 4 Bytes
wchar_t Name[32]; // 32 * 2 = 64 Bytes (CharSet.Unicode)
uint8_t MacAddress[6]; // 6 Bytes, inline
int8_t IsOnline; // 1 Byte (I1), nicht das Standard-BOOL mit 4 Bytes
}; // Pack = 1 -> keine Auffüllung -> insgesamt 75 Bytes
Jede Zahl darin stammt aus den Attributen. ByValTStr macht Name zu einem inline festen Puffer von 32 Zeichen statt zu einem Zeiger auf eine Zeichenkette; CharSet.Unicode macht jedes Zeichen 2 Bytes groß; ByValArray bettet 6 Bytes inline ein, wo der Standard byte[] als Zeiger marshaln würde; und [MarshalAs(I1)] verkleinert bool von seinem Win32-Standard von 4 Bytes auf ein einziges Byte. Verlieren Sie eines davon, und die Struct hat eine andere Größe und die Felder landen bei anderen Offsets.
Wohin der Compiler es tatsächlich gelegt hat
Kompilieren Sie das und schauen Sie in die Metadaten, nicht ins IL. Drei Dinge haben sich geändert, keines davon ein benutzerdefiniertes Attribut.
1. Die TypeDef-Flags. LayoutKind.Sequential setzt tdSequentialLayout; CharSet.Unicode setzt tdUnicodeClass. Der Klassenkopf trägt sie direkt:
.class public sequential unicode sealed beforefieldinit DeviceInfo
extends [System.Runtime]System.ValueType
{
.pack 1
.size 0
2. Die ClassLayout-Tabelle (0x0F). Pack und jede explizite Größe leben hier, eine Zeile, die an den TypeDef gebunden ist:
ClassLayout
Parent PackingSize ClassSize
DeviceInfo 1 0
PackingSize = 1 ist das Pack = 1. ClassSize = 0 bedeutet „berechne sie aus den Feldern” — die Laufzeit summiert sie nach der Packregel.
3. Die FieldMarshal-Tabelle (0x0D). Das ist der Kern. Jedes [MarshalAs] wird zu einer Zeile: ein Parent (ein codierter Index, der auf das Feld zeigt) und ein NativeType (ein Index in den Blob-Heap). Der Blob ist ein Marshalling-Deskriptor — ein winziges Byte-Skript in der NATIVE_TYPE_*-Codierung aus ECMA-335:
FieldMarshal
Parent (Feld) NativeType blob
Name 17 20 ; FIXEDSYSSTRING(0x17), SizeConst = 0x20 (32)
MacAddress 1e 06 04 ; FIXEDARRAY(0x1e), Anzahl = 6, Element U1(0x04)
IsOnline 03 ; I1(0x03)
Diese Bytes sind der ganze Vertrag. 0x17 ist NATIVE_TYPE_FIXEDSYSSTRING (was C# als ByValTStr schreibt), und das folgende 0x20 ist die komprimierte Elementanzahl. 0x1e ist NATIVE_TYPE_FIXEDARRAY, gefolgt von der Anzahl und dem nativen Typ des Elements. 0x03 ist NATIVE_TYPE_I1. Es gibt keine FieldMarshal-Zeile für Felder ohne Attribut: Size erscheint schlicht nicht in der Tabelle, und das ist selbst eine Information: keine Zeile bedeutet Standard-Marshalling.
Die Rückabbildung, Schritt für Schritt
Glass durchläuft die drei Quellen und setzt einen Attributsatz pro Feld und einen pro Typ zusammen.
Für den Typ liest es das Layout-Bit aus den TypeDef-Flags (tdSequentialLayout → LayoutKind.Sequential, tdExplicitLayout → Explicit, keines → Auto) und die Charset-Bits (tdUnicodeClass → CharSet.Unicode, tdAnsiClass → Ansi, tdAutoClass → Auto). Es verknüpft die ClassLayout-Zeile, um Pack und, falls ungleich null, Size zu ziehen. Das wird zu den Argumenten von [StructLayout(...)].
Für jedes Feld sucht es eine FieldMarshal-Zeile, deren Parent auf dieses Feld auflöst. Gibt es keine, wird das Feld standardmäßig marshalt und erhält kein Attribut. Gibt es eine, decodiert Glass den Blob: Das erste Byte ist der UnmanagedType, und je nachdem, welcher, folgen null oder mehr Operanden. 0x17 (ByValTStr) nimmt eine Anzahl → SizeConst. 0x1e (ByValArray) nimmt eine Anzahl und einen nativen Elementtyp → SizeConst plus, wenn der Elementtyp nicht der offensichtliche Standard ist, ArraySubType. Skalare wie 0x03 (I1) nehmen nichts. Das decodierte Ergebnis wird als [MarshalAs(UnmanagedType.X, ...)] ausgegeben.
Der Lohn ist, dass die wiederhergestellte Struct keine Vermutung ist. Die 75-Byte-Zahl, die 2-Byte-Zeichen, der ein Byte große bool — all das wird aus Bytes rekonstruiert, die der Compiler festgeschrieben hat, sodass Glass die native Größe neben dem Typ anzeigen kann. Diese Zahl ist genau das, weswegen Sie gekommen sind, wenn Sie eine Interop-Grenze gegen einen C-Header prüfen.
Wann die Wiederherstellung teilweise bleibt
Die ehrlichen Grenzen betreffen allesamt Informationen, die die Metadaten tatsächlich nicht aufbewahren.
- Die Namen der Felder in einem sequential- oder explicit-Layout sind für das Marshalling nicht tragend, aber es sind weiterhin echte Feldnamen und sie überleben. Was nicht überlebt, ist alles, was das Attribut berechnet statt gespeichert hat.
LayoutKind.Auto-Structs tragen keinClassLayoutund keine Garantie für die Feldreihenfolge, also gibt es außer dem Flag nichts wiederherzustellen. - Arrays variabler Länge verlieren ihre literale Größe.
UnmanagedType.LPArraymit einemSizeParamIndexcodiert einen Parameterindex im Blob, keine Konstante, sodass GlassSizeParamIndex = nwiederherstellt, was genau das war, was dort stand — aber es gibt keinSizeConstanzuzeigen. - Standard-Marshalling ist absichtlich unsichtbar. Ein
byte[]ohne[MarshalAs]wird als Zeiger marshalt. Glass gibt korrekterweise kein Attribut aus, aber ein Leser, der einen Inline-Puffer erwartet, muss wissen, dass das Fehlen einer Zeile „Zeiger, nicht inline” bedeutet. Das ist eine Eigenschaft der Plattform, keine Lücke des Decompilers. [StructLayout]mitCharSet.Autobedeutet, dass die native Breite von string-Feldern vom Betriebssystem abhängt, auf dem der Code läuft. Glass kann nurAutoanzeigen; es kann Ihnen nicht sagen, zu welcher Breite ein bestimmtes Deployment es aufgelöst hat.
Fazit
Die Attribute, die einen Interop-Vertrag definieren, werden wegkompiliert: StructLayout in TypeDef-Flags und eine ClassLayout-Zeile, jedes MarshalAs in einen FieldMarshal-Blob. Ein Decompiler, der nur benutzerdefinierte Attribute ausgibt, würde Ihnen eine Struct ohne all das zeigen, was an einer Interop-Grenze schlimmer als nutzlos ist. Glass.NET bildet die echten Tabellen zurück, decodiert die NATIVE_TYPE_*-Deskriptoren und rekonstruiert die exakten Attribute und die native Byte-Größe — sodass das, was Sie zurücklesen, der Vertrag ist, den nativer Code tatsächlich sieht. Glass ist ein kostenloser .NET-Decompiler; Sie können jedes Assembly inspizieren, das Sie analysieren dürfen, über die Glass.NET-Produktseite oder die CLI- und MCP-Dokumentation.
Nebula.NET testen
Härten Sie Ihren .NET-Code in wenigen Minuten — starten Sie mit der kostenlosen Edition.