Procédure : créer un fournisseur de synchronisation managé

Article
08/18/2010

Cette rubrique explique comment utiliser un langage managé pour créer un fournisseur de synchronisation Sync Framework qui synchronise les données à partir d'un magasin de données personnalisé.

Cette rubrique suppose une connaissance de base des concepts C# et Microsoft .NET Framework.

Les exemples de cette rubrique reposent sur les classes et les interfaces Sync Framework suivantes :

Présentation des fournisseurs de synchronisation

Un fournisseur de synchronisation est un composant logiciel qui représente un réplica lors de la synchronisation. Cela permet au réplica de synchroniser ses données avec d'autres réplicas. Afin que la synchronisation ait lieu, une application crée en premier un objet SyncOrchestrator, le connecte à deux objets SyncProvider, puis démarre la session. L'un des fournisseurs représente le réplica source. Le réplica source fournit les métadonnées pour les éléments modifiés via sa méthode GetChangeBatch et les données d'élément via un objet IChangeDataRetriever. L'autre fournisseur représente le réplica de destination. Le réplica de destination reçoit les métadonnées pour les éléments modifiés via sa méthode ProcessChangeBatch et applique les modifications à son magasin d'éléments en utilisant un objet NotifyingChangeApplier fourni par Sync Framework avec son propre objet INotifyingChangeApplierTarget.

Pour plus d'informations sur le rôle du fournisseur de synchronisation, consultez Implémentation d'un fournisseur personnalisé standard.

Configuration de génération

.NET Framework 2.0 ou version ultérieure.
Référence à Microsoft.Synchronization.
Référence à Microsoft.Synchronization.MetadataStorage.

Exemple

L'exemple de code de cette rubrique indique comment implémenter les méthodes d'interface et de classe de base requises afin qu'un réplica participe à une communauté de synchronisation Sync Framework, à la fois comme une source et comme une destination. Dans cet exemple, le réplica stocke des contacts dans un fichier texte de valeurs séparées par des virgules. Les éléments à synchroniser sont les contacts contenus dans ce fichier. Cet exemple utilise également un magasin des métadonnées personnalisé implémenté en utilisant l'API du service de stockage des métadonnées. Pour plus d'informations sur le service de stockage des métadonnées, consultez Service de stockage des métadonnées de Sync Framework.

Dans les exemples suivants, _itemStore représente un objet qui contient à la fois le magasin d'éléments et le magasin des métadonnées.

Implémentation de SyncProvider et de KnowledgeSyncProvider

Le point d'entrée dans le fournisseur est la classe SyncProvider. Cette classe est conçue pour fonctionner en tant que classe de base pour d'autres classes de fournisseur plus puissantes. Cet exemple utilise la classe KnowledgeSyncProvider.

Déclaration de KnowledgeSyncProvider

Ajoutez KnowledgeSyncProvider à la liste d'héritage de classe.

class ContactsProviderXmlMetadataNoChangeUnits : KnowledgeSyncProvider

Ajoutez les méthodes SyncProvider et KnowledgeSyncProvider à la classe.

Propriété IdFormats

Sync Framework appelle IdFormats sur les fournisseurs de source et de destination lorsque Synchronize est appelé sur l'objet SyncOrchestrator. La propriété IdFormats retourne le schéma du format de l'ID utilisé par le fournisseur. Ce schéma doit être le même pour les deux fournisseurs. Cet exemple définit les tailles des ID d'élément qui contiennent un SyncGlobalId, des ID de réplica qui contiennent le chemin d'accès absolu du réplica et des ID d'unité de modification qui sont membres d'une énumération.

public override SyncIdFormatGroup IdFormats
{
    get 
    {
        SyncIdFormatGroup FormatGroup = new SyncIdFormatGroup();

        // Item IDs are of SyncGlobalId type, so they are fixed length and contain a ulong prefix plus a Guid.
        FormatGroup.ItemIdFormat.IsVariableLength = false;
        FormatGroup.ItemIdFormat.Length = (ushort)(sizeof(ulong) + Marshal.SizeOf(typeof(Guid)));

        // Replica IDs are the absolute path to the item store, so they are variable length with maximum
        // length equal to the maximum length of a path.
        FormatGroup.ReplicaIdFormat.IsVariableLength = true;
        FormatGroup.ReplicaIdFormat.Length = 260 * sizeof(char);

        return FormatGroup;
    }
}

