Utils.csproj

[NF] Programmlogger added (v1.1.0)
[NF] Utils fixing tiny issues

Zway-Bot.csproj
[NF] changes Topics without beginning /
[NF] Using programmlogger (v1.4.0)

CmdArgs.cs

@@ -1,7 +1,6 @@
 using System;
 using System.Collections.Generic;
 using System.Linq;
-using System.Text;
 
 namespace BlubbFish.Utils
 {
@@ -13,9 +12,9 @@ namespace BlubbFish.Utils
       Touple
     }
     #region Classes
-        public class VaildArguments
+    public struct VaildArguments
     {
-            public VaildArguments(ArgLength length, bool required)
+      public VaildArguments(ArgLength length, Boolean required)
       {
         this.Required = required;
         this.Length = length;
@@ -27,34 +26,36 @@ namespace BlubbFish.Utils
       }
 
       public ArgLength Length { get; private set; }
-            public bool Required { get; private set; }
+      public Boolean Required { get; private set; }
     }
-        private class ArgTouple
+    private struct ArgTouple
     {
-            public ArgTouple(string type, string data)
+      public ArgTouple(String type, String data)
       {
-                this.type = type;
+        this.Type = type;
-                this.data = data;
+        this.Data = data;
       }
-            public ArgTouple(string type)
+      public ArgTouple(String type)
       {
-                this.type = type;
+        this.Type = type;
+        this.Data = "";
       }
-            public string type { get; private set; }
+      public String Type { get; private set; }
-            public string data { get; private set; }
+      public String Data { get; private set; }
 
-            internal void setData(string data)
+      internal void SetData(String data)
       {
-                if (data != "")
+        if (data != "") {
-                    this.data = data;
+          this.Data = data;
+        }
       }
     }
     #endregion
-        private string[] args;
+    private String[] args;
     private List<ArgTouple> argList;
-        private Dictionary<string, VaildArguments> argsPosible = new Dictionary<string, VaildArguments>();
+    private Dictionary<String, VaildArguments> argsPosible = new Dictionary<String, VaildArguments>();
     private static CmdArgs instances = null;
