Source code for robomove.cs

```
using System;
```
```
using System.Collections.Generic;
```
```
using System.IO;
```
```
using System.Linq;
```
```
using System.Text;
```
```
 
```
```
 
```
```
namespace RobvanderWoude
```
```
{
```
```
	class RoboMove
```
```
	{
```
```
		static string progver = "1.00";
```

		static string logfile = Path.Combine( Directory.GetCurrentDirectory( ), "RoboMove.log" );

		static List<string> logtext = new List<string>( );

```
		static bool debugmode = false;
```
```
		static bool logging = false;
```
```
		static bool overwritelog = false;
```
```
		static bool testmode = false;
```
```
		static bool verbose = false;
```
```
		static int duplicates = 0;
```
```
		static int newfiles = 0;
```
```
		static int movedfiles = 0;
```
```
		static int matchingfiles = 0;
```
```
 
```
```
 
```
```
		static int Main( string[] args )
```
```
		{
```
```
			#region Parse Command Line
```
```
 
```
```
			if ( args.Length < 2 )
```
```
			{
```
```
				return ShowHelp( );
```
```
			}
```
```
			foreach ( string arg in args )
```
```
			{
```
```
				if ( arg == "/?" )
```
```
				{
```
```
					return ShowHelp( );
```
```
				}
```
```
			}
```
```
			if ( args.Length > 2 )
```
```
			{
```

				foreach ( string arg in args.Skip<string>( 2 ) )

```
				{
```

					if ( arg.Length > 1 && arg[0] == '/' )

```
					{
```

						switch ( arg.ToUpper( ).Substring( 0, 2 ) )

```
						{
```
```
							case "/D":
```
```
								if ( debugmode )
```
```
								{
```

									return ShowHelp( "Duplicate command line switch /D" );

```
								}
```
```
								debugmode = true;
```
```
								break;
```
```
							case "/L":
```
```
								if ( logging )
```
```
								{
```

									return ShowHelp( "Duplicate command line switch /L" );

```
								}
```

								if ( arg.Length > 4 && arg[2] == ':' )

```
								{
```

									if ( Directory.Exists( Directory.GetParent( arg.Substring( 3 ) ).FullName ) )

```
									{
```
```
										logfile = arg.Substring( 3 );
```
```
									}
```
```
									else
```
```
									{
```

										return ShowHelp( "Invalid directory for log file: \"{0}\"", Directory.GetParent( arg.Substring( 3 ) ).FullName );

```
									}
```
```
								}
```
```
								else
```
```
								{
```

									return ShowHelp( "Invalid logfile specified: {0}", arg );

```
								}
```
```
								logging = true;
```
```
								break;
```
```
							case "/O":
```
```
								if ( overwritelog )
```
```
								{
```

									return ShowHelp( "Duplicate command line switch /O" );

```
								}
```
```
								overwritelog = true;
```
```
								break;
```
```
							case "/T":
```
```
								if ( testmode )
```
```
								{
```

									return ShowHelp( "Duplicate command line switch /T" );

```
								}
```
```
								testmode = true;
```
```
								break;
```
```
							case "/V":
```
```
								if ( verbose )
```
```
								{
```

									return ShowHelp( "Duplicate command line switch /V" );

```
								}
```
```
								verbose = true;
```
```
								break;
```
```
							default:
```

								return ShowHelp( "Invalid command line switch \"{0}\"", args[2] );

```
						}
```
```
					}
```
```
					else
```
```
					{
```

						return ShowHelp( "Invalid command line argument \"{0}\"", args[2] );

```
					}
```
```
				}
```
```
			}
```
```
 
```

			// Debug Mode implies Logging to file

```
			logging = ( logging || debugmode );
```
```
 
```

			// Overwrite can only be used if Logging is enabled

```
			if ( overwritelog && !logging )
```
```
			{
```

				return ShowHelp( "/O switch can only be used with /D or /L" );

```
			}
```
```
 
```
```
			if ( debugmode )
```
```
			{
```

				Display( "\nRoboMove {0}, started on {1}, at {2}\n", progver, DateTime.Now.Date.ToShortDateString( ), DateTime.Now.ToShortTimeString( ) );

				Display( "#arguments:\t{0}", args.Length.ToString( ) );

