[TUTORIAL] Programmiere deinen eigenen Downloadmanager mit WPF

In diesem Programmieren lernen Tutorial programmierst du deinen eigenen Downloadmanager. Er wird parallele Downloads unterstützen, die heruntergeladenen Dateien im Windowsexplorer anzeigen und auch löschen können. Am Ende kannst du deiner Phantasie freien Lauf lassen und aus der vorgegebenen Basis einen ausgereiften Downloadmanager mit beliebigen Zusatzfunktionen Programmieren.

GUI WPF Download Manager

Wenn du noch nicht weißt was Schleifen, Variablen, Switch Case Anweisungen, Stringverarbeitung, Datentypen, Arrays und Vergleichsoperatoren sind dann hole das doch bitte erst einmal nach, sonst wirst du in diesem Tutorial nicht viel verstehen.

Inhalt

Um hier den Umfang nicht zu sprengen, gehe ich in dem folgenden Tutorial nicht auf jede einzelne Zeile Code ein. Wenn Fragen dazu bestehen sollten, stelle diese doch einfach unten in den Kommentaren. Außerdem ist der Quellcode auch noch zusätzlich mit Kommentaren versehen, die du in diesem Beitrag selbst nicht findest, also einfach mal herunterladen und loslegen.

Was ist WPF?

Die Windows Presentation Foundation, nachfolgend als WPF bezeichnet, wurde im Jahre 2006 mit der Version 3.0 des .NET Frameworks veröffentlicht. Die WPF ist im Grunde eine Art Nachfolger der Windows Forms API.  Es ist also eine moderne Methode um Windows Applikationen mit graphischer Benutzeroberfläche auf Basis des .NET Frameworks zu erstellen.

WPF Eigenschaften

  • Die Benutzeroberfläche wird mit XAML (extensible application markup language), einer XML ähnelnden Sprache erstellt. Das ermöglicht eine Trennung vom Design der Benutzeroberfläche und der eigentlichen Logik des Programms
  • Die Unterstützung von Grafiken wurde verbessert und die Grafikkarte statt der CPU wird für das Berechnen von Grafiken verwendet
  • Es wird eine zweiseitige Datenbindung von Steuerelementen unterstützt. Dies ist ein besonderer Vorteil gegenüber Windows Forms, muss man dort jedes Mal mit Events arbeiten und die Controls direkt ansteuern
  • WPF Anwendungen können auch im Browser dargestellt werden
  • Durch die vektorbasierte Ausgabe funktioniert das Skalieren besser, bzw. die Grafiken werden nicht mehr verpixelt angezeigt

WPF Projekt erstellen

In Visual Studio gehst du über das Menu Datei – Neu – Projekt und wählst aus den Vorlagen, WPF Anwendung aus.

Visual Studio neues WPF Projekt anlegen

Und schon hast du ein neues Visual Studio Projekt von Typ WPF erstellt mit dem du jetzt beliebige Windows Anwendungen programmieren kannst.

Aufbau einer WPF Anwendung

Im mittleren Fenster bekommt man sogleich ein neues Fenster, mit dem Namen MainWindow.xaml, zu sehen. Der obere Teil ist der Designer der dem aus Windows Forms sehr ähnelt. Man kann auch hier mit der Toolbox arbeiten und per Drag und Drop Steuerelemente auf das Fenster ziehen und so eine Oberfläche designen.

WPF GUI Designer in Visual Studio

Der untere Teil des Fensters ist aber ein neuer Editor den es so in Windows Forms nicht gibt und zwar ein XAML Editor. Hier kann man mit einer XML ähnelnden Sprache die Oberfläche designen, ganz ohne .NET und auch ohne Designer.

WPF XAML Editor
WPF XAML Editor in Visual Studio

Die Dateitypen

In einem neuen WPF Projekt findet man, im Projektmappen-Explorer unter anderem die vier folgenden Dateitypen:

