Namen in C♯ 

Namen sind daran erkennbar, daß sie – anders als Literale und Operatoren – mit einem Buchstaben  beginnen.

Ein Name ist ein Ausdruck. Er kann daher ausgewertet werden und so einen bestimmten Wert erhalten.

Ein Wertname kann fast jeden möglichen Datentyp haben, ohne daß dies am Namen selber ablesbar ist.

Das folgende Programm zeigt die Ausgabe des Wertes des Namens »global::System.Math.PI«, einer Näherung des Wertes der Kreiszahl π. Der Datentyp dieses Wertnamens ist »double«.

Program.cs

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

global::System.Console.Out

3.14159265358979

Man kann dies mit dem folgenden Programm vergleichen, welches ein Literal als Wertausdruck verwendet.

Program.cs

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

global::System.Console.Out

3.14159265358979

Wir betrachten den gesamten Namen »global::System.Math.PI« zunächst als eine Einheit und behandeln die Bedeutung der Punkte erst etwas später.

Wenn man bei der Eingabe eines Numerales an einer Stelle eine falsche Ziffer verwendet, dann erhält man in der Regel keine  Fehlermeldung. Schreibt man bei der Eingabe eines Namens einen Buchstaben falsch, so erhält man oft eine Fehlermeldung. Daher ist die Verwendung des Namens »global::System.Math.PI« weniger fehlerträchtig als die Verwendung des Numerales »3.14159265358979«.

Sowohl Wertnamen als auch Literale sind Ausdrücke. Ein Wertname hat wie ein Literal einen bestimmten Typ  und Wert. Dieser Typ und Wert eines Wertnamens ist aber in diesem Fall nicht schon durch die Programmiersprache C♯  (nach CLS ) bestimmt, sondern erst durch die Standardbibliothek  (eine Sammlung vordefinierter Programmteile, die üblicherweise mit C♯  zusammen verwendet wird).

Das folgende Programm zeigt die Ausgabe des Wertes des Wertnamens »global::System.Int32.MaxValue«. Dieser Wertname hat den Datentyp »int«.

Program.cs

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

global::System.Console.Out

2147483647

Man kann dies mit dem folgenden Programm vergleichen, welches ein Literal als Wertausdruck verwendet.

Program.cs

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

global::System.Console.Out

2147483647

Der Typ »int« umfaßt die ganzen Zahlen im Bereich von »global::System.Int32.MinValue« (einschließlich) bis »global::System.Int32.MaxValue« (einschließlich).

In diesem Kapitel werden Namen, wie »global::System.Math.PI« vorgestellt, ohne daß die als Beispiel gewählten speziellen Namen dabei im Vordergrund stehen sollen. Es geht vielmehr darum, das allgemeine Phänomen der Vergabe von Namen vorzustellen. Deswegen werden an dieser Stelle die Anwendungsmöglichkeiten des Wertes »global::System.Math.PI« nicht weiter vertieft. Es geht hier nicht um die speziellen Möglichkeiten der Anwendung des Namens »global::System.Math.PI«, sondern darum, daß es allgemein möglich ist, Namen für Werte einzuführen. »global::System.Math.PI« dient dann lediglich als ein  Beispiel dafür.

Unterschiede zwischen Namen und Literalen

Der Wert eines Namens wird dem Namen in der Regel ganz willkürlich zugeordnet, während der Wert eines Literals sich meist in regelhafter Weise aus den Zeichen des Literals ergibt (das Wort „Literal“ kommt vom lateinischen "littera" - „Schriftzeichen“).

Ersetzt man im Literal »11« das letzte Zeichen durch seinen Nachfolger, so ergibt sich wieder ein Literal, nämlich »12«, und dessen Wert ist um 1 größer. Ersetzt man hingegen im Namen »global::System.Int32.MinValue« das letzte Zeichen durch seinen Nachfolger, so ergibt sich »global::System.Int32.MinValuf«, was in der Regel gar festgelegt wurde und daher gar keinen bestimmten Wert hat. Die Regel, die einem Literal seinen Wert zuordnet, ist auch meist in einem Programm überall gleich und wird oft durch die Programmiersprache festgelegt, während Namen in verschiedenen Programmteilen oft unterschiedliche Bedeutungen haben können, wie später gezeigt werden wird.

Signifikanz der Groß- und Kleinschreibung

Die Groß- und Kleinschreibung von Quelltextzeichen ist in C♯  signifikant. Das heißt, daß ein kleiner Buchstabe (ein gemeiner Buchstabe, eine Minuskel) als ein anderes Zeichen gilt als der zu ihm gehörende große Buchstabe (als die zu ihm gehörige Majuskel). Wenn ein Name mit »PI« verwendet werden kann, so heißt dies daher beispielsweise im allgemeinen nicht, daß dann auch die Schreibweise mit »Pi« zulässig ist und dieselbe Bedeutung hat.

Program.cs

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

global::System.Console.Out

3.14159265358979

Program.cs

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

global::System.Console.Out (übersetzt)

Program.cs(4,19): Fehler CS0117: 'System.Math' enthält keine Definition von 'Pi'

global::System.Console.Out (Englisch)

