{"id":55000021,"date":"2016-02-01T00:00:00","date_gmt":"2024-04-25T16:18:20","guid":{"rendered":"http:\/\/access-im-unternehmen.aix-dev.de\/aiu\/?p=21"},"modified":"-0001-11-30T00:00:00","modified_gmt":"-0001-11-30T00:00:00","slug":"Von_VBA_zu_C_Dateidialoge","status":"publish","type":"post","link":"https:\/\/vbentwickler.de\/Von_VBA_zu_C_Dateidialoge\/","title":{"rendered":"Von VBA zu C#: Dateidialoge"},"content":{"rendered":"

\"\"<\/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

Dateien auswählen per Klasse<\/h2>\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

using Microsoft.Win32;<\/pre>\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
\"Entwurf<\/p>\n
Bild 1: Entwurf des Fensters zum Auswählen einer Datei<\/span><\/b><\/p>\n
private 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
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
\"Ein<\/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
Eigenschaften des OpenFileDialog-Objekts<\/h2>\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
    \n
  • CheckFileExists<\/b>: Boolean-Wert, der angibt, ob das Vorhandensein der gewählten Datei geprüft werden soll. Der Wert false <\/b>lässt auch die Angabe nicht vorhandener Dateien zu, der Wert true <\/b>liefert eine Meldung, wenn eine nicht vorhandene Datei gewählt wird (Standardwert: true<\/b>) <\/li>\n
  • CustomPlaces<\/b>: Spezielle Ordner zusätzlich zu den Favoriten-Ordnern anzeigen<\/li>\n
  • DereferenceLinks<\/b>: Legt fest, ob bei der Auswahl einer Dateiverknüpfung die Verknüpfung selbst zurückgegeben werden soll (in der Regel eine .lnk<\/b>-Datei) oder der Pfad zu der verknüpften Datei.<\/li>\n
  • FileName<\/b>: Liefert den Dateinamen der gewählten Datei zurück. <\/li>\n
  • FileNames<\/b>: Liefert ein Array mit den Dateinamen der gewählten Dateien zurück. Sowohl FileName <\/b>als auch FileNames <\/b>funktionieren bei der Einfachauswahl als auch bei der Mehrfachauswahl (siehe Eigenschaft MultiSelect<\/b>).<\/li>\n
  • FileOk<\/b>: Dies ist ein Ereignis, das ausgelöst wird, wenn der Benutzer die Schaltfläche Öffnen<\/b> des Datei öffnen<\/b>-Dialogs betätigt hat.<\/li>\n
  • Filter<\/b>: Erwartet einen Ausdruck, der die zu filternden Dateien angibt. Beispiel: Access-Datenbanken (*.mdb, *.accdb)|*.mdb;*.accdb|Alle Dateien (*.*)|*.*<\/b><\/li>\n
  • FilterIndex<\/b>: Legt fest, welcher Filter<\/b>-Eintrag angezeigt werden soll (1 <\/b>für den ersten Eintrag, 2 <\/b>für den zweiten und so weiter)<\/li>\n
  • InitialDirectory<\/b>: Gibt das beim Einblenden des Dialogs anzuzeigende Verzeichnis an, entweder als Zeichenkette mit führendem @-Zeichen (@”c:\\”<\/b>) oder als Ausdruck, zum Beispiel AppDomain.CurrentDomain.BaseDirectory <\/b>für das Verzeichnis der aktuellen Anwendung.<\/li>\n
  • MultiSelect<\/b>: Boolean<\/b>-Eigenschaft, die festlegt, ob nur eine (false<\/b>) oder mehrere Dateien gleichzeitig ausgewählt werden können (true<\/b>).<\/li>\n
  • SafeFileName<\/b>: Liefert den Dateinamen ohne Verzeichnis.<\/li>\n
  • SafeFileNames<\/b>: Liefert bei Mehrfachauswahl die Dateinahmen ohne Verzeichnis.<\/li>\n
  • ShowDialog<\/b>: Zeigt den Dialog an und liefert den Wert true<\/b> zurück, wenn der Benutzer den Dialog mit der Öffnen<\/b>-Schaltfläche schließt.<\/li>\n
  • Title<\/b>: Legt den Fenstertitel fest.<\/li>\n<\/ul>\n
    Mehrere Dateien ermitteln<\/h2>\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
    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
    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
    \"Markieren<\/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
    \"Anzeige<\/p>\n
    Bild 4: Anzeige der Dateien im Listenfeld<\/span><\/b><\/p>\n
    Textdatei einlesen<\/h2>\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
    \"Einlesen<\/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
    \"Das<\/p>\n
    Bild 6: Das Beispielformular nach dem Einlesen einer XML-Datei<\/span><\/b><\/p>\n
    Ereignis nach Auswahl auslösen<\/h2>\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
    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>\n
    Listing 3: Anzeigen eines OpenFileDialog-Dialogs, der eine Ereignisprozedur auslösen soll<\/span><\/b><\/p>\n
    static OpenFileDialog openFileDialog1;<\/pre>\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
    private void OpenFileDialog1_FileOk(object sender, \r\n         CancelEventArgs e) {\r\n     MessageBox.Show(\"Markierte Datei: \" + \r\n         openFileDialog1.FileName);\r\n}<\/pre>\n
    Sie soll lediglich zum entsprechenden Zeitpunkt ein Meldungsfenster einblenden, welches den Namen der gewählten Datei ausgibt.<\/p>\n
    Zusätzliche Ordner: CustomPlaces<\/h2>\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
    ...\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
    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
    \"Per<\/p>\n
    Bild 7: Per CustomPlaces hinzugefügte Ordner<\/span><\/b><\/p>\n
      \n
    • Contacts<\/b>: Kontakte-Ordner des aktuellen Benutzers<\/li>\n
    • Cookies<\/b>: Internet-Cookies des aktuellen Benutzers<\/li>\n
    • Desktop<\/b>: Desktop-Ordner des aktuellen Benutzers<\/li>\n
    • Documents<\/b>: Dokumente-Ordner<\/li>\n
    • Favorites<\/b>: Favoriten-Ordner<\/li>\n
    • LocalApplicationData<\/b>: Anwendungsdaten des aktuellen Benutzers<\/li>\n
    • Music<\/b>: Musik-Ordner<\/li>\n
    • Pictures<\/b>: Bilder-Ordner<\/li>\n
    • ProgramFiles<\/b>: Programme-Ordner<\/li>\n
    • ProgramFilesCommon<\/b>: Gemeinsame Dateien<\/li>\n
    • Programs<\/b>: Programme-Ordner des Startmenüs<\/li>\n
    • RoamingApplicationData<\/b>: Ordner \\AppData\\Roaming des aktuellen Benutzers<\/li>\n
    • SendTo<\/b>: Mögliche Ziele zum Senden von Dateien<\/li>\n
    • StartMenu<\/b>: Startmenü des aktuellen Benutzers<\/li>\n
    • Startup<\/b>: Autostart-Ordner<\/li>\n
    • System<\/b>: Systemdateien<\/li>\n
    • Templates<\/b>: Vorlagenordner<\/li>\n<\/ul>\n
      Benutzerdefinierte Ordner hinzufügen<\/h2>\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
      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
      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
      \"Benutzerdefinierter<\/p>\n
      Bild 8: Benutzerdefinierter Ordner<\/span><\/b><\/p>\n
      SaveFileDialog<\/h2>\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
      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
      Es gibt lediglich einige speziell für die SaveFileDialog<\/b>-Klasse vorgesehene Eigenschaften:<\/p>\n
        \n
      • AddExtension<\/b>: Fügt eine Dateierweiterung hinzu.<\/li>\n
      • CreatePrompt<\/b>: Fragt, ob eine noch nicht vorhandene Datei erzeugt werden soll.<\/li>\n
      • DefaultExt<\/b>: Gibt die Standarddateierweiterung an.<\/li>\n
      • CheckPathExists<\/b>: Prüft, ob der gewählte Pfad existiert.<\/li>\n<\/ul>\n
        Rückfrage, ob die Datei angelegt werden soll<\/h2>\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
        \"Rückfrage,<\/p>\n
        Bild 9: Rückfrage, ob eine noch nicht vorhandene Datei erstellt werden soll<\/span><\/b><\/p>\n
        saveFileDialog.CreatePrompt = true;<\/pre>\n
        Automatische Dateierweiterung<\/h2>\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
        saveFileDialog.DefaultExt = \".txt\";\r\nsaveFileDialog.AddExtension = true;<\/pre>\n
        Ordner auswählen<\/h2>\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
        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
        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
        \"Ordner<\/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
        using 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
        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":[],"aioseo_head":"\n\t\t\n\t\n\t\n\t\n\t\n\t\n\t\t\n\t\t\n\t\t\n\t\t\n\t\t\n\t\t\n\t\t\n\t\t\n\t\t\n\t\t\n\t\t\n\t\t\n\t\t\n\t\t\n\t\t