INotifyingChangeApplierTarget.SaveChangeWithChangeUnits 方法

在派生类中重写时，将包含单位变更的变更的项变更保存到项存储区中。

命名空间: Microsoft.Synchronization
程序集: Microsoft.Synchronization（在 microsoft.synchronization.dll 中）

语法

声明
Sub SaveChangeWithChangeUnits ( _
    change As ItemChange, _
    context As SaveChangeWithChangeUnitsContext _
)
用法
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
)

参数

• change
  要应用的项变更。

• context
  有关要应用的变更的信息。

备注

实施者注意事项： 如果 context 中包含的操作为 Create，则必须以原子方式保存项变更。这意味着要么必须成功保存所有变更单位，要么必须放弃整个项变更。如果保存了某些变更单位但无法保存其他变更单位，则会导致数据损坏。 当调用 RecordRecoverableErrorForChangeUnit 并且 context 为 Create 时，RecordRecoverableErrorForChangeUnit 将引发 CreateFailuresMustBeForEntireItemException。 如果调用此方法的过程中取消了同步，并且提供程序已应用部分变更单位，则提供程序必须对所有未应用的变更单位调用 RecordRecoverableErrorForChangeUnit。

示例

以下示例说明如何处理 SaveChangeWithChangeUnits 方法中一些最常用的 SaveChangeAction 值。

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

请参阅

参考

INotifyingChangeApplierTarget 接口
INotifyingChangeApplierTarget 成员
Microsoft.Synchronization 命名空间