Gestion des métadonnées pour les fournisseurs simples

Article
10/17/2009

Si vous utilisez un fournisseur simple, vous devez stocker les métadonnées dans les services de stockage des métadonnées, qui sont implémentés dans SqlMetadataStore (pour le code managé) et dans ISqlSyncMetadataStore (pour le code non managé).

Le magasin des métadonnées contient les métadonnées avec lesquelles un fournisseur ou une application interagit. Ces métadonnées sont les suivantes :

ID de réplica. Il identifie le réplica qui utilise un magasin particulier.
ID d'élément et versions. Ils identifient les éléments qui ont été énumérés à partir d'un magasin d'éléments et la version actuelle de chaque élément.
ID d'unité de modification et versions. Ils identifient, le cas échéant, les parties d'un élément qui doivent faire l'objet d'un suivi et la version actuelle de chaque partie. Par exemple, un contact d'une base de données de contacts peut être un élément, et le champ numéro de téléphone peut être l'une des unités de modification.

Identification des éléments dans le magasin d'éléments et le magasin des métadonnées

Pour synchroniser un élément, Sync Framework doit être en mesure d'identifier l'élément en question dans le magasin d'éléments et de mapper cette identité à un ID interne dans le magasin des métadonnées. Il doit également pouvoir déterminer si la version de l'élément a changé depuis la session de synchronisation précédente. Si la version a changé et que le réplica de destination ne contient pas encore cette version de l'élément, l'élément doit être synchronisé. Si les modifications sont synchronisées au niveau d'une unité de modification au lieu d'un élément, Sync Framework doit être en mesure d'identifier l'unité de modification et sa version. Une unité de modification représente une modification d'un sous-élément, par exemple le champ numéro de téléphone dans un élément représentant un contact. Cet exemple n'utilise pas d'unités de modification.

Spécification du format des ID utilisés dans le magasin des métadonnées

Le code suivant définit le constructeur de MyFullEnumerationSimpleSyncProvider et la propriété IdFormats. Le runtime Sync Framework utilise cette propriété pour déterminer quel format le magasin des métadonnées utilise pour les ID. Si les ID flexibles ne sont pas utilisés, Sync Framework utilise un format fixe pour identifier les réplicas, les éléments et les unités de modification. Si les ID flexibles sont utilisés, les méthodes ISimpleSyncProviderIdGenerator sont utilisées pour générer des ID.

public MyFullEnumerationSimpleSyncProvider(string name, MySimpleDataStore store)
{
    _name = name;
    _store = store;

    // Create a file to store metadata for all items and a file to store 
    // the replica ID.
    _replicaMetadataFile = Environment.CurrentDirectory + "\\" + _name.ToString() + ".Metadata";
    _replicaIdFile = Environment.CurrentDirectory + "\\" + _name.ToString() + ".Replicaid";

    // Set ReplicaIdFormat to use a GUID as an ID, and ItemIdFormat to use a GUID plus
    // an 8-byte prefix.
    _idFormats = new SyncIdFormatGroup();
    _idFormats.ItemIdFormat.IsVariableLength = false;
    _idFormats.ItemIdFormat.Length = 24;
    _idFormats.ReplicaIdFormat.IsVariableLength = false;
    _idFormats.ReplicaIdFormat.Length = 16;

    this.ItemConstraint += new EventHandler<SimpleSyncItemConstraintEventArgs>(OnItemConstraint);
    this.ItemConflicting += new EventHandler<SimpleSyncItemConflictingEventArgs>(OnItemConflicting);
}

public SyncId ReplicaId
{
    get 
    {
        if (_replicaId == null)
        {
            _replicaId = GetReplicaIdFromFile( _replicaIdFile);
        }

        return _replicaId; 
    }
}

public override SyncIdFormatGroup IdFormats
{
    get { return _idFormats; }
}

