init

Utils/Utils/CmdArgs.cs

@@ -0,0 +1,186 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+
+namespace BlubbFish.Utils
+{
+  public class CmdArgs
+  {
+    public enum ArgLength
+    {
+      Single,
+      Touple
+    }
+    #region Classes
+    public struct VaildArguments
+    {
+      public VaildArguments(ArgLength length, Boolean required)
+      {
+        this.Required = required;
+        this.Length = length;
+      }
+      public VaildArguments(ArgLength length)
+      {
+        this.Required = false;
+        this.Length = length;
+      }
+
+      public ArgLength Length { get; private set; }
+      public Boolean Required { get; private set; }
+    }
+    private struct ArgTouple
+    {
+      public ArgTouple(String type, String data)
+      {
+        this.Type = type;
+        this.Data = data;
+      }
+      public ArgTouple(String type)
+      {
+        this.Type = type;
+        this.Data = "";
+      }
+      public String Type { get; private set; }
+      public String Data { get; private set; }
+
+      internal void SetData(String data)
+      {
+        if (data != "") {
+          this.Data = data;
+        }
+      }
+    }
+    #endregion
+    private String[] args;
+    private List<ArgTouple> argList;
+    private Dictionary<String, VaildArguments> argsPosible = new Dictionary<String, VaildArguments>();
+    private static CmdArgs instances = null;
+    private Boolean isSetArguments = false;
+
+    private CmdArgs()
+    {
+    }
+
+    /// <summary>
+    /// Gibt eine Instanz der Klasse zurück
+    /// </summary>
+    /// <returns>Klasse</returns>
+    public static CmdArgs Instance
+    {
+      get {
+        if (instances == null) {
+          instances = new CmdArgs();
+        }
+        return instances;
+      }
+    }
+
+    /// <summary>
+    /// Übernimmt die Argumente für die Klasse
+    /// </summary>
+    /// <param name="arguments">Mögliche Komandozeilenargumente</param>
+    /// <param name="args">Tatsächliche Komandozeilenargumente</param>
+    public void SetArguments(Dictionary<String, VaildArguments> arguments, String[] args)
+    {
+      this.args = args;
+      if (!this.isSetArguments) {
+        this.isSetArguments = true;
+        this.argsPosible = arguments;
+        this.Init();
+      }
+    }
+
+    private void Init()
+    {
+      this.argList = new List<ArgTouple>();
+      for (Int32 i = 0; i < this.args.Length; i++) {
+        if (this.argsPosible.Keys.Contains(this.args[i])) {
+          ArgTouple arg = new ArgTouple(this.args[i]);
+          if (this.argsPosible[this.args[i]].Length == ArgLength.Touple) {
+            if (this.args.Length > i + 1) {
+              arg.SetData(this.args[++i]);
+            } else {
+              throw new ArgumentException();
+            }
+          }
+          this.argList.Add(arg);
+        }
+      }
+    }
+
+    /// <summary>
+    /// Menge der angegebenen Komandozeilen-Argumente
+    /// </summary>
+    /// <returns>Menge</returns>
+    public Int32 GetArgsLength()
+    {
+      return this.argList.Count;
+    }
+
+    /// <summary>
+    /// Gibt zurück ob ein Argument angegeben wurde
+    /// </summary>
+    /// <param name="name">Name des Arguments</param>
+    /// <returns>true wenn angegeben</returns>
+    public Boolean HasArgumentType(String name)
+    {
+      foreach (ArgTouple t in this.argList) {
+        if (t.Type == name) {
+          return true;
+        }
+      }
+      return false;
+    }
+
+    /// <summary>
+    /// Gibt den Inhalt des angegeben Arguments zurück, nur bei zweiteiligen Argumenten möglich
+    /// </summary>
+    /// <param name="name">Name des Arguments</param>
+    /// <returns>Inhalt des Arguments oder ArgumentNullException</returns>
+    public String GetArgumentData(String name)
+    {
+      foreach (ArgTouple t in this.argList) {
+        if (t.Type == name && t.Data != null) {
+          return t.Data;
+        } else {
+          throw new ArgumentNullException();
+        }
+      }
+      return null;
+    }
+
+    public Boolean HasAllRequiredArguments()
+    {
+      foreach (KeyValuePair<String, VaildArguments> item in this.argsPosible) {
+        if (item.Value.Required && !this.HasArgumentType(item.Key)) {
+          return false;
+        }
+      }
+      return true;
+    }
+
+    public String GetUsageList(String name)
+    {
+      String ret = "Usage: " + name + " Parameter\nParameter:\n";
+      String req = "";
+      String opt = "";
+      foreach (KeyValuePair<String, VaildArguments> item in this.argsPosible) {
+        if (item.Value.Required) {
+          req += item.Key + " " + ((item.Value.Length == ArgLength.Touple) ? " [data]\n" : "\n");
+        }
+      }
+      if (req != "") {
+        ret += "Benötigte Parameter:\n" + req;
+      }
+      foreach (KeyValuePair<String, VaildArguments> item in this.argsPosible) {
+        if (!item.Value.Required) {
+          opt += item.Key + " " + ((item.Value.Length == ArgLength.Touple) ? " [data]\n" : "\n");
+        }
+      }
+      if (opt != "") {
+        ret += "Optionale Parameter:\n" + opt;
+      }
+      return ret;
+    }
+  }
+}