Méthode BeginSession

Sync Framework appelle BeginSession sur les fournisseurs de source et de destination avant qu'il appelle d'autres méthodes. Cette méthode informe un fournisseur qu'il se joint à une session de synchronisation et passe au fournisseur un objet qui contient des informations d'état de session. Cette implémentation stocke l'objet d'état de session ou lève SyncInvalidOperationException si le fournisseur s'est déjà joint à une session de synchronisation.

public override void BeginSession(SyncProviderPosition position, SyncSessionContext syncSessionContext)
{
    // If this object is already in a session, throw an exception.
    if (null != _sessionContext)
    {
        throw new SyncInvalidOperationException();
    }

    _sessionContext = syncSessionContext;
}

Méthode GetSyncBatchParameters

Sync Framework appelle GetSyncBatchParameters sur le fournisseur de destination. Cette méthode récupère le nombre de modifications que le fournisseur de source doit inclure dans un lot de modifications et obtient la connaissance actuelle du fournisseur de destination. Cette implémentation récupère la connaissance du magasin des métadonnées et définit la taille de lot à 10.

public override void GetSyncBatchParameters(out uint batchSize, out SyncKnowledge knowledge)
{
    // Set a batch size of 10.
    batchSize = 10;

    // Return the current knowledge of the replica.
    knowledge = _itemStore.ContactReplicaMetadata.GetKnowledge();
}

L'objet de magasin des métadonnées retourne la connaissance actuelle du réplica à l'aide de GetKnowledge. Cette implémentation crée un objet SyncKnowledge si le réplica ne contient pas encore de connaissance, et définit le nombre de cycles de la connaissance sur le nombre de cycles actuel du réplica.

public override SyncKnowledge GetKnowledge()
{
    // If the replica does not yet contain any knowledge, create a new knowledge object.
    if (null == _knowledge)
    {
        _knowledge = new SyncKnowledge(IdFormats, ReplicaId, _tickCount);            
    }

    // Ensure the tick count of the knowledge is set to the current tick count of the replica.
    _knowledge.SetLocalTickCount(_tickCount);

    return _knowledge;
}

Méthode GetChangeBatch

La session de synchronisation démarre vraiment lorsque Sync Framework appelle GetChangeBatch sur le fournisseur de source. Cette méthode récupère un lot de modifications à envoyer au fournisseur de destination et retourne également l'interface d'extracteur de données. Sync Framework utilise l'interface d'extracteur de données pour obtenir un object, qui est ensuite utilisé par le fournisseur de destination pour récupérer des données d'élément relatives aux modifications qui sont appliquées au réplica de destination. Sync Framework appelle GetChangeBatch à plusieurs reprises jusqu'à ce que le dernier lot soit envoyé. Le fournisseur de source indique qu'un lot est le dernier en appelant la méthode SetLastBatch sur l'objet de lot de modifications. Cette implémentation délègue la tâche d'énumération des modifications à l'objet de magasin des métadonnées. L'objet de fournisseur implémente IChangeDataRetriever ; par conséquent, il est retourné dans le paramètre changeDataRetriever.

public override ChangeBatch GetChangeBatch(uint batchSize, SyncKnowledge destinationKnowledge, out object changeDataRetriever)
{
    // Return this object as the IChangeDataRetriever object that is called to retrieve item data.
    changeDataRetriever = this;

    // Call the metadata store to get a batch of changes.
    return _itemStore.ContactReplicaMetadata.GetChangeBatch(batchSize, destinationKnowledge);
}

L'objet de magasin des métadonnées retourne un lot de modifications à l'aide de GetChangeBatch. Cette implémentation stocke les éléments dans le magasin des métadonnées comme une liste d'objets ItemMetadata classés par ID d'élément. Les éléments sont énumérés et une modification est ajoutée à un groupe classé dans l'objet de lot de modifications si la modification n'est pas contenue dans la connaissance de destination. Lorsque tous les éléments du magasin des métadonnées ont été énumérés, SetLastBatch est appelé sur le lot de modifications.

