Consolen Outpot gleichzeitig in .txt speichern

  • C#
  • .NET (FX) 4.5–4.8

Es gibt 19 Antworten in diesem Thema. Der letzte Beitrag () ist von Plexian.

    Consolen Outpot gleichzeitig in .txt speichern

    Hallo,

    Ich wollte fragen wie ich den Consolen Output gleichzeitig in eine Textdatei speichern kann, aber so, dass ich den Consolen Output noch sehe!
    Habe bis das dato immer gelöst mit Console.SetOut und dann in nen Filestream rein, aber dann sieht man ja den Output nich mehr.

    Frage also: Geht das überhaupt? Wenn ja.. wie ?

    MfG,
    Logan.

    Im folgenden Thread auf Stackoverflow werden für das Problem einige erfolgsversprechende Lösungen vorgestellt:

    stackoverflow.com/questions/42…-console-output-to-a-file

    Für VB.Net dann den Converter benutzen: codeconverter.sharpdevelop.net/SnippetConverter.aspx

    Bzw. Fragen falls der Converter nicht alles richtig übersetzt.

    Edit: Folgender Code funktioniert bei mir (eigenes Programm) - wenn ich aber richtig gelesen habe, werden damit keine Consolen-Eingaben in das Log gespeichert.

    VB.NET-Quellcode

    1. Private Sub MirroringOutput()
    2. Trace.Listeners.Clear()
    4. Dim twtl = New TextWriterTraceListener(AppDomain.CurrentDomain.BaseDirectory & "log.txt")
    5. twtl.Name = "TextLogger"
    6. twtl.TraceOutputOptions = TraceOptions.ThreadId Or TraceOptions.DateTime
    8. Dim ctl = New ConsoleTraceListener(False)
    9. ctl.TraceOutputOptions = TraceOptions.DateTime
    11. Trace.Listeners.Add(twtl)
    12. Trace.Listeners.Add(ctl)
    13. Trace.AutoFlush = True
    15. Trace.WriteLine("The first line to be in the logfile and on the console.")
    16. End Sub

    Oder im folgenden kann man weiterhin "Console.WriteLine" benutzen und auch die Konsolen-Eingabe in Log speichern - durch erneute Ausgabe der eingelesen Daten von der Konsole.

    Spoiler anzeigen

    VB.NET-Quellcode

    1. Imports System.Text
    2. Imports System.IO
    4. Module Module1
    6. Sub Main()
    8. Using cc = New ConsoleCopy(AppDomain.CurrentDomain.BaseDirectory & "mylogfile.txt")
    9. Console.WriteLine("testing 1-2-3")
    10. Console.WriteLine("testing 4-5-6")
    11. Dim ReadStr As String = Console.ReadLine()
    12. Console.WriteLine(ReadStr)
    13. End Using
    15. End Sub
    17. End Module
    19. Public Class ConsoleCopy
    20. Implements IDisposable
    22. Private fileStream As FileStream
    23. Private fileWriter As StreamWriter
    24. Private doubleWriter As TextWriter
    25. Private oldOut As TextWriter
    27. Private Class DoubleWrite
    28. Inherits TextWriter
    30. Private one As TextWriter
    31. Private two As TextWriter
    33. Public Sub New(one As TextWriter, two As TextWriter)
    34. Me.one = one
    35. Me.two = two
    36. End Sub
    38. Public Overrides ReadOnly Property Encoding() As Encoding
    39. Get
    40. Return one.Encoding
    41. End Get
    42. End Property
    44. Public Overrides Sub Flush()
    45. one.Flush()
    46. two.Flush()
    47. End Sub
    49. Public Overrides Sub Write(value As Char)
    50. one.Write(value)
    51. two.Write(value)
    52. End Sub
    54. End Class
    56. Public Sub New(path As String)
    57. oldOut = Console.Out
    59. Try
    60. fileStream = File.Open(path, FileMode.Append, FileAccess.Write, FileShare.Read)
    62. fileWriter = New StreamWriter(fileStream)
    63. fileWriter.AutoFlush = True
    65. doubleWriter = New DoubleWrite(fileWriter, oldOut)
    66. Catch e As Exception
    67. Console.WriteLine("Cannot open file for writing")
    68. Console.WriteLine(e.Message)
    69. Return
    70. End Try
    71. Console.SetOut(doubleWriter)
    72. End Sub
    74. Public Overloads Sub Dispose() Implements IDisposable.Dispose
    75. Console.SetOut(oldOut)
    76. If fileWriter IsNot Nothing Then
    77. fileWriter.Flush()
    78. fileWriter.Close()
    79. fileWriter = Nothing
    80. End If
    81. If fileStream IsNot Nothing Then
    82. fileStream.Close()
    83. fileStream = Nothing
    84. End If
    85. End Sub
    87. End Class

    Dieser Beitrag wurde bereits 8 mal editiert, zuletzt von „Thias“ ()

    Hi
    besonders elegant fände ich folgende Lösung:
    Spoiler anzeigen

    VB.NET-Quellcode

    1. Imports System.IO
    2. Imports System.Text
    4. Public Class WriteToManyTextWriter
    5. Inherits TextWriter
    7. Private ReadOnly _writers As IEnumerable(Of TextWriter)
    9. Public Sub New(ParamArray writerArray As TextWriter())
    10. Me.New(writers:=writerArray)
    11. End Sub
    13. Public Sub New(writers As IEnumerable(Of TextWriter))
    14. If writers Is Nothing Then Throw New ArgumentNullException(NameOf(writers))
    15. _writers = writers
    16. End Sub
    18. Public Overrides ReadOnly Property Encoding As Encoding
    19. Get
    20. Return Encoding.Default
    21. End Get
    22. End Property
    24. Public Overrides Sub Write(buffer() As Char, index As Integer, count As Integer)
    25. For Each w As TextWriter In _writers
    26. If w IsNot Nothing Then w.Write(buffer, index, count)
    27. Next
    28. End Sub
    30. Public Overrides Sub Flush()
    31. MyBase.Flush()
    32. For Each w As TextWriter In _writers
    33. If w IsNot Nothing Then w.Flush()
    34. Next
    35. End Sub
    36. End Class


    Du erzeugst einfach eine Instanz obigen TextWriters mit den Ausgabetextwritern (StreamWriter zum Filestream und Console.Out) als Parameter, in die geschrieben werden soll und setzt diesen als neuen Konsolen-Output.

    Viele Grüße
    ~blaze~

    Fortender schrieb:

    Geht es um den Console-Output deines eigenen oder eines externen Programms?

    Für ein externes Programm (gestartet über Process.Start) - wie z.B. cmd.exe - habe ich mir aus meinem editierten Post 5 und aus folgenden Post's mal schnell ein Konsolenprogramm zusammengebastelt - da mag dann einiges (strukturell) zu verbessern sein, aber als primitives Beispiel sollte es taugen.

    Problem bei Kommandozeile Auslesen
    stackoverflow.com/questions/16…nd-with-visual-basic-code

    Spoiler anzeigen

    VB.NET-Quellcode

    1. Imports System.Text
    2. Imports System.IO
    4. Module Module1
    6. Public cc As ConsoleCopy = New ConsoleCopy(AppDomain.CurrentDomain.BaseDirectory & "mylogfile.txt")
    8. Sub Main()
    10. Run_Process("CMD.exe", "/C Dir /B", True)
    11. Run_Process("CMD.exe", "/C Dir2 /B", True)
    12. Run_Process("CMD.exe", "/C @Echo OFF & For /L %X in (0,1,10) Do (Echo %X)", True, False)
    14. MsgBox("Stop")
    17. End Sub
    19. Private Function Run_Process(ByVal Process_Name As String, Optional Process_Arguments As String = Nothing, Optional Read_Output As Boolean = False, Optional Process_Hide As Boolean = False, Optional Process_TimeOut As Integer = -1) As String
    21. ' Returns True if "Read_Output" argument is False and Process was finished OK
    22. ' Returns False if ExitCode is not "0"
    23. ' Returns Nothing if process can't be found or can't be started
    24. ' Returns "ErrorOutput" or "StandardOutput" (In that priority) if Read_Output argument is set to True.
    26. Dim My_Process As New Process()
    28. Try
    30. If Read_Output Then
    31. AddHandler My_Process.ErrorDataReceived, AddressOf ProcessOutputDataReceived
    32. AddHandler My_Process.OutputDataReceived, AddressOf ProcessOutputDataReceived
    33. End If
    35. Dim My_Process_Info As New ProcessStartInfo()
    36. My_Process_Info.FileName = Process_Name ' Process filename
    37. My_Process_Info.Arguments = Process_Arguments ' Process arguments
    38. My_Process_Info.CreateNoWindow = Process_Hide ' Show or hide the process Window
    39. My_Process_Info.UseShellExecute = False ' Don't use system shell to execute the process
    40. My_Process_Info.RedirectStandardOutput = Read_Output ' Redirect (1) Output
    41. My_Process_Info.RedirectStandardError = Read_Output ' Redirect non (1) Output
    42. My_Process.EnableRaisingEvents = True ' Raise events
    43. My_Process.StartInfo = My_Process_Info
    44. My_Process.Start() ' Run the process NOW
    46. If Read_Output Then
    47. My_Process.BeginErrorReadLine()
    48. My_Process.BeginOutputReadLine()
    49. End If
    51. My_Process.WaitForExit(Process_TimeOut)
    52. Threading.Thread.Sleep(1000)
    54. Catch ex As Exception
    55. MsgBox(ex.Message)
    56. Return Nothing ' Returns nothing if the process can't be found or started.
    57. Finally
    58. If Read_Output Then
    59. RemoveHandler My_Process.ErrorDataReceived, AddressOf ProcessOutputDataReceived
    60. RemoveHandler My_Process.OutputDataReceived, AddressOf ProcessOutputDataReceived
    61. End If
    62. End Try
    64. Return CStr(True) ' Returns True if Read_Output argument is set to False and the process finished without errors.
    66. End Function
    68. Private Sub ProcessOutputDataReceived(sender As Object, e As DataReceivedEventArgs)
    69. If Not String.IsNullOrEmpty(e.Data) Then
    70. Console.WriteLine(e.Data)
    71. End If
    72. End Sub
    74. End Module
    76. Public Class ConsoleCopy
    77. Implements IDisposable
    79. Private fileStream As FileStream
    80. Private fileWriter As StreamWriter
    81. Private doubleWriter As TextWriter
    82. Private oldOut As TextWriter
    84. Private Class DoubleWrite
    85. Inherits TextWriter
    87. Private one As TextWriter
    88. Private two As TextWriter
    90. Public Sub New(one As TextWriter, two As TextWriter)
    91. Me.one = one
    92. Me.two = two
    93. End Sub
    95. Public Overrides ReadOnly Property Encoding() As Encoding
    96. Get
    97. Return one.Encoding
    98. End Get
    99. End Property
    101. Public Overrides Sub Flush()
    102. one.Flush()
    103. two.Flush()
    104. End Sub
    106. Public Overrides Sub Write(value As Char)
    107. one.Write(value)
    108. two.Write(value)
    109. End Sub
    111. End Class
    113. Public Sub New(path As String)
    114. oldOut = Console.Out
    116. Try
    117. fileStream = File.Open(path, FileMode.Append, FileAccess.Write, FileShare.Read)
    119. fileWriter = New StreamWriter(fileStream)
    120. fileWriter.AutoFlush = True
    122. doubleWriter = New DoubleWrite(fileWriter, oldOut)
    123. Catch e As Exception
    124. Console.WriteLine("Cannot open file for writing")
    125. Console.WriteLine(e.Message)
    126. Return
    127. End Try
    128. Console.SetOut(doubleWriter)
    129. End Sub
    131. Public Overloads Sub Dispose() Implements IDisposable.Dispose
    132. Console.SetOut(oldOut)
    133. If fileWriter IsNot Nothing Then
    134. fileWriter.Flush()
    135. fileWriter.Close()
    136. fileWriter = Nothing
    137. End If
    138. If fileStream IsNot Nothing Then
    139. fileStream.Close()
    140. fileStream = Nothing
    141. End If
    142. End Sub
    144. End Class


    Edit: "My_Process.BeginErrorReadLine()" ergänzt!

    Dieser Beitrag wurde bereits 9 mal editiert, zuletzt von „Thias“ ()

    Habe noch ein wenig gebastelt - auch wenn sich von der Struktur her immer noch vieles verbessern ließe - aber dazu wäre ein realer Anwendungsfall hilfreicher.

    Jedenfalls habe ich noch das Process Excited Event reingebaut.

    Da gibt es dann nur ein Problem, obwohl dieses Exit-Event gefeuert wird, liest OutputDataReceived immer noch Daten ein - bei mir noch bis zu einer Sekunde nach dem Exit-Event - je nach DOS-Befehl.

    Deswegen setzt die Sub ProcessOutputDataReceived dann DataReceived = True

    Und erst wenn in der Sub My_Process_Exited für mindestens 100ms DataReceived = False ist, erst dann wird WaitExitEvent.Set() gesetzt.

    Worauf hin dann in der Sub Run_Process es bei WaitExitEvent.WaitOne weitergeht.

    Spoiler anzeigen

    VB.NET-Quellcode

    1. Imports System.Text
    2. Imports System.IO
    3. Imports System.Threading
    5. Module Module1
    7. Public cc As ConsoleCopy = New ConsoleCopy(AppDomain.CurrentDomain.BaseDirectory & "mylogfile.txt")
    8. Public WaitExitEvent As New ManualResetEvent(False)
    9. Public DataReceived As Boolean = False
    11. Sub Main()
    13. Run_Process("CMD.exe", "/C DIR C:\Windows\Microsoft.NET /S", True)
    14. Run_Process("CMD.exe", "/C Dir /B", True)
    15. Run_Process("CMD.exe", "/C Dir2 /B", True)
    16. Run_Process("CMD.exe", "/C @Echo OFF & For /L %X in (0,1,10) Do (Echo %X)", True, False)
    18. MsgBox("Stop")
    20. End Sub
    22. Private Function Run_Process(ByVal Process_Name As String, Optional Process_Arguments As String = Nothing, Optional Read_Output As Boolean = False, Optional Process_Hide As Boolean = False, Optional Process_TimeOut As Integer = -1) As String
    24. ' Returns True if "Read_Output" argument is False and Process was finished OK
    25. ' Returns False if ExitCode is not "0"
    26. ' Returns Nothing if process can't be found or can't be started
    27. ' Returns "ErrorOutput" or "StandardOutput" (In that priority) if Read_Output argument is set to True.
    29. Dim My_Process As New Process()
    30. WaitExitEvent.Reset()
    32. Try
    34. If Read_Output Then
    35. AddHandler My_Process.Exited, AddressOf My_Process_Exited
    36. AddHandler My_Process.ErrorDataReceived, AddressOf ProcessOutputDataReceived
    37. AddHandler My_Process.OutputDataReceived, AddressOf ProcessOutputDataReceived
    38. End If
    40. Dim My_Process_Info As New ProcessStartInfo()
    41. My_Process_Info.FileName = Process_Name ' Process filename
    42. My_Process_Info.Arguments = Process_Arguments ' Process arguments
    43. My_Process_Info.CreateNoWindow = Process_Hide ' Show or hide the process Window
    44. My_Process_Info.UseShellExecute = False ' Don't use system shell to execute the process
    45. My_Process_Info.RedirectStandardOutput = Read_Output ' Redirect (1) Output
    46. My_Process_Info.RedirectStandardError = Read_Output ' Redirect non (1) Output
    47. My_Process.EnableRaisingEvents = True ' Raise events
    48. My_Process.StartInfo = My_Process_Info
    49. My_Process.Start() ' Run the process NOW
    51. If Read_Output Then
    52. My_Process.BeginErrorReadLine()
    53. My_Process.BeginOutputReadLine()
    54. End If
    56. My_Process.WaitForExit(Process_TimeOut)
    58. If Read_Output Then
    59. WaitExitEvent.WaitOne(10000)
    60. End If
    62. Catch ex As Exception
    63. MsgBox(ex.Message)
    64. Return Nothing ' Returns nothing if the process can't be found or started.
    65. Finally
    66. If Read_Output Then
    67. RemoveHandler My_Process.Exited, AddressOf My_Process_Exited
    68. RemoveHandler My_Process.ErrorDataReceived, AddressOf ProcessOutputDataReceived
    69. RemoveHandler My_Process.OutputDataReceived, AddressOf ProcessOutputDataReceived
    70. End If
    71. End Try
    73. Return CStr(True) ' Returns True if Read_Output argument is set to False and the process finished without errors.
    75. End Function
    77. Private Sub ProcessOutputDataReceived(sender As Object, e As DataReceivedEventArgs)
    78. If Not String.IsNullOrEmpty(e.Data) Then
    79. Console.WriteLine(e.Data)
    80. DataReceived = True
    81. End If
    82. End Sub
    84. ' Handle Exited event and display process information.
    85. Private Sub My_Process_Exited(ByVal sender As Object, ByVal e As System.EventArgs)
    87. ' https://msdn.microsoft.com/de-de/library/system.diagnostics.process.exited(v=vs.110).aspx
    89. Dim myProcess As Process = DirectCast(sender, Process)
    91. Console.WriteLine("Exit time: {0}" & vbCrLf & "Exit code: {1}", myProcess.ExitTime, myProcess.ExitCode)
    93. Do While DataReceived
    94. DataReceived = False
    95. Threading.Thread.Sleep(100)
    96. Loop
    98. WaitExitEvent.Set()
    100. End Sub
    102. End Module
    104. Public Class ConsoleCopy
    105. Implements IDisposable
    107. Private fileStream As FileStream
    108. Private fileWriter As StreamWriter
    109. Private doubleWriter As TextWriter
    110. Private oldOut As TextWriter
    112. Private Class DoubleWrite
    113. Inherits TextWriter
    115. Private one As TextWriter
    116. Private two As TextWriter
    118. Public Sub New(one As TextWriter, two As TextWriter)
    119. Me.one = one
    120. Me.two = two
    121. End Sub
    123. Public Overrides ReadOnly Property Encoding() As Encoding
    124. Get
    125. Return one.Encoding
    126. End Get
    127. End Property
    129. Public Overrides Sub Flush()
    130. one.Flush()
    131. two.Flush()
    132. End Sub
    134. Public Overrides Sub Write(value As Char)
    135. one.Write(value)
    136. two.Write(value)
    137. End Sub
    139. End Class
    141. Public Sub New(path As String)
    142. oldOut = Console.Out
    144. Try
    145. fileStream = File.Open(path, FileMode.Append, FileAccess.Write, FileShare.Read)
    147. fileWriter = New StreamWriter(fileStream)
    148. fileWriter.AutoFlush = True
    150. doubleWriter = New DoubleWrite(fileWriter, oldOut)
    151. Catch e As Exception
    152. Console.WriteLine("Cannot open file for writing")
    153. Console.WriteLine(e.Message)
    154. Return
    155. End Try
    156. Console.SetOut(doubleWriter)
    157. End Sub
    159. Public Overloads Sub Dispose() Implements IDisposable.Dispose
    160. Console.SetOut(oldOut)
    161. If fileWriter IsNot Nothing Then
    162. fileWriter.Flush()
    163. fileWriter.Close()
    164. fileWriter = Nothing
    165. End If
    166. If fileStream IsNot Nothing Then
    167. fileStream.Close()
    168. fileStream = Nothing
    169. End If
    170. End Sub
    172. End Class

    Dieser Beitrag wurde bereits 8 mal editiert, zuletzt von „Thias“ ()

    finde auch die Implementierung von @~blaze~ am schönsten
    @Thias
    Process_TimeOut sollte -1 sein für endloses warten.
    Außerdem dürfte ein Console Redirect meines wissens auch die Consolenausgabe verhindern, was der TE ja anscheinend gar nicht will

    Was man dafür versuchen könnte wäre(anstelle von Redirect von Process) mittels WinAPI AttachConsole auf das Process handle anzuwenden(evtl muss auch CreateRemoteThread o.ä. verwendet werden),
    anschließend mittels GetStdHandle das Handle dieser Konsole zu holen(und zu merken), mittels SetStdHandle die Konsolenausgabe zu einer von uns erstelltem Stream umzuleiten und mittels eines solchen Writers beim Empfang von Konsolenoutput
    wieder an das Ursprüngliche Handle von GetStdHandle zurückschreiben.
    Ich wollte auch mal ne total überflüssige Signatur:
    ---Leer---

    Thias schrieb:

    Wobei es ihm wohl sogar mehr um sein eigenes Programm ging (Lösungen in Post 5) - wenn ich es recht verstanden habe - als über Process.Start (kam da selber nur auf die Idee wg. der Nachfrage von @Fortender)
    Aber letztendlich wäre es an @Fachkraftx3 mitzuteilen, ob das Problem für ihn gelöst ist oder ob noch Klärungsbedarf ist.

    Ja für so eine Art Logger lohnt es sich ein Singleton zu erstellen, welches das Reporting sowohl in dem Fenster, als auch in einem File bereitstellt
    Man kann dann von überall ​Log.Instance.Report(report) aufrufen.

    Danke @jvbsl für den Hinweis mit Process_TimOut -1 - ist angepasst und lässt sich ja bei Bedarf als Parameter dennoch weiterhin anders setzen.

    Denke @Fachkraftx3 ging es hauptsächlich darum, den Output in eine Datei weggeschrieben zu bekommen und gleichzeitig am Bildschirm in irgendeiner Konsole zu sehen - was bei allen Lösungen der Fall ist.
    Wobei es ihm wohl sogar mehr um sein eigenes Programm ging (Lösungen in Post 5) - wenn ich es recht verstanden habe - als über Process.Start (kam da selber nur auf die Idee wg. der Nachfrage von @Fortender)
    Aber letztendlich wäre es an @Fachkraftx3 mitzuteilen, ob das Problem für ihn gelöst ist oder ob noch Klärungsbedarf ist.

    Ob bei der Lösung von @~blaze~ weiterhin die Möglichkeit besteht, wie bei der Lösung mit ConsoleCopy, mit Console.WriteLine zu arbeiten (was ich schön finde) oder ob Programme für die Ausgaben angepasst werden müssen auf WriteToManyTextWriter.Write, ist mir leider noch nicht so klar, da ein Beispiel für den Aufruf fehlt und ich sichlerlich einige Zeit basteln müsste bis ich den hinbekäme - wg. der List(Of TextWriter) beim Konstruktor.
    Wobei das entscheidende wohl ist, dass Console.Out ja auch ein TextWriter ist - eventuell wäre der Aufruf doch nicht so schwert, aber ich hab es noch nicht ausprobiert.

    Edit: Für Eingaben bei cmd.exe fehlt noch My_Process_Info.RedirectStandardInput
    Falls ich Zeit habe, werde ich dafür andermal auch noch etwas basteln.

    Dieser Beitrag wurde bereits 4 mal editiert, zuletzt von „Thias“ ()

    Hilfe - warum hilft man hier nur, wenn es doch nicht gelesen wird?

    Der von mir in Post 5 verlinkte Ursprung ist alles in C#

    stackoverflow.com/questions/42…-console-output-to-a-file

    Die Lösung entweder mit den 90 Bewertungen oder den 25 Bewertugnen - wobei auch die anderen C#-Lösungen dort wohl großteils funktionieren!

    Und dann gib doch bitte wenigstens in Deinem Profil an, dass Du mit C# programmierst.

    Edit: @Plexian - stimmt, den letztn Satz hätte ich mir sparen können - insbesonere da ich damals extra den C#-Post bei stackoverflow.com rausgesucht hatte - nur heute habe ich nicht mehr zum Threadtitel hochgesrcollt - dies würde im Profil schneller ersichtlich sein

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

    Thias schrieb:

    Und dann gib doch bitte wenigstens in Deinem Profil an, dass Du mit C# programmierst.

    OT: Steht neben dem Threadtitle, als Threadtag.
    »There's no need to "teach" atheism. It's the natural result of education without indoctrination.« — Ricky Gervais

Facebook
Telefonspende