Utils/Utils/EventArgsHelper.cs

@@ -0,0 +1,34 @@
+using System;
+
+namespace BlubbFish.Utils {
+  public class UpdaterEventArgs : EventArgs {
+    public UpdaterEventArgs(Boolean hasUpdates, String message) {
+      this.HasUpdates = hasUpdates;
+      this.Message = message;
+    }
+    public String Message { get; private set; }
+    public Boolean HasUpdates { get; private set; }
+  }
+
+  public class UpdaterFailEventArgs : EventArgs {
+    public UpdaterFailEventArgs(Exception e) {
+      this.Except = e;
+    }
+
+    public Exception Except { get; private set; }
+  }
+
+  public class LogEventArgs : EventArgs {
+    public LogEventArgs(String location, String message, OwnObject.LogLevel level, DateTime date) {
+      this.Location = location;
+      this.Message = message;
+      this.Level = level;
+      this.Date = date;
+    }
+
+    public String Location { get; private set; }
+    public String Message { get; private set; }
+    public OwnObject.LogLevel Level { get; private set; }
+    public DateTime Date { get; private set; }
+  }
+}

Utils/Utils/FileLogger.cs

@@ -0,0 +1,67 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.IO;
+using System.Reflection;
+
+namespace BlubbFish.Utils
+{
+  public class FileLogger
+  {
+    private static Dictionary<String, FileLogger> instances = new Dictionary<String, FileLogger>();
+    private static String logDir = Path.GetDirectoryName(Assembly.GetExecutingAssembly().Location) + Path.DirectorySeparatorChar;
+    private StreamWriter file;
+    private FileLogger(String filename, Boolean append)
+    {
+      filename = logDir + filename;
+      if (!File.Exists(filename)) {
+        String folder = Path.GetDirectoryName(Path.GetFullPath(filename));
+        if (!Directory.Exists(folder)) {
+          Directory.CreateDirectory(folder);
+        }
+      }
+      this.file = new StreamWriter(filename, append, Encoding.UTF8) {
+        AutoFlush = true
+      };
+    }
+    public static FileLogger GetInstance(String filename, Boolean append)
+    {
+      if (!instances.Keys.Contains(filename)) {
+        instances.Add(filename, new FileLogger(filename, append));
+      }
+      return instances[filename];
+    }
+
+    public static void SetLogDir(String v)
+    {
+      v = v.Replace("..", "");
+      v = Path.GetDirectoryName(Assembly.GetExecutingAssembly().Location) + Path.DirectorySeparatorChar + v;
+      if (Directory.Exists(v)) {
+        logDir = v;
+      } else {
+        Directory.CreateDirectory(v);
+        logDir = v;
+      }
+      if (logDir.Substring(logDir.Length - 1) != Path.DirectorySeparatorChar.ToString()) {
+        logDir = logDir + Path.DirectorySeparatorChar;
+      }
+    }
+
+    public void SetArray(String[] text)
+    {
+      this.file.Write(String.Join(this.file.NewLine, text) + this.file.NewLine);
+      this.file.Flush();
+    }
+
+    public void SetLine(String text)
+    {
+      this.file.WriteLine(text);
+      this.file.Flush();
+    }
+    public void SetLine(String text, DateTime d)
+    {
+      this.SetLine(d.ToString("[yyyy-MM-dd HH:mm:ss.ffff] ") + text);
+    }
+  }
+}

Utils/Utils/FileMutex.cs