```
				int i = 0;
```
```
				foreach ( string arg in args )
```
```
				{
```

					Display( "argument #{0}:\t\"{1}\"", i.ToString( ), arg );

```
					i += 1;
```
```
				}
```

				Display( "\nSource Root:\t\"{0}\"", args[0] );

				Display( "Source exists:\t{0}", Directory.Exists( args[0] ).ToString( ) );

				Display( "Target Root:\t\"{0}\"", args[1] );

				Display( "Target exists:\t{0}", Directory.Exists( args[1] ).ToString( ) );

				Display( "Debug Mode:\t{0}", debugmode.ToString( ) );

				Display( "Log to File:\t{0}", logging.ToString( ) );

				Display( "Log File:\t\"{0}\"", logfile );

				Display( "Log exists:\t{0}", File.Exists( logfile ).ToString( ) );

				Display( "Overwrite Log:\t{0}", overwritelog.ToString( ) );

				Display( "Test Mode:\t{0}", testmode.ToString( ) );

				Display( "Verbose:\t{0}\n", verbose.ToString( ) );

```
			}
```
```
 
```

			// Validate paths of source and target directories

```
			string sourcerootdir;
```
```
			string targetrootdir;
```
```
			if ( Directory.Exists( args[0] ) )
```
```
			{
```
```
				try
```
```
				{
```

					sourcerootdir = Path.GetFullPath( args[0] );

```
				}
```
```
				catch ( Exception e )
```
```
				{
```

					return ShowHelp( "Invalid source root directory \"{0}\": {1}", args[0], e.Message );

```
				}
```
```
			}
```
```
			else
```
```
			{
```

				return ShowHelp( "Source directory \"{0}\" not found", args[0] );

```
			}
```
```
			if ( Directory.Exists( args[1] ) )
```
```
			{
```
```
				try
```
```
				{
```

					targetrootdir = Path.GetFullPath( args[1] );

```
				}
```
```
				catch ( Exception e )
```
```
				{
```

					return ShowHelp( "Invalid target root directory \"{0}\": {1}", args[0], e.Message );

```
				}
```
```
			}
```
```
			else
```
```
			{
```

				return ShowHelp( "Target directory \"{0}\" not found", args[1] );

```
			}
```
```
 
```
```
			#endregion Parse Command Line
```
```
 
```
```
			// List directory trees
```

			string[] sourcetreeabs = Directory.GetDirectories( sourcerootdir, "*.*", SearchOption.AllDirectories );

			string[] targettreeabs = Directory.GetDirectories( targetrootdir, "*.*", SearchOption.AllDirectories );

			List<string> sourcetree = new List<string>( );

			List<string> targettree = new List<string>( );

```
 
```
```
			// Remove root folders from paths
```
```
			int srclen = sourcerootdir.Length;
```

			foreach ( string dir in sourcetreeabs )

```
			{
```

				if ( dir.ToLower( ).IndexOf( sourcerootdir.ToLower( ) ) == 0 )

```
				{
```

					sourcetree.Add( dir.Substring( srclen ) );

```
				}
```
```
				else
```
```
				{
```

					Display( "ABORTING: error while building source directory tree list" );

```
					return 1;
```
```
				}
```
```
			}
```
```
			int tgtlen = targetrootdir.Length;
```

			foreach ( string dir in targettreeabs )

```
			{
```

				if ( dir.ToLower( ).IndexOf( targetrootdir.ToLower( ) ) == 0 )

```
				{
```

					targettree.Add( dir.Substring( tgtlen ) );

```
				}
```
```
				else
```
```
				{
```

					Display( "ABORTING: error while building target directory tree list" );

```
					return 1;
```
```
				}
```
```
			}
```
```
 
```

			// Add missing folders to target tree

```
			foreach ( string dir in sourcetree )
```
```
			{
```
```
				if ( !targettree.Contains( dir ) )
```
```
				{
```
```
					targettree.Add( dir );
```

					string newdir = Path.Combine( targetrootdir, dir.TrimStart( '\\' ) );

					if ( MKDIR( newdir ) == 1 && ( debugmode || testmode ) )