Program.cs(4,19): error CS0117: 'System.Math' does not contain a definition for 'Pi'

Kombination mit Operatoren und Literalen

Wie Literale können auch Wertnamen als Wertausdrücke in einem Operatorausdruck verwendet werden.

Program.cs

public static class Program
{ public static void Main()
  { global::System.Console.WriteLine
    ( -global::System.Int32.MaxValue ); }}

global::System.Console.Out

-2147483647

Operationen bei der Auswertung von »-global::System.Int32.MaxValue«:

Erste Operation Auslesen des Wertes »global::System.Int32.MaxValue«.

 _____________________________
-global::System.Int32.MaxValue →
-2147483647

Zweite Operation Berechnung des negativen Wertes.

___________
-2147483647 →
-2147483647

Program.cs

public static class Program
{ public static void Main()
  { global::System.Console.WriteLine
    ( global::System.Math.PI/2 ); }}

global::System.Console.Out

1.5707963267949

Operationen bei der Auswertung von »global::System.Math.PI/2«:

Erste Operation Auslesen des Wertes »global::System.Math.PI«.

______________________
global::System.Math.PI/2 →
3.141592653589793115997963468544185161590576171875/2

Zweite Operation Berechnung der Division.

____________________________________________________
3.141592653589793115997963468544185161590576171875/2 →
1.5707963267948965579989817342720925807952880859375

Eine C♯ -Implementation verwendet intern tatsächlich die in den obenstehenden Auswertungsschritten wiedergegebenen Werte! Das Ergebnis wird dann bei der Ausgabe auf die angezeigten 13 Nachkommastellen gerundet. Das heißt aber nicht, daß eine C♯ -Implementation intern viel genauer rechnet als mit zirka 13 Dezimalstellen, denn die hier gezeigten weiteren Nachkommastellen ergeben sich nur durch technische Effekte und sind nicht  mathematisch korrekt. (Weiter unten ist der richtige Wert von π auf 50 Stellen genau angegeben, so daß interessierte Leser Vergleiche anstellen können.)

Wertausdrücke mit Literalen, Wertnamen und Operatoren dürfen praktisch beliebig groß und kompliziert werden, solange sie korrekt gebildet sind.

Trennende und halbtrennende Zeichen

Wir hatten bisher schon die runden Klammern als trennende Zeichen kennengelernt, die nie durch zusätzlichen Leerraum abgegrenzt werden müssen.

Program.cs

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

global::System.Console.Out

-2147483647

Program.cs

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

global::System.Console.Out

2

Es gibt auch Zeichen, die zwar manchmal durch Leerraum abgegrenzt werden müssen, aber nicht bei Kontakt zu einem Wort oder einem Literal. Solche Zeichen nennen wir hier auch halbtrennend. Das Minuszeichen »-« ist solch ein halbtrennendes Zeichen. Es muß zwar manchmal mit Leerraum von einem anderen Minuszeichen abgegrenzt werden, aber dies kommt selten vor. Wenn es jedoch vor oder hinter einem Wort oder Literal steht, so ist keine Abgrenzung mit Leerraum nötig. Es kann also meistens wie ein trennendes Zeichen ohne Leerraum verwendet werden.

Program.cs

public static class Program
{ public static void Main()
  { global::System.Console.WriteLine
    ( -global::System.Int32.MaxValue-System.Int32.MinValue ); }}

global::System.Console.Out

1

Program.cs

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

global::System.Console.Out

-4

Eigenschaften

Die Schreibweise zur Verwendung einer Eigenschaft  ist wie bei einem der bisher behandelten Wertnamen.

Allerdings sind Eigenschaften keine Namen für Werte, sondern für Ergebnisse  von Programmen.

Immer, wenn der Ausdruck »global::System.DateTime.Now« ausgewertet wird, wird ein speziell dafür vorgesehens Programm gestartet, welches die aktuelle Uhrzeit  ermittelt. Dieses Programm legt dann den Wert der Auswertung fest. So kann sich bei jedem Start des folgenden Programms eine andere Ausgabe  ergeben.

Program.cs

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

global::System.Console.Out

2018-02-21 10:12:07

global::System.Console.Out

2018-02-21 10:12:12

Bei mehreren aufeinanderfolgenden Auswertungen einer Eigenschaft ergibt sich allerdings in der Regel derselbe  Wert, solange dieser nicht dazwischen durch absichtliche Eingriffe verändert wurde. Insofern ist die Veränderung des Wertes von »global::System.DateTime.Now« ohne solche Eingriffe eine Ausnahme bei den Eigenschaften.

Der Typ der Eigenschaft ist »string«. Das folgende Programm zeigt, wie die Uhrzeit in Apostrophe  eingeschlossen ausgegeben wird.

Program.cs

public static class Program
{ public static void Main()
  { global::System.Console.WriteLine
    ( "'" + global::System.DateTime.Now + "'" ); }}

global::System.Console.Out

'2018-02-21 10:14:38'

Das portable Zeilenende

