Synchronisation du fournisseur de synchronisation de fichiers avec d'autres fournisseurs

Article
10/17/2009

Cette rubrique décrit comment créer une application managée qui permet à un fournisseur de synchronisation de fichiers d'effectuer une synchronisation avec un autre fournisseur Sync Framework. Dans ce cas, l'autre fournisseur est un fournisseur simple, mais vous pouvez aussi utiliser un fournisseur personnalisé standard. Pour plus d'informations sur les fournisseurs simples, consultez Implémentation d'un fournisseur personnalisé simple.

Il existe deux exigences principales pour cette application :

L'application doit implémenter IFileDataRetriever en tant qu'interface de transfert de données entre les deux fournisseurs.
Le fournisseur simple doit utiliser le même format pour les ID utilisés par le fournisseur de synchronisation de fichiers : un GUID de 16 octets pour les ID de réplica ; un GUID de 16 octets assorti d'un préfixe de 8 octets pour les ID d'élément ; et un entier de 4 octets pour les ID d'unité de modification.

Exemples de code managé

Les exemples figurant dans cette section illustre une partie du code qui est pertinent pour synchroniser un fournisseur de synchronisation de fichiers et un fournisseur de synchronisation simple, avec l'accent mis sur les exigences en termes d'ID et d'interface de transfert. Pour afficher ce code dans le contexte d'une application complète, consultez l'application "Sync 101 - Synchronizing a File Synchronization Provider with a Simple Provider" qui est disponible sur le site Code Gallery (en anglais).

L'exemple de code suivant illustre la façon dont la définition de la propriété IdFormats pour le fournisseur simple correspond aux exigences mentionnées précédemment.

public override SyncIdFormatGroup IdFormats
{
    get
    {
        SyncIdFormatGroup idFormats = new SyncIdFormatGroup();
        idFormats.ItemIdFormat.Length = 24;
        idFormats.ItemIdFormat.IsVariableLength = false;
        idFormats.ReplicaIdFormat.Length = 16;
        idFormats.ReplicaIdFormat.IsVariableLength = false;
        idFormats.ChangeUnitIdFormat.Length = 4;
        idFormats.ChangeUnitIdFormat.IsVariableLength = false;

        return idFormats;
    }
}

Public Overrides ReadOnly Property IdFormats() As SyncIdFormatGroup
    Get
        Dim FormatGroup As New SyncIdFormatGroup()

        FormatGroup.ItemIdFormat.Length = 24
        FormatGroup.ItemIdFormat.IsVariableLength = False
        FormatGroup.ReplicaIdFormat.Length = 16
        FormatGroup.ReplicaIdFormat.IsVariableLength = False
        FormatGroup.ChangeUnitIdFormat.Length = 4
        FormatGroup.ChangeUnitIdFormat.IsVariableLength = False

        Return FormatGroup
    End Get
End Property

Les exemples de code suivants illustrent deux des méthodes requises pour les fournisseurs simples : LoadChangeData et InsertItem. La majorité du code dans ces méthodes est spécifique à l'implémentation d'un fournisseur simple, mais deux critères doivent être mis en relief :

LoadChangeData est utilisé pour charger des données qui ont été énumérées à partir du magasin local (le magasin qui est servi par le fournisseur simple). Cette méthode retourne des données en tant qu'objet SimpleFileDataRetriever, qui est l'exemple d'implémentation de IFileDataRetriever.

public override object LoadChangeData(ItemFieldDictionary keyAndExpectedVersion,
    IEnumerable<SyncId> changeUnitsToLoad,
    RecoverableErrorReportingContext recoverableErrorReportingContext)
{
    // Figure out which item is being asked for

    string localRelativePath;
    long expectedLMT;
    ParseDictionary(keyAndExpectedVersion, out localRelativePath, out expectedLMT);

    string localPath = Path.Combine(this.rootFolder, localRelativePath);
    string currentVersion = File.GetLastWriteTimeUtc(localPath).Ticks.ToString();

    // Check if it changed --- race condition!

    if (File.GetLastWriteTimeUtc(localPath).Ticks != expectedLMT)
    {
        recoverableErrorReportingContext.RecordRecoverableErrorForChange(
            new RecoverableErrorData(null));
        return null;
    }

    // Return
    return new SimpleFileDataRetriever(localRelativePath, null, localPath, File.GetAttributes(localPath));
}