```
					{
```
```
						return 1;
```
```
					}
```
```
				}
```
```
			}
```
```
 
```
```
			// List file trees
```

			string[] sourcelistabs = Directory.GetFiles( sourcerootdir, "*.*", SearchOption.AllDirectories );

			string[] targetlistabs = Directory.GetFiles( targetrootdir, "*.*", SearchOption.AllDirectories );

			List<string> sourcelist = new List<string>( );

			List<string> targetlist = new List<string>( );

```
 
```
```
			// List unique file names
```

			SortedList<string, bool> sourcefilenames = new SortedList<string, bool>( ); // string filename, bool unique name

			foreach ( string file in sourcelistabs )

```
			{
```

				string name = Path.GetFileName( file );

				if ( sourcefilenames.ContainsKey( name ) )

```
				{
```
```
					sourcefilenames[name] = false;
```
```
				}
```
```
				else
```
```
				{
```
```
					sourcefilenames.Add( name, true );
```
```
				}
```
```
			}
```

			SortedList<string, bool> targetfilenames = new SortedList<string, bool>( ); // string filename, bool unique name

			foreach ( string file in targetlistabs )

```
			{
```

				string name = Path.GetFileName( file );

				if ( targetfilenames.ContainsKey( name ) )

```
				{
```
```
					targetfilenames[name] = false;
```
```
				}
```
```
				else
```
```
				{
```
```
					targetfilenames.Add( name, true );
```
```
				}
```
```
			}
```
```
 
```
```
			// Remove root folders from paths
```

			foreach ( string file in sourcelistabs )

```
			{
```

				if ( file.ToLower( ).IndexOf( sourcerootdir.ToLower( ) ) == 0 )

```
				{
```

					sourcelist.Add( file.Substring( srclen ) );

```
				}
```
```
				else
```
```
				{
```

					Display( "ABORTING: error while removing root folder from source directory tree list" );

```
					return 1;
```
```
				}
```
```
			}
```

			foreach ( string file in targetlistabs )

```
			{
```

				if ( file.ToLower( ).IndexOf( targetrootdir.ToLower( ) ) == 0 )

```
				{
```

					targetlist.Add( file.Substring( tgtlen ) );

```
				}
```
```
				else
```
```
				{
```

					Display( "ABORTING: error while removing root folder from target directory tree list" );

```
					return 1;
```
```
				}
```
```
			}
```
```
 
```
```
			// Compare directory trees
```

			foreach ( string file in targetlist )

```
			{
```

				string name = Path.GetFileName( file );

```
				if ( sourcelist.Contains( file ) )
```
```
				{
```
```
					if ( debugmode || verbose )
```
```
					{
```

						Display( "OK: locations of file \"{0}\" in source and target trees match", name );

```
						matchingfiles += 1;
```
```
					}
```
```
				}
```
```
				else
```
```
				{
```

					if ( sourcefilenames.ContainsKey( name ) && targetfilenames.ContainsKey( name ) )

```
					{
```

						if ( sourcefilenames[name] && targetfilenames[name] )

```
						{
```

							string currentlocation = Path.Combine( targetrootdir, file.TrimStart( '\\' ) );

							string sourcelocation = sourcelist.FirstOrDefault( stringToCheck => stringToCheck.Contains( name ) );

							string movetolocation = Path.Combine( targetrootdir, sourcelocation.TrimStart( '\\' ) );

							if ( MOVE( currentlocation, movetolocation ) == 1 && ( debugmode || testmode ) )

```
							{
```
```
								return 1;
```
```
							}
```
```
						}
```
```
						else
```
```
						{
```

							if ( debugmode || testmode || verbose )

```
							{
```

								Display( "SKIPPED: duplicate file name \"{0}\"", name );

```
							}
```
```
							duplicates += 1;
```
```
						}
```
```
					}
```
```
					else
```
```
					{
```

						if ( debugmode || testmode || verbose )

```
						{
```

							Display( "SKIPPED: file \"{0}\" not found in source tree", name );

```
						}
```
```
						// New file in target: SKIP
```
```
						newfiles += 1;
```
```
					}
```
```
				}
```
```
			}
```
```
 
```

			// Cleanup moved folders from target tree

```
			targettree.Sort( );
```

			targettree.Reverse( ); // Reversed sort guarantees that empty subfolders will be deleted first

			foreach ( string dir in targettreeabs )

```
			{
```
```
				if ( !sourcetree.Contains( dir ) )
```
```
				{
```

					if ( Directory.GetFiles( dir, "*.*", SearchOption.TopDirectoryOnly ).Length == 0 )

