Variables

Mία μεταβλητή μπορεί να συγκριθεί με μία αποθήκη, και είναι απαραίτητη για τον προγραμματιστή. Στην C#, μια μεταβλητή δηλώνεται ως εξής:

<τύπος δεδομένων> <όνομα>;

Ένα παράδειγμα θα ήταν:

string name;

Αυτή είναι η πιο βασική μορφή, αλλά η μεταβλητή δεν έχει ακόμα τιμή. Μπορούμε να αναθέσουμε μία τιμή στην μεταβλητή μετά την δήλωση της ή την ίδια στιγμή που την δηλώνουμε , με αυτόν τον τρόπο:

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

Αν η μεταβλητή δεν είναι τοπική στην μέθοδο που την χρησιμοποιούμε (π.χ. μία μεταβλητή μέλος κλάσης), μπορεί να θέλουμε να αναθέσουμε και ορατότητα στη μεταβλητή:

<ορατότητα> <τύπος δεδομένων> <όνομα> = <τιμή>;

Ένα ολοκληρωμένο παράδειγμα:

private string name = "John Doe";

The visibility part is related to classes, so you can find a more complete explanation of it in the chapter about classes. Let's concentrate on the variable part with an example where we actually use a couple of them:

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();
    }
    }
}

Οκ, πολλά από αυτά έχουν ήδη τεκμηριωθεί, οπότε θα πηδήξουμε κατευθείαν στο ενδιαφέρον σημείο. Πρώτα απ' όλα, δηλώνουμε δύο μεταβλητές τύπου string. Ένα string απλά περιέχει κείμενο, όπως μπορείτε να δείτε, αφού του δίνουμε τιμή κατευθείαν. Έπειτα, εμφανίζουμε μία γραμμή κειμένου στην κονσόλα, όπου χρησιμοποιούμε τις δυο μεταβλητές. Το string δημιουργείται χρησιμοποιώντας τον χαρακτήρα + για να ενώσουμε τα διαφορετικά κομμάτια.

Έπειτα, ζητάμε από τον χρήστη να εισάγει ένα νέο όνομα, και χρησιμοποιούμε την μέθοδο ReadLine() για να διαβάσουμε την είσοδο του χρήστη από την κονσόλα και να την εκχωρήσουμε στην μεταβλητή firstName. Μόλις ο χρήστης πατήσει το κουμπί Enter, το νέο όνομα εκχωρείται στη μεταβλητή και στην επόμενη γραμμή εμφανίζουμε πάλι το όνομα για να δείξουμε την αλλαγή. Μόλις χρησιμοποιήσαμε την πρώτη μας μεταβλητή και το ένα και το πιο σημαντικό χαρακτηριστικό μίας μεταβλητής: Την ικανότητα να αλλάζει η τιμή της την ώρα της εκτέλεσης.

Another interesting example is doing math. Here is one, based on a lot of the same code we have just used:

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();

Put this in our Main method, and try it out. The only new "trick" we use here, is the int.Parse() method. It simply reads a string and converts it into an integer. As you can see, this application makes no effort to validate the user input, and if you enter something which is not a number, an exception will be raised. More about those later.

Variables & scope

So far, we have only used local variables, which are variables defined and used within the same method. In C#, a variable defined inside a method can't be used outside of this method - that's why it's called local. If you're familiar with other programming languages, you may also know about global variables, which can be accessed from more places, but C# doesn't support the concept of global variables. Instead, you can define a field on a class, which can be accessed from all the methods of this class. Allow me to demonstrate this with an example:

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);
    }
    }
}

Notice the helloClass member, declared on the class scope instead of inside a method - this will allow us to access it from both our Main() method as well as our own DoStuff() method. That is not true for our helloLocal variable, which has been declared inside the Main() method and can therefore only be used inside of this specific method.

The concept of differentiating between where a variable has been declared is called scoping and it prevents your code from becoming a huge mess of variables which can be changed from too many places. Another technique that helps us with this is called member visibility (in this case illustrated with the private keyword), which we'll discuss in the chapter about classes.

Summary

Variables allow you to store data of various types, e.g. text strings, numbers or custom objects. There are local variables, which are accessible inside of the method in which it has been defined, and then there are class fields, which can be accessed from all the methods of the class and even outside of the class, if the visibility permits it.