Dateityp Beschreibung
App.xaml Dies ist eine Datei die die XAML Sprache verwendet. Hier werden zwei Namespaces hinzugefügt. Außerdem wird ein Attribut mit dem Namen StartupUri dem Fenster zugewiesen, das nach Starten der Anwendung angezeigt werden soll.
App.xaml.cs Diese Datei ist eine so genannte Code Behind Datei zugehörig zur App.xaml. Der Code in dieser Datei wird ausgeführt sobald die Anwendung gestartet wird und das erste Fenster angezeigt wird.
MainWindow.xaml In dieser Datei wird der XAML Code zu dem Hauptfenster gespeichert.
MainWindow.xaml.cs Dies ist die so genannte Code Behind Datei zugehörig zum Hauptfenster. Hier wird der .NET Code geschrieben der direkt auf die Benutzerintaktion reagiert. Es kann zum Beispiel auf Button-Click oder viele andere Events reagiert werden.

Die Basis Oberfläche designen

Jetzt nachdem du weißt worum es sich bei WPF handelt geht es endlich los mit dem Download Manager. Dazu erstellst du bitte ein neues WPF Projekt und erstellst das folgende Fenster einfach mit der Toolbox und Drag und Drop, oder wenn du es hinbekommst, gerne auch direkt per XAML

Download Manager Benutzeroberfläche

Probiere es bitte selbst, damit du auch was lernst. Wenn du den Code benötigst, lade ihn einfach jetzt direkt am Ende dieses Beitrags runter.

Die eigentliche Logik

Als Erstes erstellst du bitte eine neue Klasse, das machst du in dem du mit der rechten Maustaste im Projektmappen-Explorer auf deinen Projektnamen (wahrscheinlich WpfApplication1) klickst und ein neues Element hinzufügst:

Neue Datei hinzufügen

In dieser Klasse kopierst du folgenden Code:

using System;	 	 

using System.ComponentModel;	 	 
using System.IO;	 	 
using System.Net;	 	 
using System.Threading;	 	 
using System.Windows;	 	 
using System.Windows.Controls;	 	 
using System.Windows.Media;	 	 

namespace WpfApplication1	 	 
{	 	 

 public class Download	 	 
 {	 	 

 public Button OpenButton { get; private set; }	 	 
 public Label FileName { get; private set; }	 	 
 public Button DeleteButton { get; private set; }	 	 
 public ProgressBar ProgressBar { get; private set; }	 	 
 public WebClient WebClient { get; private set; } 	 	 
 public Label LabelPercentage { get; private set; }	 	 
 {	 	 

 OpenButton = newOpenButton;	 	 
 FileName = fileName;	 	 
 DeleteButton = deleteButton;	 	 
 ProgressBar = progressBar;	 	 
 WebClient = webClient;	 	 
 LabelPercentage = labelPercentage;	 	 
 OpenButton.Click += buttonOpenFile_Click;	 	 
 WebClient.DownloadProgressChanged += new DownloadProgressChangedEventHandler(client_DownloadProgressChanged);	 	 
 WebClient.DownloadFileCompleted += new AsyncCompletedEventHandler(DownloadCompleted);	 	 

 }	 	 

 public void DownloadCompleted(object sender, AsyncCompletedEventArgs e)	 	 
 {	 	 

 if (e.Cancelled)	 	 
 {	 	 

 LabelPercentage.Content = "0%";	 	 
 RemoveDownloadFromGrid(); 	 	 
 }	 	 

 }	 	 

 public void RemoveDownloadFromGrid()	 	 
 {	 	 

 var grid = (Grid)VisualTreeHelper.GetParent(FileName);	 	 
 grid.Children.Remove(FileName);	 	 
 grid.Children.Remove(DeleteButton);	 	 
 grid.Children.Remove(ProgressBar);	 	 
 grid.Children.Remove(LabelPercentage);	 	 
 grid.Children.Remove(OpenButton);	 	 
 }	 	 