public override ChangeBatch GetChangeBatch(uint batchSize, SyncKnowledge destinationKnowledge)
{
    // The destination knowledge must be converted to be compatible with the source replica
    // before it can be used.
    SyncKnowledge mappedDestKnowledge = _knowledge.MapRemoteKnowledgeToLocal(destinationKnowledge);

    // Create a new change batch, initialized by using the current knowledge of the source replica
    // and a new ForgottenKnowledge object.
    ChangeBatch changeBatch = new ChangeBatch(IdFormats, GetKnowledge(), new ForgottenKnowledge());

    // Start a group of changes in the change batch. The group is ordered by item ID.
    // _getChangeBatchCurrent is 0 the first time GetChangeBatch is called, and is used to track the
    // position in the metadata store for subsequent calls to GetChangeBatch.
    changeBatch.BeginOrderedGroup(_items.Values[_getChangeBatchCurrent].GlobalId);

    // itemsAdded is incremented each time a change is added to the change batch. When itemsAdded
    // is greater than the requested batch size, enumeration stops and the change batch is returned.
    int itemsAdded = 0;

    ItemMetadata itemMeta;

    // Enumerate items and add a change to the change batch if it is not contained in the 
    // destination knowledge.
    // _items is a SortedList that contains ItemMetadata objects that are ordered by item ID.
    for (; itemsAdded <= batchSize && _getChangeBatchCurrent < _items.Count; _getChangeBatchCurrent++)
    {
        itemMeta = _items.Values[_getChangeBatchCurrent];
        ChangeKind kind = (itemMeta.IsDeleted) ? ChangeKind.Deleted : ChangeKind.Update;
        ItemChange change = new ItemChange(IdFormats, ReplicaId, itemMeta.GlobalId, kind, itemMeta.CreationVersion, 
            itemMeta.ChangeVersion);

        // If the change is not contained in the destination knowledge, add it to the change batch.
        if (!mappedDestKnowledge.Contains(change))
        {
            changeBatch.AddChange(change);
            itemsAdded++;
        }
    }

    // End the group of changes in the change batch. Pass the current source knowledge.
    changeBatch.EndOrderedGroup(_items.Values[_getChangeBatchCurrent - 1].GlobalId, _knowledge);

    // When all items in the metadata store have been enumerated, set this batch as the
    // last batch.
    if (_getChangeBatchCurrent == _items.Count)
    {
        changeBatch.SetLastBatch();
    }

    return changeBatch;
}

Méthode ProcessChangeBatch

Après que Sync Framework a obtenu un lot de modifications du fournisseur de source en appelant sa méthode GetChangeBatch, Sync Framework appelle ProcessChangeBatch sur le fournisseur de destination. Cette méthode applique les modifications au réplica de destination. Cette méthode est appelée une fois pour chaque lot de modifications récupéré de GetChangeBatch sur le fournisseur de source. Cette implémentation utilise l'objet de magasin des métadonnées pour obtenir des informations de versions locales pour les éléments du fournisseur de source. Elle crée ensuite un objet NotifyingChangeApplier implémenté par Sync Framework et appelle sa méthode ApplyChanges.

public override void ProcessChangeBatch(ConflictResolutionPolicy resolutionPolicy, ChangeBatch sourceChanges, object changeDataRetriever, SyncCallbacks syncCallbacks, SyncSessionStatistics sessionStatistics)
{
    // Use the metadata store to get the local versions of changes received from the source provider.
    IEnumerable<ItemChange> destVersions = _itemStore.ContactReplicaMetadata.GetLocalVersions(sourceChanges);

    // Use a NotifyingChangeApplier object to process the changes. Note that this object is passed as the INotifyingChangeApplierTarget
    // object that will be called to apply changes to the item store.
    NotifyingChangeApplier changeApplier = new NotifyingChangeApplier(IdFormats);
    changeApplier.ApplyChanges(resolutionPolicy, sourceChanges, (IChangeDataRetriever)changeDataRetriever, destVersions,
        _itemStore.ContactReplicaMetadata.GetKnowledge(), _itemStore.ContactReplicaMetadata.GetForgottenKnowledge(), 
        this, _sessionContext, syncCallbacks);
}