```
					{
```

						if ( Directory.GetDirectories( dir, "*.*", SearchOption.AllDirectories ).Length == 0 )

```
						{
```
```
							if ( RMDIR( dir ) == 1 )
```
```
							{
```
```
								return 2;
```
```
							}
```
```
						}
```
```
					}
```
```
				}
```
```
			}
```
```
 
```
```
			// End of Main program: show results
```
```
			if ( debugmode || verbose )
```
```
			{
```

				Display( "{0} file location{1} in source and target tree matched", matchingfiles.ToString( ), ( matchingfiles == 1 ? String.Empty : "s" ) );

				Display( "{0} file{1} moved", movedfiles.ToString( ), ( movedfiles == 1 ? " was" : "s were" ) );

				Display( "{0} duplicate file name{1} found", duplicates.ToString( ), ( duplicates == 1 ? " was" : "s were" ) );

				Display( "{0} file{1} found in the target tree that did not exist in the source tree", newfiles.ToString( ), ( newfiles == 1 ? " was" : "s were" ) );

				Display( "\nRoboMove {0}, finished on {1}, at {2}\n", progver, DateTime.Now.Date.ToShortDateString( ), DateTime.Now.ToShortTimeString( ) );

```
			}
```
```
			if ( duplicates + newfiles == 0 )
```
```
			{
```
```
				return WriteLog( );
```
```
			}
```
```
			else
```
```
			{
```
```
				if ( debugmode || verbose )
```
```
				{
```

					int skipped = duplicates + newfiles;

					Display( "{0} file{1} skipped, use the following command to finish synchronization:", skipped.ToString( ), ( skipped == 1 ? " was" : "s were" ) );

					Display( "ROBOCOPY /MIR \"{0}\" \"{1}\"", sourcerootdir, targetrootdir );

```
				}
```
```
				if ( WriteLog( ) == 1 )
```
```
				{
```
```
					return 1;
```
```
				}
```
```
				else
```
```
				{
```
```
					return 2;
```
```
				}
```
```
			}
```
```
		}
```
```
 
```
```
 
```

		static void Display( string text, params string[] values )

```
		{
```

			string newtext = String.Format( text, values );

```
			if ( verbose )
```
```
			{
```
```
				Console.WriteLine( newtext );
```
```
			}
```
```
			if ( logging )
```
```
			{
```
```
				logtext.Add( newtext );
```
```
			}
```
```
		}
```
```
 
```
```
 
```
```
		static int MKDIR( string dir )
```
```
		{
```
```
			if ( testmode )
```
```
			{
```

				Display( "Creating directory \"{0}\" skipped in Test Mode", dir );

```
				return 0;
```
```
			}
```
```
			if ( debugmode || verbose )
```
```
			{
```

				Display( "Creating directory \"{0}\"", dir );

```
			}
```
```
			try
```
```
			{
```
```
				Directory.CreateDirectory( dir );
```
```
				if ( debugmode || verbose )
```
```
				{
```

					Display( "Directory \"{0}\" created successfully", dir );

```
				}
```
```
				return 0;
```
```
			}
```

			catch ( DirectoryNotFoundException e )

```
			{
```

				Display( "Directory not found while trying to create directory \"{0}\": {1}", dir, e.Message );

```
				return 1;
```
```
			}
```
```
			catch ( IOException e )
```
```
			{
```

				Display( "I/O error while trying to create directory \"{0}\": {1}", dir, e.Message );

```
				return 1;
```
```
			}
```
```
		}
```
```
 
```
```
 
```

		static int MOVE( string currentlocation, string newlocation )

```
		{
```
```
			if ( testmode )
```
```
			{
```

				Display( "Moving file \"{0}\" to \"{1}\" skipped in Test Mode", currentlocation, newlocation );

```
				return 0;
```
```
			}
```
```
			if ( debugmode || verbose )
```
```
			{
```

				Display( "Moving file \"{0}\" to \"{1}\"", currentlocation, newlocation );

```
			}
```
```
			try
```
```
			{
```

				File.Move( currentlocation, newlocation );

```
				movedfiles += 1;
```
```
				return 0;
```
```
			}
```

			catch ( DirectoryNotFoundException e )

