Escape Sequenzen

Escape Sequenzen werden in einem String genutzt um eine spezielle Funktion auszuführen oder ein sonst unerlaubtes Zeichen innerhalb einer Zeichenkette auszugeben. Dies kann zum Beispiel ein Zeilenumbruch, ein Tabstopp oder das Darstellen von Sonderzeichen sein. Die verschiedenen Programmiersprachen haben hierbei teilweise unterschiedliche Escape Sequenzen.

Eine Escape Sequenz beginnt immer mit einem Backslash „\“ gefolgt von einem oder mehreren Buchstaben oder einer Zahlenkombination.

Folgende Tabelle gibt einen Überblick über die Escape Sequenzen in C#:

Escapesequenz Repräsentiert
\a Glocke (Warnung)
\b Rücktaste
\f Seitenvorschub
\n Zeilenwechsel
\r Wagenrücklauf
\t Horizontaler Tabulator
\v Vertikaler Tabulator
\‘ Einfaches Anführungszeichen
\“ Doppeltes Anführungszeichen
\\ Umgekehrter Schrägstrich
\? Literales Fragezeichen
\ ooo ASCII-Zeichen in der Oktalnotation
\x hh ASCII-Zeichen in der Hexadezimalnotation
\x hhhh Unicode-Zeichen in der Hexadezimalnotation, wenn diese Escapesequenz in einer Konstante mit Breitzeichen oder in einem Unicode-Zeichenfolgenliteral verwendet wird.

Beispielsweise WCHAR f = L’\x4e00′ oder WCHAR b[] = L“The Chinese character for one is \x4e00″.

Quelle: Microsoft

In Java werden auch einige dieser Sequenzen unterstützt, welche kannst du in der folgenden Tabelle erkennen:

Zeichen Repräsentiert
\b Rücktaste
\n Zeilenwechsel
\f Seitenvorschub
\r Wagenrücklauf
\t Horizontaler Tabulator
\“ Doppeltes Anführungszeichen
\‘ Einfaches Anführungszeichen
\\ Backslash

Quelle: Eigene Darstellung

Nehmen wir jetzt mal folgenden Beispieltext:

„Auf der Seite:        

finde ich viele kostenlose Tutorials und Erklärungen, die mir helfen ein erfolgreicher Programmierer zu werden. Wenn ich etwas nicht direkt finde, nutze ich die Suchfunktion oder schreibe einen Kommentar unter einen Beitrag oder auf der Facebookseite

Wenn man diesen Text nun einfach in einem „Console.WriteLine(<String>);“ Befehl kopiert wird diese nicht korrekt dargestellt werden. Es fehlen die Tabstopps und die Zeilenumbrüche deshalb würde es folgendermaßen aussehen:

Quelle: Eigene Darstellung

Wenn wir den Text aber formatieren wollen, müssen folgende Escape Sequenzen genutzt werden:

Console.WriteLine("Auf der Seite:\t\t\r\nfinde ich viele kostenlose Tutorials und Erklärungen, die mir helfen ein erfolgreicher Programmierer\r\nzu werden.Wenn ich etwas nicht direkt finde, nutze ich die Suchfunktion oder schreibe einen\r\nKommentar unter einen Beitrag oder auf der Facebookseite\r\n\n \"\" ");

Das Ergebnis:

Quelle: Eigene Darstellung

Du willst mehr über Escape Sequenzen wissen, dann seien dir folgende Fachbücher ans Herz gelegt:

Grundkurs C: C-Programmierung verständlich erklärt

C# 6 mit Visual Studio 2015: Das umfassende Handbuch: Spracheinführung, Objektorientierung, Programmiertechniken

Programmieren lernen mit Java

[Interview] Bist du bereit für die Cloud?

Was bedeutet das Thema Cloud für uns als Entwickler? Müssen wir uns daran anpassen, welche Vorteile und Möglichkeiten gibt es?

Maarten Balliauw hat einen absolut empfehlenswerten Blog der sich unter anderem mit Azure Cloudtechnologien auseinander setzt. Er war so nett und hat mir ein paar Fragen beantwortet die mir auf dem Herzen lagen:

Hello Maarten before a few days I searched the web for good C# blogs and came across your great blog I really recommend it for people that want to be a professional .NET developer and do not want to be suspended. It is really great that you take some of your time to answer some questions about the state of the art topic, „Cloud“. Could you please introduce yourself to my readers?

Of course, thanks for reaching out. I’m Maarten Balliauw and I live and work in Antwerp, Belgium. I’m working with JetBrains as a Developer Advocate for the .NET products like Rider – which is a great alternative to Visual Studio – and the various memory and performance profilers. Together with a former colleague at a previous job I’m building out MyGet where we have a software-as-a-service solution that allows you to create and distribute NuGet packages, as well as npm, Maven etc.

My main interest is in everything related to web and cloud, you could say if it uses HTTP or HTTPS as the transport then I’m game. Although I mainly focus on the .NET side of things, so ASP.NET and Azure. If I do find some spare time, I try to brew my own beers. Sometimes good, sometimes less but still drinkable.

The topic of Cloud has been heard for several years. More and more companies are preparing for it, is this just a short-term hype or even a non-halting development to which we as developers should adapt as soons as possible?

If you are not looking at the cloud right now, you may be missing out. I think that advice counts for businesses as well as developers. For businesses, the cloud may (or may not) provide advantages in delivery of their services. These advantages can be in cost, development speed, security, reliability, scale and so forth. As developers, we should definitely have notion of what the cloud is and even better: experience and learn it first hand – many businesses will ask for your experience with it and I am starting to see job ads that specifically require knowledge of certain technologies.

That the data will be saved at the datacenter from another company like Microsoft still produces a bad feeling for some people do you think that the worries are justified?

Like with anything, this comes down to trust and risk. Don’t trust the bakery to not put poison in their bread? Bake your own. But maybe the cupcakes there are good, so let’s get cupcakes from the bakery and bake our own bread. And maybe the bread isn’t that bad, so let’s go all-in on that bakery. As with all things, I think it is important to be aware of all security policies the cloud vendor has in place, and based on your own risk analysis and requirements, pick the best option. And that best option can be the cloud, it can be your own datacenter. As always in IT: “it depends”.

What new possibilities delivers the cloud, that in the past were not realizable? For example, for the requirement that a lot of technical resources are required for a short period of time, this could be on a release day from a computer game, or for a time-limited competition for which advertising is made on the TV?

When I first was introduced to the cloud, all I thought was it was yet another place to run our code. That is true in a large extent, but vendors like Microsoft, Amazon and Google are making their clouds much more than that – enabling scenarios that were either not possible before, or very hard to get right.

Examples could be your example of needing a lot of capacity for a short period of time: just head to one of the clouds, deploy, and one week later kill off the application again. You’ll only pay for that week of capacity, and not negotiate with an account manager at a traditional hoster. Really quick to set this up, and very cost-efficient.

That is a classic example, however. There are definitely companies that have that scenario, but does your company do a lot of these one-off campaigns that require lots of capacity for a short period of time? The big value comes from other scenarios, I think. Each cloud has their specific offerings to make certain scenarios possible.

When I was a consultant, I was hired by a company that collected telemetry from devices that were placed at their customer’s location. They had a working solution, running on just one server. Then they got acquired, and needed to make this work for more customers. Not only that: the devices would no longer be on their own network, and the existing solution was not secure enough to make this work on the public Internet. Pretty much every cloud vendor has some offering which comes with the building blocks for a scenario like this. Why spend months or years on building your own secure gateway device, when there is one you can get with just a few clicks, inexpensive and secure? Instead of focusing on that aspect of the solution, using this “commodity” solution from the cloud vendor means you as a business can focus on making your business better, by looking at things like better reporting or nice integrations with other devices, in this example.

I often hear from the Microsoft Cloud called Azure and the Amazon Cloud called AWS, is there one which you prefer, for example for a special technology like .NET?