L'objet de magasin des métadonnées retourne les informations de versions locales pour les éléments du fournisseur de source à l'aide de GetLocalVersions. Cette implémentation énumère les modifications envoyées dans le lot de modifications du fournisseur de source. Si un élément se trouve dans les métadonnées de destination, ses informations de version sont ajoutées à une liste de modifications contenant les informations de version. Si un élément n'existe pas dans les métadonnées de destination, il est signalé comme un élément inconnu dans la liste des versions locales.

public override IEnumerable<ItemChange> GetLocalVersions(ChangeBatch sourceChanges)
{
    List<ItemChange> localVersions = new List<ItemChange>();

    // Enumerate the source changes and retrieve the destination version for each source change. 
    foreach (ItemChange srcItem in sourceChanges)
    {
        ItemChange localVer;

        // When the source item exists in the destination metadata store, retrieve the destination version of the item.
        if (_items.ContainsKey(srcItem.ItemId))
        {
            XmlItemMetadata localMeta = _items[srcItem.ItemId];
            ChangeKind kind = (localMeta.IsDeleted) ? ChangeKind.Deleted : ChangeKind.Update;
            localVer = new ItemChange(IdFormats, ReplicaId, srcItem.ItemId, kind, localMeta.CreationVersion, localMeta.ChangeVersion);
        }
        // When the source item does not exist in the destination metadata store, create a new change with unknown
        // version information.
        else
        {
            localVer = new ItemChange(IdFormats, ReplicaId, srcItem.ItemId, ChangeKind.UnknownItem, SyncVersion.UnknownVersion, SyncVersion.UnknownVersion);
        }

        localVersions.Add(localVer);
    }

    return localVersions;
}

Méthode EndSession

Une fois que le fournisseur de source a envoyé son dernier lot de modifications et que le fournisseur de destination a appliqué les modifications dans son magasin de données, Sync Framework appelle EndSession sur les fournisseurs de source et de destination. Cette méthode informe un fournisseur qu'il quitte une session de synchronisation et qu'il doit libérer toutes les ressources associées à la session. Cette implémentation libère l'objet d'état de session qu'il a stocké dans l'appel BeginSession ou lève SyncInvalidOperationException si le fournisseur ne s'est pas précédemment joint à une session de synchronisation.

public override void EndSession(SyncSessionContext syncSessionContext)
{
    // If this object is not in a session, throw an exception.
    if (null == _sessionContext)
    {
        throw new SyncInvalidOperationException();            
    }

    _sessionContext = null;
}

Méthodes qui ne sont pas implémentées

Les méthodes suivantes ne sont pas requises, car cet exemple ne supprime jamais des éléments marqués comme supprimés dans le magasin des métadonnées. Ces méthodes peuvent lever NotImplementedException :

Implémentation d'INotifyingChangeApplierTarget

Cette interface est fournie à Sync Framework lorsque le fournisseur de destination appelle la méthode ApplyChanges, généralement dans la méthode ProcessChangeBatch. INotifyingChangeApplierTarget contient des méthodes appelées lors de l'application des modifications. Ces méthodes sont appelées uniquement sur le fournisseur de destination.

Déclaration d'INotifyingChangeApplierTarget

Ajoutez INotifyingChangeApplierTarget à la liste d'héritage de classe.

class ContactsProviderXmlMetadataNoChangeUnits : KnowledgeSyncProvider
    , INotifyingChangeApplierTarget

Ajoutez les méthodes INotifyingChangeApplierTarget à la classe.

Propriété IdFormats

Sync Framework appelle IdFormats pour récupérer le schéma du format de l'ID du fournisseur. Cet exemple utilise la même classe pour implémenter KnowledgeSyncProvider et INotifyingChangeApplierTarget. Par conséquent, cette implémentation est la même que pour la propriété IdFormats de KnowledgeSyncProvider ci-dessus.

GetNextTickCount