@@ -0,0 +1,71 @@
+using System;
+using System.IO;
+using System.Security.Cryptography;
+using System.Text;
+
+namespace BlubbFish.Utils
+{
+  public class FileMutex : IDisposable
+  {
+    private static FileMutex instance;
+    private String filename;
+    private StreamWriter file;
+    private FileMutex() { }
+
+    public static FileMutex Instance
+    {
+      get {
+        if (instance == null) {
+          instance = new FileMutex();
+        }
+        return instance;
+      }
+    }
+
+    public void SetName(String name)
+    {
+      String path = AppDomain.CurrentDomain.BaseDirectory;
+      this.filename = path + String.Join(String.Empty, Array.ConvertAll(new SHA512Managed().ComputeHash(Encoding.UTF8.GetBytes(name)), b => b.ToString("X2"))) + ".lock.txt";
+    }
+
+    public Boolean Create()
+    {
+      if (File.Exists(this.filename)) {
+        return false;
+      }
+
+      this.file = new StreamWriter(this.filename);
+      InitFile();
+      return File.Exists(this.filename) && this.file != null;
+    }
+
+    private void InitFile()
+    {
+      this.file.Write("Created: " + DateTime.Now.ToUniversalTime() + "\n");
+      this.file.Flush();
+    }
+
+    public Boolean Delete()
+    {
+      if(this.file != null) {
+        this.file.Close();
+      }
+
+      File.Delete(this.filename);
+      return !File.Exists(this.filename);
+    }
+
+    protected virtual void Dispose(Boolean disposing) {
+      if (disposing) {
+        if(this.file != null) {
+          this.file.Close();
+        }
+      }
+    }
+
+    public void Dispose() {
+      Dispose(true);
+      GC.SuppressFinalize(this);
+    }
+  }
+}

Utils/Utils/InIReader.cs

