Introducere în C#

C# (pronunțat "C sharp") este un limbaj de programare modern, de uz general, dezvoltat de Microsoft. Este utilizat pe scară largă pentru construirea diferitelor tipuri de aplicații, inclusiv aplicații desktop, web, mobile și pentru jocuri. În acest ghid, vom acoperi elementele de bază ale programării C#, inclusiv tipuri de date, variabile, flux de control, funcții, clase, namespaces și multe altele.

În plus, C# oferă un set bogat de caracteristici și instrumente, făcându-l un limbaj de programare versatil și puternic pentru diverse domenii, inclusiv aplicații desktop, dezvoltare web, aplicații mobile și dezvoltarea jocurilor folosind tehnologii precum Unity. Pe măsură ce progresați în călătoria dvs. C#, puteți explora subiecte mai avansate, cum ar fi moștenirea, polimorfismul, interfețele, genericele, LINQ (Language Integrated Query) și programarea asincronă folosind task-uri și async/wait. Înțelegerea acestor concepte vă va îmbunătăți capacitatea de a proiecta aplicații robuste și scalabile.

Să începem cu elementele de bază.

Crearea mediului de dezvoltare

Pentru a începe codarea în C#, va trebui să vă configurați mediul de dezvoltare. Iată pașii pentru a începe:

Instalați Visual Studio: Descărcați și instalați Visual Studio de pe site-ul oficial Microsoft. Visual Studio este un mediu de dezvoltare integrat (IDE) puternic care oferă toate instrumentele necesare dezvoltării C#.
Creați un proiect nou: Lansați Visual Studio și creați un proiect nou. Alegeți șablonul de proiect potrivit în funcție de tipul de aplicație pe care doriți să o construiți.
Scrie cod: Odată configurat proiectul, puteți începe să scrieți cod C# în editorul de cod oferit de Visual Studio.

Acum că ați configurat mediul de dezvoltare, haideți să ne aprofundăm în elementele de bază ale programării C#.

Hello World Program

Tradiționalul „Hello, World!” programul este adesea primul program pe care îl scrieți în orice limbaj de programare. Iată cum îl puteți scrie în C#:

using System;

class Program
{
    static void Main()
    {
        Console.WriteLine("Hello, World!");
    }
}

În acest exemplu de cod, includem mai întâi spațiul de nume 'System', care conține o clasă numită 'Console', pentru gestionarea intrării și ieșirii. Apoi, definim o clasă numită 'Program'. În această clasă, avem o metodă 'Main', care este punctul de intrare al unui program C#. În cele din urmă, folosim metoda 'Console.WriteLine' pentru a tipări „Hello, World!” mesaj către consolă.

Variabile și tipuri de date

În C#, trebuie să declarați variabile înainte de a le putea folosi. Variabilele dețin valori ale diferitelor tipuri de date. Iată câteva tipuri de date utilizate în mod obișnuit în C#:

'int': Reprezintă numere întregi (de exemplu, 10, -5, 0).
'double': Reprezintă numere în virgulă mobilă cu zecimale (de exemplu, 3,14, -0,5).
'bool': Reprezintă valori booleene (adevărat sau fals).
'string': Reprezintă o secvență de caractere (de exemplu, "Hello", "C#").

Iată un exemplu care demonstrează declararea variabilelor și operațiile de bază:

int age = 25;
double pi = 3.14;
bool isStudent = true;
string name = "John";

int sum = age + 5;
double circleArea = pi * 2 * 2;
bool isAdult = age >= 18;

Console.WriteLine("Name: " + name);
Console.WriteLine("Age: " + age);
Console.WriteLine("Sum: " + sum);
Console.WriteLine("Circle Area: " + circleArea);
Console.WriteLine("Is Adult? " + isAdult);

În acest exemplu, declarăm variabilele 'age', 'pi', 'isStudent' și 'name' cu acestea. tipuri de date. Efectuăm câteva operații de bază, cum ar fi adunarea, înmulțirea și compararea. Metoda 'Console.WriteLine' este folosită pentru a afișa valorile pe consolă.

