<\/p>\n
Sie werden immer mal wieder auf die Aufgabe stoßen, automatisiert Zip-Dateien zu erstellen, Daten in Zip-Dateien zu speichern oder Daten aus Zip-Dateien zu extrahieren. Dazu benötigen Sie optimalerweise VBA-Code ohne viel Schnickschnack wie externe Bibliotheken et cetera. Windows liefert glücklicherweise in aktuelleren Versionen Möglichkeiten, Zip-Dateien auch per VBA zu erstellen, zu füllen und zu lesen. Diese sind zwar nicht so einfach zu finden, aber wir haben Ihnen eine Auswahl wichtiger Funktionen zusammengestellt.<\/b><\/p>\nGrundlegende Technik<\/h2>\n
Wenn wir die Windows-Funktionen zum Verwenden von Zip-Dateien nutzen wollen, haben wir nur eine eingeschränkte Menge an Möglichkeiten zur Verfügung. Diese sollten jedoch für den Großteil der denkbaren Einsatzfälle ausreichend sein.<\/p>\n
Benötigen Sie spezielle Techniken etwa zum Hinzufügen eines Kennworts zum Schutz des Inhalts der Zip-Datei, müssen Sie auf fertige Bibliotheken zurückgreifen, die möglicherweise kostenpflichtig sind und gegebenenfalls auch erst beim Nutzer installiert werden müssen.<\/p>\n
Die hier vorgestellten Techniken nutzen allein die vom Betriebssystem bereitgestellten Funktionen.<\/p>\n
In einem halbwegs frischen System, also ohne zusätzliche Einträge in den Kontextmenüs, sieht die eingebaute Funktion zum Erstellen von Zip-Dateien wie in Bild 1 aus. <\/p>\n
![\"Erstellen](\"..\/fileadmin\/_temp_\/2016_06\/pic_1064_001.png\")
<\/p>\n
Bild 1: Erstellen einer Zip-Datei mit Windows-Bordmitteln<\/span><\/b><\/p>\n Es gibt keine eingebaute Funktion, um eine leere Zip-Datei zu erstellen. Wie können wir dieses Problem umgehen Dazu gibt es zumindest zwei Möglichkeiten:<\/p>\n Ersteres würde zumindest noch eine weitere Tabelle mit dem Anlage-Feld erforderlich machen, was wir an dieser Stelle für übertriebenen Aufwand halten. Also erstellen wir lieber mit WinZip oder WinRar eine leere Zip-Datei und betrachten diese in einem Texteditor.<\/p>\n Das Ergebnis sieht dann etwa wie in Bild 2 aus. Was soll schon schieflaufen, wenn wir einfach eine leere Textdatei mit den eingebauten VBA-Befehlen erzeugen und die hier enthaltenen Zeichen einfügen Also machen wir uns an die Arbeit. Die Prozedur aus Listing 1 erwartet den Namen der zu erstellenden Zip-Datei und legt diese dann an. Dazu erstellt sie eine String<\/b>-Variable namens strZipinhalt <\/b>und füllt sie genau mit dem Inhalt der Datei, die wir oben probehalber erzeugt und im Texteditor angezeigt haben. Die Zeichen in der verwendeten Vorlage werden vom Texteditor im hexadezimalen Format angezeigt. Wir müssen diese, bevor wir die Zeichen mit der Funktion Chr() <\/b>ermitteln, in das Dezimalformat umwandeln. Dies erledigen wir durch Voranstellen der Zeichenkette &H<\/b>. Die achtzehn Nullen fügen wir mit der Funktion String()<\/b> hinzu, der wir als ersten Parameter die Anzahl der zu liefernden Zeichen und als zweiten den Code für das gewünschte Zeichen übergeben.<\/p>\n Bild 2: Aussehen einer leeren Zip-Datei<\/span><\/b><\/p>\n Die Prozedur ermittelt dann mit der Funktion FreeFile <\/b>eine Dateinummer für den Zugriff auf die neu zu erstellende Datei. Diese öffnen wir mit der Open<\/b>-Methode, der wir den Namen der zu erstellenden Datei folgen lassen (strZipdatei<\/b>). Der öffnungsmodus ist For Binary Access Write<\/b>, die Dateinummer lautet schließlich #intDateinummer<\/b>. Die Put<\/b>-Methode schreibt den Inhalt der Variablen strZipinhalt <\/b>in die mit #intDateinummer <\/b>geöffnete Datei, die Close<\/b>-Methode schließt diese wieder.<\/p>\n Ein beispielhafter Aufruf für diese Prozedur sieht etwa wie folgt aus:<\/p>\n Die so erzeugte Datei hat genau den gleichen Inhalt wie die oben mit WinZip erzeugte Datei im Texteditor und kann somit auch etwa mit WinZip oder WinRar geöffnet werden. Außerdem, und das ist ja unser erklärtes Ziel, können wir diese neu erstellte Zip-Datei nun mit den von uns gewünschten Dateien füllen.<\/p>\n Der zweite Schritt besteht nun darin, eine Datei zu einer Zip-Datei hinzuzufügen. Dazu verwenden wir die Funktion Zippen <\/b>aus Listing 2. Die Datei erwartet zwei Parameter:<\/p>\n Listing 2: Funktion zum Hinzufügen einer Datei zu einer Zip-Datei<\/span><\/b><\/p>\n Die Funktion deklariert zwei Objektvariablen namens objZip <\/b>und objShell <\/b>sowie eine Integer<\/b>-Variable namens intCount<\/b>. objShell <\/b>füllen wir mit einem neuen Objekt auf Basis der Klasse Shell.Application <\/b>wie bereits in der Prozedur ZipErstellen<\/b>. objZip <\/b>erhält einen Verweis auf das Namespace<\/b>-Objekt auf Basis der Zip-Datei.<\/p>\n Diesen holen wir über die Namespace<\/b>-Eigenschaft des Shell.Application<\/b>-Objekts. Danach prüft die Funktion, ob objZip <\/b>einen Verweis enthält. Dies ist nicht der Fall, wenn die mit strZipdatei <\/b>übergebene Datei keine Zip-Datei ist. In diesem Fall erstellt die Funktion die Zip-Datei mit der bereits vorgestellten Prozedur ZipErstellen <\/b>neu und erneuert dann den in objZip <\/b>gespeicherten Verweis auf diese Datei.<\/p>\n Nun folgt ein Schritt, der für die überprüfung des Erfolgs wichtig ist. Mit der Eigenschaft Count<\/b> der items<\/b>-Auflistung des Namespace<\/b>-Objekts mit der Zip-Datei ermitteln wir die Anzahl der in der Zip-Datei enthaltenen Dateien beziehungsweise Elemente (hier werden auch Ordner mitgezählt). Bei einer frisch angelegten Zip-Datei sollte dies den Wert 0 <\/b>liefern.<\/p>\n Anschließend würden wir normalerweise einfach die CopyHere<\/b>-Methode des Namespace<\/b>-Objekts mit der Zip-Datei aufrufen und als Parameter den Namen der hinzuzufügenden Datei übergeben:<\/p>\n Dies ist auf dem Testsystem jedoch zuverlässig schiefgegangen. Nach einigen Recherchen stellte sich heraus, dass man den Dateinamen in Klammern einfassen muss, damit es gelingt:<\/p>\n Die Methode CopyHere <\/b>ist eine asynchrone Methode, das heißt, sie wird ausgeführt, während der Code weiterläuft. Wenn wir also direkt danach mit der folgenden Anweisung prüfen würden, ob die Datei hinzugefügt wurde, kann es sein, dass das Hinzufügen noch nicht abgeschlossen wurde:<\/p>\n Also bauen wir eine Do…Loop<\/b>-Schleife ein, die mit einer Hilfsfunktion prüft, ob die Datei bereits zur Zip-Datei hinzugefügt wurde. Mit jedem Durchlauf dieser Schleife rufen wir zunächst die Sleep<\/b>-Funktion mit dem Wert 100 <\/b>als Parameter auf, was eine Pause von einer Zehntelsekunde hervorruft. Die Sleep<\/b>-Funktion deklarieren wir wie folgt in einem Standardmodul:<\/p>\n Die Abbruchbedingung lautet so:<\/p>\n Die hier angegebene Funktion ZipdateiGeschlossen <\/b>erwartet den Namen der zu überprüfenden Datei als Parameter (s. Listing 3). Sie ermittelt eine Nummer für den schreibenden Zugriff auf die angegebene Datei und versucht dann, diese mit der Open<\/b>-Anweisung zu öffnen.<\/p>\n Listing 3: Funktion zur Prüfung, ob eine bestimmte Datei aktuell geschlossen ist<\/span><\/b><\/p>\n Ist die Datei noch geöffnet, löst diese Anweisung einen Fehler aus und die Funktion springt zur Marke Ende_ZipdateiGeschlossen<\/b>. Die Funktion liefert dann den Wert False <\/b>zurück. Anderenfalls schließt die Funktion die Datei mit der Close<\/b>-Anweisung wieder und stellt den Rückgabewert auf True <\/b>ein.<\/p>\n Auf diese Weise wird die Do…Loop<\/b>-Schleife so lange durchlaufen, bis die Zip-Datei nicht mehr durch die CopyHere<\/b>-Anweisung in Beschlag genommen wird und die Datei hinzugefügt wurde. Danach können wir dann in der If…Then<\/b>-Bedingung prüfen, ob sich die Anzahl der enthaltenen Dateien im Anschluss an das Hinzufügen geändert hat. Falls ja, wird der Rückgabewert der Funktion Zippen <\/b>auf den Wert True <\/b>eingestellt.<\/p>\n Die Funktion Zippen <\/b>testen wir etwa mit folgender Routine:<\/p>\n Dies stellt die Pfadangaben zur Zip-Datei und zur hinzuzufügenden Datei zusammen und übergibt diese an die Funktion Zippen<\/b>. Das Ergebnis wird dann in einer Meldung ausgegeben.<\/p>\n Mit der Funktion Zippen <\/b>können Sie auch komplette Verzeichnisse zippen. Dazu übergeben Sie als zweiten Parameter einfach den Pfad zu dem zu zippenden Verzeichnis:<\/p>\n Nachdem Sie diese beiden Test-Routinen aufgerufen haben, erhalten Sie eine Zip-Datei, die mit WinRar geöffnet etwa wie in Bild 3 aussieht.<\/p>\n Bild 3: Zip-Datei mit einigen per VBA hinzugefügten Elementen<\/span><\/b><\/p>\n Die bisher beschriebene Version der Funktion Zippen <\/b>haben wir unter dem Namen Zippen_Version1 <\/b>im Modul mdlZippen <\/b>abgelegt.<\/p>\n Nun möchten Sie möglicherweise nicht das komplette Verzeichnis zippen, sondern nur die in diesem Verzeichnis enthaltenen Dateien. Das können Sie erledigen, indem Sie die Funktion Zippen <\/b>entsprechend anpassen.<\/p>\n Die neue Version sieht nun wie in Listing 4 aus. Sie erwartet zwei Parameter mehr als die vorherige Version, nämlich lngAnzahl <\/b>und bolOhneVerzeichnis<\/b>. Beide sind nur in Zusammenhang mit der übergabe eines Verzeichnisses mit dem Parameter strDateiVerzeichnis <\/b>interessant, da nur dann mehrere Dateien verarbeitet werden.<\/p>\n <\/p>\n Listing 4: Zippen-Funktion, die auch einzelne Elemente eines Verzeichnisses zippt – mit Rückgabe der Anzahl<\/span><\/b><\/p>\n Die Funktion verwendet außerdem drei zusätzliche Variablen: intCount <\/b>nimmt die Anzahl der hinzufügten Elemente auf. strDatei <\/b>soll, wenn es sich beim Inhalt des Parameters strDateiVerzeichnis <\/b>um ein Verzeichnis handelt, zum Durchlaufen der darin enthaltenen Dateien dienen. strVerzeichnis <\/b>nimmt entsprechend das Verzeichnis aus strDateiVerzeichnis <\/b>auf – dies nur, um Verwechslungen zu vermeiden. Die Zip-Datei wird wie gehabt referenziert beziehungsweise, sofern noch nicht vorhanden, erstellt. Die Variable intCount <\/b>speichert nach wie vor die Anzahl der Elemente des Zip-Archivs vor dem Hinzufügen der Elemente.<\/p>\n Dann prüft die Hilfsfunktion IstVerzeichnis<\/b>, ob es sich bei dem mit strDateiVerzeichnis <\/b>übergebenen Pfad um ein Verzeichnis handelt. Ist dies der Fall und gleichzeitig der Parameter bolOhneVerzeichnis <\/b>auf True <\/b>eingestellt, wird der erste Teil der If…Then<\/b>-Bedingung abgearbeitet.<\/p>\n Innerhalb dieses Abschnitts trägt die Funktion den Wert von strDateiVerzeichnis <\/b>in die Variable strVerzeichnis <\/b>ein. Dann prüft sie, ob strVerzeichnis <\/b>ein abschließendes Backslash-Zeichen (\\<\/b>) enthält, und fügt dieses gegebenenfalls noch hinzu. Schließlich liest die Prozedur mit der Dir<\/b>-Funktion den Namen des ersten Elements des in strVerzeichnis <\/b>angegebenen Verzeichnisses in die Variable strDatei <\/b>ein.<\/p>\n Damit steigt die Funktion in eine Do While<\/b>-Schleife ein, die so lange läuft, wie die Länge der in strDatei <\/b>gespeicherten Zeichenkette größer als 0 <\/b>ist, die Variable also einen Wert enthält. Innerhalb der Schleife fügt die CopyHere<\/b>-Methode nun die Datei mit dem aus strVerzeichnis <\/b>und strDatei <\/b>zusammengesetzten Pfad zu der mit objZip <\/b>referenzierten Zip-Datei hinzu. Die Do…Loop<\/b>-Schleife mit dem Ausdruck Not ZipdateiGeschlossen(strZipdatei) <\/b>hält die weitere Ausführung der Funktion wieder so lange an, bis die Zip-Datei durch den asynchronen Befehl CopyHere <\/b>fertig beschrieben wurde.<\/p>\n Danach ermittelt die Funktion über den einfachen Aufruf der Dir<\/b>-Funktion die nächste Datei in dem angegebenen Verzeichnis. Warum kein Parameter Weil die Dir<\/b>-Funktion so strukturiert ist, dass sie mit Verzeichnisangabe das erste Element dieses Verzeichnisses zurückliefert und ohne Parameter immer das jeweils folgende Element. Die Schleife beginnt nun von vorn, wo sie wieder prüft, ob strDatei <\/b>noch mit einem Dateinamen gefüllt ist. Falls ja, werden auch die folgenden Dateien zur Zip-Datei hinzugefügt, anderenfalls ist die Schleife abgearbeitet.<\/p>\n Der Else-Teil der If…Then<\/b>-Bedingung fügt wie bereits in der vorherigen Version der Zippen<\/b>-Funktion die mit strDateiVerzeichnis <\/b>angegebene Datei oder das Verzeichnis zur Zip-Datei hinzu.<\/p>\n Ob während des Aufrufs der Zippen<\/b>-Funktion ein oder mehrere Dateien zur Zip-Datei hinzugefügt wurden, ermitteln wir wieder mit der Differenz aus objZip.items.Count <\/b>und dem Wert aus der Variablen intCount<\/b>. Diesmal landet das Ergebnis allerdings gleich im Rückgabeparameter lngAnzahl<\/b>. Deren Inhalt überprüft dann auch die If…Then<\/b>-Bedingung, welche den Rückgabewert der Funktion Zippen <\/b>im Falle eines Wertes größer 0 <\/b>auf True <\/b>einstellt.<\/p>\n Die Hilfsfunktion IstVerzeichnis<\/b>, mit der wir prüfen, ob es sich bei dem mit strDateiVerzeichnis <\/b>übergebenen Ausdruck um eine Datei oder ein Verzeichnis handelt, sieht wie folgt aus:<\/p>\n Sie liest den Wert der Funktion GetAttr<\/b> für den Parameter strPfad <\/b>ein und prüft, ob das Ergebnis die Konstante vbDirectory <\/b>enthält. In diesem Fall handelt es sich um ein Verzeichnis und die Funktion liefert den Wert True <\/b>zurück.<\/p>\n Das Ergebnis für ein Verzeichnis, das beispielsweise drei Textdateien enthält und mit folgender Routine aufgerufen wurde, sieht wie in Bild 4 aus:<\/p>\n Bild 4: Zip-Datei mit dem Inhalt eines Verzeichnis als einzelne Dateien<\/span><\/b><\/p>\n Nun wollen wir herausfinden, welche Dateien überhaupt in einer Zip-Datei enthalten sind. Im Hinblick auf eine spätere Anwendung, in der wir diese Dateien in einem Unterformular anzeigen wollen, speichern wir diese Daten direkt in einer Tabelle namens tblDateien<\/b>.<\/p>\n Diese sieht im Entwurf wie in Bild 5 aus. Neben dem Primärschlüsselfeld speichert die Tabelle den Dateinamen, das Datum der letzten änderung, die Größe der gepackten und der ungepackten Dateien sowie das Verhältnis dieser Zahlen. Das Feld Dateiname<\/b> versehen wir mit einem eindeutigen Schlüssel, da die enthaltenen Dateien nur jeweils einmal vorkommen dürfen.<\/p>\n Bild 5: Tabelle zum Speichern der Informationen der in einer Zip-Datei gespeicherten Dateien<\/span><\/b><\/p>\n Damit wir uns die Arbeit beim Erstellen der folgenden Routinen vereinfachen, binden wir zwischenzeitlich die Bibliothek Microsoft Shell Controls and Automation <\/b>wie in Bild 6 ein (VBA-Editor, Menüpunkt Extras|Verweise<\/b>). Damit können wir nun IntelliSense nutzen und etwas intuitiver mit den Elementen der verwendeten Klasse Shell32 <\/b>umgehen.<\/p>\n Bild 6: Verweis auf die Bibliothek Microsoft Shell Controls and Automation<\/span><\/b><\/p>\n Später sollten Sie, um Versionskonflikte bei Verwendung verschiedener Betriebssystemversionen zu vermeiden, allerdings wieder auf Late Binding umsteigen. In diesem Fall reduziert sich der Aufwand darauf, in den Deklarationen die Variablentypen wieder in den Typ Objekt <\/b>umzuwandeln.<\/p>\n Die Prozedur zum Einlesen der Dateien einer Zip-Datei in die Tabelle tblDateien <\/b>sieht wie in Listing 5 aus. Sie erwartet lediglich den Namen der zu untersuchenden Zip-Datei als Parameter. Wir haben hier in der Early Binding-Variante gleich drei Objektvariablen deklariert, die Klassen der Shell32<\/b>-Bibliothek nutzen:<\/p>\n Listing 5: Funktion zum Auslesen der in einer Zip-Datei enthaltenen Dateien<\/span><\/b><\/p>\n Die übrigen Variablen nehmen temporär die Informationen zur jeweiligen Datei auf. Die Prozedur füllt die Database-Variable db <\/b>zunächst mit einem Verweis auf die aktuelle Datenbank und löscht dann alle Datensätze der Tabelle tblDateien<\/b>. Sie prüft dann, ob der Parameter strZipdatei <\/b>überhaupt eine vorhandene Datei liefert. Falls ja, arbeitet die Prozedur einige Anweisungen ab, die sich innerhalb der entsprechenden If…Then<\/b>-Bedingung befinden.<\/p>\n Die erste erstellt ein Objekt auf Basis der Klasse Shell.Application <\/b>und speichert den Verweis darauf in der Variablen objShell<\/b>. Dazu verwendet sie die CreateObject<\/b>-Methode. Da wir aktuell Early Binding verwenden, hätten wir das Objekt auch mit der New<\/b>-Methode erstellen können. Da wir dies beim ändern in eine Late Binding-Methode wieder rückgängig machen müssten, haben wir es bei der CreateObject<\/b>-Methode belassen. Die zweite Anweisung referenziert die übergebene Zip-Datei mit der NameSpace<\/b>-Methode, welches ein Folder2<\/b>-Objekt basierend auf dem übergebenen Pfad zurückliefert. Dieses Objekt referenzieren wir mit der Variablen Zip-Datei erstellen<\/h2>\n
\n
![\"Aussehen](\"..\/fileadmin\/_temp_\/2016_06\/pic_1064_002.png\")
<\/p>\nPublic Sub <\/span>Test_ZipErstellen()\r\n On Error Resume Next<\/span>\r\n Kill CurrentProject.Path & \"\\testvba.zip\"\r\n On Error GoTo<\/span> 0\r\n ZipErstellen CurrentProject.Path & \"\\testvba.zip\"\r\nEnd Sub<\/span><\/pre>\nZip-Datei füllen<\/h2>\n
Public Function <\/span>Zippen(strZipdatei As String<\/span>, strDatei As String<\/span>) As Boolean<\/span>\r\n Dim <\/span>objZip As Object<\/span>\r\n Dim <\/span>objShell As Object<\/span>\r\n Dim <\/span>intCount As Integer<\/span>\r\n Set<\/span> objShell = CreateObject(\"Shell.Application\")\r\n Set<\/span> objZip = objShell.Namespace((strZipdatei))\r\n If <\/span>objZip Is Nothing Then<\/span>\r\n ZipErstellen strZipdatei\r\n Set<\/span> objZip = objShell.Namespace(CVar(strZipdatei))\r\n End If<\/span>\r\n intCount = objZip.items.Count\r\n ''''objZip.CopyHere strDatei\r\n objZip.CopyHere (strDatei) ''''Klammer Pflicht, da sonst kein zippen\r\n Do\r\n Call<\/span> Sleep(100)\r\n Loop<\/span> While Not<\/span> ZipdateiGeschlossen(strZipdatei)\r\n If <\/span>objZip.items.Count > intCount Then<\/span>\r\n Zippen = True<\/span>\r\n End If<\/span>\r\nEnd Function<\/span><\/pre>\n\n
objZip.CopyHere strDatei<\/pre>\n
objZip.CopyHere (strDatei)<\/pre>\n
If <\/span>objZip.items.Count > intCount Then<\/span><\/pre>\nDeclare Sub Sleep Lib \"kernel32\" (ByVal dwMilliseconds As Long<\/span>)<\/pre>\nLoop<\/span> While Not<\/span> ZipdateiGeschlossen(strZipdatei)<\/pre>\nPrivate Function <\/span>ZipdateiGeschlossen(strZipdatei As String<\/span>) As Boolean<\/span>\r\n Dim <\/span>intDateinummer As Integer<\/span>\r\n intDateinummer = FreeFile\r\n On Error GoTo<\/span> Ende_ZipdateiGeschlossen\r\n Open strZipdatei For Binary Access Read Lock Write As <\/span>intDateinummer\r\n Close intDateinummer\r\n ZipdateiGeschlossen = True<\/span>\r\nEnde_ZipdateiGeschlossen:\r\nEnd Function<\/span><\/pre>\nPublic Sub <\/span>Test_Zippen_Datei_klein()\r\n Dim <\/span>strDatei As String<\/span>\r\n Dim <\/span>strZipdatei As String<\/span>\r\n strZipdatei = CurrentProject.Path & \"\\testvba.zip\"\r\n strDatei = CurrentProject.Path & \"\\test.txt\"\r\n MsgBox<\/span> \"Zippen erfolgreich \" _\r\n & Zippen(strZipdatei, strDatei)\r\nEnd Sub<\/span><\/pre>\nVerzeichnisse zippen<\/h2>\n
Public Sub <\/span>Test_Zippen_Folder()\r\n Dim <\/span>strDatei As String<\/span>\r\n Dim <\/span>strZipdatei As String<\/span>\r\n strZipdatei = CurrentProject.Path & \"\\testvba.zip\"\r\n strDatei = CurrentProject.Path & \"\\test\\\"\r\n MsgBox<\/span> \"Zippen erfolgreich \" _\r\n & Zippen(strZipdatei, strDatei)\r\nEnd Sub<\/span><\/pre>\n![\"Zip-Datei](\"..\/fileadmin\/_temp_\/2016_06\/pic_1064_003.png\")
<\/p>\nDateien eines Verzeichnisses einzeln zippen<\/h2>\n
Public Function <\/span>Zippen(strZipdatei As String<\/span>, ByVal strDateiVerzeichnis As String<\/span>, _\r\n Optional<\/span> lngAnzahl As Long<\/span>, Optional<\/span> bolOhneVerzeichnis As Boolean<\/span> = False<\/span>) As Boolean<\/span>\r\n Dim <\/span>objZip As Object<\/span>, objShell As Object<\/span>\r\n Dim <\/span>intCount As Integer<\/span>, strDatei As String<\/span>, strVerzeichnis As String<\/span>\r\n Set<\/span> objShell = CreateObject(\"Shell.Application\")\r\n Set<\/span> objZip = objShell.NameSpace((strZipdatei))\r\n If <\/span>objZip Is Nothing Then<\/span>\r\n ZipErstellen strZipdatei\r\n Set<\/span> objZip = objShell.NameSpace(CVar(strZipdatei))\r\n End If<\/span>\r\n intCount = objZip.items.Count\r\n If <\/span>IstVerzeichnis(strDateiVerzeichnis) And bolOhneVerzeichnis Then<\/span>\r\n strVerzeichnis = Trim<\/span>(strDateiVerzeichnis)\r\n If <\/span>Not<\/span> Right<\/span>(strVerzeichnis, 1) = \"\\\" Then<\/span>\r\n strVerzeichnis = strVerzeichnis & \"\\\"\r\n End If<\/span>\r\n strDatei = Dir(strVerzeichnis)\r\n Do While<\/span> Len<\/span>(strDatei) > 0\r\n objZip.CopyHere (strVerzeichnis & strDatei)\r\n Do\r\n Call<\/span> Sleep(100)\r\n Loop<\/span> While Not<\/span> ZipdateiGeschlossen(strZipdatei)\r\n strDatei = Dir()\r\n Loop<\/span>\r\n Else<\/span>\r\n objZip.CopyHere (strDateiVerzeichnis)\r\n Do\r\n Call<\/span> Sleep(100)\r\n Loop<\/span> While Not<\/span> ZipdateiGeschlossen(strZipdatei)\r\n End If<\/span>\r\n lngAnzahl = objZip.items.Count - intCount\r\n If <\/span>lngAnzahl Then<\/span>\r\n Zippen = True<\/span>\r\n End If<\/span>\r\nEnd Function<\/span><\/pre>\nFunction <\/span>IstVerzeichnis(ByVal strPfad As String<\/span>) As Boolean<\/span>\r\n On Error Resume Next<\/span>\r\n IstVerzeichnis = _\r\n ((GetAttr(strPfad) And vbDirectory) = vbDirectory)\r\nEnd Function<\/span><\/pre>\n![\"Zip-Datei](\"..\/fileadmin\/_temp_\/2016_06\/pic_1064_004.png\")
<\/p>\nPublic Sub <\/span>Test_Zippen_VerzeichnisDateienEinzeln_MitAnzahl()\r\n Dim <\/span>strDatei As String<\/span>\r\n Dim <\/span>strZipdatei As String<\/span>\r\n Dim <\/span>lngAnzahl As Long<\/span>\r\n Dim <\/span>bolZippen As Boolean<\/span>\r\n strZipdatei = CurrentProject.Path & \"\\testvba.zip\"\r\n strDatei = CurrentProject.Path & \"\\test\"\r\n bolZippen = Zippen(strZipdatei, strDatei, lngAnzahl, True<\/span>)\r\n If <\/span>bolZippen Then<\/span>\r\n MsgBox<\/span> \"Zippen erfolgreich, Anzahl: \" & lngAnzahl\r\n Else<\/span>\r\n MsgBox<\/span> \"Zippen nicht erfolgreich\"\r\n End If<\/span>\r\nEnd Sub<\/span><\/pre>\nElemente der Zip-Datei ermitteln<\/h2>\n
![\"Tabelle](\"..\/fileadmin\/_temp_\/2016_06\/pic_1064_005.png\")
<\/p>\nZur Vereinfachung: Early Binding<\/h2>\n
![\"Verweis](\"..\/fileadmin\/_temp_\/2016_06\/pic_1064_006.png\")
<\/p>\nProzedur zum Einlesen der gezippten Dateien<\/h2>\n
Public Sub <\/span>ZipdateiUntersuchen(strZipdatei As String<\/span>)\r\n Dim <\/span>objShell As <\/span>Shell ''''(As Object) - für Late Binding wieder einkommentieren\r\n Dim <\/span>objZip As <\/span>Shell32.Folder2 ''''(As Object) - für Late Binding wieder einkommentieren\r\n Dim <\/span>objDatei As <\/span>Shell32.FolderItem ''''(As Object) - für Late Binding wieder einkommentieren\r\n Dim <\/span>db As <\/span>DAO.Database\r\n Dim <\/span>strDateiname As String<\/span>\r\n Dim <\/span>datLetzteAenderung As Date<\/span>\r\n Dim <\/span>dblGroesseUngepackt As Double<\/span>\r\n Dim <\/span>dblGroesseGepackt As Double<\/span>\r\n Dim <\/span>intRatioGepacktUngepackt As Integer<\/span>\r\n Set<\/span> db = CurrentDb\r\n db.Execute \"DELETE FROM tblDateien\", dbFailOnError\r\n If <\/span>Len<\/span>(Dir(strZipdatei)) > 0 Then<\/span>\r\n Set<\/span> objShell = CreateObject(\"Shell.Application\")\r\n Set<\/span> objZip = objShell.NameSpace(CVar(strZipdatei))\r\n For Each objDatei In objZip.Items\r\n With<\/span> objZip\r\n strDateiname = .GetDetailsOf(objDatei, 0)\r\n datLetzteAenderung = Replace<\/span>(Replace<\/span>(.GetDetailsOf(objDatei, 7), ChrW(8206), \"\"), ChrW(8207), \"\")\r\n dblGroesseUngepackt = Val(.GetDetailsOf(objDatei, 5))\r\n dblGroesseGepackt = Val(.GetDetailsOf(objDatei, 2))\r\n intRatioGepacktUngepackt = Val(Replace<\/span>(.GetDetailsOf(objDatei, 6), ChrW(8206), \"\"))\r\n db.Execute \"INSERT INTO tblDateien(Dateiname, ZuletztGeaendert, GepackteGroesse, \" _\r\n \"UngepackteGroesse, Ratio) VALUES(''''\" & strDateiname & \"'''', \" & ISODatum(datLetzteAenderung) & \", \" _\r\n & dblGroesseGepackt & \", \" & dblGroesseUngepackt & \", \" & intRatioGepacktUngepackt & \")\", dbFailOnError\r\n End With<\/span>\r\n Next<\/span> varDatei\r\n Set<\/span> objShell = Nothing\r\n End If<\/span>\r\nEnd Sub<\/span><\/pre>\n\n