 public void client_DownloadProgressChanged(object sender, DownloadProgressChangedEventArgs e)	 	 
 {	 	 
 LabelPercentage.Content = e.ProgressPercentage + "%";	 	 
 ProgressBar.Value = e.ProgressPercentage;
	 	 
 }	 	 
 public void buttonDeleteClick(object sender, RoutedEventArgs e)	 	 
 {	 	 
 WebClient.CancelAsync(); 	 	 

 try	 	 
 {	 	 
 Thread.Sleep(200);	 	 
 File.Delete(FileName.Content.ToString());	 	 
 FileName.Content = "Download wurde durch den Benutzer gestoppt!";	 	 
 }	 	 

 catch (Exception ex)	 	 
 {	 	 
 MessageBox.Show("Fehler beim Löschen: " + ex.Message);	 	 
 } 	 	 
 }	 	 

 private void buttonOpenFile_Click(object sender, RoutedEventArgs e)	 	 
 {	 	 
 try	 	 
 {	 	 
 string argument = "/select, \"" + FileName.Content.ToString() + "\"";	 	 
 System.Diagnostics.Process.Start("explorer.exe", argument);	 	 
 }	 	 

 catch (Exception ex)	 	 
 {	 	 
 MessageBox.Show(ex.Message);	 	 
 } 	 	 
 }	 	 
 }	 	 
}	 	 

 

Dazu später mehr.

Als nächstes klickst du doppelt auf den Start Download Button und automatisch erstellt Visual Studio ein Event in der MainWindow.xaml.cs Datei. Der Code innerhalb dieser Methode wird aufgerufen sobald der Benutzer deiner Anwendung den Start Download Button drückt.

Bitte füge an den Anfang deiner MainWindow.xaml.cs die folgenden Using – Direktiven ein:

using Microsoft.Win32; 
using System; 
using System.Collections.Generic; 
using System.Diagnostics; 
using System.Linq; 
using System.Net; 
using System.Windows; 
using System.Windows.Controls; 
using System.Windows.Navigation;

Dies sind Verweise auf Teile des .NET Frameworks. Dadurch kann Code aus diesen Bereichen z.B. System.Net in dieser Datei verwendet werden.

Als nächstes füge nun folgenden Code in MainWindow.xaml.cs Klasse nach dem Codeabschnitt

public partial class MainWindow : Window
{

ein:

        List downloads;
        const int startHeight = 70;
        const string downloadTextBoxPlaceholder = "Enter new DownloadURL here...";
        public MainWindow()
        {
            InitializeComponent();

            textBoxDownloadPath.Text = downloadTextBoxPlaceholder;
            downloads = new List();
            ServicePointManager.DefaultConnectionLimit = 100;
        }

Der Code enthält:

  • Eine Liste in die nachher alle Downloads mit aufgenommen werden
  • Eine Konstante startHeight = 70 das ist die minimale Höhe auf der wir nachher die Position neuer Steuerelemente berechnen. Wofür neue Steuerlemente? Dir ist sicherlich aufgefallen, dass weder ein Downloadbalken noch ein Label für den Downloadfortschritt vorhanden sind. Diese werden nachträglich dynamisch erzeugt, sobald der Download beginnt.
  • Eine weitere Konstante „downloadTextBoxPlaceholde = „Enter new DownloadURL here…““ das ist der Platzhaltertext für die Textbox
  • Text = downloadTextBoxPlaceholder; hier wird der Platzhaltertext in die Textbox geschrieben
  • ServicePointManager.DefaultConnectionLimit = 100 mit dieser Option werden die im Standard auf 2 begrenzte parallele Downloads auf 100 erhöht. Das kannst du natürlich nach deinen Bedürfnissen anpassen

Als nächstes erstellst du eine neue Methode mit dem Namen „ValidateDownloadURL“. Diese dient dazu, zu überprüfen ob der Benutzer auch eine DownloadURL eingegeben hat.