Public Overrides Function LoadChangeData(ByVal keyAndExpectedVersion As ItemFieldDictionary, ByVal changeUnitsToLoad As IEnumerable(Of SyncId), ByVal recoverableErrorReportingContext As RecoverableErrorReportingContext) As Object
    ' Figure out which item is being asked for 

    Dim localRelativePath As String = ""
    Dim expectedLMT As Long
    ParseDictionary(keyAndExpectedVersion, localRelativePath, expectedLMT)

    Dim localPath As String = Path.Combine(Me.rootFolder, localRelativePath)
    Dim currentVersion As String = File.GetLastWriteTimeUtc(localPath).Ticks.ToString()

    ' Check if it changed --- race condition! 

    If File.GetLastWriteTimeUtc(localPath).Ticks <> expectedLMT Then
        recoverableErrorReportingContext.RecordRecoverableErrorForChange(Nothing)
        Return Nothing
    End If

    ' Return 
    Return New SimpleFileDataRetriever(localRelativePath, Nothing, localPath, File.GetAttributes(localPath))
End Function

InsertItem est utilisée pour insérer des données dans le magasin local à partir du magasin distant (le magasin qui est servi par le fournisseur de synchronisation de fichiers). Cette méthode convertit les données d'élément qu'elle reçoit en un objet IFileDataRetriever. La méthode InsertItem convertit aussi les données.

public override void InsertItem(object itemData,
    IEnumerable<SyncId> changeUnitsToCreate,
    RecoverableErrorReportingContext recoverableErrorReportingContext,
    out ItemFieldDictionary keyAndUpdatedVersion,
    out bool commitKnowledgeAfterThisItem)
{
    // Figure out where to create it

    IFileDataRetriever fileData = (IFileDataRetriever)itemData;

    string localPath = Path.Combine(this.rootFolder, Path.Combine(fileData.RelativeDirectoryPath, fileData.FileData.Name));

    // Check if it is already there --- name collision

    if (File.Exists(localPath))
    {
        recoverableErrorReportingContext.RecordConstraintError(
            ConstructDictionary(Path.Combine(fileData.RelativeDirectoryPath, fileData.FileData.Name)));

        keyAndUpdatedVersion = null;
        commitKnowledgeAfterThisItem = false;

        return;
    }

    // Create it

    File.Copy(fileData.AbsoluteSourceFilePath, localPath);

    // Return particulars to Simple Provider framework

    keyAndUpdatedVersion = ConstructDictionary(
        Path.Combine(fileData.RelativeDirectoryPath, fileData.FileData.Name),
        File.GetLastWriteTimeUtc(localPath).Ticks);

    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)
    ' Figure out where to create it 

    Dim fileData As IFileDataRetriever = DirectCast(itemData, IFileDataRetriever)

    Dim localPath As String = Path.Combine(Me.rootFolder, Path.Combine(fileData.RelativeDirectoryPath, fileData.FileData.Name))

    ' Check if it is already there --- name collision 

    If File.Exists(localPath) Then
        recoverableErrorReportingContext.RecordConstraintError(ConstructDictionary(Path.Combine(fileData.RelativeDirectoryPath, fileData.FileData.Name)))

        keyAndUpdatedVersion = Nothing
        commitKnowledgeAfterThisItem = False

        Exit Sub
    End If

    ' Create it 

    File.Copy(fileData.AbsoluteSourceFilePath, localPath)

    ' Return particulars to Simple Provider framework 

    keyAndUpdatedVersion = ConstructDictionary(Path.Combine(fileData.RelativeDirectoryPath, fileData.FileData.Name), File.GetLastWriteTimeUtc(localPath).Ticks)

    commitKnowledgeAfterThisItem = False
End Sub

L'exemple de code suivant crée la classe SimpleFileDataRetriever, qui utilise AbsoluteSourceFilePath et RelativeDirectoryPath pour identifier les emplacements de fichiers, et FileData et FileStream pour transférer les données actuelles.

class SimpleFileDataRetriever : IFileDataRetriever, IDisposable
{
    private string _relativeLocalFilePath;
    private Stream _sourceStream;
    private string _absoluteSourceFilePath;
    private FileAttributes _attributes;

