Erstes Programm

Du hast das SDK schon installiert und ein erstes Labor gestartet. Der Bildschirm zeigte pine. Diese Seite bleibt bei derselben Programmform und stellt eine andere Frage: Welche Zeile in der Datei hat dieses Wort geschrieben, und welche Zeilen haben nichts geschrieben. Du installierst .NET nicht noch einmal. Die Versionszeile von der letzten Seite kann bleiben, wie sie war. Behalte die öffentliche Klasse namens Pine, behalte Main und behalte Console.WriteLine("pine");. Der Bildschirm, den du erklärst, ist weiterhin eine Zeile, und diese Zeile ist pine.

Die Datei hat mehr als eine Zeile, also ist die erste Vermutung, dass jede Dateizeile zu einer Bildschirmzeile wird. Diese Vermutung ist falsch, und der Rest dieser Seite zeigt warum. Mehrere Zeilen benennen etwas. Nur eine davon schreibt. Die geschweiften Klammern gruppieren diese Zeilen. Auch sie schreiben nicht. Wenn du mit der Datei vor dir auf die Schreibzeile zeigen kannst, ist diese Seite fertig. Die nächste Seite fügt eine Notiz hinzu, die der Bildschirm nicht zeigt. Sie ändert pine nicht.

using System bereitet kurze Namen vor

Die erste nützliche Zeile ist using System;. Lies sie als Vorbereitungszeile, nicht als Satz, den der Bildschirm drucken wird. Sie holt Namen aus dem Namensraum System in Kurzform, damit Console ohne langen Pfad erscheinen kann. Du siehst das Wort using nicht auf dem Bildschirm. Du siehst System nicht auf dem Bildschirm. Löschst du diese Zeile in einem falschen Experiment, kann der kurze Name Console später scheitern — das ist eine Compile-Geschichte für einen anderen Tag. Auf dieser Seite bleibt die Zeile, und der Bildschirm bleibt pine, weil diese Zeile nicht schreibt.

Die Klassenzeile benennt den Typ

Die nächste Typzeile ist public class Pine. Lies sie als drei Wörter mit einer Aufgabe, nicht als Bildschirmtext. public heißt, anderer Code darf diesen Typ nutzen. Du siehst public nicht auf dem Bildschirm. class heißt, diese Datei definiert eine benannte Einheit. Du siehst class nicht auf dem Bildschirm. Pine ist der Name dieser Einheit. In dieser Lehrform passt der Dateistamm zu diesem Namen. Ändere den Namen in dieser Zeile, und die Dateinamengewohnheit muss mitgehen. Diese Regel betrifft Typ und Datei. Sie betrifft nicht den Bildschirm. Schau noch einmal auf den Bildschirm. Der Bildschirm zeigt kein Pine. Er zeigt pine. Das große P und das kleine p sind nicht dasselbe Wort. Die Klassenzeile schreibt ihren Namen nie auf den Bildschirm.