```
			{
```

				Console.Error.WriteLine( "Directory not found while trying to move \"{0}\" to \"{1}\": {2}", currentlocation, newlocation, e.Message );

```
				return 1;
```
```
			}
```
```
			catch ( IOException e )
```
```
			{
```

				Display( "I/O error while trying to move \"{0}\" to \"{1}\": {2}", currentlocation, newlocation, e.Message );

```
				return 1;
```
```
			}
```
```
		}
```
```
 
```
```
 
```
```
		static int RMDIR( string dir )
```
```
		{
```
```
			if ( testmode )
```
```
			{
```

				Display( "Removing directory \"{0}\" skipped in Test Mode", dir );

```
				return 0;
```
```
			}
```
```
			if ( debugmode || verbose )
```
```
			{
```

				Display( "Removing directory \"{0}\"", dir );

```
			}
```
```
			try
```
```
			{
```
```
				Directory.Delete( dir );
```
```
				return 0;
```
```
			}
```

			catch ( DirectoryNotFoundException e )

```
			{
```

				Display( "Directory not found while trying to remove \"{0}\": {1}", dir, e.Message );

```
				return 1;
```
```
			}
```
```
			catch ( IOException e )
```
```
			{
```

				Display( "I/O error while trying to remove directory \"{0}\": {1}", dir, e.Message );

```
				return 1;
```
```
			}
```
```
		}
```
```
 
```
```
 
```

		static int ShowHelp( params string[] errmsg )

```
		{
```
```
 
```
```
			/*
```
```
			RoboMove,  Version 1.00
```

			Move files in target directory tree to make it match the source directory tree

```
 
```

			Usage:    ROBOMOVE  sourcedir  targetdir  [ options ]

```
 
```

			Where:    "sourcedir"   is the source tree root directory

			          "targetdir"   is the target tree root directory

			Options:  /D            Debugging mode: more screen output than Verbose

			          /L[:logfile]  enable Logging

			                        (default logfile: RoboMove.log in current directory)

			          /O            Overwrite existing logfile (default: append)

			          /T            Test mode: shows the changes that would be made,

			                        but doesn't really make any changes

			          /V            Verbose mode: display every action for every file

```
 
```

			Notes:    ROBOMOVE is a ROBOCOPY like utility, but instead of copying or

			          deleting files, it only moves them. It is intended to be used when

			          large numbers of files have been moved and have to be synchronized

			          with a slow network drive (moving files is faster then copying).

			          ROBOCOPY may be required afterwards to finish the synchronization.

			          Duplicate file names within the directory trees will not be moved.

			          Return code is 0 if all files were moved and no further action is

			          required (i.e. no duplicate or new files), 1 in case of command line

			          errors, 2 if duplicate or new files require ROBOCOPY to be run.

```
 
```
```
			Written by Rob van der Woude
```
```
			http://www.robvanderwoude.com
```
```
			*/
```
```
 
```
```
			if ( errmsg.Length > 0 )
```
```
			{
```

				List<string> errargs = new List<string>( errmsg );

```
				errargs.RemoveAt( 0 );
```
```
				Console.Error.WriteLine( );
```

				Console.ForegroundColor = ConsoleColor.Red;

```
				Console.Error.Write( "ERROR:\t" );
```

				Console.ForegroundColor = ConsoleColor.White;

				Console.Error.WriteLine( errmsg[0], errargs.ToArray( ) );

```
				Console.ResetColor( );
```
```
			}
```
```
 
```
```
			Console.Error.WriteLine( );
```
```
 
```

			Console.Error.WriteLine( "RoboMove,  Version {0}", progver );

```
 
```

			Console.Error.WriteLine( "Move files in target directory tree to make it match the source directory tree" );

```
 
```
```
			Console.Error.WriteLine( );
```
```
 
```
```
			Console.Error.Write( "Usage:    " );
```

			Console.ForegroundColor = ConsoleColor.White;

			Console.Error.WriteLine( "ROBOMOVE  sourcedir  targetdir  [ options ]" );

```
			Console.ResetColor( );
```
```
 
```
```
			Console.Error.WriteLine( );
```
```
 
```
```
			Console.Error.Write( "Where:    " );
```

			Console.ForegroundColor = ConsoleColor.White;

			Console.Error.Write( "\"sourcedir\"" );

