C# array all'interno di una struttura

Question

voglio fare questo: (EDIT: il codice di esempio male, ignorare e passare sotto)

struct RECORD { 
    char[] name = new char[16]; 
    int dt1; 
} 
struct BLOCK { 
    char[] version = new char[4]; 
    int field1; 
    int field2; 
    RECORD[] records = new RECORD[15]; 
    char[] filler1 = new char[24]; 
} 

Ma non essendo in grado di dichiarare la dimensione dell'array nella struct, come faccio a riconfigurare questo?

MODIFICA: Il motivo del layout è che sto utilizzando BinaryReader per leggere un file scritto con le strutture C. Usando BinaryReader e un C# struct union (FieldOffset (0)), voglio caricare l'intestazione come una matrice di byte, quindi leggerla come originariamente intesa.

[StructLayout(LayoutKind.Sequential)] 
unsafe struct headerLayout 
{ 
    [FieldOffset(0)] 
    char[] version = new char[4]; 
    int fileOsn; 
    int fileDsn; 
    // and other fields, some with arrays of simple types 
} 

[StructLayout(LayoutKind.Explicit)] 
struct headerUnion     // 2048 bytes in header 
{ 
    [FieldOffset(0)] 
    public byte[] headerBytes;  // for BinaryReader 
    [FieldOffset(0)] 
    public headerLayout header;  // for field recognition 
} 

Answer 1

Non userei quel modello in primo luogo. Questo tipo di mappatura della memoria può essere appropriato in c, ma non in un linguaggio di alto livello come C#.

Scrivo semplicemente una chiamata al lettore binario per ogni membro che voglio leggere. Ciò significa che puoi usare le classi e scriverle in modo pulito e di alto livello.

Si occupa anche dei problemi di endian. Mentre la mappatura della memoria si interrompe quando viene utilizzata su diversi sistemi endian.

questione connessa: Casting a byte array to a managed structure

---

Quindi il codice sarà simile al seguente (aggiungere modificatori di accesso, ecc):

class Record 
{ 
    char[] name; 
    int dt1; 
} 
class Block { 
    char[] version; 
    int field1; 
    int field2; 
    RECORD[] records; 
    char[] filler1; 
} 

class MyReader 
{ 
    BinaryReader Reader; 

    Block ReadBlock() 
    { 
     Block block=new Block(); 
     block.version=Reader.ReadChars(4); 
     block.field1=Reader.ReadInt32(); 
     block.field2=Reader.ReadInt32(); 
     block.records=new Record[15]; 
     for(int i=0;i<block.records.Length;i++) 
      block.records[i]=ReadRecord(); 
     block.filler1=Reader.ReadChars(24); 
     return block; 
    } 

    Record ReadRecord() 
    { 
     ... 
    } 

    public MyReader(BinaryReader reader) 
    { 
     Reader=reader; 
    } 
} 

Answer 2

uso un costruttore con Parametri:

public struct RECORD { 
    public RECORD(int initial) { 
     name = new char[16]; 
     dt1 = initial; 
    } 
    public char[] name; 
    public int dt1; 
} 

...

var record = new RECORD(5); 

Answer 3

Utilizzando codice unsafe e buffer di dimensione fissa questo può essere fatto: http://msdn.microsoft.com/en-us/library/zycewsya.aspx

I buffer di dimensione fissa sono inline-byte della struct. Non vivono all'interno di un array separato come fa il tuo char [].

Answer 4

Uso fixed size buffers:

[StructLayout(LayoutKind.Explicit)] 
unsafe struct headerUnion     // 2048 bytes in header 
{ 
    [FieldOffset(0)] 
    public fixed byte headerBytes[2048];  
    [FieldOffset(0)] 
    public headerLayout header; 
} 

Alternativ si può semplicemente utilizzare lo struct e leggerlo con il seguente metodo di estensione:

private static T ReadStruct<T>(this BinaryReader reader) 
     where T : struct 
{ 
    Byte[] buffer = new Byte[Marshal.SizeOf(typeof(T))]; 
    reader.Read(buffer, 0, buffer.Length); 
    GCHandle handle = default(GCHandle); 
    try 
    { 
     handle = GCHandle.Alloc(buffer, GCHandleType.Pinned); 
     return (T)Marshal.PtrToStructure(handle.AddrOfPinnedObject(), typeof(T)); 
    } 
    finally 
    { 
     if (handle.IsAllocated) 
      handle.Free(); 
    } 
} 

Answer 5

Array all'interno di strutture strutture non gestiti possono contenere array embedded. Per impostazione predefinita, questi campi di matrice incorporati vengono sottoposti a marshalling come SAFEARRAY. Nell'esempio seguente, s1 è un array incorporato che viene allocato direttamente all'interno della struttura stessa.

Unmanaged representation 
struct MyStruct { 
    short s1[128]; 
} 

array possono essere marshalling come UnmanagedType.ByValArray, che richiede di impostare il campo MarshalAsAttribute.SizeConst. La dimensione può essere impostata solo come costante. Il codice seguente mostra la corrispondente definizione gestita di MyStruct. C# VB

[StructLayout(LayoutKind.Sequential)] 
public struct MyStruct { 
    [MarshalAs(UnmanagedType.ByValArray, SizeConst=128)] public short[] s1; 
}