Compartir a través de

Crear un proveedor de sincronización administrado

  • Artículo

En este tema se describe cómo utilizar un lenguaje administrado para crear un proveedor de sincronización de Sync Framework que sincronice los datos de un almacén de datos personalizado.

En este tema se presupone que se dispone de un conocimiento básico de C# y conceptos de Microsoft .NET Framework.

Los ejemplos de este tema se centran en las siguientes clases e interfaces de Sync Framework:

Introducción a los proveedores de sincronización

Un proveedor de sincronización es un componente de software que representa una réplica durante la sincronización. De esta forma, la réplica puede sincronizar sus datos con otras réplicas. Para que tenga lugar una sincronización, una aplicación crea en primer lugar un objeto SyncOrchestrator, lo conecta a dos objetos SyncProvider y, a continuación, inicia la sincronización. Uno de los proveedores representa la réplica de origen. La réplica de origen proporciona los metadatos para los elementos cambiados a través de su método GetChangeBatch y los datos de elemento a través de un objeto IChangeDataRetriever. El otro proveedor representa la réplica de destino. La réplica de destino recibe los metadatos de los elementos cambiados a través de su método ProcessChangeBatch y aplica los cambios en su almacén de elementos utilizando un objeto NotifyingChangeApplier suministrado por Sync Framework junto con su propio objeto INotifyingChangeApplierTarget.

Para obtener más información acerca del rol del proveedor de sincronización, vea Implementar un proveedor estándar personalizado.

Requisitos de la generación

Ejemplo

El código de ejemplo de este tema muestra cómo implementar los métodos de clase y de interfaz básicos que se requieren para que una réplica participe en una comunidad de sincronización de Sync Framework, como origen y como destino. La réplica de este ejemplo es un archivo de texto que almacena información de contacto en forma de lista de valores separados por comas. Los elementos para sincronizar son los contactos que contiene este archivo. Este ejemplo también utiliza un almacén de metadatos personalizado que se implementa utilizando la API de Metadata Storage Service. Para obtener más información acerca de Metadata Storage Service, vea Sync Framework Metadata Storage Service.

En los ejemplos siguientes, _itemStore representa un objeto que contiene el almacén de elementos y el almacén de metadatos.

Implementar SyncProvider y KnowledgeSyncProvider

El punto de entrada principal al proveedor es la clase SyncProvider. Esta clase está pensada para actuar como clase base para otras clases de proveedor más eficaces. Este ejemplo utiliza la clase KnowledgeSyncProvider.

Declarar la interfaz KnowledgeSyncProvider

Agregue KnowledgeSyncProvider a la lista de herencias de clases.

class ContactsProviderXmlMetadataNoChangeUnits : KnowledgeSyncProvider

Agregue los métodos SyncProvider y KnowledgeSyncProvider a la clase.

Propiedad idFormats

Sync Framework llama a IdFormats tanto en el proveedor de destino como en el de origen cuando se llama a Synchronize en el objeto SyncOrchestrator. La propiedad IdFormats devuelve el esquema de formato de identificadores que utiliza el proveedor. Este esquema debe ser el mismo para ambos proveedores. En este ejemplo se definen los tamaños para los identificadores de elemento que contienen un SyncGlobalId, los identificadores de réplica que contienen la ruta de acceso absoluta de la réplica y los identificadores de la unidad de cambio que son miembros de una enumeración.

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étodo BeginSession

Sync Framework llama a BeginSession en el proveedor de origen y en el de destino antes de llamar a cualquier otro método. Este método informa a un proveedor de que se está uniendo a una sesión de sincronización y le pasa un objeto que contiene información del estado de la sesión. Esta implementación almacena el objeto de estado de la sesión o produce una excepción SyncInvalidOperationException si el proveedor ya se ha unido a una sesión de sincronización.

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étodo GetSyncBatchParameters

Sync Framework llama a GetSyncBatchParameters en el proveedor de destino. Este método recupera el número de cambios que el proveedor de origen debería incluir en un lote de cambios y obtiene el conocimiento actual del proveedor de destino. Esta implementación extrae el conocimiento del almacén de metadatos y establece el tamaño del lote en 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();
}

El objeto de almacén de metadatos devuelve el conocimiento actual de la réplica mediante GetKnowledge. Esta implementación crea un nuevo objeto SyncKnowledge siempre y cuando la réplica no contenga aún conocimientos y establece el contador del conocimiento según el contador actual de la 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étodo GetChangeBatch

