/// <summary>
/// The way the current P2P provider works, versions are bumped up when conflicts are resolved on the server.
/// This would result in us sending the changes to the client on the next download request. We want
/// to not enumerate that change again. So one solution is to get the server knowledge after all changes are applied and then
/// project the knowledge of each conflict and add it as a positive exception to the updated client knowledge.
/// </summary>
/// <param name="updatedClientKnowledge">Knowledge that is going to be sent to the client in the response</param>
/// <param name="serverKnowledge">Server knowledge after applying changes</param>
private void AddConflictItemsKnowledgeToClientKnowledge(SyncKnowledge updatedClientKnowledge, SyncKnowledge serverKnowledge)
{
foreach (var conflict in _conflicts)
{
SyncId entitySyncId;
_conflictToSyncEntityIdMapping.TryGetValue(conflict, out entitySyncId);
if (null == entitySyncId)
{
throw new InvalidOperationException("SyncId is missing for a conflicting entity.");
}
// Create a new SyncKnowledge which only includes the server replica and set the local tickcount to
// the value of @@DBTS that was read before committing the Apply transaction.
var localKnowledge = new SyncKnowledge(serverKnowledge.GetSyncIdFormatGroup(),
serverKnowledge.ReplicaId,
_serverTickCountAfterResolvingAllConflicts);
// Add the knowledge of the conflicting item to the client knowledge. This will be
// sent back to the client. In the next download request, the conflicting item will
// not be enumerated since it is already contained in the knowledge.
// After enumeration the knowledge is compacted and the single item positive exception
// is removed.
// Note: If there are a lot of conflicts, the knowledge sent back to the client will be
// large for that one instance. However the size will is not very significant compared to the amount
// of data that is sent back in the response in the winning and the losing entities.
// The large knowledge in this case will be compacted on a subsequent download from the same client.
// Project the knowledge of the single row from the created knowledge and combine it with
// the updated client knowledge. This will add a positive exception since the server tickcount in the
// knowledge that is created (localKnowledge) is newer than that in the updatedClientKnowledge.
updatedClientKnowledge.Combine(localKnowledge.GetKnowledgeForItem(entitySyncId));
}
}
