TOC

This article has been localized into German by the community.

Grundlagen:

Variablen

Eine Variable kann man mit einem Lagerraum vergleichen. Sie ist für den Programmierer essentiell. In C# wird eine Variable wie folgt deklariert:

<Datentyp> <Name>;

Ein Beispiel könnte so aussehen:

String Name;

Das ist die einfachste Ausführung, bei der die Variable aber noch keinen Wert enthält. Diesen kann man später zuweisen oder gleichzeitig mit dem Deklarieren:

<data type> <name> = <value>;

Wenn diese Variable nicht lokal auf die Methode beschränkt ist, in der du gerade arbeitest (z.B. die statischen Variablen einer Klasse), macht es Sinn der Variable eine Sichtbarkeit zuzuweisen:

<Sichtbarkeit> <Datentyp> <Name> = <Wert>;

Und als vollständiges Beispiel:

private string name = "John Doe";

Der Sichtbarkeit-Themenkomplex hat was mit Klassen zu tun, daher kannst du eine vollständigere Erklärung im Kapitel über Klassen finden. Konzentrieren wir uns jetzt auf den Variablen Teil mit einem Beispiel, bei dem wir auch ein paar davon verwenden:

using System;

namespace ConsoleApplication1
{
    class Program
    {
static void Main(string[] args)
{
    string firstName = "John";
    string lastName = "Doe";

    Console.WriteLine("Name: " + firstName + " " + lastName);

    Console.WriteLine("Please enter a new first name:");
    firstName = Console.ReadLine();

    Console.WriteLine("New name: " + firstName + " " + lastName);

    Console.ReadLine();
}
    }
}

Okay, einiges davon haben wir schon erklärt, lass uns also direkt zum interessanten Teil springen. Als erstes haben wir ein paar Variablen vom Typ String deklariert. Ein String enthält einfach Text, was du daran erkennen kannst, dass wir ihnen direkt einen Wert zugewiesen haben. Als nächstes geben wir eine Zeile Text an die Konsole aus, in der wir die beiden Variablen nutzen. Der String wird zusammengefügt mithilfe des +-Zeichens um die einzelnen Bestandteile "einzusammeln".

Als nächstes fordern wir den Nutzer auf einen neuen Vornamen einzugeben und verwenden anschließend die ReadLine() Methode um den Input von der Konsole in die firstName Variable einzulesen. Sobald der Nutzer Enter drückt, wird der neue Vorname der Variable zugewiesen. Anschließend geben wir mit der nächsten Zeile den neuen Text aus um die Änderung zu zeigen. Damit haben wir gerade unsere erste Variable und deren allerwichtigste Eigenschaft angewendet: Die Fähigkeit noch während der Programmlaufzeit ihren Wert zu ändern.

Ein weiteres Beispiel ist für Arithmetik. Hier zum Beispiel, basierend auf einer Menge Code die wir eben schon verwendet haben:

int number1, number2;

Console.WriteLine("Please enter a number:");
number1 = int.Parse(Console.ReadLine());

Console.WriteLine("Thank you. One more:");
number2 = int.Parse(Console.ReadLine());

Console.WriteLine("Adding the two numbers: " + (number1 + number2));

Console.ReadLine();

Schreib das in unsere Main-Methode und probier es aus. Der einzige neue "Trick" den wir hier anwenden ist die int.Parse()-Methode. Sie liest einfach einen String und konvertiert ihn in einen Integer. Wie du siehst überprüft die Anwendung in keinster Weise den Input der vom Nutzer kommt, wenn du also etwas eingibst, das keine Zahl ist, wird eine Ausnahme ausgelöst. Dazu später mehr.

Variablen & Reichweite

Bisher haben wir nur lokale Variablen verwendet, bei denen es sich um Variablen handelt, die innerhalb derselben Methode definiert und verwendet werden. In C# kann eine in einer Methode definierte Variable nicht außerhalb dieser Methode verwendet werden - deshalb heißt sie lokal. Wenn Sie mit anderen Programmiersprachen vertraut sind, kennen Sie vielleicht auch globale Variablen, auf die von mehreren Stellen aus zugegriffen werden kann, aber C# unterstützt nicht das Konzept globaler Variablen. Stattdessen können Sie ein Feld für eine Klasse definieren, auf das von allen Methoden dieser Klasse aus zugegriffen werden kann. Gestatten Sie mir, dies an einem Beispiel zu demonstrieren:

using System;

namespace VariableScope
{
    class Program
    {
private static string helloClass = "Hello, class!";

static void Main(string[] args)
{
    string helloLocal = "Hello, local!";
    Console.WriteLine(helloLocal);
    Console.WriteLine(Program.helloClass);
    DoStuff();
}

static void DoStuff()
{
    Console.WriteLine("A message from DoStuff: " + Program.helloClass);
}
    }
}

Beachten Sie das Element helloClass, das im Klassenbereich anstatt innerhalb einer Methode deklariert ist. Dies ermöglicht uns den Zugriff sowohl von unserer Main() -Methode als auch von unserer eigenen DoStuff() Methode. Dies gilt nicht für unsere helloLocal -Variable, die innerhalb der Main() -Methode deklariert wurde und daher nur innerhalb dieser spezifischen Methode verwendet werden kann.

Das Konzept, zwischen der Definition einer Variablen zu unterscheiden, heißt scoping und verhindert, dass Ihr Code zu einer riesigen Ansammlung von Variablen wird, die von zu vielen Stellen geändert werden können. Eine andere Technik, die uns dabei hilft, heißt member visibility (in diesem Fall mit dem Schlüsselwort private dargestellt), auf die wir im Kapitel über Klassen eingehen werden.

Zusammenfassung

Mit Variablen können Sie Daten verschiedener Typen speichern, z.B. Textzeichenfolgen, Zahlen oder benutzerdefinierte Objekte. Es gibt lokale Variablen, auf die innerhalb der Methode zugegriffen werden kann, in der sie definiert wurde, und dann gibt es Klassenfelder, auf die von allen Methoden der Klasse und sogar außerhalb der Klasse zugegriffen werden kann, wenn die Sichtbarkeit es erlaubt.

This article has been fully translated into the following languages: Is your preferred language not on the list? Click here to help us translate this article into your language!