Internet-Update in eigene Anwendung integrieren Je komplexer ein Programm ist, desto größer wird auch der Wunsch nach einem eigenen Updateprogramm. In diesem Workshop zeigen wir Ihnen, wie Sie eine Updatefunktion in Ihr Hauptprogramm integrieren und Sie Ihr Programm um eine (weitere) professionelle Funktion erweitern können.
Autor:  Florian Platzer	Bewertung:     [ Jetzt bewerten ]	Views:  39.653

Geben Sie hier Ihre persönliche Bewertung ab! Anzahl Bewertungen bisher: 6 Bewertung insgesamt: nützlich Durchschnittliche Bewertung: 3.2 von 5 Sternen

sehr gut     gut     nützlich     mittelmäßig     mangelhaft

Je komplexer ein Programm ist, desto größer wird auch der Wunsch nach einem eigenen Updateprogramm. In diesem Workshop zeigen wir Ihnen, wie Sie eine Updatefunktion in Ihr Hauptprogramm integrieren und Sie Ihr Programm um eine (weitere) professionelle Funktion erweitern können.

Alles was Sie brauchen ist ein neues Projekt (natürlich können Sie den Code in Ihr bereits vorhandenes Projekt einbauen, für Testzwecke ist es aber besser, ein eigenes zu erstellen). Außerdem bedienen wir uns des genialen Downloadworkshops:
 Datei-Download via HTTP-Protokoll.

Öffnen Sie also ein neues Projekt (Standard-Exe) und binden Sie die Klasse clsDownload aus eben genannten Datei-Download-Workshop in Ihr Projekt ein.
Des Weiteren öffnen Sie bitte noch das Komponentenfenster und fügen Sie das "Microsoft Winsock Control" und die "Microsoft Windows Common Controls" hinzu. So - gestalten wir nun die Oberfläche des Forms, benötigt werden:

Das sollte dann ungefähr so aussehen:

Wenn Sie mit dem Gestalten fertig sind, geht's ans Eingemachte:

Beginnen wir mit dem Deklarationsteil:
Ein Feature dieser Updatefunktion ist das Erstellen einer Batch-Datei, so kann die laufende "alte" Anwendung nach Beenden dieser automatisch durch die "Neue" ersetzt werden. Dazu benötigen wir folgende API:

Private Declare Function CharToOemA Lib "user32.dll" ( _
  ByVal lpszSrc As String, _
  ByVal lpszDst As String) As Long

Nun verweisen wir 2x auf die Download-Klasse. Ein Objekt ist für den Download der Versionsdatei verantwortlich, das Andere für den Download des zu ersetzenden Programms. Zusätzlich deklarieren wir gleich eine Variable, in der die neue Version gespeichert werden soll.

Dim WithEvents VersionDownload As clsDownload
Dim WithEvents FileDownload As clsDownload
Dim sNewVersion As String

Was jetzt noch fehlt, sind die Konstanten, die auf den Server und auf die Versionsdatei verweisen (für diesen Workshop habe ich meinen Server zur Verfügung gestellt):

Private Const sDomain As String = "http://www.vbmaster.gbadmin.de/extra/Tutorial_Updateprogramm/"
Private Const sCurrentVersion As String = "current_version.txt"

Im Ordner, auf den in der Konstante "sDomain" verwiesen wird, befinden sich folgende Dateien:

• MyProg.exe (Version 1.0.1) - das ist die neue Version des Programms
• current_version.txt - in dieser Textdatei steht die Versionsnummer des aktuellen Programms (z.B. "1.0.1" - ohne Anführungszeichen)
• (Zum besseren Verständnis, laden Sie sich einfach das Beispielprojekt herunter und sehen Sie im Ordner "server" nach)

Hilfsfunktionen

Fangen wir nun mit dem relevanten Teil des Codes an, am Besten zuerst mit den Hilfsfunktionen:

' Function TextRead gibt den ausgelesenen Text einer (Text-) Datei zurück
Private Function TextRead(ByVal sFileName As String) As String
  Dim iNumber As Integer
  Dim lSize As Long
  iNumber = FreeFile
 
  Open sFileName For Input As iNumber
  lSize = LOF(iNumber)
  TextRead = Input(lSize, iNumber)
  Close iNumber
End Function
 