I started out with Azure and have been a big fan since, but have also been working with Amazon’s cloud as well as Google’s. They all have their own strengths, and some make it easier to run a specific workload than others. For .NET, they all support this, although for example Microsoft Azure Web Apps do make it really really easy to host .NET applications.

Which function you would recommend a newbie in developing should test first, is it for example Azure Web Apps, and why you would recommend that?

Azure Web Apps is indeed a good place to start. In essence, it’s just a place you can upload your application and run it. It provides those basics, but if you want to level up the more advanced things are there too. Some basic tuning of the server. Integration with a Redis cache. Geo-distribution. Staging slots and VIP-swaps. It’s a good stepping stone if you are building web application and want to get excited about Azure.

Is there also a (easy) way that I can deploy a consoleapplication, which I would in the old way install as a windowsservice on a physical server?

Absolutely! Spin up a virtual machine, remote desktop into it and upload that application and run it. The question is not ideal though. You can take any workload from a traditional datacenter and move it onto a virtual machine in the cloud. But in essence, you are now just running on someone else’s computer instead of your own.

Look at what that console application is doing. Is it reading from a table in a database and then sending out emails to customers? Perhaps something like Azure Functions would be better to run that workload. Yes, the application will need a little rewrite, but it will be cheaper to run, more efficient as well, and there is no more risk that one virtual machine can go down and stop your business at that point.

So “lift and shift” is possible, but each cloud has those specific services that can do a better job at running a specific task.

If you think about the integration of Azure into Visual Studio, how hard is it for a newbie to deploy a ASP.NET Web Application to Azure, the first time?

If you already have an account on Azure, it is as simple as right-click, publish. There is some good built-in tooling that allows you to deploy web applications, cloud services, etc.

The Azure docs are quite good – they have a good starting page at where you can select the application type you are developing, and then see how to deploy it to, for example, Azure Web Apps.

And at the end a question not directly reffering to the topic: Do you would recommend a new developer to become a specialist in one topic and work more and more on that topic, or should he also concentrate on other programming languages, technical skills, design patterns which he currently does not need?

That is a great question! And one that has, for me, an easy answer. Generic technical skills and patterns are what matters first. Being a specialist in one topic should be second. But also keep in mind being a specialist in some topic is not a bad thing – there is big demand for specialists.

To give you an example: when I was back in school, I learned COBOL as a programming language. We would get programming exercises like reading a file that held orders for customers, and then generating a summary report that would list a customer, their order total, and then each single line on those orders. While I thought at the time I was learning COBOL, what I was actually learning was a pattern for reading and processing data. Whether COBOL, Java, C#, the structure of doing something like that is always going to be similar, and knowledge that I can apply in whatever he programming language of the moment is.

Another one. Right now, there is a big push towards “microservices”, splitting up your application in multiple blocks that are developed separately, hosted separately and ideally deployed separately. 10 years ago, there was a similar concept, “service-oriented architecture”. Not 100% the same, but similar enough to just read an article somewhere and know what microservices are trying to solve. So that prior pattern I learned, combined with a short news article on microservices, now helps in understanding when a customer asks something around microservices.

Does all of this mean we should not be learning new stuff at all? Absolutely not! Being a developer is continuous learning, and through learning and experimenting, you build experience. And that experience helps make it easier to learn and understand the next big thing.

Thank you Maarten

Und bist du schon ready für das Thema Cloud?

Welche Fragen liegen dir auf dem Herzen die hier nicht beantwortet wurden?

Wozu wünscht du dir ein Tutorial?

Teile es doch einfach in den Kommentaren mit.


[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.


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 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%";	 	 


 public void RemoveDownloadFromGrid()	 	 

 var grid = (Grid)VisualTreeHelper.GetParent(FileName);	 	 

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

 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)	 	 
 string argument = "/select, \"" + FileName.Content.ToString() + "\"";	 	 
 System.Diagnostics.Process.Start("explorer.exe", argument);	 	 

 catch (Exception ex)	 	 


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


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

            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())

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;
                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;
            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)
                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();

            catch (Exception ex)

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)
                string argument = "/select, \"" + FileName.Content.ToString() + "\"";
                System.Diagnostics.Process.Start("explorer.exe", argument);
            catch (Exception ex)

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;
                if (!ValidateDownloadURL())

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

                    //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);
                catch (Exception exception)
                    download.buttonDeleteClick(null, null);
                textBoxDownloadPath.Text = downloadTextBoxPlaceholder;
            catch (Exception ex)

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.


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 🙂

Programmieren lernen für Kinder

Auch Kinder können schon das Programmieren lernen. Je nach Alter gibt es verschiedene Möglichkeiten, mit denen dein Kind auf spielerische Art entweder alleine oder mit deiner Hilfe die Grundlagen für das Programmieren erlernen kann. Einige davon möchte ich dir hier kurz vorstellen.

Worauf du achten solltest

Je jünger dein Kind ist, umso eher solltest du darauf achten, dass es nicht so lernt wie ein Erwachsener. Kinder sind schnell überfordert oder gelangweilt, wenn man sie mit zu vielen Informationen gleichzeitig überschüttet. Deshalb solltest du immer darauf achten, geduldig und langsam vorzugehen und ihm nur so viel vorzugeben wie nötig. Am Besten bleibt z.B. eine Anweisung immer im Gedächtnis, wenn man sie selbst abtippt – das gilt für Kinder genauso wie für Erwachsene. Lass dein Kind möglichst alles selbst entdecken. Etwas nachhelfen kannst du aber natürlich, wenn dein Kind alleine nicht weiter kommt.
Kurze Programme sind vor allem für den Anfang besser, weil Kinder sich nicht so lange auf eine Sache konzentrieren können. Außerdem ist das optische Feedback wichtig: wenn ein Kind etwa ein Spielzeug mit dem Quellcode steuern kann oder grafisch etwas auf dem Bildschirm passiert, macht das Spaß und motiviert dadurch, weiterzumachen. So wird das Programm für das Kind (be-)greifbarer.



Programmieren mit Lego

Die Besonderheiten, die das Programmieren lernen für Kinder mit sich bringt, hat Lego in einigen Produktserien gut bedacht und umgesetzt. Viele Kinder kennen und mögen Lego und haben selbst vielleicht schon Bausätze zuhause, deswegen fällt es nicht schwer, sie dafür zu begeistern. Das Lernen wird hier also eher zum positiven Nebeneffekt.
Die neuste Reihe, Lego Boost, kannst du ab August 2017 für etwa 160€ kaufen.
Lego Boost Roboter und App
Der Grundsatz beinhaltet die notwendigen Sensoren, Motoren und Lego Steine, um fünf verschiedene Roboter nach Anleitung zu bauen und mit Programmierung zum Leben erwecken. Wie bei Lego üblich, kann man aber natürlich auch der eigenen Fantasie freien Lauf lassen.
Programmieren kann dein Kind dabei auf dem PC oder Tablet, die Software dazu kommt auch von Lego. Die App erinnert an ein buntes Puzzle-Spiel und kann auch so ähnlich benutzt werden. Der Code ist in verschiedene Gruppen unterteilt, z.B. gibt es eine Gruppe für Sensoreingaben. Jede Gruppe hat dabei eine eigene Farbe und dein Kind kann das Programm einfach aus größeren zusammenhängenden Codestücken zusammenbauen. Oder aber es schreibt das Programm komplett selbst, wenn es schon etwas Erfahrung gesammelt hat. Neben der Boost Reihe findest du von Lego auch noch andere programmierbare Sets. Lego Boost ist eher so gehalten, dass besonders Kinder im Alter von etwa 7 bereits gut damit zurecht kommen. Wenn dein Kind schon älter ist, kannst du beispielsweise auch die Mindstorms-Sets in Erwägung ziehen.

Wie du deinem Kind das Programmieren sonst noch näher bringen kannst

