<\/p>\n
Unter VBA musste man schon einigen Zusatzcode inklusive Api-Deklarationen zu seinem Projekt hinzufügen, um Dialoge etwa zum Auswählen einer zu öffnenden Datei, eines Verzeichnisses oder zur Angabe eines Dateinamens zum Speichern anzuzeigen. Unter .NET gibt es dazu natürlich eine vorgefertigte Klasse, die alle notwendigen Funktionen liefert. Der vorliegende Artikel zeigt, wie Sie diese Dialoge anzeigen und die damit ermittelten Daten nutzen können.<\/b><\/p>\n
Die folgenden Beispiele verwenden eine WPF-Anwendung unter C#.<\/p>\n
Unter VBA gibt es verschiedene Varianten, um beispielsweise einen Datei öffnen<\/b>-Dialog anzuzeigen. Per API, über die versteckte Wizhook-Klasse oder auch mit der entsprechenden Klasse der Office-Bibliothek. Alle Lösungen hatten Vor- und Nachteile, aber wirklich perfekt war keine davon.<\/p>\n
Unter .NET und in unserem Fall unter C# gibt es eine Klasse namens OpenFileDialog<\/b>. Diese ist Bestandteil des Namespaces Microsoft.Win32<\/b>, den Sie der Klasse per using<\/b>-Anweisung bekannt machen:<\/p>\n Danach können Sie bereits auf die OpenFileDialog<\/b>-Klasse zugreifen. Dazu legen wir ein WPF-Formular an, das wie in Bild 1 aussieht. Das Textfeld heißt txtDateiname<\/b>, die Schaltfläche btnDateiAuswaehlen<\/b>. Für die Schaltfläche hinterlegen wir die folgende Ereignisprozedur:<\/p>\n Bild 1: Entwurf des Fensters zum Auswählen einer Datei<\/span><\/b><\/p>\n Diese erstellt zunächst ein neues Objekt auf Basis der Klasse OpenFileDialog<\/b>. Im folgenden Schritt rufen wir den Datei öffnen<\/b>-Dialog mit der Funktion ShowDialog <\/b>auf. Diese zeigt den Datei öffnen<\/b>-Dialog an und erwartet die Eingabe des Benutzers (siehe Bild 2). Die Funktion liefert als Ergebnis einen Boolean-Wert zurück, den die if<\/b>-Anweisung auswertet. Lautet das Ergebnis true<\/b>, hat der Benutzer eine Datei ausgewählt und wir können diese über die Eigenschaft FileName <\/b>des OpenFileDialog<\/b>-Objekts auslesen und als Text des Textfeldes txtDateiname <\/b>eintragen.<\/p>\n Bild 2: Ein einfacher Datei öffnen-Dialog<\/span><\/b><\/p>\n Den Wert false <\/b>liefert die Funktion nur dann zurück, wenn der Benutzer den Dialog mit der Schließen<\/b>-Schaltfläche oben rechts oder mit der Abbrechen<\/b>-Schaltfläche unten rechts beendet.<\/p>\n Die Klasse besitzt natürlich einige Eigenschaften, mit denen Sie das Aussehen des Dialogs und auch seine Funktion beeinflussen können. Hier ist eine Liste der wichtigsten Eigenschaften samt Kurzbeschreibung – weiter unten schauen wir uns Beispiele zu den wichtigsten Eigenschaften an:<\/p>\n Wenn Sie mit der OpenFileDialog<\/b>-Klasse nicht nur eine, sondern gegebenenfalls auch einmal mehrere Dateien gleichzeitig ermitteln möchten, bedarf es nur weniger Änderungen (siehe Listing 1). Dazu stellen Sie zunächst einmal den Wert der Eigenschaft MultiSelect <\/b>der Objektvariablen openFileDialog <\/b>auf den Wert true <\/b>ein. Danach zeigen Sie den Dialog wie gewohnt mit der Methode ShowDialog <\/b>an.<\/p>\n Listing 1: Einlesen mehrerer Dateinamen per OpenFileDialog<\/span><\/b><\/p>\n Hat der Benutzer die gewünschten Dateien ausgewählt und die Öffnen<\/b>-Schaltfläche betätigt (siehe Bild 3), gehen wir allerdings etwas anders vor als bei einer einzigen Datei. In diesem Fall soll die Methode nämlich eine foreach<\/b>-Schleife über alle string<\/b>-Objekte der Auflistung FileNames <\/b>des OpenFileDialog<\/b>-Objekts durchlaufen. Innerhalb der Schleife fügt die Methode der Auflistung Items <\/b>des Listenfeldes namens lstDateinamen <\/b>einen neuen Eintrag mit der Add<\/b>-Methode hinzu.<\/p>\n Bild 3: Markieren mehrerer Dateien gleichzeitig<\/span><\/b><\/p>\n Das Ergebnis sieht wie in Bild 4 aus. Der Methode haben wir noch eine weitere Anweisung hinzugefügt, welche den Wert der Eigenschaft FileName <\/b>in das Textfeld txtDateiname <\/b>einträgt. Damit zeigen wir, dass auch bei der Einstellung MultiSelect = true <\/b>der erste Eintrag über die FileName<\/b>-Eigenschaft ermittelt werden kann.<\/p>\n Bild 4: Anzeige der Dateien im Listenfeld<\/span><\/b><\/p>\n Wenn wir schon Dateien auswählen, können wir deren Inhalt auch direkt einmal in ein Textfeld einlesen – zumindest, wenn es sich um eine Textdatei handelt.<\/p>\n Dazu verwenden wir die Schaltfläche btnDateiEinlesen<\/b>, welche die Methode aus Listing 2 auslöst. Wir wollen an dieser Stelle gleich ein Beispiel für einen Filter liefern. Der Öffnen<\/b>-Dialog soll entweder nur Dateien mit der Dateiendung .txt<\/b>, mit der Endung .xml <\/b>oder alle Dateien anzeigen (*.*<\/b>) – siehe Bild 5. Dazu geben wir der Eigenschaft Filter <\/b>einen entsprechenden Ausdruck mit und stellen den zu Beginn anzuzeigenden Filtereintrag mit der Eigenschaft FilterIndex <\/b>ein.<\/p>\n Bild 5: Einlesen von Text- oder XML-Dateien per Filter<\/span><\/b><\/p>\n Nach dem Anzeigen des Öffnen<\/b>-Dialogs und der Auswahl der Datei speichert die Methode den Dateinamen in der Variablen dateiname<\/b>. Dann erstellt sie ein neues Objekt des Typs StreamReader <\/b>und übergibt dem Konstruktor den Dateinamen. Die Methode ReadToEnd <\/b>ermittelt schließlich den Inhalt der Textdatei und trägt diesen in das Textfeld txtDateiinhalt <\/b>ein. Der Dateiname landet schließlich noch im Textfeld txtDateiname<\/b>. Das Ergebnis sieht dann wie in Bild 6 aus.<\/p>\n Bild 6: Das Beispielformular nach dem Einlesen einer XML-Datei<\/span><\/b><\/p>\n Die Klasse OpenFileDialog <\/b>bietet auch ein Ereignis an, das Sie implementieren können. Dazu legen wir eine neue Schaltfläche namens btnEreignisFileOk <\/b>an. Die dadurch ausgelöste Methode finden Sie in Listing 3. Diese zeigt wieder ein OpenFileDialog<\/b>-Fenster an. Diesmal fügt sie jedoch der Eigenschaft FileOk <\/b>den Namen der auszulösenden Methode hinzu, nämlich OpenFileDialog1_FileOk<\/b>. Dazu verwenden wir den +=<\/b>-Operator. Nach der Eingabe dieses Operators bietet Visual Studio an, per Tabulator<\/b>-Taste automatisch den Wert OpenFileDialog1_FileOk <\/b>hinzuzufügen und die entsprechende Ereignis-Methode anzulegen, was wir dankend annehmen. Damit wir diese für das Objekt OpenFileDialog1 <\/b>implementieren können, müssen wir die entsprechende Objektvariable diesmal außerhalb der Methode deklarieren, welche die Ereigniseigenschaft füllt:<\/p>\n Listing 3: Anzeigen eines OpenFileDialog-Dialogs, der eine Ereignisprozedur auslösen soll<\/span><\/b><\/p>\n Die beim Anklicken der Schaltfläche Öffnen <\/b>des Öffnen<\/b>-Dialogs ausgelöste Methode OpenFileDialog1_FileOk <\/b>sieht dann wie folgt aus:<\/p>\n Sie soll lediglich zum entsprechenden Zeitpunkt ein Meldungsfenster einblenden, welches den Namen der gewählten Datei ausgibt.<\/p>\n Für das CustomPlaces<\/b>-Objekt können Sie mit der Add<\/b>-Methode zusätzliche Ordner in der Art hinzufügen, wie es mit den Favoriten-Ordnern geschieht. Die folgenden drei Anweisungen zeigen, wie dies gelingt:<\/p>\n Bild 7 zeigt, wie ein um alle zusätzlichen Ordner erweitertes Datei öffnen<\/b>-Fenster aussieht. Die möglichen Optionen finden Sie hier:<\/p>\n Bild 7: Per CustomPlaces hinzugefügte Ordner<\/span><\/b><\/p>\n Auf ähnliche Art können Sie auch selbst definierte Ordner im Datei öffnen<\/b>-Dialog anbieten, wie in der durch die Schaltfläche btnBenutzerdefinierteOrdner<\/b> ausgelösten Methode aus Listing 4.<\/p>\n Listing 4: OpenFileDialog-Fenster mit einem benutzerdefinierten Ordner anzeigen<\/span><\/b><\/p>\n Dazu erstellen Sie zunächst ein neues Objekt des Typs FileDialogCustomPlace <\/b>und speichern den Verweis in einer Variablen namens customPlace<\/b>.<\/p>\n Als Parameter für den Konstruktor übergeben Sie dabei die Angabe des Verzeichnisses, das angezeigt werden soll. Schließlich hängen Sie das customPlace<\/b>-Objekt mit der Add<\/b>-Methode an die Auflistung CustomPlaces <\/b>des OpenFileDialog<\/b>-Objekts an.<\/p>\n Das Ergebnis sehen Sie in Bild 8. Der neue Ordner ist unter dem Eintrag vshost32.exe <\/b>abgelegt. Dies ist der Name der Datei, welche den Ordner hinzugefügt hat, in diesem Fall beim Debuggen. Wenn Sie die Anwendung später über das Erstellen-Menü erstellen, erscheint dort der Name der jeweiligen .exe<\/b>-Datei.<\/p>\n Bild 8: Benutzerdefinierter Ordner<\/span><\/b><\/p>\n Der mit der Klasse OpenFileDialog <\/b>hervorgerufene Dialog erwartet in der Regel die Auswahl einer vorhandenen Datei. Gelegentlich möchten Sie aber vielleicht auch mal einen Dialog zum Ermitteln einer zu speichernden Datei anzeigen. Auch dafür liefert die Win32<\/b>-Bibliothek eine entsprechende Klasse namens SaveFileDialog<\/b>. Die Vorgehensweise ist in den meisten Fällen ähnlich wie bei der OpenFileDialog<\/b>-Klasse – mit dem Unterschied, dass Sie eine andere Klasse verwenden. ShowDialog <\/b>blendet den Speichern unter<\/b>-Dialog ein, die FileName<\/b>-Eigenschaft liefert den Namen der ausgewählten oder eingegebenen Datei:<\/p>\n Es gibt lediglich einige speziell für die SaveFileDialog<\/b>-Klasse vorgesehene Eigenschaften:<\/p>\n Wenn der Benutzer nicht vorhandene Dateien als Zielort für einen Speichervorgang angibt, können Sie mit der Eigenschaft CreatePrompt<\/b> festlegen, dass eine entsprechende Meldung angezeigt wird (siehe Bild 9). Dazu stellen Sie die Eigenschaft auf den Wert true <\/b>ein:<\/p>\n Bild 9: Rückfrage, ob eine noch nicht vorhandene Datei erstellt werden soll<\/span><\/b><\/p>\n Für den Fall, dass der Benutzer keine Dateierweiterung angibt, können Sie eine Standarddateierweiterung angeben. Diese legen Sie mit der Eigenschaft DefaultExt <\/b>fest. Außerdem stellen Sie die Eigenschaft AddExtension <\/b>auf den Wert true <\/b>ein:<\/p>\n Fehlt noch ein Dialog, mit dem Sie einen Ordner auswählen können. Diesen benötigen Sie beispielsweise, wenn Sie eine Reihe von Dateien von A nach B kopieren wollen oder Ihre Anwendung eine oder mehrere Dateien erzeugt und diese unter fest vorgegebenen Namen in einem vom Benutzer gewählten Verzeichnis landen sollen. Dazu können wir leider nicht die gleiche Bibliothek verwenden, aus der wir auch die beiden Klassen OpenFileDialog <\/b>und SaveFileDialog <\/b>genutzt haben. Stattdessen nehmen wir hier die Bibliothek System.Windows.Forms <\/b>zuhilfe. Diese liefert die Klasse FolderBrowserDialog<\/b>, die Sie wie üblich deklarieren und instanzieren (siehe Listing 5).<\/p>\n Listing 5: Dialog zur Auswahl von Verzeichnissen anzeigen<\/span><\/b><\/p>\n Die Klasse bietet die Methode ShowDialog<\/b> an, mit der Sie den Ordner suchen<\/b>-Dialog aus Bild 10 anzeigen. Diese liefert allerdings keinen Boolean<\/b>-Wert als Antwort, sondern eine Konstante des Typs DialogResult<\/b>. In diesem Fall wollen wir das gewählte Verzeichnis im Textfeld txtDateiname <\/b>anzeigen, wenn der Benutzer die Schaltfläche OK <\/b>betätigt hat, was der Konstanten DialogResult.OK <\/b>entspricht.<\/p>\n Bild 10: Ordner suchen-Dialog aufrufen<\/span><\/b><\/p>\n Die Verweise auf die Objekte der Bibliothek System.Windows.Forms <\/b>haben wir diesmal nicht mit der using<\/b>-Anweisung vereinfacht. Dies hätte zu einem Fehler geführt, weil dann sowohl System.Windows.Forms <\/b>als auch Microsoft.Win32 <\/b>die Klassen OpenFileDialog <\/b>und SaveFileDialog <\/b>bereitgestellt hätten. Um dies zu verhindern, könnten Sie auch die folgende Variante der using<\/b>-Direktive nutzen – und zwar zusätzlich zu den bereits vorhandenen using<\/b>-Direktiven:<\/p>\n Damit haben Sie die drei Dialoge zum Öffnen und Speichern von Dateien sowie zum Auswählen von Verzeichnissen kennen gelernt. Diese können Sie nun leicht in eigenen Anwendungen einsetzen.<\/p>\n Im Gegensatz zu VBA stehen die entsprechenden Objekte erfreulicherweise bereits in den einzubindenden Bibliotheken bereit, eine direkte DLL-Nutzung ist so nicht mehr nötig.<\/p>\n","protected":false},"excerpt":{"rendered":" Unter VBA musste man schon einigen Zusatzcode inklusive Api-Deklarationen zu seinem Projekt hinzufügen, um Dialoge etwa zum Auswählen einer zu öffnenden Datei, eines Verzeichnisses oder zur Angabe eines Dateinamens zum Speichern anzuzeigen. Unter .NET gibt es dazu natürlich eine vorgefertigte Klasse, die alle notwendigen Funktionen liefert. Der vorliegende Artikel zeigt, wie Sie diese Dialoge anzeigen und die damit ermittelten Daten nutzen können.<\/p>\n","protected":false},"author":1,"featured_media":0,"comment_status":"open","ping_status":"open","sticky":false,"template":"","format":"standard","meta":{"om_disable_all_campaigns":false,"_monsterinsights_skip_tracking":false,"_monsterinsights_sitenote_active":false,"_monsterinsights_sitenote_note":"","_monsterinsights_sitenote_category":0,"_uf_show_specific_survey":0,"_uf_disable_surveys":false,"footnotes":""},"categories":[66012016,662016,44000002,44000001,44000027],"tags":[],"yst_prominent_words":[66062023,66062051,66062047,66062079,66062053,66062096],"class_list":["post-55000021","post","type-post","status-publish","format-standard","hentry","category-66012016","category-662016","category-Benutzeroberflaeche_mit_WPF","category-CGrundlagen","category-Excel_programmieren"],"aioseo_notices":[],"_links":{"self":[{"href":"https:\/\/vbentwickler.de\/data\/wp\/v2\/posts\/55000021","targetHints":{"allow":["GET"]}}],"collection":[{"href":"https:\/\/vbentwickler.de\/data\/wp\/v2\/posts"}],"about":[{"href":"https:\/\/vbentwickler.de\/data\/wp\/v2\/types\/post"}],"author":[{"embeddable":true,"href":"https:\/\/vbentwickler.de\/data\/wp\/v2\/users\/1"}],"replies":[{"embeddable":true,"href":"https:\/\/vbentwickler.de\/data\/wp\/v2\/comments?post=55000021"}],"version-history":[{"count":0,"href":"https:\/\/vbentwickler.de\/data\/wp\/v2\/posts\/55000021\/revisions"}],"wp:attachment":[{"href":"https:\/\/vbentwickler.de\/data\/wp\/v2\/media?parent=55000021"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/vbentwickler.de\/data\/wp\/v2\/categories?post=55000021"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/vbentwickler.de\/data\/wp\/v2\/tags?post=55000021"},{"taxonomy":"yst_prominent_words","embeddable":true,"href":"https:\/\/vbentwickler.de\/data\/wp\/v2\/yst_prominent_words?post=55000021"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}using Microsoft.Win32;<\/pre>\n
![\"Entwurf](\"..\/fileadmin\/_temp_\/2016_01\/pic_21_002.png\")
<\/p>\nprivate void btnDateiAuswaehlen_Click(object sender, \r\n RoutedEventArgs e) {\r\n OpenFileDialog openFileDialog = new OpenFileDialog();\r\n if (openFileDialog.ShowDialog()== true) {\r\n txtDateiname.Text = openFileDialog.FileName;\r\n }\r\n}<\/pre>\n![\"Ein](\"..\/fileadmin\/_temp_\/2016_01\/pic_21_001.png\")
<\/p>\nEigenschaften des OpenFileDialog-Objekts<\/h2>\n
\n
Mehrere Dateien ermitteln<\/h2>\n
private void btnDateienAuswaehlen_Click(object sender, RoutedEventArgs e) {\r\n OpenFileDialog openFileDialog = new OpenFileDialog();\r\n openFileDialog.InitialDirectory = AppDomain.CurrentDomain.BaseDirectory;\r\n openFileDialog.Multiselect = true;\r\n if (openFileDialog.ShowDialog() == true) {\r\n foreach(string filename in openFileDialog.FileNames) {\r\n lstDateinamen.Items.Add(filename);\r\n }\r\n txtDateiname.Text = openFileDialog.FileName;\r\n }\r\n}<\/pre>\n![\"Markieren](\"..\/fileadmin\/_temp_\/2016_01\/pic_21_004.png\")
<\/p>\n![\"Anzeige](\"..\/fileadmin\/_temp_\/2016_01\/pic_21_005.png\")
<\/p>\nTextdatei einlesen<\/h2>\n
![\"Einlesen](\"..\/fileadmin\/_temp_\/2016_01\/pic_21_006.png\")
<\/p>\n![\"Das](\"..\/fileadmin\/_temp_\/2016_01\/pic_21_007.png\")
<\/p>\nEreignis nach Auswahl auslösen<\/h2>\n
private void btnEreignisFileOK_Click(object sender, RoutedEventArgs e) {\r\n openFileDialog1 = new OpenFileDialog();\r\n openFileDialog1.FileOk += OpenFileDialog1_FileOk;\r\n if (openFileDialog1.ShowDialog() == true) {\r\n txtDateiname.Text = openFileDialog1.FileName;\r\n }\r\n}<\/pre>\nstatic OpenFileDialog openFileDialog1;<\/pre>\n
private void OpenFileDialog1_FileOk(object sender, \r\n CancelEventArgs e) {\r\n MessageBox.Show(\"Markierte Datei: \" + \r\n openFileDialog1.FileName);\r\n}<\/pre>\nZusätzliche Ordner: CustomPlaces<\/h2>\n
...\r\nopenFileDialog.CustomPlaces.Add(\r\n FileDialogCustomPlaces.Cookies);\r\nopenFileDialog.CustomPlaces.Add(\r\n FileDialogCustomPlaces.Desktop);\r\nopenFileDialog.CustomPlaces.Add(\r\n FileDialogCustomPlaces.SendTo);\r\n...<\/pre>\n
![\"Per](\"..\/fileadmin\/_temp_\/2016_01\/pic_21_003.png\")
<\/p>\n\n
Benutzerdefinierte Ordner hinzufügen<\/h2>\n
private void btnBenutzerdefinierteOrdner_Click(object sender, RoutedEventArgs e) {\r\n OpenFileDialog openFileDialog = new OpenFileDialog();\r\n string verzeichnis = @\"c:\\Windows\\System32\";\r\n FileDialogCustomPlace customPlace = new FileDialogCustomPlace(verzeichnis);\r\n openFileDialog.CustomPlaces.Add(customPlace);\r\n if (openFileDialog.ShowDialog() == true) {\r\n txtDateiname.Text = openFileDialog.FileName;\r\n }\r\n}<\/pre>\n![\"Benutzerdefinierter](\"..\/fileadmin\/_temp_\/2016_01\/pic_21_008.png\")
<\/p>\nSaveFileDialog<\/h2>\n
private void btnDateiSpeichern_Click(object sender, \r\n RoutedEventArgs e) {\r\n SaveFileDialog saveFileDialog = new SaveFileDialog();\r\n if (saveFileDialog.ShowDialog() == true) {\r\n this.txtDateiname.Text = saveFileDialog.FileName;\r\n }\r\n}<\/pre>\n\n
Rückfrage, ob die Datei angelegt werden soll<\/h2>\n
![\"Rückfrage,](\"..\/fileadmin\/_temp_\/2016_01\/pic_21_009.png\")
<\/p>\nsaveFileDialog.CreatePrompt = true;<\/pre>\n
Automatische Dateierweiterung<\/h2>\n
saveFileDialog.DefaultExt = \".txt\";\r\nsaveFileDialog.AddExtension = true;<\/pre>\n
Ordner auswählen<\/h2>\n
private void btnVerzeichnisAuswaehlen_Click(object sender, RoutedEventArgs e) {\r\n System.Windows.Forms.FolderBrowserDialog folderBrowserDialog = new System.Windows.Forms.FolderBrowserDialog();\r\n if (folderBrowserDialog.ShowDialog() == System.Windows.Forms.DialogResult.OK) {\r\n this.txtDateiname.Text = folderBrowserDialog.SelectedPath;\r\n }\r\n}<\/pre>\n![\"Ordner](\"..\/fileadmin\/_temp_\/2016_01\/pic_21_010.png\")
<\/p>\nusing OpenFileDialog = Microsoft.Win32.OpenFileDialog;\r\nusing SaveFileDialog = Microsoft.Win32.SaveFileDialog;\r\nusing FolderBrowserDialog = \r\n System.Windows.Forms.FolderBrowserDialog;<\/pre>\n
Zusammenfassung und Ausblick<\/h2>\n