@@ -0,0 +1,203 @@
+using System;
+using System.Collections.Generic;
+using System.IO;
+using System.Linq;
+using System.Text;
+using System.Text.RegularExpressions;
+using System.Threading.Tasks;
+
+namespace BlubbFish.Utils
+{
+  public class InIReader : IDisposable
+  {
+    private Dictionary<String, Dictionary<String, String>> inifile;
+    private FileSystemWatcher k = new FileSystemWatcher(Directory.GetCurrentDirectory(), "*.ini");
+    private String filename;
+
+    private static Dictionary<String, InIReader> instances = new Dictionary<String, InIReader>();
+
+    private InIReader(String filename)
+    {
+      this.filename = filename;
+      this.k.Changed += new FileSystemEventHandler(this.ReadAgain);
+      LoadFile();
+    }
+
+    public static InIReader GetInstance(String filename)
+    {
+      if (!instances.Keys.Contains(filename)) {
+        instances.Add(filename, new InIReader(filename));
+      }
+      return instances[filename];
+    }
+
+    private void ReadAgain(Object sender, EventArgs e)
+    {
+      this.LoadFile();
+    }
+
+    private void LoadFile()
+    {
+      this.inifile = new Dictionary<String, Dictionary<String, String>>();
+      StreamReader file = new StreamReader(this.filename);
+      List<String> buf = new List<String>();
+      String fline = "";
+      while (fline != null) {
+        fline = file.ReadLine();
+        if (fline != null && fline.Length > 0 && fline.Substring(0, 1) != ";") {
+          buf.Add(fline);
+        }
+      }
+      file.Close();
+      Dictionary<String, String> sub = new Dictionary<String, String>();
+      String cap = "";
+      foreach (String line in buf) {
+        Match match = Regex.Match(line, @"^\[[a-zA-ZäöüÄÖÜ0-9\-_ ]+\]\w*$", RegexOptions.IgnoreCase);
+        if (match.Success) {
+          if (sub.Count != 0 && cap != "") {
+            this.inifile.Add(cap, sub);
+          }
+          cap = line;
+          sub = new Dictionary<String, String>();
+        } else {
+          if (line != "" && cap != "") {
+            String key = line.Substring(0, line.IndexOf('='));
+            String value = line.Substring(line.IndexOf('=') + 1);
+            sub.Add(key, value);
+          }
+        }
+      }
+      if (sub.Count != 0 && cap != "") {
+        this.inifile.Add(cap, sub);
+      }
+    }
+
+    public List<String> GetSections(Boolean withBrackets = true)
+    {
+      if(withBrackets) {
+        return this.inifile.Keys.ToList();
+      } else {
+        List<String> ret = new List<String>();
+        foreach (String item in this.inifile.Keys) {
+          ret.Add(item.Substring(1, item.Length - 2));
+        }
+        return ret;
+      }
+    }
+
+    public Dictionary<String, String> GetSection(String section) {
+      if(this.inifile.Keys.Contains(section)) {
+        return this.inifile[section];
+      }
+      if(this.inifile.Keys.Contains("["+section+"]")) {
+        return this.inifile["[" + section + "]"];
+      }
+      return new Dictionary<String, String>();
+    }
+
+    public String GetValue(String section, String key)
+    {
+      if (!section.StartsWith("[")) {
+        section = "[" + section + "]";
+      }
+      if (this.inifile.Keys.Contains(section)) {
+        if (this.inifile[section].Keys.Contains(key)) {
+          return this.inifile[section][key];
+        }
+      }
+      return null;
+    }
+
+
+    public void SetValue(String section, String key, String value)
+    {
+      if (!section.StartsWith("[")) {
+        section = "[" + section + "]";
+      }
+      if (this.inifile.Keys.Contains(section)) {
+        if (this.inifile[section].Keys.Contains(key)) {
+          this.inifile[section][key] = value;
+        } else {
+          this.inifile[section].Add(key, value);
+        }
+      } else {
+        Dictionary<String, String> sub = new Dictionary<String, String> {
+          { key, value }
+        };
+        this.inifile.Add(section, sub);
+      }
+      this.Changed();
+    }
+
+    private void Changed()
+    {
+      this.k.Changed -= null;
+      SaveSettings();
+      LoadFile();
+      this.k.Changed += new FileSystemEventHandler(this.ReadAgain);
+    }
+
+    private void SaveSettings()
+    {
+      StreamWriter file = new StreamWriter(this.filename);
+      file.BaseStream.SetLength(0);
+      file.BaseStream.Flush();
+      file.BaseStream.Seek(0, SeekOrigin.Begin);
+      foreach (KeyValuePair<String, Dictionary<String, String>> cap in this.inifile) {
+        file.WriteLine(cap.Key);
+        foreach (KeyValuePair<String, String> sub in cap.Value) {
+          file.WriteLine(sub.Key + "=" + sub.Value);
+        }
+        file.WriteLine();
+      }
+      file.Flush();
+      file.Close();
+    }
+
+    /// <summary>
+    /// Fügt eine neue Sektion in der Ini-Datei ein.
+    /// </summary>
+    /// <param name="name">Sektionsname</param>
+    /// <returns>true if added, false if error</returns>
+    public Boolean AddSection(String name)
+    {
+      if (!name.StartsWith("[")) {
+        name = "[" + name + "]";
+      }
+      if (this.inifile.Keys.Contains(name)) {
+        return false;
+      }
+      this.inifile.Add(name, new Dictionary<String, String>());
+      this.Changed();
+      return true;
+    }
+
+    /// <summary>
+    /// Löscht eine Sektion inklusive Unterpunkte aus der Ini-Datei.
+    /// </summary>
+    /// <param name="name">Sektionsname</param>
+    /// <returns>true if removed, false if error</returns>
+    public Boolean RemoveSection(String name)
+    {
+      if (!name.StartsWith("[")) {
+        name = "[" + name + "]";
+      }
+      if (!this.inifile.Keys.Contains(name)) {
+        return false;
+      }
+      this.inifile.Remove(name);
+      this.Changed();
+      return false;
+    }
+    protected virtual void Dispose(Boolean disposing) {
+      if (disposing) {
+        this.k.Dispose();
+      }
+    }
+
+    public void Dispose() {
+      Dispose(true);
+      GC.SuppressFinalize(this);
+    }
+  }
+}

Utils/Utils/OwnController.cs

@@ -0,0 +1,22 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+using System.Windows.Forms;
+
+namespace BlubbFish.Utils
+{
+  public abstract class OwnController
+  {
+    /// <summary>
+    /// Führt den Controller aus.
+    /// </summary>
+    public void Execute()
+    {
+      this.Init();
+    }
+    abstract protected void Init();
+    abstract public void Dispose();
+  }
+}

Utils/Utils/OwnModel.cs

