Erste Schritte mit C♯  unter Microsoft® Windows 7 

Viele einfache C♯ -Programme lassen sich schon mit einer Webseite wie »dotnetfiddle.net« ausführen.

Aktuelle Dotnet-Version installieren

Bis zur Version 5.0 von C♯  war der Compiler für C♯  Teil des Dotnet-Frameworks.

Den Compiler für die Version 6.0 von C♯  ist unter der folgenden URI zu finden.

Microsoft Build Tools 2015

https://www.microsoft.com/en-us/download/details.aspx?id=48159&6B49FDFB-8E5B-4B07-BC31-15695C5A2143=1
https://download.microsoft.com/download/E/E/D/EEDF18A8-4AED-4CE0-BEBE-70A83094FC5A/BuildTools_Full.exe

Es kann nicht schaden, davor eine aktuelle Version des Microsoft-.NET-Framework 4.6.1 zu installieren.

Microsoft .NET Framework 4.6.1

https://www.microsoft.com/en-us/download/details.aspx?id=49982
https://download.microsoft.com/download/E/4/1/E4173890-A24A-4936-9FC9-AF930FE3FA40/NDP461-KB3102436-x86-x64-AllOS-ENU.exe

Arbeitsverzeichnis anlegen

In weiteren Verlauf der Vorbereitung der Ausführung von C♯ -Programmen wird es sich als hilfreich erweisen, ein Verzeichnis für vom Leser angelegte Dateien zur Verfügung zu haben. Daher sollte der Leser jetzt ein solches Verzeichnis an einem der Orte anlegen, an dem er auch sonst von ihm angelegte Verzeichnisse und Dateien speichert.

C♯ -Implementation finden

Durch die Eingabe des folgenden Kommandos in das Windows -Programm cmd  können wir den Ort der C♯ -Implementation auf der Festplatte finden.

Eingabe

dir /s/b C:\csc.exe

Es ist zum Erlernen der Programmiersprache C♯  nicht wichtig, dieses dir-Kommando genau zu verstehen, so daß wir hier auf weitere Erläuterung verzichten.

Es kann einige Minuten dauern, bis dieses Kommando beendet ist. Die Ausgabe hängt von dem System ab, auf welchem das Kommando gestartet wird, und könnte beispielsweise ähnlich wie folgt lauten.

mögliche Ausgabe

C:\Program Files\MSBuild\14.0\Bin\csc.exe
C:\Windows\Microsoft.NET\Framework\v2.2.344\csc.exe
C:\Windows\Microsoft.NET\Framework\v3.6\csc.exe
C:\Windows\Microsoft.NET\Framework\v4.0\csc.exe
C:\Windows\Microsoft.NET\Framework64\v2.2.344\csc.exe
C:\Windows\Microsoft.NET\Framework64\v3.6\csc.exe
C:\Windows\Microsoft.NET\Framework64\v4.0\csc.exe
C:\Windows\winsxs\…

In der erhaltenen Ausgabe können wir zunächst alle Pfade mit »winsxs« ignorieren.

Falls vorhanden sollte für die nächsten Schritte der Pfad mit »C:\Program Files\MSBuild\14.0\Bin\csc.exe« verwendet werden. Ansonsten sollten sollten für den nächsten Schritt die Pfade mit »64« verwendet werden, wenn mit einer 64-Bit-Verson von Microsoft® Windows  gearbeitet wird, andernfalls die Pfade ohne  »64«, und dann sollte der Pfad mit der größten Versionsnummer  ausgewählt werden; in dem obigen Beispiel wäre dies für eine 64-Bit-Verson von Microsoft® Windows  beispielsweise der Pfad »C:\Windows\Microsoft.NET\Framework64\v4.0\csc.exe«.

Die Versionsnummer kann nicht immer dem Pfad entnommen werden! Eventuell muß der Bearbeiter an dieser Stelle zusätzliche Nachforschungen anstellen, um herauszufinden, welcher der beste oder neueste Compiler ist.

