Synchronizing Directories In Code

By Felipe Ramos Nov 09, 2010
Create an algorithm to detect and synchronize files from two different directories.

 What I wanted to do with the implementation was to create a base for all the checks and validation and any child class to provide their own implementation of the algorithm. I decided to leave the IDisposable since later own new check or a base implementation could be added.

/// <summary>

    /// RepositorySynch will contain basic functionality for validation and property holding.

    /// </summary>

    public abstract class RepositorySynch : IDisposable

    {

        // Properties

        public string SourcePath { get; private set; }

        public string DestinationPath { get; private set; }

        public DirectoryInfo SourceDirectory { get; private set; }

        public DirectoryInfo DestinationDirectory { get; private set; }

 

        public RepositorySynch(string SourcePath, string DestinationPath)

        {

            this.SourcePath = SourcePath;

            this.DestinationPath = DestinationPath;

        }

 

        /// <summary>

        /// Validate both source and destination path and create a new instance of the directory info.

        /// </summary>

        protected void ValidatePaths()

        {

            if (Directory.Exists(SourcePath))

                SourceDirectory = new DirectoryInfo(SourcePath);

            else

                throw new DirectoryNotFoundException(string.Format("Unabled to find source: {0}.", SourcePath));

 

            if (Directory.Exists(DestinationPath))

                DestinationDirectory = new DirectoryInfo(DestinationPath);

            else

                throw new DirectoryNotFoundException(string.Format("Unabled to find destination: {0}.", DestinationPath));

        }

 

        public virtual void Synch()

        {

            ValidatePaths();

        }

 

        public void Dispose()

        {

        }

    }

 

 The second code listing illustrates an implementation with a specific logic set and naming convention rules. The idea below was to leverage linq as much as possible to assist in filtering the data and getting down to the files the needed to be copied. 

 

    /// <summary>

    /// InvoiceRepositorySynch will keep two different invoices repositories in synch.

    /// </summary>

    public class InvoiceRepositorySynch : RepositorySynch

    {

        /// <summary>

        /// Specific to this implementation and how the folders are named.

        /// </summary>

        private struct ProcessStruct

        {

            public int Year;

            public int Month;

        }

 

        public InvoiceRepositorySynch(string SourcePath, string DestinationPath)

            : base(SourcePath, DestinationPath)

        {

        }

 

        /// <summary>

        /// Override Synch, still calling the base so we don't have to recall the validation function.

        /// </summary>

        public override void Synch()

        {

            base.Synch();

 

            // Gather Stats - Folder are named as year ex. 2010 and the subfolders are named ex. 12-2010

            // We only want current month and next month.

            int currentYear = DateTime.Now.Year;

            int currentMonth = DateTime.Now.Month;

            int futureMonth = currentMonth + 1;

 

            // Run Current

            Process(currentYear, currentMonth);

   

            // Calculate Next

            if (currentMonth == 12)

            {

                futureMonth = 1;

                currentYear += 1;

            }

 

            // Run Future

            Process(currentYear, futureMonth);

        }

 

        /// <summary>

        /// Synch the folders

        /// </summary>

        /// <param name="year"></param>

        /// <param name="month"></param>

        private void Process(int year, int month)

        {

            try

            {

                ProcessStruct pStruct = new ProcessStruct() { Month = month, Year = year };

 

                // Get the year directory

                DirectoryInfo sourceDir =

                    SourceDirectory.GetDirectories().Where(d => d.Name == pStruct.Year.ToString()).FirstOrDefault();

                DirectoryInfo destinationDir =

                    DestinationDirectory.GetDirectories().Where(d => d.Name == pStruct.Year.ToString()).FirstOrDefault();

 

                if (sourceDir != null && destinationDir != null)

                {

                    // Get the month directory

                    DirectoryInfo sourceMonth =

                        sourceDir.GetDirectories().Where(d => d.Name == ValidName(pStruct)).FirstOrDefault();

                    DirectoryInfo destinationMonth  =

                        destinationDir.GetDirectories().Where(d => d.Name == ValidName(pStruct)).FirstOrDefault();

 

                    if (sourceMonth != null && destinationMonth != null)

                    {

                        // Get the arrays for file info in both directories

                        FileInfo[] sourceFiles = sourceMonth.GetFiles();

                        FileInfo[] destinationFiles = destinationMonth.GetFiles();

 

                        // In this case we only want to perform our last check when the source contains more files

                        if (sourceFiles.Length > destinationFiles.Length)

                        {

                            // Get the filenames array

                            List<string> sourceFileNames = (from f in sourceFiles

                                                            select f.Name).ToList<string>();

                            List<string> destinationFileNames = (from f in destinationFiles

                                                                 select f.Name).ToList<string>();

                            // Get all matches for removal

                            List<string> matches = (from s in sourceFileNames

                                                    join d in destinationFileNames on s equals d

                                                    select s).ToList<string>();

                           

                            // Remove matches to keep a list of all the missing filenames

                            sourceFileNames.RemoveAll(a =>

                                {

                                    return matches.Contains(a);

                                });

 

                            // Copy missing files

                            FileInfo[] filesToCopy = (from f in sourceFiles

                                                      join c in sourceFileNames on f.Name equals c

                                                      select f).ToArray<FileInfo>();

                           

                            foreach (FileInfo f in filesToCopy)

                            {

                                f.CopyTo(destinationMonth.FullName + @"\\" + f.Name);

                            }

                        }

                    }

                }

            }

            catch (Exception ex)

            {

                throw ex;

            }

        }

 

        private string ValidName(ProcessStruct pStruct)

        {

            return string.Format("{0}-{1}", pStruct.Month < 10 ? "0" + pStruct.Month.ToString() : pStruct.Month.ToString(),

                                            pStruct.Year.ToString());

        }

    }

 

 Another way could be to order by the last updated date on the files and only check the files that have change within a certain period of time. I hope this have been helpful and I know that this is just one of many ways to complete this task so please leave comments or suggestions. Thank you in advance. 

 

Felipe Ramos

Developer for the last 7-8 years using .NET technologies.

COMMENT USING

PREMIUM SPONSORS

Hire Mobile & Web Developer on demand. 100% satisfaction. Try for 1 week or Money Back. Local and remote developers available all over USA.

Latest Blogs