add .gitignore

[v1.6.2] Adding a Test for Lora Binary

.gitignore

@@ -0,0 +1,3 @@
+/.vs
+/Utils/obj
+/Utils/bin

InIReader.cs

@@ -1,185 +0,0 @@
-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>> cont;
-    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.cont = 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-Z0-9\-_ ]+\]\w*$", RegexOptions.IgnoreCase);
-        if (match.Success) {
-          if (sub.Count != 0 && cap != "") {
-            this.cont.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.cont.Add(cap, sub);
-      }
-    }
-
-    public List<String> GetSections()
-    {
-      return this.cont.Keys.ToList<String>();
-    }
-
-    public String GetValue(String section, String key)
-    {
-      if (!section.StartsWith("[")) {
-        section = "[" + section + "]";
-      }
-      if (this.cont.Keys.Contains(section)) {
-        if (this.cont[section].Keys.Contains(key)) {
-          return this.cont[section][key];
-        }
-      }
-      return null;
-    }
-
-
-    public void SetValue(String section, String key, String value)
-    {
-      if (!section.StartsWith("[")) {
-        section = "[" + section + "]";
-      }
-      if (this.cont.Keys.Contains(section)) {
-        if (this.cont[section].Keys.Contains(key)) {
-          this.cont[section][key] = value;
-        } else {
-          this.cont[section].Add(key, value);
-        }
-      } else {
-        Dictionary<String, String> sub = new Dictionary<String, String> {
-          { key, value }
-        };
-        this.cont.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.cont) {
-        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.cont.Keys.Contains(name)) {
-        return false;
-      }
-      this.cont.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.cont.Keys.Contains(name)) {
-        return false;
-      }
-      this.cont.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);
-    }
-  }
-}

Updater.cs

@@ -1,145 +0,0 @@
-
-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;
-
-    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 struct VersionInfo {
-      public VersionInfo(String name, String version, String filename, String guid) {
-        this.Name = name;
-        this.Version = version;
-        this.Filename = filename;
-        this.GUID = guid;
-      }
-      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;
-      }
-
-      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 delegate void UpdateStatus(Object sender, UpdaterEventArgs e);
-
-    public event UpdateStatus UpdateResult;
-
-    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() {
-      throw new NotImplementedException();
-    }
-
-    /// <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("You must set url first.");
-      }
-      if(this.versions.Length == 0) {
-        throw new ArgumentException("You must set a Version number first.");
-      }
-      if(this.UpdateResult == null) {
-        throw new ArgumentNullException("You must attach an event first.");
-      }
-      Thread t = new Thread(this.Runner);
-      t.Start();
-    }
-
-    private void Runner() {
-      Thread.Sleep(1000);
-      WebRequest request = WebRequest.Create(this.url + "version.xml");
-      WebResponse response = null;
-      try {
-         response = request.GetResponse();
-      } catch(WebException e) {
-        this.UpdateResult(this, new UpdaterEventArgs(false, e.Message));
-        return;
-      }
-      Stream stream = response.GetResponseStream();
-      StreamReader reader = new StreamReader(stream);
-      String content = reader.ReadToEnd();
-    }
-
-    /// <summary>
-    /// Update the file
-    /// </summary>
-    /// <param name="filename">The filename of the targetfile</param>
-    /// <param name="url">The url of the sourcefile</param>
-    /// <param name="afterExit">Updates the Programm after it has been closed</param>
-    /// <returns></returns>
-    public Boolean Update(Boolean afterExit = true) {
-      return true;
-    }
-  }
-}

Utils.sln

