În lecția despre instanțiere am învățat că putem declara clase, iar mai apoi putem face copii ale acestora, numite instanțe, cărora le putem atribui valori proprietăților lor:
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
|
using
System;
namespace
BunaLume
{
class
Persoana
{
public string Nume { get; set; }
public string Prenume { get; set; }
public int Varsta { get; set; }
}
class
Program
{
static void Main(string[] args)
{
Persoana oPersoana = new Persoana();
Persoana altaPersoana = new Persoana();
oPersoana.Nume = "Popescu";
oPersoana.Prenume = "Ion";
oPersoana.Varsta = 30;
altaPersoana.Nume = "Popescu";
altaPersoana.Prenume = "Maria";
altaPersoana.Varsta = 25;
Console.ReadLine();
}
}
}
|
Folosind inițializatoarele de obiecte, care au fost introduse în C# 3.0, putem face același lucru, dar fără a mai fi nevoie să apelăm un constructor, urmat mai apoi de linii și linii de atribuire. Nu există nici un beneficiu practic, în afară de a face codul mai ușor de citit și de înțeles:
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
|
using
System;
namespace
BunaLume
{
class
Persoana
{
public string Nume { get; set; }
public string Prenume { get; set; }
public int Varsta { get; set; }
}
class
Program
{
static void Main(string[] args)
{
Persoana oPersoana = new Persoana() { Nume = "Popescu", Prenume = "Ion", Varsta = 30 };
Persoana altaPersoana = new Persoana() { Nume = "Popescu", Prenume = "Maria", Varsta = 25 };
Console.ReadLine();
}
}
}
|
Este clar că declararea și inițializarea celor două instanțe de tip Persoana este mult mai concisă acum.
Doar proprietățile și variabilele accesibile ale unui obiect pot fi inițializate astfel, și este chiar logic - nu le-am putea atribui valori nici în modul "tradițional" de declarare, dacă nu ar fi public, internal, etc.
Dacă o clasă definește doar constructori cu parametri obligatorii (fără constructor implicit), tot trebuie să furnizați valori pentru acești parametri atunci când instanțiați obiectul folosind această sintaxă de inițializare a obiectelor.
Fără să vă dați seama, ați văzut deja această sintaxă folosită înainte, când am discutat despre inițializarea array-urilor, care pot avea elementele specificate în timpul declarației, folosind sintaxa de inițializare a obiectelor:
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
|
using
System;
namespace
BunaLume
{
class
Program
{
static void Main(string[] args)
{
int[] myArray = { 1, 2, 3, 4, 5, 6 };
Console.ReadLine();
}
}
}
|
În sfârșit, dacă avem o colecție de date de un tip mai complex, de exemplu, un array de tip Persoana, putem inițializa folosind acest tip de sintaxă nu doar elementele sale, ci și membrii respectivelor elemente (cu alte cuvinte, inițializare imbricată):
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
|
using
System;
namespace
BunaLume
{
class
Persoana
{
public string Nume { get; set; }
public string Prenume { get; set; }
public int Varsta { get; set; }
}
class
Program
{
static void Main(string[] args)
{
Persoana[] myArray =
{
new Persoana() { Nume = "Popescu", Prenume = "Ion", Varsta = 30 },
new Persoana() { Nume = "Popescu", Prenume = "Maria", Varsta = 25 }
};
Console.ReadLine();
}
}
}
|
Un lucru de reținut este faptul că sintaxa de inițializatori de obiecte, care atribuie valori proprietăților și variabilelor unui obiect, este executată după ce constructorul acelui tip este apelat în timpul instanțierii, și își termină execuția. Aceasta înseamnă că membrii read-only nu pot fi alocați folosind această sintaxă. În schimb, ei trebuie declarați ca proprietăți cu setter init-only, așa cum este discutat în lecția despre proprietăți.