Eine Idee aus dem Hause Apple, mit der dein Kind ebenfalls auf dem Tablet spielerisch das Programmieren lernen kann, ist die App Swift Playgrounds.
Swift Playground App von Apple
Dabei kann dein Kind mit Hilfe von kleinen Anweisungsblöcken eine Spielfigur steuern, die sich daraufhin bewegt oder Aktionen durchführt. Auch diese App ist bunt und fröhlich gehalten und verbindet Lernen und Spielen mit einander. Mit der aktuellen Version ist es sogar möglich, Hardware wie etwa Drohnen zu steuern. Swift wurde als Programmiersprache besonders darauf ausgelegt, dass jeder sie leicht erlernen kann und der Code möglichst einfach gehalten ist.
Du siehst, es gibt eine Menge Möglichkeiten für das Programmieren lernen für Kinder jeden Alters, die auch deinem Kind gefallen könnten!

Wie lerne ich Programmieren?

Wie lerne ich Programmieren? Wie werde ich ein erfolgreicher Programmierer? Was muss ich tun um Programmieren zu lernen? Diese Fragen werde ich in diesem Beitrag beantworten. Als erstes solltest du dich fragen was du genau erreichen möchtest, zum Beispiel:

  1. Du möchtest nur eine einfache Webseite zum Beispiel für dein Unternehmen oder auch privat erstellen
  2. Du möchtest eine komplexe Anwendung zum Beispiel eine Webseite oder APP erstellen mit verschiedensten Funktionen und/oder Usertypen
  3. Du möchtest ein Softwareentwickler werden
  4. Du möchtest ein eigenes Spiel programmieren
  5. Du brauchst es für deine Ausbildung oder Studium

Nachfolgend werde ich Tipps für jeden diese 5 Fälle geben. Denn die Vorgehensweise kann sich hier erheblich voneinander unterscheiden.

Du möchtest nur eine einfache Webseite erstellen

Wenn dies Fall ist, dann reicht vielleicht auch ein CMS (content management system) wie WordPress dafür aus. Wenn dies der einzige Grund ist aus dem du Programmieren lernen möchtest, dann solltest du lieber Tools wie zum Beispiel WordPress dafür nutzen, somit kannst du dich mehr auf den Inhalt, als mit dem Programmieren der Seite beschäftigen.

Du möchtest eine komplexe Anwendung erstellen

Wenn es wirklich nur um diese eine Webseite oder APP geht dann beauftrage doch jemand anderen dafür. Es gibt viele Seiten im Netz wo du sowas günstig in Auftrag geben kannst. Zum Beispiel upwork, fiverr, twago und viele weitere. Deine Motivation Programmieren zu lernen sollte schon etwas weiter reichen, als nur für ein einmaliges Projekt wie eine Webseite, sonst wirst du nicht bis zum Ende durchhalten und es lohnt sich der Aufwand nicht. Denn wenn du von 0 anfängst wirst du nicht innerhalb einer oder zwei Wochen zu einem Experten.

Du möchtest ein Softwareentwickler werden

Das ist ein guter Grund um Programmieren lernen zu wollen. Allerdings stellt sich dann sogleich die Frage, mit welcher Programmiersprache fange ich an? Dafür liefert die dieser Beitrag eine Antwort, so wie jede Menge Literaturtipps, nutze sie! Wenn du nun die Programmiersprache weißt, dann empfehle ich dir, der Reihe nach alle Beiträge dieses Blogs durchzuarbeiten, dir zusätzlich die Anwendungspakete zu erwerben, damit du gleich voll durchstarten kannst, und außerdem ein paar der Literaturtipps auf der rechten Seite zu kaufen und durchzuarbeiten. Außerdem empfehle ich dir ganz klar, dich bei Codecademy anzumelden um dich dort mit der Syntax deiner Sprache vertraut zu machen. Auch Seiten wie Selhtml sollten dein 2. zu Hause werden.

Du möchtest ein eigenes Spiel programmieren

Das kann ich gut verstehen, auch ich hatte das ziemlich schnell für mich als Ziel gesetzt. Doch ohne die Grundlagen geht hier erstmal gar nichts. Auch dir empfehle ich, arbeite alle Beiträge dieser Seite durch, beginne mit dem Ersten, und beschäftige dich mit den Grundlagen. Dann solltest du dir überlegen welche Technologie dein Spiel einsetzen soll. Generell würde ich dir empfehlen, sobald du in der Lage bist so gut wie jedes Konsolenprogramm zu entwickeln, dich mit der freien multiplattformunterstützenden Unity Engine auseinander zu setzen.

Du brauchst es für deine Ausbildung oder Studium

Hier kommt es jetzt wieder darauf an ob du es gerne machst, ob du es nachher auch in deinem Job brauchst und welche Programmiersprache du einsetzt. Ich empfehle dir die Literaturtipps aus diesem Beitrag.

Allgemeine Hinweise für Anfänger

Wenn du wirklich Programmieren lernen willst, dann solltest du dich auch unbedingt mit dem Thema Datenbanken und SQL auseinander setzen. Du solltest dich aber auch auf nicht zu viele Sprachen gleichzeitig konzentrieren. Wenn du HTML und C# oder SQL und C# gleichzeitig lernst ist es sicher kein Problem, da diese sich stark voneinander unterscheiden und du nicht durcheinander kommen wirst. Java und C# gleichzeitig zu lernen ist eine Sache von der ich dir aber auf jeden Fall abraten würde, da die Syntax schon sehr, sozusagen zum verwechseln ähnlich, aufgebaut ist. Um die Syntax einer Sprache zu erlernen empfehle ich dir noch zusätzlich Codecademy die Seite ist kostenlos und du bekommst sofort Aufgaben die du mit Hilfe eines Codeeditors lösen darfst.

Was muss ich tun um Programmieren zu lernen?

Vor allem solltest du nicht bei den ersten Problemen und Schwierigkeiten aufgeben. Du musst am Ball bleiben. Lerne Probleme zu lösen. Du solltest dir die Fähigkeit aneignen dich selbständig weiterzubilden und Probleme zu lösen von denen du anfangs keine Ahnung hast wie du sie lösen kannst. Du solltest dir vor allem erstmal eine Sprache raussuchen mit der du beginnst, welche ist hierbei gar nicht so wichtig. Ich empfehle dir C# oder Java, aber es kann auch irgendeine andere sein. Am Anfang ist die Lernkurve hoch, doch wenn du die erste Programmiersprache beherrschst, ist der Lernprozess für eine weitere Sprache lang nicht mehr so anspruchsvoll. Anfangs sind die Grundlagen ganz wichtig zum Beispiel Datentypen, Schleifen, Stringverarbeitung, Switch Case Anweisungen, Arrays, Vergleichsoperatoren und vor allem Praxis Praxis Praxis, zum Beispiel durch Codecademy. Aber natürlich muss man seinen Code auch immer wieder optimieren und vergleichen mit professionellem Code.

Wie werde ich ein erfolgreicher Programmierer?

  • Du solltest dich immer weiterbilden
  • Lerne von den Erfolgreichen
  • Lese dir alle Bücher durch die ich auf der rechten Seite empfehle
  • Besuche Schulungen
  • Lerne neue Technologien und Frameworks zum Beispiel Angular2
  • Lerne jedes Jahr eine neue Programmiersprache
  • Beschäftige dich zum Beispiel mit funktionaler Programmierung und schreibe funktionale Programme
  • Arbeite an open source Projekten mit
  • Tritt einer .NET User Group bei und tausche dich mit anderen Fachleuten aus
  • Abonniere oder lese regelmäßig Fachzeitschriften wie zum Beispiel die dotnetpro
  • Beschäftige dich mit Clouddevelopment zum Beispiel mit Azure
  • Entwickle ein eigenes Spiel mit der Unity Engine
  • Hab ein Überblick über aktuelle Entwurfsmuster und erwerbe das Wissen welches Muster für welchen Anwendungsfall am geeignetsten ist


Windows Forms