Sync Framework appelle GetNextTickCount pour incrémenter et récupérer le nombre de cycles du réplica. Cette implémentation appelle la méthode GetNextTickCount de l'objet de magasin des métadonnées.

public ulong GetNextTickCount()
{
    return _itemStore.ContactReplicaMetadata.GetNextTickCount();
}

L'implémentation du magasin des métadonnées de GetNextTickCount incrémente le nombre de cycles du réplica et le retourne.

public override ulong GetNextTickCount()
{
    return ++_tickCount;
}

SaveItemChange

Pendant l'application des modifications, Sync Framework appelle SaveItemChange pour chaque modification à appliquer au réplica de destination. Cette implémentation met à jour le magasin d'éléments et le magasin des métadonnées pour chaque type de modification reçue. Lorsqu'un élément est créé ou mis à jour, les données d'élément sont reçues dans la propriété ChangeData du paramètre context. La propriété ChangeData contient l'object retourné par la méthode LoadChangeData du fournisseur de source. Après avoir appliqué la modification, la connaissance de destination mise à jour est stockée.

public void SaveItemChange(SaveChangeAction saveChangeAction, ItemChange change, SaveChangeContext context)
{
    switch (saveChangeAction)
    {
        // Update the item store and metadata store when an item is created or updated.
        case SaveChangeAction.Create:
        case SaveChangeAction.UpdateVersionAndData:
        {
            try
            {
                _itemStore.UpdateContactFromSync(change, (string)context.ChangeData);
            }
            catch (Exception ex)
            {
                RecoverableErrorData errData = new RecoverableErrorData(ex);
                context.RecordRecoverableErrorForItem(errData);
            }
            break;
        }

        // Update only the version of this item in the metadata store.
        case SaveChangeAction.UpdateVersionOnly:
        {
            try
            {
                _itemStore.UpdateContactVersion(change.ItemId, change.ChangeVersion);
            }
            catch (Exception ex)
            {
                RecoverableErrorData errData = new RecoverableErrorData(ex);
                context.RecordRecoverableErrorForItem(errData);
            }
            break;
        }

        // Delete the item from the item store and store a tombstone for it in the metadata store.
        case SaveChangeAction.DeleteAndStoreTombstone:
        {
            try
            {
                _itemStore.DeleteContactFromSync(change.ItemId, change.ChangeVersion);
            }
            catch (Exception ex)
            {
                RecoverableErrorData errData = new RecoverableErrorData(ex);
                context.RecordRecoverableErrorForItem(errData);
            }

            break;
        }

        // Neither merging of data nor removing tombstones is supported.
        case SaveChangeAction.UpdateVersionAndMergeData:
        case SaveChangeAction.DeleteAndRemoveTombstone:
        {
            throw new NotImplementedException();
        }

        default:
        {
            throw new ArgumentOutOfRangeException();
        }
    }

    // Save the knowledge in the metadata store as each change is applied. Saving knowledge as each change is applied is 
    // not required. It is more robust than saving the knowledge only after each change batch, because if synchronization is interrupted 
    // before the end of a change batch, the knowledge will still reflect all of the changes applied. However, it is less efficient because 
    // knowledge must be stored more frequently.
    SyncKnowledge knowledge;
    ForgottenKnowledge forgottenKnowledge;
    context.GetUpdatedDestinationKnowledge(out knowledge, out forgottenKnowledge);
    _itemStore.ContactReplicaMetadata.SetKnowledge(knowledge);
}

Dans les exemples suivants, _ContactItemMetaList contient des objets ItemMetadata.

La méthode UpdateContactFromSync du magasin de contacts met à jour le contact spécifié. Si le contact n'existe pas, un nouveau contact est créé et ajouté au magasin de contacts. Le magasin des métadonnées est également mis à jour pour refléter les modifications apportées au magasin de contacts.