Dieser Pfad sollte für spätere Verwendung aufbewahrt werden. Wir nennen ihn den CSC-Pfad. (Die Abkürzung “csc ” bedeutet so viel wie “C Sharp compiler ”.)

Dateien anlegen

Nun sind zwei Textdateien anzulegen. Im folgenden finden sich Wiedergaben dieser zwei Dateien in einer Form, bei der zuerst der Name der anzulegenden Textdatei und darunter eingerückt ihr Inhalt angegeben ist. Diese Anleitung setzt voraus, daß der Leser das Anlegen von Textdateien unter Windows  bereits erlernt hat. Obwohl der Inhalt dieser Dateien Text sein soll, soll die Dateinamenserweiterung nicht ».txt« sein, sondern jeweils wie angegeben lauten.

»Run.cmd«

In die folgende Datei »Run.cmd« ist der im vorigen Schritt erhaltene CSC-Pfad hinter das Gleichheitszeichen in der ersten Zeile einzufügen. In dem folgenden Beispiel findet sich beispielsweise »C:\Windows\Microsoft.NET\Framework64\v4.0\csc.exe« als CSC-Pfad. Dieser ist durch den im vorigen Schritt erhaltenen CSC-Pfad zu ersetzen.

Run.cmd (Beispiel, ist unter Umständen noch anzupassen)

@set CSC=C:\Program Files\MSBuild\14.0\Bin\csc.exe
"%CSC%" /nologo /warn:4 /debug /optimize ^
  /reference:C:\Windows\Microsoft.NET\Framework64\v4.0.30319\Microsoft.JScript.dll ^
  /reference:System.IO.Compression.FileSystem.dll ^
  /reference:C:\Windows\Microsoft.NET\Framework64\v4.0.30319\WPF\PresentationCore.dll ^
  /reference:C:\Windows\Microsoft.NET\Framework64\v4.0.30319\WPF\PresentationFramework.dll ^
  /reference:System.dll ^
  /reference:System.Windows.dll ^
  /reference:System.Xaml.dll ^
  /reference:C:\Windows\Microsoft.NET\Framework64\v4.0.30319\WPF\WindowsBase.dll ^
  Program.cs
@IF NOT ERRORLEVEL 1 .\Program.exe
@PAUSE

»Program.cs«

Die folgende Datei ist das eigentliche C♯ -Programm. Wenn es gestartet wird, schreibt es den Text »Hallo, Welt!«.

Program.cs

public static class Program
{ public static void Main()
  { global::System.Console.WriteLine
    ( "Hallo, Welt!" ); }}

Als den eigentlichen Namen  einer Datei bezeichnen wir hier den Teil des Dateinamens vor dem letzten Punkt. Der eigentliche Name der Datei »Program.cs« lautet also »Program«.

Der Name der Klasse muß nicht  mit dem eigentlichen Namen der Datei übereinstimmen.

Wenn ein einfaches Kommando, in der Art wie »csc Program.cs« zum Übersetzen verwendet wird, so wird der Name der ausführbaren Datei »Program.exe« aus dem Namen der Datei  »Program.cs« gebildet – nicht  aus dem Namen der Klasse (»Program«).

In dem obigen Programm beginnt eine Klasse mit »static class«. Der Klassenname ist der Name dieses Klasse und wird durch das Wort festgelegt, welches direkt hinter »class« steht.

Das Programm starten

Nun kann die Datei »Run.cmd« gestartet werden, die dann ihrerseits das C♯ -Programm startet. Hierzu kann der Eintrag »Öffnen« im Kontextmenü jener Datei aktiviert werden. Daraufhin sollte sich ein Konsolenfenster öffnen und die Ausgabe des Skripts anzeigen.

Ausgabe des Skripts (ähnlich)

>set CSC=C:\Program Files\MSBuild\14.0\Bin\csc.exe
>"C:\Program Files\MSBuild\14.0\Bin\csc.exe" Program.cs
Microsoft (R) Visual C# Compiler version 4.0.30319.18408
for Microsoft (R) .NET Framework 4.5
Copyright (C) Microsoft Corporation. All rights reserved.
>IF NOT ERRORLEVEL 1 .\Program.exe
Hallo, Welt!
>PAUSE
Press any key to continue . . .