Public Sub New(ByVal name As String, ByVal store As MySimpleDataStore)
    _name = name
    _store = store

    ' Create a file to store metadata for all items and a file to store 
    ' the replica ID. 
    _replicaMetadataFile = (Environment.CurrentDirectory & "\") + _name.ToString() & ".Metadata"
    _replicaIdFile = (Environment.CurrentDirectory & "\") + _name.ToString() & ".Replicaid"

    ' Set ReplicaIdFormat to use a GUID as an ID, and ItemIdFormat to use a GUID plus 
    ' an 8-byte prefix. 
    _idFormats = New SyncIdFormatGroup()
    _idFormats.ItemIdFormat.IsVariableLength = False
    _idFormats.ItemIdFormat.Length = 24
    _idFormats.ReplicaIdFormat.IsVariableLength = False
    _idFormats.ReplicaIdFormat.Length = 16

    AddHandler Me.ItemConstraint, AddressOf HandleItemConstraint
    AddHandler Me.ItemConflicting, AddressOf HandleItemConflicting
End Sub
Public ReadOnly Property ReplicaId() As SyncId
    Get
        If _replicaId Is Nothing Then
            _replicaId = GetReplicaIdFromFile(_replicaIdFile)
        End If

        Return _replicaId
    End Get
End Property

Public Overrides ReadOnly Property IdFormats() As SyncIdFormatGroup
    Get
        Return _idFormats
    End Get
End Property

Spécification des champs d'élément et du schéma des métadonnées

Sync Framework mappe les données du magasin d'éléments, ou les métadonnées supplémentaires que vous créez, aux ID internes du magasin des métadonnées et aux versions en utilisant un objet ItemMetadataSchema qui est exposé par la propriété MetadataSchema. Les exemples de code suivants fournissent la valeur d'entrée de l'objet ItemMetadataSchema. Les constantes dans l'exemple de code définissent une valeur entière pour chaque colonne dans le magasin d'éléments. Ces valeurs sont utilisées lors de la création des définitions de champ personnalisé et des règles d'identité pour l'objet ItemMetadataSchema.

public const uint CUSTOM_FIELD_ID = 1;
public const uint CUSTOM_FIELD_TIMESTAMP = 2;

public override ItemMetadataSchema MetadataSchema
{
    get
    {
        CustomFieldDefinition[] customFields = new CustomFieldDefinition[2];
        customFields[0] = new CustomFieldDefinition(CUSTOM_FIELD_ID, typeof(ulong));
        customFields[1] = new CustomFieldDefinition(CUSTOM_FIELD_TIMESTAMP, typeof(ulong));

        IdentityRule[] identityRule = new IdentityRule[1];
        identityRule[0] = new IdentityRule(new uint[] { CUSTOM_FIELD_ID });

        return new ItemMetadataSchema(customFields, identityRule);
    }
}

Public Const CUSTOM_FIELD_ID As UInteger = 1
Public Const CUSTOM_FIELD_TIMESTAMP As UInteger = 2
Public Overrides ReadOnly Property MetadataSchema() As ItemMetadataSchema
    Get
        Dim customFields As CustomFieldDefinition() = New CustomFieldDefinition(1) {}
        customFields(0) = New CustomFieldDefinition(CUSTOM_FIELD_ID, GetType(ULong))
        customFields(1) = New CustomFieldDefinition(CUSTOM_FIELD_TIMESTAMP, GetType(ULong))

        Dim identityRule As IdentityRule() = New IdentityRule(0) {}
        identityRule(0) = New IdentityRule(New UInteger() {CUSTOM_FIELD_ID})

        Return New ItemMetadataSchema(customFields, identityRule)
    End Get
End Property

L'objet ItemMetadataSchema expose trois propriétés :

CustomFields

Les champs personnalisés sont des champs qui sont identifiés par des entiers dans le magasin des métadonnées. Si une application requiert un nom convivial pour un ou plusieurs champs, elle doit mapper l'entier à un nom. Les champs personnalisés sont définis pour deux raisons : identifier les éléments, et indiquer la version de chacun de ces éléments. Les champs version permettent à Sync Framework de déterminer si un élément ou une unité de modification a changé. Dans cet exemple, les champs version contiennent les données réelles du magasin d'éléments. Il y a donc un champ pour chaque champ contenu dans le magasin d'éléments. Ce mappage un-à-un des champs n'est ni nécessaire, ni efficace. Il est plus judicieux d'effectuer un hachage des champs d'élément et de le stocker dans un champ personnalisé unique.
IdentityRules

La règle d'identité spécifie le champ personnalisé ou les champs à utiliser pour identifier un élément. Dans ce cas, le champ CUSTOM_FIELD_ID (champ 0) est utilisé.
ChangeUnitVersionDefinitions (non utilisée dans cet exemple)

Si les unités de modification sont utilisées, vous devez définir les champs version correspondants. Il n'est pas nécessaire de définir un mappage un-à-un entre les unités de modification et les informations de version, ni de stocker les données réelles. Les unités de modification peuvent également être étendues à plusieurs champs. Par exemple, cette application peut spécifier que les champs Zip et Phone représentent une unité de modification et que le champ Guid représente une autre unité de modification. Vous pouvez utiliser les données réelles pour Guid et pour l'autre unité de modification, un hachage des champs Zip et Phone ou toute autre méthode pour déterminer la version.

Certaines méthodes qui utilisent les données d'un magasin d'éléments, telles que InsertItem, requièrent une collection d'objets ItemField qui représentent chaque champ. Les objets ItemFieldDictionary qui sont des paramètres de ces méthodes ont les mêmes valeurs d'index que celles définies dans les objets CustomFieldDefinition.

Voir aussi

Concepts

Implémentation d'un fournisseur personnalisé simple
Procédure : créer un fournisseur simple managé

Partager via