Matrice și colecții

Matricele și colecțiile sunt structuri de date fundamentale în C# care vă permit să stocați și să manipulați mai multe valori în mod eficient. Ele joacă un rol crucial în diferite scenarii de programare și sunt utilizate pe scară largă în dezvoltarea C#.

Matrice

O matrice în C# este o colecție de dimensiuni fixe de elemente de același tip. Iată un exemplu:

int[] numbers = new int[5] { 1, 2, 3, 4, 5 };

În acest exemplu, declarăm un tablou întreg numit 'numbers' cu o dimensiune de '5'. Inițializam matricea cu valorile specificate folosind acolade '{}'. Puteți accesa elemente individuale ale matricei folosind notația index, începând de la 0. De exemplu, 'numbers[0]' vă oferă primul element.

Colecții

Colecțiile în C# oferă mai multă flexibilitate decât matricele, deoarece pot crește sau micșora dinamic. C# oferă diverse tipuri de colecții, cum ar fi 'List<T>', 'Dictionary<TKey, TValue>' și 'HashSet<T>'.

Puteți crea o colecție generică utilizând una dintre clasele din spațiul de nume 'System.Collections.Generic'. O colecție generică este utilă atunci când fiecare articol din colecție are același tip de date. O colecție generică impune o tastare puternică, permițând adăugarea numai a tipului de date dorit.

using System.Collections.Generic;

Iată un exemplu folosind colecția 'List<T>':

List<string> names = new List<string>();
names.Add("Alice");
names.Add("Bob");
names.Add("Charlie");

În acest exemplu, creăm o listă de șiruri numite 'names' folosind clasa de inițializare 'List<T>'. Folosim metoda 'Add()' pentru a adăuga elemente la listă.

'List<T>' oferă multe metode și proprietăți utile pentru lucrul cu colecții, cum ar fi 'Count' pentru a obține numărul de elemente, 'Remove()' pentru a elimina un element și 'Contains()' pentru a verifica dacă există un element.

Iterație peste matrice și colecții

Puteți itera peste matrice și colecții folosind bucle, cum ar fi 'for' sau 'foreach', pentru a accesa și a manipula elementele acestora. Iată un exemplu de iterare peste o matrice și o listă:

int[] numbers = new int[] { 1, 2, 3, 4, 5 };

foreach (int number in numbers)
{
    Console.WriteLine(number);
}

List<string> names = new List<string>() { "Alice", "Bob", "Charlie" };

foreach (string name in names)
{
    Console.WriteLine(name);
}

În acest exemplu, folosim bucla 'foreach' pentru a repeta fiecare element din matricea 'numbers' și lista 'names' și le imprimăm la consola.

Controlul fluxului

Fluxul de control vă permite să luați decizii și să executați diferite blocuri de cod în funcție de condiții. C# oferă mai multe structuri de flux de control, inclusiv instrucțiuni 'if', instrucțiuni 'switch' și bucle.

'If'

O instrucțiune 'if' vă permite să executați un bloc de cod numai dacă o condiție specificată este adevărată. Iată un exemplu:

int number = 10;

if (number > 0)
{
    Console.WriteLine("The number is positive.");
}
else if (number < 0)
{
    Console.WriteLine("The number is negative.");
}
else
{
    Console.WriteLine("The number is zero.");
}

În acest exemplu, verificăm valoarea variabilei 'number' folosind clauzele 'if', 'else if' și 'else'. În funcție de stare, mesajul corespunzător va fi tipărit.

'Switch'

O instrucțiune 'switch' vă permite să selectați unul dintre multele blocuri de cod care urmează să fie executate pe baza valorii unei expresii. Iată un exemplu:

int dayOfWeek = 2;
string dayName;