@@ -0,0 +1,20 @@
+
+Microsoft Visual Studio Solution File, Format Version 12.00
+# Visual Studio 2012
+Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "Utils", "Utils\Utils.csproj", "{FAC8CE64-BF13-4ECE-8097-AEB5DD060098}"
+EndProject
+Global
+	GlobalSection(SolutionConfigurationPlatforms) = preSolution
+		Debug|Any CPU = Debug|Any CPU
+		Release|Any CPU = Release|Any CPU
+	EndGlobalSection
+	GlobalSection(ProjectConfigurationPlatforms) = postSolution
+		{FAC8CE64-BF13-4ECE-8097-AEB5DD060098}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
+		{FAC8CE64-BF13-4ECE-8097-AEB5DD060098}.Debug|Any CPU.Build.0 = Debug|Any CPU
+		{FAC8CE64-BF13-4ECE-8097-AEB5DD060098}.Release|Any CPU.ActiveCfg = Release|Any CPU
+		{FAC8CE64-BF13-4ECE-8097-AEB5DD060098}.Release|Any CPU.Build.0 = Release|Any CPU
+	EndGlobalSection
+	GlobalSection(SolutionProperties) = preSolution
+		HideSolutionNode = FALSE
+	EndGlobalSection
+EndGlobal

Utils/CmdArgs.cs

@@ -12,7 +12,7 @@ namespace BlubbFish.Utils
       Touple
     }
     #region Classes
