Angepinnt [Sammelthread] Code-Korrektur

  • VB.NET

Es gibt 123 Antworten in diesem Thema. Der letzte Beitrag () ist von FormFollowsFunction.

    Lord C schrieb:

    korrigieren lassen
    Ein leeres CD / DVD / BR-Laufwerk knallt.
    Dieser Pfad knallt, weil nicht vorhanden:

    VB.NET-Quellcode

    1. "C:\Users\" & My.User.Name & "\Documents\Save_Path\other_diretory.txt"

    Was genau soll da rauskommen?
    Falls Du diesen Code kopierst, achte auf die C&P-Bremse.
    Jede einzelne Zeile Deines Programms, die Du nicht explizit getestet hast, ist falsch :!:
    Ein guter .NET-Snippetkonverter (der ist verfügbar).
    Programmierfragen über PN / Konversation werden ignoriert!
    den pfad erstelle ich im vorraus per code. Dann wird die input aufgefufen der user wählt aus der cb seinen neuen pfad der wird in die txt gespeichert. und dann werden die daten vom standart speicherort dahin geschoben und gespeichert.

    Edit: ich habe die aufrufrotiene des eig. codes noch hinzugefügt.

    Lord C schrieb:

    VB.NET-Quellcode

    1. IO.Directory.Exists("C:\Program Files (x86)\Save_Path\other_diretory.txt")
    Was soll Deiner Meinung nach diese Zeile tun?
    Tut sie es tatsächlich?
    Überzeuge Dich davon :!:
    Falls Du diesen Code kopierst, achte auf die C&P-Bremse.
    Jede einzelne Zeile Deines Programms, die Du nicht explizit getestet hast, ist falsch :!:
    Ein guter .NET-Snippetkonverter (der ist verfügbar).
    Programmierfragen über PN / Konversation werden ignoriert!
    Das stellt aber keine Inputbox dar.
    Das scheint mir einen Directory-Selection-Dialog darzustellen, und so würde ich das Form dann auch benennen.
    Wie bist du auf ObjectModel.Collection(Of T) verfallen, ist List(Of T) nicht gut genug? ;)
    Ich würde auch versuchen, die DriveInfo-Klasse einzuspannen statt des bisserl eigentümlichen Environment.GetLogicalDrives.

    VB.NET-Quellcode

    1. Public Class dlgDirectorySelect
    2. Private _Directories As New List(Of String)
    3. Private _Drives As DriveInfo()
    4. Private Sub Form_Load(sender As Object, e As EventArgs) Handles MyBase.Load
    5. _Drives = DriveInfo.GetDrives.Where(Function(dri) dri.IsReady).ToArray
    6. For Each dri In _Drives
    7. For Each di In dri.RootDirectory.EnumerateDirectories
    8. If AcceptDir(di, "$R", "Boot") Then _Directories.Add(di.FullName)
    9. Next
    10. Next
    11. cbOutput.DataSource = _Directories
    12. End Sub
    13. Private Function AcceptDir(di As DirectoryInfo, ParamArray rejectPatterns() As String) As Boolean
    14. For Each pat In rejectPatterns
    15. If _Drives.Any(Function(dri) di.FullName.StartsWith(dri.RootDirectory.FullName & pat)) Then Return False
    16. Next
    17. Return True
    18. End Function
    19. Private Sub btAccept_Click(sender As Object, e As EventArgs) Handles btAccept.Click
    20. Me.DialogResult = Windows.Forms.DialogResult.OK
    21. End Sub
    22. End Class
    Also ich habe jetzt - Architektur - eine Methode AcceptDir() eingeführt, die anhand der rejectPattern entscheidet, ob ein DirectoryInfo zulässig ist. So wird 2 mal derselbe Code vermieden, und bei Bedarf könntest du gar noch weitere rejectPattern hinzufügen.
    btAccept_Click würde ich nur per DialogResult den Dialog schließen lassen - und auf das DialogResult soll dann der Aufrufer reagieren.
    Siehe auch Dialoge: Instanziierung von Forms und Aufruf von Dialogen

    Dieser Beitrag wurde bereits 1 mal editiert, zuletzt von „ErfinderDesRades“ ()

    Zu Rod:

    Die zeile soll mit dem if not überprüfen ob dieser ordner nicht existiert. wenn er nicht existiert erstelle diesen + txt datei.
    (Den benutze ich weiter oben schon öfters und da klappts)

    Zu EDR:

    weil ich eig. (auch in der schule bisher nur objektmodel.collection(of ) genutze habe ;)
    ich schaue mir deinen code an.

    PS: Danke an die Dialogresult erinnerung die habe ich wieder total vergessen ;(

    Dieser Beitrag wurde bereits 1 mal editiert, zuletzt von „Lord C“ ()

    Lord C schrieb:

    wenn er nicht existiert erstelle diesen
    Lösche bitte das Verzeichnis oder benenne es um.
    Try again.

    Lord C schrieb:

    VB.NET-Quellcode

    1. input_box.Show()
    Dies unbedingt lesen.
    Falls Du diesen Code kopierst, achte auf die C&P-Bremse.
    Jede einzelne Zeile Deines Programms, die Du nicht explizit getestet hast, ist falsch :!:
    Ein guter .NET-Snippetkonverter (der ist verfügbar).
    Programmierfragen über PN / Konversation werden ignoriert!
    So ich habe jetzt alle korrekturen vorgenommen. Und danke an EDR und Rod :thumbsup: .

    @Rod ich hab denfehler dei den IO. sachen gefunden, es haben abfragen gefehlt, das gezeigte waren ig nur die If nor anweißungen.
    @ EDR danke für das dlgDirecrtorySelect ich hab es jetzt verstand wie es geht und eingebaut.

    LG und ein großes danke
    Lord C

    PS: Es wird denke ich noch ein paar mal code hier rein kommen :D
    Hallo zusammen,

    toll das es genau den Thread gibt... Ich bin kein Programmierer und hatte noch nie mit VB.Net zu tun. Blöderweise brauche ich aber jetzt eine Programmauswertung. Ich hab ne Woche getüftelt um das angehängte Code Konstrukt zu erstellen... schon sehr lange hat aber auch riesig Spaß gemacht muss man sagen... und bitte nicht steinigen, das ist bestimmt ganz und gar nicht gut programmiert aber es funktioniert. Allerdings mit Schwächen. Zunächsteinmal kurz die Anforderung erklärt...

    * Ein Logger zeichnet Werte auf, Zeit und Impuls ggf. noch Drehzahl, Temperatur und Druck (dann muss ich aber das programm noch erweitern).
    * Loggingrate ist 1ms - 20ms
    * Die Werte werden in einem txt File abgespeichert
    * Mein Programm liest das ein, zählt die Impulse, berechnte die Zeit von einem zum anderen Impuls. damit als Basis wird weiter gerechnet...
    * Berechnete Werte werden in einem Graphen ausgegeben.

    Ich hab das mit For schleifen gemacht. Wenn die Auflösung, also die Logging Zeit erhöht wird steigt die zeilenanzahl des txt File sehr stark an. Das können ca 25000 Zeilen sein eventuell sogar noch mehr. Dann dauert die Berechnung so lange, dass der Thread abstürtzt, selbst wenn er nicht Abstürtzen würde, würde es einfach zu lange dauern... Das Selbe Problem hab ich wenn ich wie oben beschrieben mehr Variablen mit logge, da ich dann die prozedur so für jede mitgeloggte Variable durchlaufen muss und ein Weiteres Array erzeugen muss.

    Ein Txt File mit nur der zeit und Impulse sieht ungefähr so aus:
    Spoiler anzeigen
    0;0,002442
    2;0,002442
    4;0,002442
    6;0,004883
    8;0,002442
    10;0,002442
    12;0,002442
    14;0,002442
    16;0,002442
    18;0,002442
    20;0,002442
    22;0,004883
    24;0,004883
    26;0,004883
    28;0,002442
    30;0,004883
    32;0,002442
    34;0,002442
    36;0,002442
    38;2,002442
    40;0,002442
    42;0,002442
    44;0,004883
    46;0,002442
    48;0,002442
    50;0,002442
    52;0,002442
    54;0,002442
    56;0,002442
    58;0,004883
    60;0,004883
    62;0,004883
    64;0,002442
    66;2,004883
    68;0,002442
    70;0,002442
    72;0,002442
    74;0,002442
    76;0,004883
    78;0,002442
    80;0,002442
    82;0,002442
    84;0,002442
    86;0,002442
    88;0,002442
    90;0,004883
    92;0,002442
    94;0,002442
    96;2,002442


    dabei ist der erste teil die zeit hier eine Rate von 2 ms und dei zweite Zeile der Impuls in V.

    Hier ist der Code:

    Quellcode

    1. Imports System.Windows.Forms.DataVisualization.Charting
    2. Imports System.Drawing.Drawing2D
    3. Imports System.IO
    4. Imports System
    5. Imports System.Drawing
    6. Imports System.ComponentModel
    7. Imports System.Windows.Forms
    8. Imports System.Globalization
    9. Public Class form_Leistungsdiagramm
    10. Private Sub Leistungsdiagramm_Load(sender As Object, e As EventArgs) Handles MyBase.Load
    11. Dim Daten As New List(Of String)
    12. Dim Arraylength As Integer
    13. ' Arraylänge bestimmen und File einlesen
    14. Using sr As New IO.StreamReader("C:\Motor_9.txt")
    15. Do
    16. Daten.Add(sr.ReadLine())
    17. Loop Until sr.Peek < 0
    18. End Using
    19. For Each Zeile As String In Daten
    20. Arraylength = Arraylength + 1
    21. Next
    22. ' Werte Spliten, konvertieren, Impulse zählen
    23. Dim Zeit(Arraylength) As String
    24. Dim Impulse(Arraylength) As String
    25. Dim Impulse_Dbl(Arraylength) As Double
    26. Dim Zeit_Dbl(Arraylength) As Double
    27. Dim Impuls_cnt As Integer = 0
    28. Dim Impuls_cnt_old As Integer = 0
    29. Dim i As Integer = 1
    30. Dim Impuls_Zeit(Arraylength) As Double
    31. For Each Zeile In Daten
    32. Dim s As String = Zeile
    33. Dim ss() As String = s.Split(";")
    34. Zeit(0 + i) = ss(0)
    35. Impulse(0 + i) = ss(1)
    36. Impulse_Dbl(0 + i) = CDbl(Impulse(0 + i))
    37. Zeit_Dbl(0 + i) = CDbl(Zeit(0 + i))
    38. 'Hysterese
    39. If Impulse_Dbl(0 + i) > 1.8 And Impuls_cnt = Impuls_cnt_old Then
    40. Impuls_cnt = Impuls_cnt + 1
    41. Impuls_Zeit(0 + Impuls_cnt) = Zeit_Dbl(0 + i)
    42. End If
    43. If Impulse_Dbl(0 + i) < 0.5 And Impuls_cnt <> Impuls_cnt_old Then
    44. Impuls_cnt_old = Impuls_cnt_old + 1
    45. End If
    46. i = i + 1
    47. Next
    48. 'Zeit pro Impuls Umdrehungen_pro_Impuls und Drehzahl berechnen
    49. Dim n As Integer = 1
    50. Dim Umdrehungen_pro_Impuls(Impuls_cnt) As Double
    51. Dim Gesamtzeit(Arraylength) As Double
    52. Dim Anzeige(Impuls_cnt) As Integer
    53. Dim Drehzahl(Impuls_cnt) As Integer
    54. Anzeige(0) = 0
    55. For index = 1 To (Impuls_cnt - 1) Step 1
    56. Gesamtzeit(0 + n) = Impuls_Zeit(1 + n) - Impuls_Zeit(0 + n)
    57. Umdrehungen_pro_Impuls(0 + n) = 60 / ((Gesamtzeit(0 + n) / 1000))
    58. Anzeige(0 + n) = n
    59. Drehzahl(0 + n) = (n / (Impuls_Zeit(0 + n) / 1000)) * 60
    60. TextBox1.Text = TextBox1.Text & Gesamtzeit(0 + n) & vbCrLf
    61. TextBox2.Text = TextBox2.Text & Umdrehungen_pro_Impuls(0 + n) & vbCrLf
    62. TextBox5.Text = TextBox5.Text & Anzeige(0 + n) & vbCrLf
    63. TextBox6.Text = TextBox6.Text & Drehzahl(0 + n) & vbCrLf
    64. n = n + 1
    65. Next
    66. 'Drehmoment und Leistung berechnen
    67. Dim Drehmoment(Impuls_cnt) As Double
    68. Dim Leistung(Impuls_cnt) As Double
    69. Dim Massentreagheit As Double = 4.7
    70. Drehmoment(1) = 0
    71. Leistung(1) = 0
    72. Dim f As Integer = 1
    73. For index = 1 To (Impuls_cnt - 1)
    74. Drehmoment(1 + f) = Massentreagheit * 2 * System.Math.PI * 0.22027 * ((Umdrehungen_pro_Impuls(1 + f) - Umdrehungen_pro_Impuls(0 + f)) / (60 * ((Gesamtzeit(1 + f)) / 1000)))
    75. Leistung(1 + f) = (1 / (Gesamtzeit(1 + f) / 1000)) * 2 * System.Math.PI * Drehmoment(1 + f)
    76. TextBox3.Text = TextBox3.Text & Drehmoment(0 + f) & vbCrLf
    77. TextBox4.Text = TextBox4.Text & Leistung(0 + f) & vbCrLf
    78. f = f + 1
    79. Next
    80. ' Graph darstellen
    81. Dim Eigenschaften As New Graph
    82. Dim h As Integer = 1
    83. For index = 1 To (Impuls_cnt - 1)
    84. Eigenschaften.AddValue(Leistung(0 + h))
    85. Eigenschaften = Graph1
    86. h = h + 1
    87. PropertyGrid1.SelectedObject = Eigenschaften
    88. Next
    89. End Sub
    90. End Class


    Ich fereu mich sehr auf tipps, anregungen, verbesserungsvorschläge.

    Gruß Bit
    hmm - eiglich war dieser Thread gedacht für Code-Snippetse, die man sich kopieren kann, und die dann bei einem selbst schoma laufen - verbesserungsfähig halt.
    Also wenn du dein Projekt zippen und anhängen könntest, könnte man was machen - die Datei-Struktur (es ist eine CSV) ist ja nicht weiter kompliziert.
    Aber bei allem anderen kann man so nicht durchblicken - wir haben ja nicht dein Form, mit den Textboxen, PropertyGrid, buttons, und was da sonst noch alles rumfahren mag.

    wie gesagt zippen und anhängen.
    Beim zippen bitte die Executables entfernen, also die Ordner Bin und Obj.


    Achso - und der wichtigste Tipp ist immer: Visual Studio - Empfohlene Einstellungen

    Dieser Beitrag wurde bereits 1 mal editiert, zuletzt von „ErfinderDesRades“ ()

    Ah ok, hab ich falsch verstanden.

    Hier das gezippte Projekt. Incl. einer TextDatei.

    Danke für die schnelle Antwort

    edit.... auf der Hauptmenü Form Startet der Start Button die Auswertung. Im Quellcode muss noch der Pfad für das File "Motor_9" angegeben werden dann sollte es so laufen wie bei mir.
    Und... das ist noch lange nicht fertig.. weisl so konfus aussieht :)
    Dateien
    • Leistungstest.7z

      (26,22 kB, 85 mal heruntergeladen, zuletzt: )
    also ich hab mal bischen ausgemistet.
    Da ich den Sinn der Rechnungen nicht verstehe und auch nicht wirklich testete, bin ich nicht sicher, ob ich nicht Bugs eingebaut hab.

    jdfs, wie gesagt: Visual Studio - Empfohlene Einstellungen

    Und dann beachte,
    • wie ich das Einlesen auf eine Zeile reduziert hab
    • welche Variablen ich rauswerfen konnte
    • wie das Anhängen von Zeilen an Textboxen vereinfacht wurde
    • wie eine Textbox beispielhaft durch eine Listbox ausgetauscht wurde
    Ist alles nur halbe sache - in wirklichkeit solltest du eine Datenmodell-Klasse anlegen, die zusammengehörige Werte auch als zusammengehörige Datensätze vereinigt.
    Solche Datensätze lassen sich dann auch sehr schön im DatagridView anzeigen - Textboxen sind dafür wirklich nicht geeignet.
    Dateien
    Hallo,
    ich finde es echt Klasse, dass es Leute wie Dich gibt! Danke für die Mühe!
    Die Daten sitimmen noch, also glaub Du hast kein Bug eingebaut. Ich muss das alles jetzt mal genauer angucken aber da sind schon auf dem ersten Blick sehr viele schöne Verbesserungen drin!!!
    Das ganze muss ich jetzt mal verstehen...
    Die textboxen waren eher für mich zur Kontrolle gedacht diese Zahlenreihen interessieren ja eh keinen wenn das mal fertig ist, aber die List boxen sind natürlich um einiges besser...
    Interessant finde ich Deinen Ansatz mit dem Datenmodell Klasse da muss ich mich informieren, vielleicht hast Du dazu ja ein parr kleine Anstöße? Weil ich hab eben erfahren, dass ich eine Loggingrate von 34,8microsekunden erreichen muss was bei einer Versuchslänge von 30s schon 860000 Zeilen sind. da komm ich mit meinen Schleifchen wohl nicht sehr weit...

    So mal den Code checken... danke nochmal!
    Nachlangerzeit Brauch ich mal wieder eine Code-Correktur. Ich bitte auch um Feedback bzgl schreibstil, methoden/funktionen Bennenung.

    Das ganze ist eine einfache Konsolen Anwendung:

    Spoiler anzeigen

    C#-Quellcode

    1. using System;
    2. using System.Collections.Generic;
    3. using System.Linq;
    4. using System.Text;
    5. using System.Threading.Tasks;
    6. using System.Diagnostics;
    7. using System.IO;
    8. namespace OnStart
    9. {
    10. class Program
    11. {
    12. static String[] meineWerte;
    13. static String[] configData;
    14. static List<String> _stream;
    15. static void Main(string[] args)
    16. {
    17. #region File Var
    18. FileInfo _fiOpen;
    19. FileInfo _fiConfig;
    20. DirectoryInfo _di;
    21. StreamReader _srPathToOpen;
    22. StreamReader _srSaveLog;
    23. StreamWriter _swWriteLog;
    24. #endregion
    25. #region Path Var
    26. String _User;
    27. String _pathToOpenData;
    28. String _pathToLog;
    29. String _pathToConfig;
    30. #endregion
    31. #region Work Var
    32. String _ConsoleRead;
    33. Boolean firstStartFile;
    34. Boolean _onOpen;
    35. List<String> _Config;
    36. #endregion
    37. #region Main Code
    38. //Set Var
    39. _onOpen = true;
    40. _User = Environment.UserName;
    41. _pathToOpenData = @"C:\Users\" + _User + @"\Documents\OnProjekt\OnStart\openData.txt";
    42. _pathToLog = @"C:\Users\" + _User + @"\Documents\OnProjekt\OnStart\log.txt";
    43. _pathToConfig = @"C:\Users\" + _User + @"\Documents\OnProjekt\OnStart\config.txt";
    44. _fiOpen = new FileInfo(_pathToOpenData);
    45. _fiConfig = new FileInfo(_pathToConfig);
    46. _di = new DirectoryInfo(@"C:\Users\" + _User + @"\Documents\OnProjekt\OnStart\");
    47. _srPathToOpen = new StreamReader(_fiOpen.FullName);
    48. _srSaveLog = new StreamReader(_pathToLog);
    49. //Write Process
    50. if (!_di.Exists) Directory.CreateDirectory(_di.FullName);
    51. if(!_fiOpen.Exists)
    52. {
    53. Console.WriteLine("openData wird erstell in: {0}", _pathToOpenData);
    54. Console.WriteLine("");
    55. Console.WriteLine("Willst du die Werte nun eintragen?");
    56. Console.WriteLine("Y/N");
    57. _ConsoleRead = Console.ReadKey().ToString();
    58. firstStartFile = true;
    59. }
    60. else
    61. {
    62. firstStartFile = false;
    63. _ConsoleRead = "";
    64. }
    65. if (firstStartFile)writeIn(_ConsoleRead, _pathToOpenData);
    66. //Configcreate
    67. if (!_fiConfig.Exists)
    68. {
    69. Console.WriteLine("Willst du eine Confif Datei erstellen? Y/N");
    70. _ConsoleRead = Console.ReadKey().ToString();
    71. if (_CheckRightKey(_ConsoleRead))
    72. {
    73. _Config = new List<string>();
    74. Console.WriteLine("Willst du erneut gefragt werden Werte Zur Liste hinzuzufügen? Y/N");
    75. _Config.Add("Startliste:" + Console.ReadKey().ToString());
    76. Console.WriteLine("Willst du das Programm automatisch nach Durchführung beenden? Y/N");
    77. _Config.Add("AutoEnde:" + Console.ReadKey().ToString());
    78. _Config.Add("Y");
    79. arrayAdderConfig(_Config);
    80. _CreateConfigData(_pathToConfig, configData);
    81. }
    82. }
    83. //Open Process
    84. _stream = new List<string>();
    85. _streamer(_srSaveLog);
    86. _srSaveLog.Close();
    87. _swWriteLog = new StreamWriter(_pathToLog);
    88. _streamer(_swWriteLog);
    89. _swWriteLog.WriteLine("---------------------------------------------------");
    90. arrayAdderConfig(_ReadConfigData(_pathToConfig, _swWriteLog));
    91. if(!_ConfigDataString(configData).Contains("Startliste:N"))
    92. {
    93. Console.WriteLine("Willst du werte deiner Liste hinzufügen? Y/N");
    94. _ConsoleRead = Console.ReadKey().ToString();
    95. if (_CheckRightKey(_ConsoleRead)) writeIn(_ConsoleRead, _pathToOpenData);
    96. }
    97. while(_onOpen)
    98. {
    99. String _onRead;
    100. _onRead = _srPathToOpen.ReadLine();
    101. if(_onRead != "Y" && _onRead != null)
    102. {
    103. StartUp(_onRead, _swWriteLog);
    104. }
    105. else
    106. {
    107. _onOpen= false;
    108. }
    109. }
    110. _swWriteLog.Close();
    111. _srPathToOpen.Close();
    112. Console.WriteLine("Die Logdatei finden sie in folgendem Verzeichnis: {0}", _pathToLog);
    113. if (!_ConfigDataString(configData).Contains("AutoEnde:Y"))
    114. {
    115. Console.WriteLine("Zum Beenden beliebige Taste drücken...");
    116. Console.ReadKey();
    117. }
    118. #endregion
    119. }
    120. #region Methoden
    121. public static void StartUp(String Programm, StreamWriter _sw)
    122. {
    123. String _PatternSW;
    124. _PatternSW = _CreatePatternSW(Programm);
    125. try
    126. {
    127. Process.Start(Programm);
    128. Console.WriteLine("{0} wurde geöffnet.", Programm);
    129. _sw.WriteLine(_PatternSW + "wurde gestartet.");
    130. }
    131. catch(Exception e)
    132. {
    133. Console.WriteLine("{0} konnte nicht geöffnet werden. Fehler: {1}", Programm, e);
    134. _sw.WriteLine(_PatternSW + "konnte nicht geöffnet werden Fehler:{0}", e);
    135. }
    136. }
    137. public static void writeIn(String wahl,String configPath)
    138. {
    139. Boolean writeBool;
    140. switch (wahl)
    141. {
    142. case "Y":
    143. writeBool = true;
    144. break;
    145. default:
    146. writeBool = false;
    147. break;
    148. }
    149. if(writeBool)
    150. {
    151. Boolean _onWrite;
    152. String _onRead;
    153. _onWrite = true;
    154. Console.Write("Beliebige Taste drücken ...");
    155. Console.ReadKey();
    156. Console.Clear();
    157. Console.WriteLine("Beginne nun mit dem Beschreiben der TXT Datei...");
    158. Console.WriteLine("Den Schreibvorgang kann man mit einem bestätigten Y beenden");
    159. List<string> _zwischenList;
    160. _zwischenList = new List<string>();
    161. while (_onWrite)
    162. {
    163. _onRead = Console.ReadLine();
    164. if (_CheckRightKey(_onRead))
    165. {
    166. _zwischenList.Add(_onRead);
    167. Console.WriteLine("Der Wert {0} wird der Config-Datei {1} hinzugefügt.", _onRead, configPath);
    168. }
    169. else
    170. {
    171. Console.WriteLine("Der Schreibvorgang wurde Beendet");
    172. _onWrite = false;
    173. _zwischenList.Add(_onRead);
    174. File.AppendAllLines(configPath, arrayAdder(_zwischenList));
    175. Console.Write("Beliebige Taste drücken ...");
    176. Console.ReadKey();
    177. }
    178. }
    179. }
    180. }
    181. #region ArrayAdder
    182. public static string[] arrayAdder(List<string> input)
    183. {
    184. meineWerte = new string[input.Count];
    185. for (int i = 0; i < input.Count; i++)
    186. {
    187. meineWerte[i] = (string)input[i];
    188. }
    189. return meineWerte;
    190. }
    191. public static string[] arrayAdderConfig(List<string> input)
    192. {
    193. configData = new string[input.Count];
    194. for (int i = 0; i < input.Count; i++)
    195. {
    196. configData[i] = (string)input[i];
    197. }
    198. return configData;
    199. }
    200. #endregion
    201. #region _CreatePatternSW
    202. public static string _CreatePatternSW(String programm)
    203. {
    204. StringBuilder builder = new StringBuilder();
    205. builder.Append(DateTime.Today.Day);
    206. builder.Append(".");
    207. builder.Append(DateTime.Today.Month);
    208. builder.Append(".");
    209. builder.Append(DateTime.Today.Year);
    210. builder.Append(" ");
    211. builder.Append(programm);
    212. builder.Append(", ");
    213. return builder.ToString();
    214. }
    215. public static string _CreatePatternSW()
    216. {
    217. StringBuilder builder = new StringBuilder();
    218. builder.Append(DateTime.Today.Day);
    219. builder.Append(".");
    220. builder.Append(DateTime.Today.Month);
    221. builder.Append(".");
    222. builder.Append(DateTime.Today.Year);
    223. builder.Append(" ");
    224. return builder.ToString();
    225. }
    226. #endregion
    227. public static void _CreateConfigData(String path, String[] configs)
    228. {
    229. StreamWriter _sw;
    230. _sw = new StreamWriter(path);
    231. if (configs != null)
    232. {
    233. foreach (String s in configs)
    234. {
    235. _sw.WriteLine(s);
    236. }
    237. }
    238. _sw.Close();
    239. }
    240. public static List<String> _ReadConfigData(String path, StreamWriter _sw)
    241. {
    242. List<String> _ConfigData;
    243. StreamReader _sr;
    244. Boolean _onRead;
    245. String _PatternSW;
    246. String _zwSR;
    247. _PatternSW = _CreatePatternSW();
    248. _onRead = true;
    249. _sr = new StreamReader(path);
    250. _ConfigData = new List<string>();
    251. while (_onRead)
    252. {
    253. _zwSR = _sr.ReadLine();
    254. if (_zwSR != "Y")
    255. {
    256. try
    257. {
    258. _ConfigData.Add(_zwSR);
    259. _sw.WriteLine(_PatternSW + "Configeinstellung {0} wurde geladen.", _zwSR);
    260. }
    261. catch ( Exception e)
    262. {
    263. _sw.WriteLine(_PatternSW + "Configeinstellung {0} konnte nicht geladen werden Fehler: {1}", _zwSR, e);
    264. }
    265. }
    266. else
    267. {
    268. _onRead = false;
    269. }
    270. }
    271. _sr.Close();
    272. return _ConfigData;
    273. }
    274. public static String _ConfigDataString(String[] Zugwert)
    275. {
    276. String ausgabe;
    277. ausgabe = "";
    278. foreach(String s in Zugwert)
    279. {
    280. ausgabe = ausgabe + s + ",";
    281. }
    282. return ausgabe;
    283. }
    284. #region Streamer
    285. public static void _streamer(StreamReader sr)
    286. {
    287. Boolean onRead;
    288. onRead = true;
    289. while(onRead)
    290. {
    291. if (sr.ReadLine() != null)
    292. {
    293. _stream.Add(sr.ReadLine());
    294. }
    295. else
    296. {
    297. onRead = false;
    298. }
    299. }
    300. }
    301. public static void _streamer(StreamWriter sw)
    302. {
    303. for(int i=0; i < _stream.Count(); i++)
    304. {
    305. sw.WriteLine(_stream[i]);
    306. }
    307. }
    308. #endregion
    309. public static Boolean _CheckRightKey(String _inputKey)
    310. {
    311. Boolean checkKey;
    312. checkKey = false;
    313. while (!checkKey)
    314. {
    315. if (_inputKey == "Y")
    316. {
    317. checkKey = true;
    318. return checkKey;
    319. }
    320. else if(_inputKey=="N")
    321. {
    322. return checkKey;
    323. }
    324. else
    325. {
    326. Console.WriteLine("Bitte Y/N eingeben!");
    327. }
    328. }
    329. return false;
    330. }
    331. #endregion
    332. }
    333. }



    LG
    LC

    Dieser Beitrag wurde bereits 1 mal editiert, zuletzt von „Lord C“ ()

    @Lord C Die Gruppierung Deiner Regionen ist "ungleichmäßig".

    Class-Member sollten einheitlich benannt werden: mit oder ohne führenden Unterstrich, wenn ohne Unterstrich, dann 1. Buchstabe groß,
    Methodennamen sollten keinen führenden Unterstrich haben,
    Parameter sollten keinen führenden Unterstrich haben,
    lokale Variablen sollten keinen führenden Unterstrich haben,

    C#-Quellcode

    1. _onRead = Console.ReadLine();
    2. if (_CheckRightKey(_onRead))
    3. {}
    _CheckRightKey() passt logisch nicht zu Console.ReadLine() (Console.WriteLine("Bitte Y/N eingeben!");)
    Die Deklaration und die Initialisierung einer (lokalen) Variable pack in eine einzige Zeile:

    C#-Quellcode

    1. String ausgabe;
    2. ausgabe = "";
    ==> String ausgabe = "";
    _sr = new StreamReader(path); / _sr.Close(); ==> Mach da ein using draus, desgleichen StreamWriter.
    DateTime.Today lässt sich insgesamt formatieren, da brauchst Du keinen StringBuilder, da genügt ein string.Format().
    xxx[i] = (string)input[i]; ==> input[i] ist ein String, das muss nicht gecastet werden.
    Den Pfad zu des Users Dokumenten bekommst Du mit Environment.GetFolderPath(Environment.SpecialFolder.MyDocuments).
    (von unten nach oben ;) )
    Falls Du diesen Code kopierst, achte auf die C&P-Bremse.
    Jede einzelne Zeile Deines Programms, die Du nicht explizit getestet hast, ist falsch :!:
    Ein guter .NET-Snippetkonverter (der ist verfügbar).
    Programmierfragen über PN / Konversation werden ignoriert!
    Also um ehrlich zu sein ist das einzig allein kompletter Clusterfuck. Klingt hart, ist aber so.
    • Mal benutzt du ein "_", mal schreibst du die variablen groß, mal schreibst du sie klein, etc. Versuch konsistent zu bleiben und mach es auf eine Weise statt auf viele verschiedene.
    • Für das Verbinden von Pfaden solltest du Path.Combine benutzen.
    • Statt deinem CreatePatternSW kannst du auch einfach folgendes machen: String.Format("{0:dd.MM.yyyy} {1}, ", DateTime.Now, programm);
    • Keine Objektorientierung
    • Und vieles, vieles, vieles, vieles mehr...
    350 Zeilen sind zum Korrigieren recht viel, vor allem wenn du dabei auch noch Tipps zum Verbessern haben willst. Am besten suchst du mal nach jemandem der sich mit dir hinsetzt und alles noch mal durchgeht. Für einen Post im Thread ist das dann doch etwas zu viel. Es sei denn hier hat jemand zu viel Zeit.
    1. Bau eine Klassenstruktur auf
    2. inputKey etc. ist immer ein Char:
    Wenn ReadKey -> Read == -1, dann ist was beim Read fehlgeschlagen, andernfalls kannst du den int in einen char casten.
    3. Verwende nicht .Count() wenn es .Count oder .Length gibt, da es eine LinQ funktion ist, die je nach Implementierung über alle Elemente iteriert um die Anzahl festzustellen
    4. 295-297 ist in einer Zeile schöner
    5. public Funktionen mit einem vorangestellten Underscore - warum?
    6. Ich mag die primitiven Datentypen besser, wenn es welche gibt -> bool statt Boolean, string statt String etc.
    7.Du hast generell alles public, obwohl alles in dieser einen Klasse passiert
    Ich wollte auch mal ne total überflüssige Signatur:
    ---Leer---
    @Lord C So was sollte nicht passieren, daq kann abgefragt (nicht abgefangen) werden:
    Falls Du diesen Code kopierst, achte auf die C&P-Bremse.
    Jede einzelne Zeile Deines Programms, die Du nicht explizit getestet hast, ist falsch :!:
    Ein guter .NET-Snippetkonverter (der ist verfügbar).
    Programmierfragen über PN / Konversation werden ignoriert!
    So hat zwar ein bisschen gedauert da ich noch andere geschäftliche wichtigere Projekte hatte aber hier ist die Verbesserung.

    Spoiler anzeigen

    Quellcode

    1. using System;
    2. using System.Collections.Generic;
    3. using System.Linq;
    4. using System.Text;
    5. using System.Threading.Tasks;
    6. using System.Diagnostics;
    7. using System.IO;
    8. namespace OnStart
    9. {
    10. class Program
    11. {
    12. static String[] meineWerte;
    13. static String[] configData;
    14. static List<String> streamSaver;
    15. static void Main(string[] args)
    16. {
    17. #region Path Var
    18. String myDocumentsPath = Environment.GetFolderPath(Environment.SpecialFolder.MyDocuments);
    19. String pathToOnStartFolder = @"\OnProjekt\OnStart\";
    20. String pathToOpenData = "openData.txt";
    21. String pathToLog = "log.txt";
    22. String pathToConfig = "config.txt";
    23. #endregion
    24. #region File Var
    25. DirectoryInfo diStartDirectory = new DirectoryInfo(myDocumentsPath + pathToOnStartFolder);
    26. FileInfo fiPathToOpenData = new FileInfo(Path.Combine(diStartDirectory.FullName, pathToOpenData));
    27. FileInfo fiPathToConfig = new FileInfo(Path.Combine(diStartDirectory.FullName, pathToConfig));
    28. FileInfo fiPathToLog = new FileInfo(Path.Combine(diStartDirectory.FullName, pathToLog));
    29. StreamReader srPathToOpen = new StreamReader();
    30. #endregion
    31. #region Work Var
    32. String ConsoleRead = "";
    33. Boolean firstStartFile = false;
    34. Boolean onOpen = true;
    35. Boolean streamReaderPathToOpenWorks = true;
    36. List<String> Config = new List<string>();
    37. #endregion
    38. #region Main Code
    39. //Write Process
    40. if (!diStartDirectory.Exists) Directory.CreateDirectory(diStartDirectory.FullName);
    41. if (!fiPathToOpenData.Exists)
    42. {
    43. Console.WriteLine("openData wird erstell in: {0}", pathToOpenData);
    44. Console.WriteLine("");
    45. Console.WriteLine("Willst du die Werte nun eintragen?");
    46. Console.WriteLine("Y/N");
    47. ConsoleRead = Console.ReadKey().Key.ToString();
    48. if (CheckRightKey(ConsoleRead))
    49. ConsoleRead = "Y";
    50. firstStartFile = true;
    51. }
    52. else
    53. {
    54. ConsoleRead = "";
    55. }
    56. if (firstStartFile)
    57. {
    58. WriteIn(ConsoleRead, fiPathToOpenData.FullName,fiPathToLog.FullName);
    59. }
    60. try
    61. {
    62. srPathToOpen = new StreamReader(fiPathToOpenData.FullName);
    63. }
    64. catch(Exception)
    65. {
    66. streamReaderPathToOpenWorks = false;
    67. }
    68. //Configcreate
    69. if (!fiPathToConfig.Exists)
    70. {
    71. Console.WriteLine();
    72. Console.WriteLine("Willst du eine Config Datei erstellen? Y/N");
    73. ConsoleRead = Console.ReadKey().Key.ToString();
    74. if (CheckRightKey(ConsoleRead))
    75. {
    76. Console.WriteLine("Willst du erneut gefragt werden Werte Zur Liste hinzuzufügen? Y/N");
    77. Config.Add("Startliste:" + Console.ReadKey().Key.ToString());
    78. Console.WriteLine("Willst du das Programm automatisch nach Durchführung beenden? Y/N");
    79. Config.Add("AutoEnde:" + Console.ReadKey().Key.ToString());
    80. Config.Add("Y");
    81. arrayAdderConfig(Config);
    82. CreateConfigData(fiPathToConfig.FullName, configData);
    83. }
    84. }
    85. //Open Process
    86. streamSaver = new List<string>();
    87. StreamWriter swWriteLog = new StreamWriter(fiPathToLog.FullName);
    88. using (swWriteLog)
    89. {
    90. if(fiPathToLog.Exists && !firstStartFile)
    91. {
    92. StreamReader srSaveLog = new StreamReader(fiPathToLog.FullName);
    93. using (srSaveLog)
    94. {
    95. streamer(srSaveLog);
    96. }
    97. streamer(swWriteLog);
    98. swWriteLog.WriteLine("---------------------------------------------------");
    99. }
    100. arrayAdderConfig(ReadConfigData(pathToConfig, swWriteLog));
    101. if (streamReaderPathToOpenWorks)
    102. {
    103. if (fiPathToConfig.Exists)
    104. {
    105. if (!ConfigDataString(configData).Contains("Startliste:N"))
    106. {
    107. Console.WriteLine("Willst du werte deiner Liste hinzufügen? Y/N");
    108. ConsoleRead = Console.ReadKey().Key.ToString();
    109. if (CheckRightKey(ConsoleRead)) WriteIn(ConsoleRead, fiPathToOpenData.FullName, fiPathToLog.FullName);
    110. }
    111. using (srPathToOpen)
    112. {
    113. while (onOpen)
    114. {
    115. String onRead;
    116. onRead = srPathToOpen.ReadLine();
    117. if (onRead.Contains("Y") && onRead != null)
    118. {
    119. StartUp(onRead, swWriteLog);
    120. }
    121. else
    122. {
    123. onOpen = false;
    124. }
    125. }
    126. }
    127. Console.WriteLine("Die Logdatei finden sie in folgendem Verzeichnis: {0}", fiPathToLog.FullName);
    128. if (!ConfigDataString(configData).Contains("AutoEnde:Y"))
    129. {
    130. Console.WriteLine("Zum Beenden beliebige Taste drücken...");
    131. Console.ReadKey();
    132. }
    133. }
    134. else
    135. {
    136. Console.WriteLine("Willst du werte deiner Liste hinzufügen? Y/N");
    137. ConsoleRead = Console.ReadKey().Key.ToString();
    138. if (CheckRightKey(ConsoleRead)) WriteIn(ConsoleRead, fiPathToOpenData.FullName, fiPathToLog.FullName);
    139. using (srPathToOpen)
    140. {
    141. while (onOpen)
    142. {
    143. String onRead;
    144. onRead = srPathToOpen.ReadLine();
    145. if (onRead.Contains("Y") && onRead != null)
    146. {
    147. StartUp(onRead, swWriteLog);
    148. }
    149. else
    150. {
    151. onOpen = false;
    152. }
    153. }
    154. }
    155. Console.WriteLine("Die Logdatei finden sie in folgendem Verzeichnis: {0}", fiPathToLog.FullName);
    156. Console.WriteLine("Zum Beenden beliebige Taste drücken...");
    157. Console.ReadKey();
    158. }
    159. }
    160. else
    161. {
    162. Console.Clear();
    163. Console.WriteLine("Bitte die Werte in die TXT Datei {0} eintragen. Und die Anwendung neustarten", fiPathToOpenData.FullName);
    164. Console.WriteLine("Beliebige Taste drücken...");
    165. Console.ReadKey();
    166. Process.Start(fiPathToOpenData.FullName);
    167. swWriteLog.WriteLine("TXT Datei nicht befüllt");
    168. }
    169. }
    170. }
    171. #endregion
    172. #region Methoden
    173. public static void StartUp(String Programm, StreamWriter sw)
    174. {
    175. String patternSW = CreatePatternSW(Programm);
    176. try
    177. {
    178. Process.Start(Programm);
    179. Console.WriteLine("{0} wurde geöffnet.", Programm);
    180. sw.WriteLine(patternSW + "wurde gestartet.");
    181. }
    182. catch(Exception e)
    183. {
    184. Console.WriteLine("{0} konnte nicht geöffnet werden. Fehler: {1}", Programm, e);
    185. sw.WriteLine(patternSW + "konnte nicht geöffnet werden Fehler:{0}", e);
    186. }
    187. }
    188. public static void WriteIn(String wahl,String configPath,String LogPath)
    189. {
    190. Boolean writeBool = false;
    191. switch (wahl)
    192. {
    193. case "Y":
    194. writeBool = true;
    195. break;
    196. default:
    197. writeBool = false;
    198. break;
    199. }
    200. if(writeBool)
    201. {
    202. Boolean onWrite=true;
    203. String onRead = "";
    204. Console.WriteLine();
    205. Console.Write("Beliebige Taste drücken ...");
    206. Console.ReadKey();
    207. Console.Clear();
    208. Console.WriteLine("Beginne nun mit dem Beschreiben der TXT Datei...");
    209. Console.WriteLine("Den Schreibvorgang kann man mit einem bestätigten Y beenden");
    210. List<string> _zwischenList = new List<string>();
    211. using (StreamWriter swLogPath = new StreamWriter(LogPath))
    212. {
    213. while (onWrite)
    214. {
    215. onRead = Console.ReadLine();
    216. if (onRead == "Y" || onRead == "y")
    217. {
    218. Console.WriteLine("Der Schreibvorgang wurde Beendet");
    219. onWrite = false;
    220. _zwischenList.Add(onRead);
    221. File.AppendAllLines(configPath, ArrayAdder(_zwischenList));
    222. Console.Write("Beliebige Taste drücken ...");
    223. Console.ReadKey();
    224. }
    225. else
    226. {
    227. _zwischenList.Add(onRead);
    228. Console.WriteLine("Der Wert {0} wird der Config-Datei {1} hinzugefügt.", onRead, configPath);
    229. swLogPath.WriteLine(onRead + " Wurde Hinzugefügt");
    230. }
    231. }
    232. }
    233. }
    234. }
    235. #region ArrayAdder
    236. public static string[] ArrayAdder(List<string> input)
    237. {
    238. meineWerte = new string[input.Count];
    239. for (int i = 0; i < input.Count; i++)
    240. {
    241. meineWerte[i] = (string)input[i];
    242. }
    243. return meineWerte;
    244. }
    245. public static string[] arrayAdderConfig(List<string> input)
    246. {
    247. configData = new string[input.Count];
    248. for (int i = 0; i < input.Count; i++)
    249. {
    250. configData[i] = (string)input[i];
    251. }
    252. return configData;
    253. }
    254. #endregion
    255. #region _CreatePatternSW
    256. public static string CreatePatternSW(String programm)
    257. {
    258. StringBuilder builder = new StringBuilder();
    259. builder.Append(DateTime.Today.Day);
    260. builder.Append(".");
    261. builder.Append(DateTime.Today.Month);
    262. builder.Append(".");
    263. builder.Append(DateTime.Today.Year);
    264. builder.Append(" ");
    265. builder.Append(programm);
    266. builder.Append(", ");
    267. return builder.ToString();
    268. }
    269. public static string CreatePatternSW()
    270. {
    271. StringBuilder builder = new StringBuilder();
    272. builder.Append(DateTime.Today.Day);
    273. builder.Append(".");
    274. builder.Append(DateTime.Today.Month);
    275. builder.Append(".");
    276. builder.Append(DateTime.Today.Year);
    277. builder.Append(" ");
    278. return builder.ToString();
    279. }
    280. #endregion
    281. public static void CreateConfigData(String path, String[] configs)
    282. {
    283. StreamWriter sw = new StreamWriter(path);
    284. using (sw)
    285. {
    286. if (configs != null)
    287. {
    288. foreach (String s in configs)
    289. {
    290. sw.WriteLine(s);
    291. }
    292. }
    293. }
    294. }
    295. public static List<String> ReadConfigData(String path, StreamWriter sw)
    296. {
    297. List<String> configData = new List<string>();
    298. StreamReader sr = new StreamReader(path);
    299. Boolean onRead = true;
    300. String patternSW = CreatePatternSW();
    301. String _zwSR="";
    302. while (onRead)
    303. {
    304. _zwSR = sr.ReadLine();
    305. if (_zwSR != "Y")
    306. {
    307. try
    308. {
    309. configData.Add(_zwSR);
    310. sw.WriteLine(patternSW + "Configeinstellung {0} wurde geladen.", _zwSR);
    311. }
    312. catch ( Exception e)
    313. {
    314. sw.WriteLine(patternSW + "Configeinstellung {0} konnte nicht geladen werden Fehler: {1}", _zwSR, e);
    315. }
    316. }
    317. else
    318. {
    319. onRead = false;
    320. }
    321. }
    322. sr.Close();
    323. return configData;
    324. }
    325. public static String ConfigDataString(String[] Zugwert)
    326. {
    327. String ausgabe="";
    328. foreach(String s in Zugwert)
    329. {
    330. ausgabe = ausgabe + s + ",";
    331. }
    332. return ausgabe;
    333. }
    334. #region Streamer
    335. public static void streamer(StreamReader sr)
    336. {
    337. Boolean onRead = true;
    338. while(onRead)
    339. {
    340. if (sr.ReadLine() != null)
    341. {
    342. streamSaver.Add(sr.ReadLine());
    343. }
    344. else
    345. {
    346. onRead = false;
    347. }
    348. }
    349. }
    350. public static void streamer(StreamWriter sw)
    351. {
    352. for(int i=0; i < streamSaver.Count(); i++)
    353. {
    354. sw.WriteLine(streamSaver[i]);
    355. }
    356. }
    357. #endregion
    358. public static Boolean CheckRightKey(String inputKey)
    359. {
    360. Boolean checkKey = false;
    361. while (!checkKey)
    362. {
    363. if (inputKey == "Y")
    364. {
    365. checkKey = true;
    366. return checkKey;
    367. }
    368. else if(inputKey=="N")
    369. {
    370. return checkKey;
    371. }
    372. else
    373. {
    374. Console.WriteLine();
    375. Console.WriteLine("Bitte Y/N eingeben!");
    376. inputKey = Console.ReadKey().Key.ToString();
    377. }
    378. }
    379. return false;
    380. }
    381. #endregion
    382. }
    383. }



    und wie oben noch einmal durchschauen und bewerteen bitte :)

    LG
    LC

    Dieser Beitrag wurde bereits 2 mal editiert, zuletzt von „Lord C“ ()

    so langen Code kann man nicht "durchsehen und bewerten".
    Den muss man bei sich einkopieren, und Testläufe damit machen.
    Und man muss wissen, was der machen soll.
    Kannst du ein lauffähiges Sample zippen und anhängen?

    scheinbar stehst du mitte Forum-Buttons noch bisserl auf Kriegsfuss, vlt. hilft da