Dieser Beitrag ist ein Tutorial für die Erstellung eines simplen Taschenrechners mit Benutzeroberfläche. Wenn du meine bisherigen Beiträge durchgearbeitet hast, bist du mit den Grundlagen wie Schleifen, Variablen, Switch Case Anweisungen, Stringverarbeitung, Datentypen, Arrays und Vergleichsoperatoren bereits vertraut. Falls nicht empfehle ich dir, das erst nachzuholen, am besten mit dem ersten Beitrag, bevor du dir mit der zusätzlichen Komponente „Benuteroberfläche“ erhöhte Komplexität erzeugst. Dieses Beispiel ist mit Hilfe von Visual Studio in C# und mit Nutzung der Windows Forms Technologie erstellt worden. Natürlich kann auch eine andere Entwicklungsumgebung hierfür genutzt werden.

  1. Inhalt
  2. Windows Forms was ist das
  3. Windows Forms Projekt erstellen
  4. Aufbau einer Windows Forms Anwendung
  5. Ausführen der Anwendung
  6. Der Entwurfsmodus
  7. Die Oberfläche designen
  8. Events nutzen
  9. Logik implementieren
  10. Einsatzempfehlung
  11. Codedownload (kostenlos)

Windows Forms was ist das?

Windows Forms ist eine Art GUI (graphical user interface) Werkzeugkasten zum Erstellen von Programmen, die eine grafische Benutzeroberfläche haben, auf der Basis des .NET Frameworks. Also die klassischen Windows (Fenster) Anwendungen inklusive des gewohnten Windows-Designs.

Mit Windows Forms werden so genannte Smart Clients entwickelt. Smart Clients sind einfach zu entwickeln, upzudaten, können mit oder ohne Verbindung zum Internet genutzt werden und greifen auf lokale Ressourcen auf einer sichereren Art zu, als traditionelle Windows basierte Applikationen. Windows Forms gibt es schon lange, ein konkurrierendes neueres Framework ist WPF (Windows Presentation Foundation) dies bietet eine einfache zweiseitige Datenbindung an die Steuerelemente der Benutzeroberfläche und setzt außerdem das Entwurfsmuster MVVM (Model View Viewmodel) konsequent um. Da dieser Beitrag aber vor allem für Personen gedacht ist, die das erste Mal mit der Entwicklung von Benutzeroberflächen zu tun haben, wäre dies zu komplex, wird aber in einem zukünftigen Beitrag behandelt. Wenn du jetzt schon mehr zu WPF wissen möchtest empfehle ich dir folgendes Fachbuch, dass ich auch selbst gelesen habe: Windows Presentation Foundation 4. Einführung und Praxis

Windows Forms Projekt erstellen

Als erstes muss ein neues Projekt vom Typ Windows Forms-Anwendung angelegt werden:

Quelle: Eigene Darstellung

Dann erstellt eure Entwicklungsumgebung, in meinem Fall Visual Studio, für euch das Projekt mit verschiedenen Dateien.

Aufbau einer Windows Forms Anwendung

In Visual Studio findet ihr im Projektmappenexplorer (im Standard auf der rechten Seite von Visual Studio zu finden, ansonsten über „Ansicht“ -> „Projektmappenexplorer“ oder [STRG] + [ALT] + [L] aufrufbar) eine Form1.cs, eine Form1.Designer.cs, in meinem Fall noch eine Form1.resx und eine Program.cs Datei.

Quelle: Eigene Darstellung


Datei Erklärung
Form1.cs Die Form1 Klasse ist gesplittet in Designerdatei und Form1.cs. Die Form1 Datei enthält Code der ausgeführt wird, wenn der Benutzer Interaktionen mit der Benutzeroberfläche stattfinden lässt, also zum Beispiel einen Button drückt, die Maus bewegt, eine Taste auf der Tastatur drückt usw. Außerdem kann man in die vordefinierte eventgesteuerte Methode „Form1_Load“ Quellcode schreiben, der unmittelbar vor der Anzeige des Formulars, ausgeführt wird. Aus dieser Datei heraus wird bei der Erstellung der Form1 Klasse (um genau zu sein beim Aufruf des Form1 Konstrukturs), die Methode InitializeComponent() aus der „Form1.Designer.cs“ aufgerufen.
Form1.Designer.cs In der Designerdatei werden, in der Regel, die Steuerelemente (Controls) des Formulars deklariert, initialisiert, positioniert, Attribute gesetzt und formatiert.
Form1.resx Diese Datei habe ich manuell hinzugefügt, sie wird genutzt um Ressourcen geordnet abzulegen. Das können zum Beispiel Stringressourcen sein, also irgendwelche Zeichenfolgen (oft Wörter und Texte). Das macht Sinn damit man diese geordnet an einer Stelle ablegen kann und bei Änderungen, oder Hinzufügen einer neuen Sprache, nur an einer Stelle und nicht an 100 Stellen angepackt werden muss. Es können aber auch, wie in diesem Fall, Bilder oder Symbole, Audiodateien und weitere Ressourcentypen abgelegt werden.
Program.cs In dieser Klasse findest du den Haupteinstiegspunkt der Anwendung. Von hier aus wird das Formular Form1 erzeugt und ausgeführt.

Quelle: Eigene Darstellung

Ausführen der Anwendung

Wenn du [F5] drückst, oder über das Menü „Debuggen“ -> „Debugging Starten“ navigierst, kannst du deine Anwendung debuggen, also Starten mit zusätzlicher Option den Code zu untersuchen, während das Programm läuft. Bei einer neuen Anwendung sieht das Ganze noch recht unspektakulär aus, eine leeres Fenster wird angezeigt.

Quelle: Eigene Darstellung

Der Entwurfsmodus

Wenn du auf die Form1.cs Datei doppelt klickst, wird dir das Formular im Entwurfsmodus angezeigt. Hier bekommst du eine direkte Vorschau darauf, wie das Formular aussieht, außerdem stehen dir noch zusätzliche Optionen wie das Eigenschaftsfenster, eine Übersicht der zur Verfügung stehenden Events und eine Toolbox zur Verfügung. Mit der Toolbox (falls nicht bereits offen, wird diese über das Menü „Ansicht“ -> „Toolbox“ oder [STRG] + [ALT] + [X] geöffnet) können sehr einfach, mit der Maus per „Drag and Drop“, Steuerelemente auf das Formular gezogen werden. Dadurch werden neue Steuerelemente in der Form1.Designer.cs Datei erstellt, das kann man natürlich auch selber machen. Wenn ein Steuerelement den Fokus hat, können außerdem über das Eigenschaftsfenster, Eigenschaften wie zum Beispiel der Name des Steuerelements gesetzt werden.

Die Oberfläche designen

Nachdem wir nun eine leere Windows Forms Anwendung erstellt haben, muss die Oberfläche designt werden, nutze dazu entweder die Toolbox und die Entwurfsansicht, oder schreib direkt Code in die Form1.Designer.cs Klasse. Als Vorlage kannst du die folgende Abbildung, ohne Hintergrundbild, nutzen.

Quelle: Eigene Darstellung

Es sind also 3 Textboxen, 3 Label zu den Textboxen, 4 Radiobuttons, und 4 normale Buttons zu benennen und zu Erstellen.

Das kann zum Beispiel folgendermaßen in der Form1.Designer.cs Datei realisiert werden (am Ende des Beitrags findest du den gesamten Quellcode zum kostenlosen Download):

namespace WindowsFormsApplication1
partial class Form1
/// <summary>
/// Erforderliche Designervariable.
/// </summary>
private System.ComponentModel.IContainer components = null;

/// <summary>
/// Verwendete Ressourcen bereinigen.
/// </summary>
/// <param name="disposing">True, wenn verwaltete Ressourcen gelöscht werden sollen; andernfalls False.</param>
protected override void Dispose(bool disposing)
if (disposing && (components != null))

#region Vom Windows Form-Designer generierter Code