-    public class VaildArguments
+    public struct VaildArguments
     {
       public VaildArguments(ArgLength length, Boolean required)
       {
@@ -28,7 +28,7 @@ namespace BlubbFish.Utils
       public ArgLength Length { get; private set; }
       public Boolean Required { get; private set; }
     }
-    private class ArgTouple
+    private struct ArgTouple
     {
       public ArgTouple(String type, String data)
       {
@@ -38,6 +38,7 @@ namespace BlubbFish.Utils
       public ArgTouple(String type)
       {
         this.Type = type;
+        this.Data = null;
       }
       public String Type { get; private set; }
       public String Data { get; private set; }
@@ -99,7 +100,8 @@ namespace BlubbFish.Utils
             if (this.args.Length > i + 1) {
               arg.SetData(this.args[++i]);
             } else {
-              throw new ArgumentException();
+              Console.WriteLine(this.GetUsageList(""));
+              throw new ArgumentException("Argument: "+this.args[i]+" missing second argument.");
             }
           }
           this.argList.Add(arg);
@@ -141,12 +143,10 @@ namespace BlubbFish.Utils
       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()
     {

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/FileLogger.cs

@@ -11,7 +11,7 @@ namespace BlubbFish.Utils
   {
     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 readonly StreamWriter file;
     private FileLogger(String filename, Boolean append)
     {
       filename = logDir + filename;

Utils/Helper.cs

@@ -0,0 +1,98 @@
+using System;
+using System.ComponentModel;
+using System.Reflection;
+
+namespace BlubbFish.Utils {
+  public static class Helper {
+    #region PropertyHelper
+    public static Boolean HasProperty(this Object o, String type) {
+      Type t = o.GetType();
+      foreach (PropertyInfo item in t.GetProperties()) {
+        if (item.Name == type) {
+          return true;
+        }
+      }
+      return false;
+    }
+
+    public static Object GetProperty(this Object o, String name) {
+      PropertyInfo prop = o.GetType().GetProperty(name);
+      if (prop.CanRead) {
+        return prop.GetValue(o);
+      }
+      return null;
+    }
+
+    public static void SetProperty(this Object o, String name, String value) {
+      PropertyInfo prop = o.GetType().GetProperty(name);
+      if (prop.CanWrite) {
+        if (prop.PropertyType == typeof(Boolean) && Boolean.TryParse(value, out Boolean vb)) {
+          prop.SetValue(o, vb);
+        } else if (prop.PropertyType == typeof(Byte) && Byte.TryParse(value, out Byte v8)) {
+          prop.SetValue(o, v8);
+        } else if (prop.PropertyType == typeof(Int32) && Int32.TryParse(value, out Int32 v32)) {
+          prop.SetValue(o, v32);
+        } else if (prop.PropertyType == typeof(Single) && Single.TryParse(value, out Single vs)) {
+          prop.SetValue(o, vs);
+        } else if (prop.PropertyType == typeof(Double) && Double.TryParse(value, out Double vd)) {
+          prop.SetValue(o, vd);
+        } else if (prop.PropertyType == typeof(Int64) && Int64.TryParse(value, out Int64 v64)) {
+          prop.SetValue(o, v64);
+        } else if (prop.PropertyType.BaseType == typeof(Enum)) {
+          try {
+            prop.SetValue(o, Enum.Parse(prop.PropertyType, value));
+          } catch (Exception) { }
+        }
+      }
+    }
+    #endregion
+
+    #region InterfaceHelper
+    public static Boolean HasInterface(this Type o, Type interf) {
+      foreach (Type item in o.GetInterfaces()) {
+        if (item == interf) {
+          return true;
+        }
+      }
+      return false;
+    }
+
+    public static Boolean HasAbstract(this Type o, Type type) {
+      if (o.BaseType == type) {
+        return true;
+      }
+      return false;
+    }
+    #endregion
+
+    #region StringHelper
+    public static String GetEnumDescription(Enum value) {
+      FieldInfo fi = value.GetType().GetField(value.ToString());
+
+      DescriptionAttribute[] attributes = (DescriptionAttribute[])fi.GetCustomAttributes(typeof(DescriptionAttribute), false);
+
+      if (attributes != null && attributes.Length > 0) {
+        return attributes[0].Description;
+      } else {
+        return value.ToString();
+      }
+    }
+
+    public static String ToUpperLower(this String s) {
+      if (s.Length == 0) {
+        return "";
+      }
+      if (s.Length == 1) {
+        return s.ToUpper();
+      }
+      return s[0].ToString().ToUpper() + s.Substring(1).ToLower();
+    }
+
+    public static void WriteError(String text) {
+      Console.ForegroundColor = ConsoleColor.Red;
+      Console.Error.WriteLine("ERROR: " + text);
+      Console.ResetColor();
+    }
+    #endregion
+  }
+}

Utils/InIReader.cs

@@ -0,0 +1,276 @@
+using System;
+using System.Collections.Generic;
+using System.IO;
+using System.Linq;
+using System.Text.RegularExpressions;
+
+namespace BlubbFish.Utils {
+  public class InIReader : IDisposable
+  {
+    private Dictionary<String, Dictionary<String, String>> inifile;
+    private readonly FileSystemWatcher k;
+    private readonly String filename;
+    private static List<String> search_path = new List<String>() {
+      Directory.GetCurrentDirectory()
+    };
+
+    private static Dictionary<String, InIReader> instances = new Dictionary<String, InIReader>();
+
+    public static void SetSearchPath(List<String> directorys) {
+      search_path.AddRange(directorys);
+    }
+
+    public static Boolean ConfigExist(String filename) {
+      foreach (String path in search_path) {
+        if (File.Exists(path + Path.DirectorySeparatorChar + filename)) {
+          return true;
+        } else if (File.Exists(path + Path.DirectorySeparatorChar + filename + ".ini")) {
+          return true;
+        } else if (File.Exists(path + Path.DirectorySeparatorChar + filename + ".conf")) {
+          return true;
+        }
+      }
+      return false;
+    }
+
+    private InIReader(String filename)
+    {
+      foreach (String path in search_path) {
+        if (File.Exists(path + Path.DirectorySeparatorChar + filename)) {
+          this.filename = path + Path.DirectorySeparatorChar + filename;
+          this.k = new FileSystemWatcher(path, filename);
+          break;
+        } else if (File.Exists(path + Path.DirectorySeparatorChar + filename + ".ini")) {
+          this.filename = path + Path.DirectorySeparatorChar + filename + ".ini";
+          this.k = new FileSystemWatcher(path, filename + ".ini");
+          break;
+        } else if(File.Exists(path + Path.DirectorySeparatorChar + filename + ".conf")) {
+          this.filename = path + Path.DirectorySeparatorChar + filename + ".conf";
+          this.k = new FileSystemWatcher(path, filename + ".conf");
+          break;
+        }
+      }
+      if(this.filename == null) {
+        throw new ArgumentException(filename + " not found!");
+      }
+      this.k.Changed += new FileSystemEventHandler(this.ReadAgain);
+      LoadFile();
+    }
+
+    /// <summary>
+    /// Gibt eine InIReader-Instanz zu einer Datei zurück
+    /// </summary>
+    /// <param name="filename">Dateiname</param>
+    /// <returns></returns>
+    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);
+      }
+    }
+
+    /// <summary>
+    /// Gibt eine Liste an Sektionen zurück
+    /// </summary>
+    /// <param name="withBrackets">Default = true; false, wenn die Liste ohne Klammern sein soll.</param>
+    /// <returns></returns>
+    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;
+      }
+    }
+
+    /// <summary>
+    /// Überschreibt eine InI-Datei mit der Kompletten neuen Configuration
+    /// </summary>
+    /// <param name="config">Neue Konfiguration</param>
+    public void SetSections(Dictionary<String, Dictionary<String, String>> config) {
+      this.inifile.Clear();
+      foreach (KeyValuePair<String, Dictionary<String, String>> item in config) {
+        String key = item.Key;
+        if(!key.StartsWith("[")) {
+          key = "[" + key + "]";
+        }
+        if (Regex.Match(key, @"^\[[a-zA-ZäöüÄÖÜ0-9\-\._/ ]+\]\w*$", RegexOptions.IgnoreCase).Success) {
+          this.inifile.Add(key, item.Value);
+        }
+      }
+      this.Changed();
+    }
+
+    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>();
+    }
+
+    /// <summary>
+    /// Gibt einen einzelnen Wert zurück
+    /// </summary>
+    /// <param name="section">Name der Sektion</param>
+    /// <param name="key">Name des Wertes</param>
+    /// <returns></returns>
+    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;
+    }
+
+    /// <summary>
+    /// Setzt einen Wert in einer Sektion
+    /// </summary>
+    /// <param name="section">Name der Sektion</param>
+    /// <param name="key">Name des Wertes</param>
+    /// <param name="value">Wert</param>
+    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/OwnModel.cs