' Sub CreateBatch erzeugt eine Batch-Datei, die sofort ausgeführt wird, 
' um das laufende Programm sofort zu ersetzen, sobald es beendet wird:
' Die downgeloadete Datei wird mit der Dateiendung *.e32 "zwischengespeichert",
' die *.bat durchläuft nun in einer Schleife, ob die laufende Anwendung noch 
' benutzt wird oder nicht mehr, wenn nicht, dann wird die alte Exe gelöscht und 
' die *.e32 in *.exe umbenannt, das ist der ganze Zauber :-)
Private Sub CreateBatch(ByVal sFile As String, ByVal sReplace As String)
  Dim BatFile As String
  Dim sCommand As String
 
  BatFile = sFile & ".bat"
 
  If GetAttr(sReplace) Then SetAttr sReplace, 0
  Call CharToOemA(sFile, sFile)
  Call CharToOemA(sReplace, sReplace)
 
  sCommand = "@echo off" & vbCrLf
  sCommand = sCommand & "IF NOT EXIST """ & sFile & """ GOTO NoReplace" & vbCrLf
  sCommand = sCommand & ":TryDel" & vbCrLf
  sCommand = sCommand & "DEL """ & sReplace & """" & vbCrLf
  sCommand = sCommand & "IF EXIST """ & sReplace & """ GOTO TryDel" & vbCrLf
  sCommand = sCommand & "COPY """ & sFile & """ /B """ & sReplace & """ /B" & vbCrLf
  sCommand = sCommand & "DEL """ & sFile & """" & vbCrLf
  sCommand = sCommand & ":NoReplace" & vbCrLf
  sCommand = sCommand & "DEL """ & BatFile & """"
 
  Open BatFile For Binary As FreeFile
  Put #1, , sCommand
  Close #1
 
  Shell BatFile, vbHide
End Sub

Im Form_Load soll der Titel und die aktuelle Programmversion in den Labels angezeigt werden:

Private Sub Form_Load()
  ' Titel setzen
  lblTitle.Caption = "Herzlich Willkommen zu 'MyProg'!" & vbCrLf & vbCrLf & _
    "Möglicherweise ist dies nicht mehr die aktuellste Version." & vbCrLf & _
    "Soll nach Updates gesucht werden?"
 
  ' Tag des Labels mit der aktuellen Versionsnummer füllen
  lblLocal.Tag = App.Major & "." & App.Minor & "." & App.Revision
 
  ' Caption des Labels mit Versionsnummer aktualisieren
  lblLocal.Caption = "Version des Programms: " & lblLocal.Tag
End Sub

DOWNLOAD-Funktion

Gut, jetzt kommen wir zu den Downloads: Wie oben gezeigt, wurden 2 Objekte deklariert, die auf die Downloadklasse verweisen.

Beginnen wir mit der Versionsdatei: Hier wird das Objekt instanziert und die Datei der Konstante "sCurrentVersion" vom Server heruntergeladen.

Private Sub cmdCheckForUpdate_Click()
  ' Objekt instanzieren
  Set VersionDownload = New clsDownload
 
  ' Sanduhr einblenden
  Screen.MousePointer = vbHourglass
 
  ' Download der Versionsnummer starten und in aktuellen Pfad speichern
  VersionDownload.DoDownload sDomain & sCurrentVersion, App.Path & "\" & sCurrentVersion
End Sub

Ist das geschafft, wird das "Finished"-Event ausgelöst. Nun kann die aktuelle Version mit der des Programms überprüft werden und bei einer "Unstimmigkeit" mit dem Download des Updates begonnen werden. Hierzu wird das Objekt "FileDownload" nach der MsgBox-Abfrage instanziert und der Download gestartet (Info: es wird automatisch nach dem gleichen Dateinamen wie dem der ausgeführten Exe gesucht):

Private Sub VersionDownload_Finished()
  ' aktuelle Version auslesen
  sNewVersion = TextRead(App.Path & "\" & sCurrentVersion)
 
  ' downgeloadete Versionsdatei löschen
  Kill App.Path & "\" & sCurrentVersion
 
  ' aktuelle Version im Label anzeigen
  lblCurrent.Caption = "Version am Server: " & sNewVersion
 
  ' Version zu einer "richtigen" Zahl umwandeln, indem Punkte entfernt werden
  sNewVersion = Replace(sNewVersion, ".", "")
 
  ' Objekt löschen
  Set VersionDownload = Nothing
 
  ' Wenn Version keine Zahl, dann ist was faul
  If Not IsNumeric(sNewVersion) Then
    MsgBox "Ungültige Datei auf Server!", vbCritical
  Else
    ' Ansonsten überprüfen, ob die neue Version als Zahl größer ist, als die Alte...
    If IsNewVersion(sNewVersion, lblLocal.Tag) Then
      ' Sie ist es, und nun fragen wir den User, ob er updaten will
      If MsgBox("Neue Version verfügbar!" & vbCrLf & "Downloaden?", vbYesNo) = vbYes Then
        ' Ja, also Objekt instanzieren und downloaden
        Set FileDownload = New clsDownload
        FileDownload.DoDownload sDomain & App.EXEName & ".exe", App.Path & "\" & App.EXEName & ".e32"
      End If
    Else
      ' kein Update vorhanden...
      MsgBox "Keine neue Programmversion verfügbar"
    End If
  End If
 
  ' Maus zurücksetzen
  Screen.MousePointer = vbDefault
End Sub

Neue Version verfügbar?

Diese Funktion wird dazu eingesetzt, um überprüfen zu lassen, ob eine Version neuer ist als die Andere.

Private Function IsNewVersion(ByVal sCurrent As String, ByVal sLocal As String) As Boolean
  Dim sSplit() As String
  Dim i
 
  ' Zuerst die neue Version überprüfen
  sSplit = Split(sCurrent, ".")
  If UBound(sSplit) < 2 Then ReDim Preserve sSplit(0 To 2) As String
 
  For i = LBound(sSplit) To UBound(sSplit)
    If Not IsNumeric(sSplit(i)) Then sSplit(i) = "0"
  Next i
 
  sCurrent = sSplit(0) & "." & Format(sSplit(1), "0000") & "." & Format(sSplit(2), "0000")
 
  ' dann die Version des lokalen Programms
  sSplit = Split(sLocal, ".")
  If UBound(sSplit) < 2 Then ReDim Preserve sSplit(0 To 2) As String
 
  For i = LBound(sSplit) To UBound(sSplit)
    If Not IsNumeric(sSplit(i)) Then sSplit(i) = "0"
  Next i
 
  sLocal = sSplit(0) & "." & Format(sSplit(1), "0000") & "." & Format(sSplit(2), "0000")
 
  ' und zuletzt beide Versionen vergleichen und Resultat zurückgeben
  IsNewVersion = (Val(Replace(sCurrent, ".", "")) > Val(Replace(sLocal, ".", "")))
End Function

Um dem User anzuzeigen, dass der Download voranschreitet, bauen wir noch eine ProgressBar ein. Schließlich zeigen wir dem User auch noch eine MsgBox an, wenn der Download beendet wurde:

' Start des File-Downloads und Anzeige der ProgressBar
Private Sub FileDownload_Start()
  pgbDownload.Visible = True
End Sub
 
' Nach jedem Datenempfang wird dieses Event ausgelöst, 
' dementsprechend können wir auch die ProgressBar aktualisieren.
Private Sub FileDownload_Progress(ByVal BytesLoaded As Long, ByVal FileSize As Long)
  If pgbDownload.Max <> FileSize Then pgbDownload.Max = FileSize
  pgbDownload.Value = BytesLoaded
End Sub
 
' Ist der Download beendet, ProgressBar ausblenden, 
' MsgBox anzeigen und die Batch-Datei erstellen...
Private Sub FileDownload_Finished()
  pgbDownload.Visible = False
  MsgBox "Download beendet"
  Call CreateBatch(App.Path & "\" & App.EXEName & ".e32", App.Path & "\" & App.EXEName & ".exe")
  Set FileDownload = Nothing
End Sub

So, damit wäre die Updatefunktion auch schon wieder fertig

Hier noch einige Infos zur Ausführung:

• Bitte probieren Sie die Updatefunktion nur in der Exe aus, der Interpreter von VB wird sich mit dem Updaten schwer tun
• Sichern Sie die erstellte Exe bevor Sie sie updaten, somit ersparen Sie sich lästiges kompilieren, um den Updatevorgang erneut auszuprobieren

Wenn Sie nun updaten, das Programm aber laufen lassen, werden Sie sehen, dass sich nun 2 neue Dateien im aktuellen Ordner befinden... nämlich eine "MyProg.e32" und eine "MyProg.e32.bat". Beenden Sie das Programm, verschwinden beide Dateien und beim nächsten Programmstart, oh Wunder, das ist doch tatsächlich die neue Version