    public SimpleFileDataRetriever(string relativeLocalFilePath, Stream sourceStream, string absoluteSourceFilePath, FileAttributes attributes)
    { 
        this._relativeLocalFilePath = relativeLocalFilePath;
        this._sourceStream = sourceStream;
        this._attributes = attributes;
        this._absoluteSourceFilePath = absoluteSourceFilePath;
    }

    #region IFileDataRetriever Members

    // If the local store has no concept of absolute file path then return a NotImplementedException here.  
    // The FSP will instead use the stream for file copying.
    // If implemented, return absolute local path including file name.
    public string AbsoluteSourceFilePath
    {
        get 
        { 
            return this._absoluteSourceFilePath; 
        }
    }

    public FileData FileData
    {
        get
        {
            FileInfo fi = new FileInfo(_absoluteSourceFilePath);

            //For the relative path on FileData, provide relative path including file name
            return new FileData(
                _relativeLocalFilePath,
                _attributes,
                fi.CreationTimeUtc,
                fi.LastAccessTimeUtc,
                fi.LastWriteTimeUtc,
                fi.Length);
        }
    }

    public System.IO.Stream FileStream
    {
        get 
        {
            if (this._sourceStream == null)
            {
                this._sourceStream = new FileStream(this._absoluteSourceFilePath, FileMode.Open);
            }

            return _sourceStream; 
        }
    }

    // Must return the relative path without the filename
    public string RelativeDirectoryPath
    {
        get
        {
            return Path.GetDirectoryName(_relativeLocalFilePath);
        }
    }

    #endregion

    #region IDisposable Members

    public void Dispose()
    {
        if (this._sourceStream != null)
        {
            this._sourceStream.Close();
        }
    }

    #endregion
}

    Class SimpleFileDataRetriever
        Implements IFileDataRetriever
        '        Implements IDisposable
        Private _relativeLocalFilePath As String
        Private _sourceStream As Stream
        Private _absoluteSourceFilePath As String
        Private _attributes As FileAttributes

        Public Sub New(ByVal relativeLocalFilePath As String, ByVal sourceStream As Stream, ByVal absoluteSourceFilePath As String, ByVal attributes As FileAttributes)
            Me._relativeLocalFilePath = relativeLocalFilePath
            Me._sourceStream = sourceStream
            Me._attributes = attributes
            Me._absoluteSourceFilePath = absoluteSourceFilePath
        End Sub

#Region "IFileDataRetriever Members"

        ' If the local store has no concept of absolute file path then return a NotImplementedException here. 
        ' The FSP will instead use the stream for file copying. 
        ' If implemented, return absolute local path including file name. 
        Public ReadOnly Property AbsoluteSourceFilePath() As String Implements IFileDataRetriever.AbsoluteSourceFilePath
            Get
                Return Me._absoluteSourceFilePath
            End Get
        End Property

        Public ReadOnly Property FileData() As FileData Implements IFileDataRetriever.FileData
            Get
                Dim fi As New FileInfo(_absoluteSourceFilePath)

                'For the relative path on FileData, provide relative path including file name 
                Return New FileData(_relativeLocalFilePath, _attributes, fi.CreationTimeUtc, fi.LastAccessTimeUtc, fi.LastWriteTimeUtc, fi.Length)
            End Get
        End Property

        Public ReadOnly Property FileStream() As System.IO.Stream Implements IFileDataRetriever.FileStream
            Get
                If Me._sourceStream Is Nothing Then
                    Me._sourceStream = New FileStream(Me._absoluteSourceFilePath, FileMode.Open)
                End If

                Return _sourceStream
            End Get
        End Property

        ' Must return the relative path without the filename 
        Public ReadOnly Property RelativeDirectoryPath() As String Implements IFileDataRetriever.RelativeDirectoryPath
            Get
                Return Path.GetDirectoryName(_relativeLocalFilePath)
            End Get
        End Property

#End Region

#Region "IDisposable Members"

        Public Sub Dispose()
            If Me._sourceStream IsNot Nothing Then
                Me._sourceStream.Close()
            End If
        End Sub

#End Region
    End Class

L'exemple de code suivant synchronise les deux fournisseurs. Le processus de synchronisation est le même que si vous synchronisiez deux fournisseurs de synchronisation de fichiers ou deux fournisseurs simples : l'implémentation de l'interface IFileDataRetriever et l'utilisation des formats d'ID appropriés garantissent que les données sont correctement transférées.