Das Zeichen nach dieser Zeile ist eine öffnende geschweifte Klammer {. Die passende schließende Klammer später in der Datei beendet den Klassenrumpf. Alles zwischen diesen Klammern gehört zur Klasse Pine. Die Klammern sind Zäune. Sie sagen C#, wo diese Einheit beginnt und wo sie endet. Ein Zaun ist kein Text für den Bildschirm. Du wirst neben pine weder { noch } sehen. Löschst du die öffnende Klammer, ist die Datei kaputt und der Compiler schreibt einen Fehler statt still zu bleiben. Dieser Fehler ist nicht diese Seite. Diese Seite behält beide Klammern, und der Bildschirm bleibt pine.

Die Main-Zeile ist, wo die Runtime startet

Die nächste Zeile ist public static void Main(). Das ist die Zeile, auf die Leute zeigen, wenn man fragt, wo das Programm startet, und sie haben mit dem Start recht. Sie irren, wenn sie danach sagen, der Bildschirm zeige Main. Die Runtime sucht nach einer Methode mit dieser Form, wenn du das Projekt startest. Sie beginnt an dieser Zeile zu laufen. Starten ist nicht dasselbe wie Schreiben. Die Wörter auf der Zeile sind Anweisungen darüber, wie gestartet wird. Sie sind keine Wörter für den Bildschirm.

Nimm die Wörter einzeln und prüfe jedes gegen den Bildschirm. public heißt wieder, die Methode kann von außen gestartet werden. static heißt, die Runtime kann diese Methode starten, ohne zuerst ein Objekt zu bauen. Du hast Objekte noch nicht getroffen, also brauchst du nur die Tatsache, dass static in dieser Lehrform nötig ist und nicht gedruckt wird. void heißt, diese Methode gibt einem Aufrufer keinen Wert zurück. Auf dieser Seite gibt es keine Aufrufer-Geschichte, und void steht nicht auf dem Bildschirm. Main ist der Name, den die Runtime in dieser Form nachschlägt. Der Bildschirm zeigt diese vier Buchstaben immer noch nicht. Runde Klammern markieren die Parameterliste. Auf dieser Seite ist die Liste leer. Leere Klammern drucken auch nichts.

Die Main-Zeile kann also auf zwei Arten zugleich wahr sein. Die Runtime hat dort gestartet. Der Bildschirm hat von dieser Zeile kein einziges Wort bekommen. Wenn deine Augen auf Main ruhen, weil es in der Mitte der Datei sitzt, beweg sie. Das Wort, das du vom Bildschirm erinnerst, ist pine, und pine steht nicht auf dieser Zeile.

Die innere Zeile schreibt pine

Innerhalb von Main, zwischen seinen eigenen geschweiften Klammern, gibt es noch eine Zeile. Diese Zeile ist Console.WriteLine("pine");. Das ist die Zeile, die den Bildschirm schreibt. Sie ist in der Datei eingerückt, damit du siehst, dass sie in Main sitzt. Die Einrückung sind Leerzeichen. Leerzeichen werden auch nicht auf den Bildschirm geschrieben. Die Runtime führt diese innere Zeile aus, weil sie in der Methode liegt, wo das Programm startet. Der Bildschirm nutzt, was diese innere Zeile schreibt. Er nutzt nicht den Namen der äußeren Methode.

Lies die innere Zeile von links. Console ist der Bildschirmhelfer, den dieser Kurs nutzt. WriteLine heißt: schreib das, dann beende die Zeile. Der Teil in den runden Klammern ist das, was geschrieben wird. In den Klammern sitzt das Wort pine zwischen doppelten Anführungszeichen. Die Anführungszeichen markieren pine als Text. Sie sind nicht Teil des Texts. Nimm sie im Kopf weg, und das Wort, das bleibt, ist pine, und das ist der ganze Bildschirm. Lass sie in der Datei. Ohne die Anführungszeichen behandelt der Compiler pine nicht als dieses Textliteral. Das Semikolon am Ende schließt die Anweisung für C#. Du siehst kein Semikolon auf dem Bildschirm. Du siehst pine, und dann endet die Zeile, weil WriteLine sie beendet hat.

Hier ist diese Schreibzeile allein, damit die anderen Zeilen sie nicht verstecken können.

Nichts im Befehl dotnet run wählt das Wort pine. Der Befehl startet nur das Projekt. Das Wort kommt aus den Anführungszeichen. Hielten die Anführungszeichen ein anderes Wort, würde der Bildschirm dieses Wort zeigen, und diese Seite tut das nicht. Die Anführungszeichen auf dieser Seite halten pine, also ist der Bildschirm pine. Eine Zeile. Keine zweite Zeile. Keine Anführungszeichen auf dem Bildschirm. Kein Wort Main. Kein Wort Pine.

Was Leute falsch lesen

Der übliche Fehler ist, die Datei von oben zu lesen und anzunehmen, das vertrauteste Wort sei die Ausgabe. Main wirkt wichtig, und es ist wichtig, weil die Runtime diese Form ohne es nicht startet. Wichtigkeit ist keine Ausgabe. Du kannst die Main-Zeile mit einem Finger abdecken, und die Schreibzeile ist immer noch Console.WriteLine("pine");. Du kannst die Schreibzeile nicht abdecken und den Bildschirm trotzdem erklären. Ein anderer Fehler ist zu sagen, der Bildschirm zeige Pine, weil die Klasse Pine heißt. Der Bildschirm nutzt das Wort zwischen den Anführungszeichen, und dieses Wort ist mit kleinem p geschrieben. Ein dritter Fehler ist, Zeilen zu zählen. Die Datei zeigt mehrere Zeilen und mehrere Klammern. Der Bildschirm zeigt eine. Klammern, die Wörter public und static und void, der Name Main, der Name Pine und using System; stehen nach dem Lauf alle noch in der Datei. Der Lauf löscht sie nicht. Er druckt sie auch nicht.

Der Bildschirm kommt von einer Zeile

Du kannst einen Finger auf Console.WriteLine("pine"); legen und sagen, dass von dieser Zeile der Bildschirm kommt. Du kannst einen Finger auf public static void Main() legen und sagen, dass die Runtime dort startet und dass das Wort Main nicht auf dem Bildschirm steht. Du kannst einen Finger auf public class Pine legen und sagen, dass dieser Name zum Lehrtyp passt und nicht zum Bildschirm. Die nächste Seite legt eine Notiz in die Datei. Die Notiz ist für eine Person, die die Datei liest. Der Bildschirm bleibt pine, weil die Notiz kein zweites WriteLine ist.
Halt übrig gebliebene Java-Gewohnheiten mit System.out.println("mint") von dieser Seite fern, wenn du die C#-Schreibzeile übst. Halt erfundene ASP.NET-Routen von dieser Seite fern. Halt die Behandlung von dotnet --version als Bildschirmwort von dieser Seite fern — die Versionszeile war Installationsnachweis, nicht die Ausgabe dieses Programms. Wenn du die Schreibzeile nennen und die falschen Vermutungen von Main und Pine ablehnen kannst, hat First Program seine Arbeit getan und du bist bereit für C# Comments, wenn du weitermachst.