La sesión de sincronización se inicia realmente cuando Sync Framework llama al método GetChangeBatch en el proveedor de origen. Este método recupera un lote de cambios para enviar al proveedor de destino y también devuelve la interfaz del recuperador de datos. Sync Framework se sirve de la interfaz de recuperador de datos para obtener un object que utilice el proveedor de destino para recuperar los datos de elemento correspondientes a los cambios que se aplicaron a la réplica de destino. Sync Framework llama a GetChangeBatch varias veces hasta que se envía el último lote. El proveedor de origen indica que un lote es el último llamando al método SetLastBatch en el objeto de lote de cambios. Esta implementación delega la tarea de enumeración de los cambios al objeto de almacén de metadatos. El objeto de proveedor implementa IChangeDataRetriever; por consiguiente, se devuelve en el parámetro 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);
}

El objeto de almacén de metadatos devuelve un lote de cambios mediante GetChangeBatch. Esta implementación almacena elementos en el almacén de metadatos en forma de lista de objetos ItemMetadata, los cuales se ordenan por identificador de elemento. Se enumeran los elementos y se agrega un cambio a un grupo ordenado en el objeto de lote de cambios si tal cambio no se encuentra en el conocimiento de destino. Cuando se hayan enumerado todos los elementos en el almacén de metadatos, se llama a SetLastBatch en el lote de cambios.

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étodo ProcessChangeBatch

Una vez que Sync Framework obtenga un lote de cambios del proveedor de origen llamando a su método GetChangeBatch, Sync Framework llamará al método ProcessChangeBatch en el proveedor de destino. Este método aplica los cambios a la réplica de destino. Este método se llama una vez para cada lote de cambios que se recupera desde GetChangeBatch en el proveedor de origen. Esta implementación utiliza el objeto de almacén de metadatos para obtener la información sobre la versión local para los elementos del proveedor de origen. A continuación, crea un objeto NotifyingChangeApplier implementado por Sync Framework y llama a su método 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);
}

El objeto de almacén de metadatos devuelve la información sobre la versión local para los elementos del proveedor de origen mediante GetLocalVersions. Esta implementación enumera los cambios enviados en el lote de cambios del proveedor de origen. Si un elemento está en los metadatos de destino, su información de versión se agrega a la lista de cambios con la información sobre la versión. Si un elemento no existe en los metadatos de destino, se marca como elemento desconocido en la lista de versiones 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étodo EndSession

Una vez que el proveedor de origen envía su último lote y el proveedor de destino ha aplicado los cambios a su almacén de datos, Sync Framework llama a EndSession tanto en el proveedor de origen como en el de destino. Este método informa a un proveedor de que está dejando una sesión de sincronización y que debería liberar cualquier recurso que esté asociado a la misma. Esta implementación libera el objeto de estado de la sesión que almacenó en la llamada a BeginSession o produce una excepción SyncInvalidOperationException si el proveedor no se unió previamente a una sesión de sincronización.

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étodos que no se implementan

No se requieren los métodos siguientes porque este ejemplo nunca quita los elementos marcados como eliminados en el almacén de metadatos. Estos métodos pueden producir una excepción NotImplementedException:

Implementar INotifyingChangeApplierTarget

Esta interfaz se proporciona a Sync Framework cuando el proveedor de destino llama al método ApplyChanges, normalmente en el método ProcessChangeBatch. INotifyingChangeApplierTarget contiene los métodos a los que se llama durante la aplicación de cambios. Solo se llama a estos métodos en el proveedor de destino.

Declarar INotifyingChangeApplierTarget

Agregue INotifyingChangeApplierTarget a la lista de herencias de clases.

class ContactsProviderXmlMetadataNoChangeUnits : KnowledgeSyncProvider
    , INotifyingChangeApplierTarget

Agregue los métodos INotifyingChangeApplierTarget a su clase.

Propiedad idFormats

Sync Framework llama a IdFormats para recuperar el esquema de formato de identificador del proveedor. En este ejemplo se utiliza la misma clase para implementar KnowledgeSyncProvider e INotifyingChangeApplierTarget. Por consiguiente, esta implementación es la misma que la de la propiedad IdFormats de la clase KnowledgeSyncProvider anterior.

GetNextTickCount

Sync Framework llama a GetNextTickCount para incrementar y recuperar el contador para la réplica. Esta implementación llama al método GetNextTickCount del objeto de almacén de metadatos.

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

La implementación del almacén de metadatos de GetNextTickCount incrementa el contador de la réplica y lo devuelve.

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

SaveItemChange