static void DoBidirectionalSync(string pathA, Guid replicaA, string pathB, Guid replicaB)
{
    SyncOperationStatistics stats;
    MySimpleFileProvider providerA = new MySimpleFileProvider(replicaA, pathA);
    FileSyncProvider providerB = new FileSyncProvider(replicaB, pathB);

    //Set the custom provider's conflict resolution policy to custom in order to show 
    //how to perform complex resolution actions.
    providerA.Configuration.ConflictResolutionPolicy = ConflictResolutionPolicy.ApplicationDefined;

    //Register callbacks so that we can handle conflicts if they are detected, and other events.
    RegisterCallbacks(providerA);
    RegisterCallbacks(providerB);

    //Synchronize the two providers that are specified.           
    Console.WriteLine("Sync {0} and {1}...", pathA, pathB);
    SyncOrchestrator agent = new SyncOrchestrator();

    //To avoid writing conflict resolution logic in your matching provider it is good practice to always sync from custom provider
    //to FSP provider first.  That way the FSP will handle all the conflicts itself.  Here we do the opposite to show our custom
    //constraint conflict resolution.
    agent.Direction = SyncDirectionOrder.UploadAndDownload;

    agent.LocalProvider = providerB;
    agent.RemoteProvider = providerA;
    stats = agent.Synchronize();

    //Display the statistics from the SyncOperationStatistics object that is returned 
    //by Synchronize().
    Console.WriteLine("Download Applied:\t {0}", stats.DownloadChangesApplied);
    Console.WriteLine("Download Failed:\t {0}", stats.DownloadChangesFailed);
    Console.WriteLine("Download Total:\t\t {0}", stats.DownloadChangesTotal);
    Console.WriteLine("Upload Total:\t\t {0}", stats.UploadChangesApplied);
    Console.WriteLine("Upload Total:\t\t {0}", stats.UploadChangesFailed);
    Console.WriteLine("Upload Total:\t\t {0}", stats.UploadChangesTotal);
}

Private Shared Sub DoBidirectionalSync(ByVal pathA As String, ByVal replicaA As Guid, ByVal pathB As String, ByVal replicaB As Guid)
    Dim stats As SyncOperationStatistics
    Dim providerA As New MySimpleFileProvider(replicaA, pathA)
    Dim providerB As New FileSyncProvider(replicaB, pathB)

    'Set the custom provider's conflict resolution policy to custom in order to show 
    'how to perform complex resolution actions. 
    providerA.Configuration.ConflictResolutionPolicy = ConflictResolutionPolicy.ApplicationDefined

    'Register callbacks so that we can handle conflicts if they are detected, and other events. 
    RegisterCallbacks(providerA)
    RegisterCallbacks(providerB)

    'Synchronize the two providers that are specified. 
    Console.WriteLine("Sync {0} and {1}...", pathA, pathB)
    Dim agent As New SyncOrchestrator()

    'To avoid writing conflict resolution logic in your matching provider it is good practice to always sync from custom provider 
    'to FSP provider first. That way the FSP will handle all the conflicts itself. Here we do the opposite to show our custom 
    'constraint conflict resolution. 
    agent.Direction = SyncDirectionOrder.UploadAndDownload

    agent.LocalProvider = providerB
    agent.RemoteProvider = providerA
    stats = agent.Synchronize()

    'Display the statistics from the SyncOperationStatistics object that is returned 
    'by Synchronize(). 
    Console.WriteLine("Download Applied:" & vbTab & " {0}", stats.DownloadChangesApplied)
    Console.WriteLine("Download Failed:" & vbTab & " {0}", stats.DownloadChangesFailed)
    Console.WriteLine("Download Total:" & vbTab & vbTab & " {0}", stats.DownloadChangesTotal)
    Console.WriteLine("Upload Total:" & vbTab & vbTab & " {0}", stats.UploadChangesApplied)
    Console.WriteLine("Upload Total:" & vbTab & vbTab & " {0}", stats.UploadChangesFailed)
    Console.WriteLine("Upload Total:" & vbTab & vbTab & " {0}", stats.UploadChangesTotal)
End Sub

Voir aussi

Concepts

Implémentation d'un fournisseur personnalisé simple
Intégration de données de fournisseurs différents
Synchronisation des fichiers

Partager via

Synchronisation du fournisseur de synchronisation de fichiers avec d'autres fournisseurs

Exemples de code managé

Voir aussi

Concepts

Ressources supplémentaires