C# matriz dentro de una estructura

Question

desee hacer esto: (EDIT: código de ejemplo malo, ignorar y pasar a continuación)

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]; 
} 

Pero al no poder declarar tamaños de matriz de estructura, ¿cómo vuelvo a configurar esto?

EDITAR: El motivo del diseño es que estoy usando BinaryReader para leer un archivo escrito con estructuras C. Utilizando BinaryReader y una unión estructural C# (FieldOffset (0)), quiero cargar el encabezado como una matriz de bytes, y luego leerlo como estaba previsto originalmente.

[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

yo no usaría ese patrón en el primer lugar. Este tipo de mapeo de memoria puede ser apropiado en c, pero no en un lenguaje de alto nivel como C#.

Me gustaría escribir una llamada al lector binario para cada miembro que quiero leer. Esto significa que puede usar clases y escribirlas de una manera limpia y de alto nivel.

También se ocupa de los problemas endian. Mientras que la asignación de memoria se romperá cuando se use en diferentes sistemas endian.

pregunta relacionada: Casting a byte array to a managed structure

---

Así que su código será similar a la siguiente (añadir modificadores de acceso, etc.):

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 constructor con parámetros :

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

El uso de código no seguro y el tampón de tamaño fijo se puede hacer esto: http://msdn.microsoft.com/en-us/library/zycewsya.aspx

Los búferes de tamaño fijo son bytes en línea de la estructura. No viven dentro de una matriz separada como tu 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 que sólo puede utilizar la estructura y leerlo con el siguiente método de extensión:

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

matrices dentro de las estructuras estructuras no administradas pueden contener matrices embebidos. Por defecto, estos campos de matriz incrustados se clasifican como SAFEARRAY. En el siguiente ejemplo, s1 es una matriz incrustada que se asigna directamente dentro de la propia estructura.

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

Las matrices pueden ser calculan como UnmanagedType.ByValArray, lo que requiere que se configure el campo MarshalAsAttribute.SizeConst. El tamaño se puede establecer solo como una constante. El siguiente código muestra la definición administrada correspondiente de MyStruct. C# VB

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