@@ -9,7 +9,7 @@ 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>();
+    private readonly List<OwnView> observer = new List<OwnView>();
     public static T Instance
     {
       get {
@@ -35,5 +35,6 @@ namespace BlubbFish.Utils
       this.observer.ForEach(delegate (OwnView view) { view.Update(); });
     }
     abstract protected void Init();
+    abstract public void Dispose();
   }
 }

Utils/OwnObject.cs

@@ -1,7 +1,5 @@
 using System;
 using System.Collections.Generic;
-using System.Linq;
-using System.Text;
 
 namespace BlubbFish.Utils
 {
@@ -37,20 +35,6 @@ namespace BlubbFish.Utils
       }
     }
 
-    public class LogEventArgs : EventArgs {
-      public LogEventArgs(String location, String message, 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 LogLevel Level { get; private set; }
-      public DateTime Date { get; private set; }
-    }
-
     private List<LogObject> loglist = new List<LogObject>();
 
     public delegate void LogEvent(Object sender, LogEventArgs e);

Utils/OwnView.cs

@@ -7,9 +7,7 @@ using System.Threading.Tasks;
 namespace BlubbFish.Utils {
   public abstract class OwnView {
 
-    protected OwnView() {
+    protected OwnView() { }
-      this.Init();
-    }
     /// <summary>
     /// Called if the Oberver (Model) updates its View
     /// </summary>
@@ -17,7 +15,7 @@ namespace BlubbFish.Utils {
     /// <summary>
     /// Called if view is viewed
     /// </summary>
-    protected abstract void Init();
+    //protected abstract void Init();
     /// <summary>
     /// Called if Form is Disposed
     /// </summary>

Utils/ProgramLogger.cs

@@ -0,0 +1,170 @@
+using System;
+using System.IO;
+using System.Reflection;
+using System.Security;
+using System.Security.Permissions;
+using System.Text;
+
+namespace BlubbFish.Utils {
+  public class ProgramLogger {
+    private FileWriter fw;
+    private ConsoleWriter stdout;
+    private ConsoleWriter errout;
+    private String loggerfile;
+
+    public ProgramLogger() {
+      this.loggerfile = Directory.GetCurrentDirectory() + Path.DirectorySeparatorChar + "output.log";
+      this.Init(this.loggerfile);
+      this.AttachToFw();
+      this.SetOutputs();
+    }
+
+    private void SetOutputs() {
+      Console.SetOut(this.stdout);
+      Console.SetError(this.errout);
+    }
+
+    private void Init(String file) {
+      if(!this.IsWritable(file)) {
+        Console.Error.WriteLine("Cannot write to " + file);
+        throw new ArgumentException("Cannot write to " + file);
+      }
+      this.fw = new FileWriter(file);
+      this.stdout = new ConsoleWriter(Console.Out, ConsoleWriterEventArgs.ConsoleType.Info);
+      this.errout = new ConsoleWriter(Console.Error, ConsoleWriterEventArgs.ConsoleType.Error);
+    }
+
+    private Boolean IsWritable(String filename) {
+      FileIOPermission writePermission = new FileIOPermission(FileIOPermissionAccess.Write, filename);
+      PermissionSet p = new PermissionSet(PermissionState.None);
+      p.AddPermission(writePermission);
+      if (!p.IsSubsetOf(AppDomain.CurrentDomain.PermissionSet)) {
+        return false;
+      }
+      try {
+        using (FileStream fstream = new FileStream(filename, FileMode.Append))
+        using (TextWriter writer = new StreamWriter(fstream)) {
+          writer.Write("");
+        }
+      } catch (UnauthorizedAccessException) {
+        return false;
+      }
+      return true;
+    }
+
+    public void SetPath(String file) {
+      if(file == null) {
+        return;
+      }
+      if (!this.IsWritable(file)) {
+        Console.Error.WriteLine("Cannot write to " + file);
+        throw new ArgumentException("Cannot write to " + file);
+      }
+      this.DisattachToFw();
+      this.fw.Close();
+      if(new FileInfo(this.loggerfile).Length > 0) {
+        File.Move(this.loggerfile, file);
+      } else {
+        File.Delete(this.loggerfile);
+      }
+      this.loggerfile = file;
+      this.fw = new FileWriter(this.loggerfile);
+      this.AttachToFw();
+    }
+
+    private void DisattachToFw() {
+      this.stdout.WriteEvent -= this.fw.Write;
+      this.stdout.WriteLineEvent -= this.fw.WriteLine;
+      this.errout.WriteEvent -= this.fw.WriteLine;
+      this.errout.WriteLineEvent -= this.fw.WriteLine;
+    }
+    private void AttachToFw() {
+      this.stdout.WriteEvent += this.fw.Write;
+      this.stdout.WriteLineEvent += this.fw.WriteLine;
+      this.errout.WriteEvent += this.fw.WriteLine;
+      this.errout.WriteLineEvent += this.fw.WriteLine;
+    }
+  }
+
+  internal class FileWriter : StreamWriter {
+    private Boolean newline = true;
+    public FileWriter(String path) : base(path) {
+    }
+
+    public override Encoding Encoding { get { return Encoding.UTF8; } }
+    public override Boolean AutoFlush { get { return true; } set { base.AutoFlush = value; } }
+
+    private void Write(String value, TextWriter origstream, ConsoleWriterEventArgs.ConsoleType type) {
+      String text = "";
+      if (this.newline) {
+        text = "[" + DateTime.Now.ToString("o") + "]-" + type.ToString() + ": " + value;
+        this.newline = false;
+      } else {
+        text = value;
+      }
+      origstream.Write(text);
+      base.Write(text);
+      base.Flush();
+    }
+
+    private void WriteLine(String value, TextWriter origstream, ConsoleWriterEventArgs.ConsoleType type) {
+      String text = "";
+      if (this.newline) {
+        text = "[" + DateTime.Now.ToString("o") + "]-" + type.ToString() + ": " + value;
+      } else {
+        text = value;
+      }
+      this.newline = true;
+      origstream.WriteLine(text);
+      base.WriteLine(text);
+      base.Flush();
+    }
+
+    internal void Write(Object sender, ConsoleWriterEventArgs e) {
+      this.Write(e.Value, e.Writer, e.StreamType);
+    }
+
+    internal void WriteLine(Object sender, ConsoleWriterEventArgs e) {
+      this.WriteLine(e.Value, e.Writer, e.StreamType);
+    }
+  }
+
+  internal class ConsoleWriterEventArgs : EventArgs {
+    public String Value { get; private set; }
+    public TextWriter Writer { get; private set; }
+    public ConsoleType StreamType { get; private set; }
+
+    public enum ConsoleType {
+      Info,
+      Error
+    }
+
+    public ConsoleWriterEventArgs(String value, TextWriter writer, ConsoleType type) {
+      this.Value = value;
+      this.Writer = writer;
+      this.StreamType = type;
+    }
+  }
+
+  internal class ConsoleWriter : TextWriter {
+    private readonly TextWriter stream;
+    private readonly ConsoleWriterEventArgs.ConsoleType streamtype;
+
+    public ConsoleWriter(TextWriter writer, ConsoleWriterEventArgs.ConsoleType type) {
+      this.stream = writer;
+      this.streamtype = type;
+    }
+
+    public override Encoding Encoding { get { return Encoding.UTF8; } }
+    public override void Write(String value) {
+      this.WriteEvent?.Invoke(this, new ConsoleWriterEventArgs(value, this.stream, this.streamtype));
+      base.Write(value);
+    }
+    public override void WriteLine(String value) {
+      this.WriteLineEvent?.Invoke(this, new ConsoleWriterEventArgs(value, this.stream, this.streamtype));
+      base.WriteLine(value);
+    }
+    public event EventHandler<ConsoleWriterEventArgs> WriteEvent;
+    public event EventHandler<ConsoleWriterEventArgs> WriteLineEvent;
+  }
+}

Utils/Properties/AssemblyInfo.cs

@@ -10,7 +10,7 @@ using System.Runtime.InteropServices;
 [assembly: AssemblyConfiguration("")]
 [assembly: AssemblyCompany("")]
 [assembly: AssemblyProduct("Utils")]
-[assembly: AssemblyCopyright("Copyright ©  2014 - 24.04.2017")]
+[assembly: AssemblyCopyright("Copyright ©  2014 - 02.10.2018")]
 [assembly: AssemblyTrademark("")]
 [assembly: AssemblyCulture("")]
 
@@ -32,5 +32,9 @@ using System.Runtime.InteropServices;
 // 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.2.6")]
+[assembly: AssemblyVersion("1.4.0")]
-[assembly: AssemblyFileVersion("1.0.2.6")]
+[assembly: AssemblyFileVersion("1.4.0")]
+
+/**
+ * 1.4.0 Add Helper to 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.csproj

@@ -1,5 +1,5 @@
 <?xml version="1.0" encoding="utf-8"?>
-<Project ToolsVersion="4.0" DefaultTargets="Build" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
+<Project ToolsVersion="12.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>
@@ -9,8 +9,9 @@
     <AppDesignerFolder>Properties</AppDesignerFolder>
     <RootNamespace>BlubbFish.Utils</RootNamespace>
     <AssemblyName>Utils</AssemblyName>
-    <TargetFrameworkVersion>v4.5</TargetFrameworkVersion>
+    <TargetFrameworkVersion>v4.7.1</TargetFrameworkVersion>
     <FileAlignment>512</FileAlignment>
+    <TargetFrameworkProfile />
   </PropertyGroup>
   <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Debug|AnyCPU' ">
     <DebugSymbols>true</DebugSymbols>
@@ -41,13 +42,16 @@
   </ItemGroup>
   <ItemGroup>
     <Compile Include="CmdArgs.cs" />
+    <Compile Include="EventArgsHelper.cs" />
     <Compile Include="FileLogger.cs" />
     <Compile Include="FileMutex.cs" />
+    <Compile Include="Helper.cs" />
     <Compile Include="InIReader.cs" />
     <Compile Include="OwnController.cs" />
     <Compile Include="OwnModel.cs" />
     <Compile Include="OwnObject.cs" />
     <Compile Include="OwnView.cs" />
+    <Compile Include="ProgramLogger.cs" />
     <Compile Include="Properties\AssemblyInfo.cs" />
     <Compile Include="Updater.cs" />
   </ItemGroup>