TOC

This article is currently in the process of being translated into Romanian (~55% done).

Notiuni de baza:

Variables

O variabila poate fi comparata cu o cutie in care pastrezi ceva si este esentiala pentru programator. In C#, o variabila se declara ca mai jos:

<tip de data> <nume>;

Un exemplu arata asa:

string name;

Asta este cea mai simpla versiune, dar variabila nu are inca o valoare. Se poate atribui o valoare la un moment dat sau in momentul declararii, ca si in exemplul de mai jos:

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

Daca aceasta variabila nu este locala, nu face parte din metoda in care o folosesti (adica nu este data membru al clasei), atunci este necesar sa i stabilesti vizibilitate:

<vizibilitate> <tip de data> <nume> =<valoare>;

Si un exemplu complet:

private string name = "John Doe";

Partea de vizibilitate este legata de clase, deci veti găsi explicatii complete despre ea in capitolul despre clase. Sa ne concentrăm pe partea de variabilă cu un exemplu unde folosim cateva dintre ele:

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

Ok, multe dintre acestea au fost deja explicate, asa ca vom sari direct la partea interesanta. Mai întâi declarăm o pereche de variabile de tipul string. Un string contine pur si simplu text, asa cum puteti vedea, deoarece îi dăm o valoare imediat. Apoi, trimitem o linie de text la consola, unde folosim cele două variabile. Șirul este format prin utilizarea caracterelor + pentru a "colecta" diferitele părți ale textului trimis la consola.

In continuare, cerem utilizatorului sa introducă alt nume, apoi folosim metoda ReadLine() pentru a citi numele introdus de utilizator si il atribuim variabilei firstName imediat ce utilizatorul apasă Enter. In linia urmatoare afisam din nou textul cu numele nou si prenumele pentru ca sa vedem modificarile facute. Tocmai am folosit prima noastra variabila si una dintre cele mai importante functionalitati ale variabilei: Abilitatea de a-si modifica valoarea.

Un alt exemplu interesant este matematic, bazat pe instructiuni pe care tocmai le-am folosit:

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

Scrieti acest cod in metoda Main si incercati-l. Singurul nou "trick" pe care l-am folosit aici este metoda int.Parse(). Este simplu, se citeste un string si se face conversia la integer. Asa cum puteti vedea, aceasta aplicatie, fara efort, valideaza intrarea si daca nu este introdus un numar se emite o exceptie. Mai multe despre acestea, mai tarziu.

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.

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!