VB-NET: BeginOutputReadLine gibt erst nach ProzessEnde Daten heraus

  • VB.NET

Es gibt 6 Antworten in diesem Thema. Der letzte Beitrag () ist von Bit-Hexer.

    VB-NET: BeginOutputReadLine gibt erst nach ProzessEnde Daten heraus

    Hallo zusammen,

    über BeginOutputReadLine versuche ich eine Console-Ausgabe einer exe abzugreifen. (LogFile)


    Hier die Sub dazu:


    Quellcode

    1. Private Sub StartImport()
    2. 'Dim Server As New Process ' >> Umgezogen in die DIMs : Private WithEvents Server As New Process
    4. Dim ProcessInfo As New ProcessStartInfo
    5. ' Absicherung das am Pfadende ein Backslash steht
    6. sV_Converter_Pfad = func_BackslashPruefung(sV_Converter_Pfad)
    7. 'Bedatung der converter-Routine
    8. Server.StartInfo.FileName = sV_Converter_Pfad & sConverter_ApplName
    9. ' Bedatung der Arguments
    10. Server.StartInfo.Arguments = _
    11. " -project " & sConverter_VAR_ProjectName & _
    12. " -in " & sConverter_VAR__Path_and_File & _
    13. " -out " & sV_Converter_VAR_Project_Path & _
    14. " -full " & _
    15. " -filetrace " & sConverter_VAR_filetrace & _
    16. " -consoletrace " & sConverter_VAR_consoletrace & _
    17. " -majornr " & sConverter_VAR_majornr & _
    18. " -minornr " & sConverter_VAR_minornr & _
    19. " -ignorecodefiles 0 " & _
    20. " -ignoreerror 0"
    22. Debug.Print("TS " & SubRoutinen02.funcTimeStamp() & ": " & Server.StartInfo.Arguments)
    23. ' lbl_Status_Info.Text = "Info: Projekt wird erstellt ... bitte warten ..."
    26. Server.EnableRaisingEvents = True
    28. Server.StartInfo.UseShellExecute = False
    29. Server.StartInfo.RedirectStandardOutput = True
    31. Server.StartInfo.CreateNoWindow = True
    32. AddHandler Server.OutputDataReceived, AddressOf OutputDataReceivedHandler
    33. AddHandler Server.Exited, AddressOf Server_Exited
    35. sortOutput = New StringBuilder()
    37. '#### Start eines neuen Prozesses um die Disabled-Funktionen durchführen zu können während die ImportRoutine läuft
    38. Server.Start()
    39. Debug.Print("TS " & SubRoutinen02.funcTimeStamp() & ": " & "Server.Start()")
    40. Server.BeginOutputReadLine()
    41. Debug.Print("TS " & SubRoutinen02.funcTimeStamp() & ": " & "server.BeginOutputReadLine()")
    43. Me.Invoke(Sub()
    44. Me.btn_StartImport.Enabled = False
    45. Me.btn_SYS.Enabled = False
    46. Me.btn_Optionen.Enabled = False
    47. Me.txtbx_Converter_VAR_PDX_Path_and_File.Enabled = False
    48. Me.txtbx_Converter_VAR_ProjectName.Enabled = False
    49. Me.FileDia_Converter_VAR_PDX_Path_and_File.Enabled = False
    50. Me.lbl_Loglevel.Enabled = False
    51. Me.NUpDn_LogLevel.Enabled = False
    52. Me.chkbx_ConsoleAktiv.Enabled = False
    53. End Sub)
    55. End Sub



    Leider fängt der OutputDataReceivedHandler die Ausgaben nicht während der exe-Laufzeit ab, sonder gibt die Lines erst bei Prozessende heraus.
    Den String greife ich zur Laufzeit mit einem BackgroundWorker heraus, der jedoch bei verspäteter Stringausgabe nicht mehr greifen kann.


    Quellcode

    1. Private Sub OutputDataReceivedHandler(sendingProcess As Object, outLine As DataReceivedEventArgs) Handles Server.OutputDataReceived
    3. ' Collect the sort command output.
    4. Me.Invoke(Sub()
    5. Debug.Print("TS " & SubRoutinen02.funcTimeStamp() & ": " & "Aufruf > OutputDataReceivedHandler ")
    6. If Not String.IsNullOrEmpty(outLine.Data) Then
    7. Debug.Print("TS " & SubRoutinen02.funcTimeStamp() & ": " & "OutputDataReceivedHandler > String füllen ")
    8. numOutputLines += 1
    10. ' Add the text to the collected output.
    11. sortOutput.Append(Environment.NewLine + "[" _
    12. + numOutputLines.ToString() + "] - " _
    13. + outLine.Data)
    14. End If
    16. End Sub)
    18. End Sub



    Dasselbe so in C# gecoded läuft einwandfrei - also die Lines werden über den OutputDataReceivedHandler in "Echtzeit" herausgegeben und mit dem BGW abgegriffen.

    Irgendwas muss das mit den Starteigenschaften (?) der exe zu tun haben warum das in C# klappt und in VB nicht.... ?(


    Danke für Infos.....

    Bit-Hexer schrieb:

    VB.NET-Quellcode

    1. 'Dim Server As New Process ' >> Umgezogen in die DIMs : Private WithEvents Server As New Process
    Kannst Du mal bitte einen Code posten, der in sich vollständig ist?
    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!

    Leider ist das problematisch - die EXE ist vertrauliche Dritt-SW und einige Variablen musste ich verfemden. :/

    Mir ist bewust, dass eine Analyse ohne kompletten Code nicht einfach ist.
    Ich erhoffe mir jedoch kleine Hinweise, die mich zum Ziel führen.

    Markant ist, dass bei nahezu gleicher Syntax C# Ergebnisse spontan liefert und VB nicht.

    Bit-Hexer schrieb:

    bei nahezu gleicher Syntax
    Dann nimm den C#-Code und übersetze ihn nach VB.NET. Tools findest Du dafür genug.
    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!

    ...und auch hier gibt es einen Fehler....

    Wir haben diverse Tools laufen lassen un kommen zu diesen Ergebnissen:

    (Der Code ist leicht gekürzt - es geht hier nur um die Defintion des EventHandlers)


    C#-Quellcode

    1. public void converter(string sODME_pfad, string sProjekt_pfad, string sProjekt_name, string sMajor, string sMinor)
    2. {
    3. Process myConverter = new Process();
    5. myConverter.StartInfo.UseShellExecute = false;
    6. myConverter.EnableRaisingEvents = true;
    7. myConverter.StartInfo.Arguments = sConverter_Param;
    8. myConverter.StartInfo.CreateNoWindow = true;
    9. myConverter.StartInfo.RedirectStandardOutput = true;
    11. myConverter.Exited += new EventHandler(myConverter_Exited);
    12. myConverter.OutputDataReceived += new DataReceivedEventHandler(myConverter_OutputDataRecieved);
    14. myConverter.Start();
    15. myConverter.BeginOutputReadLine();
    17. Form1.iProzessID = myConverter.Id;
    18. }



    VB.NET-Quellcode

    1. Public Sub converter(sODME_pfad As String, sProjekt_pfad As String, sProjekt_name As String, sMajor As String, sMinor As String)
    2. Dim myConverter As New Process()
    4. myConverter.StartInfo.UseShellExecute = False
    5. myConverter.EnableRaisingEvents = True
    6. myConverter.StartInfo.Arguments = sConverter_Param
    7. myConverter.StartInfo.CreateNoWindow = True
    8. myConverter.StartInfo.RedirectStandardOutput = True
    10. myConverter.Exited += New EventHandler(myConverter_Exited)
    11. myConverter.OutputDataReceived += New DataReceivedEventHandler(myConverter_OutputDataRecieved)
    13. myConverter.Start()
    14. myConverter.BeginOutputReadLine()
    16. Form1.iProzessID = myConverter.Id
    17. End Sub



    Der Code läuft so nicht da der EventHandler nicht die korrekte Syntax hat....

    Also bringt ein umkonvertieren keine brauchbaren Ergebnisse.

    Deswegen starte ich in VB.NET ja auch so:

    VB.NET-Quellcode

    1. Server.EnableRaisingEvents = True
    2. Server.StartInfo.UseShellExecute = False
    3. Server.StartInfo.RedirectStandardOutput = True
    4. Server.StartInfo.CreateNoWindow = True
    7. AddHandler Server.OutputDataReceived, AddressOf OutputDataReceivedHandler
    8. AddHandler Server.Exited, AddressOf Server_Exited
    11. Server.Start()
    12. Server.BeginOutputReadLine()



    Trotzdem macht der VB-NET-Code keine Echtzeit wie es C# macht. :?:

Facebook
Telefonspende