@@ -0,0 +1,39 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace BlubbFish.Utils
+{
+  public abstract class OwnModel<T> where T : class
+  {
+    private static readonly Lazy<T> _instance = new Lazy<T>(() => CreateInstanceOfT());
+    private List<OwnView> observer = new List<OwnView>();
+    public static T Instance
+    {
+      get {
+        return _instance.Value;
+      }
+    }
+    private static T CreateInstanceOfT()
+    {
+      return Activator.CreateInstance(typeof(T), true) as T;
+    }
+
+    public void SetObserver(OwnView view)
+    {
+      this.observer.Add(view);
+      view.Update();
+    }
+
+    public void RemoveObserver(OwnView view) {
+      this.observer.Remove(view);
+    }
+    protected void Update()
+    {
+      this.observer.ForEach(delegate (OwnView view) { view.Update(); });
+    }
+    abstract protected void Init();
+  }
+}

Utils/Utils/OwnObject.cs

@@ -0,0 +1,110 @@
+using System;
+using System.Collections.Generic;
+
+namespace BlubbFish.Utils
+{
+  abstract public class OwnObject
+  {
+    public struct LogObject {
+      public LogObject(DateTime date, String location, String message, LogLevel level) {
+        this.Date = date;
+        this.Location = location;
+        this.Message = message;
+        this.Level = level;
+      }
+
+      public DateTime Date { get; set; }
+      public String Location { get; set; }
+      public String Message { get;  set; }
+      public LogLevel Level { get; set; }
+      /// <summary>
+      /// Formates a LogMessage to a String
+      /// </summary>
+      /// <returns>Formated String</returns>
+      public override String ToString() {
+        return "[" + this.Date.ToString("R") + "]: " + this.Level.ToString() + " "+ this.Location + ", " + this.Message;
+      }
+      /// <summary>
+      /// Formates a LogMessage to a String
+      /// </summary>
+      /// <param name="classNames">Enables the output of the location</param>
+      /// <param name="timeStamps">Enables the output of the date</param>
+      /// <returns>Formated String</returns>
+      public String ToString(Boolean classNames, Boolean timeStamps) {
+        return (timeStamps ? "[" + this.Date.ToString("R") + "]: " + this.Level.ToString() + " " : "") + (classNames ? this.Location + ", " : "") + this.Message;
+      }
+    }
+
+    private List<LogObject> loglist = new List<LogObject>();
+
+    public delegate void LogEvent(Object sender, LogEventArgs e);
+    public enum LogLevel : Int32 {
+      Debug = 1,
+      Notice = 2,
+      Info = 4,
+      Warn = 8,
+      Error = 16
+    }
+
+    public event LogEvent EventDebug;
+    public event LogEvent EventNotice;
+    public event LogEvent EventInfo;
+    public event LogEvent EventWarn;
+    public event LogEvent EventError;
+    public event LogEvent EventLog;
+
+    /// <summary>
+    /// Get the Complete Log
+    /// </summary>
+    public List<String> GetLog(LogLevel level, Boolean classNames, Boolean timeStamps) {
+      List<String> ret = new List<String>();
+      foreach (LogObject t in this.loglist) {
+        if (t.Level >= level) {
+          ret.Add(t.ToString(classNames, timeStamps));
+        }
+      }
+      return ret;
+    }
+
+    /// <summary>
+    /// Put a message in the log
+    /// </summary>
+    /// <param name="location">Where the event arrives</param>
+    /// <param name="message">The logmessage itselfs</param>
+    /// <param name="level">Level of the message</param>
+    protected void AddLog(String location, String message, LogLevel level)
+    {
+      this.AddLog(location, message, level, DateTime.Now);
+    }
+
+    /// <summary>
+    /// Put a message in the log
+    /// </summary>
+    /// <param name="location">Where the event arrives</param>
+    /// <param name="message">The logmessage itselfs</param>
+    /// <param name="level">Level of the message</param>
+    /// <param name="date">Date of the message</param>
+    protected void AddLog(String location, String message, LogLevel level, DateTime date)
+    {
+      LogEventArgs e = new LogEventArgs(location, message, level, date);
+      if (EventDebug != null && level >= LogLevel.Debug) {
+        EventDebug(this, e);
+      }
+      if (EventNotice != null && level >= LogLevel.Notice) {
+        EventNotice(this, e);
+      }
+      if (EventInfo != null && level >= LogLevel.Info) {
+        EventInfo(this, e);
+      }
+      if (EventWarn != null && level >= LogLevel.Warn) {
+        EventWarn(this, e);
+      }
+      if (EventError != null && level >= LogLevel.Error) {
+        EventError(this, e);
+      }
+      EventLog?.Invoke(this, e);
+
+      this.loglist.Add(new LogObject(date, location, message, level));
+    }
+  }
+}