switch (dayOfWeek)
{
    case 1:
        dayName = "Monday";
        break;
    case 2:
        dayName = "Tuesday";
        break;
    case 3:
        dayName = "Wednesday";
        break;
    // ...
    default:
        dayName = "Invalid day";
        break;
}

Console.WriteLine("Today is " + dayName + ".");

În acest exemplu, atribuim numele zilei pe baza valorii 'dayOfWeek' folosind declarația 'switch'. Instrucțiunile 'case' specifică valorile posibile și cazul 'default' este executat dacă niciunul dintre cazuri nu se potrivește.

Instrucțiuni de buclă

Buclele vă permit să executați în mod repetat un bloc de cod până când este îndeplinită o anumită condiție. C# oferă bucle 'for', 'while' și 'do-while'.

'For'

O buclă 'for' este utilizată atunci când cunoașteți în avans numărul de iterații. Iată un exemplu:

for (int i = 0; i < 5; i++)
{
    Console.WriteLine("Iteration: " + i);
}

În acest exemplu, bucla rulează de cinci ori, imprimând numărul de iterație de fiecare dată.

'While'

O buclă 'while' este folosită atunci când nu știți numărul de iterații în avans, dar aveți o condiție de verificat. Iată un exemplu:

int count = 0;

while (count < 5)
{
    Console.WriteLine("Count: " + count);
    count++;
}

În acest exemplu, bucla rulează până când variabila 'count' ajunge la 5.

'Do-While'

O buclă 'do-while' este similară cu o buclă while, dar condiția este verificată la sfârșit, astfel încât bucla se execută cel puțin o dată. Iată un exemplu:

int num = 1;

do
{
    Console.WriteLine("Number: " + num);
    num++;
} while (num <= 5);

În acest exemplu, bucla rulează până când variabila 'num' nu mai este mai mică sau egală cu 5.

Funcții

Funcțiile vă permit să încapsulați blocuri de cod reutilizabile. C# acceptă definirea funcțiilor folosind cuvântul cheie 'void' pentru metodele care nu returnează o valoare și alte tipuri de date pentru metodele care returnează o valoare. Iată un exemplu:

int Add(int a, int b)
{
    return a + b;
}

void Greet(string name)
{
    Console.WriteLine("Hello, " + name + "!");
}

int result = Add(5, 3);
Greet("Alice");

În acest exemplu, definim două funcții: 'Add' și 'Greet'. Funcția 'Add' preia doi parametri întregi și returnează suma acestora. Funcția 'Greet' preia un parametru șir și tipărește un mesaj de salut. Apoi numim aceste funcții cu argumentele adecvate.

Clase și Obiecte

C# este un limbaj de programare orientat pe obiecte, ceea ce înseamnă că acceptă crearea de clase și obiecte. Clasele definesc planul pentru crearea obiectelor, care sunt instanțe ale acelor clase. Iată un exemplu:

class Person
{
    public string Name { get; set; }
    public int Age { get; set; }

    public void SayHello()
    {
        Console.WriteLine("Hello, my name is " + Name + " and I'm " + Age + " years old.");
    }
}

Person person = new Person();
person.Name = "John";
person.Age = 30;
person.SayHello();

În acest exemplu, definim o clasă 'Person' cu proprietăți 'Name' și 'Age' și o metodă 'SayHello'. Apoi creăm o instanță a clasei 'Person' folosind cuvântul cheie 'new' și setăm proprietățile acesteia. În cele din urmă, numim metoda 'SayHello' pe obiectul 'person'.

Concepte de programare orientată pe obiecte (OOP).

C# este un limbaj de programare orientat pe obiecte și oferă diverse caracteristici pentru a sprijini concepte OOP, cum ar fi moștenirea, încapsularea și polimorfismul.

Moştenire

Moștenirea vă permite să creați noi clase bazate pe clasele existente, moștenind atributele și comportamentele acestora. Iată un exemplu:

class Shape
{
    public virtual void Draw()
    {
        Console.WriteLine("Drawing a shape.");
    }
}

