lantool

GlobalCache.cs (7574B)

---

 using System;
 using System.Collections.Generic;
 using System.IO;
 using System.Security.Cryptography;
 
 namespace LanTool.Classes
 {
 	/// <summary>
 	/// Beinhaltet die globalen CacheListe des LanTools
 	/// </summary>
 	public class GlobalCache : IDisposable
 	{
 		#region Konstanten für die Caches
 
 		private const string cHashKeyCacheFile = "LanTool.cache";
 		private const string cHashKeyExcludeFile = "LanTool.exclude";
 		private const string cHashKeyIgnoreFile = "LanTool.ignore";
 
 		#endregion
 
 		#region Properties
 
 		/// <summary>
 		/// Cache mit allen Hash-Werten von bekannten Dateien
 		/// </summary>
 		public SortedDictionary<string, string> HashCache { get; private set; }
 		/// <summary>
 		/// Cache mit allen Hash-Werten, die gesperrt sind
 		/// </summary>
 		public List<String> ExcludeCache { get; private set; }
 		/// <summary>
 		/// Cache mit allen Hash-Werten, bei denen Dubletten ignoriert werden
 		/// </summary>
 		public List<String> IgnoreCache { get; private set; }
 
 		#endregion
 
 		#region Fields mit den Caches
 
 		private long hashOldInCache = 0;
 		private long hashNewInCache = 0;
 		private string _basePath;
 
 		private MD5 md5;
 
 		#endregion
 
 		/// <summary>
 		/// Konstruktor für den globalen Cache
 		/// Legt die Cachelisten an und füllt diese von den Platten
 		/// </summary>
 		/// <param name="basePath">Standard-Pfad</param>
 		public GlobalCache(string basePath)
 		{
 			this._basePath = basePath;
 
 			this.HashCache = new SortedDictionary<string, string>();
 			this.ExcludeCache = new List<string>();
 			this.IgnoreCache = new List<string>();
 
 			md5 = MD5.Create();
 
 			// Caches einlesen
 			LoadCacheFromDisk();
 			LoadExcludeListFromDisk();
 			LoadIgnoreListFromDisk();
 		}
 
 		/// <summary>
 		/// Speichert alle Liste auf Festplatte
 		/// </summary>
 		public void Dispose()
 		{
 			Dispose(true);
 			GC.SuppressFinalize(this);
 		}
 
 		/// <summary>
 		/// Speichert alle Liste auf Festplatte
 		/// </summary>
 		/// <param name="yes"></param>
 		protected virtual void Dispose(Boolean yes)
 		{
 			if (yes)
 			{
 			}
 
 			SaveCacheToDisk();
 			SaveExcludeListToDisk();
 			SaveIgnoreListToDisk();
 		}
 
 		#region Behandlung der globalen Cache-Liste
 
 		/// <summary>
 		/// MD5-Cache von der Platte laden
 		/// </summary>
 		private void LoadCacheFromDisk()
 		{
 			HashCache.Clear();
 			if (File.Exists(_basePath + cHashKeyCacheFile))
 			{
 				using (StreamReader cacheReader = File.OpenText(_basePath + cHashKeyCacheFile))
 				{
 					string s;
 					while ((s = cacheReader.ReadLine()) != null)
 					{
 						if ( s.Length > 44 )
 						{
 							HashCache[ s.Substring( 44 ) ] = s.Substring( 0, 43 );
 						}
 					}
 				}
 				Program.MainWindow.Log(cHashKeyCacheFile + " wurde mit " + HashCache.Keys.Count.ToString() + " Einträgen geladen.");
 			}
 			else
 			{
 				Program.MainWindow.LogWarning(cHashKeyCacheFile + " nicht vorhanden.");
 			}
 		}
 
 		/// <summary>
 		/// MD5-Cache auf Platte speichern
 		/// </summary>
 		public void SaveCacheToDisk()
 		{
 			try
 			{
 				using (StreamWriter sw = File.CreateText(_basePath + cHashKeyCacheFile))
 				{
 					foreach (KeyValuePair<string, string> di in HashCache)
 					{
 						sw.WriteLine(di.Value + "/" + di.Key);
 					}
 				}
 				Program.MainWindow.Log(cHashKeyCacheFile + " wurde mit " + HashCache.Keys.Count.ToString() + " Einträgen gespeichert (" + hashNewInCache.ToString() + " neue Einträge, " + hashOldInCache.ToString() + " Treffer)");
 			}
 			catch (Exception e)
 			{
 				Program.MainWindow.LogError(cHashKeyCacheFile + " konnte nicht gespeichert werden: " + e.Message);
 			}
 		}
 
 		/// <summary>
 		/// Löschen des Hash-Caches
 		/// </summary>
 		public void Clear()
 		{
 			HashCache.Clear();
 
 			hashNewInCache = 0;
 			hashOldInCache = 0;
 			
 			SaveCacheToDisk();
 		}
 
 		/// <summary>
 		/// Aus Datei einen Hashkey erzeugen oder aus dem Cache entnehmen
 		/// </summary>
 		/// <param name="file">Datei</param>
 		/// <returns>Hash-Key</returns>
 		public string GetHashCodeFromFileHeader(string file)
 		{
 			if (String.IsNullOrEmpty(file))
 			{
 				return String.Empty;
 			}
 
 			Int32 md5HashSize = Program.MainWindow.m_Config.MD5FileSize;
 
 			// Nachsehen, ob der Länge / Dateipfad gecached sind
 			if (HashCache.ContainsKey(md5HashSize + " " + file))
 			{
 				hashOldInCache++;
 				return HashCache[md5HashSize + " " + file];
 			}
 
 			// wenn die Datei nicht existiert, keinen Fehler melden
 			// sondern leeren String, Datei wird später als Lesefehler markiert
 			if (!File.Exists(file))
 			{
 				return String.Empty;
 			}
 
 			try
 			{
 				// Teil 1 des Hashcodes ist die Dateigröße
 				FileInfo fi = new FileInfo(file);
 				string hash = fi.Length.ToString("X10");
 				// Teil 2 des Hascode ist das md5 über x Bytes. Bei Netzwerkzugriff
 				// ist das etwas zu viel die ganzen Dateien zu lesen
 				byte[] buffer = new byte[md5HashSize];
 				using (FileStream fs = fi.OpenRead())
 				{
 					int gelesen = fs.Read(buffer, 0, md5HashSize);
 
 					// Wenn die Datei leer ist, den Dateinamen nehmen
 					if (gelesen == 0)
 					{
 						for (int i = 0; i < file.Length; i++)
 							buffer[i] = (byte)file[i];
 					}
 				}
 
 				byte[] mdhash = md5.ComputeHash(buffer);
 				hash = "/" + hash;
 				foreach (byte b in mdhash)
 				{
 					hash = b.ToString("X2") + hash;
 				}
 
 				// Im Cache ablegen für weitere Verwendung
 				HashCache[md5HashSize + " " + file] = hash;
 				hashNewInCache++;
 				return hash;
 			}
 			catch
 			{
 				return String.Empty;
 			}
 		}
 
 		#endregion
 
 		/// <summary>
 		/// Exclude-Liste von Platte laden
 		/// </summary>
 		private void LoadExcludeListFromDisk()
 		{
 			ExcludeCache.Clear();
 			if (File.Exists(_basePath + cHashKeyExcludeFile))
 			{
 				// Alle Zeilen der Datei in den Cache einlesen
 				ExcludeCache.AddRange(File.ReadAllLines(_basePath + cHashKeyExcludeFile));
 
 				Program.MainWindow.Log(cHashKeyExcludeFile + " wurde mit " + ExcludeCache.Count.ToString() + " Einträgen geladen");
 			}
 			else
 			{
 				Program.MainWindow.LogWarning(cHashKeyExcludeFile + " nicht vorhanden.");
 			}
 		}
 
 		/// <summary>
 		/// Exclude-Liste auf Platte speichern
 		/// </summary>
 		public void SaveExcludeListToDisk()
 		{
 			try
 			{
 				// Alle Zeilen des Exclude-Caches in die Datei schreiben
 				File.WriteAllLines(_basePath + cHashKeyExcludeFile, ExcludeCache.ToArray());
 
 				Program.MainWindow.Log(cHashKeyExcludeFile + " wurde mit " + ExcludeCache.Count.ToString() + " Einträgen gespeichert");
 			}
 			catch (Exception e)
 			{
 				Program.MainWindow.LogError(cHashKeyExcludeFile + "konnte nicht gespeichert werden: " + e.Message);
 			}
 		}
 
 		/// <summary>
 		/// Exclude-Liste von Platte laden
 		/// </summary>
 		private void LoadIgnoreListFromDisk()
 		{
 			IgnoreCache.Clear();
 			if (File.Exists(_basePath + cHashKeyIgnoreFile))
 			{
 				// Alle Zeilen in den IgnoreCache laden
 				IgnoreCache.AddRange(File.ReadAllLines(_basePath + cHashKeyIgnoreFile));
 
 				Program.MainWindow.Log(cHashKeyIgnoreFile + " wurde mit " + IgnoreCache.Count.ToString() + " Einträgen geladen");
 			}
 			else
 			{
 				Program.MainWindow.LogWarning(cHashKeyIgnoreFile + " nicht vorhanden.");
 			}
 		}
 
 		/// <summary>
 		/// Exclude-Liste auf Platte speichern
 		/// </summary>
 		public void SaveIgnoreListToDisk()
 		{
 			try
 			{
 				File.WriteAllLines(_basePath + cHashKeyIgnoreFile, IgnoreCache.ToArray());
 				Program.MainWindow.Log(cHashKeyIgnoreFile + " wurde mit " + IgnoreCache.Count.ToString() + " Einträgen gespeichert");
 			}
 			catch (Exception e)
 			{
 				Program.MainWindow.LogError(cHashKeyIgnoreFile + "konnte nicht gespeichert werden: " + e.Message);
 			}
 		}
 	}
 }