<\/p>\n
Verlieren Sie auch hin und wieder den überblick über Ihr Dateisystem und finden partout bestimmte Dateien nicht mehr auf Dann ist neben der Windows-Suche ein Tool wie Everything ein guter Freund. Doch nicht nur die Anwendung mit ihrer Oberfläche selbst ist ein ausgereifter Helfer. Denn als Pluspunkt können Sie zusätzlich eine API-Schnittstelle verbuchen, welche sich aus Access heraus ansprechen lässt.<\/b><\/p>\nEverything<\/h2>\n
Gerade als Entwickler nennen Sie wahrscheinlich einen Rechner ihr Eigen, welcher mit Programmen, Tools, Dokumenten, Quellcode und anderen Dateien vollgestopft ist. Ich verzeichne aktuell über zwei Millionen Dateien auf meinem Hauptrechner. Da heißt es Ordnung halten und das Dateisystem gut strukturieren. Dennoch kommt es häufig vor, dass der Verbleib mancher Dateien schleierhaft bleibt – vor allem dann, wenn sie mehrfach in verschiedenen Verzeichnissen abgelegt wurden. Nun können Sie zum Auffinden selbstverständlich die Suche benutzen, die Windows von Haus aus mitbringt und, etwa unter Windows 10<\/b>, die Suche namens Cortona<\/b> befragen. Windows Search<\/b> indiziert im Hintergrund fortwährend das System und füllt damit eine Datenbank, die im Ergebnis eine relativ schnelle Suche ermöglicht. Allerdings kann ich mich weder mit den möglichen Suchparametern, noch mit der Präsentation der Ergebnisse so richtig anfreunden. Deshalb gibt es eine Menge Tools, die die Lücke schließen und eine Alternative anbieten.<\/p>\n
Everything<\/b> von voidtools.com<\/b> sticht dabei unter mehreren Aspekten heraus. Zwar gibt es mittlerweile diverse Freeware-Tools, die ebenso schnell arbeiten, weil sie als Basis die MFTs<\/b> der Festplatten heranziehen, doch gerade die ausgefeilte API<\/b>-Schnittstelle von Everything<\/b> stellt ein Alleinstellungsmerkmal dar. Zudem haben Sie bei Installation die Wahl zwischen einer Systeminstallation und der Portable Version<\/b>, bei der Sie den Download nur in ein Verzeichnis Ihrer Wahl entpacken.<\/p>\n
Sollten Sie Everything<\/b> noch nicht kennen, so lohnt sich zunächst ein Blick in die FAQ<\/b> auf den Seiten von void-tools<\/b>. Unter dem Menüpunkt Support<\/b> finden Sie dort dann eine ausführliche Beschreibung aller Möglichkeiten und alles zum Umgang mit der Anwendung. Möchten Sie das Programm nutzen, so begeben Sie sich zu den Downloads<\/b> und wählen unter verschiedenen Optionen die passende Version.<\/p>\n
Es spielt, soviel vorweggenommen, keine Rolle, ob Sie die 32-Bit<\/b>– oder die 64-Bit<\/b>-Version nehmen. Normalerweise müssen Sie bei Office<\/b>, das Sie sicherlich als 32-Bit-Version vorliegen haben, darauf achten, dass ein Programm, welches über eine API<\/b>-Schnittstelle angesprochen wird, ebenfalls in 32 Bit vorliegt. Doch mit Everything<\/b> wird gar nicht direkt kommuniziert, sondern über eine intermediäre DLL, die einen standardisierten Transportmechanismus von Windows nutzt, nämlich IPC<\/b>. Der kann sich zwischen 32-Bit- und 64-Bit-Programmen gleichermaßen austauschen. Vielleicht liegt Ihnen die portable Version eher, als die Installation über eine Setup<\/b>– oder MSI<\/b>-Datei. Allerdings installiert letztere zunächst nicht einen Windows-Service, der das System automatisch im Hintergrund indiziert. Sie müssen dann die Anwendung erst unter Administratorrechten starten, was den bekannten UAC-Prompt <\/b>unumgänglich macht. Erst dann scannt das Tool das System.<\/p>\nWie funktioniert Everything<\/h2>\n
Wollten Sie das Dateisystem mit Bordmitteln von Windows auslesen und sich dabei solcher API<\/b>-Funktionen, wie FindFileFirst<\/b>, et cetera, bedienen, oder unter VBA die Dir<\/b>-Funktion nutzen, oder einen Verweis auf ein File System Object<\/b> setzen, um mit jenem zu arbeiten, so können Sie auch auf einem schnellen Rechner bei Millionen von Dateien eine lange Kaffeepause einlegen. Solche Verfahren sind zum Scannen des gesamten Dateisystems schlicht ungeeignet.<\/p>\n
Everything<\/b> nimmt sich jedoch direkt die MFT<\/b> (Master File Table<\/b>) einer Festplattenpartition zur Brust, die ein Verzeichnis aller Dateien und Ordner darstellt. Die Indizierung läuft deshalb unglaublich schnell ab. Bei den erwähnten zwei Millionen Dateien ist das hier in etwa 30 Sekunden erledigt. Ist die interne Everything<\/b>-Datenbank einmal angelegt, so berücksichtigt das Tool nur noch änderungen am Dateisystem.<\/p>\n
Nach dem Start dauert dies dann gerade einmal zwei bis fünf Sekunden, je nachdem, wieviel sich seit dem letzten Indizieren am Dateisystem geändert hat. Voraussetzung allerdings ist, dass das Dateisystem mit NTFS<\/b> partitioniert ist. FAT<\/b> kann Everything<\/b> natürlich ebenfalls lesen, doch dann kommen die altbekannten Windows-API-Verfahren zum Zug, die erheblich langsamer sind.<\/p>\n
Sinnvoll ist es deshalb, eine Verknüpfung zum Tool in den Autostart<\/b>-Ordner von Windows zu legen, wenn Sie die portable Version verwenden. Nach dem Start der Anwendung minimiert sich diese in den Tray<\/b> von Windows. Mit Doppelklick auf das entsprechende Lupen-Icon öffnet sich dann die Oberfläche des Tools. Ist Everything<\/b> als Service installiert, so ist das Tray-Icon<\/b> automatisch immer aktiv. Solange die Anwendung läuft, bekommt sie alle änderungen am Dateisystem mit und modifiziert demgemäß ihre Datenbank. Das lässt sich sogar Live beobachten, wenn Sie die Oberfläche von Everything<\/b> geöffnet haben.<\/p>\n
Das GUI<\/b> von Everything<\/b> zeigt Bild 1. Im Textfeld oben geben Sie einen Suchbegriff ein, und sofort filtert sich die Ergebnisliste unten entsprechend. Die Syntax für den Suchbegriff ist dabei weitaus mächtiger, als die von Windows. Hier können spezielle Platzhalter zum Einsatz kommen und allerlei Kombinationen derselben bis hin zu regulären Ausdrücken. Das Kombinationsfeld rechts neben dem Suchfeld erlaubt die einfache Filterung nach Kategorien, wie etwa Dokumente, Bilder oder Videos. Die Einträge in dieser Combobox können Sie zuvor selbst festgelegt haben.<\/p>\n
![\"Das](\"..\/fileadmin\/_temp_\/2018_04\/EverythingEXE.png\")
<\/p>\n
Bild 1: Das GUI von Everything wirkt auf den ersten Blick recht unspektakulär und eher spartanisch, hat unter der Haube aber viel zu bieten.<\/span><\/b><\/p>\n Die Ergebnisliste ist nicht einfach nur eine Liste, sondern hat alle Eigenschaften der Windows-Shell<\/b>. Das bedeutet, dass die gelisteten Dateien etwa dasselbe Kontextmenü anzeigen, wie der Explorer, und Kopier- sowie Drag And Drop<\/b>-Operationen zulassen. Doch Gegenstand dieses Beitrags ist nicht die Beschreibung des Tools selbst, sondern seine Fernsteuerung. Zum Umgang mit der Anwendung finden Sie alle Informationen unter dem Menüpunkt Support<\/b> auf voidtools<\/b>. Sie werden staunen, was alles mit Everything<\/b> möglich ist!<\/p>\n Unter dem Stichwort SDK<\/b> können Sie auf voidtools<\/b> die interaktive Schnittstelle zu Everything<\/b> herunterladen. Die Funktionen der Schnittstelle sind zudem auf den Webseiten genau dokumentiert. über diese Schnittstelle können Sie dann dieselben Vorgänge realisieren, wie auch manuell über die GUI:<\/b> Sie setzen einen Suchbegriff ab, übergeben einige Suchoptionen, und erhalten als Resultat eine Liste mit den gefundenen Dateien oder Ordner. Das GUI<\/b> von Everything<\/b> muss während dieses Vorgangs nicht geöffnet sein.<\/p>\n Nun hatte David Carpenter<\/b>, der Entwickler von voidtools<\/b>, mit diesem SDK<\/b> nicht unbedingt Visual Basic<\/b>-Entwickler als Zielgruppe im Sinn. Die Dokumentation stützt sich deshalb auf C<\/b>. Zwar finden Sie im Netz – genauer: im Forum zu Everything<\/b> – auch eine VB-Portierung der C-Header<\/b>-Dateien, doch die ist etwas veraltet und hat nur eine Teilmenge der Methoden übersetzt.<\/p>\n Also hat Access im Unternehmen<\/b> die Fleißarbeit für Sie übernommen und praktisch alle API<\/b>-Aufrufe nach VBA<\/b> übersetzt, sodass Sie nun auch aus einer Datenbank heraus Zugriff auf Everything<\/b> haben – mit den gleichen Möglichkeiten, wie ein C++<\/b>-Programmierer.<\/p>\n Alles, was Sie dazu benötigen, ist eine aktuelle Version der everything32.dll<\/b>, die als Bestandteil des SDK<\/b> den IPC<\/b>-Mittler zwischen API<\/b> und Everything<\/b>-Anwendung oder -Dienst darstellt. Sie finden die DLL direkt im Download zur Demodatenbank. Und schließlich brauchen Sie noch alle API-Deklarationen zur DLL, die sich im Klassenmodul clsEverything<\/b> der Demo befinden. Die kleine Testprozedur in Listing 1 zeigt zunächst, wie Sie dieses Modul einsetzen. Hier soll Everything<\/b> untersuchen, wo sich alle Dateien mit dem Namen mscomctl.ocx<\/b> befinden. Die Prozedur rufen Sie einfach aus dem VBA-Direktfenster heraus auf.<\/p>\n Listing 1: Die Verwendung des Klassenmoduls clsEverything demonstriert diese Test-Routine<\/span><\/b><\/p>\n Damit die Klasse funktioniert muss eine Instanz von Everything<\/b> bereits auf dem Rechner laufen. Haben Sie es als Service installiert oder eine Verknüpfung zur everything.exe<\/b> in den Autostart<\/b>-Ordner von Windows gelegt, so ist dies bereits gewährleistet. Dann können Sie die erste Zeile der Prozedur löschen oder auskommentieren.<\/p>\n Die nämlich startet die im Datenbankverzeichnis befindliche VBScript<\/b>-Datei starteverything.vbs<\/b> über die API-Anweisung ShellExecute<\/b>. Vielleicht kommt Ihnen das seltsam vor, weist doch VBScript<\/b> keinerlei Methoden auf, die VBA selbst nicht auch enthielte. Man könnte also die Zeilen des Skripts ja auch in ein VBA-Modul schreiben<\/p>\n Tatsächlich gibt es damit ein Problem: Everything<\/b> soll mit erhöhten Administratorrechten laufen. Ein Start aus Access heraus würde dies nicht gewährleisten können, da Access selbst nur unter Benutzerrechten läuft. Diesem Umstand hilft das Skript ab. Aus Platzgründen listen wir es hier nicht auf, erläutern jedoch dessen Funktionsweise. Der Trick ist nämlich, dass das Skript automatisch zweimal startet. Es ruft sich selbst auf, nachdem es über das WMI<\/b>, je nach Betriebssystem, erfahren hat, wo sich die für die Skript-Ausführung verantwortliche Datei wscript.exe<\/b> befindet.<\/p>\n Und die wird dann ein zweites Mal ausgeführt, wobei nun als Argument ein runas<\/b> übergeben wird. Das weist den Kommandozeileninterpreter an, das Skript mit erhöhten Rechten zu startet. Es kommt nun zum UAC-Prompt<\/b>. In der Folge ermittelt die Routine den Ort zur everything.exe<\/b> und startet eine Instanz derselben unter Zuhilfenahme des Windows Scripting Host <\/b>und der Methode Run<\/b>. Everything<\/b> ist nun automatisch mit Admin-Rechten gestartet. Das Skript findet dabei selbständig heraus, ob die 32-Bit<\/b>– oder die 64-Bit-Version<\/b> von Everything<\/b> installiert ist. Nach diesem Start kann die Klasse clsEverything<\/b> in Gestalt der Objektvariablen C<\/b>, auf die ein With<\/b>-Block gesetzt wird, in Aktion treten.<\/p>\n Mit der Eigenschaft Ready<\/b> ermittelt die Prozedur erst, ob Everything<\/b> als Prozess auch wirklich korrekt ansprechbar ist. Dann werden einige Suchoptionen eingestellt. CaseSensitive<\/b> steht auf False<\/b>, wodurch nicht zwischen Groß- und Kleinschreibung unterschieden wird. Die maximale Anzahl an Rückgabewerten (ResultLimit<\/b>) wird auf 2.000<\/b> festgelegt. Das ist für diesen Testaufruf eigentlich nicht notwendig, da Sie wohl kaum mehr Dateien mit dem Namen mscomctl.ocx<\/b> finden werden. (Bei mir waren es aber immerhin 94.)<\/p>\n übergeben Sie jedoch im Parameter Search<\/b> der Prozedur etwa *.jpg<\/b>, so ist die Wahrscheinlichkeit groß, dass dieses Limit überschritten wird. Dann stehen im Ergebnis nur die ersten 2.000<\/b> gefunden JPEG-Dateien.<\/p>\n Die nächste Einstellung ist da schon wichtiger. ResultProperties<\/b> können Sie eine Kombination der im Klassenmodul definierten Enumerationskonstanten eEVERYTHING_REQUEST<\/b> übergeben. Die steuern, was alles im Ergebnis enthalten sein soll. Die Standardeinstellung ist FULL_PATH_AND_FILE_NAME<\/b>, die alle Dateien oder Ordner mit vollem Pfad zurückgibt. Weitere Angaben fehlen. Mit der zusätzlichen Einstellung DATE_CREATED<\/b> weist das Ergebnis dann eine zusätzliche Spalte mit dem Erstelldatum der Dateien auf.<\/p>\n ShowMessages<\/b> weist an, dass etwaige Fehlermeldungen ausgegeben werden sollen. Die Sortierung des Ergebnisses geschieht aufsteigend nach Namen, weil dies in SortOrder<\/b> so eingestellt ist. Statt PATH_ASCENDING<\/b> können Sie eine Menge anderer Sortierungen angeben. Mit SIZE_DESCENDING<\/b> etwa würden die Ergebnisse absteigend nach Größe der Dateien sortiert. <\/p>\n Nach dieser (optionalen) Einstellung der Sucheigenschaften geht es mit dem Aufruf der Methode Search<\/b> erst wirklich zur Sache. Dieser übergeben Sie im ersten Parameter den Suchausdruck, im zweiten ein Variant-Array (ret<\/b>) und im dritten eine String-Variable sCols<\/b>, welche die ermittelten Spalten im Ergebnis wiederspiegeln wird. Das Klassenmodul füllt diesen String selbst und gibt in unserem Beispiel über Debug.Print<\/b> dies aus:<\/p>\n Die erste Ergebnisspalte enthält demnach die Eigenschaft Kind<\/b> der Dateien. Das ist ein Dateiattribut, welches aus einem Buchstaben besteht. Mit F<\/b> ist eine Datei gekennzeichnet (File<\/b>), mit D<\/b> ein Ordner (Directory<\/b>) und mit V<\/b> ein Laufwerk (Volume<\/b>). Path<\/b> verweist auf den Dateipfad, File<\/b> auf den Dateinamen. DateCreated<\/b> gibt in der letzten Spalte das Erstelldatum aus. Nützlich ist dieser String dann, wenn Sie die Elemente des Rückgabe-Arrays etwa den Spalten einer Tabelle zuordnen möchten, wie wir noch sehen werden.<\/p>\n Das in ret<\/b> zurückgegebene Array ist damit zweidimensional. Die zweite mit UBound(ret, 2)<\/b> ermittelte Dimension ist die Anzahl der Zeilen, die erste die Zahl der Spalten darin. Zwei verschachtelte Schleifen mit den Zählern i<\/b> und j<\/b> auf diese Dimensionen durchlaufen nun das Array und geben die Werte im Direktfenster aus. Das abschließende Komma in Debug.Print<\/b> weist VBA an, den nächsten Eintrag jeweils an die nächste TAB-Position zu stellen. Nach der inneren Schleife führt das Debug.Print<\/b> ohne Parameter hingegen zum Zeilenumbruch.<\/p>\n <\/p>\n Im Test dauerte der Aufruf von Search<\/b> etwa ein bis zwei Sekunden. Vergegenwärtigen Sie sich, dass dabei das komplette Dateisystem durchsucht wird! Am schnellsten geschieht das, wenn Sie lediglich die Dateipfade zurückgeben lassen. Mit jedem weiteren Parameter steigt die Rechenzeit an. Besonders kritisch ist das beim Einsatz der Suchoption SIZE<\/b>, die auch die Größe der Dateien ermittelt. Das übernimmt im Klassenmodul nämlich nicht Everything<\/b> selbst, sondern eine Hilfsfunktion. Würden Sie als Suchausdruck etwa *.* <\/b>angeben, so müsste für alle zwei Millionen im System gefundenen Dateien deren Größe ermittelt werden – vorausgesetzt, Sie hätten für ResultLimit<\/b> einen entsprechenden Wert angegeben.<\/p>\n Abgesehen davon, dass ein Array mit 2 Millionen Werten wohl den Speicher von VBA sprengen würde, dürfte die Ermittlung dieser Dateigrößen locker eine Stunde benötigen. Ausprobiert haben wir das nicht.<\/p>\n ResultLimit<\/b> ist übrigens auf 100.000<\/b> voreingestellt, wenn Sie die Eigenschaft nicht selbst setzen. Trotz der Performance von Everything<\/b> kann die Ermittlung des Ergebnisses, je nach Situation, etwas dauern, weshalb es sich im Zweifel gut macht, vor dem Aufruf von Search<\/b> ein DoCmd.Hourglass True<\/b> abzusetzen, um die Sanduhr erscheinen zu lassen.<\/p>\n Die Hauptaufgabe des Moduls ist die übersetzung der C-Header<\/b> von Everything<\/b> nach VBA. Im Kopf finden Sie deshalb eine Menge von Konstantendefinitionen und API-Deklarationen. Die werden dann von den Prozeduren des Moduls verwendet. Außerhalb des Moduls brauchen Sie sich keine Gedanken über diese API-Deklarationen zu machen, die ja auch alle als Private<\/b> daherkommen.<\/p>\n Im Initialize<\/b>-Ereignis der Klasse (siehe Listing 2) werden einige Voreinstellungen für die Suche vorgenommen. Das Ergebnis-Limit steht auf 100.000<\/b>, die Rückgabespalten bestehen nur aus Pfad und Name der Datei, die Sortierung geschieht nach Namen, und zwischen Groß- und Kleinschreibung soll nicht unterschieden werden. Diese Einstellungen speichern die Member<\/b>-Variablen des Moduls, welche namentlich jeweils mit m_<\/b> beginnen. <\/p>\n Listing 2: Im Initialize-Ereignis werden Suchparameter voreingestellt und die everything-DLL geladen<\/span><\/b><\/p>\n Damit die API-Deklarationen greifen, muss die für die Kommunikation mit Everything verantwortliche Datei everything32.dll<\/b> geladen werden. Das muss nur einmal geschehen. GetModuleHandle<\/b> fragt ab, ob das Modul bereits im Prozessraum von Access steht. Dann ist alles ok und hMod<\/b> ist ungleich Null. Ansonsten schaut die Routine erst einmal nach, ob die everything32.dll <\/b>überhaupt im Datenbankverzeichnis liegt (CurrentProject.Path<\/b>), was die Voraussetzung für die Klasse ist. Sie können diesen Zweig natürlich modifizieren und die DLL etwa in einem anderen Verzeichnis unterbringen. Ist die Datei vorhanden, so lädt LoadLibrary<\/b> sie und speichert das erhaltene Modul-Handle<\/b> in hMod<\/b>.<\/p>\n Selbst dann, wenn die DLL geladen ist, muss zusätzlich überprüft werden, ob das Anwendungsfenster von Everything<\/b> schon aufgebaut ist. über dieses Fenster geschieht nämlich die Kommunikation in Form von IPC-Messages<\/b>. Sichtbar muss es dazu allerdings nicht sein. Es reicht, wenn Everything<\/b> als Icon im Tray<\/b> zu finden ist. Die Eigenschaft Ready<\/b> des Klassenmoduls sucht nun erst nach dem Fenster und anschließend nach dem Zustand von Everything<\/b>, welcher über die API-Funktion Everything_IsDBLoaded<\/b> abgefragt werden kann. Starten Sie Everything<\/b> etwa über das besprochene VBS-Script<\/b>, so beginnt Everything<\/b> zunächst mit der Indizierung der modifizierten Dateien des Systems, um diese änderungen in seiner Datenbank abzulegen. Das kann einige Zeit in Anspruch nehmen und erst nach Ablauf dieser gibt Everything_IsDBLoaded<\/b> einen anderen Wert aus, als Null:<\/p>\n Die ganzen Property<\/b>-Prozeduren des Moduls übernehmen im Wesentlichen die Aufgabe, die übergebenen Parameter in Member<\/b>-Variablen abzuspeichern, die dann erst beim Aufruf von Search<\/b> ausgewertet werden. Und diese Prozedur ist das Kernstück des Moduls. Deklariert ist sie so:<\/p>\n In QueryString<\/b> übergeben Sie den Suchausdruck, in ResultSet<\/b> das undimensionierte Rückgabe-Array vom Typ Variant<\/b>, und in Columns<\/b> eine String-Variable, die anschließend die Spalten des Ergebnisses enthält. Gültig ist das Ergebnis indessen nur dann, wenn die Funktion True<\/b> zurückgibt. Haben Sie etwa ShowMessages<\/b> auf False<\/b> eingestellt, dann unterbleiben Fehlermeldungen. In diesem Fall gibt nur der Rückgabewert der Funktion Aufschluss über den Erfolg der Suche.<\/p>\n In der Testprozedur von Listing 1<\/b> wird dieser Rückgabewert auch ausgewertet.<\/p>\n Search<\/b> stellt nun anhand der über die Eigenschaft ResultProperties<\/b> eingestellten Suchoptionen über die Member<\/b>-Variable m_requestprops<\/b> die Spalten des Ergebnisses zusammen:<\/p>\n Die Boolean-Variablen bExt<\/b>, bDateCr<\/b>, bDateMod<\/b> et cetera steuern den weiteren Ablauf in der Prozedur. Der Suchausdruck wird nun an Everything<\/b> übergeben:<\/p>\n QueryW<\/b> ermittelt hier, ob der übergebene Suchausdruck korrekt ist und den Spezifikationen von Everything<\/b> genügt. Nur dann steht der Rückgabewert in ret<\/b> auf 1<\/b>. Tatsächlich führt dieser Aufruf bereits zur Suche und das Ergebnis kann anschließend ausgewertet werden:<\/p>\n In cnt<\/b> steht jetzt die Zahl der ermittelten Dateien oder Ordner. Ist sie gleich 0<\/b>, so wird die Prozedur verlassen. Andernfalls fährt Sie mit der überführung der Ergebnisse in das Array ResultSet<\/b> fort:<\/p>\n Das Array wird anhand der Ergebniszahl cnt<\/b> dimensioniert. Das gilt für die zweite Dimension. Die erste bestimmt die Zahl der Spalten, die vorher in n<\/b> bei der Zusammenstellung derselben ermittelt wurde.<\/p>\n Den Dateinamen erhält die Routine nun etwa so:<\/p>\n Die String-Variable sFile<\/b> muss zuerst mit Null-Characters<\/b> gefüllt werden, wie dies häufig bei API-Funktionen erforderlich ist. Der String wird nicht direkt übergeben, sondern als Zeiger per StrPtr<\/b>. In ret<\/b> steht dann die Buchstabenzahl, die die API-Funktion errechnete. Left<\/b> schneidet die nun überflüssigen Null-Characters<\/b> ab.<\/p>\n übrigens fährt die Prozedur mit den weiteren Schritten grundsätzlich nur dann fort, wenn ret<\/b> hier auf >0<\/b> steht. Denn der Datei- oder Ordnername sind das Mindeste, was im Ergebnis auftauchen muss.<\/p>\n Soll auch das Erstelldatum abgefragt werden, so tritt dieser Zweig in Aktion:<\/p>\n Die API-Funktion füllt eine Variable FillTime<\/b> des benutzerdefinierten Typs FILETIME<\/b>, der erst mit der Hilfsfunktion APITimeToDate<\/b> im Modul in ein VBA-Datum überführt wird. Der Spaltenzähler col<\/b> erhöht sich nun.<\/p>\n Der Zeilenzähler i<\/b> wird, wie Sie sehen, jeweils den API-Funktionen von Everything<\/b> als erstes Argument übergeben. Für alle weiteren Funktionen gilt dieser Grundsatz ebenso.<\/p>\n Der Long-Wert i<\/b> ist quasi der Index auf einen Wert, den Everything<\/b> in seinem Speicher für das Suchergebnis abgelegt hatte. Nach Durchlaufen aller Werte in der Schleife auf i<\/b> ist das Rückgabe-Array ResultSet<\/b> gefüllt und die Routine kann verlassen werden.<\/p>\n Kurz sei noch auf die Hilfsfunktion eingegangen, welche die Größe der Dateien ebenfalls per API<\/b> ermittelt:<\/p>\n Warum braucht es hier eine spezielle Funktion, um die Dateigröße zu ermitteln, obwohl doch VBA mit FileLen<\/b> schon eine solche mitbringt Ganz einfach: Unter Access 32-Bit<\/b> kann FileLen<\/b> nur Long-Werte bis etwa 2 GB<\/b> speichern.<\/p>\n Bei größeren Dateien gibt es ein falschen Wert aus, der quasi durch Modulo<\/b> auf 2^32<\/b> zustande kommt. Nur die API-Funktion GetFileSizeEx<\/b> kann größere Werte abfragen, indem es sie in 8 Byte abspeichert, was dem VBA-Typ Currency<\/b> entspricht.<\/p>\n Es ist nun auch klar, warum des Ergebnis-Array von Typ Variant<\/b> sein muss: Die Elemente können jeweils vom Typ String<\/b>, Date<\/b>, Long<\/b> oder Currency<\/b> sein. Sie können nun die VBA-Funktionen Typename<\/b> oder VarType<\/b> dafür nutzen, um etwa den Datentyp zu bestimmen, der für das Abspeichern der Ergebnisse in eine Tabelle erforderlich ist.<\/p>\n Natürlich können Sie die Klasse direkt in Modulen für beliebige Zwecke verwenden. Das Beispielformular frmEverything<\/b> demonstriert aber, wie Sie die Ergebnisse in einer Tabelle unterbringen und anzeigen lassen können. Im oberen Teil des Formulars (siehe Bild 2) geben Sie in das Textfeld (Everything Filter<\/b>) den Suchausdruck ein. Mit Max. results<\/b> beschränken Sie die Zahl der Ergebnisse. Die Checkboxen können Sie einzeln aktivieren. Sie führen dazu, dass nach Klick auf OK<\/b> in der Ergebnisliste unten sich zusätzliche Spalten mit den entsprechenden Angaben einblenden. Diese Liste stellt ein Unterformular, welches über eine Abfrage auf der Tabelle tblEverything<\/b> basiert. Bild 3 zeigt das Suchergebnis für alle gefundenen JPG<\/b>-Dateien im System. Am Datensatzzähler des Unterformulars können Sie ablesen, dass dies mehr sind, als das eingestellte Limit von 50.000<\/b> erlaubt. Sie müssten diesen Wert heraufsetzen, um wirklich alle JPG<\/b>-Dateien zu ermitteln.<\/p>\n Bild 2: Nach dem Klick auf OK füllt sich die Ergebnisliste mit allen gemäß dem angegebenen Filterausdruck gefundenen Dateien.<\/span><\/b><\/p>\n Bild 3: So präsentiert sich das Formular frmEverything mit seinem Suchfeld und verschiedenen Suchoptionen initial nach dem öffnen <\/span><\/b><\/p>\n Günstiger ist es jedoch, die Ergebnismenge durch einen anderen Suchausdruck einzugrenzen, wie in Bild 4, wo nur JPG<\/b>-Dateien gefunden werden sollen, die den String stone<\/b> enthalten. Damit reduziert sich das Ergebnis auf 112<\/b> Datensätze. Hier sind übrigens die Checkboxen für DateCreated<\/b> und Size<\/b> aktiviert, wodurch sich die zusätzlichen Spalten einblenden. Das Unterformular können Sie anschließend natürlich über das Kontextmenü des Spaltenkopfs weiter nach Belieben sortieren oder filtern, wie üblich. <\/p>\n Bild 4: Sind oben bestimmte Checkboxen aktiviert, so blendet die Ergebnisliste weitere Spalten mit den gewünschten Informationen ein.<\/span><\/b><\/p>\n Den Entwurf des Formulars demonstriert Bild 5. Neben den Checkboxen und dem Textfeld enthält es für die Ergebnisliste das Unterformular sfrmResults<\/b>, welches fest an die Abfrage qry_Everything<\/b> gebunden ist.<\/p>\n Bild 5: Das Formular in der Entwurfsansicht<\/span><\/b><\/p>\n Die Tabelle tblEverything<\/b> hat den Aufbau in Bild 6. Hier sind für alle möglichen Informationen, die die Klasse clsEverything<\/b> zu einer Datei liefern kann, Datenfelder des passenden Typs vorgesehen. Sie erkennen etwa, dass die Größe einer Datei (Size<\/b>) den Datentyp Währung (Currency<\/b>) aufweist, um auch Größen jenseits der 2 GB<\/b>-Grenze anzeigen zu können. Die Tabelle wird allerdings nicht direkt als Unterformular in das Hauptformular eingebunden, sondern über eine einfache Abfrage qry_Everything<\/b>:<\/p>\n Bild 6: Entwurf der Tabelle tblEverything zur Zwischenspeicherung der Suchergebnisse für das Formular<\/span><\/b><\/p>\n Im Grundzustand erscheinen damit im Ergebnis nur die Spalten für die Dateiart, den Pfad und den Dateinamen.<\/p>\n Aufgabe des Formularmoduls ist es nun einerseits, den Suchausdruck und die Suchoptionen an eine Instanz der Klasse clsEverything<\/b> zu leiten und andererseits das Suchergebnis in die Tabelle tblEverything<\/b> abzuspeichern. Zudem muss es für die Anzeige der Spalten im Unterformular gegebenenfalls die Abfrage qry_Everything<\/b> modifizieren.<\/p>\n Die Tabelle tblEverything<\/b> wird beim Entladen des Formulars automatisch geleert. Möchten Sie ihren Inhalt dennoch einsehen, so öffnen Sie diese einfach zur Laufzeit des Formulars und nach Ausführung einer Suchanfrage im Navigationsfenster. Das könnte dann etwa so aussehen, wie in Bild 7. Hier wurden die Checkboxen für DateCreated<\/b> und Size<\/b> aktiviert, weshalb neben den Standardspalten nun auch nur diese gefüllt sind und die anderen Datenfelder leer bleiben.<\/p>\n Bild 7: Zur Laufzeit des Formulars können Sie den Inhalt der Tabelle tblEverything mit den selektiv gefüllten Spalten einsehen<\/span><\/b><\/p>\n Bei den Suchoptionen gibt es zwei, die der Erläuterung bedürfen. Run Count<\/b> wird normalerweise nur bei ausführbaren Dateien erscheinen und gibt dann aus, wie oft ein Prozess dieser von Everything<\/b> aus auf dem System ausgeführt wurde – also von seiner GUI<\/b> aus. DateLastRun<\/b> ist ebenfalls damit verknüpft und gibt aus, wann der Prozess das letzte Mal gestartet war. Die beiden Optionen werden Sie wohl selten brauchen.<\/p>\n Soweit zur Anwendung des Formulars. Die Prozeduren des Formularmoduls, welches lediglich 78 Code-Zeilen umfasst, sehen wir uns nun genauer an. Beim Laden und Entladen des Formulars laufen diese beiden Ereignisprozeduren ab:<\/p>\n Eine Objektvariable cEverything<\/b> nimmt in Form_Load<\/b> eine Instanz der Klasse clsEverything<\/b> entgegen. Die Versionsnummer des installierten Everything<\/b> wird in der Titelzeile des Formulars angezeigt. Beim Entladen (Form_Unload<\/b>) wird die Objektvariable dereferenziert und die Tabelle tblEverything<\/b> über die Execute<\/b>-Anweisung geleert. Außer diesen beiden existiert im Modul nur noch eine weitere Prozedur cmdOK_Click<\/b>, die auf den OK<\/b>-Button cmdOK<\/b> reagiert. Listing 3 zeigt diese Prozedur in leicht gekürzter Version.<\/p>\nAPI-Schnittstelle<\/h2>\n
Sub <\/span>TestEverything(Optional<\/span> ByVal Search As String<\/span> = \"mscomctl.ocx\")\r\n Dim <\/span>C As <\/span>New<\/span> clsEverything\r\n Dim <\/span>ret() As Variant<\/span>\r\n Dim <\/span>sCols As String<\/span>\r\n Dim <\/span>i As Long<\/span>, j As Long<\/span>\r\n ShellExecute 0&, \"open\", CurrentProject.Path & _\r\n \"\\starteverything.vbs\", vbNullString, CurrentProject.Path, 0&\r\n With<\/span> C\r\n If <\/span>.Ready Then<\/span>\r\n Debug.Print<\/span> .Version\r\n .CaseSensitive = False<\/span>\r\n .ResultLimit = 2000\r\n .ResultProperties = EVERYTHING_REQUEST_FULL_PATH_AND_FILE_NAME Or _\r\n EVERYTHING_REQUEST_DATE_CREATED\r\n .ShowMessages = True<\/span>\r\n .SortOrder = EVERYTHING_SORT_PATH_ASCENDING\r\n If <\/span>.Search(Search, ret, sCols) Then<\/span>\r\n Debug.Print<\/span> Replace<\/span>(sCols, \";\", vbTab)\r\n For i = 0 To UBound<\/span>(ret, 2)\r\n For j = 0 To UBound<\/span>(ret, 1)\r\n Debug.Print<\/span> ret(j, i),\r\n Next<\/span> j\r\n Debug.Print<\/span>\r\n Next<\/span> i\r\n End If<\/span>\r\n End If<\/span>\r\n End With<\/span>\r\nEnd Sub<\/span><\/pre>\nKind; Path; File; DateCreated<\/pre>\n
Klassenmodul clsEverything<\/h2>\n
Private Sub <\/span>Class_Initialize()\r\n m_sort = EVERYTHING_SORT_PATH_ASCENDING\r\n m_requestprops = EVERYTHING_REQUEST_FILE_NAME Or _\r\n EVERYTHING_REQUEST_PATH\r\n m_msg = True<\/span>\r\n m_limit = 100000\r\n m_case = False<\/span>\r\n \r\n hMod<\/span> = GetModuleHandle(\"everything32\")\r\n If <\/span>hMod<\/span> = 0 Then<\/span>\r\n If <\/span>Len<\/span>(Dir(CurrentProject.Path & \"\\everything32.dll\")) = 0 Then<\/span>\r\n MsgBox<\/span> _\r\n \"Die Datei everything32.dll muss im Datenbankverzeichnis liegen!\", _\r\n vbCr<\/span>itical, \"Everything\"\r\n Else<\/span>\r\n hMod<\/span> = LoadLibrary(CurrentProject.Path & \"\\everything32.dll\")\r\n End If<\/span>\r\n End If<\/span>\r\nEnd Sub<\/span><\/pre>\nIf <\/span>Everything_IsDBLoaded Then<\/span>\r\n Ready = True<\/span>\r\nElse<\/span>\r\n MsgBox<\/span> \"Die Everything-Datenbank ist noch nicht\" & _\r\n \"vollständig geladen. Bitte später nochmals \" & _\r\n \"versuchen.\", vbCr<\/span>itical, \"Everything\"\r\nEnd If<\/span><\/pre>\nFunction <\/span>Search( _\r\n ByVal QueryString As String<\/span>, _\r\n ResultSet() As Variant<\/span>, _\r\n ByRef Columns As String<\/span>) As Boolean<\/span><\/pre>\nColumns = \"Kind;Path;File;\" \r\nIf <\/span>(m_requestprops And REQUEST_EXTENSION) Then<\/span>\r\n bExt = True: Columns = Columns & \"Extension;\"\r\nIf <\/span>(m_requestprops And REQUEST_DATE_CREATED) Then<\/span> \r\n bDateCr = True: Columns = Columns & \"DateCreated;\"\r\nIf <\/span>(m_requestprops And REQUEST_DATE_MODIFIED) Then<\/span>\r\n bDateMod<\/span> = True: Columns = Columns & \"DateModified;\"\r\n...<\/pre>\nEverything_SetSearchW (StrPtr(QueryString))\r\nret = Everything_QueryW(1)<\/pre>\n
cnt = Everything_GetNumResults<\/pre>\n
If <\/span>cnt > 0 Then<\/span>\r\n Search = True: ReDim ResultSet(n - 1, cnt - 1)\r\n For i = 0 To cnt - 1\r\n (...)\r\n Next<\/span> i\r\nEnd If<\/span><\/pre>\nsFile = String(260, 0)\r\nret = Everything_GetResultFullPathNameW( _\r\n i, StrPtr(sFile), 260&)\r\nIf <\/span>ret > 0 Then<\/span> sFile = Left<\/span>(sFile, ret)<\/pre>\nIf <\/span>bDateCr Then<\/span>\r\n ret = Everything_GetResultDateCreated(i, FilTime)\r\n If <\/span>ret <> 0 Then<\/span>\r\n ResultSet(col, i) = APITimeToDate(FilTime)\r\n End If<\/span>\r\n col = col + 1\r\nEnd If<\/span><\/pre>\nFunction <\/span>FileSize(ByVal sFilePath As String<\/span>) As Currency<\/span>\r\n Dim <\/span>hFile As Long<\/span>, nSize As Currency<\/span>\r\n \r\n hFile = CreateFile(sFilePath, &H80000000, 1&, _\r\n ByVal 0&, 3&, ByVal 0&, ByVal 0&)\r\n If <\/span>hFile <> 0 Then<\/span>\r\n GetFileSizeEx hFile, nSize\r\n CloseHandle hFile\r\n FileSize = nSize * 10000\r\n End If<\/span>\r\nEnd Function<\/span><\/pre>\nBeispielformular für den Einsatz des Klassenmoduls<\/h2>\n
![\"Nach](\"..\/fileadmin\/_temp_\/2018_04\/frmEverything2.png\")
<\/p>\n![\"So](\"..\/fileadmin\/_temp_\/2018_04\/frmEverything1.png\")
<\/p>\n![\"Sind](\"..\/fileadmin\/_temp_\/2018_04\/frmEverything3.png\")
<\/p>\n![\"Das](\"..\/fileadmin\/_temp_\/2018_04\/frmEverythingDS.png\")
<\/p>\n![\"Entwurf](\"..\/fileadmin\/_temp_\/2018_04\/tblEverythingDS.png\")
<\/p>\nSELECT Kind, Path, File FROM tblEverything<\/pre>\n
![\"Zur](\"..\/fileadmin\/_temp_\/2018_04\/tblEverythingRT.png\")
<\/p>\nPrivate <\/span>cEverything As <\/span>clsEverything\r\nPrivate Sub <\/span>Form_Load()\r\n Set<\/span> cEverything = New<\/span> clsEverything\r\n Me.Caption = \"Everything V \" & cEverything.Version\r\nEnd Sub<\/span>\r\nPrivate Sub <\/span>Form_Unload(Cancel As Integer<\/span>)\r\n Set<\/span> cEverything = Nothing\r\n CurrentDb.Execute \"DELETE FROM tblEverything\"\r\nEnd Sub<\/span><\/pre>\nPrivate Sub <\/span>cmdOK_Click()\r\n Dim <\/span>arrRet() As Variant<\/span>, sCols As String<\/span>, arrCols() As String<\/span>\r\n Dim <\/span>sSQL As String<\/span>\r\n Dim <\/span>i As Long<\/span>, j As Long<\/span>\r\n Dim <\/span>lRequest As <\/span>eEVERYTHING_REQUEST\r\n Dim <\/span>qdf As <\/span>QueryDef, rs As <\/span>DAO.Recordset\r\n \r\n On Error GoTo<\/span> Fehler\r\n With<\/span> cEverything\r\n If <\/span>.Ready Then<\/span>\r\n .CaseSensitive = Me!chkSensitive.Value\r\n .ResultLimit = CLng(Me!txtMax.Value)\r\n lRequest = EVERYTHING_REQUEST_FILE_NAME Or EVERYTHING_REQUEST_PATH\r\n If <\/span>Me!chkAttr.Value = True<\/span> Then<\/span> lRequest = lRequest Or EVERYTHING_REQUEST_ATTRIBUTES\r\n (...)\r\n If <\/span>Me!chkSize.Value = True<\/span> Then<\/span> lRequest = lRequest Or EVERYTHING_REQUEST_SIZE\r\n .ResultProperties = lRequest\r\n .SortOrder = EVERYTHING_SORT_PATH_ASCENDING\r\n DoCmd.Hourglass True: DoEvents\r\n If <\/span>.Search(Nz(Me!txtQuery.Value), arrRet, sCols) Then<\/span>\r\n sCols = Left<\/span>(sCols, Len<\/span>(sCols) - 1)\r\n arrCols = Split<\/span>(sCols, \";\")\r\n \r\n Set<\/span> qdf = CurrentDb.QueryDefs(\"qry_Everything\")\r\n qdf.SQL = \"SELECT \" & Replace<\/span>(sCols, \";\", \",\") & \" FROM tblEverything\"\r\n CurrentDb.Execute \"DELETE FROM tblEverything\"\r\n Set<\/span> rs = CurrentDb.OpenRecordset(\"SELECT * FROM tblEverything\", dbOpenDynaset)\r\n For i = 0 To UBound<\/span>(arrRet, 2)\r\n rs.AddNew<\/span>\r\n For j = 0 To UBound<\/span>(arrCols)\r\n rs.Fields(arrCols(j)).Value = arrRet(j, i)\r\n Next<\/span> j\r\n rs.Update\r\n Next<\/span> i\r\n rs.Close\r\n Me!sfrmResults.SourceObject = \"Query.qry_Everything\": Me!sfrmResults.Requery\r\n End If<\/span>\r\n DoCmd.Hourglass False<\/span>\r\n End If<\/span>\r\n End With<\/span>\r\n Exit Sub<\/span>\r\n \r\nFehler:\r\n DoCmd.Hourglass