Utilisation des services de sérialisation

MIDL génère un stub de sérialisation pour la procédure avec les attributs [encode] et [decode]. Lorsque vous appelez cette routine, vous exécutez un appel de sérialisation au lieu d’un appel distant. Les arguments de procédure sont marshalés vers ou démarshalés à partir d’une mémoire tampon de la manière habituelle. Vous disposez alors d’un contrôle total des mémoires tampons.

En revanche, lorsque votre programme effectue la sérialisation de type (un type est étiqueté avec des attributs de sérialisation), MIDL génère des routines pour dimensionner, encoder et décoder des objets de ce type. Pour sérialiser des données, vous devez appeler ces routines de la manière appropriée. La sérialisation de type est une extension Microsoft et, en tant que telle, n’est pas disponible lorsque vous compilez en mode de compatibilité DCE (/osf). En utilisant les attributs [encode] et [decode] comme attributs d’interface, RPC applique l’encodage à tous les types et routines définis dans le fichier IDL.

Vous devez fournir des mémoires tampons correctement alignées lors de l’utilisation des services de sérialisation. Le début de la mémoire tampon doit être aligné à une adresse qui est un multiple de 8 ou 8 octets alignés. Pour la sérialisation de procédure, chaque appel de procédure doit être marshalé dans ou démarshaler à partir d’une position de mémoire tampon alignée sur 8 octets. Pour la sérialisation de type, le dimensionnement, l’encodage et le décodage doivent commencer à une position alignée sur 8 octets.

Une façon pour votre application de s’assurer que ses mémoires tampons sont alignées consiste à écrire la fonction midl_user_allocate de sorte qu’elle crée des mémoires tampons alignées. L’exemple de code suivant montre comment procéder.

#include <windows.h>

#define ALIGN_TO8(p)   (char *)((unsigned long)((char *)p + 7) & ~7)

void __RPC_FAR *__RPC_USER  MIDL_user_allocate(size_t sizeInBytes)
{
    unsigned char *pcAllocated;
    unsigned char *pcUserPtr;

    pcAllocated = (unsigned char *) malloc( sizeInBytes + 15 );
    pcUserPtr =  ALIGN_TO8( pcAllocated );
    if ( pcUserPtr == pcAllocated )
        pcUserPtr = pcAllocated + 8;

    *(pcUserPtr - 1) = pcUserPtr - pcAllocated;

    return( pcUserPtr );
}

L’exemple suivant montre la fonction midl_user_free correspondante.

void __RPC_USER  MIDL_user_free(void __RPC_FAR *f)
{
    unsigned char * pcAllocated;
    unsigned char * pcUserPtr;

    pcUserPtr = (unsigned char *) f;
    pcAllocated = pcUserPtr - *(pcUserPtr - 1);

    free( pcAllocated );
}