        private bool ValidateDownloadURL()
        {
            string downloadPath = textBoxDownloadPath.Text;
            if (String.IsNullOrEmpty(downloadPath) || downloadPath == downloadTextBoxPlaceholder)
            {
                MessageBox.Show("Bitte erst eine gültige Download URL eingeben!");
                return false;
            }

            return true;
        }

Das ist natürlich nicht zwingend nötig um die Funktionalität zu gewährleisten, aber es kann verhindern, dass das Programm versucht den Donwnload zu starten, ohne dass eine DownloadURL eingegeben wurde.

Diese Methode rufst du jetzt aus dem Button-Click Event auf, also der Stelle im Code die angezeigt wird, wenn du doppelt auf den Start-Download Button klickst. Hierdurch wird überprüft ob in der DownloadURL Textbox text vorhanden ist und das es sich dabei nicht um den Platzhaltertext „“Enter new DownloadURL here…““ handelt. Sollte das aber doch der Fall sein beendet der return Befehl die weitere Ausführung von Code innerhalb der buttonDownload_Click Methode, der Download wird also nicht versucht auszuführen:

  
  private void buttonDownload_Click(object sender, RoutedEventArgs e)
        {
                if (!ValidateDownloadURL())
                {
                    return;
                }
        }

Der SaveFileDialog

Wenn jetzt der Downladbutton betätigt wurde, weiß das Programm noch nicht wohin der Download gespeichert und wie der Download benannt werden soll.

Hier hilft der SaveFileDialog des .NET Frameworks weiter. Hierzu erstelle am besten eine neue Methode mit der Zuständigkeit den Dateinamen zu bestimmen zum Beispiel folgendermaßen:

  
private string GetFileName()
        {
            var dialog = new SaveFileDialog();
            dialog.Filter = "ZipFiles|*.zip| WinrarFiles|*.rar|Executablefiles|*.exe|MSI Setup|*.msi| Image|*.iso" +
             "|All Files|*.*" + "|Word Documents|*.doc|Excel Worksheets|*.xls|PowerPoint Presentations|*.ppt" +
             "|Office Files|*.doc;*.xls;*.ppt";
            
            var result = dialog.ShowDialog(); 
            if (result == true)
            {
                return dialog.FileName;
            }
            else
            {
                MessageBox.Show("Download vom Benutzer abgebrochen!");
                return null;
            }
        }

Mit dem Filter kannst du die zulässigen Dateitypen bestimmen. Diese Methode rufst du aus der Start-Download Button_Click Methode auf. Du kommst dahin indem du doppelt auf den Start Download Button im Designer klickst. Der Benutzer bekommt dann mit Hilfe dieses SaveFileDialogs die Möglichkeit eine Datei auszuwählen.

Steuerelemente dynamisch zur Laufzeit erzeugen

Als nächstes erstellst du wieder eine neue Methode in der MainWindow.xaml.cs Klasse mit dem Namen CreateNewDownload. Diese Methode wird für dich unter anderem neue Steuerelemente erstellen die dann den aktuellen Download und seinen Status anzeigen:

