PageRenderTime 85ms CodeModel.GetById 9ms app.highlight 57ms RepoModel.GetById 1ms app.codeStats 1ms

/Utilities/Helpers/FileHelper.cs

#
C# | 2070 lines | 1228 code | 189 blank | 653 comment | 104 complexity | b7a0f155bd58030704580436144e2d15 MD5 | raw file

Large files files are truncated, but you can click here to view the full file

   1using System;
   2using System.Collections.Generic;
   3using System.IO;
   4using System.Security.Cryptography;
   5using System.Text;
   6using System.Threading;
   7using NUnit.Framework;
   8
   9namespace Delta.Utilities.Helpers
  10{
  11	/// <summary>
  12	/// File helper class to get text lines, number of text lines, etc. This
  13	/// extends the existing File and Path functionality of .NET.
  14	/// <para />
  15	/// This class also abstracts the use of File.Exists and File.Open for
  16	/// IsolatedStorage classes are used, which just allow access to the
  17	/// current directory, which is all we need in the engine internally).
  18	/// </summary>
  19	public static class FileHelper
  20	{
  21		#region Constants
  22		/// <summary>
  23		/// Represents the separator for folders in file paths on microsoft
  24		/// platforms.
  25		/// </summary>
  26		public static readonly char FolderSeparator = '\\';
  27
  28		/// <summary>
  29		/// Represents the separator for folders in file paths on Unix platforms.
  30		/// </summary>
  31		public static readonly char AlternateFolderSeparator = '/';
  32
  33		/// <summary>
  34		/// Both folder separators together in one char array, used for GetFilename
  35		/// </summary>
  36		public static readonly char[] AllFolderSeparators =
  37			new[]
  38			{
  39				FolderSeparator, AlternateFolderSeparator
  40			};
  41
  42		/// <summary>
  43		/// The typical file extension separator is just a dot: .
  44		/// </summary>
  45		public const char FileExtensionSeperator = '.';
  46		#endregion
  47
  48		#region Delegates
  49		internal delegate bool ExistsDelegate(string path);
  50
  51		internal delegate void CopyDelegate(string sourceFile,
  52			string destinationFile);
  53
  54		internal delegate void MoveDelegate(string sourceFile,
  55			string destinationFile);
  56
  57		internal delegate FileStream OpenDelegate(string filePath, FileMode mode,
  58			FileAccess access, FileShare share);
  59
  60		internal delegate void DeleteDelegate(string filePath);
  61
  62		internal delegate bool FileIsNewerDelegate(string fileToCheckIfNewer,
  63			string originalFile);
  64
  65		/// <summary>
  66		/// Compare two files with the help of the MD5-checksum
  67		/// </summary>
  68		/// <param name="fileName1">Filename 1</param>
  69		/// <param name="fileName2">Filename 2</param>
  70		/// <returns>True if both file contents are the same</returns>
  71		internal delegate bool CompareFilesDelegate(string fileName1,
  72			string fileName2);
  73
  74		/// <summary>
  75		/// Check if file exists and is not written to recently. This is mostly
  76		/// used for update checks to see if we can assume this file is complete
  77		/// and we can now open it, etc. (e.g. used in the RestartTool).
  78		/// </summary>
  79		/// <param name="filename">File to check</param>
  80		/// <returns>
  81		/// True if the file exists and was not written to recently.
  82		/// </returns>
  83		internal delegate bool FileNotWrittenToDelegate(string filename);
  84		#endregion
  85
  86		#region Exists (Static)
  87		/// <summary>
  88		/// Check if the file exists.
  89		/// </summary>
  90		/// <param name="filename">Filename</param>
  91		/// <returns>filename</returns>
  92		public static bool Exists(string filename)
  93		{
  94			return ExistsCallback(filename);
  95		}
  96		#endregion
  97
  98		#region Copy (Static)
  99		/// <summary>
 100		/// Copy the source file to the destination file.
 101		/// Note: this method overwrites existing destination files!
 102		/// </summary>
 103		/// <param name="sourceFile">Source filepath.</param>
 104		/// <param name="destinationFile">Destination Filepath.</param>
 105		public static void Copy(string sourceFile, string destinationFile)
 106		{
 107			CopyCallback(sourceFile, destinationFile);
 108		}
 109		#endregion
 110
 111		#region Move (Static)
 112		/// <summary>
 113		/// Move the source file to the destination file.
 114		/// </summary>
 115		/// <param name="sourceFile">Source filepath.</param>
 116		/// <param name="destinationFile">Destination filepath.</param>
 117		public static void Move(string sourceFile, string destinationFile)
 118		{
 119			MoveCallback(sourceFile, destinationFile);
 120		}
 121		#endregion
 122
 123		#region Open (Static)
 124		/// <summary>
 125		/// Opens a the given file (will not create it if it doesn't exists) on
 126		/// platforms where this is possible.
 127		/// <para />
 128		/// Note: The file-mode is "Open" only and the file-access + file-share
 129		/// mode is "Read".
 130		/// </summary>
 131		public static FileStream Open(string filePath)
 132		{
 133			return Open(filePath, FileMode.Open, FileAccess.Read,
 134				FileShare.Read);
 135		}
 136
 137		/// <summary>
 138		/// Open, will use File.Open on platforms where this is possible.
 139		/// </summary>
 140		public static FileStream Open(string filePath, FileMode mode,
 141			FileAccess access, FileShare share)
 142		{
 143			return OpenCallback(filePath, mode, access, share);
 144		}
 145		#endregion
 146
 147		#region Rename (Static)
 148		/// <summary>
 149		/// Rename the file.
 150		/// </summary>
 151		/// <param name="sourceFile">Path to the file to rename.</param>
 152		/// <param name="destFile">Path to the file after rename.</param>
 153		/// <returns>True if succeeded otherwise false.</returns>
 154		public static bool Rename(string sourceFile, string destFile)
 155		{
 156			if (Exists(sourceFile) == false)
 157			{
 158				return false;
 159			}
 160
 161			try
 162			{
 163				Move(sourceFile, destFile);
 164			}
 165			catch
 166			{
 167				return false;
 168			}
 169
 170			return true;
 171		}
 172		#endregion
 173
 174		#region GetFilename (Static)
 175		/// <summary>
 176		/// Extracts filename from full path+filename, but don't cuts off the
 177		/// extension. Can be also used to cut of directories from a path (only
 178		/// last one will remain).
 179		/// </summary>
 180		/// <returns>filename</returns>
 181		public static string GetFilename(string filePath)
 182		{
 183			// Similar code as GetFilename(..), but this method is called more often!
 184
 185			#region Validation
 186			if (String.IsNullOrEmpty(filePath))
 187			{
 188				return "";
 189			}
 190			#endregion
 191
 192			// At first we try to find any folder separators (incl. alternate ones)
 193			int lastSeparatorIndex = filePath.LastIndexOf(FolderSeparator);
 194			int lastAlternateSeperatorIndex = filePath.LastIndexOf(
 195				AlternateFolderSeparator);
 196			// to pick the backmost one
 197			int backMostIndex = (lastSeparatorIndex > lastAlternateSeperatorIndex)
 198			                    	? lastSeparatorIndex
 199			                    	: lastAlternateSeperatorIndex;
 200
 201			// to get only the filename
 202			return (backMostIndex != MathHelper.InvalidIndex)
 203			       	? // -> "Path\SubPath\File.tst" -> "File.tst"
 204			       // -> "Path/SubPath\File.tst" -> "File.tst"
 205			       // -> "Path\SubPath/File.tst" -> "File.tst"
 206			       filePath.Substring(backMostIndex + 1)
 207			       	: // -> "File.tst" -> "File.tst"
 208			       filePath;
 209		}
 210
 211		/// <summary>
 212		/// Extracts filename from full path+filename, but don't cuts off the
 213		/// extension. Can be also used to cut of directories from a path (only
 214		/// last one will remain).
 215		/// </summary>
 216		public static string GetFilename(string filePath, out string pathOnly)
 217		{
 218			#region Validation
 219			if (String.IsNullOrEmpty(filePath))
 220			{
 221				pathOnly = "";
 222				return "";
 223			}
 224			#endregion
 225
 226			// At first we try to find any folder separators (incl. alternate ones)
 227			int lastSeparatorIndex = filePath.LastIndexOf(FolderSeparator);
 228			int lastAlternateSeperatorIndex = filePath.LastIndexOf(
 229				AlternateFolderSeparator);
 230			// to pick the backmost one
 231			int backMostIndex = lastSeparatorIndex > lastAlternateSeperatorIndex
 232			                    	? lastSeparatorIndex
 233			                    	: lastAlternateSeperatorIndex;
 234
 235			if (backMostIndex != MathHelper.InvalidIndex)
 236			{
 237				// -> "Path\SubPath\File.tst" -> "File.tst"
 238				// -> "Path/SubPath\File.tst" -> "File.tst"
 239				// -> "Path\SubPath/File.tst" -> "File.tst"
 240				pathOnly = filePath.Substring(0, backMostIndex);
 241				return filePath.Substring(backMostIndex + 1);
 242			}
 243			else
 244			{
 245				// -> "File.tst" -> "File.tst"
 246				pathOnly = "";
 247				return filePath;
 248			}
 249		}
 250
 251		/// <summary>
 252		/// Extracts filename from full path+filename, cuts of extension
 253		/// if cutExtension is true. Can be also used to cut of directories
 254		/// from a path (only last one will remain).
 255		/// </summary>
 256		public static string GetFilename(string filePath, bool cutExtension)
 257		{
 258			#region Validation
 259			if (String.IsNullOrEmpty(filePath))
 260			{
 261				return "";
 262			}
 263			#endregion
 264
 265			// At first we try to find any folder separators (incl. alternate ones)
 266			int lastSeparatorIndex = filePath.LastIndexOf(FolderSeparator);
 267			int lastAlternateSeperatorIndex = filePath.LastIndexOf(
 268				AlternateFolderSeparator);
 269			// to pick the backmost one
 270			int backMostIndex =
 271				lastSeparatorIndex > lastAlternateSeperatorIndex
 272					? lastSeparatorIndex
 273					: lastAlternateSeperatorIndex;
 274
 275			// Convert to filename, examples:
 276			// -> "Path\SubPath\File.tst" -> "File.tst"
 277			// -> "Path/SubPath\File.tst" -> "File.tst"
 278			// -> "Path\SubPath/File.tst" -> "File.tst"
 279			// -> "File.tst" -> "File.tst"
 280			string filename =
 281				backMostIndex != MathHelper.InvalidIndex
 282					? filePath.Substring(backMostIndex + 1)
 283					: filePath;
 284
 285			// Return the filename without path (and optionally cut of the extension)
 286			// -> "File.tst" -> "File"
 287			return
 288				cutExtension
 289					? CutExtension(filename)
 290					: filename;
 291		}
 292		#endregion
 293
 294		#region IsFilenameOnly (Static)
 295		/// <summary>
 296		/// Is filename only
 297		/// </summary>
 298		/// <param name="anyFilePath">Any file path</param>
 299		public static bool IsFilenameOnly(string anyFilePath)
 300		{
 301			if (String.IsNullOrEmpty(anyFilePath) ||
 302			    // If this is a filename, it better has an extension. Note: This is
 303			    // also used for GetContentName, so all content follows this rule too.
 304			    HasFileNoExtension(anyFilePath))
 305			{
 306				return false;
 307			}
 308
 309			// Make sure the filename does not contain any path elements
 310			if (anyFilePath.IndexOf(FolderSeparator) >= 0 ||
 311			    anyFilePath.IndexOf(AlternateFolderSeparator) >= 0)
 312			{
 313				return false;
 314			}
 315
 316			return true;
 317		}
 318		#endregion
 319
 320		#region HasFileNoExtension (Static)
 321		/// <summary>
 322		/// Has a filename no extension
 323		/// </summary>
 324		/// <param name="anyFilePath">Any file path</param>
 325		/// <returns>True if the given file path has no extension.</returns>
 326		public static bool HasFileNoExtension(string anyFilePath)
 327		{
 328			if (String.IsNullOrEmpty(anyFilePath))
 329			{
 330				return false;
 331			}
 332
 333			// The file extension is always separated with the '.' defined above.
 334			// If we cannot find it, this file has no extension.
 335			return anyFilePath.LastIndexOf(FileExtensionSeperator) < 0;
 336		}
 337		#endregion
 338
 339		#region GetDirectoryPath (Static)
 340		/// <summary>
 341		/// Get directory of path+File, if only a path is given we will cut off
 342		/// the last sub path!
 343		/// </summary>
 344		/// <param name="filePath">File path</param>
 345		/// <returns>Directory path</returns>
 346		public static string GetDirectoryPath(string filePath)
 347		{
 348			// pathFile must be valid
 349			if (String.IsNullOrEmpty(filePath))
 350			{
 351				return "";
 352			}
 353
 354			// If pathFile ends with a folder separator, cut that off!
 355			if (filePath.EndsWith(FolderSeparator.ToString()) ||
 356			    filePath.EndsWith(AlternateFolderSeparator.ToString()))
 357			{
 358				filePath = filePath.Substring(0, filePath.Length - 1);
 359			}
 360
 361			// Normal directory check
 362			int index = filePath.LastIndexOf(FolderSeparator);
 363			int alternateIndex = filePath.LastIndexOf(AlternateFolderSeparator);
 364
 365			if (alternateIndex > index)
 366			{
 367				index = alternateIndex;
 368			}
 369
 370			if (index >= 0 &&
 371			    index < filePath.Length)
 372			{
 373				// Return directory
 374				return filePath.Substring(0, index);
 375			}
 376
 377			// No sub directory found (parent of some directory is "")
 378			// Only exception is when we are on the file system root level (e.g. c:)
 379			return
 380				filePath.Contains(":")
 381					? filePath
 382					: "";
 383		}
 384
 385		/// <summary>
 386		/// Get directory sub path of the given path or file path.
 387		/// (-> e.g. "FileHelper.GetDirectoryPath(@"C:\Ab\cde\App.exe", 2)" will
 388		/// return "C:\Ab")
 389		/// </summary>
 390		/// <param name="filePath">File path</param>
 391		/// <param name="jumpbackCount">
 392		/// The number of folders it should be "jumped" back.
 393		/// </param>
 394		/// <returns>Directory path</returns>
 395		public static string GetDirectoryPath(string filePath, int jumpbackCount)
 396		{
 397			// pathFile must be valid
 398			if (String.IsNullOrEmpty(filePath))
 399			{
 400				return "";
 401			}
 402
 403			// At first split the path in its folder (+ filename) parts
 404			string[] pathParts = filePath.Split(AllFolderSeparators);
 405
 406			// If we less or equal (folder) parts than folders we want to jump back
 407			int remainingPartCount = pathParts.Length - jumpbackCount;
 408			if (remainingPartCount <= 0)
 409			{
 410				// then we will just return an empty path
 411				return "";
 412			}
 413
 414			// Now just count the number of characters we have to cut off
 415			int cutOffCount = 0;
 416			for (int index = remainingPartCount; index < pathParts.Length; index++)
 417			{
 418				cutOffCount += pathParts[index].Length + 1;
 419			}
 420
 421			// And finally just return the remaining path
 422			return filePath.Substring(0, filePath.Length - cutOffCount);
 423		}
 424		#endregion
 425
 426		#region GetFirstDirectoryName (Static)
 427		/// <summary>
 428		/// Get first directory of path or file path! Returns "c:" for "C:\test.x"
 429		/// or "bla" for "bla\blub\honk.txt".
 430		/// </summary>
 431		/// <param name="pathFile">Path file to search</param>
 432		/// <returns>First found directory part</returns>
 433		public static string GetFirstDirectoryName(string pathFile)
 434		{
 435			if (String.IsNullOrEmpty(pathFile))
 436			{
 437				return "";
 438			}
 439
 440			string[] parts = pathFile.Split(new char[]
 441			{
 442				'/', '\\'
 443			});
 444			// Just return the first part
 445			return parts[0];
 446		}
 447		#endregion
 448
 449		#region GetLastDirectoryName (Static)
 450		/// <summary>
 451		/// Get last directory of path+File, if only a path is given we will cut
 452		/// off the last sub path! Returns "Models" for "C:\aoeus\Models\test.x".
 453		/// Warning: If you just use a path, the results might be different from
 454		/// what you want (use GetFilename instead): ""C:\aoeus\Models" will return
 455		/// "aoeus" and not "Models".
 456		/// </summary>
 457		/// <param name="pathFile">Path file to search</param>
 458		/// <returns>Last found directory</returns>
 459		public static string GetLastDirectoryName(string pathFile)
 460		{
 461			if (String.IsNullOrEmpty(pathFile))
 462			{
 463				return "";
 464			}
 465
 466			string dir1 = GetDirectoryPath(pathFile);
 467			string dir2 = GetDirectoryPath(dir1);
 468
 469			// No other sub directory found?
 470			if (String.IsNullOrEmpty(dir2))
 471			{
 472				return dir1;
 473			}
 474
 475			// Remove dir2 part including "\\" or "/"
 476			return dir1.Remove(0, dir2.Length + 1);
 477		}
 478		#endregion
 479
 480		#region RemoveFirstDirectory (Static)
 481		/// <summary>
 482		/// Remove first directory of path if one exists. "maps\\mymaps\\hehe.map"
 483		/// becomes "mymaps\\hehe.map". Also used to cut first folder off,
 484		/// especially useful for paths. e.g. "maps\\test" becomes "test".
 485		/// </summary>
 486		/// <param name="path">Path</param>
 487		/// <returns>Reduced directory path</returns>
 488		public static string RemoveFirstDirectory(string path)
 489		{
 490			int index = path.IndexOf(FolderSeparator);
 491			if (index >= 0 &&
 492			    index < path.Length)
 493			{
 494				// Return rest of path
 495				return path.Substring(index + 1);
 496			}
 497			index = path.IndexOf(AlternateFolderSeparator);
 498			if (index >= 0 &&
 499			    index < path.Length)
 500			{
 501				// Return rest of path
 502				return path.Substring(index + 1);
 503			}
 504
 505			// No first directory found, just return original path
 506			return path;
 507		}
 508		#endregion
 509
 510		#region CutExtension (Static)
 511		/// <summary>
 512		/// Cut of extension, e.g. "hi.txt" becomes "hi"
 513		/// </summary>
 514		/// <param name="file">File</param>
 515		/// <returns>Filename without extension</returns>
 516		public static string CutExtension(string file)
 517		{
 518			if (String.IsNullOrEmpty(file))
 519			{
 520				return "";
 521			}
 522
 523			// Don't cut below any directory structure (which may contain points)
 524			int maxLastSeparatorIndex = file.LastIndexOf(FolderSeparator);
 525			int alternateSeparatorIndex = file.LastIndexOf(AlternateFolderSeparator);
 526			if (alternateSeparatorIndex > maxLastSeparatorIndex)
 527			{
 528				maxLastSeparatorIndex = alternateSeparatorIndex;
 529			}
 530
 531			// Get extension position.
 532			int lastPointPos = file.LastIndexOf(FileExtensionSeperator);
 533
 534			// Only cut off stuff if we have valid indices, else return the input
 535			return
 536				lastPointPos > 0 &&
 537				lastPointPos > maxLastSeparatorIndex
 538					? file.Remove(lastPointPos, file.Length - lastPointPos)
 539					: file;
 540		}
 541		#endregion
 542
 543		#region GetExtension (Static)
 544		/// <summary>
 545		/// Get extension (whatever is behind that '.'), e.g. "test.bmp" will
 546		/// return "bmp". Only a filename will return "", e.g. "Test" returns ""
 547		/// </summary>
 548		/// <param name="file">Filename to get the extension from</param>
 549		/// <returns>Returns the extension string of the file.</returns>
 550		public static string GetExtension(string file)
 551		{
 552			if (String.IsNullOrEmpty(file))
 553			{
 554				return "";
 555			}
 556
 557			int lastPointPos = file.LastIndexOf(FileExtensionSeperator);
 558
 559			// Don't cut below any directory structure (which may contain points)
 560			int lastDirectoryPos = file.LastIndexOf(FolderSeparator);
 561			int alternateSeparatorIndex = file.LastIndexOf(AlternateFolderSeparator);
 562			if (alternateSeparatorIndex > lastDirectoryPos)
 563			{
 564				lastDirectoryPos = alternateSeparatorIndex;
 565			}
 566			if (lastPointPos > 0 &&
 567			    lastPointPos > lastDirectoryPos &&
 568			    lastPointPos < file.Length)
 569			{
 570				return file.Remove(0, lastPointPos + 1);
 571			}
 572
 573			// No extension found, return empty string (filename without extension).
 574			return "";
 575		}
 576		#endregion
 577
 578		#region TryToUseRelativePath (Static)
 579		/// <summary>
 580		/// Helper function for saving, we check if path starts with same as
 581		/// our application. If so, better use relative path, then we can use
 582		/// them even if application is moved or copied over network!
 583		/// </summary>
 584		/// <param name="fullPath">Full path to check against</param>
 585		/// <returns>Relative path starting at fullPath if possible</returns>
 586		public static string TryToUseRelativePath(string fullPath)
 587		{
 588			return TryToUseRelativePath(Environment.CurrentDirectory, fullPath);
 589		}
 590
 591		/// <summary>
 592		/// Helper function for saving, we check if path starts with same as
 593		/// our application. If so, better use relative path, then we can use
 594		/// them even if application is moved or copied over network!
 595		/// </summary>
 596		/// <param name="pathToCheckFrom">Path to check from (e.g. from our
 597		/// application) and the origin for the relative path that is returned
 598		/// </param>
 599		/// <param name="fullPath">Full path to check against</param>
 600		/// <returns>Relative path starting at fullPath if possible</returns>
 601		public static string TryToUseRelativePath(string pathToCheckFrom,
 602			string fullPath)
 603		{
 604			if (fullPath != null &&
 605			    fullPath.StartsWith(pathToCheckFrom))
 606			{
 607				int len = pathToCheckFrom.Length;
 608				// +1 to remove '/' too
 609				if (!pathToCheckFrom.EndsWith(@"\"))
 610				{
 611					len++;
 612				}
 613				return fullPath.Remove(0, len);
 614			} // if (fullPath)
 615			// Startup path not found, so either its relative already or
 616			// we can't use relative path that easy!
 617			return fullPath;
 618		}
 619		#endregion
 620
 621		#region TryToUseAbsolutePath (Static)
 622		/// <summary>
 623		/// Helper method to use an absolute path. If the path is already absolute
 624		/// nothing will change, but if the path is relative the basePath is added.
 625		/// </summary>
 626		/// <param name="basePath">Path to check from</param>
 627		/// <param name="possibleFullPath">Full or relative path to check.</param>
 628		/// <returns>Absolute path to the file</returns>
 629		public static string TryToUseAbsolutePath(string basePath,
 630			string possibleFullPath)
 631		{
 632			// If the path is relative, combine it
 633			if (Path.IsPathRooted(possibleFullPath) == false)
 634			{
 635				return Path.Combine(basePath, possibleFullPath);
 636			}
 637			// Otherwise just return the original absolute path.
 638			return possibleFullPath;
 639		}
 640		#endregion
 641
 642		#region IsDirectSubFolder (Static)
 643		/// <summary>
 644		/// Check if a folder is a direct sub folder of a main folder.
 645		/// True is only returned if this is a direct sub folder, not if
 646		/// it is some sub folder few levels below.
 647		/// </summary>
 648		/// <param name="mainFolder">MainFolder</param>
 649		/// <param name="subFolder">SubFolder</param>
 650		/// <returns>
 651		/// True if the subFolder is a direct sub folder of mainFolder.
 652		/// </returns>
 653		public static bool IsDirectSubFolder(string subFolder, string mainFolder)
 654		{
 655			// First check if subFolder is really a sub folder of mainFolder
 656			if (subFolder != null &&
 657			    subFolder.StartsWith(mainFolder))
 658			{
 659				// Same order?
 660				if (subFolder.Length <
 661				    mainFolder.Length + 1)
 662				{
 663					// Then it ain't a sub folder!
 664					return false;
 665				}
 666
 667				// Ok, now check if this is direct sub folder or some sub folder
 668				// of mainFolder sub folder
 669				string folder = subFolder.Remove(0, mainFolder.Length + 1);
 670
 671				// Check if this is really a direct sub folder
 672				if (folder.IndexOf(FolderSeparator) >= 0 ||
 673				    folder.IndexOf(AlternateFolderSeparator) >= 0)
 674				{
 675					// No, this is a sub folder of mainFolder sub folder
 676					return false;
 677				}
 678
 679				// Ok, this is a direct sub folder of mainFolder!
 680				return true;
 681			}
 682
 683			// Not even any sub folder!
 684			return false;
 685		}
 686		#endregion
 687
 688		#region CleanupWindowsPath (Static)
 689		/// <summary>
 690		/// Cleans up the given path, so that it's in an homogenous unix/web path.
 691		/// E.g. ".\MyPath\With/Subfolder" => "My/Path/With/Subfolder"
 692		/// Also used by our whole content pipeline to make searching easier.
 693		/// </summary>
 694		/// <param name="anyPath">Any path in windows or unix format</param>
 695		/// <returns>Path in windows format</returns>
 696		public static string CleanupWindowsPath(string anyPath)
 697		{
 698			// Validation check
 699			if (String.IsNullOrEmpty(anyPath))
 700			{
 701				return "";
 702			}
 703
 704			// First we make sure the we have an homogenous windows path format
 705			if (anyPath.StartsWith("file:///"))
 706			{
 707				anyPath = anyPath.Substring("file:///".Length);
 708			}
 709			anyPath = anyPath.Replace("/", @"\");
 710
 711			// If the path begins with "./" like e.g. ".\MyFolder\With\Subfolder",
 712			// then we cut this away, because we don't need that and it makes the
 713			// path more tight, might happen on windows
 714			// else return the cleaned path
 715			return
 716				anyPath.StartsWith(@".\")
 717					? anyPath.Substring(2)
 718					: anyPath;
 719		}
 720		#endregion
 721
 722		#region CleanupLinuxPath (Static)
 723		/// <summary>
 724		/// Cleans up the given path, so that it's in an homogenous unix/web path.
 725		/// E.g. ".\MyPath\With/Subfolder" => "My/Path/With/Subfolder"
 726		/// Also used by our whole content pipeline to make searching easier.
 727		/// </summary>
 728		/// <param name="anyPath">Any path in windows or unix format</param>
 729		/// <returns>Path in unix format</returns>
 730		public static string CleanupLinuxPath(string anyPath)
 731		{
 732			// Validation check
 733			if (String.IsNullOrEmpty(anyPath))
 734			{
 735				return "";
 736			}
 737
 738			// First we make sure the we have an homogenous unix/web path format
 739			if (anyPath.StartsWith(@"\\"))
 740			{
 741				anyPath = "file://///" + anyPath.Substring(2);
 742			}
 743			anyPath = anyPath.Replace(@"\", "/");
 744
 745			// If the path begins with "./" like e.g. "./MyFolder/With/Subfolder",
 746			// then we cut this away, because we don't need that and it makes the
 747			// else return the cleaned path
 748			return
 749				anyPath.StartsWith("./")
 750					? anyPath.Substring(2)
 751					: anyPath;
 752		}
 753		#endregion
 754
 755		#region GetRelativeFilePath (Static)
 756		/// <summary>
 757		/// Get relative file path of a given absolute file path based on basePath.
 758		/// If the basePath and the absoluteFilePath share something in common this
 759		/// method will try to remove the common part (e.g. "c:\code\Delta\bla"
 760		/// in the basePath "c:\code" will be reduced to "Delta\bla" or in the
 761		/// basePath "c:\code\DeltaEngine" will be "..\Delta\bla").
 762		/// </summary>
 763		/// <param name="absoluteFilePath">
 764		/// Absolute file path, might already be relative or even be on a different
 765		/// drive, then it will just be returned.
 766		/// </param>
 767		/// <param name="basePath">Base path</param>
 768		/// <returns>Relative path if possible</returns>
 769		public static string GetRelativeFilePath(string absoluteFilePath,
 770			string basePath)
 771		{
 772			#region Validation checks
 773			if (String.IsNullOrEmpty(absoluteFilePath))
 774			{
 775				return "";
 776			}
 777
 778			if (String.IsNullOrEmpty(basePath))
 779			{
 780				return absoluteFilePath;
 781			}
 782			#endregion
 783
 784			// We can only easily "build" the relative content path, if the given
 785			// file path starts with the given content base path.
 786			string relativeContentFilePath =
 787				absoluteFilePath.StartsWith(basePath)
 788					? absoluteFilePath.Substring(basePath.Length)
 789					: absoluteFilePath;
 790
 791			// If that did not worked, we can also check folder by folder if
 792			// the two path strings are equal up to a certain point.
 793			if (relativeContentFilePath == absoluteFilePath)
 794			{
 795				string[] basePathParts = basePath.Split(new char[]
 796				{
 797					'\\', '/'
 798				});
 799				string[] absoluteFilePathParts = absoluteFilePath.Split(new char[]
 800				{
 801					'\\', '/'
 802				});
 803
 804				// Continue checking as long as the parts are equal. Note: This will
 805				// abort in the first loop when the drives are different or one part
 806				// is not absolute.
 807				int num = 0;
 808				for (; num < basePathParts.Length &&
 809					num < absoluteFilePathParts.Length; num++)
 810				{
 811					if (basePathParts[num] != absoluteFilePathParts[num])
 812					{
 813						break;
 814					}
 815					// Remove this part as it is equal (plus the separator)!
 816					relativeContentFilePath =
 817						relativeContentFilePath.Substring(basePathParts[num].Length + 1);
 818				}
 819
 820				// Nothing matched? Then just return the absolute path again!
 821				if (num == 0)
 822				{
 823					return absoluteFilePath;
 824				}
 825
 826				// Otherwise add the number of parts we are away from the base path.
 827				for (; num < basePathParts.Length; num++)
 828				{
 829					relativeContentFilePath = "..\\" + relativeContentFilePath;
 830				}
 831			}
 832
 833			// If the path starts with a "folder backslash" like "\Folder" then cut
 834			// it off
 835			return
 836				relativeContentFilePath.StartsWith(@"\")
 837					? relativeContentFilePath.Substring(1)
 838					: relativeContentFilePath;
 839		}
 840		#endregion
 841		
 842		#region TrimPath (Static)
 843		/// <summary>
 844		/// Removes all unnecessary relative path fragments and will return a
 845		/// trimmed path. Useful in combination with GetRelativeFilePath.
 846		/// <para />
 847		/// Example: "C:\Path\SubPath1\..\SubPath2\file.exe" will become to
 848		/// "C:\Path\SubPath2\file.exe". Also works with relative paths and unix
 849		/// paths (e.g. '/SomePath/../SomeFile.xml' will become 'SomeFile.xml').
 850		/// </summary>
 851		/// <param name="filePath">Path to be shortened if possible.</param>
 852		public static string TrimPath(string filePath)
 853		{
 854			// If the filePath has no ..\ in it, ignore it and just return it!
 855			if (String.IsNullOrEmpty(filePath) ||
 856				(filePath.Contains("..\\") == false &&
 857				filePath.Contains("../") == false))
 858			{
 859				return filePath;
 860			}
 861
 862			// Network paths need the \\ added again after we are done processing
 863			bool isNetworkPath = filePath.StartsWith(@"\\");
 864
 865			// Go through the path and collect all parts.
 866			string[] pathParts = filePath.Split(new char[]
 867			{
 868				'\\', '/'
 869			});
 870
 871			// Now collect all .. parts and cut off previous directories!
 872			List<string> result = new List<string>();
 873			foreach (string part in pathParts)
 874			{
 875				// Also ignore the . and empty parts (e.g. \ or at the beginning).
 876				if (String.IsNullOrEmpty(part))
 877				{
 878					continue;
 879				}
 880				// For .. entries remove the last real path entry we added
 881				if (result.Count > 0 &&
 882				    result[result.Count - 1] != ".." &&
 883				    part == "..")
 884				{
 885					result.RemoveAt(result.Count - 1);
 886				}
 887				else
 888				{
 889					// Otherwise add the path part normally (might even be .. if there
 890					// is nothing more we can cut off).
 891					result.Add(part);
 892				}
 893			}
 894
 895			// Return the result in windows path mode if the incoming path contained
 896			// backslashes, otherwise return it in linux format.
 897			return
 898				(isNetworkPath
 899				 	? @"\\"
 900				 	: "") +
 901				ArrayHelper.Write(result,
 902					filePath.Contains("\\")
 903						? "\\"
 904						: "/");
 905		}
 906		#endregion
 907
 908		#region GetFileSize (Static)
 909		/// <summary>
 910		/// Get file size. Returns 0 if file does not exists instead of throwing
 911		/// an exception. Else it returns file size as a long number.
 912		/// </summary>
 913		/// <param name="filename">Filename</param>
 914		/// <returns>Long</returns>
 915		public static long GetFileSize(string filename)
 916		{
 917			if (Exists(filename))
 918			{
 919				using (FileStream fileStream = Open(filename,
 920					FileMode.Open, FileAccess.Read, FileShare.ReadWrite))
 921				{
 922					return fileStream.Length;
 923				}
 924			}
 925
 926			return 0;
 927		}
 928		#endregion
 929
 930		#region GetLines (Static)
 931		/// <summary>
 932		/// Returns the text lines we got in a file.
 933		/// </summary>
 934		/// <param name="filename">Filename</param>
 935		/// <returns>
 936		/// All text lines from the file or null if no file was found.
 937		/// </returns>
 938		public static string[] GetLines(string filename)
 939		{
 940			return GetLines(filename, Encoding.UTF8);
 941		}
 942
 943		/// <summary>
 944		/// Returns the text lines we got in a file. Will not crash! If file does
 945		/// not exist, we will just return null, same for an unreadable file.
 946		/// </summary>
 947		/// <param name="filename">Filename</param>
 948		/// <param name="textEncoding">Text encoding</param>
 949		/// <returns>
 950		/// All text lines from the file or null if no file was found.
 951		/// </returns>
 952		public static string[] GetLines(string filename, Encoding textEncoding)
 953		{
 954			// If filename is invalid or file does not exist, just abort!
 955			if (String.IsNullOrEmpty(filename) ||
 956			    Exists(filename) == false)
 957			{
 958				return null;
 959			}
 960
 961			try
 962			{
 963				List<string> lines = new List<string>();
 964
 965				using (FileStream stream = Open(filename, FileMode.Open,
 966					FileAccess.Read, FileShare.ReadWrite))
 967				{
 968					StreamReader reader = new StreamReader(stream, textEncoding);
 969					do
 970					{
 971						lines.Add(reader.ReadLine());
 972					} while (reader.Peek() >
 973					         -1);
 974				}
 975
 976				return lines.ToArray();
 977			}
 978			catch (Exception ex)
 979			{
 980				Log.Warning(String.Format("Failed to GetLines of file={0}: {1}",
 981					filename, ex));
 982				// Failed to read, just return null!
 983				return null;
 984			}
 985		}
 986		#endregion
 987
 988		#region GetText (Static)
 989		/// <summary>
 990		/// Gets all the text of a file (e.g. if you just want to the text of a
 991		/// text file). Will not crash! If file does not exist, we will just return
 992		/// an empty string. If file is somehow unreadable, we will log an warning
 993		/// (because this shouldn't happen, we should always open files in a way
 994		/// that allows reading) and return an empty string too.
 995		/// </summary>
 996		/// <param name="filename">Filename for the file to load</param>
 997		/// <returns>String with all the text from the file</returns>
 998		public static string GetText(string filename)
 999		{
1000			string error;
1001			string text = GetText(filename, out error);
1002
1003			// Log out the error if there was one
1004			if (String.IsNullOrEmpty(error) == false)
1005			{
1006				Log.Warning(error);
1007			}
1008
1009			return text;
1010		}
1011
1012		/// <summary>
1013		/// Gets all the text of a file (e.g. if you just want to the text of a
1014		/// text file). Will not crash! If file does not exist, we will just return
1015		/// an empty string. If file is somehow unreadable, we will log an warning
1016		/// (because this shouldn't happen, we should always open files in a way
1017		/// that allows reading) and return an empty string too.
1018		/// </summary>
1019		/// <param name="filename">Filename for the file to load</param>
1020		/// <returns>String with all the text from the file</returns>
1021		public static string GetText(string filename, out string error)
1022		{
1023			// If filename is invalid or file does not exist, just abort!
1024			if (String.IsNullOrEmpty(filename) ||
1025			    Exists(filename) == false)
1026			{
1027				error = "GetText failed to get non existing file: '" + filename + "'";
1028				return "";
1029			}
1030
1031			try
1032			{
1033				using (StreamReader reader =
1034					new StreamReader(OpenFileAsStream(filename), Encoding.UTF8))
1035				{
1036					error = "";
1037					return reader.ReadToEnd();
1038				}
1039			}
1040			catch (Exception ex)
1041			{
1042				error = "Failed to GetText of file='" + filename + "': " + ex.Message;
1043				// Failed to read, just return an empty string!
1044				return "";
1045			}
1046		}
1047		#endregion
1048
1049		#region PathCombine (Static)
1050		/// <summary>
1051		/// Path combining methods to ensure each path is compatible. This is
1052		/// more powerful than Path.Combine and handles all platform cases and
1053		/// should be used if you need your code to run on all platforms.
1054		/// </summary>
1055		/// <param name="path1">Path 1</param>
1056		/// <param name="path2">Path 2</param>
1057		/// <returns>Combined path</returns>
1058		public static string PathCombine(string path1, string path2)
1059		{
1060			// If either one of the two paths are empty/null, return nothing.
1061			if ((path1 == null) ||
1062			    (path2 == null))
1063			{
1064				return "";
1065			}
1066
1067			// If either path contains the wrong "slash", revert to the correct one
1068			if ((path1.Contains(@"\")) ||
1069			    (path2.Contains(@"\")))
1070			{
1071				path1 = path1.Replace(@"\", "/");
1072				path2 = path2.Replace(@"\", "/");
1073			}
1074
1075			// If either path starts with either a "/" or a ".", remove them
1076			if (path1.StartsWith(@"/") ||
1077			    path1.StartsWith("."))
1078			{
1079				path1 = path1.Remove(0, 1);
1080			}
1081			if (path2.StartsWith(@"/") ||
1082			    path2.StartsWith("."))
1083			{
1084				path2 = path2.Remove(0, 1);
1085			}
1086
1087			// If either path ends with either a "/" or a ".", remove them.
1088			if (path1.EndsWith(@"/") ||
1089			    path1.EndsWith("."))
1090			{
1091				path1 = path1.Substring(0, path1.Length - 1);
1092			}
1093			if (path2.EndsWith(@"/") ||
1094			    path2.EndsWith("."))
1095			{
1096				path2 = path2.Substring(0, path2.Length - 1);
1097			}
1098
1099			// Return our combined path with the correct seperator
1100			return (path1 + "/" + path2);
1101		}
1102		#endregion
1103
1104		#region GetLinesCount (Static)
1105		/// <summary>
1106		/// Returns the number of text lines we got in a text file.
1107		/// </summary>
1108		/// <param name="filename">Filename</param>
1109		/// <returns>Number of lines in the given text file.</returns>
1110		public static int GetLinesCount(string filename)
1111		{
1112			int lines = 0;
1113
1114			try
1115			{
1116				using (StreamReader reader = new StreamReader(Open(
1117					filename, FileMode.Open, FileAccess.Read, FileShare.ReadWrite),
1118					Encoding.UTF8))
1119				{
1120					do
1121					{
1122						reader.ReadLine();
1123						lines++;
1124					} while (reader.Peek() >
1125					         -1);
1126				}
1127			}
1128			catch
1129			{
1130			} // catch
1131
1132			// Failed to read, just return 0 lines!
1133			return lines;
1134		}
1135		#endregion
1136
1137		#region CreateTextFile (Static)
1138		/// <summary>
1139		/// Create text file or overwrite an existing file. Will store all the
1140		/// given text into it with the optional Encoding (default is UTF8).
1141		/// </summary>
1142		/// <param name="filename">Filename to save text to</param>
1143		/// <param name="textForFile">Text to store in the new file</param>
1144		/// <param name="encoding">
1145		/// Encoding to use for file, by default UTF8
1146		/// </param>
1147		/// <exception cref="IOException">
1148		/// Will be thrown if file already exists and could not be overwritten or
1149		/// if creating the file failed for other reasons (e.g. unable to write).
1150		/// </exception>
1151		public static void CreateTextFile(string filename, string textForFile,
1152			Encoding encoding = null)
1153		{
1154			using (TextWriter textWriter = new StreamWriter(Open(
1155				filename, FileMode.Create, FileAccess.Write, FileShare.ReadWrite),
1156				encoding ?? Encoding.UTF8))
1157			{
1158				/*this is nice, but slow, it should not be required anymore!
1159				string[] textLines = StringHelper.SplitMultiLineText(textForFile);
1160				foreach (string line in textLines)
1161				{
1162					textWriter.WriteLine(line);
1163				}
1164				 */
1165				textWriter.Write(textForFile);
1166				textWriter.Close();
1167			}
1168		}
1169
1170		/// <summary>
1171		/// Create text file. Will create a new file and store all the given text
1172		/// lines into it with the optional Encoding (default is UTF8).
1173		/// </summary>
1174		/// <param name="filename">Filename to save text to</param>
1175		/// <param name="textLines">Text lines to store</param>
1176		/// <param name="encoding">
1177		/// Encoding to use for file, by default UTF8
1178		/// </param>
1179		/// <exception cref="IOException">
1180		/// Will be thrown if file already exists and could not be overwritten or
1181		/// if creating the file failed for other reasons (e.g. unable to write).
1182		/// </exception>
1183		public static void CreateTextFile(string filename, string[] textLines,
1184			Encoding encoding = null)
1185		{
1186			using (StreamWriter textWriter = new StreamWriter(Open(
1187				filename, FileMode.Create, FileAccess.Write, FileShare.ReadWrite),
1188				encoding ?? Encoding.UTF8))
1189			{
1190				foreach (string line in textLines)
1191				{
1192					textWriter.WriteLine(line);
1193				}
1194				textWriter.Close();
1195			}
1196		}
1197		#endregion
1198
1199		#region CreateBinaryFile (Static)
1200		/// <summary>
1201		/// Helper method to create a binary file with the given byte data array.
1202		/// /// <para />
1203		/// Note: If the file exists, it will just be overwritten. The path to
1204		/// the filename must exist however, else this will throw an exception.
1205		/// Also if writing this file is not possible an access denied IOException
1206		/// will be thrown.
1207		/// </summary>
1208		/// <param name="filename">Filename to save binary data to</param>
1209		/// <param name="binaryData">The data to save</param>
1210		public static void CreateBinaryFile(string filename, byte[] binaryData)
1211		{
1212			using (FileStream fileStream = Open(
1213				filename, FileMode.Create, FileAccess.Write, FileShare.ReadWrite))
1214			{
1215				fileStream.Write(binaryData, 0, binaryData.Length);
1216			}
1217		}
1218
1219		/// <summary>
1220		/// Helper method to create a binary file with the given memory stream.
1221		/// <para />
1222		/// Note: If the file exists, it will just be overwritten. The path to
1223		/// the filename must exist however, else this will throw an exception.
1224		/// Also if writing this file is not possible an access denied IOException
1225		/// will be thrown.
1226		/// </summary>
1227		/// <param name="filename">Filename to save binary data to</param>
1228		/// <param name="data">The data to save</param>
1229		public static void CreateBinaryFile(string filename, MemoryStream data)
1230		{
1231			using (FileStream fileStream = Open(
1232				filename, FileMode.Create, FileAccess.Write, FileShare.ReadWrite))
1233			{
1234				fileStream.Write(data.ToArray(), 0, (int)data.Length);
1235			}
1236		}
1237		#endregion
1238
1239		#region GetBytes (Static)
1240		/// <summary>
1241		/// Helper method to grab all bytes of a binary file and then close it
1242		/// again. Will not crash! If file does not exist, we will just return
1243		/// an empty array. If file is somehow unreadable, we will log an warning
1244		/// (because this shouldn't happen, we should always open files in a way
1245		/// that allows reading) and return an empty array too.
1246		/// </summary>
1247		/// <param name="filename">File to load</param>
1248		/// <returns>Array of bytes from the file</returns>
1249		public static byte[] GetBytes(string filename)
1250		{
1251			// If filename is invalid or file does not exist, just abort!
1252			if (String.IsNullOrEmpty(filename) ||
1253			    Exists(filename) == false)
1254			{
1255				Log.Warning("GetBytes failed to get non existing file: " + filename);
1256				return new byte[0];
1257			}
1258
1259			try
1260			{
1261				using (Stream fileStream = OpenFileAsStream(filename))
1262				{
1263					byte[] bytes = new byte[fileStream.Length];
1264					fileStream.Read(bytes, 0, bytes.Length);
1265					return bytes;
1266				}
1267			}
1268			catch (Exception ex)
1269			{
1270				Log.Warning("Failed to GetBytes of file '" + filename + "': " + ex);
1271				// Failed to read, just return an empty array!
1272				return new byte[0];
1273			}
1274		}
1275		#endregion
1276
1277		#region SafeDelete (Static)
1278		/// <summary>
1279		/// Safely deletes a file.
1280		/// </summary>
1281		/// <param name="filePath">File to delete</param>
1282		/// <returns>True if file was deleted or did not exist anymore</returns>
1283		public static bool SafeDelete(string filePath)
1284		{
1285			if (String.IsNullOrEmpty(filePath) ||
1286			    Exists(filePath) == false)
1287			{
1288				// File did not exist, so no deletion was required
1289				// (return true to mark that this file is gone now because it
1290				// was already gone).
1291				return true;
1292			}
1293
1294			try
1295			{
1296				DeleteCallback(filePath);
1297				return true;
1298			}
1299			catch (IOException ioEx)
1300			{
1301				if (ioEx.Message.Contains("The process cannot access the file"))
1302				{
1303					// Try to wait a short while, maybe it is free soon
1304					Thread.Sleep(50);
1305
1306					// And try to delete it again
1307					try
1308					{
1309						DeleteCallback(filePath);
1310						// Everything is fine now, quit without logging an error
1311						return true;
1312					}
1313					catch (Exception ex)
1314					{
1315						Log.Warning("Couldn't safely delete file even with waiting '" +
1316						            filePath + "' because of: " + ex.Message);
1317					}
1318				}
1319			}
1320			catch (Exception ex)
1321			{
1322				Log.Warning("Couldn't safely delete file '" + filePath +
1323				            "' because of: " + ex.Message);
1324			}
1325
1326			// File was not deleted
1327			return false;
1328		}
1329		#endregion
1330
1331		#region SafeDeleteFiles (Static)
1332		/// <summary>
1333		/// Safely delete the files matching the search pattern in the base
1334		/// directory and if wanted recursive in sub directories as well.
1335		/// </summary>
1336		/// <param name="basePath">Base Path</param>
1337		/// <param name="recursive">Recursive</param>
1338		/// <param name="searchPattern">Search Pattern</param>
1339		/// <returns>True if deleting the files worked (no matter if it actually
1340		/// deleted something or not), false otherwise (warnings for failed file
1341		/// deletes will be outputted via the SafeDelete method)</returns>
1342		public static bool SafeDeleteFiles(string basePath, string searchPattern,
1343			bool recursive)
1344		{
1345			if (DirectoryHelper.Exists(basePath) == false)
1346			{
1347				return true;
1348			}
1349
1350			string[] files = recursive
1351			                 	? DirectoryHelper.GetFilesRecursive(basePath, searchPattern)
1352			                 	: DirectoryHelper.GetFiles(basePath, searchPattern);
1353
1354			foreach (string file in files)
1355			{
1356				SafeDelete(file);
1357			}
1358
1359			return true;
1360		}
1361		#endregion
1362
1363		#region CheckIfFileIsNewer (Static)
1364		/// <summary>
1365		/// Check if file is newer. Not the fastest method ever as it needs
1366		/// to load both files and compare their last write times.
1367		/// </summary>
1368		/// <param name="fileToCheckIfNewer">File to check if newer</param>
1369		/// <param name="originalFile">Original File</param>
1370		/// <returns>True if the file is newer than the original.</returns>
1371		public static bool CheckIfFileIsNewer(string fileToCheckIfNewer,
1372			string originalFile)
1373		{
1374			// Got no file to check, then we can't compare and should not copy.
1375			if (Exists(fileToCheckIfNewer) == false)
1376			{
1377				return false;
1378			}
1379			// For no original file, the new file is obviously newer than nothing!
1380			if (Exists(originalFile) == false)
1381			{
1382				return true;
1383			}
1384
1385			return FileIsNewerCallback(fileToCheckIfNewer, originalFile);
1386		}
1387		#endregion
1388
1389		#region ExistsPath (Static)
1390		/// <summary>
1391		/// Exist path, will check if a full file path or just a directory path
1392		/// exists. This is different from the DirectoryHelper.Exists method,
1393		/// which just checks if a directory path exists (this one checks for
1394		/// files too if a valid extension for a file path was given).
1395		/// </summary>
1396		/// <param name="path">A path from a file or a directory</param>
1397		/// <returns>True if the path was found as a file or directory</returns>
1398		public static bool ExistsPath(string path)
1399		{
1400			if (Path.HasExtension(path))
1401			{
1402				return Exists(path);
1403			}
1404			return DirectoryHelper.Exists(path);
1405		}
1406		#endregion
1407
1408		#region CutPath (Static)
1409		/// <summary>
1410		/// Cuts off the given "cut path" completely from the given filePath.
1411		/// </summary>
1412		/// <param name="filePath">
1413		/// Any absolute or relative file or folder path.
1414		/// </param>
1415		/// <param name="pathToCutOff">
1416		/// The path (or folder) which should be cut off completely.
1417		/// </param>
1418		/// <returns>FilePath without pathToCutOff</returns>
1419		public static string CutPath(string filePath, string pathToCutOff)
1420		{
1421			#region Validation
1422			if (String.IsNullOrEmpty(filePath))
1423			{
1424				return "";
1425			}
1426			#endregion
1427
1428			// IF we have a valid path which should be cut off
1429			if (String.IsNullOrEmpty(pathToCutOff) == false)
1430			{
1431				// then try to find that (sub)path or folder in the given file path
1432				int cutOffIndex = filePath.IndexOf(pathToCutOff);
1433				// If it really exists in the file path
1434				if (cutOffIndex != MathHelper.InvalidIndex)
1435				{
1436					cutOffIndex += pathToCutOff.Length;
1437					// then just check if the "cut off path" ends already with an "\"
1438					if (pathToCutOff[pathToCutOff.Length - 1] != '\\')
1439					{
1440						// because if not then we have to increase the index by that
1441						cutOffIndex++;
1442					}
1443
1444					// before we can finally cut off the subpath, but only if we
1445					// don't will cut off a filename
1446					return (filePath[cutOffIndex - 1] != '.')
1447					       	? filePath.Substring(cutOffIndex)
1448					       	: filePath;
1449				}
1450			}
1451
1452			return filePath;
1453		}
1454		#endregion
1455
1456		#region CompareFiles (Static)
1457		/// <summary>
1458		/// Compare two files with the help of the MD5-checksum
1459		/// </summary>
1460		/// <param name="fileName1">Filename 1</param>
1461		/// <param name="fileName2">Filename 2</param>
1462		/// <returns>True if both file contents are the same</returns>
1463		public static bool CompareFiles(string fileName1, string fileName2)
1464		{
1465			return CompareFilesCallback(fileName1, fileName2);
1466		}
1467		#endregion
1468
1469		#region AppendTextToFile (Static)
1470		/// <summary>
1471		/// Append text to file, does the same as File.AppendAllText, but it
1472		/// won't crash and can handle already open files :)
1473		/// </summary>
1474		/// <param name="filename">Filename</param>
1475		/// <param name="text">Text</param>
1476		public static void AppendTextToFile(string filename, string text)
1477		{
1478			try
1479			{
1480				using (StreamWriter writer = new StreamWriter(Open(
1481					filename, FileMode.OpenOrCreate, FileAccess.Write,
1482					FileShare.ReadWrite), Encoding.UTF8))
1483				{
1484					// Go to end of file
1485					writer.BaseStream.Seek(0, SeekOrigin.End);
1486					// And write our new text
1487					writer.Write(text);
1488				}
1489			}
1490			catch (Exception ex)
1491			{
1492				Log.Warning("Failed to AppendTextToFile of file " + filename + ": " +
1493				            ex);
1494			}
1495		}
1496
1497		/// <summary>
1498		/// Append text to file, does the same as File.AppendAllText, but it
1499		/// won't crash and can handle already open files :) This overload checks
1500		/// if the existing data is more than maxTextFileSizeBeforeAppending
1501		/// already, then remove data from the beginning before appending.
1502		/// </summary>
1503		/// <param name="filename">Filename</param>
1504		/// <param name="maxTextFileSizeBeforeAppending">Max Text File Size before
1505		/// appending</param>
1506		/// <param name="text">Text</param>
1507		public static void AppendTextToFile(string filename, string text,
1508			int maxTextFileSizeBeforeAppending)
1509		{
1510			//this suxx: File.AppendAllText(filename, text, UTF8);
1511			try
1512			{
1513				FileStream stream = Open(filename, FileMode.OpenOrCreate,
1514					FileAccess.ReadWrite, FileShare.ReadWrite);
1515				// File is too big, remove data at the beginning (happens rarely).
1516				if (stream.Length > maxTextFileSizeBeforeAppending)
1517				{
1518					stream.Close();
1519					// Just read it all into lines and build it up again from bottom up!
1520					string[] oldLines = GetLines(filename, Encoding.UTF8);
1521					// Always grab the first 100 lines and keep them!
1522					List<string> newLines = new List<string>();
1523					int newSize = 0;
1524					for (int line = 0; line < 100 && line < oldLines.Length; line++)
1525					{
1526						string newLine = oldLines[line];
1527						newLines.Add(newLine);
1528						newSize += newLine.Length;
1529					}
1530					newLines.Add(
1531						"\n" +
1532						"****************************\n" +
1533						"This text file was exceeding " +
1534						StringHelper.WriteKbMbGbNumber(
1535							maxTextFileSizeBeforeAppending) + ", old data will be " +
1536						"removed from the beginning.\nSkipped the first 100 lines and " +
1537						"the new text is appended at the end as usually.\n" +
1538						"****************************\n");
1539					// Next fill up the lines until we reach the max size.
1540					int insertLineNum = newLines.Count;
1541					for (int line = oldLines.Length - 1; line >= 100; line--)
1542					{
1543						string newLine = oldLines[line];
1544						// Always insert at 101 (100 presevered lines + our message),
1545						// this way we go bottom up
1546						newLines.Insert(insertLineNum, newLine);
1547						newSize += newLine.Length;
1548						// Abort if we reach the max size / 2 (this way we don't have to
1549						// do this costly operation too often).
1550						if (newSize > maxTextFileSizeBeforeAppending / 2)
1551						{
1552							break;
1553						}
1554					}
1555
1556					// And finally create the new file and get another stream handle
1557					CreateTextFile(filename, newLines.ToArray(),
1558						Encoding.UTF8);
1559					stream = Open(filename, FileMode.OpenOrCreate,
1560						FileAccess.ReadWrite, FileShare.ReadWrite);
1561				}
1562
1563				using (StreamWriter writer = new StreamWriter(stream, 

Large files files are truncated, but you can click here to view the full file