ProgressBar zur Dateigröße einer Image Datei

  • VB.NET
  • .NET (FX) 1.0–2.0

Es gibt 20 Antworten in diesem Thema. Der letzte Beitrag () ist von diylab.

    ProgressBar zur Dateigröße einer Image Datei

    Hallo Leute,
    ich hab noch nicht so die Erfahrung mit VB2010 und bräuchte mit einer ProgressBar etwas hilfe.

    Ich lasse derzeit mit diesem Code ein Image einer Diskette erstellen:

    Quellcode

    1. oProcess = System.Diagnostics.Process.Start(My.Application.Info.DirectoryPath + "\rawwritewin.exe", "--read " + Chr(34) + My.Application.Info.DirectoryPath + "\Disk2.ima" + Chr(34))
    2. oProcess.WaitForExit()


    Dazu würde ich gerne eine ProgressBar haben die den Fortschritt anzeigt.
    Es müsste also irgend wie die Datei größe abgefragt werden, ob die 1440 KB schon erreicht wurden, und das irgend wie mit der ProgressBar verknüpft werden.

    Ich hoffe ihr könnt mir da weiter helfen.
    Mfg, Aod

    Aod schrieb:

    und das irgend wie mit der ProgressBar verknüpft werden.
    Ich bin mir nicht sicher, ob die Länge ühaupt ausgelesen werden kann.
    Wenn ja:
    Lies sie in einer Timer.Tick-Prozedur aus und zeige sie an.
    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 ich habe es jetzt so probiert:

    Quellcode

    1. Dim WithEvents oTimer As Timer
    2. Dim DateiTick As String = ""
    4. Private Sub Button1_Click(ByVal sender As System.Object, ByVal e As System.EventArgs) Handles Button1.Click
    6. oProcess = System.Diagnostics.Process.Start(My.Application.Info.DirectoryPath + "\rawwritewin.exe", "--read " + Chr(34) + My.Application.Info.DirectoryPath + "\Disk2.ima" + Chr(34))
    8. DateiTick = My.Application.Info.DirectoryPath + "\Disk2.ima"
    9. oTimer = New Timer
    10. oTimer.Interval = 50
    11. oTimer.Start()
    13. oProcess.WaitForExit()
    15. MsgBox("Auslesen abgeschlossen")
    17. End Sub
    20. Private Sub oTimer_Tick(ByVal sender As Object, ByVal e As System.EventArgs) Handles oTimer.Tick
    21. ProgressBar1.Minimum = 0
    22. ProgressBar1.Maximum = 1474560
    24. If IO.File.Exists(DateiTick) = True Then
    25. Dim infoReader As System.IO.FileInfo
    26. infoReader = My.Computer.FileSystem.GetFileInfo(DateiTick)
    28. ProgressBar1.Value = CInt(infoReader.Length)
    29. End If
    31. End Sub



    Ich denke mal sauber gelöst ist was anderes?
    Denn auf der Form bewegt sich die Progressbar nur, wenn ich oProcess.WaitForExit() raus lasse. Allerdings brauch ich das wait ?(

    Aod schrieb:

    bewegt sich die Progressbar nur
    Dann musst Du einen anderen Timer verwenden, der in einem anderen Thread arbeitet: System.Threading.Timer Gugst Du hier.
    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!

    Hmm,
    also wenn ich es richtig sehe habe ich den Timer so in einem anderen Thread:

    Quellcode

    1. Imports System
    2. Imports System.Threading
    3. Private demoThread As Thread = Nothing
    4. Dim DateiTick As String = ""
    6. Private Sub Button1_Click(ByVal sender As System.Object, ByVal e As System.EventArgs) Handles Button1.Click
    8. oProcess = System.Diagnostics.Process.Start(My.Application.Info.DirectoryPath + "\rawwritewin.exe", "--read " + Chr(34) + My.Application.Info.DirectoryPath + "\Disk2.ima" + Chr(34))
    9. DateiTick = My.Application.Info.DirectoryPath + "\Disk2.ima"
    11. ProgressBar1.Minimum = 0
    12. ProgressBar1.Maximum = 1474560
    13. Me.alarm = New Threading.Timer(AddressOf Tick, Nothing, 0, 0)
    14. Me.alarm.Change(1, 1)
    15. oProcess.WaitForExit()
    16. Me.alarm.Change(Timeout.Infinite, Timeout.Infinite)
    17. MsgBox("Auslesen abgeschlossen")
    18. ProgressBar1.Value = 0
    20. End Sub
    22. Private Sub Tick(ByVal state As Object)
    24. Me.demoThread = New Thread(New ThreadStart(AddressOf Me.Test123))
    25. Me.demoThread.Start()
    27. End Sub
    29. Public Sub Test123()
    31. If IO.File.Exists(DateiTick) = True Then
    32. Dim infoReader As System.IO.FileInfo
    33. infoReader = My.Computer.FileSystem.GetFileInfo(DateiTick)
    34. ProgressBar1.Value = CInt(infoReader.Length)
    35. End If
    37. End Sub


    Allerdings bekomme ich nun diese Fehlermeldung bei ProgressBar1.Value:

    Ungültiger threadübergreifender Vorgang: Der Zugriff auf das Steuerelement ProgressBar1 erfolgte von einem anderen Thread als dem Thread, für den es erstellt wurde.


    Und ich verstehe nicht wie ich es anders aufrufen könnte .


    NACHTRAG:
    Ich habe die eine Sub nun so mit invoke hoffentlich richtig geändert:

    Quellcode

    1. Public Sub Test123()
    2. If Me.InvokeRequired Then
    3. Me.Invoke(New MethodInvoker(AddressOf Test123))
    4. Else
    5. ProgressBar1.Minimum = 0
    6. ProgressBar1.Maximum = 1474560
    8. If IO.File.Exists(DateiTick) = True Then
    9. Dim infoReader As System.IO.FileInfo
    10. infoReader = My.Computer.FileSystem.GetFileInfo(DateiTick)
    12. ProgressBar1.Value = CInt(infoReader.Length)
    13. End If
    14. End If
    16. End Sub


    Das Problem ist aber nun wieder das alte, die Progressbar bewegt sich nicht während der "oProcess" noch läuft.

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

    Aod schrieb:

    hoffentlich richtig
    Nö.
    Nicht der Prozess soll invoked werden, sondern lediglich die Anzeige.
    Spoiler anzeigen

    VB.NET-Quellcode

    1. Imports System
    2. Imports System.Threading
    4. Public Class Form1
    5. Private demoThread As Threading.Timer
    6. Private DateiTick As String = ""
    8. Private Sub Button1_Click(sender As System.Object, e As System.EventArgs) Handles Button1.Click
    9. DateiTick = My.Application.Info.DirectoryPath + "\Disk2.ima"
    11. Dim oProcess As New Process
    12. oProcess.StartInfo.FileName = My.Application.Info.DirectoryPath & "\rawwritewin.exe"
    13. oProcess.StartInfo.Arguments = "--read """ & DateiTick & """"
    14. oProcess.Start()
    16. ProgressBar1.Minimum = 0
    17. ProgressBar1.Maximum = 1474560
    18. Me.demoThread = New Threading.Timer(AddressOf Test123)
    19. Me.demoThread.Change(0, 500)
    20. oProcess.WaitForExit()
    21. MsgBox("Auslesen abgeschlossen")
    22. Me.SetProgress(0)
    23. Me.demoThread.Change(Timeout.Infinite, Timeout.Infinite)
    24. End Sub
    26. Public Sub Test123(xx As Object)
    27. Dim fi As New System.IO.FileInfo(DateiTick)
    28. If fi.Exists Then
    29. Me.Invoke(Sub() Me.SetProgress(CInt(fi.Length)))
    30. End If
    31. End Sub
    33. Private Sub SetProgress(value As Integer)
    34. ProgressBar1.Value = value
    35. ProgressBar1.Update()
    36. End Sub
    37. End Class
    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!

    Erstmal danke für den Code, habe beim Invoken total den überblick verloren.

    Nun zu der schlechten Nachricht, die Progressbar fängt leider immernoch erst an, wenn oProcess.WaitForExit() vorbei ist.

    Ich verstehe es auch nicht...

    Wenn ich einen Haltepunkt setze und dann Einzelschritte mache, kann ich sehen das die Subs für die Progressbar erst abgearbeitet werden, wenn der Schritt oProcess.WaitForExit() abgearbeitet wurde. Es scheint also nicht Parallel zu laufen, aber warum?


    NACHTRAG:
    Ok, hab es schon so halb hinbekommen. Es liegt am WaitforExit:
    waitforexit stroppt form beim laden
    vb-paradise.de/index.php/Thread/?postID=143674#post143674

    NACHTRAG2:
    Spoiler anzeigen

    Quellcode

    1. Imports System
    2. Imports System.Threading
    4. Public Class Form1
    5. Private demoThread As Threading.Timer
    6. Private DateiTick As String = ""
    8. Private Sub Button1_Click(sender As System.Object, e As System.EventArgs) Handles Button1.Click
    9. DateiTick = My.Application.Info.DirectoryPath + "\Disk2.ima"
    11. ProgressBar1.Minimum = 0
    12. ProgressBar1.Maximum = 1474560
    13. Me.demoThread = New Threading.Timer(AddressOf Test123)
    14. Me.demoThread.Change(0, 500)
    16. Dim oProcess As New Process
    17. oProcess.StartInfo.FileName = My.Application.Info.DirectoryPath + "\Vorlagen\Diskette\rawwritewin.exe"
    18. oProcess.StartInfo.Arguments = "--read """ & DateiTick & """"
    19. oProcess.EnableRaisingEvents = True
    20. AddHandler oProcess.Exited, AddressOf processExited
    21. oProcess.Start()
    23. End Sub
    25. Private Sub processExited(ByVal sender As Object, ByVal e As EventArgs)
    27. MsgBox("Auslesen abgeschlossen")
    28. Me.SetProgress(0)
    29. Me.demoThread.Change(Timeout.Infinite, Timeout.Infinite)
    30. End Sub
    32. Public Sub Test123(xx As Object)
    33. Dim fi As New System.IO.FileInfo(DateiTick)
    34. If fi.Exists Then
    35. Me.Invoke(Sub() Me.SetProgress(CInt(fi.Length)))
    36. End If
    37. End Sub
    39. Private Sub SetProgress(value As Integer)
    40. ProgressBar1.Value = value
    41. ProgressBar1.Update()
    42. End Sub
    43. End Class


    Jetzt bekomme ich nur wieder das Problem mit "Ungültiger threadübergreifender Vorgang"

    Dieser Beitrag wurde bereits 3 mal editiert, zuletzt von „Aod“ ()

    Aod schrieb:

    "Ungültiger threadübergreifender Vorgang"
    Dann lies mal die Posts oben richtig durch.
    Ansonsten pack das Process-Handling in einen separaten Thread, BackgroundWorker dürfte reichen.
    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!

    Aod schrieb:

    Jetzt bekomme ich nur wieder das Problem mit "Ungültiger threadübergreifender Vorgang"

    Hallo @Aod,
    da mich das Thema auch ein bisschen interessiert hat, möchte ich Dir noch einen leicht anderen Ansatz geben - mit BackgroundWorkern.
    So ein BackgroundWorker ist eine altbewährte Möglichkeit, solche einfachen Sachen leicht umzusetzen, da jeder Worker nicht nur einen Arbeitsthread, sondern auch zwei Andere hat, wo z.B. der aktuelle Status threadsicher abgegriffen werden kann und der Worker meldet auch, wenn er fertig ist - das kann man auch gut gebrauchen.

    Anbei ein ganzes Testprojekt als Anhang, dort kannst Du das mal ausprobieren.
    Für die Image-Erstellung habe ich eine Simulation benutzt, dort würde dann Dein externes Programm laufen.

    Ich benutze zwei dieser BackgroundWorker - dadurch friert auch die Form nicht ein.
    Der eine Worker kümmert sich um das Schreiben des Images, der Andere um das Lesen der Image-Größe.

    Das Programm ist in C#, aber Du kannst es mühelos in VB konvertieren (Konverter sind in meiner Signatur).
    Auf der Form selbst ist nur eine ProgressBar und ein Button - also kein Problem.
    Das Programm ist schnell entstanden, ist also vielleicht nicht unbedingt der Stein der Weisen ;) ..

    Hier der C# Code:
    Spoiler anzeigen

    C#-Quellcode

    1. using System;
    2. using System.ComponentModel;
    3. using System.IO;
    4. using System.Threading;
    5. using System.Windows.Forms;
    7. namespace DiskImageProgress
    8. {
    9. public partial class frmMain : Form
    10. {
    11. private BackgroundWorker bwWrite = new BackgroundWorker();
    12. private BackgroundWorker bwRead = new BackgroundWorker();
    14. public frmMain()
    15. {
    16. InitializeComponent();
    18. // BackGroundWorker (Image)
    19. bwWrite.WorkerSupportsCancellation = false;
    20. bwWrite.WorkerReportsProgress = false;
    21. bwWrite.DoWork += new DoWorkEventHandler(bwWrite_DoWork);
    22. bwWrite.RunWorkerCompleted += new RunWorkerCompletedEventHandler(bwWrite_RunWorkerCompleted);
    24. // BackGroundWorker (Image-Größe)
    25. bwRead.WorkerSupportsCancellation = false;
    26. bwRead.WorkerReportsProgress = true;
    27. bwRead.DoWork += new DoWorkEventHandler(bwRead_DoWork);
    28. bwRead.ProgressChanged += new ProgressChangedEventHandler(bwRead_ProcessChanged);
    29. bwRead.RunWorkerCompleted += new RunWorkerCompletedEventHandler(bwRead_RunWorkerCompleted);
    30. }
    32. /// <summary>
    33. /// Arbeitsthread zum Erstellen eines Disketten-Images.
    34. /// Dadurch friert die Form nicht ein.
    35. /// </summary>
    36. /// <param name="sender"></param>
    37. /// <param name="e"></param>
    38. private void bwWrite_DoWork(object sender, DoWorkEventArgs e)
    39. {
    40. // Simulation zum Erstellen eines Disketten-Images mit 1,44MB (1440 Blöcke mit 1024 Byte))
    41. // 'Thread.Sleep' ist wichtig, damit der Vorgang nicht zu schnell geht
    42. using (StreamWriter sw = File.CreateText(Application.StartupPath + @"\diskimage.img"))
    43. {
    44. string buffer = string.Empty.PadRight(1024, '*');
    45. for (int i = 0; i < 1440; i++)
    46. {
    47. sw.Write(buffer);
    48. sw.Flush();
    49. Thread.Sleep(1);
    50. }
    51. }
    53. // Dem Image-Größe Thread ein bisschen Zeit geben,
    54. // damit der Status und die ProgressBar den richtigen Wert anzeigen
    55. Thread.Sleep(500);
    56. }
    58. /// <summary>
    59. /// Thread zum Image Erstellen ist fertig
    60. /// </summary>
    61. /// <param name="sender"></param>
    62. /// <param name="e"></param>
    63. private void bwWrite_RunWorkerCompleted(object sender, RunWorkerCompletedEventArgs e)
    64. {
    65. // Der Thread zum Erstellen des Images ist komplett - mach hier etwas bei Bedarf..
    66. }
    68. /// <summary>
    69. /// Image-Größe Arbeitsthread
    70. /// </summary>
    71. /// <param name="sender"></param>
    72. /// <param name="e"></param>
    73. private void bwRead_DoWork(object sender, DoWorkEventArgs e)
    74. {
    75. BackgroundWorker worker = sender as BackgroundWorker;
    77. FileInfo fi;
    78. int loopCounter = 0;
    80. while (bwWrite.IsBusy)
    81. {
    82. fi = new FileInfo(Application.StartupPath + @"\diskimage.img");
    83. Thread.Sleep(10);
    85. loopCounter++;
    86. if (loopCounter % 10 == 0)
    87. worker.ReportProgress((int)fi.Length);
    88. }
    89. }
    91. /// <summary>
    92. /// Status des Image-Größe-Threads
    93. /// </summary>
    94. /// <param name="sender"></param>
    95. /// <param name="e"></param>
    96. private void bwRead_ProcessChanged(object sender, ProgressChangedEventArgs e)
    97. {
    98. // Schreibt den aktuellen Status in den Form-Kopf
    99. this.Text = e.ProgressPercentage.ToString("N0") + " Bytes erstellt..";
    101. // Zeigt den aktuellen Status in der ProgressBar
    102. progressBarWriteImage.Value = ((int)((e.ProgressPercentage) * 100 / 1474560));
    103. }
    105. /// <summary>
    106. /// Thread zum Anzeigen der Image-Größe ist fertig
    107. /// </summary>
    108. /// <param name="sender"></param>
    109. /// <param name="e"></param>
    110. private void bwRead_RunWorkerCompleted(object sender, RunWorkerCompletedEventArgs e)
    111. {
    112. // Der Thread zum Anzeigen der Image-Größe ist komplett - mach hier etwas bei Bedarf..
    113. // this.Text = "Das Image wurde komplett erstellt!";
    114. }
    116. /// <summary>
    117. /// Button 'Image Erstellen'
    118. /// </summary>
    119. /// <param name="sender"></param>
    120. /// <param name="e"></param>
    121. private void btnWriteImage_Click(object sender, EventArgs e)
    122. {
    123. if (!bwWrite.IsBusy || !bwRead.IsBusy)
    124. {
    125. bwWrite.RunWorkerAsync();
    126. bwRead.RunWorkerAsync();
    127. }
    128. else
    129. {
    130. MessageBox.Show("Mindestens ein Thread ist noch nicht fertig.");
    131. }
    132. }
    133. }
    134. }



    Das sieht dann so aus:


    Es funktioniert einwandfrei - nur falls jetzt Jemand der Meinung ist "geht nicht bei mir.." ^^
    Vielleicht siehst Du es als Anregung und entwickelst es weiter?
    Falls Du Fragen zu oben gezeigtem Code hast, nenne die Zeilennummer(n) und frag nach.

    LG und viel Spaß beim Tüfteln,
    Bruno
    Dateien

    ErfinderDesRades schrieb:

    Das scheint mir absurd, zum Lesen einen Extra-BW zu bemühen, der nix anneres liest, als was man grad geschrieben hat.
    Also was man grad geschrieben hat, braucht man doch nicht wieder einzulesen - das weiß man doch so.


    Der TE hat ein externes Programm, dass keinen Status zurück gibt!
    Darum möchte er den aktuellen Status der Datei wissen (wozu auch immer, aber sieht nett aus 8-) ).
    In meinem Programm wird das Schreiben der Image-Datei lediglich simuliert und muss an dieser Stelle durch sein Teil ersetzt werden.

    Jetzt verstanden?

    ja - bisserl langsam, und auch weil das Thema nu shcon bischen länglich ist - sorry. :saint:

    Edit: Aber um alle 300ms eine Dateigröße auszulesen braucht man doch keinen BW!
    Da nimmt man doch einen Timer!

    Und auch um ein externes Proggi zu starten braucht man kein BW. Das startet man halt, und dann läuft das ja per se in einem anneren Thread - es ist ja ein unabhängiges Proggi.

    Also null BW, einfach das Proggi starten, und mittm Timer nachgucken, obs Fortschritte macht.

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

    diylab schrieb:

    einen Impuls setzen
    indem Du die Hausaufgaben von @Aod machst?
    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!

    RodFromGermany schrieb:

    indem Du die Hausaufgaben von @Aod machst?

    Weißt Du, wenn ich im Internet irgend etwas suche, finde ich zu 90% so ein Müll, wo 9x kluge User dem TE entweder auf die Forum- oder Internetsuche verweisen oder ihn so lange versuchen zu belehren, bis der Thread so durcheinander ist, bis niemand mehr durchsieht.
    Meistens sind solche Threads dann auch noch gespickt mit Kommentaren von Usern, die zu jedem Pups Ihren Senf dazugeben müssen - egal ob hilfreich oder nicht.

    Da ist es doch schon besser, INHALTE zu finden - oder?
    Jeder der lernen möchte, wird dies auch tun und jeder der eine schnelle Lösung braucht, wird eher unwillig lernen und sich über Lösungen freuen.

    Also überlass das mir, wie ich wem helfe - bin schon groß.
    Ok?

    Hallo Leute,
    erstmal danke für die ganzen Posts. Ich denke ich werde wieder zum Timer zurück kehren. Damit sollte es jetzt gehen, da ich ja nicht mehr WaitforExit sondern nun
    oProcess.EnableRaisingEvents = True
    AddHandler oProcess.Exited, AddressOf processExited
    benutze. Ich bin noch nicht zum ausprobieren gekommen, aber das hole ich noch nach.

    @diylab,
    danke für deine mühe mit dem Beispiel Program, ich werd es mir mal genauer angucken ob ich da noch was raus lernen kann.

    @RodFromGermany,
    Ein bisschen hatte ich mich letztens schon mit dem Background worker rumgeschlagen, aber es hatte nicht geklappt. Hatte mich einfach zu sehr auf das waitforexit festgefahren. Hätte nicht gedacht das waitforexit wirklich alles anhält, egal ob etwas in einem anderen thread läuft oder nicht.

    @Allgemeinheit ^^
    Ich verstehe RodFromGermanys ansicht, das es besser ist jemandem zu zeigen wie man etwas rausfindt, da so der lern effeckt größer ist, und man so beim nächsten problem besser weiß wie man die lösung findet.
    Aber auch diylabs antwort finde ich gut, denn so kann man besser erkennen wie etwas funktioniert. Also danke an euch beide.

    Ich probier dann mal noch ein paar sachen aus, ob es nun klappt.
    Wenn ich nicht weiter komme melde ich mich wieder ;)

    ErfinderDesRades schrieb:

    Edit: Aber um alle 300ms eine Dateigröße auszulesen braucht man doch keinen BW!
    Da nimmt man doch einen Timer!

    "man" hat mich noch nie interessiert.
    Viele Wege führen nach Rom, aber meiner kommt bis jetzt an - der Rest waren nur Tipps und Blasen (bis jetzt!) :D .
    Ich könnte Dir noch min. 20 andere Wege zum Ziel zeigen, aber darum geht es garnicht.
    Meine Version benutzt halt BackgroundWorker und vielleicht ist es in einem anderen Kontext für Suchende ja interessant.
    Der TE kann Timer nehmen bis die Uhr glüht - wie er halt möchte.

    tja, ich sehe halt immer nach guten und besseren Lösungen. Klar führen viele Wege nach Rom, aber als Programmierer nimmt man immer den kürzesten.
    Also nach meinem Verständnis kann man (anders als in vielen anneren Bereichen des Lebens) beim Programmieren Lösungen i.a. ziemlich klar in eine Rangordnung von besser und schlechter bringen.
    Und anzuwenden ist logisch immer das Beste, was eim grad bekannt ist.

    (ach ein komplett offtopic mussich noch loswerden: Deine "vogonische Dichtkunst" von heut morgen war für mich bereits das Highlight des Tages :thumbsup: )

Facebook
Telefonspende