Procédure : créer un fournisseur simple managé
Cette rubrique décrit des parties importantes de l'exemple d'application "Sync101 using Simple Sync Provider" inclus avec le Kit de développement logiciel (SDK) Sync Framework. Cette application montre comment créer et synchroniser des fournisseurs simples basés sur les ancres et d'énumération complète. L'exemple d'application comprend trois classes :
MyFullEnumerationSimpleSyncProvider, qui dérive de FullEnumerationSimpleSyncProvider.
MyAnchorEnumerationSimpleSyncProvider, qui dérive de AnchorEnumerationSimpleSyncProvider.
MySimpleDataStore est un magasin de données d'élément en mémoire. MySimpleDataStore est une classe utilisée pour cet exemple ; elle ne fait pas partie de Sync Framework.
Les deux classes de fournisseur implémentent les interfaces de gestion des conflits suivantes : ISimpleSyncProviderConcurrencyConflictResolver et ISimpleSyncProviderConstraintConflictResolver.
Cette rubrique décrit les parties suivantes de l'application :
Création du magasin des métadonnées
Identification des éléments dans le magasin d'éléments et le magasin des métadonnées
Énumération des éléments et chargement des données
Synchronisation de deux fournisseurs
Gestion des conflits
Cette rubrique explique aussi brièvement comment filtrer des données et exécuter des suppressions en local uniquement.
Création du magasin des métadonnées
Chaque réplica requiert un magasin des métadonnées, qui, pour les fournisseurs simples, est une instance de SqlMetadataStore. L'exemple de code suivant spécifie des options pour un magasin dans le constructeur de MyFullEnumerationSimpleSyncProvider :
public MyFullEnumerationSimpleSyncProvider(string name, MySimpleDataStore store)
{
_name = name;
_store = store;
// Create a file to store metadata for all items and a file to store
// the replica ID.
_replicaMetadataFile = Environment.CurrentDirectory + "\\" + _name.ToString() + ".Metadata";
_replicaIdFile = Environment.CurrentDirectory + "\\" + _name.ToString() + ".Replicaid";
// Set ReplicaIdFormat to use a GUID as an ID, and ItemIdFormat to use a GUID plus
// an 8-byte prefix.
_idFormats = new SyncIdFormatGroup();
_idFormats.ItemIdFormat.IsVariableLength = false;
_idFormats.ItemIdFormat.Length = 24;
_idFormats.ReplicaIdFormat.IsVariableLength = false;
_idFormats.ReplicaIdFormat.Length = 16;
this.ItemConstraint += new EventHandler<SimpleSyncItemConstraintEventArgs>(OnItemConstraint);
this.ItemConflicting += new EventHandler<SimpleSyncItemConflictingEventArgs>(OnItemConflicting);
}
Public Sub New(ByVal name As String, ByVal store As MySimpleDataStore)
_name = name
_store = store
' Create a file to store metadata for all items and a file to store
' the replica ID.
_replicaMetadataFile = (Environment.CurrentDirectory & "\") + _name.ToString() & ".Metadata"
_replicaIdFile = (Environment.CurrentDirectory & "\") + _name.ToString() & ".Replicaid"
' Set ReplicaIdFormat to use a GUID as an ID, and ItemIdFormat to use a GUID plus
' an 8-byte prefix.
_idFormats = New SyncIdFormatGroup()
_idFormats.ItemIdFormat.IsVariableLength = False
_idFormats.ItemIdFormat.Length = 24
_idFormats.ReplicaIdFormat.IsVariableLength = False
_idFormats.ReplicaIdFormat.Length = 16
AddHandler Me.ItemConstraint, AddressOf HandleItemConstraint
AddHandler Me.ItemConflicting, AddressOf HandleItemConflicting
End Sub
L'exemple de code suivant crée le magasin :
private void InitializeMetadataStore()
{
SyncId id = ReplicaId;
// Create or open the metadata store, initializing it with the ID formats
// that are used to reference items and replicas.
if (!File.Exists(_replicaMetadataFile))
{
_metadataStore = SqlMetadataStore.CreateStore(_replicaMetadataFile);
}
else
{
_metadataStore = SqlMetadataStore.OpenStore(_replicaMetadataFile);
}
}
Private Sub InitializeMetadataStore()
Dim id As SyncId = ReplicaId
' Create or open the metadata store, initializing it with the ID formats
' that are used to reference items and replicas.
If Not File.Exists(_replicaMetadataFile) Then
_metadataStore = SqlMetadataStore.CreateStore(_replicaMetadataFile)
Else
_metadataStore = SqlMetadataStore.OpenStore(_replicaMetadataFile)
End If
End Sub
Le code suivant retourne ce magasin en tant que propriété de fournisseur :
public override MetadataStore GetMetadataStore(out SyncId replicaId, out System.Globalization.CultureInfo culture)
{
InitializeMetadataStore();
replicaId = ReplicaId;
culture = CultureInfo.CurrentCulture;
return _metadataStore;
}
Public Overrides Function GetMetadataStore(ByRef replicaId__1 As SyncId, ByRef culture As System.Globalization.CultureInfo) As MetadataStore
InitializeMetadataStore()
replicaId__1 = ReplicaId
culture = CultureInfo.CurrentCulture
Return _metadataStore
End Function
Identification des éléments dans le magasin d'éléments et le magasin des métadonnées
Pour synchroniser un élément, Sync Framework doit être en mesure d'identifier l'élément en question dans le magasin d'éléments et de mapper cette identité à un ID interne dans le magasin des métadonnées. Il doit également pouvoir déterminer si la version de l'élément a changé depuis la session de synchronisation précédente. Si la version a changé et que le réplica de destination ne contient pas encore cette version de l'élément, l'élément doit être synchronisé. Si les modifications sont synchronisées au niveau d'une unité de modification au lieu d'un élément, Sync Framework doit être en mesure d'identifier l'unité de modification et sa version. Une unité de modification représente une modification d'un sous-élément, par exemple le champ numéro de téléphone dans un élément représentant un contact. Cet exemple n'utilise pas d'unités de modification.
Spécification du format des ID utilisés dans le magasin des métadonnées
Le code suivant définit le constructeur de MyFullEnumerationSimpleSyncProvider et la propriété IdFormats. Le runtime Sync Framework utilise cette propriété pour déterminer quel format le magasin des métadonnées utilise pour les ID. Si les ID flexibles ne sont pas utilisés, Sync Framework utilise un format fixe pour identifier les réplicas, les éléments et les unités de modification. Si les ID flexibles sont utilisés, les méthodes ISimpleSyncProviderIdGenerator sont utilisées pour générer des ID.
public MyFullEnumerationSimpleSyncProvider(string name, MySimpleDataStore store)
{
_name = name;
_store = store;
// Create a file to store metadata for all items and a file to store
// the replica ID.
_replicaMetadataFile = Environment.CurrentDirectory + "\\" + _name.ToString() + ".Metadata";
_replicaIdFile = Environment.CurrentDirectory + "\\" + _name.ToString() + ".Replicaid";
// Set ReplicaIdFormat to use a GUID as an ID, and ItemIdFormat to use a GUID plus
// an 8-byte prefix.
_idFormats = new SyncIdFormatGroup();
_idFormats.ItemIdFormat.IsVariableLength = false;
_idFormats.ItemIdFormat.Length = 24;
_idFormats.ReplicaIdFormat.IsVariableLength = false;
_idFormats.ReplicaIdFormat.Length = 16;
this.ItemConstraint += new EventHandler<SimpleSyncItemConstraintEventArgs>(OnItemConstraint);
this.ItemConflicting += new EventHandler<SimpleSyncItemConflictingEventArgs>(OnItemConflicting);
}
public SyncId ReplicaId
{
get
{
if (_replicaId == null)
{
_replicaId = GetReplicaIdFromFile( _replicaIdFile);
}
return _replicaId;
}
}
public override SyncIdFormatGroup IdFormats
{
get { return _idFormats; }
}
Public Sub New(ByVal name As String, ByVal store As MySimpleDataStore)
_name = name
_store = store
' Create a file to store metadata for all items and a file to store
' the replica ID.
_replicaMetadataFile = (Environment.CurrentDirectory & "\") + _name.ToString() & ".Metadata"
_replicaIdFile = (Environment.CurrentDirectory & "\") + _name.ToString() & ".Replicaid"
' Set ReplicaIdFormat to use a GUID as an ID, and ItemIdFormat to use a GUID plus
' an 8-byte prefix.
_idFormats = New SyncIdFormatGroup()
_idFormats.ItemIdFormat.IsVariableLength = False
_idFormats.ItemIdFormat.Length = 24
_idFormats.ReplicaIdFormat.IsVariableLength = False
_idFormats.ReplicaIdFormat.Length = 16
AddHandler Me.ItemConstraint, AddressOf HandleItemConstraint
AddHandler Me.ItemConflicting, AddressOf HandleItemConflicting
End Sub
Public ReadOnly Property ReplicaId() As SyncId
Get
If _replicaId Is Nothing Then
_replicaId = GetReplicaIdFromFile(_replicaIdFile)
End If
Return _replicaId
End Get
End Property
Public Overrides ReadOnly Property IdFormats() As SyncIdFormatGroup
Get
Return _idFormats
End Get
End Property
Spécification des champs d'élément et du schéma des métadonnées
Sync Framework mappe les données du magasin d'éléments, ou les métadonnées supplémentaires que vous créez, aux ID internes du magasin des métadonnées et aux versions en utilisant un objet ItemMetadataSchema qui est exposé par la propriété MetadataSchema. Les exemples de code suivants fournissent la valeur d'entrée de l'objet ItemMetadataSchema. Les constantes dans l'exemple de code définissent une valeur entière pour chaque colonne dans le magasin d'éléments. Ces valeurs sont utilisées lors de la création des définitions de champ personnalisé et des règles d'identité pour l'objet ItemMetadataSchema.
public const uint CUSTOM_FIELD_ID = 1;
public const uint CUSTOM_FIELD_TIMESTAMP = 2;
public override ItemMetadataSchema MetadataSchema
{
get
{
CustomFieldDefinition[] customFields = new CustomFieldDefinition[2];
customFields[0] = new CustomFieldDefinition(CUSTOM_FIELD_ID, typeof(ulong));
customFields[1] = new CustomFieldDefinition(CUSTOM_FIELD_TIMESTAMP, typeof(ulong));
IdentityRule[] identityRule = new IdentityRule[1];
identityRule[0] = new IdentityRule(new uint[] { CUSTOM_FIELD_ID });
return new ItemMetadataSchema(customFields, identityRule);
}
}
Public Const CUSTOM_FIELD_ID As UInteger = 1
Public Const CUSTOM_FIELD_TIMESTAMP As UInteger = 2
Public Overrides ReadOnly Property MetadataSchema() As ItemMetadataSchema
Get
Dim customFields As CustomFieldDefinition() = New CustomFieldDefinition(1) {}
customFields(0) = New CustomFieldDefinition(CUSTOM_FIELD_ID, GetType(ULong))
customFields(1) = New CustomFieldDefinition(CUSTOM_FIELD_TIMESTAMP, GetType(ULong))
Dim identityRule As IdentityRule() = New IdentityRule(0) {}
identityRule(0) = New IdentityRule(New UInteger() {CUSTOM_FIELD_ID})
Return New ItemMetadataSchema(customFields, identityRule)
End Get
End Property
L'objet ItemMetadataSchema expose trois propriétés :
-
Les champs personnalisés sont des champs qui sont identifiés par des entiers dans le magasin des métadonnées. Si une application requiert un nom convivial pour un ou plusieurs champs, elle doit mapper l'entier à un nom. Les champs personnalisés sont définis pour deux raisons : identifier les éléments, et indiquer la version de chacun de ces éléments. Les champs version permettent à Sync Framework de déterminer si un élément ou une unité de modification a changé. Dans cet exemple, les champs version contiennent les données réelles du magasin d'éléments. Il y a donc un champ pour chaque champ contenu dans le magasin d'éléments. Ce mappage un-à-un des champs n'est ni nécessaire, ni efficace. Il est plus judicieux d'effectuer un hachage des champs d'élément et de le stocker dans un champ personnalisé unique.
-
La règle d'identité spécifie le ou les champs personnalisés à utiliser pour identifier un élément. Dans ce cas, le champ CUSTOM_FIELD_ID (champ 0) est utilisé.
ChangeUnitVersionDefinitions (non utilisée dans cet exemple)
Si les unités de modification sont utilisées, vous devez définir les champs version correspondants. Il n'est pas nécessaire de définir un mappage un-à-un entre les unités de modification et les informations de version, ni de stocker les données réelles. Les unités de modification peuvent également être étendues à plusieurs champs. Par exemple, cette application peut spécifier que les champs Zip et Phone représentent une unité de modification et que le champ Guid représente une autre unité de modification. Vous pouvez utiliser les données réelles pour Guid et pour l'autre unité de modification, un hachage des champs Zip et Phone ou un autre mécanisme pour déterminer la version.
Certaines méthodes qui utilisent les données d'un magasin d'éléments, telles que InsertItem, requièrent une collection d'objets ItemField qui représentent chaque champ. Les objets ItemFieldDictionary qui sont des paramètres de ces méthodes ont les mêmes valeurs d'index que celles définies dans les objets CustomFieldDefinition.
Énumération des éléments et chargement des données
Sync Framework doit être en mesure d'énumérer des éléments dans le magasin d'éléments source, de détecter si des éléments ou des unités de modification ont changé, puis de charger les données modifiées afin qu'elles puissent être appliquées au magasin de destination. La détection des modifications est gérée par le runtime Sync Framework, mais l'énumération des modifications et le chargement des données sont spécifiques au magasin et gérés pour les fournisseurs d'énumération complète en implémentant les méthodes EnumerateItems et LoadChangeData. L'exemple de code suivant retourne une liste des éléments énumérés à partir de l'objet MySimpleDataStore :
public override void EnumerateItems(FullEnumerationContext context)
{
List<ItemFieldDictionary> items = new List<ItemFieldDictionary>();
foreach (ulong id in _store.Ids)
{
items.Add(_store.CreateItemFieldDictionary(id));
}
context.ReportItems(items);
}
Public Overrides Sub EnumerateItems(ByVal context As FullEnumerationContext)
Dim items As New List(Of ItemFieldDictionary)()
For Each id As ULong In _store.Ids
items.Add(_store.CreateItemFieldDictionary(id))
Next
context.ReportItems(items)
End Sub
L'exemple de code suivant retourne un objet qui contient l'une des modifications de données énumérées par EnumerateItems. Sync Framework appelle cette méthode jusqu'à ce que toutes les modifications aient été chargées.
public override object LoadChangeData(ItemFieldDictionary keyAndExpectedVersion, IEnumerable<SyncId> changeUnitsToLoad, RecoverableErrorReportingContext recoverableErrorReportingContext)
{
IDictionary<uint, ItemField> expectedFields = (IDictionary<uint, ItemField>)keyAndExpectedVersion;
ulong id = (ulong)expectedFields[CUSTOM_FIELD_ID].Value;
return new ItemTransfer(id, _store.Get(id));
}
Public Overrides Function LoadChangeData(ByVal keyAndExpectedVersion As ItemFieldDictionary, ByVal changeUnitsToLoad As IEnumerable(Of SyncId), ByVal recoverableErrorReportingContext As RecoverableErrorReportingContext) As Object
Dim expectedFields As IDictionary(Of UInteger, ItemField) = DirectCast(keyAndExpectedVersion, IDictionary(Of UInteger, ItemField))
Dim id As ULong = CULng(expectedFields(CUSTOM_FIELD_ID).Value)
Return New ItemTransfer(id, _store.[Get](id))
End Function
Application d'insertions, de mises à jour et de suppressions
Après avoir détecté et chargé les modifications de la source, Sync Framework doit appliquer ces modifications et les modifications de métadonnées correspondantes au réplica de destination. Les modifications de métadonnées sur la destination sont gérées par Sync Framework, mais l'application des modifications de données est spécifique au magasin et gérée en implémentant les méthodes suivantes : DeleteItem, InsertItem et UpdateItem. Les exemples de code suivants fournissent une implémentation pour chacune de ces méthodes :
public override void InsertItem(object itemData,
IEnumerable<SyncId> changeUnitsToCreate,
RecoverableErrorReportingContext recoverableErrorReportingContext,
out ItemFieldDictionary keyAndUpdatedVersion,
out bool commitKnowledgeAfterThisItem)
{
ItemTransfer transfer = (ItemTransfer)itemData;
ItemData dataCopy = new ItemData(transfer.ItemData);
// Check for duplicates, and record a constraint error if a duplicate is detected.
if (!_store.Contains(transfer.Id))
{
_store.CreateItem(dataCopy, transfer.Id);
keyAndUpdatedVersion = _store.CreateItemFieldDictionary(transfer.Id);
}
else
{
recoverableErrorReportingContext.RecordConstraintError(_store.CreateItemFieldDictionary(transfer.Id));
keyAndUpdatedVersion = null;
}
commitKnowledgeAfterThisItem = false;
}
public override void UpdateItem(object itemData,
IEnumerable<SyncId> changeUnitsToUpdate,
ItemFieldDictionary keyAndExpectedVersion,
RecoverableErrorReportingContext recoverableErrorReportingContext,
out ItemFieldDictionary keyAndUpdatedVersion,
out bool commitKnowledgeAfterThisItem)
{
ItemTransfer transfer = (ItemTransfer)itemData;
ItemData dataCopy = new ItemData(transfer.ItemData);
IDictionary<uint, ItemField> expectedFields = (IDictionary<uint, ItemField>)keyAndExpectedVersion;
ulong idToUpdate = (ulong)expectedFields[CUSTOM_FIELD_ID].Value;
if (_store.Contains(idToUpdate))
{
ulong timeStamp = _store.UpdateItem(idToUpdate, dataCopy);
keyAndUpdatedVersion = _store.CreateItemFieldDictionary(transfer.Id);
}
else
{
// If the item to update does not exist, record an error on this change and
// continue with the rest of the session.
recoverableErrorReportingContext.RecordRecoverableErrorForChange(new RecoverableErrorData(new Exception("Item not found in the store")));
keyAndUpdatedVersion = null;
}
commitKnowledgeAfterThisItem = false;
}
public override void DeleteItem(ItemFieldDictionary keyAndExpectedVersion,
RecoverableErrorReportingContext recoverableErrorReportingContext,
out bool commitKnowledgeAfterThisItem)
{
IDictionary<uint, ItemField> expectedFields = (IDictionary<uint, ItemField>)keyAndExpectedVersion;
ulong id = (ulong)expectedFields[CUSTOM_FIELD_ID].Value;
if (_store.Contains(id))
{
_store.DeleteItem(id);
}
else
{
// If the item to delete does not exist, record an error on this change and
// continue with the rest of the session.
recoverableErrorReportingContext.RecordRecoverableErrorForChange(new RecoverableErrorData(new Exception("Item not found in the store")));
}
commitKnowledgeAfterThisItem = false;
}
Public Overrides Sub InsertItem(ByVal itemData As Object, ByVal changeUnitsToCreate As IEnumerable(Of SyncId), ByVal recoverableErrorReportingContext As RecoverableErrorReportingContext, ByRef keyAndUpdatedVersion As ItemFieldDictionary, ByRef commitKnowledgeAfterThisItem As Boolean)
Dim transfer As ItemTransfer = DirectCast(itemData, ItemTransfer)
Dim dataCopy As New ItemData(transfer.ItemData)
' Check for duplicates, and record a constraint error if a duplicate is detected.
If Not _store.Contains(transfer.Id) Then
_store.CreateItem(dataCopy, transfer.Id)
keyAndUpdatedVersion = _store.CreateItemFieldDictionary(transfer.Id)
Else
recoverableErrorReportingContext.RecordConstraintError(_store.CreateItemFieldDictionary(transfer.Id))
keyAndUpdatedVersion = Nothing
End If
commitKnowledgeAfterThisItem = False
End Sub
Public Overrides Sub UpdateItem(ByVal itemData As Object, ByVal changeUnitsToUpdate As IEnumerable(Of SyncId), ByVal keyAndExpectedVersion As ItemFieldDictionary, ByVal recoverableErrorReportingContext As RecoverableErrorReportingContext, ByRef keyAndUpdatedVersion As ItemFieldDictionary, ByRef commitKnowledgeAfterThisItem As Boolean)
Dim transfer As ItemTransfer = DirectCast(itemData, ItemTransfer)
Dim dataCopy As New ItemData(transfer.ItemData)
Dim expectedFields As IDictionary(Of UInteger, ItemField) = DirectCast(keyAndExpectedVersion, IDictionary(Of UInteger, ItemField))
Dim idToUpdate As ULong = CULng(expectedFields(CUSTOM_FIELD_ID).Value)
If _store.Contains(idToUpdate) Then
Dim timeStamp As ULong = _store.UpdateItem(idToUpdate, dataCopy)
keyAndUpdatedVersion = _store.CreateItemFieldDictionary(transfer.Id)
Else
' If the item to update does not exist, record an error on this change and
' continue with the rest of the session.
recoverableErrorReportingContext.RecordRecoverableErrorForChange(New RecoverableErrorData(New Exception("Item not found in the store")))
keyAndUpdatedVersion = Nothing
End If
commitKnowledgeAfterThisItem = False
End Sub
Public Overrides Sub DeleteItem(ByVal keyAndExpectedVersion As ItemFieldDictionary, ByVal recoverableErrorReportingContext As RecoverableErrorReportingContext, ByRef commitKnowledgeAfterThisItem As Boolean)
Dim expectedFields As IDictionary(Of UInteger, ItemField) = DirectCast(keyAndExpectedVersion, IDictionary(Of UInteger, ItemField))
Dim id As ULong = CULng(expectedFields(CUSTOM_FIELD_ID).Value)
If _store.Contains(id) Then
_store.DeleteItem(id)
Else
' If the item to delete does not exist, record an error on this change and
' continue with the rest of the session.
recoverableErrorReportingContext.RecordRecoverableErrorForChange(New RecoverableErrorData(New Exception("Item not found in the store")))
End If
commitKnowledgeAfterThisItem = False
End Sub
Synchronisation de deux fournisseurs
L'exemple de code suivant montre comment les réplicas source et de destination sont synchronisés. Après avoir créé les fournisseurs de source et de destination, le code définit les options de l'objet SyncOrchestrator et synchronise les réplicas.
Dim agent As New SyncOrchestrator()
agent.Direction = SyncDirectionOrder.DownloadAndUpload
agent.LocalProvider = providerA
agent.RemoteProvider = providerB
stats = agent.Synchronize()
SyncOrchestrator agent = new SyncOrchestrator();
agent.Direction = SyncDirectionOrder.DownloadAndUpload;
agent.LocalProvider = providerA;
agent.RemoteProvider = providerB;
stats = agent.Synchronize();
Gestion des conflits
Dans cet exemple, les stratégies de gestion des conflits d'accès concurrentiel et des conflits de contraintes sont conservées comme valeurs par défaut d'ApplicationDefined. Cela signifie que l'application s'inscrira aux événements ItemConflicting et ItemConstraint et spécifiera une action visant à résoudre les conflits s'ils se produisent pendant la synchronisation. Pour plus d'informations, consultez Gestion de conflits pour les fournisseurs simples. L'exemple de code suivant illustre les gestionnaires d'événements spécifiés dans le constructeur de MyFullEnumerationSimpleSyncProvider :
this.ItemConstraint += new EventHandler<SimpleSyncItemConstraintEventArgs>(OnItemConstraint);
this.ItemConflicting += new EventHandler<SimpleSyncItemConflictingEventArgs>(OnItemConflicting);
AddHandler Me.ItemConstraint, AddressOf HandleItemConstraint
L'exemple de code suivant illustre les gestionnaires d'événements qui définissent les actions de résolution de conflit sur Merge :
void OnItemConstraint(object sender, SimpleSyncItemConstraintEventArgs e)
{
// Set the resolution action for constraint conflicts.
// In this sample, the provider checks for duplicates in InsertItem, and this event would
// fire if a duplicate occurred.
e.SetResolutionAction(ConstraintConflictResolutionAction.Merge);
}
void OnItemConflicting(object sender, SimpleSyncItemConflictingEventArgs e)
{
// Set the resolution action for concurrency conflicts.
e.SetResolutionAction(ConflictResolutionAction.Merge);
}
Private Sub HandleItemConstraint(ByVal sender As Object, ByVal e As SimpleSyncItemConstraintEventArgs)
' Set the resolution action for constraint conflicts.
' In this sample, the provider checks for duplicates in InsertItem, and this event would
' fire if a duplicate occurred.
e.SetResolutionAction(ConstraintConflictResolutionAction.Merge)
End Sub
Private Sub HandleItemConflicting(ByVal sender As Object, ByVal e As SimpleSyncItemConflictingEventArgs)
' Set the resolution action for concurrency conflicts.
e.SetResolutionAction(ConflictResolutionAction.Merge)
End Sub
L'exemple de code suivant illustre la méthode MergeConstraintConflict implémentée pour répondre à une action de résolution Merge (fusion) pour un conflit de contraintes :
public void MergeConstraintConflict(object itemData,
ConflictVersionInformation conflictVersionInformation,
IEnumerable<SyncId> changeUnitsToMerge,
ItemFieldDictionary localConflictingItem,
ItemFieldDictionary keyAndExpectedVersion,
RecoverableErrorReportingContext recoverableErrorReportingContext,
out ItemFieldDictionary updatedKeyAndVersion)
{
ItemTransfer transfer = (ItemTransfer)itemData;
ItemData dataCopy = new ItemData(transfer.ItemData);
// Combine the conflicting data.
ItemData mergedData = (_store.Get(transfer.Id)).Merge((ItemData)dataCopy);
// We are doing a merge so we must delete the old conflicting item from our store.
ulong idConflicting = (ulong)localConflictingItem[CUSTOM_FIELD_ID].Value;
_store.DeleteItem(idConflicting);
// Now create the new merged data in the store.
if (_store.Contains(transfer.Id))
{
_store.UpdateItem(transfer.Id, dataCopy);
}
else
{
_store.CreateItem(mergedData, transfer.Id);
}
updatedKeyAndVersion = _store.CreateItemFieldDictionary(transfer.Id);
}
Public Sub MergeConstraintConflict(ByVal itemData As Object, ByVal conflictVersionInformation As ConflictVersionInformation, ByVal changeUnitsToMerge As IEnumerable(Of SyncId), ByVal localConflictingItem As ItemFieldDictionary, ByVal keyAndExpectedVersion As ItemFieldDictionary, ByVal recoverableErrorReportingContext As RecoverableErrorReportingContext, _
ByRef updatedKeyAndVersion As ItemFieldDictionary) Implements ISimpleSyncProviderConstraintConflictResolver.MergeConstraintConflict
Dim transfer As ItemTransfer = DirectCast(itemData, ItemTransfer)
Dim dataCopy As New ItemData(transfer.ItemData)
' Combine the conflicting data.
Dim mergedData As ItemData = (_store.[Get](transfer.Id)).Merge(DirectCast(dataCopy, ItemData))
' We are doing a merge so we must delete the old conflicting item from our store.
Dim idConflicting As ULong = CULng(localConflictingItem(CUSTOM_FIELD_ID).Value)
_store.DeleteItem(idConflicting)
' Now create the new merged data in the store.
If _store.Contains(transfer.Id) Then
_store.UpdateItem(transfer.Id, dataCopy)
Else
_store.CreateItem(mergedData, transfer.Id)
End If
updatedKeyAndVersion = _store.CreateItemFieldDictionary(transfer.Id)
End Sub
Filtrage des données
Certaines applications requièrent que les données soient filtrées de sorte que seules les données répondant à des critères spécifiques soient appliquées à une destination. Par exemple, un commercial peut n'avoir besoin des informations détaillées des produits que pour les produits qu'il vend régulièrement. Les fournisseurs simples permettent aux réplicas de filtrer des données en implémentant une interface de filtrage et en négociant l'utilisation des filtres.
L'exemple de code suivant utilise des interfaces de négociation des filtres pour déterminer si un filtre spécifique doit être utilisé pendant une session de synchronisation. La négociation des filtres permet à un fournisseur de destination de spécifier que le fournisseur de source doit utiliser un ou plusieurs filtres pendant l'énumération des modifications ; le fournisseur de source peut accepter ou rejeter un filtre. Si un fournisseur de source ne prend en charge aucun des filtres demandés, le fournisseur de destination peut choisir de recevoir toutes les données et procéder lui-même au filtrage. Sync Framework appelle les fournisseurs en conséquence pour négocier l'utilisation des filtres.
public bool RequestFilter
{
set
{
_requestFilter = value;
}
}
private bool _requestFilter = false;
void IRequestFilteredSync.SpecifyFilter(FilterRequestCallback filterRequest)
{
// Request a filter only if this provider represents a filtered replica.
if (_requestFilter)
{
if (!filterRequest("TheFilter", FilteringType.CurrentItemsOnly))
{
throw new SyncInvalidOperationException("Could not agree on filter.");
}
}
}
bool ISupportFilteredSync.TryAddFilter(object filter, FilteringType filteringType)
{
if (!((string)filter).Equals("TheFilter"))
{
throw new Exception("Filter is incorrect");
}
// Remember the filter.
_filter = (string)filter;
return true;
}
private string _filter = "";
Public WriteOnly Property RequestFilter() As Boolean
Set(ByVal value As Boolean)
_requestFilter = value
End Set
End Property
Private _requestFilter As Boolean = False
Private Sub SpecifyFilter(ByVal filterRequest As FilterRequestCallback) Implements IRequestFilteredSync.SpecifyFilter
' Request a filter only if this provider represents a filtered replica.
If _requestFilter Then
If Not filterRequest("TheFilter", FilteringType.CurrentItemsOnly) Then
Throw New SyncInvalidOperationException("Could not agree on filter.")
End If
End If
End Sub
Private Function TryAddFilter(ByVal filter As Object, ByVal filteringType As FilteringType) As Boolean Implements ISupportFilteredSync.TryAddFilter
If Not DirectCast(filter, String).Equals("TheFilter") Then
Throw New Exception("Filter is incorrect")
End If
' Remember the filter.
_filter = DirectCast(filter, String)
Return True
End Function
Private _filter As String = ""
L'exemple de code suivant spécifie en premier lieu l'option de filtre None. Cela signifie que les éléments doivent être filtrés même s'ils sont déjà connus de la destination. L'exemple de code implémente ensuite la méthode IsItemInFilterScope, qui filtre alors des éléments selon l'une des valeurs de champs d'éléments. Après avoir défini le filtre, l'exemple de code implémente la méthode UseFilterThisSession. Cela permet à une application de spécifier si le filtrage doit être utilisé session par session.
SimpleSyncProviderFilterOptions IFilteredSimpleSyncProvider.FilterOptions
{
get
{
return SimpleSyncProviderFilterOptions.None;
}
}
bool IFilteredSimpleSyncProvider.IsItemInFilterScope(ItemFieldDictionary KeyAndVersion)
{
ulong itemId = (ulong)KeyAndVersion[1].Value;
ItemData itemData = _store.Get(itemId);
if (itemData["data"] == "3333")
{
return false;
}
return true;
}
bool IFilteredSimpleSyncProvider.UseFilterThisSession
{
get
{
// Indicate whether a filter has been requested and agreed upon for this session.
return ("" != _filter);
}
}
Private ReadOnly Property FilterOptions() As SimpleSyncProviderFilterOptions Implements IFilteredSimpleSyncProvider.FilterOptions
Get
Return SimpleSyncProviderFilterOptions.None
End Get
End Property
Private Function IsItemInFilterScope(ByVal KeyAndVersion As ItemFieldDictionary) As Boolean Implements IFilteredSimpleSyncProvider.IsItemInFilterScope
Dim itemId As ULong = KeyAndVersion(1).Value
Dim data As ItemData = _store.Get(itemId)
If data("data") Is "3333" Then
Return False
End If
Return True
End Function
Private ReadOnly Property UseFilterThisSession() As Boolean Implements IFilteredSimpleSyncProvider.UseFilterThisSession
Get
' Indicate whether a filter has been requested and agreed upon for this session.
Return "" Is _filter
End Get
End Property
Exécution de suppressions en local uniquement
Certains scénarios de synchronisation requièrent la possibilité de supprimer un élément sur un réplica local, sans propager cette suppression à d'autres réplicas. Par exemple, un serveur peut se synchroniser avec plusieurs périphériques qui stockent des informations pour différents commerciaux. L'espace disponible étant limité sur chaque périphérique, les commerciaux en suppriment les anciennes commandes traitées. Les suppressions de ce type ne doivent pas être propagées au serveur, car ce dernier doit conserver ces données. Les fournisseurs simples vous permettent de spécifier que les données ne doivent être supprimées que localement. Pour contrôler le comportement de suppressions session par session, spécifiez l'option appropriée à l'aide de la méthode SetDeleteMode. L'exemple de code suivant spécifie que les suppressions ne doivent pas être propagées pendant la synchronisation.
public override void EnumerateItems(FullEnumerationContext context)
{
context.SetDeleteMode(SimpleSyncProviderDeleteMode.LocalOnly);
List<ItemFieldDictionary> items = new List<ItemFieldDictionary>();
foreach (ulong id in _store.Ids)
{
items.Add(_store.CreateItemFieldDictionary(id));
}
context.ReportItems(items);
}
public override void EnumerateItems(FullEnumerationContext context)
{
context.SetDeleteMode(SimpleSyncProviderDeleteMode.LocalOnly);
List<ItemFieldDictionary> items = new List<ItemFieldDictionary>();
foreach (ulong id in _store.Ids)
{
items.Add(_store.CreateItemFieldDictionary(id));
}
context.ReportItems(items);
}