Utils/Utils/OwnView.cs

@@ -0,0 +1,24 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace BlubbFish.Utils {
+  public abstract class OwnView {
+
+    protected OwnView() { }
+    /// <summary>
+    /// Called if the Oberver (Model) updates its View
+    /// </summary>
+    public abstract void Update();
+    /// <summary>
+    /// Called if view is viewed
+    /// </summary>
+    //protected abstract void Init();
+    /// <summary>
+    /// Called if Form is Disposed
+    /// </summary>
+    public abstract void Dispose();
+  }
+}

Utils/Utils/Properties/AssemblyInfo.cs

@@ -0,0 +1,36 @@
+using System.Reflection;
+using System.Runtime.CompilerServices;
+using System.Runtime.InteropServices;
+
+// Allgemeine Informationen über eine Assembly werden über die folgenden 
+// Attribute gesteuert. Ändern Sie diese Attributwerte, um die Informationen zu ändern,
+// die mit einer Assembly verknüpft sind.
+[assembly: AssemblyTitle("Utils")]
+[assembly: AssemblyDescription("")]
+[assembly: AssemblyConfiguration("")]
+[assembly: AssemblyCompany("")]
+[assembly: AssemblyProduct("Utils")]
+[assembly: AssemblyCopyright("Copyright ©  2014 - 25.09.2017")]
+[assembly: AssemblyTrademark("")]
+[assembly: AssemblyCulture("")]
+
+// Durch Festlegen von ComVisible auf "false" werden die Typen in dieser Assembly unsichtbar 
+// für COM-Komponenten. Wenn Sie auf einen Typ in dieser Assembly von 
+// COM zugreifen müssen, legen Sie das ComVisible-Attribut für diesen Typ auf "true" fest.
+[assembly: ComVisible(false)]
+
+// Die folgende GUID bestimmt die ID der Typbibliothek, wenn dieses Projekt für COM verfügbar gemacht wird
+[assembly: Guid("6f20376a-5c71-4979-9932-13c105d1c6e6")]
+
+// Versionsinformationen für eine Assembly bestehen aus den folgenden vier Werten:
+//
+//      Hauptversion
+//      Nebenversion 
+//      Buildnummer
+//      Revision
+//
+// Sie können alle Werte angeben oder die standardmäßigen Build- und Revisionsnummern 
+// übernehmen, indem Sie "*" eingeben:
+// [assembly: AssemblyVersion("1.0.*")]
+[assembly: AssemblyVersion("1.0.5.2")]
+[assembly: AssemblyFileVersion("1.0.5.2")]

Utils/Utils/Updater.cs