/// <summary>
/// Erforderliche Methode für die Designerunterstützung.
/// Der Inhalt der Methode darf nicht mit dem Code-Editor geändert werden.
/// </summary>
private void InitializeComponent()
System.ComponentModel.ComponentResourceManager resources = new System.ComponentModel.ComponentResourceManager(typeof(Form1));
this.textBox1 = new System.Windows.Forms.TextBox();
this.textBox2 = new System.Windows.Forms.TextBox();
this.label1 = new System.Windows.Forms.Label();
this.textBox_Ergebnis = new System.Windows.Forms.TextBox();
this.bt_berechnen = new System.Windows.Forms.Button();
this.bt_Wurzel = new System.Windows.Forms.Button();
this.bt_Reset = new System.Windows.Forms.Button();
this.bt_Beenden = new System.Windows.Forms.Button();
this.label4 = new System.Windows.Forms.Label();
this.Zahl2 = new System.Windows.Forms.Label();
this.radioButtonAddieren = new System.Windows.Forms.RadioButton();
this.radioButtonSubtrahieren = new System.Windows.Forms.RadioButton();
this.radioButtonMulti = new System.Windows.Forms.RadioButton();
this.radioButtonDividieren = new System.Windows.Forms.RadioButton();
// textBox1
this.textBox1.Location = new System.Drawing.Point(73, 86);
this.textBox1.Name = "textBox1";
this.textBox1.Size = new System.Drawing.Size(109, 20);
this.textBox1.TabIndex = 4;

// textBox2
this.textBox2.Location = new System.Drawing.Point(233, 86);
this.textBox2.Name = "textBox2";
this.textBox2.Size = new System.Drawing.Size(110, 20);
this.textBox2.TabIndex = 5;
// label1
this.label1.AutoSize = true;
this.label1.Font = new System.Drawing.Font("Microsoft Sans Serif", 17.25F, System.Drawing.FontStyle.Regular, System.Drawing.GraphicsUnit.Point, ((byte)(0)));
this.label1.Location = new System.Drawing.Point(75, 56);
this.label1.Name = "label1";
this.label1.Size = new System.Drawing.Size(72, 29);
this.label1.TabIndex = 6;
this.label1.Text = "Zahl1";
// textBox_Ergebnis
this.textBox_Ergebnis.Location = new System.Drawing.Point(77, 169);
this.textBox_Ergebnis.Name = "textBox_Ergebnis";
this.textBox_Ergebnis.Size = new System.Drawing.Size(105, 20);
this.textBox_Ergebnis.TabIndex = 8;
// bt_berechnen
this.bt_berechnen.Location = new System.Drawing.Point(583, 79);
this.bt_berechnen.Name = "bt_berechnen";
this.bt_berechnen.Size = new System.Drawing.Size(108, 31);
this.bt_berechnen.TabIndex = 10;
this.bt_berechnen.Text = "Berechnen";
this.bt_berechnen.UseVisualStyleBackColor = true;
this.bt_berechnen.Click += new System.EventHandler(this.bt_berechnen_Click);
// bt_Wurzel
this.bt_Wurzel.Location = new System.Drawing.Point(583, 144);
this.bt_Wurzel.Name = "bt_Wurzel";
this.bt_Wurzel.Size = new System.Drawing.Size(108, 31);
this.bt_Wurzel.TabIndex = 11;
this.bt_Wurzel.Text = "Wurzel aus Summe";
this.bt_Wurzel.UseVisualStyleBackColor = true;
this.bt_Wurzel.Click += new System.EventHandler(this.button2_Click);
// bt_Reset
this.bt_Reset.Location = new System.Drawing.Point(583, 215);
this.bt_Reset.Name = "bt_Reset";
this.bt_Reset.Size = new System.Drawing.Size(108, 31);
this.bt_Reset.TabIndex = 12;
this.bt_Reset.Text = "Reset";
this.bt_Reset.UseVisualStyleBackColor = true;
this.bt_Reset.Click += new System.EventHandler(this.bt_Reset_Click);
// bt_Beenden
this.bt_Beenden.Location = new System.Drawing.Point(583, 283);
this.bt_Beenden.Name = "bt_Beenden";
this.bt_Beenden.Size = new System.Drawing.Size(108, 31);
this.bt_Beenden.TabIndex = 13;
this.bt_Beenden.Text = "Beenden";
this.bt_Beenden.UseVisualStyleBackColor = true;
this.bt_Beenden.Click += new System.EventHandler(this.bt_Beenden_Click);
// label4
this.label4.AutoSize = true;
this.label4.Font = new System.Drawing.Font("Microsoft Sans Serif", 17.25F, System.Drawing.FontStyle.Regular, System.Drawing.GraphicsUnit.Point, ((byte)(0)));
this.label4.Location = new System.Drawing.Point(72, 136);
this.label4.Name = "label4";
this.label4.Size = new System.Drawing.Size(110, 29);
this.label4.TabIndex = 14;
this.label4.Text = "Ergebnis";
// Zahl2
this.Zahl2.AutoSize = true;
this.Zahl2.Font = new System.Drawing.Font("Microsoft Sans Serif", 17.25F, System.Drawing.FontStyle.Regular, System.Drawing.GraphicsUnit.Point, ((byte)(0)));
this.Zahl2.Location = new System.Drawing.Point(228, 54);
this.Zahl2.Name = "Zahl2";
this.Zahl2.Size = new System.Drawing.Size(72, 29);
this.Zahl2.TabIndex = 15;
this.Zahl2.Text = "Zahl2";
// radioButtonAddieren
this.radioButtonAddieren.AutoSize = true;
this.radioButtonAddieren.Font = new System.Drawing.Font("Microsoft Sans Serif", 9.75F, System.Drawing.FontStyle.Bold, System.Drawing.GraphicsUnit.Point, ((byte)(0)));
this.radioButtonAddieren.Location = new System.Drawing.Point(403, 111);
this.radioButtonAddieren.Name = "radioButtonAddieren";
this.radioButtonAddieren.Size = new System.Drawing.Size(89, 20);
this.radioButtonAddieren.TabIndex = 16;
this.radioButtonAddieren.TabStop = true;
this.radioButtonAddieren.Text = "Addieren";
this.radioButtonAddieren.UseVisualStyleBackColor = true;
// radioButtonSubtrahieren
this.radioButtonSubtrahieren.AutoSize = true;
this.radioButtonSubtrahieren.Font = new System.Drawing.Font("Microsoft Sans Serif", 9.75F, System.Drawing.FontStyle.Bold);
this.radioButtonSubtrahieren.Location = new System.Drawing.Point(403, 158);
this.radioButtonSubtrahieren.Name = "radioButtonSubtrahieren";
this.radioButtonSubtrahieren.Size = new System.Drawing.Size(114, 20);
this.radioButtonSubtrahieren.TabIndex = 17;
this.radioButtonSubtrahieren.TabStop = true;
this.radioButtonSubtrahieren.Text = "Subtrahieren";
this.radioButtonSubtrahieren.UseVisualStyleBackColor = true;
// radioButtonMulti
this.radioButtonMulti.AutoSize = true;
this.radioButtonMulti.Font = new System.Drawing.Font("Microsoft Sans Serif", 9.75F, System.Drawing.FontStyle.Bold);
this.radioButtonMulti.Location = new System.Drawing.Point(403, 205);
this.radioButtonMulti.Name = "radioButtonMulti";
this.radioButtonMulti.Size = new System.Drawing.Size(117, 20);
this.radioButtonMulti.TabIndex = 18;
this.radioButtonMulti.TabStop = true;
this.radioButtonMulti.Text = "Multiplizieren";
this.radioButtonMulti.UseVisualStyleBackColor = true;
// radioButtonDividieren
this.radioButtonDividieren.AutoSize = true;
this.radioButtonDividieren.Font = new System.Drawing.Font("Microsoft Sans Serif", 9.75F, System.Drawing.FontStyle.Bold);
this.radioButtonDividieren.Location = new System.Drawing.Point(402, 256);
this.radioButtonDividieren.Name = "radioButtonDividieren";
this.radioButtonDividieren.Size = new System.Drawing.Size(97, 20);
this.radioButtonDividieren.TabIndex = 19;
this.radioButtonDividieren.TabStop = true;
this.radioButtonDividieren.Text = "Dividieren";
this.radioButtonDividieren.UseVisualStyleBackColor = true;
// Form1
this.AutoScaleDimensions = new System.Drawing.SizeF(6F, 13F);
this.AutoScaleMode = System.Windows.Forms.AutoScaleMode.Font;
this.BackColor = System.Drawing.SystemColors.ControlLightLight;
this.BackgroundImage = ((System.Drawing.Image)(resources.GetObject("$this.BackgroundImage")));
this.ClientSize = new System.Drawing.Size(730, 403);
this.Name = "Form1";
this.Text = "Taschenrechner";
this.Load += new System.EventHandler(this.Form1_Load);


