Existe-t-il une alternative pour l'attribut StructLayout "Pack" dans le cadre compact?

La méthode la plus simple de traiter ce type de problème est le long des mêmes lignes que vous pourriez pour un champ de bit, appuyez simplement vos données dans un membre privé (ou des membres si elle est grande) du type de données approprié, puis présent. Propriétés publiques qui décompressent les données pour vous. Les opérations de déballage sont extrêmement rapides et auront peu d'impact sur la performance. Pour votre type particulier, ce qui suit est probablement ce que vous voulez: xxx

pour certaines structures même, cette méthode n'est pas utilisable en raison de la maladie malheureuse une structure a été définie. Dans ces cas, vous devrez généralement utiliser une matrice d'octets comme une blob de données à partir de laquelle les éléments peuvent être déballés.

Edit: pour développer ce que je veux dire sur les structures qui ne peuvent pas être traitées à l'aide de cette méthode simple. Lorsque vous ne pouvez pas faire de simples emballage / déballage comme celui-ci, vous devez fermer manuellement la structure irrégulière. Cela peut être fait à l'aide de méthodes manuelles au point que vous appelez l'API BLVVOKED ou en utilisant un maréchaleur personnalisé. Vous trouverez ci-dessous un exemple de marhysaler personnalisé qui peut être facilement adapté au maréchalage manuel de la tache. xxx

dans le cas des tableaux de ces structures, vous ne pouvez pas utiliser la maréchalation personnalisée, à moins que la taille de la matrice ne soit corrigée, mais il est relativement facile de repousser manuellement les données de réseau dans son ensemble. en utilisant les mêmes techniques.

Layoutkind.Explicite et FieldOffsetattribute vous permettront de faire tout ce que vous pourriez faire avec la propriété Pack. Ces attributs de mise en page explicite vous permettent de spécifier la position exact des octets de chaque champ dans la structure (par rapport au début de la plage de mémoire de la structure). La propriété Pack est utilisée par l'exécution pour déterminer la position exacte de chaque champ lors de l'utilisation d'une disposition séquentielle. La propriété Pack n'a pas d'autre effet. L'utilisation de la mise en page explicite vous permet d'imiter exactement le même comportement, même si un peu plus verboisement. Si vous ne pensez pas que cela résout votre problème, vous pourriez peut-être poster un peu plus d'informations sur ce que vous essayez de faire ou pourquoi vous pensez avoir besoin d'utiliser la propriété Pack.

Edit: Je viens de remarquer le commentaire supplémentaire sur la tentative d'obtenir la taille de la structure totale à 8 octets. Avez-vous essayé d'utiliser la propriété StructLayOntAttribute.Size? Contrairement à Pack, il est disponible dans le cadre compact.

Ce n'est probablement pas le type de réponse que vous recherchez, mais je le posterai de toute façon pour l'enfer:

public struct SomeStruct
{
    public byte SomeByte;
    public int SomeInt;
    public short SomeShort;
    public byte SomeByte2;


    public byte[] APIStruct
    {
        get
        {
            byte[] output = new byte[8];
            output[0] = this.SomeByte;
            Array.Copy(BitConverter.GetBytes(this.SomeInt), 0,
                output, 1, 4);
            Array.Copy(BitConverter.GetBytes(this.SomeShort), 0,
                output, 5, 2);
            output[7] = this.SomeByte2;
            return output;
        }
        set
        {
            byte[] input = value;
            this.SomeByte = input[0];
            this.SomeInt = BitConverter.ToInt32(input, 1);
            this.SomeShort = BitConverter.ToInt16(input, 5);
            this.SomeByte2 = input[7];
        }
    }
}

Êtes-vous absolument besoin em> cette mise en page spécifique ou est-ce acceptable de simplement faire la taille 8?

Je le demande comme suit comme suit P>

[StructLayout(LayoutKind.Explicit, Size=8)]
public struct SomeStruct
{ 
   [FieldOffset(0)] private byte b0;
   [FieldOffset(1)] private byte b1;
   [FieldOffset(2)] private byte b2;
   [FieldOffset(3)] private byte b3;
   [FieldOffset(4)] private byte b4;
   [FieldOffset(5)] private byte b5;
   [FieldOffset(6)] private byte b6;
   [FieldOffset(7)] private byte b7;

   // not thread safe - alter accordingly if that is a requirement
   private readonly static byte[] scratch = new byte[4];       

   public byte SomeByte 
   { 
       get { return b0; }
       set { b0 = value; }
   }

   public int SomeInt
   {
       get 
       { 
           // get the right endianess for your system this is just an example!
           scratch[0] = b1;
           scratch[1] = b2;
           scratch[2] = b3;
           scratch[3] = b4;
           return BitConverter.ToInt32(scratch, 0);
       }
   }

   public short SomeShort
   {
        get 
        { 
            // get the right endianess for your system this is just an example!
            scratch[0] = b5;
            scratch[1] = b6;
            return BitConverter.ToInt16(scratch, 0);
        }
    }

    public byte SomeByte2 
    { 
        get { return b7; }
        set { b7 = value; }
    }
}

Je pense que l'on devrait prendre la réponse de Stephen Martin, le faire accepter un T et utiliser la réflexion pour mettre en œuvre de manière générique les méthodes marshalagédonative et marshalnativetomatique. Ensuite, vous aurez un maréchaler de structure emballée personnalisé qui fonctionnera pour tout type de structure.

Voici le code: xxx