Microsoft Sync Framework - A primer to the file sync provider

private void btnSynchronize_Click(object sender, EventArgs e)
{
    // Generate a unique Id for the source and store it in a file for future reference.
    SyncId sourceId = GetSyncID(@"C:\Sync\Source\File.ID");

    // Generate a unique Id for the destination and store it in a file for future reference.
    SyncId destId = GetSyncID(@"C:\Sync\Destination\File.ID");

    // Create a FileSyncProvider object by passing the SyncID and the source location.
    FileSyncProvider sourceReplica = new FileSyncProvider(sourceId, @"C:\Sync\Source\");

    // Create a FileSyncProvider object by passing the SyncID and the destination location.
    FileSyncProvider destReplica = new FileSyncProvider(destId, @"C:\Sync\Destination\");

    // Initialize the agent which actually performs the synchronization.
    SyncAgent agent = new SyncAgent();

    // Assign the source replica as the Local Provider and the destination replica as the Remote provider
    // so that the agent knows which is the source and which one is the destination.
    agent.LocalProvider = sourceReplica;
    agent.RemoteProvider = destReplica;

    // Set the direction of synchronization from Source to destination as this is a one-way synchronization.
    // You may use SyncDirection.Download if you want the Local replica to be treated as Destination
    // and the Remote replica to be the source; use SyncDirection.DownloadAndUpload or
    // SyncDirection.UploadAndDownload for two-way synchronization.
    agent.Direction = SyncDirection.Upload;

    // Make a call to the Synchronize method for starting the synchronization process.
    agent.Synchronize();
}

// This is a private function I have created to generate the SyncID if
// it is the first time a Sync is happening on the source and destination replicas
// or else retrieve the SyncID stored in a pre-defined file (File.ID) on the source and destination replicas.
// I have used the GUID for generating the SyncID, whereas you may also
// use a unique string, byte array, etc. for generating the SyncID.
// The objective here is to have a unique SyncID.
private static SyncId GetSyncID(string syncFilePath)
{
    Guid guid;
    SyncId replicaID = null;

    if (!File.Exists(syncFilePath)) // The ID file doesn't exist.
    {
        // Create the file and store the guid which is used to instantiate the instance of the SyncId.
        guid = Guid.NewGuid();
        replicaID = new SyncId(guid);
        using (FileStream fs = File.Open(syncFilePath, FileMode.Create))
        using (StreamWriter sw = new StreamWriter(fs))
        {
            sw.WriteLine(guid.ToString());
        }
    }
    else
    {
        // Read the SyncID from the existing file.
        using (FileStream fs = File.Open(syncFilePath, FileMode.Open))
        using (StreamReader sr = new StreamReader(fs))
        {
            string guidString = sr.ReadLine();
            guid = new Guid(guidString);
            replicaID = new SyncId(guid);
        }
    }

    return replicaID;
}

The source code above is just a simple example of synchronizing contents in one folder with that of another. There can be more advanced requirements like excluding files from synchronization, recovering files which are deleted in synchronization, etc. For these you have to use the FileSyncScopeFilter and the FileSyncOptions while creating the FileSyncProvider object for source and destination replicas.

For excluding files from synchronization, you have to create an object of the FileSyncScopeFilter, add the filenames to be excluded from the synchronization and then pass the FileSyncScopeFilter object to the FileSyncProvider constructor while creating an object for the source replica.

For example if I was to exclude the file named "File.ID" from the synchronization in the above source code, I would have to do the following.

Add the following code just before creating the object named sourceReplica.

FileSyncScopeFilter scopeFilter = new FileSyncScopeFilter();
scopeFilter.FileNameExcludes.Add("File.ID");

// Modify the code for creating the sourceReplica object by passing the scopeFilter object to the constructor.
FileSyncProvider sourceReplica = new FileSyncProvider(sourceId, @"C:\Sync\Source\", scopeFilter, FileSyncOptions.None);

// That's all you do to exclude a file from synchronization. 
// You would be wondering what the FileSyncOptions.None does in the code above. 
// Well, FileSyncOptions is an enumeration that you use to specify additional information 
// on how the synchronization handles deletes, overwrites, etc. 

// For example, the synchronization process may lead to the deletion of file(s) 
// from the destination replica if the same no longer exists in the source replica. 
// In such cases, you may want to send the deleted file to the recycle bin for future reference. 
// The FileSyncProvider does not send the deleted file to the recycle bin by default, 
// but you can set the FileSyncOptions.RecycleDeletes option while creating the destReplica object 
// to send all deleted files to the recycle bin as follows:

FileSyncProvider destReplica = new FileSyncProvider(destId, @"C:\Sync\Destination\", scopeFilter, FileSyncOptions.RecycleDeletes);

Other FileSyncOptions that you may use are.

FileSyncOptions.RecycleOverwrites
FileSyncOptions.CompareFileStreams FileSyncOptions.ExplicitDetectChanges

Resources

You will need the Microsoft Sync Framework to create sync programs in .Net. You can download the same and other related resources from http://msdn2.microsoft.com/en-us/sync/default.aspx.

Conclusion

As the intention of this article is just to be a primer on the Microsoft Sync Framework, there are numerous options apart from the ones in this article that you can explore to make powerful synchronization applications.