private System.Windows.Forms.TextBox textBox1;
private System.Windows.Forms.TextBox textBox2;
private System.Windows.Forms.Label label1;
private System.Windows.Forms.TextBox textBox_Ergebnis;
private System.Windows.Forms.Button bt_berechnen;
private System.Windows.Forms.Button bt_Wurzel;
private System.Windows.Forms.Button bt_Reset;
private System.Windows.Forms.Button bt_Beenden;
private System.Windows.Forms.Label label4;
private System.Windows.Forms.Label Zahl2;
private System.Windows.Forms.RadioButton radioButtonAddieren;
private System.Windows.Forms.RadioButton radioButtonSubtrahieren;
private System.Windows.Forms.RadioButton radioButtonMulti;
private System.Windows.Forms.RadioButton radioButtonDividieren;

Jetzt haben wir die Oberfläche designt, die nötige Logik um die Funktion des Taschenrechners abzubilden fehlt aber noch.

Events nutzen

In dieser ersten, einfachen Umsetzung, wird bewusst aus Gründen der Einfachheit, auf das Konzept der Objektorientierung und andere Entwurfsmuster, verzichtet. Wenn man, in der Entwurfsansicht, auf ein Steuerelement, wie zum Beispiel den „Berechnen Button“ einen doppelten Mausklick ausführt, wird für das entsprechende „OnClick-Event“ ein Delegate erstellt, der auf die auszuführende Methode zeigt, wenn das Event ausgeführt wird (in der Datei Form1.Designer.cs).


this.bt_berechnen.Click += new System.EventHandler(this.bt_berechnen_Click);
  • bt_berechnen ist ein Button, nämlich der „Berechnen Button“
  • Click ist das Event, das Eintritt wenn man mit der Maus auf dieses Element klickt
  • Diesem Event wird ein neues Objekt vom Typ „Delegate“, erzeugt durch den Aufruf EventHandler(<Name der auszuführenden Methode>), welches auf die Methode bt_berechnen_Click verweist, zugewiesen
  • Die Methode bt_berechnen_Click wird ausgeführt, wenn mit der Maus auf den Button bt_berechnen geklickt wird.

Außerdem wird die Methode „bt_berechnen_Click“ automatisch in der Form1.cs Klasse erstellt.

Diesen Vorgang kann man entweder auch automatisch, mit einem Doppelklick auf die anderen Steuerelemente nachziehen, oder besser, weil viel lehrreicher, wäre der Weg dies manuell für die anderen Steuerelemente zu realisieren.

Logik implementieren

Jetzt haben wir eine Benutzeroberfläche, wir wissen wie die Verknüpfung zwischen Buttons, Events, Delegates und der Methode auf die das Delegate zeigt, umgesetzt wird. Es fehlt also noch die eigentliche Funktion des Taschenrechners. Dazu muss in der Methode auf die das Event verweist:

  1. Der aktuelle Wert aus den Textboxen ausgelesen werden (ggf. überprüft werden, ob dieser Wert valide ist, also ob es sich um eine gültige Zahl handelt)
  2. Die Rechenoperation ausgeführt werden und somit das Ergebnis berechnet werden
  3. Das Ergebnis in die Textbox für das Ergebnis geschrieben werden

Machen wir das doch mal an dem Beispiel des „Dividieren“ Operators.

private void bt_berechnen_Click(object sender, EventArgs e)
            zahl1 = Convert.ToDouble(textBox1.Text);
            zahl2 = Convert.ToDouble(textBox2.Text);

            ergebnis = BerechneGrundrechenArten();

            textBox_Ergebnis.Text = Convert.ToString(ergebnis);            

Hier werden zwei zuvor Global deklarierte int-Variablen (zahl1, zahl2) die zum Datentyp double konvertierte Werte, der zugehörigen Textboxen, zugewiesen. Die Anweisung „textBox1.Text“ ruft auf der Textbox die den Namen textBox1 trägt, die Eigenschaft Text auf. Diese Eigenschaft enthält den Text der in der Textbox steht. Mit Text kann man aber nicht rechnen, deshalb muss dieser Wert erst in einen numerischen Datentyp umgewandelt, man sagt „konvertiert“, werden.

Anschließend wir eine neue Methode BerechneGrundrechenArten() ausgeführt, die wiederum das Ergebnis der Rechenoperation zurückgibt. In dieser Methode wird die Eigenschaft „Checked“ der RadioButtons, die die Rechenoperation angeben, abgefragt. Wenn „checked == true“ ist, dann ist dieser RadioButton gesetzt und es wird das Ergebnis entsprechend dieser Operation berechnet. Außerdem wird eine Division durch 0 verhindert.


if (zahl2 == 0 && radioButtonDividieren.Checked == true) MessageBox.Show("Division durch Null nicht zulässig", "Fehlermeldung");
            if (radioButtonAddieren.Checked == true) ergebnis += zahl1 + zahl2;
            if (radioButtonSubtrahieren.Checked == true) ergebnis -= zahl1 - zahl2;
            if (radioButtonDividieren.Checked == true) ergebnis /= zahl1 / zahl2;
            if (radioButtonMulti.Checked == true)
                if (ergebnis != 0) ergebnis *= zahl1 * zahl2;
                else ergebnis = zahl1 * zahl2;

            return ergebnis;

Das Ergebnis wird zurückgegeben und der ergebnis Variable aus der bt_berechnen_Click Methode zugewiesen. Anschließend wird das Ergebnis dann in den Datentyp „string“ konvertiert und der Wert wird der Eigenschaft „Text“ der Ergebnistextbox zugewiesen.


Windows Forms sollte man nutzen, wenn man eine Client- oder eigenständige Windows Anwendung programmieren möchte, die auch ohne Internetverbindung zurechtkommt und außerdem die Anzahl der Formulare in einem (sehr) niedrigen Bereich angesiedelt ist. Wenn man weiß, dass man viele Formulare, benötigt oder dass die Anwendung komplexer wird, ist es empfehlenswert, sich mit WPF auseinander zu setzen, das von vornherein bidirektionale Datenbindung, so wie das MVVM Pattern unterstützt.

Download des Quellcodes

Wenn man zum erstern Mal mit Benutzeroberflächen zu tun hat, dann mag dieser Beitrag vielleicht nicht ganz trivial erscheinen. Deshalb empfehle ich den Quellcode kostenlos herunterzuladen, auszuprobieren und parallel dazu den Beitrag zu verstehen und sich selbst auszuprobieren.

Einen komplexeren, wissenschaftlichen Taschenrechner, und viele weitere lohnenswerte Applikationen kannst du im Paket User Interface erwerben.

Empfohlene weiterführende Literatur:

C# 6 mit Visual Studio 2015: Das umfassende Handbuch: Spracheinführung, Objektorientierung, Programmiertechniken


Ein Array, manchmal als Datenfeld bezeichnet, ist eine Datenstruktur in der mehrere Variablen gleichzeitig gespeichert werden können. Die Variablen die innerhalb eines Arrays gespeichert sind, werden mit Hilfe eines Indexes aufgerufen und identifiziert.