 private Download CreateNewDownload(string fileName)
        {

            var newDownloadFileLabel = new Label { Content = fileName, HorizontalAlignment = HorizontalAlignment.Left, VerticalAlignment = VerticalAlignment.Top, Margin = new Thickness(26, startHeight * (downloads.Count + 1), 0, 0) };
            var newProgressBar = new ProgressBar { HorizontalAlignment = HorizontalAlignment.Left, Height = 17, Width = 280, VerticalAlignment = VerticalAlignment.Top, Margin = new Thickness(26, (startHeight * (downloads.Count + 1)) + 26, 0, 0) };
            var newPercentageLabel = new Label { Content = "0%", HorizontalAlignment = HorizontalAlignment.Left, VerticalAlignment = VerticalAlignment.Top, Margin = new Thickness(26, (startHeight * (downloads.Count + 1)) + 48, 0, 0) };
            var newDeleteButton = new Button { HorizontalAlignment = HorizontalAlignment.Left, VerticalAlignment = VerticalAlignment.Top, Content = "Löschen", Height = 20, Width = 52, Margin = new Thickness(380, (startHeight * (downloads.Count + 1)) + 23, 0, 0) };
            var newOpenButton = new Button { HorizontalAlignment = HorizontalAlignment.Left, VerticalAlignment = VerticalAlignment.Top, Content = "Öffnen", Height = 20, Width = 52, Margin = new Thickness(325, (startHeight * (downloads.Count + 1)) + 23, 0, 0) };
           
            newDeleteButton.Click += button_Click;
           
            grid.Children.Add(newDownloadFileLabel);
            grid.Children.Add(newProgressBar);
            grid.Children.Add(newPercentageLabel);
            grid.Children.Add(newDeleteButton);
            grid.Children.Add(newOpenButton);
           
            var client = new WebClient();
            var download = new Download(newDownloadFileLabel, newDeleteButton, newProgressBar, client, newPercentageLabel, newOpenButton);            

            return download;
        }

„new Label“ erzeugt ein neues Steuerlement vom Typ Label, also einer Beschriftung. In den geschweiften Klammern werden der Text des Labels, die Ausrichtung Horizontal und Vertikal, Größe und Position des Steuerlements definiert.

Der Bereich Margin = new Thickness(….) enthält in den Klammern auch die Variable startHeight zur Bestimmung des Abstands zum oberen Rand. Dieser Wert muss für jeden weiteren Download erhöht werden. Deshalb wird der Wert mit der Anzahl der Downloads multipliziert. So wird immer die passende Höhe ermittelt.

Das Gleiche wird danach für die ProgressBar, für die Anzeige des Downloadfortschritts, für ein weiteres Label zur Angabe des Downloadfortschritts in %, einen weitereren Button für das Löschen des Downloads und einen Button zum Öffnen des Downloadpfades, getan.

Der weitere Code ist durch die Kommentarblöcke die mit einem doppelten Slash // beginnen, erklärt die du sehen kannst wenn du meinen Sourcecode runterlädst und in Visual Studio öffnest.

Am Ende des Codeblocks wird mit:

var download = new Download(newDownloadFileLabel, newDeleteButton, newProgressBar, client, newPercentageLabel, newOpenButton);

ein neues Objekt vom Typ Download erstellt. Diesen Typ „Download“ hast du am Anfang selber in einen neuen Datei und einer neuen Klasse erstellt.

Die Download Klasse

Die Download Klasse bildet einen Download ab. Da mehrere Downloads parallel laufen können, kann es mehrere Objekte geben die diese Klasse nutzen.

Die Klasse enthält die Steuerelemente, den WebClient für den Download selbst, und Methoden die ausgeführt werden, wenn der Download beendet wurde, die Steuerelemente wieder von der Oberfläche entfernt werden, wenn der Download-Fortschritt sich verändert hat, der Löschen Button, oder der Datei öffnen Button geklickt wurde.

Um hier den Umfang nicht zu sprengen, gehe ich nicht auf jede Zeile Code ein. Wenn Fragen dazu bestehen sollten, schaue dir meine Downloadklasse in Visual Studio an, ich habe diese zusätzlich kommentiert oder stelle deine Fragen doch einfach unten in den Kommentaren.

Die Download Löschen Funktionalität

Dazu erstelle bitte folgende Methode in der MainWindow.xaml.cs:

 private Download CreateNewDownload(string fileName)
        private void button_Click(object sender, RoutedEventArgs e)
        {
            try
            {
                var downloadToDelete = downloads.Where(x => x.DeleteButton == sender).Single();

                downloadToDelete.buttonDeleteClick(sender, e);
                var removedIndex = downloads.IndexOf(downloadToDelete);

                var downloadsToMove = downloads.Skip(removedIndex + 1).Take(downloads.Count).ToList();
                MoveControlsUp(downloadsToMove);

                downloads.Remove(downloadToDelete);
            }
            catch (Exception ex)
            {
                MessageBox.Show(ex.Message);
            }
        }

Die Zeile

var downloadToDelete = downloads.Where(x => x.DeleteButton == sender).Single();

selektiert mit Hilfe von LINQ  den Download der zu dem aktuell gedrückten Button gehört. Auf diesem Button wird als nächstes die buttonDeleteClick Methode in der Download Klasse ausgeführt. Diese Methode wiederum beendet den Download, versucht die Datei auf dem Computer zu löschen und entfernt die zugehörigen Steuerelemente von der Benutzeroberfläche.

Die folgende Zeile schreibt den Index des zu löschenden Downloads, also die Stelle an der der Download in der Liste gespeichert wurde (z.B. 4) in eine neue Variable.

var removedIndex = downloads.IndexOf(downloadToDelete);

Die danach folgende Zeile wiederum ermittelt alle Downloads die einen größeren Index haben (also neuer sind) als der zu löschende Download.

var downloadsToMove = downloads.Skip(removedIndex + 1).Take(downloads.Count).ToList();

Dies ist erforderlich, denn die Steuerelemente dieser Downloads müssen schließlich alle nach oben verschoben werden, damit keine hässliche Lücke in der Oberfläche entsteht, nachdem der zu löschende Download von der Oberfläche entfernt wurde.

Position von Steuerelementen zur Laufzeit ändern

Die Methode MoveControlsUp erstellst du jetzt als nächstes in der Datei MainWindow.xaml.cs folgendermaßen:

  private void MoveControlsUp (List downloadsToMove)
        {
            foreach (var download in downloadsToMove)
            {
                download.FileName.Margin = new Thickness { Left = download.FileName.Margin.Left, Top = download.FileName.Margin.Top - startHeight, Bottom = 0, Right = 0 };
                download.DeleteButton.Margin = new Thickness { Left = download.DeleteButton.Margin.Left, Top = download.DeleteButton.Margin.Top - startHeight, Bottom = 0, Right = 0 };
                download.OpenButton.Margin = new Thickness { Left = download.OpenButton.Margin.Left, Top = download.OpenButton.Margin.Top - startHeight, Bottom = 0, Right = 0 };
                download.ProgressBar.Margin = new Thickness { Left = download.ProgressBar.Margin.Left, Top = download.ProgressBar.Margin.Top - startHeight, Bottom = 0, Right = 0 };
                download.LabelPercentage.Margin = new Thickness { Left = download.LabelPercentage.Margin.Left, Top = download.LabelPercentage.Margin.Top - startHeight, Bottom = 0, Right = 0 };
            }
        }

Hier passiert eigentlich nichts Besonderes, die Methode erwartet eine Liste von Downloads als Parameter. Diese Liste wird dann in der Schleife durchlaufen, um allen zugehörigen Steuerelementen eine neue Position zuzuweisen.

Datei im Windows Explorer anzeigen

Um die heruntergeladene Datei im Windows Explorer anzuzeigen und zu markieren hast du bereits folgende Methode in die Download Klasse eingefügt und dem ButtonClick-Event des Löschen Buttons zugewiesen:

          private void buttonOpenFile_Click(object sender, RoutedEventArgs e)
        {
            try
            {
                string argument = "/select, \"" + FileName.Content.ToString() + "\"";
                System.Diagnostics.Process.Start("explorer.exe", argument);
            }
            catch (Exception ex)
            {
                MessageBox.Show(ex.Message);
            }            
        }

Diese Methode erstellt erst ein Argument und startet dann einen Prozess, in diesem Fall den Prozess „explorer.exe“ und als Argument einen Selektierbefehl mit dem zu markierenden Dateinamen.

Downloadbutton Logik

Um den Download Button jetzt endgültig zum Leben zu rufen fehlt noch ein bisschen Code den du jetzt bitte einfügst. Klicke einfach doppelt auf den Starte Download Button und füge folgenden Code ein:

  
 private void buttonDownload_Click(object sender, RoutedEventArgs e)
        {
            Download download = null;
            try
            {
                if (!ValidateDownloadURL())
                {
                    return;
                }

                string downloadPath = textBoxDownloadPath.Text;
                string fileName = GetFileName();
                if (String.IsNullOrEmpty(fileName))
                {
                    return;
                }
                
                download = CreateNewDownload(fileName);                

                try
                {
                    //DownloadFileAsync ist der Befehl um den Download zu beginnen. Async damit während des Downloads weitergearbeitet werden kann.
                    download.WebClient.DownloadFileAsync(new Uri(downloadPath), fileName);
                    downloads.Add(download);
                }
                catch (Exception exception)
                {
                    download.buttonDeleteClick(null, null);
                    download.RemoveDownloadFromGrid();
                    MessageBox.Show(exception.Message);
                }
              
                textBoxDownloadPath.Text = downloadTextBoxPlaceholder;
            }
            catch (Exception ex)
            {
                MessageBox.Show(ex.Message);
            }
        }

Was passiert hier?

Download download = null; Es wird ein Download Objekt erzeugt und mit null initialisiert.
if (!ValidateDownloadURL()) { return; } Die DownloadURL in der Textbox wird überprüft, wenn keine angegebene wird hier abgerbochen
string downloadPath = textBoxDownloadPath.Text; Die DownloadURL wird aus der Textbox in eine Variable geschrieben
string fileName = GetFileName(); Der Dateiname wird, mit Hilfe eine Benutzereingabe, bestimmt
if (String.IsNullOrEmpty(fileName)) { return; } Wenn kein Dateiname angegeben wurde, wird der Download nicht gestartet.
download = CreateNewDownload(fileName); Das downloadobjekt wird jetzt mit Leben gefüllt
download.WebClient.DownloadFileAsync(new Uri(downloadPath), fileName); Diese Zeile startet den eigentlich Download mit Hilfe des WebClients aus dem .NET Framework. Der Download wird asynchron gestartet, das bedeutet dass während des Download gleichzeitig anderer Code ausgeführt werden kann. Hierdurch werden parallele Downloads möglich.
downloads.Add(download); Der Download wird der Downloadliste hinzugefügt
catch (Exception exception) { download.buttonDeleteClick(null, null); download.RemoveDownloadFromGrid(); MessageBox.Show(exception.Message); } Dieser Codeblock wird nur ausgeführt wenn beim Starten des Downloads ein Fehler erzeugt wurde. In diesem Fall wird der Download gelöscht, von der Oberfläche entfernt und eine Fehlermeldung zurückgegeben.
textBoxDownloadPath.Text = downloadTextBoxPlaceholder; Der Platzhaltertext wird wieder in die DownloadURL Textbox geschrieben
catch (Exception ex) { MessageBox.Show(ex.Message); } Dieser Codeblock wird ausgeführt wenn es irgendwo in dem zugeordneten Try Block zu einem Fehlerfall kam. Dem Benutzer wird dann durch MessageBox.Show eine Meldung angezeigt.

Quellcodedownload

Lade hier kostenlos den gesamten Quellocde mit zusätzlich erklärenden Kommentaren herunter

 

Außerdem empfehle ich dir folgende weiterführende Lektüre für WPF und für .NET allgemein. Möchtest du noch jede Menge zusätzlicher Beispiele dann erwerbe eines meiner Anwendungspakete, über 40 Applikationen stehen jetzt zum Download bereit.

 

Du verstehst etwas nicht, oder hast andere Fragen und Anregungen, dann nutze doch die Kommentarfunktion und dir wird geholfen 🙂

Schreibe einen Kommentar

Deine E-Mail-Adresse wird nicht veröffentlicht.