Durante la aplicación de los cambios, Sync Framework llama a SaveItemChange para cada cambio que se va a aplicar a la réplica de destino. Esta implementación actualiza el almacén de elementos y el almacén de metadatos para cada tipo de cambio recibido. Cuando un elemento se crea o actualiza, los datos de elemento se reciben en la propiedad ChangeData del parámetro context. La propiedad ChangeData contiene el object devuelto desde el método LoadChangeData del proveedor de origen. Una vez se ha aplicado el cambio, el conocimiento de destino actualizado se almacena.

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);
}

En los ejemplos siguientes, _ContactItemMetaList contiene objetos ItemMetadata.

El método UpdateContactFromSync del almacén de contactos actualiza el contacto especificado. Si el contacto no existe, se creará un contacto nuevo y se agregará al almacén de contactos. El almacén de metadatos también se actualiza para reflejar los cambios en el almacén de contactos.

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;
}

El método UpdateContactVersion del almacén de contactos actualiza los metadatos de la versión correspondientes al elemento especificado.

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

El método DeleteContactFromSync del almacén de contactos quita el elemento de este almacén y lo marca como eliminado en el almacén de metadatos.

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

Después de procesar cada lote de cambios, Sync Framework llama a StoreKnowledgeForScope para que el proveedor de destino pueda guardar el conocimiento que contienen los cambios nuevos. Esta implementación guarda los objetos de conocimiento en el almacén de metadatos y sobrescribe el conocimiento existente previamente. Los cambios realizados en el almacén de contactos y en el almacén de metadatos durante el procesamiento del lote de cambios se confirman para los archivos en el disco.

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();
}

El método SaveMetadataChanges del almacén de contactos confirma los cambios realizados al almacén de metadatos para el archivo en el disco.

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étodos que no se implementan

Los métodos siguientes no se requieren en escenarios de sincronización básicos y pueden producir la excepción NotImplementedException:

Implementar IChangeDataRetriever

El proveedor de origen devuelve IChangeDataRetriever a Sync Framework en respuesta a la llamada. GetChangeBatch. IChangeDataRetriever se envía al proveedor de destino en la llamada a ProcessChangeBatch, donde se suele pasar al método ApplyChanges de un aplicador de cambios. A continuación, el aplicador de cambios llama a LoadChangeData para obtener un object que represente los datos de elemento. El aplicador de cambios pasa esta interfaz al método SaveItemChange o SaveChangeWithChangeUnits del proveedor de destino. El proveedor de destino utiliza este object para recuperar los datos de elemento para los elementos nuevos o cambiados, y aplica los datos de elemento a la réplica de destino.

Declarar IChangeDataRetriever

Agregue IChangeDataRetriever a la lista de herencias de clases.

class ContactsProviderXmlMetadataNoChangeUnits : KnowledgeSyncProvider
    , INotifyingChangeApplierTarget
    , IChangeDataRetriever

Agregue los métodos IChangeDataRetriever a la clase.

Propiedad idFormats

Sync Framework llama a IdFormats para recuperar el esquema de formato de identificador del proveedor. En este ejemplo se utiliza la misma clase para implementar KnowledgeSyncProvider e IChangeDataRetriever. Por consiguiente, esta implementación es la misma que la de la propiedad IdFormats de la clase KnowledgeSyncProvider anterior.

Método LoadChangeData

Durante la aplicación de los cambios, Sync Framework llama a LoadChangeData para obtener un object que el proveedor de destino puede utilizar para recuperar los datos de elemento. Esta implementación devuelve los datos de contacto serializados como una cadena.

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

Pasos siguientes

A continuación, es posible que desee crear una aplicación que pueda hospedar la sesión de sincronización y conectarla al proveedor. Para obtener información sobre cómo hacer esto, vea Crear una aplicación de sincronización no administrada.

También puede mejorar el proveedor para filtrar los elementos o unidades de cambio que se sincronizan. Para obtener más información sobre los filtros, vea Filtrar los datos de sincronización.

También puede mejorar el proveedor para que administre unidades de cambio. Para obtener más información acerca de las unidades de cambio, vea Sincronizar las unidades de cambio.

También podría desear crear un almacén de metadatos personalizado. Para obtener más información sobre cómo controlar los metadatos de sincronización, vea Administrar metadatos para proveedores estándar.

Vea también

Referencia

SyncProvider
KnowledgeSyncProvider
INotifyingChangeApplierTarget
IChangeDataRetriever
NotifyingChangeApplier

Conceptos

Implementar un proveedor estándar personalizado
Componentes principales de Sync Framework