Das portable Zeilenende »global::System.Environment.NewLine« ist eine Eigenschaft, deren Wert eine Zeichenfolge ist, die unter der aktuellen Umgebung eine Zeile abschließt. Es stimmt mit der Zeichenfolge überein, die von »global::System.Console.WriteLine« verwendet wird, um die ausgegebene Zeile zu beenden.

Mit Hilfe dieser Eigenschaft können wir nun auch mehrere Zeilen  ausgeben.

Program.cs

public static class Program
{ public static void Main()
  { global::System.Console.WriteLine
    ( global::System.Math.PI/2 + 
      global::System.Environment.NewLine + 
      global::System.DateTime.Now ); }}

Protokoll

1.5707963267949
2017-03-27 18:18:29

Ausdrücke

Zusammenfassend sei festgehalten, daß nach dem bisher Gesagtem ein Ausdruck entweder

• ein Literal – wie »2« – oder
• ein Wertname oder eine Eigenschaft – wie »global::System.Math.PI« – oder
• ein Operatorausdruck – wie »global::System.Math.PI/2« – ist

und daß solch ein Ausdruck in den Ausdruckrahmen eingesetzt werden kann.

Neue, erweiterte Syntax (vereinfacht)

Ausdruck
                .----------.
---.----------->| Literal  |---------------------------.---->
   |            '----------'                           |
   |            .----------.                           |
   '----------->| Name     |---------------------------'
   |            '----------'                           |
   |     .-.    .----------.                           |
   '--->( - )-->| Ausdruck |---------------------------'
   |     '-'    '----------'                           |
   |     .-.    .----------.                           |
   '--->( + )-->| Ausdruck |---------------------------'
   |     '-'    '----------'                           |
   |     .-.    .----------.    .-.                    |
   '--->( ( )-->| Ausdruck |-->( ) )-------------------'
   |     '-'    '----------'    '-'                    |
   |            .----------.    .-.    .----------.    |
   '----------->| Ausdruck |-->( / )-->| Ausdruck |----'
   |            '----------'    '-'    '----------'    |
   |            .----------.    .-.    .----------.    |
   '----------->| Ausdruck |-->( + )-->| Ausdruck |----'
   |            '----------'    '-'    '----------'    |
   |            .----------.    .-.    .----------.    |
   '----------->| Ausdruck |-->( - )-->| Ausdruck |----'
   |            '----------'    '-'    '----------'    |
   |            .----------.    .-.    .----------.    |
   '----------->| Ausdruck |-->( * )-->| Ausdruck |----'
                '----------'    '-'    '----------'

Innere Ausdrücke

Innere Ausdrücke in $-Literalen dürfen auch Namen als Ausdrücke in geschweiften Klammern enthalten. Somit erlauben innere Ausdrücke es, Namen beschriftet auszugeben, jedoch kann dabei »global::« nicht verwendet werden.

Program.cs

public static class Program
{ public static void Main()
  { global::System.Console.WriteLine
    ( $"global::System.Math.PI = {global::System.Math.PI}." ); }}

Protokoll

Program.cs(4,35): error CS0103: The name 'global' does not exist in the current context

Die Fehlermeldung ergibt sich daraus, daß der Doppelpunkt in den geschweiften Klammern im $-Zeichenfolgenliteral eine besondere Bedeutung hat (die wir bisher noch nicht kennengelernt haben). Man kann die Fehlermeldung aber vermeiden, wenn man solche Ausdrücke mit Doppelpunkten auch noch einmal in runde Klammern einschließt.

Program.cs

public static class Program
{ public static void Main()
  { global::System.Console.WriteLine
    ( $"global::System.Math.PI = {(global::System.Math.PI)}." ); }}

Protokoll

global::System.Math.PI = 3.14159265358979.

Übungsaufgaben

/   Wertermittlung

Ermitteln Sie den Wert des Wertnamens »global::System.Decimal.MaxValue«, indem Sie den Ausdruckrahmen verwenden.

Zusatzaufgaben *

/   Wertermittlung *

Rechnen Sie 30° (30 Grad, Winkelangabe in Grad [„Altgrad“]) in die Einheit „Radiant“ um, indem Sie 30 mit π/180 multiplizieren.

Beispiele *

●   Beispiel Berechnung des Umfangs eines Kreises mit Radius 3 Meter *

r: Radius, hier nehmen wir als Beispiel an: r = 3

U: Umfang

π  ≈  3,14159265358979323846264338327950288419716939937510

U = 2 π r  ⇒  U = 2 π · 3

Program.cs

public static class Program
{ public static void Main()
  { global::System.Console.WriteLine
    ( "Umfang = " + 2 * global::System.Math.PI * 3 + " Meter" ); }}

global::System.Console.Out

Umfang = 18.8495559215388 Meter

●   Beispiel Berechnung der Fläche eines Kreises mit Radius 3 Meter *

Einige Bezeichnungen dieses Beispiels werden aus dem vorigen Beispiel übernommen.

F: Fläche

F = π r²  ⇒  F = π · 3²

Program.cs

public static class Program
{ public static void Main()
  { global::System.Console.WriteLine
    ( "Flaeche = " + global::System.Math.PI * 3 * 3 + " Quadratmeter" ); }}

global::System.Console.Out

Flaeche = 28.2743338823081 Quadratmeter