In der Ausgabe des Skripts lassen sich vier Abschnitte erkennen.

Der erste Abschnitt zeigt das ausgeführte set-Kommando an, welches den CSC -Pfad festlegt. Es ist zum Erlernen der Programmiersprache C♯  nicht wichtig, dieses set-Kommando genau zu verstehen, so daß wir hier auf weitere Erläuterung verzichten.

Der zweite Abschnitt zeigt das Kommando, mit dem der C♯ -Compiler gestartet wird. Es handelt sich dabei um ein Programm, welches C♯ -Programme auf Fehler überprüft und zur Ausführung vorbereitet.

Der dritte Abschnitt zeigt das Kommando, mit dem das vom C♯ -Compiler zur Ausführung vorbereitete C♯ -Programm, welches nun »Hello.exe« heißt, gestartet wird, falls die Übersetzung gelang. Das C♯ -Programm gibt dann den Text »Hallo, Welt!« aus.

Die erzeugte exe-Datei kann in der Regel jederzeit gelöscht werden, da sie aus der cs-Programmdatei wieder hergestellt werden kann.

Im letzten Abschnitt sieht man schließlich noch das Kommando »PAUSE«. Es verhindert das Schließen des Konsolenfensters solange, bis eine Taste in diesem Konsolenfenster gedrückt wird, und ermöglicht es so, die obenstehenden Ausgaben zu lesen.

Weitere Software

Einige Programm, die in Zusammenhang mit der C♯ -Programmierung noch nützlich sein könnten, sind: SharpDevelop, LINQPad, Red Gate's .Net-Reflector, ILSpy  oder dotPeek.

Übungsaufgaben

/   Programm starten

Führen Sie die oben beschriebenen Schritte aus, um das C♯ -Programm zu starten.

/   Programmausgabe ändern

Ändern Sie das Programm so ab, daß es nicht mehr »Hallo, Welt!«, sondern »Ausgabe« ausgibt. Dazu ist die Datei »Program.cs« in der letzten Zeile zu verändern. Zur Kontrolle soll das Programm dann durch Öffnen der Datei »Run.cmd« gestartet werden.

Ausgabe des Skripts (ähnlich)

>set CSC=C:\Windows\Microsoft.NET\Framework64\v4.0.30319\csc.exe
>"C:\Windows\Microsoft.NET\Framework64\v4.0.30319\csc.exe" Main.cs
Microsoft (R) Visual C# Compiler version 4.0.30319.18408
for Microsoft (R) .NET Framework 4.5
Copyright (C) Microsoft Corporation. All rights reserved.
>IF NOT ERRORLEVEL 1 .\Main.exe
Ausgabe
>PAUSE
Press any key to continue . . .

Variante für den Unterrichtsraum TK309 (32-Bit Windows)

RUN.cmd

@set CSC=C:\Program Files\MSBuild\14.0\Bin\csc.exe
@"%CSC%" /nologo /warn:4 /debug /optimize ^
/reference:C:\Windows\Microsoft.NET\Framework\v4.0.30319\Microsoft.JScript.dll ^
/reference:System.IO.Compression.FileSystem.dll ^
/reference:C:\Windows\Microsoft.NET\Framework\v4.0.30319\WPF\PresentationCore.dll ^
/reference:C:\Windows\Microsoft.NET\Framework\v4.0.30319\WPF\PresentationFramework.dll ^
/reference:System.dll ^
/reference:System.Windows.dll ^
/reference:System.Xaml.dll ^
/reference:C:\Windows\Microsoft.NET\Framework\v4.0.30319\WPF\WindowsBase.dll ^
Program.cs
@IF NOT ERRORLEVEL 1 .\Main.exe
@PAUSE

Program.cs

public static class Program
{ public static void Main()
  { global::System.Console.WriteLine
    ( "orkten" ); }}";