@@ -0,0 +1,192 @@
+
+using System;
+using System.IO;
+using System.Net;
+using System.Reflection;
+using System.Runtime.InteropServices;
+using System.Text;
+using System.Threading;
+using System.Xml;
+
+namespace BlubbFish.Utils {
+  public class Updater : OwnObject {
+    private static Updater instances;
+    private String url;
+    private VersionInfo[] versions;
+    private Thread t;
+
+    public struct VersionInfo {
+      public VersionInfo(Type type) {
+        this.Name = type.Assembly.GetName().Name;
+        this.Version = type.Assembly.GetName().Version.ToString();
+        this.Filename = type.Assembly.ManifestModule.Name;
+        this.GUID = ((GuidAttribute)type.Assembly.GetCustomAttribute(typeof(GuidAttribute))).Value;
+        this.HasUpdate = false;
+      }
+
+      public String Name { get; private set; }
+      public String Version { get; private set; }
+      public String Filename { get; private set; }
+      public String GUID { get; private set; }
+      public Boolean HasUpdate { get; set; }
+    }
+
+    public delegate void UpdateStatus(Object sender, UpdaterEventArgs e);
+    public delegate void UpdateFail(Object sender, UpdaterFailEventArgs e);
+
+    public event UpdateStatus UpdateResult;
+    public event UpdateFail ErrorRaised;
+
+    private Updater() { }
+
+    /// <summary>
+    /// Get Instance of Updater
+    /// </summary>
+    public static Updater Instance {
+      get {
+        if(instances == null) {
+          instances = new Updater();
+        }
+        return instances;
+      }
+    }
+
+    /// <summary>
+    /// Waits for the Result of the Updater thread.
+    /// </summary>
+    public void WaitForExit(Boolean exceuteUpdate = true) {
+      while (this.t.ThreadState == ThreadState.Running) { }
+      if(exceuteUpdate) {
+        if(File.Exists("update.bat")) {
+          System.Diagnostics.Process.Start("update.bat");
+        }
+      }
+    }
+
+    /// <summary>
+    /// Set Path to check for Updates
+    /// </summary>
+    /// <param name="url">HTTP URI</param>
+    public void SetUpdateInfo(String url, VersionInfo[] versions) {
+      this.url = url;
+      this.versions = versions;
+      FileStream file = new FileStream("version.xml",FileMode.Create);
+      XmlTextWriter xml = new XmlTextWriter(file, Encoding.UTF8);
+      xml.WriteStartDocument();
+      xml.WriteWhitespace("\n");
+      xml.WriteStartElement("filelist");
+      xml.WriteWhitespace("\n");
+      foreach (VersionInfo version in versions) {
+        xml.WriteWhitespace("\t");
+        xml.WriteStartElement("file");
+        xml.WriteAttributeString("Version", version.Version);
+        xml.WriteAttributeString("Filename", version.Filename);
+        xml.WriteAttributeString("GUID", version.GUID);
+        xml.WriteString(version.Name);
+        xml.WriteEndElement();
+        xml.WriteWhitespace("\n");
+      }
+      xml.WriteEndElement();
+      xml.Flush();
+      file.Flush();
+      file.Close();
+    }
+
+    /// <summary>
+    /// Check for Updates
+    /// </summary>
+    /// <exception cref="ArgumentException"></exception>
+    public void Check() {
+      if(this.url == "") {
+        throw new ArgumentException("Zuerst eine URL setzen!");
+      }
+      if(this.versions.Length == 0) {
+        throw new ArgumentException("Zuerst Dateien registrieren!");
+      }
+      if(this.UpdateResult == null) {
+        throw new ArgumentNullException("Zuerst das Update Event anhängen.");
+      }
+      this.t = new Thread(this.Runner);
+      this.t.Start();
+    }
+
+    private void Runner() {
+      Thread.Sleep(1000);
+      try {
+        Stream stream = WebRequest.Create(this.url + "version.xml").GetResponse().GetResponseStream();
+        String content = new StreamReader(stream).ReadToEnd();
+        Boolean update = false;
+        XmlDocument doc = new XmlDocument();
+        doc.LoadXml(content);
+        foreach (XmlNode node in doc.DocumentElement.ChildNodes) {
+          String guid = node.Attributes["GUID"].Value;
+          String version = node.Attributes["Version"].Value;
+          for(Int32 i=0;i<this.versions.Length;i++) {
+            if (this.versions[i].GUID == guid && this.versions[i].Version != version) {
+              this.versions[i].HasUpdate = true;
+              update = true;
+            }
+          }
+        }
+        if (update) {
+          this.UpdateResult(this, new UpdaterEventArgs(true, "Update verfügbar"));
+          return;
+        }
+      } catch (Exception e) {
+        this.ErrorRaised?.Invoke(this, new UpdaterFailEventArgs(e));
+        return;
+      }
+      this.UpdateResult(this, new UpdaterEventArgs(false, "Kein Update verfügbar"));
+    }
+
+    /// <summary>
+    /// Update the file
+    /// </summary>
+    /// <param name="afterExit">Updates the Programm after it has been closed</param>
+    /// <returns></returns>
+    public Boolean Update(Boolean afterExit = true) {
+      try {
+        if (afterExit) {
+          this.UpdateAfter();
+        } else {
+          this.UpdateNow();
+        }
+      } catch (Exception e) {
+        this.ErrorRaised?.Invoke(this, new UpdaterFailEventArgs(e));
+        return false;
+      }
+      return true;
+    }
+
+    private void UpdateAfter() {
+      this.UpdateNow(true);
+      StreamWriter update = new StreamWriter("update.bat", false);
+      update.WriteLine("echo off");
+      update.WriteLine("echo \"Warte 10s\"");
+      update.WriteLine("ping 127.0.0.1 -n 10");
+      update.WriteLine("echo \"Kopiere Dateien....\"");
+      foreach (VersionInfo file in this.versions) {
+        if (file.HasUpdate) {
+          update.WriteLine("echo \"Kopiere " + file.Filename + "\"");
+          update.WriteLine("del " + file.Filename);
+          update.WriteLine("move " + file.Filename + "_ " + file.Filename);
+        }
+      }
+      update.WriteLine("start cmd /C ping 127.0.0.1 -n 10 & del update.bat");
+      update.Flush();
+      update.Close();
+    }
+
+    private void UpdateNow(Boolean forAfter = false) {
+      foreach (VersionInfo file in this.versions) {
+        if (file.HasUpdate) {
+          Stream stream = WebRequest.Create(this.url + file.Filename).GetResponse().GetResponseStream();
+          FileStream target = new FileStream(file.Filename + (forAfter ? "_" : ""), FileMode.Create);
+          stream.CopyTo(target);
+          target.Flush();
+          target.Close();
+        }
+      }
+    }
+  }
+}