```
			Console.ResetColor( );
```

			Console.Error.WriteLine( "   is the source tree root directory" );

```
 
```

			Console.ForegroundColor = ConsoleColor.White;

			Console.Error.Write( "          \"targetdir\"" );

```
			Console.ResetColor( );
```

			Console.Error.WriteLine( "   is the target tree root directory" );

```
 
```
```
			Console.Error.Write( "Options:  " );
```

			Console.ForegroundColor = ConsoleColor.White;

			Console.Error.Write( "/D            D" );

```
			Console.ResetColor( );
```

			Console.Error.Write( "ebugging mode: more screen output than " );

```
			Console.Error.Write( "Options:  " );
```
```
			Console.Error.Write( "V" );
```
```
			Console.ResetColor( );
```
```
			Console.Error.WriteLine( "erbose" );
```
```
 
```

			Console.ForegroundColor = ConsoleColor.White;

			Console.Error.Write( "          /L[:logfile]" );

```
			Console.ResetColor( );
```
```
			Console.Error.Write( "  enable " );
```

			Console.ForegroundColor = ConsoleColor.White;

```
			Console.Error.Write( "L" );
```
```
			Console.ResetColor( );
```
```
			Console.Error.WriteLine( "ogging" );
```
```
 
```

			Console.Error.WriteLine( "                        (default logfile: RoboMove.log in current directory)" );

```
 
```

			Console.ForegroundColor = ConsoleColor.White;

			Console.Error.Write( "          /O            O" );

```
			Console.ResetColor( );
```

			Console.Error.WriteLine( "verwrite existing logfile (default: append)" );

```
 
```

			Console.ForegroundColor = ConsoleColor.White;

			Console.Error.Write( "          /T            T" );

```
			Console.ResetColor( );
```

			Console.Error.WriteLine( "est mode: shows the changes that would be made" );

```
 
```

			Console.Error.WriteLine( "                        but doesn't really make any changes" );

```
 
```

			Console.ForegroundColor = ConsoleColor.White;

			Console.Error.Write( "          /V            V" );

```
			Console.ResetColor( );
```

			Console.Error.WriteLine( "erbose mode: display every action for every file" );

```
 
```
```
			Console.Error.WriteLine( );
```
```
 
```

			Console.Error.WriteLine( "Notes:    ROBOMOVE is a ROBOCOPY like utility, but instead of copying or" );

```
 
```

			Console.Error.WriteLine( "          deleting files, it only moves them. It is intended to be used when" );

```
 
```

			Console.Error.WriteLine( "          large numbers of files have been moved and have to be synchronized" );

```
 
```

			Console.Error.WriteLine( "          with a slow network drive (moving files is faster then copying)." );

```
 
```

			Console.Error.WriteLine( "          ROBOCOPY may be required afterwards to finish the synchronization." );

```
 
```

			Console.Error.WriteLine( "          Duplicate file names within the directory trees will not be moved." );

```
 
```

			Console.Error.WriteLine( "          Return code is 0 if all files were moved and no further action is" );

```
 
```

			Console.Error.WriteLine( "          required (i.e. no duplicate or new files), 1 in case of command line" );

```
 
```

			Console.Error.WriteLine( "          errors, 2 if duplicate or new files require ROBOCOPY to be run." );

```
 
```
```
			Console.Error.WriteLine( );
```
```
 
```

			Console.Error.WriteLine( "Written by Rob van der Woude" );

```
 
```

			Console.Error.WriteLine( "http://www.robvanderwoude.com" );

```
 
```
```
			return 1;
```
```
		}
```
```
 
```
```
 
```
```
		static int WriteLog( )
```
```
		{
```
```
			if ( logging )
```
```
			{
```
```
				try
```
```
				{
```

					StreamWriter file = new StreamWriter( logfile, !overwritelog, Encoding.Default );

```
					foreach ( string line in logtext )
```
```
					{
```
```
						file.WriteLine( line );
```
```
					}
```
```
					file.Close( );
```
```
				}
```
```
				catch ( Exception e )
```
```
				{
```

					return ShowHelp( "Error writing logfile: {0}", e.Message );

```
				}
```
```
			}
```
```
			return 0;
```
```
		}
```
```
	}
```
```
}
```
```
 
```
```
 
```