Autohotkey.txt

    run_java_main() {
    SetTitleMatchMode 3
    IfWinExist, %A_WinDir%\system32\cmd.exe
    WinClose
    IfWinExist, %A_WinDir%\system32\cmd.exe
    WinClose
    SetTitleMatchMode RegEx
    IfWinExist, i)Program\.cs - (Editor|Notepad)
    WinActivate
    Else
    Run %A_WinDir%\notepad.exe %A_ScriptDir%\Program.cs,,Max
    Send ^s
    Run "%A_ScriptDir%\RUN.cmd",%A_ScriptDir%
    Return
    }
    ^R::
    run_java_main()
    Return
    ^E::
    SetTitleMatchMode RegEx
    IfWinExist, i)Program\.cs - (Editor|Notepad)
    WinActivate
    Else
    Run %A_WinDir%\notepad.exe %A_ScriptDir%\Program.cs,,Max
    Return
    ^H::
    Send ^c
    SetTitleMatchMode RegEx
    IfWinExist, i)Program\.cs - (Editor|Notepad)
    WinActivate
    Else
    { 
      Run %A_WinDir%\notepad.exe %A_ScriptDir%\Program.cs,,Max
      sleep, 999 
      }
    sleep, 99 
    Send ^a
    Send ^v
    run_java_main()
    Return
    ^B::
    Send ^c
    SetTitleMatchMode RegEx
    IfWinExist, i)Program\.cs - (Editor|Notepad)
    WinActivate
    Else
    { 
      Run %A_WinDir%\notepad.exe %A_ScriptDir%\Program.cs,,Max
      sleep, 999 
      }
    sleep, 99 
    Send ^a
    SendInput public public static class Program{enter}{{} public static void Main(){enter}  {{} global::System.Console.WriteLine{enter}    ({space}
    Send ^v
    Send {space}); {}}{}}
    run_java_main()
    Return
    ^D::Run, cmd /c start Firefox http://msdn.microsoft.com/en-us/library/gg145045(v=vs.110).aspx,,Max
    ^O::
    Run, cmd /c start Firefox http://www.google.de,,Max
    Return
    :*?:qjp::
    SendInput global::System.Console.WriteLine(
    return

Autohotkey.cmd

Start Autohotkey Autohotkey.txt

Anleitung

Strg-R   Run                 Ausfuehren des Programms
Strg-E   Edit                Bearbeiten des Programms
Strg-H                       Ausfuehren der Markierung als Programm
Strg-B   Bitte auswerten!    Auswertung der Markierung als Ausdruck
Strg-D   Documentation       Dokumentation
Strg-O   Off to Google       Zu Google gehen

Motivation

Warum wird im Kurs mit Textdateien gearbeitet?

• Textdateien können von Programmen aus generiert werden, und so können C#-Programme aus innerhalb von Skripten ausgeführt werden. (Siehe mein SQL-Kurs-Skript.)

 O
/|\ -------> GUI
/ \
 O
/|\ -.
/ \   '-.
         :-> Text
      .-'
Prg -'        

• Anstatt der manuellen Ausführung von Bedien- und Konfigurationsvorgängen, können die Konfigurationen als Text mit einem einzigen Schritt verarbeitet werden. (Beispielsweise Referenzierungen von Bauten.)
• Textdateien sind für Menschen und Computer gleichermaßen einsehbar und schreibbar. Spezielle binäre Dateien einzelner GUI-IDEs sind nicht immer für Menschen verständlich und können nicht als Text in diesem Skriptum abgedruckt werden.
• Es gibt verschiedene IDEs für C♯, und es müßte relativ willkürlich eine davon ausgewählt werden, während die Build-Tools eine einigermaßen neutrale Auswahl darstellen.
• Da GUI-Programm eher selbsterklärend sind, können Kursteilnehmer sich die Bedienung von GUI-Programmen oft selber aneignen und brauchen hier weniger Hilfe. Kursteilnehmer können auch GUI-IDEs, deren Bedienung sie schon beherrschen, im Kurs verwenden.
• Die Verwendung textbasierter Programme macht das Programmieren als Steuerung eines Computers durch Texte transparent und verhindert irrige Vorstellung, wie etwa den Glauben, daß GUI-Programme nur mit einer GUI-IDE geschrieben werden können.