Deklaration eines Arrays (C#, Java und weitere..)

Im Folgenden Beispiel wird ein Array deklariert:

int [] zahlen;

Durch diese Anweisung wird ein Array vom Datentyp  integer mit dem Namen „zahlen“, deklariert. Als nächstes muss das Array initialisiert werden. Dafür muss auch die Anzahl der maximal im Array abzulegenden Variablen angegeben werden:

zahlen = new int[3];

Das Array wird als neues Objekt erzeugt, daher wird das Schlüsselwort „new“ benötigt. In den eckigen Klammern steht die Anzahl der im Array enthaltenen Elemente, nämlich 3.

Alternativ kann man das Array auch in einer Zeile deklarieren und initialisieren. Dafür muss man bei der Deklaration bereits wissen, wie viele Elemente das Array genau enthalten soll:

int[] zahlen = new int[3];

Wenn bereits bei der Deklaration klar ist, welche Werte im Array gespeichert werden sollen, kann man dies auch direkt mit angeben:

int[] zahlen = new int[] {1,3,2};

Es ist sogar möglich das Ganze noch kürzer zu gestalten, folgendes Beispiel erzeugt genau das Gleiche Array wie das vorherige Beispiel:

int[] zahlen = {1,3,2};


Durch die Initialisierung eines Arrays werden die einzelnen Elemente eines Arrays erstellt und bekommen einen Index zugewiesen. Dieser Index startet bei 0, somit ist das 1. Element eines Arrays über den Index 0 aufrufbar, das 2. Element über den Index 1 und so weiter. Das weiter oben erstellte Array hat somit drei Elemente die folgendermaßen aufrufbar sind:


Wenn nun dem zweiten Element eine Zahl zugewiesen werden soll, kann das folgendermaßen realisiert werden:

zahlen[1] = 42;

Wenn nun der Wert eines, im Array enthaltenen, Elements einer Variablen zugewiesen werden soll, geht dies einfach mit der folgenden Zuweisung:

int element2 = zahlen[1];

Mit der Eigenschaft Length kann man außerdem die Länge eines Arrays zurückgeben.

int laengeMeinesArrays = zahlen.Length;

Im Folgenden Beispiel werden zwei Arrays, deklariert, initialisiert und dann auf dem Konsolenfenster wieder ausgegeben:

            int[] zahlen = new int[3];
            string[] woerter = new string[4] { " ", "sind die Besten!", "von ", "Die Beispiele " };

            zahlen[0] = 3;
            zahlen[1] = 1;
            zahlen[2] = 2;
            Console.WriteLine("Arrays\n =============================================================================\n");
            Console.WriteLine("zahlen[0]= " + zahlen[0]);
            Console.WriteLine("zahlen[1]= " + zahlen[1]);
            Console.WriteLine("zahlen[2]= " + zahlen[2]);
            Console.WriteLine("zahlen.Length = " + zahlen.Length);
            Console.WriteLine(woerter[3] + woerter[2] + woerter[0] + woerter[1]);


Wenn du Hilfe benötigst, Fragen oder Anmerkungen hast kannst du hierfür die Kommentarfunktion nutzen.


Claudi Hautumm /

In Bedingungsanweisungen zum Beispiel bei Schleifen, oder bei einer If Anweisung, werden häufig so genannte Vergleichsoperatoren genutzt. Dafür gibt es eine entsprechende Syntax die über einige Sprachen hinweg (zum Beispiel C#, Java, C …) einheitlich ist.

Bedingung Symbol Beispiel
Kleiner als < (x < y)
Größer als > (x > y)
Kleine oder gleich <= (x <= y)
Größer oder gleich >= (x >= y)
Gleich == (x == y)
Ungleich != (x != y)

Quelle: Eigene Darstellung

Die Funktion der meisten Operatoren kann man sich denken. Jedoch enthält der „Gleich“ Operator zwei Gleichheitszeichen. Dies gibt an, dass hier eine Überprüfung auf Gleichheit stattfindet, anstatt einer Zuweisung, die ein einzelnes Gleichheitszeichen nutzen würde. In dem Beispiel x == y wird also überprüft ob die beiden Variablen, x und y gleich sind. Das Ausrufezeichen ist eine Negierung. Das Beispiel x != y prüft also ob die Variablen ungleich sind.

Außerdem kann man die Vergleichsoperatoren mit ODER und UND Verknüpfen.

Logik Symbol Beispiel
ODER || ((x < y) || (x == z))
UND && ((x < y) && (x == z))

Quelle: Eigene Darstellung

Wenn eine der beiden Bedingungen des ersten Beispiels eintrifft, also wahr ist, dann wird, durch die ODER Verknüpfung, auch die Gesamtbedingung wahr. Im zweiten Beispiel wird die Gesamtbedingung nur erfüllt, wenn sowohl die erste, als auch die zweite Bedingung, gleichzeitig erfüllt werden. Ein abstraktes Einsatzbeispiel könnte sein:

if(aktuellerHelligkeitswert < schwellenWert && lichtAus == 1)
//Code um Licht einzuschalten

Der Code um das Licht einzuschalten würde nur ausgeführt werden, wenn es aktuell dunkler ist als der definierte Schwellenwert UND das Licht auch aus ist, also die lichtAus Variable den Wert 1 enthält. Wäre nur das Licht aus oder nur der aktuelle Helligkeitswert niedriger als der Schwellenwert, würde der Code um das Licht einzuschalten, nicht ausgeführt werden.

Angenommen die lichtAus Variable wäre vom Datentyp boolean, dann könnte man die Bedingung folgendermaßen noch vereinfachen:

if(aktuellerHelligkeitswert < schwellenWert && lichtAus)
//Code um Licht einzuschalten

Der Vergleich für die Variable lichtAus wird hier selbständig anhand des Wertes durchgeführt. Wenn die Variable den Wert 1 bzw. true enthält, ist die Bedingung wahr und wenn sie 0 bzw false enthält, ist die Bedingung nicht wahr. Das kann mit einem davorstehenden Ausrufezeichen zusätzlich negiert werden.


Rainer Sturm /

Ein String stellt eine beliebige Zeichenfolge, mit einer bestimmten Enkodierung, in C# ist es UTF 16,  dar. UTF 16 (Unicode Transformation Format) unterstützt sehr viele aber nicht alle Zeichen, hier findest du eine Auflistung aller unterstützten Zeichen.  Zurück zum String, man nutzt diesen Datentyp  um Zeichenketten oder Text in einer Variable abzulegen. Dies kann zum Beispiel der Fall sein, wenn ein Benutzer Eingaben auf einem Formular zu Registrierung auf einer Webseite gemacht hat. Dann werden diese Daten meist validiert, also auf ihre Gültigkeit geprüft, mit den Daten in der Datenbank abgeglichen und bei Erfolg in der Datenbank gespeichert. In Variablen vom Typ String werden also Zeichen abgelegt die sich mit den anderen Datentypen schlecht oder gar nicht realisieren lassen. Beispielsweise könnten Kundennummern auch Buchstaben enthalten, dadurch wären diese nicht für einen numerischen Datentypen, wie integer oder double geeignet. In C# und Java bieten die Frameworks eine Vielzahl von mächtigen Funktionen in der String Klasse an. Ein paar von mir häufig genutzte Beispiele:

  • „Replace“ zum Ersetzen von Zeichen, wenn ungewünschte oder verbotene Zeichen oder Zeichenfolgen vorhanden sind.
  • Substring“ ruft einen Teil des Strings, an einer bestimmten Stelle, für eine feste Länge, auf
  • Trim“ schneidet am Ende und Anfang leere Zeichen (spaces) oder ggf. auch andere Zeichen wie führende oder anhängende 0en ab
  • Split“ unterteilt die Zeichenkette in weitere Zeichenketten zum Beispiel anhand eines Trennzeichens. Dies könnte bei CSV Dateien zum Einsatz kommen
  • Join“ ist das Gegenstück zu Split es verkettet mehrere Strings zu einem und fügt ggf. Trennzeichen ein
  • Length“ ist eine Eigenschaft und gibt die Anzahl der Zeichen dieser Zeichenkette zurück
  • Contains“ überprüft ob eine Zeichenfolge in dem String vorhanden ist
  • Equals“ überprüft ob die Zeichenfolge den gleichen Wert wie eine andere Zeichenfolge hat

Es gibt noch viel mehr Funktionen die die String Klasse mit sich bringt, die man für C# in der Microsoft, bzw. für Java in der Oracle Dokumentation alle nachschlagen kann.

Oft werden auch zwei Strings aneinander gehangen, wie im folgenden C# Beispiel:

 string vorname;
 string nachname;
 Console.Write("Bitte geben Sie ihren Vornamen ein:\t");
 vorname = Console.ReadLine();
 Console.Write("\nBitte geben Sie Ihren Nachname ein:\t");
 nachname = Console.ReadLine();
 Console.WriteLine("\nSie heißen:\t\t\t\t" + vorname + " " + nachname);

Der Benutzer wird gebeten, erst seinen Vornamen, danach seinen Nachnamen einzugeben. Anschließend wird sein Name auf der Konsole ausgegeben. Dazu wurde der String „Sie heißen:“ mit der Variable strVorname, einem Leerzeichen und der Variable strNachname konkateniert, also verknüpft.

Das Ergebnis sieht folgendermaßen aus:

Empfohlene weiterführende Literatur:

Grundkurs C: C-Programmierung verständlich erklärt

C# 6 mit Visual Studio 2015: Das umfassende Handbuch: Spracheinführung, Objektorientierung, Programmiertechniken

Programmieren lernen mit Java


Switch Case Anweisung

adel /


Die Switch Case Anweisung kann man nutzen, wenn man aus einer festen Menge von möglichen Kandidaten auswählt. Sie könnte zum Beispiel eingesetzt werden wenn auf einem Telefon eine entsprechende Taste gedrückt wurde. Wenn die 1 gedrückt wurde, könnte man zum Beispiel eine Weiterleitung an einen anderen Service implementieren. Wenn die 2 gedrückt wurde, könnte man die Weiterleitung mit einem Servicemitarbeiter umsetzen und so weiter.

Jede Switch Case Anweisung ließe sich auch mit einer „If elseif“ Anweisung umsetzen. Der Vorteil der Switch Case Anweisung ist, dass sie besser lesbar ist, da sie nicht so tief verschachtelt ist.

Der Aufbau ist recht einfach erklärt:

  1. Es startet mit dem Switch Keyword
  2. In den Klammern nach dem Keyword die Variable die überprüft wird
  3. In geschweiften Klammern, die Case Klausel gefolgt von
  4. Dem bedingten Wert und einem Doppelpunkt
  5. Dann kommt die eigentliche Anweisung die ausgeführt werden soll, wenn die Variable diesen Wert enthält.
  6. Am Ende eines Caseblocks steht das Schlüsselwort „break“. Es verhindert ein weiteres Ausführen des nachfolgenden Codes.
  7. Am Ende das optionale Schlüsselwort „default“ der hierauf folgende Code wird ausgeführt, wenn keiner der vorherigen Bedingungen wahr ist, oder bei der vorherigen Anweisung das Schlüsselwort „break“ nicht benutzt wurde.

Zum Beispiel C#, Java und weitere

Zum Beispiel C#, Java und weitere

      int number = 1;
      switch (number)
          case 1:
              //Auszuführender Code wenn Number = 1 ist
          case 2:
              //Auszuführender Code wenn Number = 2 ist
              //Wird ausgeführt wenn andere Bedingungen nicht wahr sind


Dim number As Integer = 8
 Select Case number
 Case 1
 //Auszuführender Code wenn die Number = 1 ist
 Case 2
 //Auszuführender Code wenn die Number = 2 ist
 Case Else
 //Wird ausgeführt wenn andere Bedingungen nicht wahr sind
End Select

In C# 7 wurde die Switch Anweisung weiterentwickelt. Es ist nun möglich auf jede Art von Typ ein Switch auszuführenden, zum Beispiel auf komplexe Objekte. Es können weiterführende Vergleiche (Pattern) in der Case Klausel benutzt werden. Hier findest du weiterführende Information von Microsoft. 

Um das Ganze noch ein bisschen greifbarer zu machen möchte ich gerne noch ein bisschen zusätzlichen Code mit euch teilen. Nachfolgend findet ihr Code für einen etwas erweiterten Taschenrechner, er kann auch Wurzeln ziehen und quadrieren (wenn W bzw. Q als Operator eingegeben wird). Auch Kommazahlen kann er verarbeiten, allerdings nur Zahlen zwischen -28000 und +28000. Wenn dich das stört, ändere es doch einfach ;). Wenn du Fragen hast nutze bitte die Kommentarfunktion.

using System;

namespace Rechnen

    class Program

        static void Main(string[] args)
            string strOperator;
            double dblZahl1;
            double dblZahl2;
            double dblErgebnis = 0;

            Console.WriteLine("\t\t*****\terweiterter Taschenrechner\t*****\n\n");
            Console.Write("Geben Sie die erste Zahl ein:\t\t\t\t\t");
            dblZahl1 = Convert.ToDouble(Console.ReadLine());

            if (dblZahl1 < -28000 | dblZahl1 > 28000)
                Console.WriteLine("\n\nFehler: Bitte geben Sie eine Zahl zwischen -28.000 und 28.000 (achtundzwanzigtausend) ein.");
                Console.Write("Geben Sie +, -, *, /, Q, oder W für die Rechenart ein:\t\t");
                strOperator = Console.ReadLine();

                if (strOperator == "+" || strOperator == "-" || strOperator == "*" || strOperator == "/" || strOperator == "W" || strOperator == "Q")

                    switch (strOperator)
                        case "Q":

                            dblErgebnis = Math.Pow(dblZahl1, 2);

                        case "W":

                            if (dblZahl1 < 0)
                                Console.WriteLine("\n\nFehler: Eine Wurzel aus einer negativen Zahl zu ziehen, ist leider nicht möglich, bitte geben Sie eine Zahl die <= 0 ist ein.");
                                dblErgebnis = Math.Sqrt(dblZahl1);


                            Console.Write("Geben Sie die zweite Zahl ein:\t\t\t\t\t");
                            dblZahl2 = Convert.ToDouble(Console.ReadLine());

                            if (dblZahl2 < -28000 | dblZahl2 > 28000)
                                Console.WriteLine("\n\nFehler: Bitte geben Sie eine Zahl zwischen -28.000 und 28.000 (achtundzwanzigtausend) ein.");
                                if (strOperator == "/" && dblZahl2 == 0)
                                    Console.WriteLine("\nFehler: Eine Division durch Null ist mathematisch nicht möglich, nehmen Sie eine andere Zahl!");
                                    Console.WriteLine("\n\n\n\n\n\n\n\n\n\n\n\n\n\n\t\t\t\t\t\t\"Development by Kai Fischer\"");

                                    switch (strOperator)

                                        case "+":

                                            dblErgebnis = dblZahl1 + dblZahl2;

                                        case "-":

                                            dblErgebnis = dblZahl1 - dblZahl2;

                                        case "*":

                                            dblErgebnis = dblZahl1 * dblZahl2;

                                        case "/":

                                            dblErgebnis = dblZahl1 / dblZahl2;

                                    if (strOperator == "+" | strOperator == "-" | strOperator == "*" | strOperator == "/" | strOperator == "W" | strOperator == "Q")
                                        Console.WriteLine("\nDas Ergebnis ihrer Rechnung lautet:\t\t\t\t{0}", Math.Round(dblErgebnis, 2));
                                        Console.WriteLine("\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\t\t\t\t\t\t\"Development by\"");


                    Console.WriteLine("\nDies war keine gültige Eingabe für einen Operanden.\nBitte geben Sie +, -, *, /, Q oder W ein.");
                    Console.WriteLine("\n\n\n\n\n\n\n\n\n\n\n\n\n\n\t\t\t\t\t\t\"Development by\"");


Empfohlene weiterführende Literatur:

Grundkurs C: C-Programmierung verständlich erklärt

C# 6 mit Visual Studio 2015: Das umfassende Handbuch: Spracheinführung, Objektorientierung, Programmiertechniken

Programmieren lernen mit Java