Méthode INotifyingChangeApplierTarget.SaveChangeWithChangeUnits

En cas de substitution dans une classe dérivée, enregistre une modification d'élément contenant les modifications d'unité de modification dans le magasin d'éléments.

Espace de noms: Microsoft.Synchronization
Assembly: Microsoft.Synchronization (dans microsoft.synchronization.dll)

Syntaxe

'Déclaration
Sub SaveChangeWithChangeUnits ( _
    change As ItemChange, _
    context As SaveChangeWithChangeUnitsContext _
)
'Utilisation
Dim instance As INotifyingChangeApplierTarget
Dim change As ItemChange
Dim context As SaveChangeWithChangeUnitsContext

instance.SaveChangeWithChangeUnits(change, context)

void SaveChangeWithChangeUnits (
    ItemChange change,
    SaveChangeWithChangeUnitsContext context
)

void SaveChangeWithChangeUnits (
    ItemChange^ change, 
    SaveChangeWithChangeUnitsContext^ context
)

void SaveChangeWithChangeUnits (
    ItemChange change, 
    SaveChangeWithChangeUnitsContext context
)

function SaveChangeWithChangeUnits (
    change : ItemChange, 
    context : SaveChangeWithChangeUnitsContext
)

Paramètres

• change
  Modification d'élément à appliquer.

• context
  Informations relatives à la modification à appliquer.

Notes

Remarques à l'attention des implémenteurs : Lorsque l'action contenue dans context est Create, la modification d'élément doit être enregistrée atomiquement. Cela signifie que toutes les unités de modification doivent être enregistrées avec succès ou que la totalité de la modification d'élément doit être ignorée. Le fait d'enregistrer certaines unités de modification et de ne pouvoir enregistrer certaines autres peut provoquer un endommagement des données. Lorsque RecordRecoverableErrorForChangeUnit est appelé et que context est Create, RecordRecoverableErrorForChangeUnit lève CreateFailuresMustBeForEntireItemException. Si la synchronisation est annulée pendant cette méthode et si le fournisseur a appliqué certaines unités de modification, ce dernier doit appeler RecordRecoverableErrorForChangeUnit sur toutes les unités de modification qui ne sont pas appliquées.

Exemple

L'exemple suivant montre comment gérer certaines des valeurs SaveChangeAction les plus courantes dans la méthode SaveChangeWithChangeUnits.

Public Sub SaveChangeWithChangeUnits(ByVal change As ItemChange, ByVal context As SaveChangeWithChangeUnitsContext) Implements INotifyingChangeApplierTarget.SaveChangeWithChangeUnits
    ' Enumerate the change units received and apply them by using the specified action.
    For Each cuChange As ChangeUnitChange In change.ChangeUnitChanges
        Select Case context.GetActionForChangeUnit(cuChange)
            Case SaveChangeAction.Create, SaveChangeAction.UpdateVersionAndData
                If True Then
                    ' Update the item store and metadata store for the specified change unit.
                    Try
                        Dim cuData As String = DirectCast(context.ChangeData, String())(cuChange.ChangeUnitId.GetByteId())
                        _ContactStore.UpdateContactFromSync(change, cuChange, cuData)
                    Catch ex As Exception
                        Dim errData As New RecoverableErrorData(ex)
                        context.RecordRecoverableErrorForChangeUnit(cuChange, errData)
                    End Try
                    Exit Select
                End If
            Case SaveChangeAction.UpdateVersionAndMergeData
                If True Then
                    ' Merge actions are not supported by this implementation.
                    Throw New NotImplementedException("UpdateVersionAndMergeData is not supported.")
                End If
            Case SaveChangeAction.UpdateVersionOnly
                If True Then
                    ' Update only the version of this change unit in the metadata store.
                    Try
                        _ContactStore.UpdateContactVersion(change.ItemId, cuChange.ChangeUnitId, cuChange.ChangeUnitVersion)
                    Catch ex As Exception
                        Dim errData As New RecoverableErrorData(ex)
                        context.RecordRecoverableErrorForChangeUnit(cuChange, errData)
                    End Try
                    Exit Select
                End If
            Case SaveChangeAction.DeleteAndRemoveTombstone, SaveChangeAction.DeleteAndStoreTombstone
                If True Then
                    ' Delete actions are handled in SaveItemChange, so throw an exception.
                    Throw New InvalidOperationException("SaveChangeWithChangeUnits received a delete action.")
                End If
            Case Else
                If True Then
                    Throw New ArgumentOutOfRangeException("SaveChangeWithChangeUnits received an out-of-range action.")
                End If
        End Select
    Next

    ' Use the metadata storage service to save the knowledge 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.
    Dim updatedKnowledge As SyncKnowledge = Nothing
    Dim updatedForgottenKnowledge As ForgottenKnowledge = Nothing
    context.GetUpdatedDestinationKnowledge(updatedKnowledge, updatedForgottenKnowledge)
    _ContactStore.ContactReplicaMetadata.SetKnowledge(updatedKnowledge)
End Sub

public void SaveChangeWithChangeUnits(ItemChange change, SaveChangeWithChangeUnitsContext context)
{
    // Enumerate the change units received and apply them by using the specified action.
    foreach (ChangeUnitChange cuChange in change.ChangeUnitChanges)
    {
        switch (context.GetActionForChangeUnit(cuChange))
        {
            case SaveChangeAction.Create:
            case SaveChangeAction.UpdateVersionAndData:
            {
                // Update the item store and metadata store for the specified change unit.
                try
                {
                    string cuData = ((string[])context.ChangeData)[cuChange.ChangeUnitId.GetByteId()];
                    _ContactStore.UpdateContactFromSync(change, cuChange, cuData);
                }
                catch (Exception ex)
                {
                    RecoverableErrorData errData = new RecoverableErrorData(ex);
                    context.RecordRecoverableErrorForChangeUnit(cuChange, errData);
                }
                break;
            }
            case SaveChangeAction.UpdateVersionAndMergeData:
            {
                // Merge actions are not supported by this implementation.
                throw new NotImplementedException("UpdateVersionAndMergeData is not supported.");
            }
            case SaveChangeAction.UpdateVersionOnly:
            {
                // Update only the version of this change unit in the metadata store.
                try
                {
                    _ContactStore.UpdateContactVersion(change.ItemId, cuChange.ChangeUnitId, cuChange.ChangeUnitVersion);
                }
                catch (Exception ex)
                {
                    RecoverableErrorData errData = new RecoverableErrorData(ex);
                    context.RecordRecoverableErrorForChangeUnit(cuChange, errData);
                }
                break;
            }
            case SaveChangeAction.DeleteAndRemoveTombstone:
            case SaveChangeAction.DeleteAndStoreTombstone:
            {
                // Delete actions are handled in SaveItemChange, so throw an exception.
                throw new InvalidOperationException("SaveChangeWithChangeUnits received a delete action.");
            }
            default:
            {
                throw new ArgumentOutOfRangeException("SaveChangeWithChangeUnits received an out-of-range action.");
            }
        }
    }

    // Use the metadata storage service to save the knowledge 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 updatedKnowledge;
    ForgottenKnowledge updatedForgottenKnowledge;
    context.GetUpdatedDestinationKnowledge(out updatedKnowledge, out updatedForgottenKnowledge);
    _ContactStore.ContactReplicaMetadata.SetKnowledge(updatedKnowledge);
}

Voir aussi

Référence

Interface INotifyingChangeApplierTarget
Membres INotifyingChangeApplierTarget
Espace de noms Microsoft.Synchronization