ID flexibles

Article
08/18/2010

Les ID flexibles sont utilisés pour identifier des réplicas, éléments ou unités de modification. Sync Framework prend en charge les types suivants d'ID flexibles :

ID de longueur fixe

Un ID de longueur fixe est toujours de la même longueur lors de chaque utilisation. La longueur est spécifiée dans le schéma du format d'ID.
ID de longueur variable

Un ID de longueur variable peut varier en longueur lors de chaque utilisation. La longueur maximale est spécifiée dans le schéma du format d'ID.

Code managé Un ID est représenté par la classe SyncId. Cette classe contient l'ID et une valeur qui indique si l'ID est de longueur variable.

Code non managé Un ID est représenté comme un tableau d'octets. Les ID de longueur variable sont représentés par la structure SYNC_ID. Cette structure contient la longueur de l'ID et l'ID représenté comme un tableau d'octets.

Schéma d'ID

Les formats d'ID sont définis dans un schéma qui spécifie les informations suivantes sur chaque ID dans le système :

si l'ID est de longueur fixe ou de longueur variable ;
la taille si l'ID est de longueur fixe ou la taille maximale si l'ID est de longueur variable.

Code managé Le schéma du format d'ID est spécifié à l'aide de la classe SyncIdFormatGroup.

Code non managé Le schéma du format d'ID est spécifié à l'aide de la structure ID_PARAMETERS.

Ce schéma doit être fourni à différentes méthodes Sync Framework et permet de garantir que tous les objets utilisent les mêmes informations de schéma d'ID.

Dans une session de synchronisation, les deux fournisseurs sont interrogés au sujet de leurs schémas. Les schémas sont ensuite comparés pour vérifier que les deux fournisseurs utilisent le même schéma. Si cette vérification échoue, la session ne sera pas créée.

Code managé La session obtient le schéma d'un fournisseur en utilisant la propriété IdFormats.

Code non managé La session obtient le schéma d'un fournisseur en utilisant la méthode ISyncProvider::GetIdParameters.

Notes

Le format d'un ID passé à une méthode Sync Framework doit correspondre au format spécifié dans le schéma du format d'ID ou la méthode échouera.

Format recommandé pour les ID globaux

Un ID global est requis pour chaque élément dans l'étendue de synchronisation et doit être unique dans une communauté de synchronisation. Un ID global est un ID flexible et, par conséquent, peut utiliser tout format. Toutefois, dans la mesure où les métadonnées peuvent représenter un groupe ordonné d'ID comme une plage unique, les métadonnées sont plus compactes lorsque les ID sont énumérés comme groupes ordonnés. L'utilisation de plages rend également la maintenance des métadonnées plus efficace. Par conséquent, il peut être utile de faire en sorte que l'ordre des ID s'ajuste logiquement à l'ordre qui convient à l'énumération. Pour le format d'un ID global, nous vous recommandons d'utiliser un GUID de 16 octets avec un préfixe de 8 octets, tel que la classe SyncGlobalId managée ou la structure SYNC_GID non managée.

Considérations spéciales relatives aux données hiérarchiques

Dans les cas où les éléments synchronisés ont une hiérarchie, il peut être utile de placer un nombre à croissance monotone, par exemple une heure d'horloge, dans le préfixe d'ID. Étant donné que les parents sont en général créés avant les enfants, ils apparaissent plus tôt dans l'ordre d'énumération. Cela permet à un fournisseur de réduire le besoin de traiter des éléments qui ne sont pas dans l'ordre dans lequel ils doivent s'appliquer.

Une approche en matière d'assignation d'ID globaux pour les données hiérarchiques est la suivante :

Créez un compteur qui est assez grand pour indexer tous les éléments uniques dans le réplica.
En commençant par la racine de l'étendue, préférez la profondeur à la largeur et parcourez le système.
Pour chaque élément (parent ou enfant), générez un GUID.
Affectez l'heure d'horloge comme préfixe au GUID.

Des ID globaux peuvent être assignés aux nouveaux éléments créés en utilisant cette même méthode, indépendamment de leurs conteneurs ou éléments individuels imbriqués.

Gestion de la mémoire dans le code non managé

Les ID sont représentés comme des pointeurs vers les tableaux d'octets. Par conséquent, pour les ID de longueur fixe, il suffit de convertir l'ID utilisé en un pointeur. Pour les ID de longueur variable, les données d'ID doivent être précédées de la taille de la mémoire tampon, comme dans la structure SYNC_ID.

Notes

Sync Framework ne conserve jamais de référence à un ID alloué par un appelant. Si Sync Framework doit garder un ID, il alloue sa propre mémoire pour l'ID et copie l'ID en interne. Les appelants sont chargés d'allouer et de libérer la mémoire associée aux ID.

ID comme valeurs de retour dans le code non managé

Les ID de longueur variable sont retournés à partir des méthodes Sync Framework dans un processus à deux appels :

La méthode est appelée pour déterminer la taille de l'ID.
L'appelant alloue la mémoire et appelle à nouveau la fonction, et fournit cette fois la mémoire tampon récemment allouée ainsi que sa taille.

Un utilisateur peut optimiser ce processus en allouant une mémoire tampon de taille correcte ou de taille maximale. Dans ce cas, le premier appel est inutile, bien que l'appelant doive toujours vérifier le HRESULT retourné pour s'assurer que la taille de la mémoire tampon était correcte.

Les méthodes qui retournent des ID de longueur fixe n'utilisent pas le processus en deux étapes. À la place, les méthodes fournissent uniquement une mémoire tampon de longueur correcte. Le paramètre de taille est facultatif lorsque vous demandez un ID de longueur fixe (NULL peut être fourni). Si la taille est passée, les méthodes agissent comme dans le cas de longueur variable. Cela signifie que, si la taille est inférieure à l'ID qui doit être retourné, un code d'erreur qui indique que d'autres données sont disponibles est retourné et la variable de taille stocke la taille requise. Si la taille est supérieure à la taille requise, la méthode réussit et la taille requise est retournée.

Plages

Les blocs d'ID ordonnés peuvent être désignés sous le nom de plage. Une plage utilise les ID inférieur et supérieur comme limites fermées pour la plage.

Code managé Les limites de plage sont passées directement aux méthodes qui utilisent des plages.

Code non managé Une plage est représentée en utilisant la structure SYNC_RANGE.