-        private bool isSetArguments = false;
+    private Boolean isSetArguments = false;
 
     private CmdArgs()
     {
@@ -64,25 +65,25 @@ namespace BlubbFish.Utils
     /// Gibt eine Instanz der Klasse zurück
     /// </summary>
     /// <returns>Klasse</returns>
-        public static CmdArgs getInstance()
+    public static CmdArgs Instance
-        {
-            if (instances == null)
     {
+      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)
+    public void SetArguments(Dictionary<String, VaildArguments> arguments, String[] args)
     {
       this.args = args;
-            if (!this.isSetArguments)
+      if (!this.isSetArguments) {
-            {
         this.isSetArguments = true;
         this.argsPosible = arguments;
         this.Init();
@@ -92,19 +93,13 @@ namespace BlubbFish.Utils
     private void Init()
     {
       this.argList = new List<ArgTouple>();
-            for (int i = 0; i < this.args.Length; i++)
+      for (Int32 i = 0; i < this.args.Length; i++) {
-            {
+        if (this.argsPosible.Keys.Contains(this.args[i])) {
-                if (this.argsPosible.Keys.Contains(args[i]))
+          ArgTouple arg = new ArgTouple(this.args[i]);
-                {
+          if (this.argsPosible[this.args[i]].Length == ArgLength.Touple) {
-                    ArgTouple arg = new ArgTouple(args[i]);
+            if (this.args.Length > i + 1) {
-                    if (argsPosible[args[i]].Length == ArgLength.Touple)
+              arg.SetData(this.args[++i]);
-                    {
+            } else {
-                        if (args.Length > i + 1)
-                        {
-                            arg.setData(args[++i]);
-                        }
-                        else
-                        {
               throw new ArgumentException();
             }
           }
@@ -117,7 +112,7 @@ namespace BlubbFish.Utils
     /// Menge der angegebenen Komandozeilen-Argumente
     /// </summary>
     /// <returns>Menge</returns>
-        public int GetArgsLength()
+    public Int32 GetArgsLength()
     {
       return this.argList.Count;
     }
@@ -127,13 +122,13 @@ namespace BlubbFish.Utils
     /// </summary>
     /// <param name="name">Name des Arguments</param>
     /// <returns>true wenn angegeben</returns>
-        public bool HasArgumentType(string name)
+    public Boolean HasArgumentType(String name)
     {
-            foreach (ArgTouple t in this.argList)
+      foreach (ArgTouple t in this.argList) {
-            {
+        if (t.Type == name) {
-                if (t.type == name)
           return true;
         }
+      }
       return false;
     }
 
@@ -142,57 +137,47 @@ namespace BlubbFish.Utils
     /// </summary>
     /// <param name="name">Name des Arguments</param>
     /// <returns>Inhalt des Arguments oder ArgumentNullException</returns>
-        public string GetArgumentData(string name)
+    public String GetArgumentData(String name)
-        {
-            foreach (ArgTouple t in this.argList)
-            {
-                if (t.type == name && t.data != null)
-                    return t.data;
-                else
     {
+      foreach (ArgTouple t in this.argList) {
+        if (t.Type == name && t.Data != null) {
+          return t.Data;
+        } else {
           throw new ArgumentNullException();
         }
       }
       return null;
     }
 
-        public bool HasAllRequiredArguments()
+    public Boolean HasAllRequiredArguments()
-        {
-            foreach (KeyValuePair<string, VaildArguments> item in this.argsPosible)
-            {
-                if (item.Value.Required && !this.HasArgumentType(item.Key))
     {
+      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)
+    public String GetUsageList(String name)
     {
-            string ret = "Usage: "+name+" Parameter\nParameter:\n";
+      String ret = "Usage: " + name + " Parameter\nParameter:\n";
-            string req ="";
+      String req = "";
-            string opt = "";
+      String opt = "";
-            foreach (KeyValuePair<string, VaildArguments> item in this.argsPosible)
+      foreach (KeyValuePair<String, VaildArguments> item in this.argsPosible) {
-            {
+        if (item.Value.Required) {
-                if (item.Value.Required)
+          req += item.Key + " " + ((item.Value.Length == ArgLength.Touple) ? " [data]\n" : "\n");
-                {
-                    req += item.Key+" "+((item.Value.Length == ArgLength.Touple)?" [data]\n":"\n");
         }
       }
-            if (req != "")
+      if (req != "") {
-            {
         ret += "Benötigte Parameter:\n" + req;
       }
-            foreach (KeyValuePair<string, VaildArguments> item in this.argsPosible)
+      foreach (KeyValuePair<String, VaildArguments> item in this.argsPosible) {
-            {
+        if (!item.Value.Required) {
-                if (!item.Value.Required)
-                {
           opt += item.Key + " " + ((item.Value.Length == ArgLength.Touple) ? " [data]\n" : "\n");
         }
       }
-            if (opt != "")
+      if (opt != "") {
-            {
         ret += "Optionale Parameter:\n" + opt;
       }
       return ret;

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; }
+  }
+}

FileLogger.cs

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

FileMutex.cs

@@ -1,49 +1,71 @@
 using System;
-using System.Collections.Generic;
 using System.IO;
-using System.Linq;
 using System.Security.Cryptography;
 using System.Text;
-using System.Threading.Tasks;
 
-namespace BlubbFish.Utils {
+namespace BlubbFish.Utils
-  public class FileMutex {
+{
+  public class FileMutex : IDisposable
+  {
     private static FileMutex instance;
     private String filename;
     private StreamWriter file;
     private FileMutex() { }
 
-    public static FileMutex Instance {
+    public static FileMutex Instance
+    {
       get {
-        if(FileMutex.instance == null) {
+        if (instance == null) {
-          FileMutex.instance = new FileMutex();
+          instance = new FileMutex();
         }
-        return FileMutex.instance;
+        return instance;
       }
     }
 
-    public void setName(string name) {
+    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";
+      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 bool create() {
+    public Boolean Create()
-      if(File.Exists(this.filename))
+    {
+      if (File.Exists(this.filename)) {
         return false;
-      this.file = new StreamWriter(this.filename);
-      this.initFile();
-      return File.Exists(this.filename) && file != null;
       }
 
-    private void initFile() {
+      this.file = new StreamWriter(this.filename);
-      this.file.Write("Created: " + DateTime.Now.ToUniversalTime()+"\n");
+      InitFile();
+      return File.Exists(this.filename) && this.file != null;
+    }
+
+    private void InitFile()
+    {
+      this.file.Write("Created: " + DateTime.Now.ToUniversalTime() + "\n");
       this.file.Flush();
     }
 
-    public bool delete() {
+    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);
+    }
   }
 }

InIReader.cs

@@ -2,151 +2,223 @@
 using System.Collections.Generic;
 using System.IO;
 using System.Linq;
-using System.Text;
 using System.Text.RegularExpressions;
-using System.Threading.Tasks;
 
-namespace BlubbFish.Utils
+namespace BlubbFish.Utils {
-{
+  public class InIReader : IDisposable
-    public class InIReader
   {
-        private Dictionary<string, Dictionary<string, string>> cont;
+    private Dictionary<String, Dictionary<String, String>> inifile;
-        private FileSystemWatcher k = new FileSystemWatcher(Directory.GetCurrentDirectory(), "*.ini");
+    private FileSystemWatcher k;
-        private string filename;
+    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>();
+    private static Dictionary<String, InIReader> instances = new Dictionary<String, InIReader>();
 
-        private InIReader(string filename)
+    public static void SetSearchPath(List<String> directorys) {
-        {
+      search_path.AddRange(directorys);
-            this.filename = filename;
-            k.Changed += new FileSystemEventHandler(this.readAgain);
-            loadFile();
     }
 
-        public static InIReader getInstance(string filename)
+    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)
     {
-            if (!instances.Keys.Contains(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)
+    private void ReadAgain(Object sender, EventArgs e)
     {
-            this.loadFile();
+      this.LoadFile();
     }
 
-        private void loadFile()
+    private void LoadFile()
     {
-            this.cont = new Dictionary<string, Dictionary<string, string>>();
+      this.inifile = new Dictionary<String, Dictionary<String, String>>();
       StreamReader file = new StreamReader(this.filename);
-            List<String> buf = new List<string>();
+      List<String> buf = new List<String>();
-            string fline = "";
+      String fline = "";
-            while (fline != null)
+      while (fline != null) {
-            {
         fline = file.ReadLine();
-                if (fline != null && fline.Length > 0 && fline.Substring(0,1) != ";")
+        if (fline != null && fline.Length > 0 && fline.Substring(0, 1) != ";") {
           buf.Add(fline);
         }
+      }
       file.Close();
-            Dictionary<string, string> sub = new Dictionary<string, string>();
+      Dictionary<String, String> sub = new Dictionary<String, String>();
-            string cap = "";
+      String cap = "";
-            foreach (string line in buf)
+      foreach (String line in buf) {
-            {
+        Match match = Regex.Match(line, @"^\[[a-zA-ZäöüÄÖÜ0-9\-_ ]+\]\w*$", RegexOptions.IgnoreCase);
-                Match match = Regex.Match(line, @"^\[[a-zA-Z0-9\-_ ]+\]\w*$", RegexOptions.IgnoreCase);
+        if (match.Success) {
-                if (match.Success)
+          if (sub.Count != 0 && cap != "") {
-                {
+            this.inifile.Add(cap, sub);
-                    if (sub.Count != 0 && cap != "")
-                    {
-                        this.cont.Add(cap, sub);
           }
           cap = line;
-                    sub = new Dictionary<string, string>();
+          sub = new Dictionary<String, String>();
-                }
+        } else {
-                else
+          if (line != "" && cap != "") {
-                {
+            String key = line.Substring(0, line.IndexOf('='));
-                    if (line != "" && cap != "")
+            String value = line.Substring(line.IndexOf('=') + 1);
-                    {
-                        string key = line.Substring(0, line.IndexOf('='));
-                        string value = line.Substring(line.IndexOf('=') + 1);
             sub.Add(key, value);
           }
         }
       }
-            if (sub.Count != 0 && cap != "")
+      if (sub.Count != 0 && cap != "") {
-            {
+        this.inifile.Add(cap, sub);
-                this.cont.Add(cap, sub);
       }
     }
 
-        public List<String> getSections()
+    /// <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)
     {
-            return cont.Keys.ToList<String>();
+      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 String getValue(String section, String key)
+    /// <summary>
-        {
+    /// Überschreibt eine InI-Datei mit der Kompletten neuen Configuration
-            if (!section.StartsWith("["))
+    /// </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 (cont.Keys.Contains(section))
+      if (this.inifile.Keys.Contains(section)) {
-            {
+        if (this.inifile[section].Keys.Contains(key)) {
-                if (cont[section].Keys.Contains(key))
+          return this.inifile[section][key];
-                {
-                    return cont[section][key];
         }
       }
       return null;
     }
 
-
+    /// <summary>
-        public void SetValue(string section, string key, string value)
+    /// Setzt einen Wert in einer Sektion
-        {
+    /// </summary>
-            if (!section.StartsWith("["))
+    /// <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 (cont.Keys.Contains(section))
+      if (this.inifile.Keys.Contains(section)) {
-            {
+        if (this.inifile[section].Keys.Contains(key)) {
-                if (cont[section].Keys.Contains(key))
+          this.inifile[section][key] = value;
-                {
+        } else {
-                    cont[section][key] = value;
+          this.inifile[section].Add(key, value);
         }
-                else
+      } else {
-                {
+        Dictionary<String, String> sub = new Dictionary<String, String> {
-                    cont[section].Add(key, value);
+          { key, value }
+        };
+        this.inifile.Add(section, sub);
       }
-            }
+      this.Changed();
-            else
-            {
-                Dictionary<string, string> sub = new Dictionary<string, string>();
-                sub.Add(key, value);
-                cont.Add(section, sub);
-            }
-            this.changed();
     }
 
-        private void changed()
+    private void Changed()
     {
-            k.Changed -= null;
+      this.k.Changed -= null;
-            saveSettings();
+      SaveSettings();
-            loadFile();
+      LoadFile();
-            k.Changed += new FileSystemEventHandler(this.readAgain);
+      this.k.Changed += new FileSystemEventHandler(this.ReadAgain);
     }
 
-        private void saveSettings()
+    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)
+      foreach (KeyValuePair<String, Dictionary<String, String>> cap in this.inifile) {
-            {
         file.WriteLine(cap.Key);
-                foreach (KeyValuePair<string, string> sub in cap.Value)
+        foreach (KeyValuePair<String, String> sub in cap.Value) {
-                {
           file.WriteLine(sub.Key + "=" + sub.Value);
         }
         file.WriteLine();
@@ -160,18 +232,16 @@ namespace BlubbFish.Utils
     /// </summary>
     /// <param name="name">Sektionsname</param>
     /// <returns>true if added, false if error</returns>
-        public bool addSection(string name)
+    public Boolean AddSection(String name)
-        {
-            if (!name.StartsWith("["))
     {
+      if (!name.StartsWith("[")) {
         name = "[" + name + "]";
       }
-            if (this.cont.Keys.Contains(name))
+      if (this.inifile.Keys.Contains(name)) {
-            {
         return false;
       }
-            this.cont.Add(name, new Dictionary<string, string>());
+      this.inifile.Add(name, new Dictionary<String, String>());
-            this.changed();
+      this.Changed();
       return true;
     }
 
@@ -180,19 +250,27 @@ namespace BlubbFish.Utils
     /// </summary>
     /// <param name="name">Sektionsname</param>
     /// <returns>true if removed, false if error</returns>
-        public bool removeSection(string name)
+    public Boolean RemoveSection(String name)
-        {
-            if (!name.StartsWith("["))
     {
+      if (!name.StartsWith("[")) {
         name = "[" + name + "]";
       }
-            if (!this.cont.Keys.Contains(name))
+      if (!this.inifile.Keys.Contains(name)) {
-            {
         return false;
       }
-            this.cont.Remove(name);
+      this.inifile.Remove(name);
-            this.changed();
+      this.Changed();
       return false;
     }
+    protected virtual void Dispose(Boolean disposing) {
+      if (disposing) {
+        this.k.Dispose();
+      }
+    }
+
+    public void Dispose() {
+      Dispose(true);
+      GC.SuppressFinalize(this);
+    }
   }
 }

OwnController.cs

@@ -12,11 +12,11 @@ namespace BlubbFish.Utils
     /// <summary>
     /// Führt den Controller aus.
     /// </summary>
-        public void execute()
+    public void Execute()
     {
-            this.init();
+      this.Init();
     }
-        abstract protected void init();
+    abstract protected void Init();
     abstract public void Dispose();
   }
 }

OwnModel.cs

@@ -12,8 +12,7 @@ namespace BlubbFish.Utils
     private List<OwnView> observer = new List<OwnView>();
     public static T Instance
     {
-            get
+      get {
-            {
         return _instance.Value;
       }
     }
@@ -22,15 +21,19 @@ namespace BlubbFish.Utils
       return Activator.CreateInstance(typeof(T), true) as T;
     }
 
-        public void setObserver(OwnView tray)
+    public void SetObserver(OwnView view)
     {
-            this.observer.Add(tray);
+      this.observer.Add(view);
-            tray.update();
+      view.Update();
     }
-        protected void update()
+
+    public void RemoveObserver(OwnView view) {
+      this.observer.Remove(view);
+    }
+    protected void Update()
     {
-            this.observer.ForEach(delegate(OwnView tray) { tray.update(); });
+      this.observer.ForEach(delegate (OwnView view) { view.Update(); });
     }
-        abstract protected void init();
+    abstract protected void Init();
   }
 }

OwnObject.cs

@@ -1,14 +1,44 @@
 using System;
 using System.Collections.Generic;
-using System.Linq;
-using System.Text;
 
-namespace BlubbFish.Utils {
+namespace BlubbFish.Utils
-  abstract public class OwnObject {
+{
-    private List<Tuple<DateTime, string, string, LogLevel>> loglist = new List<Tuple<DateTime, string, string, LogLevel>>();
+  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 delegate void LogEvent(string location, string message, LogLevel level, DateTime date);
+      public DateTime Date { get; set; }
-    public enum LogLevel : int {
+      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,
@@ -16,57 +46,65 @@ namespace BlubbFish.Utils {
       Error = 16
     }
 
-    public event LogEvent eventDebug;
+    public event LogEvent EventDebug;
-    public event LogEvent eventNotice;
+    public event LogEvent EventNotice;
-    public event LogEvent eventInfo;
+    public event LogEvent EventInfo;
-    public event LogEvent eventWarn;
+    public event LogEvent EventWarn;
-    public event LogEvent eventError;
+    public event LogEvent EventError;
     public event LogEvent EventLog;
 
     /// <summary>
     /// Get the Complete Log
     /// </summary>
-    public List<string> getLog(LogLevel level, bool classNames, bool timeStamps) {
+    public List<String> GetLog(LogLevel level, Boolean classNames, Boolean timeStamps) {
-      List<string> ret = new List<string>();
+      List<String> ret = new List<String>();
-      foreach(Tuple<DateTime, string, string, LogLevel> t in this.loglist) {
+      foreach (LogObject t in this.loglist) {
-        if(t.Item4 >= level) {
+        if (t.Level >= level) {
-          ret.Add(logToString(t.Item2, t.Item3, t.Item4, t.Item1, classNames, timeStamps));
+          ret.Add(t.ToString(classNames, timeStamps));
         }
       }
       return ret;
     }
 
     /// <summary>
-    /// Formates a LogMessage to a String
+    /// Put a message in the log
     /// </summary>
-    public static string logToString(string location, string message, LogLevel level, DateTime date, bool classNames, bool timeStamps) {
+    /// <param name="location">Where the event arrives</param>
-      return (timeStamps ? "[" + date.ToString("R") + "]: "+level.ToString()+" " : "") + (classNames ? location + ", " : "") + message;
+    /// <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);
     }
 
-    protected void addLog(string location, string message, LogLevel level) {
+    /// <summary>
-      this.addLog(location, message, level, DateTime.Now);
+    /// 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);
 
-    protected void addLog(string location, string message, LogLevel level, DateTime date) {
+      this.loglist.Add(new LogObject(date, location, message, level));
-      if(eventDebug != null && level >= LogLevel.Debug) {
-        eventDebug(location, message, level, date);
-      }
-      if(eventNotice != null && level >= LogLevel.Notice) {
-        eventNotice(location, message, level, date);
-      }
-      if(eventInfo != null && level >= LogLevel.Info) {
-        eventInfo(location, message, level, date);
-      }
-      if(eventWarn != null && level >= LogLevel.Warn) {
-        eventWarn(location, message, level, date);
-      }
-      if(eventError != null && level >= LogLevel.Error) {
-        eventError(location, message, level, date);
-      }
-      if(EventLog != null) {
-        EventLog(location, message, level, date);
-      }
-      this.loglist.Add(new Tuple<DateTime, string, string, LogLevel>(date, location, message, level));
     }
   }
 }

OwnView.cs

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

ProgramLogger.cs

@@ -0,0 +1,163 @@
+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);
+      }
+      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 = "[" + DateTime.Now.ToString("o") + "]-" + type.ToString() + ": " + value;
+      origstream.WriteLine(text);
+      base.WriteLine(text);
+      this.newline = true;
+      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;
+  }
+}

Properties/AssemblyInfo.cs

@@ -10,7 +10,7 @@ using System.Runtime.InteropServices;
 [assembly: AssemblyConfiguration("")]
 [assembly: AssemblyCompany("")]
 [assembly: AssemblyProduct("Utils")]
-[assembly: AssemblyCopyright("Copyright ©  2014 - 03.03.2017")]
+[assembly: AssemblyCopyright("Copyright ©  2014 - 15.05.2018")]
 [assembly: AssemblyTrademark("")]
 [assembly: AssemblyCulture("")]
 
@@ -32,5 +32,5 @@ 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.1")]
+[assembly: AssemblyVersion("1.1.0")]
-[assembly: AssemblyFileVersion("1.0.2.1")]
+[assembly: AssemblyFileVersion("1.1.0")]

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.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,6 +42,7 @@
   </ItemGroup>
   <ItemGroup>
     <Compile Include="CmdArgs.cs" />
+    <Compile Include="EventArgsHelper.cs" />
     <Compile Include="FileLogger.cs" />
     <Compile Include="FileMutex.cs" />
     <Compile Include="InIReader.cs" />
@@ -48,7 +50,9 @@
     <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>
   <Import Project="$(MSBuildToolsPath)\Microsoft.CSharp.targets" />
   <!-- To modify your build process, add your task inside one of the targets below and uncomment it.