Erweiterte Grundlagen - Entwicklungsumgebung

Im Kapitel Grundlagen Teil 1 wurden erklärt wie ein Projekt erstellt wird und die am Anfang notwendigen Funktionen behandelt. In diesem Kapitel sollen ein paar weitere Funktionen, von Visual C# erläutert werden. Dabei handelt es sich um Funktionen, die für einen Anfänger hilfreich sein können oder um Funktionen, die benötigt werden. Es ist offensichtich, dass nur ein Bruchteil der Funktionen von Visual C# behandelt wird. Allerdings ergeben sich viele Funktionen mit der Zeit von selbst.

Kommentare

Bei den anfänglichen Programmen waren Kommentare kaum notwendig, weshalb sie in den vorheerigen Kapitel nicht erwähnt wurden. Jedoch ist es nützlich bei längeren Programmen den Programmcode zu kommentieren, um bei einem späteren Betrachten des Programmcodes einfacher nachvollziehen zu können, worin der Zweck einer Methode lag. Grundlegend sind Kommentare Zeilen / Bereich im Programmcode, welche nicht zum Programm gehören und beim Compilieren (interpretieren des Programmcodes) ignoriert werden. Es gibt zwei klassiche Arten Programmcode zu kommentieren, entweder eine einzelne Zeile oder einen Abschnitt im Programmcode.

Auskommentieren einer Zeile
erfolgt durch schreiben von // vor einer Zeile. Allerdings können diese Zeichen auch im späteren Verlauf einer Zeile erfolgen. Dadurch wird der restliche Text ab den // in der Zeile auskommentiert und beim Compilieren ignoriert.

In Visual C# würde ein Programm mit einer auskommentierten Zeile folgendermaßen aussehen:

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;

namespace Projekt1
{
      class Program
      {
            static void Main(string[] args)
            {
                  // Das ist eine auskommentierte Zeile!
            }
      }
}

Auskommentieren mehrere Zeilen
funktioniert etwas anders als das Auskommentieren einer Zeile. Beim Auskommentieren mehrere Zeilen wird am Anfang des auszukommentierenden Bereichs /* geschrieben und am Ende des Bereichs */. Dies wird auch häufig dazu verwendet um Programmcodeabschnitte aus Testgründen auszublenden. Man muss jedoch darauf achten, dass dabei nicht benötigter Code auskommentiert wird.

Ein auskommentierter Bereich würde folgendermaßen aussehen:

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;

namespace Projekt1
{
      class Program
      {
            static void Main(string[] args)
            {
                  /* auskommentierter Bereich
                  der über mehrere
                  Zeilen verläuft */

            }
      }
}

XML Kommentare
Diese Art von Kommentaren eignet sich sehr gut zur Dokumentation von Programmen, allerdings werden sie von den meisten Anfänger als Zwang / Ärgernis angesehen. Sie bieten allerdings einige Vorteile, da XML Kommentare mit Visual C# zusammenarbeiten. Ein XML Kommentare wird erstellt durch /// danach wird automatisch eine Grundstruktur erstellt.

Ein Besipiel mit der Klasse rechner und Methode division würde folgendermaßen aussehen:

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;

namespace Projekt1
{
      class Program
      {
            static void Main(string[] args)
            {
            }
      }

      class Rechner
      {
            /// <summary>
            ///
            /// </summary>
            /// <param name="dividend"></param>
            /// <param name="divisor"></param>
            /// <returns></returns>
            public int Division(int dividend, int divisor)
            {
                  return dividend / divisor;
            }
      }
}

summary, param, returns wird automatisch durch Visual C# erzeugt nachdem /// über die Methoden geschrieben wurde. Allerdings werden param und returns nur erstellt, wenn die Methode Parameter bzw einen Rückgabewert besitzt.

Es gibt einige weitere Zusatzfunktionen, welche für einen Anfänger nicht von Bedeutung sind. Aus diesem Grund möchte ich hier darauf verzichten.

Ein sinnvolles Kommentar auf dieses Beispiel bezogen könnte folgendermaßen aussehen:

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;

namespace Projekt1
{
      class Program
      {
            static void Main(string[] args)
            {
            }
      }

      class Rechner
      {
            /// <summary>
            /// Dividiert den Dividenden durch den Divisor
            /// </summary>
            /// <param name="dividend">Dezimalzahl durch die dividiert werden soll </param>
            /// <param name="divisor">Deziamlzahl mit welcher der Dividend dividiert werden soll </param>
            /// <returns>Ergebnis der Division</returns>
            public int Division(int dividend, int divisor)
            {
                  return dividend / divisor;
            }
      }
}

IntelliSense

intelliSense

Klingt toll, ist es auch. Der eine oder andere wird es auch schon genutzt haben ohne dass ich darauf eingegangen bin. Der Vorteil dieses System ist die Autovervollständigung und Beschreibung der Klassen, Methoden und deren Parametern. Des Weiteren, ist es oft hilfreich, wenn eine bestimmte Klasse oder Methode gesucht wird und einem der Name nicht auswendig bekannt ist. Ein weiterer Vorteil ist das Vermeiden von Tippfehlern.

