INotifyingChangeApplierTarget.SaveChangeWithChangeUnits Método

Cuando se invalida en una clase derivada, guarda un cambio de elemento que contiene cambios de las unidades de cambio en el almacén de elementos.

Espacio de nombres: Microsoft.Synchronization
Ensamblado: Microsoft.Synchronization (en microsoft.synchronization.dll)

Sintaxis

'Declaración
Sub SaveChangeWithChangeUnits ( _
    change As ItemChange, _
    context As SaveChangeWithChangeUnitsContext _
)
'Uso
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
)

Parámetros

• change
  Cambio de elemento que se va a aplicar.

• context
  Información sobre el cambio que se va a aplicar.

Notas

Notas a los implementadores: Cuando la acción contenida en context es Create, el cambio de elemento se debe guardar atómicamente. Esto significa que todas las unidades de cambio se deben guardar correctamente o se debe descartar todo el cambio de elemento. Si se guardan algunas de las unidades de cambio y no otras, se puede producir daños en los datos. Si se llama a RecordRecoverableErrorForChangeUnit y context es Create, RecordRecoverableErrorForChangeUnit produce una excepción CreateFailuresMustBeForEntireItemException. Si se cancela la sincronización durante este método y el proveedor ha aplicado algunas de las unidades de cambio, el proveedor debe llamar a RecordRecoverableErrorForChangeUnit en todas las unidades de cambio que no se han aplicado.

Ejemplo

En el ejemplo siguiente se muestra cómo controlar algunos de los valores SaveChangeAction más comunes del método 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);
}

Vea también

Referencia

INotifyingChangeApplierTarget Interfaz
INotifyingChangeApplierTarget Miembros
Microsoft.Synchronization Espacio de nombres