public void UpdateContactFromSync(ItemChange itemChange, string changeData)
{
    // If the item does not exist, create a new contact and add it to the contact and metadata store.
    if (!_ContactList.ContainsKey(itemChange.ItemId))
    {
        Contact contact = new Contact();
        ItemMetadata newItemMeta = _ContactReplicaMetadata.CreateItemMetadata(itemChange.ItemId,
            itemChange.CreationVersion);

        _ContactList.Add(newItemMeta.GlobalId, contact);
        _ContactItemMetaList.Add(newItemMeta.GlobalId, newItemMeta);
    }

    // Update the specified contact in the contact store. changeData is the contact data returned by the
    // IChangeDataRetriever.LoadChangeData method of the source provider.
    _ContactList[itemChange.ItemId].FromString(changeData);

    // Get the metadata for the specified item.
    ItemMetadata itemMeta = _ContactItemMetaList[itemChange.ItemId];

    // Update the index fields for the item. This implementation defines an index that uniquely identifies each contact.
    // The index consists of the first name, last name, and phone number of the contact.
    itemMeta.SetCustomField(FirstNameField, _ContactList[itemChange.ItemId].FirstName);
    itemMeta.SetCustomField(LastNameField, _ContactList[itemChange.ItemId].LastName);
    itemMeta.SetCustomField(PhoneNumberField, _ContactList[itemChange.ItemId].PhoneNumber);

    // Update the version for the change.
    itemMeta.ChangeVersion = itemChange.ChangeVersion;
}

La méthode UpdateContactVersion du magasin de contacts met à jour les métadonnées de version pour l'élément spécifié.

public void UpdateContactVersion(SyncId itemId, SyncVersion itemVersion)
{
    // Update the version metadata for the specified item.
    _ContactItemMetaList[itemId].ChangeVersion = itemVersion;
}

La méthode DeleteContactFromSync du magasin de contacts supprime l'élément du magasin de contacts et le marque comme supprimé dans le magasin des métadonnées.

public void DeleteContactFromSync(SyncId itemId, SyncVersion version)
{
    if (_ContactList.ContainsKey(itemId))
    {
        // Remove the item from the contact store.
        _ContactList.Remove(itemId);

        // Mark the item as deleted in the metadata store.
        ItemMetadata itemMeta = _ContactItemMetaList[itemId];
        itemMeta.MarkAsDeleted(version);

        // Change the first index field so the index fields don't collide with future items.
        itemMeta.SetCustomField(FirstNameField, itemId.ToString());

        // Move the metadata for the deleted item to a separate list. 
        // The deleted item metadata must be kept so that it can be committed when
        // SaveChanges is called.
        _ContactDeletedItemMetaList.Add(itemMeta);
        _ContactItemMetaList.Remove(itemId);
    }
    else 
    {
        // An item marked as deleted has been received as part of synchronization, but it does not exist in
        // the item store. Create a tombstone for it in the metadata store.
        ItemMetadata itemMeta = _ContactReplicaMetadata.CreateItemMetadata(itemId, version);
        itemMeta.MarkAsDeleted(version);

        // Clear the index fields so they don't collide with future items.
        itemMeta.SetCustomField(FirstNameField, itemId.ToString());

        _ContactDeletedItemMetaList.Add(itemMeta);
    }
}

StoreKnowledgeForScope

Après avoir traité chaque lot de modifications, Sync Framework appelle StoreKnowledgeForScope afin que le fournisseur de destination puisse enregistrer la connaissance qui contient les nouvelles modifications. Cette implémentation enregistre les objets de connaissance dans le magasin des métadonnées et remplace la connaissance existante précédente. Les modifications apportées au magasin de contacts et au magasin des métadonnées pendant le traitement du lot de modifications sont validées dans les fichiers du disque.

public void StoreKnowledgeForScope(SyncKnowledge knowledge, ForgottenKnowledge forgottenKnowledge)
{
    _itemStore.ContactReplicaMetadata.SetKnowledge(knowledge);

    // Commit changes made to the in-memory item store to the file on disk.
    _itemStore.SaveContactChanges();

    // Commit changes made to the in-memory metadata store to the file on disk.
    _itemStore.SaveMetadataChanges();
}

La méthode SaveMetadataChanges du magasin de contacts valide les modifications apportées au magasin des métadonnées dans le fichier du disque.