class Circle : Shape
{
    public override void Draw()
    {
        Console.WriteLine("Drawing a circle.");
    }
}

În acest exemplu, clasa 'Circle' moștenește din clasa 'Shape' folosind simbolul ':'. Clasa 'Circle' suprascrie metoda 'Draw' din clasa de bază pentru a oferi propria implementare.

Încapsulare

Încapsularea este practica de a grupa datele și metodele într-o clasă și de a controla accesul acestora. Puteți utiliza modificatori de acces ('public', 'private', 'protected' etc.) pentru a specifica vizibilitatea membrilor. Iată un exemplu:

class Person
{
    private string name;

    public string GetName()
    {
        return name;
    }

    public void SetName(string newName)
    {
        name = newName;
    }
}

În acest exemplu, câmpul 'name' este încapsulat în clasa 'Person' și poate fi accesat numai prin 'GetName' și 'SetName' metode.

Polimorfism

Polimorfismul permite ca obiectele din clase diferite să fie tratate ca obiecte ale unei clase de bază comune. Acest lucru permite să fie scris cod care funcționează cu diferite tipuri de obiecte într-o manieră uniformă. Iată un exemplu:

class Animal
{
    public virtual void MakeSound()
    {
        Console.WriteLine("Animal makes a sound.");
    }
}

class Dog : Animal
{
    public override void MakeSound()
    {
        Console.WriteLine("Dog barks.");
    }
}

class Cat : Animal
{
    public override void MakeSound()
    {
        Console.WriteLine("Cat meows.");
    }
}

În acest exemplu, clasa 'Animal' are o metodă virtuală 'MakeSound', care este înlocuită de 'Dog' și 'Cat' ore . Polimorfismul ne permite să tratăm instanțele de 'Dog' și 'Cat' ca instanțe de 'Animal' și să numim 'MakeSound' metoda asupra lor.

Tratarea excepțiilor

Gestionarea excepțiilor vă permite să gestionați cu grație erorile de rulare. În C#, puteți folosi blocurile 'try-catch' pentru a captura și gestiona excepțiile. Iată un exemplu:

try
{
    int result = 10 / 0;
    Console.WriteLine("Result: " + result);
}
catch (DivideByZeroException ex)
{
    Console.WriteLine("Divide by zero error: " + ex.Message);
}
finally
{
    Console.WriteLine("Cleanup code goes here.");
}

În acest exemplu, încercăm să efectuăm o împărțire la zero, care aruncă un 'DivideByZeroException'. Codul din interiorul blocului 'try' este executat, iar dacă apare o excepție, acesta este prins de blocul 'catch'.

Blocul 'finally' este executat indiferent dacă apare sau nu o excepție și este de obicei folosit pentru operațiuni de curățare.

Gestionarea excepțiilor ajută la prevenirea blocărilor programului și permite gestionarea controlată a erorilor și recuperarea.

Concluzie

Acest ghid cuprinzător a oferit o introducere detaliată în programarea C#, acoperind elementele fundamentale și conceptele esențiale ale limbajului. Începând cu configurarea mediului de dezvoltare și scrierea unui „Hello, World!” program, am explorat tipuri de date, variabile, structuri ale fluxului de control precum instrucțiuni și bucle if și crearea de funcții. Am abordat subiecte mai avansate, cum ar fi clase, obiecte, moștenire, încapsulare, polimorfism, precum și gestionarea excepțiilor. În plus, am discutat despre utilizarea matricelor și colecțiilor pentru gestionarea mai multor valori. Cu aceste cunoștințe, aveți acum o bază solidă în programarea C#, dându-vă puterea să dezvoltați o gamă largă de aplicații, de la aplicații de consolă la aplicații web și mobile. Nu uitați să continuați să exersați și să explorați vastul ecosistem C# pentru a vă îmbunătăți abilitățile și a debloca posibilități nesfârșite.

programare csharp oop dezvoltare variabile controlflow clase obiecte moștenire încapsulare gestionarea excepțiilor matrice colecții funcții