Auf dem Bild rechts sehen wir ein klassisches Beispiel für eine IntelliSense Funktion. Es wurde die Instanz meinRechner von der Klasse Rechner aus dem Beispiel weiter oben erstellt. Danach war die Instanz meinRechner bekannt und nach dem Tippen der ersten zwei Buchstaben hat Visual C# meinRechner vorgeschlagen.
Durch Enter oder Tabulator wählt man das Selektiere Objekt aus. Natürlich besteht auch die Möglichkeit, mit den Pfeiltasten durch das Menü zu blättern ,um ein anderes Objekt auszuwählen.
Oft ist es hilfreich die Liste nach einer passenden Klasse / Methode zu durchsuchen. Ohne diese Funktion müsste man mühsam in einer Dokumentation nach einer passenden Klassen / Methode suchen. Zwar befreit einem diese Funktion nicht immer davon die Dokumentation nach einer passenden Klasse / Methode zu durchsuchen, spart jedoch sehr oft einiges an Zeit.

intelliSense2

Natürlich ist das längst nicht alles.
Nachdem wir meinRechner ausgewählt haben, schreiben wir einen Punkt, um Zugriff auf die public Elemente der Klasse Rechner zu bekommen. IntelliSense zeigt daraufhin die zur Verfügung gestellten Methode und Variablen an. Wie zu erwarten war, wird unsere Methode Division angezeigt, mit dem Text den wir bei summary definiert haben. Des Weiteren, sehen wir schon welche Parameter diese Methode benötigt und welchen Rückgabewert sie besitzt.
Wählen wir nun Enter / Tabulator die Methode aus, müssen wir noch die runde Klammer notieren.

intelliSense3

Nachdem man die runde Klammer geöffnet hat wird einem folgendes Bild gezeigt. Dabei werden weitere Informationen zu den Parametern gezeigt. Nicht sonderlich überraschend ist, dass es sich bei den beim ersten Parameter angezeigten Informationen um die handelt, welche wir beim Kommentar zu Parameter 1 notiert hatten. Nachdem der ersten Parameter notiert wurde und der erforderliche Beistrich notiert ist, werden einem die Informationen für den zweiten Parameter angezeigt.

Weitere Dateien zum Projekt hinzufügen

neueDatei1

Natürlich ist es nützlich weitere Quellcodedatein zu einem Projekt hinzuzufügen. Oft werden Klassen getrennt in einem File abgespeichert, um die Übersichtlichkeit zu verbessern. In unserem Fall lagern wir die Klasse Rechner in ein eigenes File aus. Dies erfolgt durch die Auswahl des Reiters Projekt, im oberen Menü und der Auswahl des darin enthaltenen Menüpunktes Neues Element hinzufügen. In dem sich daraufhin öffnenden Fenster, wählen wir Klasse und bennen das File in Rechner um, danach wird automatisch von Visual C# eine Datei mit allen notwendigen Programmzeilen erstellt.
Abschließend gilt es den Programmcode der Klasse Rechner aus der ersten Datei, in die erstellte Datei Rechner.cs zu kopieren. Anschließend muss die Klasse Rechner aus Program.cs entfernt werden, da eine Klasse nicht mehrmals vorhanden sein darf.

neueDatei2

Danach steht folgendes in den Dateien:

Program.cs

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;

namespace Projekt1
{
      class Program
      {
            static void Main(string[] args)
            {
            }
      }
}

Rechner.cs

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;

namespace Projekt1
{
      class Rechner
      {
            /// <summary>
            /// Dividiert den Dividenden durch den Divisor
            /// </summary>
            /// <param name="dividend">Dezimalzahl durch die dividiert werden soll </param>
            /// <param name="divisor">Deziamlzahl mit welcher der Dividend dividiert werden soll </param>
            /// <returns>Ergebnis der Division</returns>
            public int Division(int dividend, int divisor)
            {
                  return dividend / divisor;
            }
      }
}

Im Projektmappen - Explorer scheint die soeben erzeugte Datei auf und kann von dort aus zum Beispiel wieder gelöscht werden.

Bennen von Objekten und Programmcode-Struktur

Ein Thema, welches weniger mit Visual C# selbst zu tun hat ist die Lesbarkeit von Code.
Sobald Programme länger als 1-2 Seiten werden, kann es schnell dazu führen, dass es nach einer Weile schwer wird eine alte Stelle Programmcode zu lesen. Dies wird verstärkt durch ungünstige Variablen- Methodennamen. Allgemein empfiehlt es sich Namen zu verwenden, welche eindeutig deren Funktion beschreiben. Des Weiteren, gibt es gewisse Formatierungen, welche üblich aber kein Zwang sind. Ich empfehle es Methoden- Klassennamen groß geschrieben zu beginnen. Wenn der Name aus mehrer Einzelwörtern besteht, wieder mit einem Großbuchstaben zu beginnen. Im Gegensatz dazu sollten Variablen klein geschrieben beginnnen, können jedoch wie Methoden und Klassen aus mehreren Einzelwörter bestehen, welche mit Großbuchstaben beginnen. Allerdings möchte ich nochmals betonen, dass Leerzeichen nicht erlaubt sind. Ein Beispielname könnte meineVariable sein.

Programmcode - Struktur wird einem in C# recht einfach gemacht, da Programmcode automatisch nach einem gewissen Muster formatiert wird. Das Wichtigste ist immer nach einer geschwungene Klammer einen Tabulator einzurücken. Dadurch wird eine bessere optische Abgrenzung erzeugt. Wenn man sich an dieses Detail hält, lässt sich später leichter erkennen, welcher Teil des Programmcodes zum jeweiligen Programmblock gehört.