vs_utils/Utils
1
0
Fork 0
Code Issues Pull Requests Releases 25 Wiki Activity

Move Utils to Subfolder

Browse Source
This commit is contained in:
Philip Schell 2019-02-14 11:43:34 +01:00
parent affe298cf9
commit b184187e21
15 changed files with 1414 additions and 1394 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

20
Utils.sln Normal file
View File

@ -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

370
CmdArgs.cs → Utils/CmdArgs.cs
View File

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

68
EventArgsHelper.cs → Utils/EventArgsHelper.cs
View File

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

134
FileLogger.cs → Utils/FileLogger.cs
View File

@ -1,67 +1,67 @@
using System; using System;
using System.Collections.Generic; using System.Collections.Generic;
using System.Linq; using System.Linq;
using System.Text; using System.Text;
using System.IO; using System.IO;
using System.Reflection; using System.Reflection;
namespace BlubbFish.Utils namespace BlubbFish.Utils
{ {
public class FileLogger public class FileLogger
{ {
private static Dictionary<String, FileLogger> instances = new Dictionary<String, FileLogger>(); private static Dictionary<String, FileLogger> instances = new Dictionary<String, FileLogger>();
private static String logDir = Path.GetDirectoryName(Assembly.GetExecutingAssembly().Location) + Path.DirectorySeparatorChar; private static String logDir = Path.GetDirectoryName(Assembly.GetExecutingAssembly().Location) + Path.DirectorySeparatorChar;
private readonly StreamWriter file; private readonly StreamWriter file;
private FileLogger(String filename, Boolean append) private FileLogger(String filename, Boolean append)
{ {
filename = logDir + filename; 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); Directory.CreateDirectory(folder);
} }
} }
this.file = new StreamWriter(filename, append, Encoding.UTF8) { this.file = new StreamWriter(filename, append, Encoding.UTF8) {
AutoFlush = true AutoFlush = true
}; };
} }
public static FileLogger GetInstance(String filename, Boolean 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)); instances.Add(filename, new FileLogger(filename, append));
} }
return instances[filename]; return instances[filename];
} }
public static void SetLogDir(String v) public static void SetLogDir(String v)
{ {
v = v.Replace("..", ""); v = v.Replace("..", "");
v = Path.GetDirectoryName(Assembly.GetExecutingAssembly().Location) + Path.DirectorySeparatorChar + v; v = Path.GetDirectoryName(Assembly.GetExecutingAssembly().Location) + Path.DirectorySeparatorChar + v;
if (Directory.Exists(v)) { if (Directory.Exists(v)) {
logDir = v; logDir = v;
} else { } else {
Directory.CreateDirectory(v); Directory.CreateDirectory(v);
logDir = 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; logDir = logDir + Path.DirectorySeparatorChar;
} }
} }
public void SetArray(String[] text) public void SetArray(String[] text)
{ {
this.file.Write(String.Join(this.file.NewLine, text) + this.file.NewLine); this.file.Write(String.Join(this.file.NewLine, text) + this.file.NewLine);
this.file.Flush(); this.file.Flush();
} }
public void SetLine(String text) public void SetLine(String text)
{ {
this.file.WriteLine(text); this.file.WriteLine(text);
this.file.Flush(); 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);
} }
} }
} }

142
FileMutex.cs → Utils/FileMutex.cs
View File

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

196
Helper.cs → Utils/Helper.cs
View File

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

552
InIReader.cs → Utils/InIReader.cs
View File