Utils/Utils/Utils.csproj

@@ -0,0 +1,63 @@
+<?xml version="1.0" encoding="utf-8"?>
+<Project ToolsVersion="4.0" DefaultTargets="Build" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
+  <Import Project="$(MSBuildExtensionsPath)\$(MSBuildToolsVersion)\Microsoft.Common.props" Condition="Exists('$(MSBuildExtensionsPath)\$(MSBuildToolsVersion)\Microsoft.Common.props')" />
+  <PropertyGroup>
+    <Configuration Condition=" '$(Configuration)' == '' ">Debug</Configuration>
+    <Platform Condition=" '$(Platform)' == '' ">AnyCPU</Platform>
+    <ProjectGuid>{FAC8CE64-BF13-4ECE-8097-AEB5DD060098}</ProjectGuid>
+    <OutputType>Library</OutputType>
+    <AppDesignerFolder>Properties</AppDesignerFolder>
+    <RootNamespace>BlubbFish.Utils</RootNamespace>
+    <AssemblyName>Utils</AssemblyName>
+    <TargetFrameworkVersion>v4.5</TargetFrameworkVersion>
+    <FileAlignment>512</FileAlignment>
+  </PropertyGroup>
+  <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Debug|AnyCPU' ">
+    <DebugSymbols>true</DebugSymbols>
+    <DebugType>full</DebugType>
+    <Optimize>false</Optimize>
+    <OutputPath>bin\Debug\</OutputPath>
+    <DefineConstants>DEBUG;TRACE</DefineConstants>
+    <ErrorReport>prompt</ErrorReport>
+    <WarningLevel>4</WarningLevel>
+  </PropertyGroup>
+  <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Release|AnyCPU' ">
+    <DebugType>pdbonly</DebugType>
+    <Optimize>true</Optimize>
+    <OutputPath>bin\Release\</OutputPath>
+    <DefineConstants>TRACE</DefineConstants>
+    <ErrorReport>prompt</ErrorReport>
+    <WarningLevel>4</WarningLevel>
+  </PropertyGroup>
+  <ItemGroup>
+    <Reference Include="System" />
+    <Reference Include="System.Core" />
+    <Reference Include="System.Windows.Forms" />
+    <Reference Include="System.Xml.Linq" />
+    <Reference Include="System.Data.DataSetExtensions" />
+    <Reference Include="Microsoft.CSharp" />
+    <Reference Include="System.Data" />
+    <Reference Include="System.Xml" />
+  </ItemGroup>
+  <ItemGroup>
+    <Compile Include="CmdArgs.cs" />
+    <Compile Include="EventArgsHelper.cs" />
+    <Compile Include="FileLogger.cs" />
+    <Compile Include="FileMutex.cs" />
+    <Compile Include="InIReader.cs" />
+    <Compile Include="OwnController.cs" />
+    <Compile Include="OwnModel.cs" />
+    <Compile Include="OwnObject.cs" />
+    <Compile Include="OwnView.cs" />
+    <Compile Include="Properties\AssemblyInfo.cs" />
+    <Compile Include="Updater.cs" />
+  </ItemGroup>
+  <Import Project="$(MSBuildToolsPath)\Microsoft.CSharp.targets" />
+  <!-- To modify your build process, add your task inside one of the targets below and uncomment it. 
+       Other similar extension points exist, see Microsoft.Common.targets.
+  <Target Name="BeforeBuild">
+  </Target>
+  <Target Name="AfterBuild">
+  </Target>
+  -->
+</Project>