public void SaveMetadataChanges()
{
    // A transaction is required for saving changes to the metadata store.
    _ContactMetadataStore.BeginTransaction(IsolationLevel.ReadCommitted);

    // Enumerate the deleted items list.
    if (null != _ContactDeletedItemMetaList)
    {
        foreach (ItemMetadata contactMeta in _ContactDeletedItemMetaList)
        {
            // Save the deleted item metadata to the metadata store.
            _ContactReplicaMetadata.SaveItemMetadata(contactMeta);
        }
    }

    // Save renamed items first to avoid collisions in the metadata store.
    foreach (SyncId itemId in _ContactRenameList)
    {
        _ContactReplicaMetadata.SaveItemMetadata(_ContactItemMetaList[itemId]);            
    }

    // Enumerate the active contacts.
    for (int iCon = 0; iCon < _ContactItemMetaList.Count; iCon++)
    { 
        // Save the item metadata to the metadata store.
        _ContactReplicaMetadata.SaveItemMetadata(_ContactItemMetaList.Values[iCon]);
    }

    // Save the replica metadata to the metadata store.
    _ContactReplicaMetadata.SaveReplicaMetadata();

    // Commit the metadata store transaction.
    _ContactMetadataStore.CommitTransaction();
}

Méthodes qui ne sont pas implémentées

Les méthodes suivantes ne sont pas requises pour les scénarios de synchronisation de base et peuvent lever NotImplementedException :

Implémentation d'IChangeDataRetriever

IChangeDataRetriever est retourné à Sync Framework par le fournisseur de source en réponse à l'appel de GetChangeBatch. IChangeDataRetriever est envoyé au fournisseur de destination dans l'appel de ProcessChangeBatch, où il est généralement passé à la méthode ApplyChanges d'un applicateur de modifications. L'applicateur de modifications appelle ensuite LoadChangeData pour obtenir un object qui représente les données d'élément. L'applicateur de modifications passe cette interface à la méthode SaveItemChange ou SaveChangeWithChangeUnits du fournisseur de destination. Le fournisseur de destination utilise cet object pour récupérer les données d'élément pour les éléments nouveaux ou modifiés, puis applique les données d'élément au réplica de destination.

Déclaration d'IChangeDataRetriever

Ajoutez IChangeDataRetriever à la liste d'héritage de classe.

class ContactsProviderXmlMetadataNoChangeUnits : KnowledgeSyncProvider
    , INotifyingChangeApplierTarget
    , IChangeDataRetriever

Ajoutez les méthodes IChangeDataRetriever à la classe.

Propriété IdFormats

Sync Framework appelle IdFormats pour récupérer le schéma du format de l'ID du fournisseur. Cet exemple utilise la même classe pour implémenter KnowledgeSyncProvider et IChangeDataRetriever. Par conséquent, cette implémentation est la même que pour la propriété IdFormats de KnowledgeSyncProvider ci-dessus.

Méthode LoadChangeData

Pendant l'application des modifications, Sync Framework appelle LoadChangeData pour obtenir un object que le fournisseur de destination peut utiliser pour récupérer les données d'élément. Cette implémentation retourne les données de contact sérialisées en tant que chaîne.

public object LoadChangeData(LoadChangeContext loadChangeContext)
{
    // Return the specified contact serialized as a string.
    return _itemStore.ContactList[loadChangeContext.ItemChange.ItemId].ToString();
}

Étapes suivantes

Vous pouvez ensuite créer une application qui peut héberger la session de synchronisation et la connecter au fournisseur. Pour plus d'informations sur la procédure à suivre, consultez Procédure : créer une application de synchronisation non managée.

Vous pouvez également améliorer le fournisseur pour filtrer les éléments ou les unités de modification synchronisés. Pour plus d'informations sur le filtrage, consultez Filtrage des données de synchronisation.

Vous pouvez également améliorer le fournisseur pour gérer des unités de modification. Pour plus d'informations sur les unités de modification, consultez Synchronisation des unités de modification.

Vous pouvez également créer une banque de métadonnées personnalisée. Pour plus d'informations sur la gestion des métadonnées de synchronisation, consultez Gestion des métadonnées pour les fournisseurs standard.