@ -1,276 +1,276 @@
using System; using System;
using System.Collections.Generic; using System.Collections.Generic;
using System.IO; using System.IO;
using System.Linq; using System.Linq;
using System.Text.RegularExpressions; using System.Text.RegularExpressions;
namespace BlubbFish.Utils { namespace BlubbFish.Utils {
public class InIReader : IDisposable public class InIReader : IDisposable
{ {
private Dictionary<String, Dictionary<String, String>> inifile; private Dictionary<String, Dictionary<String, String>> inifile;
private readonly FileSystemWatcher k; private readonly FileSystemWatcher k;
private readonly String filename; private readonly String filename;
private static List<String> search_path = new List<String>() { private static List<String> search_path = new List<String>() {
Directory.GetCurrentDirectory() Directory.GetCurrentDirectory()
}; };
private static Dictionary<String, InIReader> instances = new Dictionary<String, InIReader>(); private static Dictionary<String, InIReader> instances = new Dictionary<String, InIReader>();
public static void SetSearchPath(List<String> directorys) { public static void SetSearchPath(List<String> directorys) {
search_path.AddRange(directorys); search_path.AddRange(directorys);
} }
public static Boolean ConfigExist(String filename) { public static Boolean ConfigExist(String filename) {
foreach (String path in search_path) { foreach (String path in search_path) {
if (File.Exists(path + Path.DirectorySeparatorChar + filename)) { if (File.Exists(path + Path.DirectorySeparatorChar + filename)) {
return true; return true;
} else if (File.Exists(path + Path.DirectorySeparatorChar + filename + ".ini")) { } else if (File.Exists(path + Path.DirectorySeparatorChar + filename + ".ini")) {
return true; return true;
} else if (File.Exists(path + Path.DirectorySeparatorChar + filename + ".conf")) { } else if (File.Exists(path + Path.DirectorySeparatorChar + filename + ".conf")) {
return true; return true;
} }
} }
return false; return false;
} }
private InIReader(String filename) private InIReader(String filename)
{ {
foreach (String path in search_path) { foreach (String path in search_path) {
if (File.Exists(path + Path.DirectorySeparatorChar + filename)) { if (File.Exists(path + Path.DirectorySeparatorChar + filename)) {
this.filename = path + Path.DirectorySeparatorChar + filename; this.filename = path + Path.DirectorySeparatorChar + filename;
this.k = new FileSystemWatcher(path, filename); this.k = new FileSystemWatcher(path, filename);
break; break;
} else if (File.Exists(path + Path.DirectorySeparatorChar + filename + ".ini")) { } else if (File.Exists(path + Path.DirectorySeparatorChar + filename + ".ini")) {
this.filename = path + Path.DirectorySeparatorChar + filename + ".ini"; this.filename = path + Path.DirectorySeparatorChar + filename + ".ini";
this.k = new FileSystemWatcher(path, filename + ".ini"); this.k = new FileSystemWatcher(path, filename + ".ini");
break; break;
} else if(File.Exists(path + Path.DirectorySeparatorChar + filename + ".conf")) { } else if(File.Exists(path + Path.DirectorySeparatorChar + filename + ".conf")) {
this.filename = path + Path.DirectorySeparatorChar + filename + ".conf"; this.filename = path + Path.DirectorySeparatorChar + filename + ".conf";
this.k = new FileSystemWatcher(path, filename + ".conf"); this.k = new FileSystemWatcher(path, filename + ".conf");
break; break;
} }
} }
if(this.filename == null) { if(this.filename == null) {
throw new ArgumentException(filename + " not found!"); throw new ArgumentException(filename + " not found!");
} }
this.k.Changed += new FileSystemEventHandler(this.ReadAgain); this.k.Changed += new FileSystemEventHandler(this.ReadAgain);
LoadFile(); LoadFile();
} }
/// <summary> /// <summary>
/// Gibt eine InIReader-Instanz zu einer Datei zurück /// Gibt eine InIReader-Instanz zu einer Datei zurück
/// </summary> /// </summary>
/// <param name="filename">Dateiname</param> /// <param name="filename">Dateiname</param>
/// <returns></returns> /// <returns></returns>
public static InIReader GetInstance(String filename) public static InIReader GetInstance(String filename)
{ {
if (!instances.Keys.Contains(filename)) { if (!instances.Keys.Contains(filename)) {
instances.Add(filename, new InIReader(filename)); instances.Add(filename, new InIReader(filename));
} }
return instances[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.inifile = new Dictionary<String, Dictionary<String, String>>(); this.inifile = new Dictionary<String, Dictionary<String, String>>();
StreamReader file = new StreamReader(this.filename); 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(); 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); buf.Add(fline);
} }
} }
file.Close(); 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-ZäöüÄÖÜ0-9\-\._/ ]+\]\w*$", RegexOptions.IgnoreCase);
if (match.Success) { if (match.Success) {
if (sub.Count != 0 && cap != "") { if (sub.Count != 0 && cap != "") {
this.inifile.Add(cap, sub); this.inifile.Add(cap, sub);
} }
cap = line; cap = line;
sub = new Dictionary<String, String>(); sub = new Dictionary<String, String>();
} else { } else {
if (line != "" && cap != "") { if (line != "" && cap != "") {
String key = line.Substring(0, line.IndexOf('=')); String key = line.Substring(0, line.IndexOf('='));
String value = line.Substring(line.IndexOf('=') + 1); String value = line.Substring(line.IndexOf('=') + 1);
sub.Add(key, value); sub.Add(key, value);
} }
} }
} }
if (sub.Count != 0 && cap != "") { if (sub.Count != 0 && cap != "") {
this.inifile.Add(cap, sub); this.inifile.Add(cap, sub);
} }
} }
/// <summary> /// <summary>
/// Gibt eine Liste an Sektionen zurück /// Gibt eine Liste an Sektionen zurück
/// </summary> /// </summary>
/// <param name="withBrackets">Default = true; false, wenn die Liste ohne Klammern sein soll.</param> /// <param name="withBrackets">Default = true; false, wenn die Liste ohne Klammern sein soll.</param>
/// <returns></returns> /// <returns></returns>
public List<String> GetSections(Boolean withBrackets = true) public List<String> GetSections(Boolean withBrackets = true)
{ {
if(withBrackets) { if(withBrackets) {
return this.inifile.Keys.ToList(); return this.inifile.Keys.ToList();
} else { } else {
List<String> ret = new List<String>(); List<String> ret = new List<String>();
foreach (String item in this.inifile.Keys) { foreach (String item in this.inifile.Keys) {
ret.Add(item.Substring(1, item.Length - 2)); ret.Add(item.Substring(1, item.Length - 2));
} }
return ret; return ret;
} }
} }
/// <summary> /// <summary>
/// Überschreibt eine InI-Datei mit der Kompletten neuen Configuration /// Überschreibt eine InI-Datei mit der Kompletten neuen Configuration
/// </summary> /// </summary>
/// <param name="config">Neue Konfiguration</param> /// <param name="config">Neue Konfiguration</param>
public void SetSections(Dictionary<String, Dictionary<String, String>> config) { public void SetSections(Dictionary<String, Dictionary<String, String>> config) {
this.inifile.Clear(); this.inifile.Clear();
foreach (KeyValuePair<String, Dictionary<String, String>> item in config) { foreach (KeyValuePair<String, Dictionary<String, String>> item in config) {
String key = item.Key; String key = item.Key;
if(!key.StartsWith("[")) { if(!key.StartsWith("[")) {
key = "[" + key + "]"; key = "[" + key + "]";
} }
if (Regex.Match(key, @"^\[[a-zA-ZäöüÄÖÜ0-9\-\._/ ]+\]\w*$", RegexOptions.IgnoreCase).Success) { if (Regex.Match(key, @"^\[[a-zA-ZäöüÄÖÜ0-9\-\._/ ]+\]\w*$", RegexOptions.IgnoreCase).Success) {
this.inifile.Add(key, item.Value); this.inifile.Add(key, item.Value);
} }
} }
this.Changed(); this.Changed();
} }
public Dictionary<String, String> GetSection(String section) { public Dictionary<String, String> GetSection(String section) {
if(this.inifile.Keys.Contains(section)) { if(this.inifile.Keys.Contains(section)) {
return this.inifile[section]; return this.inifile[section];
} }
if(this.inifile.Keys.Contains("["+section+"]")) { if(this.inifile.Keys.Contains("["+section+"]")) {
return this.inifile["[" + section + "]"]; return this.inifile["[" + section + "]"];
} }
return new Dictionary<String, String>(); return new Dictionary<String, String>();
} }
/// <summary> /// <summary>
/// Gibt einen einzelnen Wert zurück /// Gibt einen einzelnen Wert zurück
/// </summary> /// </summary>
/// <param name="section">Name der Sektion</param> /// <param name="section">Name der Sektion</param>
/// <param name="key">Name des Wertes</param> /// <param name="key">Name des Wertes</param>
/// <returns></returns> /// <returns></returns>
public String GetValue(String section, String key) public String GetValue(String section, String key)
{ {
if (!section.StartsWith("[")) { if (!section.StartsWith("[")) {
section = "[" + section + "]"; section = "[" + section + "]";
} }
if (this.inifile.Keys.Contains(section)) { if (this.inifile.Keys.Contains(section)) {
if (this.inifile[section].Keys.Contains(key)) { if (this.inifile[section].Keys.Contains(key)) {
return this.inifile[section][key]; return this.inifile[section][key];
} }
} }
return null; return null;
} }
/// <summary> /// <summary>
/// Setzt einen Wert in einer Sektion /// Setzt einen Wert in einer Sektion
/// </summary> /// </summary>
/// <param name="section">Name der Sektion</param> /// <param name="section">Name der Sektion</param>
/// <param name="key">Name des Wertes</param> /// <param name="key">Name des Wertes</param>
/// <param name="value">Wert</param> /// <param name="value">Wert</param>
public void SetValue(String section, String key, String value) public void SetValue(String section, String key, String value)
{ {
if (!section.StartsWith("[")) { if (!section.StartsWith("[")) {
section = "[" + section + "]"; section = "[" + section + "]";
} }
if (this.inifile.Keys.Contains(section)) { if (this.inifile.Keys.Contains(section)) {
if (this.inifile[section].Keys.Contains(key)) { if (this.inifile[section].Keys.Contains(key)) {
this.inifile[section][key] = value; this.inifile[section][key] = value;
} else { } else {
this.inifile[section].Add(key, value); this.inifile[section].Add(key, value);
} }
} else { } else {
Dictionary<String, String> sub = new Dictionary<String, String> { Dictionary<String, String> sub = new Dictionary<String, String> {
{ key, value } { key, value }
}; };
this.inifile.Add(section, sub); this.inifile.Add(section, sub);
} }
this.Changed(); this.Changed();
} }
private void Changed() private void Changed()
{ {
this.k.Changed -= null; this.k.Changed -= null;
SaveSettings(); SaveSettings();
LoadFile(); LoadFile();
this.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); StreamWriter file = new StreamWriter(this.filename);
file.BaseStream.SetLength(0); file.BaseStream.SetLength(0);
file.BaseStream.Flush(); file.BaseStream.Flush();
file.BaseStream.Seek(0, SeekOrigin.Begin); file.BaseStream.Seek(0, SeekOrigin.Begin);
foreach (KeyValuePair<String, Dictionary<String, String>> cap in this.inifile) { foreach (KeyValuePair<String, Dictionary<String, String>> cap in this.inifile) {
file.WriteLine(cap.Key); 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(sub.Key + "=" + sub.Value);
} }
file.WriteLine(); file.WriteLine();
} }
file.Flush(); file.Flush();
file.Close(); file.Close();
} }
/// <summary> /// <summary>
/// Fügt eine neue Sektion in der Ini-Datei ein. /// Fügt eine neue Sektion in der Ini-Datei ein.
/// </summary> /// </summary>
/// <param name="name">Sektionsname</param> /// <param name="name">Sektionsname</param>
/// <returns>true if added, false if error</returns> /// <returns>true if added, false if error</returns>
public Boolean AddSection(String name) public Boolean AddSection(String name)
{ {
if (!name.StartsWith("[")) { if (!name.StartsWith("[")) {
name = "[" + name + "]"; name = "[" + name + "]";
} }
if (this.inifile.Keys.Contains(name)) { if (this.inifile.Keys.Contains(name)) {
return false; return false;
} }
this.inifile.Add(name, new Dictionary<String, String>()); this.inifile.Add(name, new Dictionary<String, String>());
this.Changed(); this.Changed();
return true; return true;
} }
/// <summary> /// <summary>
/// Löscht eine Sektion inklusive Unterpunkte aus der Ini-Datei. /// Löscht eine Sektion inklusive Unterpunkte aus der Ini-Datei.
/// </summary> /// </summary>
/// <param name="name">Sektionsname</param> /// <param name="name">Sektionsname</param>
/// <returns>true if removed, false if error</returns> /// <returns>true if removed, false if error</returns>
public Boolean RemoveSection(String name) public Boolean RemoveSection(String name)
{ {
if (!name.StartsWith("[")) { if (!name.StartsWith("[")) {
name = "[" + name + "]"; name = "[" + name + "]";
} }
if (!this.inifile.Keys.Contains(name)) { if (!this.inifile.Keys.Contains(name)) {
return false; return false;
} }
this.inifile.Remove(name); this.inifile.Remove(name);
this.Changed(); this.Changed();
return false; return false;
} }
protected virtual void Dispose(Boolean disposing) { protected virtual void Dispose(Boolean disposing) {
if (disposing) { if (disposing) {
this.k.Dispose(); this.k.Dispose();
} }
} }
public void Dispose() { public void Dispose() {
Dispose(true); Dispose(true);
GC.SuppressFinalize(this); GC.SuppressFinalize(this);
} }
} }
} }

44
OwnController.cs → Utils/OwnController.cs
View File

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

80
OwnModel.cs → Utils/OwnModel.cs
View File

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

220
OwnObject.cs → Utils/OwnObject.cs
View File

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

48
OwnView.cs → Utils/OwnView.cs
View File

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

340
ProgramLogger.cs → Utils/ProgramLogger.cs
View File

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

80
Properties/AssemblyInfo.cs → Utils/Properties/AssemblyInfo.cs
View File

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

384
Updater.cs → Utils/Updater.cs
View File

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

130
Utils.csproj → Utils/Utils.csproj
View File

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