Programare orientată pe obiecte Curs 10

Folosirea colecțiilor de elemente

Pentru folosirea colecțiilor de elemente se pot utiliza tablourile unidimensionale sau
multidimensionale precum și clase special create pentru manipularea colecțiilor de
elemente. Aceste clase se găsesc în spațiile de nume System.Collections sau
System.Collections.Generic.

Exemplu:
const int NR_RANDURI=3;
const int NR_COLOANE=2;
static void Main(string[] args)
{
int[] a = new int[10];//tablou cu 10 elemente
for (int i = 0; i < 10; i++) a[i] = i;

String[] nume = new string[3] { "Ion", "John", "Johann" };

double[,] b = new double[3, 2] { { 1, 2 }, { 3, 4 }, { 5, 6 }

};//matrice cu 3 linii si 2 coloane

int size = b.Length;//6

Complex[] linie = new Complex[NR_COLOANE];

for (int i = 0; i < linie.Length; i++) linie[i] = new Complex(i, 2 * i);

Complex[][] matrice = new Complex[NR_RANDURI][];//tablou de tablouri

for (int i = 0; i < matrice.Length; i++)
{
matrice[i] = new Complex[NR_COLOANE];
for (int j = 0; j < matrice[i].Length; j++)
matrice[i][j] = new Complex(i, j);

}
//linie[2]=new Complex(3,2);//eroare, exceptie de tip
'System.IndexOutOfRangeException'
}

În exemplul de mai sus am folosit proprietatea Length pentru a citi dimensiunea

tabloului. Se observă că elementele unui tablou pot fi de tipuri standard sau declarate de
programator
Pentru lucrul cu tablouri "dinamice" (dimensiune variabilă) putem folosi clasa
List<T> din spațiul de nume System.Collections.Generic. Elementele listei pot fi accesate
prin index. Clasa pune la dispoziție metode pentru căutare, sortare și manipulare a listelor.

Un constructor al clasei este

List<T>()

care crează o nouă instanță a clasei (o listă goală).

1 lect. dr. Marius Apetrii

Programare orientată pe obiecte Curs 10

Numărul total de elemente ce poate fi reținut fără redimensionare poate fi controlat

prin intermediul proprietății Capacity. Nu este obligatorie redimensionarea, aceasta
făcându-se automat. Proprietatea Count permite citirea numărului de elemente din listă iar
proprietatea Index permite accesul la elementul de pe poziția specificată.

Printre metodele clasei regăsim:

Nume Descriere
Add Adaugă un obiect la sfârșitul listei.

AddRange Adaugă o colecție de obiecte la sfârșitul listei.

Clear Elimină toate elementele listei.

IndexOf(T) Intoarce indexul elementului specificat (dacă acesta există în listă).

Insert Adaugă un element cu indexul specificat.

Remove Elimină din listă primul element care coincide cu cel specificat

RemoveAt Elimină elementul de pe poziția specificată.

Reverse() Așează elementele listei în ordine inversă .

Reverse(Int32, Int32) Schimbă ordinea elementelor din intervalul specificat.

Sort(Comparison<T>) Sortează elementele listei folosind s the elements in the entire List<T>

using the specified System.Comparison<T>.

ToArray Copie elementele listei într-un tablou.

Observație: Elementele unei liste pot fi de tipul null și se accepta duplicate.

Pentru parcurgerea elementelor unei liste se poate folosi o formă specială a
instrucțiunii for și anume foreach ( a se vedea în exemplul de mai jos motoda diferenta
din clasa Multime ).

Exemplu:

class Punct
{
private float x, y;
private String text;
public Punct(String text, float x = 0, float y = 0)
{
this.text = text;
this.x = x;
this.y = y;
}
public String Text
{

2 lect. dr. Marius Apetrii

Programare orientată pe obiecte Curs 10

get { return text; }

set { text = value; }
}
public float X
{
get { return x; }
set { x = value; }
}
public float Y
{
get { return y; }
set { y = value; }
}
}

class Multime
{
String nume;
List<Punct> elemente;
public Multime(String nume)
{
this.nume = nume;
this.elemente = new List<Punct>();//lista goala cu elemente de tip Punct
}
public String Nume
{
get { return nume; }
set { nume = value; }
}
public int NrElemente
{//numarul de elemente din lista
get { return elemente.Count; }
}
public List<Punct> Elemente
{
get { return elemente; }
set { elemente = value; }
}
public void adauga(Punct P)
{
elemente.Add(P);//adaugam un element la final
}
public void adauga(Punct P, int index)
{
try
{
elemente.Insert(index, P);//adaugam un element cu indexul index
}
catch (Exception)
{
elemente.Add(P);
}
}
public void scrie()
{
String text = nume + "={";
if (NrElemente > 0)
{

3 lect. dr. Marius Apetrii

Programare orientată pe obiecte Curs 10

text += elemente[0].Text;
for (int i = 1; i < NrElemente; i++)
text += "," + elemente[i].Text;
}
text += "}";
Console.WriteLine(text);
}
public void inverseazaElemente()
{
elemente.Reverse();
}
public static Multime reuniune(Multime M1, Multime M2)
{
Multime M = new Multime(M1.Nume + "U" + M2.Nume);
M.Elemente.AddRange(M1.Elemente);
//daca am fi pus in locul instructiunii de mai sus
//M->Elemente=M1->Elemente;
//instructiunea urmatoare ar fi adaugat elementele si listei multimii M1
M.Elemente.AddRange(M2.Elemente);
M.elimina_duplicate();
return M;
}
public static Multime diferenta(Multime M1, Multime M2)
{
Multime M = new Multime(M1.Nume + "/" + M2.Nume);
M.Elemente.AddRange(M1.Elemente);
foreach (Punct P in M2.Elemente)
M.Elemente.Remove(P);
return M;
}
public bool contine(Punct P)
{
return elemente.IndexOf(P) >= 0;
}
public void elimina_duplicate()
{
for (int i = 0; i < elemente.Count; i++)
for (int j = i + 1; j < elemente.Count; j++)
if (elemente[j] == elemente[i])
{
elemente.RemoveAt(j);
j--;
}
}
public static int ascendent_dupa_X(Punct P1, Punct P2)
{
if(P1.X == P2.X)return 0;
return P1.X > P2.X ? 1 : -1;
}
public static int descendent_dupa_X(Punct P1, Punct P2)
{
return -ascendent_dupa_X(P1, P2);
}
public static int ascendent_dupa_nume(Punct P1, Punct P2)
{
return String.Compare(P1.Text, P2.Text);
}
/*Pentru a folosi metoda Sort este important ca functia sa fie statica*/

4 lect. dr. Marius Apetrii

Programare orientată pe obiecte Curs 10

public void sorteaza(int tip)

{
switch (tip)
{
case 1://crescator dupa X
elemente.Sort(new Comparison<Punct>(ascendent_dupa_X));
break;
case 2://descrescator dupa X
elemente.Sort(new Comparison<Punct>(descendent_dupa_X));
break;
case 3://crescator dupa nume
elemente.Sort(new Comparison<Punct>(ascendent_dupa_nume));
break;
}
}
}

static void Main(string[] args)

{
Multime A = new Multime("A");
Multime B = new Multime("B");
Multime C;

Punct a = new Punct("a", 4, 0), b = new Punct("b", 2, 3), c = new

Punct("c", 5, 0), d = new Punct("d", 6, 9), e = new Punct("e", 1, 3);
Punct f = new Punct("f", 4, 9), g = new Punct("g", 2, 1), h = new
Punct("h", 7, 6), i = new Punct("i", 1, 3), j = new Punct("j", 9, 2);

Console.WriteLine(A.Elemente.Capacity);//citim valoarea pentru Capacity

(initial este 0)
A.adauga(a);
Console.WriteLine(A.Elemente.Capacity);//citim valoarea pentru Capacity
(valoarea a crescut automat cand s-a adaugat elementul)
A.adauga(b, 3);
A.adauga(c, 0);
A.adauga(h);
A.adauga(d);

B.adauga(a);
B.adauga(e);
B.adauga(f);
B.adauga(b);
B.adauga(h);
B.adauga(i);
B.adauga(j);

A.scrie();
B.scrie();

C = Multime.reuniune(A, B);
C.scrie();
C = Multime.diferenta(A, B);
C.scrie();

C.scrie();
Console.WriteLine(A.contine(j));
A.scrie();

5 lect. dr. Marius Apetrii

Programare orientată pe obiecte Curs 10

A.sorteaza(1);
A.scrie();
A.sorteaza(2);
A.scrie();
A.sorteaza(3);
A.scrie();
}
În urma execuției obținem:
0
4
A={c,a,b,h,d}
B={a,e,f,b,h,i,j}
AUB={c,a,b,h,d,e,f,i,j}
A/B={c,d}
A/B={c,d}
False
A={c,a,b,h,d}
A={b,a,c,d,h}
A={h,d,c,a,b}
A={a,b,c,d,h}
Press any key to continue . . .

Observație: Pentru lucrul cu liste de elemente cu tipuri diferite (nu au un tip de bază
comun) se poate folosi clasa ArrayList din spațiul de nume System.Collection. Elementele
acestei clase se utilizează în mod asemănător.

Operaţii de intrare/ieşire

Clasele utilizate pentru operaţiile de intrare/ieşire precum şi clasele utilizate pentru

lucrul cu fişiere şi directoare sunt conţinute de spaţiul de nume System.IO.

Principalele clase din System.IO sunt:

Clasa Descrierea
BinaryReader Citeşte tipurile primitive de date ca valori binare
BinaryWriter Scrie tipurile primitive de date ca valori binare
BufferedStream O clasă flux care memorează într-un buffer citirile şi scrierile
către alt flux
Directory Posedă metode statice pentru lucrul cu directoare
DirectoryInfo Posedă metode non-statice pentru lucrul cu directoare
File Posedă metode statice pentru lucrul cu fişiere

6 lect. dr. Marius Apetrii

Programare orientată pe obiecte Curs 10

FileInfo Posedă metode non-statice pentru lucrul cu fişiere

FileStream O clasă pentru citirea şi scrierea de fişiere cu ajutorul unui flux
FileSystemInfo Clasă abstractă de bază pentru clasele DirectoryInfo şi FileInfo
FileSystemWatcher Urmăreşte modificările efectuate în sistemul de fişiere
IOException Excepţia generată de clasele din spaţiul de nume System.IO
MemoryStream O clasă flux care efectuează citiri şi scrieri în memorie
Path Permite lucrul cu şiruri de directoare într-o manieră
independentă de platformă
Stream Clasă abstractă de bază pentru toate clasele flux
StreamReader O clasă TextReader care citeşte caractere dintr-un flux de
octeţi
StreamWriter O clasă TextWriter care scrie caractere într-un flux de octeţi
StringReader O clasă TextReader care citeşte dintr-un şir
StringWriter O clasă TextWriter care scrie într-un şir
TextReader Clasă abstractă de bază pentru clasele StreamReader şi
StringReader
TextWriter Clasă abstractă de bază pentru clasele StreamWriter şi
StringWriter

Clasele orientate pe operaţii de intrare/ieşire din spaţiul de nume System.IO pot fi

împărţite în trei grupuri:

o Clasele stream, care sunt proiectate pentru intrarea şi ieşirea fluxurilor de octeţi;
o Clasele TextReader şi TextWrite, care sunt utilizate pentru operaţii de intrare/ieşire
în mod caracter;
o Clasele BinaryReader şi BinaryWriter, care sunt utilizate pentru intrarea şi ieşirea
tipurilor primitive, cum ar fi Int32 şi Double, în format binar.

Clasa FileStream

Este utilizată pentru a transfera octeţi într-un fişier. Clasa FileStream are
constructori supraîncărcaţi care permit specificarea următoarelor informaţii:
o Numele fişierului
o Modul de deschidere a fişierului
o Tipul de acces necesar
o Opţiunile de partajare
o Dimensiunea buffer-ului

public FileStream(String, FileMode);

public FileStream(String, FileMode, FileAccess);
public FileStream(String, FileMode, FileAccess, FileShare);
public FileStream(String, FileMode, FileAccess, FileShare, int);

7 lect. dr. Marius Apetrii

Programare orientată pe obiecte Curs 10

Modul de deschidere al fişierului este reprezentat de membrii enumerării FileMode,

o parte a acestor membri fiind prezentaţi în tabelul următor:

Nume membru Descriere

Append Deschide un fişier existent sau creează un fişier nou şi adaugă
textul la sfârşit
Create Creează un fişier nou sau deschide un fişier existent şi îl
suprascrie
CreateNew Crează un fişier nou şi generează o excepţie dacă fişierul
există deja
Open Deschide un fişier şi lansează excepţia
System.IO.FileNotFoundException dacă fişierul nu există.

Tipul de acces este reprezentat de membrii enumerării FileAccess, prezentaţi în

tabelul următor:

Nume membru Descriere

Read Accesul pentru citire
ReadWrite Accesul pentru citire/scriere
Write Accesul pentru scriere

Opţiunile de partajare sunt specificate de enumerarea FileShare:

Nume membru Descriere

None Fără partajare
Read Accesul pentru citire partajată
ReadWrite Accesul pentru citire/scriere partajată
Write Accesul pentru scriere partajată

Exemplu:

FileStream fs=new
FileStream("fisier.txt",FileMode.Create,FileAccess.ReadWrite,
FileShare.Read);

Observaţie: De obicei, clasa FileStream este utilizată împreună cu alte clase de

scriere/citire, însă se pot utiliza metodele Read şi Write ale acesteia pentru a citi/scrie
octeţii direct.

8 lect. dr. Marius Apetrii

Programare orientată pe obiecte Curs 10

Clasa TextWriter

Este clasă abstractă de bază pentru un grup de clase (ex.: StreamWriter,

StringWriter) utilizate pentru a scrie caractere. Principalele metode ale clasei sunt:

Metodă Descriere
Close Închide obiectul pentru scriere şi eliberează resursele utilizate
de acesta
Dispose Eliberează resursele utilizate de obiectul pentru scriere
Flush Scrie toate datele memorate în buffer la dispozitivul de bază
Write Scrie textul fără o linie nouă
WriteLine Scrie textul cu o linie nouă

Observaţie: Clasa Console utilizează un obiect TextWriter pentru efectuarea

operaţiilor de ieşire.

Exemplu de utilizare a clasei TextWriter:

try{
// Creăm un FileStream
FileStream fs = new FileStream("iesire.txt", FileMode.Create);
// Creăm un StreamWriter
StreamWriter sw = new StreamWriter(fs);
// Scriem un text
sw.Write("Prima ");
sw.WriteLine(" linie");
sw.WriteLine("A doua linie");
sw.WriteLine("A treia linie");
sw.Flush();
sw.Close();
}
catch(System.Exception pe){
Console.WriteLine(pe.ToString());
}

În fişierul “iesire.txt” vom avea:

Prima linie
A doua linie
A treia linie

Clasa TextReader

Este clasă abstractă de bază pentru un grup de clase (ex.: StreamReader,

StringReader) utilizate pentru a citi caractere. Principalele metode ale clasei sunt:

9 lect. dr. Marius Apetrii

Programare orientată pe obiecte Curs 10

Metodă Descriere
Close Închide obiectul pentru citire şi eliberează resursele utilizate de
acesta
Dispose Eliberează resursele utilizate de obiectul pentru citire
Peek Returnează următorul caracter de la fluxul de intrare fără să mute
pointerul de fişier
Read Citeşte unul sau mai multe caractere de la fluxul de intrare şi mută
pointerul de fişier
ReadBlock Citeşte un bloc de caractere
ReadLine Citeşte o linie
ReadToEnd Citeşte până la sfârşitul fluxului de intrare

Similar clasei TextWriter, obiectele clasei TextReader interconectează cu obiectele

care acţionează ca sursă de octeţi (ex.: FileStream).

Observaţie: Clasa Console utilizează un obiect TextReader pentru efectuarea

operaţiilor de citire.

Exemplu de utilizare a clasei TextReader pentru citirea linie cu linie:

using System.IO;

…
static void Main(string[] args)
{
FileStream fs=null;
StreamReader sr=null;
try
{
fs = new FileStream("intrare.txt", FileMode.Open);
sr = new StreamReader(fs);
int nr = 0;
for (; ; )
{
String linie = sr.ReadLine();
nr++;
if (linie == null) break;//daca s-a citit tot
Console.WriteLine(linie);
if (nr % 20 == 0)
{//afisam câte 20 de linii odata
Console.Write("--continuare?--");
String raspuns = Console.ReadLine();
if (raspuns.Equals("Nu")) break;
nr = 0;
}

10 lect. dr. Marius Apetrii

Programare orientată pe obiecte Curs 10

}
}
catch (System.Exception e)
{
Console.WriteLine("Eroare:\r\n"+e.ToString());
}
finally
{
if(sr!=null)sr.Close();
if (fs != null) fs.Close();
}
}

Exemplu de utilizare a clasei TextReader pentru citirea caracter cu caracter:

using System.IO;

…
static void Main(string[] args)
{
FileStream fs=null;
StreamReader sr = null ;
try
{
fs = new FileStream("intrare.txt", FileMode.Open);
sr = new StreamReader(fs);
int nr = 0;
for (; ; )
{
int caracter = sr.Read();
nr++;
if (caracter == -1) break;//daca s-a citit tot
Console.Write(Convert.ToChar(caracter));
}
}
catch (System.Exception e)
{
Console.WriteLine(e.ToString());
}
finally
{
if(sr!=null)sr.Close();
if(fs!=null)fs.Close();
}

Clasa BinaryWriter

Clasa BinaryWriter scrie tipurile primitive în format binar. Ca şi clasa TextWriter

foloseşte un obiect Stream de bază pentru a pune la dispoziţie un flux de octeţi. Accesul la
acest obiect se face prin intermediul proprietăţii BaseStream. Principalele metode ale clasei
sunt:

11 lect. dr. Marius Apetrii

Programare orientată pe obiecte Curs 10

Metodă Descriere
Close Închide obiectul pentru scriere şi obiectul Stream de bază
Dispose Eliberează resursele utilizate de obiectul pentru scriere
Flush Scrie toate datele memorate în buffer la dispozitivul de bază
Seek Stabileşte poziţia în cadrul obiectului Stream de bază
Write Scrie o valoare în obiectul Stream

Observaţie: Metoda Write acceptă diferite tipuri de bază. Modul de utilizare al

aceastei metode se va vedea în exeplul de mai jos.

Clasa BinaryReader

Clasa BinaryReader citeşte tipurile primitive în format binar. Ca şi clasa

TextReader foloseşte un obiect Stream de bază pentru a pune la dispoziţie un flux de octeţi.
Accesul la acest obiect se face prin intermediul proprietăţii BaseStream. Principalele
metode ale clasei sunt:

Metodă Descriere
Close Închide obiectul pentru citire şi obiectul Stream de bază
Dispose Eliberează resursele utilizate de obiectul pentru citire
FillBuffer Umple bufferul intern cu un număr de octeţi citiţi de la
fluxul de bază
PeekChar Citeşte următorul caracter dar nu avansează pointerul de
poziţionare
Read Citeşte unul sau mai mulţi octeţi sau caractere de la
obiectul Stream
ReadBoolean Citeşte o valoare de tip Boolean de la obiectul Stream
ReadByte, ReadBytes Citeşte una sau mai multe valori de tip Byte de la obiectul
Stream
ReadChar, ReadChars Citeşte una sau mai multe valori de tip Char de la
obiectul Stream
ReadDecimal Citeşte o valoare de tip Decimal de la obiectul Stream
ReadDouble, ReadSingle Citeşte o valoare în virgulă mobilă cu dublă sau simplă
precizie de la obiectul Stream
ReadInt16, ReadInt32, Citeşte o valoare de tip întreg de la obiectul Stream
ReadInt64
ReadString Citeşte o valoare de tip String de la obiectul Stream

12 lect. dr. Marius Apetrii

Programare orientată pe obiecte Curs 10

Observaţie: Spre deosebire de clasa BinaryWriter, clasa BinaryReader pune la

dispoziţie funcţii separate pentru citirea fiecăruia dintre tipurile de bază.

Exemplu de utilizare a claselor BinaryReader şi BinaryWriter pentru citire/scriere în format

binar:
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using System.IO;

namespace Angajati
{
class Angajat
{
String nume, prenume;
int anNastere;
bool casatorit;
double salar;

public Angajat(String nume, String prenume, int anNastere, bool casatorit,

double salar)
{
this.nume = nume;
this.prenume = prenume;
this.anNastere = anNastere;
this.casatorit = casatorit;
this.salar = salar;
}
public void scrie(BinaryWriter bw)
{
bw.Write(nume);
bw.Write(prenume);
bw.Write(anNastere);
bw.Write(casatorit);
bw.Write(salar);
}
public static Angajat citeste(BinaryReader br)
{
String nume, prenume;
int anNastere;
bool casatorit;
double salar;
try
{
nume = br.ReadString();
prenume = br.ReadString();
anNastere = br.ReadInt32();
casatorit = br.ReadBoolean();
salar = br.ReadDouble();
return new Angajat(nume, prenume, anNastere, casatorit, salar);
}
catch (Exception) { return null; }
}
}

13 lect. dr. Marius Apetrii

Programare orientată pe obiecte Curs 10

class Program
{
static void Main(string[] args)
{
List<Angajat> angajati = new List<Angajat>();
angajati.Add(new Angajat("Popescu", "Gheorghe", 1955, true, 1800));
angajati.Add(new Angajat("Sandulescu", "Sandu", 1975, true, 900));
angajati.Add(new Angajat("Georgecu", "Ion", 1962, true, 2800));

//salvam lista de angajati in fisierul angajati.io

FileStream fs=null;
BinaryWriter bw=null;
try
{
fs = new FileStream("angajati.io", FileMode.Open);
bw = new BinaryWriter(fs);
bw.Write(angajati.Count);//scriem numarul angajatilor
foreach (Angajat a in angajati)
a.scrie(bw);
}
catch (Exception)
{
Console.WriteLine("Eroare la scriere in fisier.");
}
finally
{
if(bw!=null)bw.Close();
if(fs!=null)fs.Close();
}

//citim lista angajatilor din fisierul angajati.io

angajati.Clear();
BinaryReader br=null;
try
{
fs = new FileStream("angajati.io", FileMode.OpenOrCreate);
br = new BinaryReader(fs);
int nrAngajati = br.ReadInt32();//citim numarul angajatilor
for (int i = 0; i < nrAngajati; i++)
angajati.Add(Angajat.citeste(br));
}
catch (Exception)
{
Console.WriteLine("Eroare la citirea din fisier.");
}
finally
{
if (bw != null) bw.Close();
if (fs != null) fs.Close();
}

}
}
}

14 lect. dr. Marius Apetrii

Programare orientată pe obiecte Curs 10

Observaţie: Pentru serializarea / deserializarea datelopr se poate urmări exemplul

prezentat în cadrul laboratorului.

Lucrul cu fişiere şi directoare

Pentru lucrul cu directoare avem clasele Directory şi DirectoryInfo. Ele se
deosebesc prin faptul că în clasa Directory există doar metode statice, în timp ce clasa
DirectoryInfo conţine metode non-statice. Ambele clase sunt utile deoarece:
o metodele statice ale clasei Directory se folosesc pentru verificări înainte de accesul
la un director sau fişier (aceste verificări sunt efectuate la fiecare apel al unei
metode statice, ceea ce poate fi costisitor din punctul de vedere al timpului de
execuţie);
o obiectele din clasa DirectoryInfo lucrează cu un singur director iar verificarea se
face o singură dată, atunci când este construit obiectul, de aceea clasa DirectoryInfo
se utilizează de obicei când se efectuează mai multe operaţii cu un acelaşi director.

Clasa Directory

Principalele metode ale clasei sunt:

Metoda Descriere
CreateDirectory Crează un director
Delete Şterge un director şi, opţional, subdirectoarele acestuia
Exists Verifică dacă există un anumit director
GetCreationTime Dă timpul la care a fost creat directorul
GetCurrentDirectory Dă un string ce reprezintă calea spre directorul curent
GetDirectories Dă un tablou de şiruri reprezentând numele
subdirectoarelor dintr-un director
GetDirectoryRoot Dă rădăcina pentru o cale dată
GetFiles Dă un tablou de şiruri reprezentând numele fişierelor dintr-
un director
GetFileSystemEntries Dă un tablou de şiruri reprezentând numele fişierelor şi
directoarelor dintr-un director dat
GetLastAccessTime Dă timpul la care s-a făcut ultimul acces al directorului
GetLastWriteTime Dă timpul ultimei scrieri pentru un director specificat
GetLogicalDrives Dă o listă cu unităţile logice de pe calculator
GetParent Dă directorul părinte pentru un director specificat
Move Mută un director şi conţinutul acestuia
SetCreationTime Stabileşte timpul de creare a directorului
SetCurrentDirectory Stabileşte directorul curent

15 lect. dr. Marius Apetrii

Programare orientată pe obiecte Curs 10

SetLastAccessTime Stabileşte timpul ultimului acces pentru director

SetLastWriteTime Stabileşte timpul ultimei scrieri pentru director

Clasa DirectoryInfo

Principalele proprietăţi ale clasei:

Proprietate Descriere
Attributes Dă sau setează obiectul FileAttributes pentru director
CreationTime Dă sau setează timpul la care a fost creat directorul
Exists Dă o valoare care indică dacă există calea directorului
FullName Dă calea completă a directorului
LastAccessTime Dă sau setează timpul ultimei accesări a directorului
LastWriteTime Dă sau setează timpul ultimei scrieri a directorului
Name Dă numele directorului
Parent Dă un obiect DirectoryInfo reprezentând părintele acestui
director
Root Dă un obiect DirectoryInfo reprezentând partea de
rădăcină a unei căi de director

Principalele metode ale clasei sunt:

Metoda Descriere
Create Crează un director
CreateSubdirectory Crează unul sau mai multe subdirectoare
Delete Şterge un director şi conţinutul acestuia
GetDirectories Dă un tablou de obiecte DirectoryInfo reprezentând
subdirectoarele directorului
GetFiles Dă un tablou de obiecte FileInfo reprezentând fişierele
directorului
GetFileSystemInfos Dă un tablou de obiecte FileSystemInfo reprezentând
fişierele şi directoarele directorului
MoveTo Mută directorul şi conţinutul acestuia
ToString Dă calea complet determinată ca un şir de caractere

16 lect. dr. Marius Apetrii

Programare orientată pe obiecte Curs 10

Pentru lucrul cu fişiere avem clasele File şi FileInfo. Similar claselor Directory şi
DirectoryInfo, clasa File conţine metode statice îar clasa FileInfo conţine metode non-
statice.

Clasa File

Principalele metode ale clasei:

Metoda Descriere
AppendText Adaugă un text unui fişier, creând fişierul dacă acesta nu
există
Copy Copie un fişier
Create Crează un nou fişier
CreateText Crează un nou fişier text
Delete Şterge un fişier
Exists Dă o valoare care indică dacă fişierul există
GetAttributes Dă atributele fişierului
GetCreationTime Dă timpul la care a fost creat fişierul
GetLastAccessTime Dă timpul ultimei accesări a fişierului
GetLastWriteTime Dă timpul la care a fost efectuată ultima scriere în fişier
Move Mută fişierul într-o locaţie nouă, cu opţiunea de a-l redenumi
Open Deschide un obiect FileStream pentru acces de tip
citire/scriere la un fişier
OpenRead Deschide un obiect FileStream pentru acces de tip numai citire
la un fişier
OpenText Deschide un obiect FileStream pentru a citi dintr-un fişier text
OpenWrite Deschide un obiect FileStream pentru acces de tip
citire/scriere la un fişier
SetAttributes Setează atributele fişierului
SetCreationTime Setează timpul la care a fost creat fişierul
SetLastAccessTime Setează timpul ultimei accesări a fişierului
SetLastWriteTime Setează timpul ultimei scrieri în fişier

Clasa FileInfo

Proprietăţile clasei:

17 lect. dr. Marius Apetrii

Programare orientată pe obiecte Curs 10

Proprietate Descriere
CreationTime Dă sau setează timpul la care a fost creat fișierul
Directory Dă un obiect DirectoryInfo reprezentând directorul părinte al
fişierului
DirectoryName Dă un şir de caractere reprezentănd calea completă a fişierului
Exists Dă o valoare care indică dacă fişierul există
LastAccessTime Dă sau setează timpul ultimei accesări a fișierului
LastWriteTime Dă sau setează timpul ultimei scrieri a fișierului
Length Dă lungimea fişierului în octeţi
Name Dă numele fişierului

Metode ale clasei

Metoda Descriere
AppendText Crează un obiect StreamWriter pentru a adăuga un text la un
fişier
CopyTo Copiază un fişier în altă locaţie
Create Crează un fişier nou şi un obiect FileStream pentru a scrie în el
CreateText Crează un obiect StreamWriter pentru a scrie într-un fişier text
nou
Delete Şterge un fişier
MoveTo Mută un fişier într-o locaţie nouă
Open Returnează un obiect FileStream cu un nivel specificat de acces
la un fişier
OpenRead Returnează un obiect FileStream cu acces pentru citire dintr-un
fişier
OpenText Crează un obiect StreamReader pentru a citi dintr-un fişier
existent
OpenWrite Returnează un obiect FileStream cu acces pentru citire/scriere
dintr-un fişier
ToString Returnează calea fişierului sub forma unui şir

Principalele atribute pentru un fişier sunt

Nume Descriere Valoare

Archive De tip arhivă. 32
Compressed Fişierul este comprimat. 2048
Directory Dacă este director 16

18 lect. dr. Marius Apetrii

Programare orientată pe obiecte Curs 10

Hidden Dacă este ascuns. 2

Normal Fişier normal, fără atribute 128
suplimentare
ReadOnly Fişier doar pentru citire 1
System Fişier de sistem, fiind utilizat numai 4
de sistemul de operare.
Temporary Fişier temporar. 256

Exemplu

if (!Directory.Exists("D:\\Test\\DirectorNou"))//testam existenta
Directory.CreateDirectory("D:\\Test\\DirectorNou");//cream directorul
if (File.Exists("C:\\fisier.txt")) ;//testam existenta fisierul de copiat
File.Copy("C:\\fisier.txt", "D:\\Test\\DirectorNou\\fisier1.txt", true);//daca
fisierul exista deja il rescrie

Exemplu Funcțiile următoare pot fi utilizate pentru afișarea conținutului unui director (lista
subdirectoarelor și a fișierelor)

static void scrie_continut(DirectoryInfo director, TextWriter sr, String alin)

{
sr.WriteLine(alin + "-" + director.Name);
alin += " |";
DirectoryInfo[] subdirectoare = director.GetDirectories();
foreach (DirectoryInfo subdir in subdirectoare)
scrie_continut(subdir, sr, alin);

FileInfo[] fisiere = director.GetFiles();

foreach (FileInfo fisier in fisiere)
sr.WriteLine(alin + "____" + fisier.Name);
}

static void scrie(String cale, TextWriter sr)

{
if (!Directory.Exists(cale))
{
sr.WriteLine("Cale incorecta!!!");
return;
}
scrie_continut(new DirectoryInfo(cale), sr, "");
}

Spre exemplu putem avea:

static void Main(string[] args)

{
scrie("D:\\Test",Console.Out);
}

19 lect. dr. Marius Apetrii

Programare orientată pe obiecte Curs 10

Exemplu Detalii despre un fisier pot fi obținute apelând funcția:

void scrie_detalii_fisier(String nume, TextWriter sr)
{
if (File.Exists(nume))
{
FileInfo file = new FileInfo(nume);
sr.WriteLine("\nDetalii despre fisierul {0}:", file.Name);
sr.WriteLine();
sr.WriteLine("Data crearii: {0}", file.CreationTime);
sr.WriteLine("Data ultimei modificari: {0}", file.LastWriteTime);
sr.WriteLine("Dimensiune fisier: {0} octeti", file.Length);
sr.WriteLine("Fisier doar pentru citire: {0}", ((file.Attributes &
FileAttributes.ReadOnly) > 0) ? "DA" : "NU");
sr.WriteLine("Fisier ascuns: {0}", ((file.Attributes &
FileAttributes.Hidden) > 0) ? "DA" : "NU");
sr.WriteLine("Fisier de sistem: {0}", ((file.Attributes &
FileAttributes.System) > 0) ? "DA" : "NU");
sr.WriteLine("Este director: {0}", ((file.Attributes &
FileAttributes.Directory) > 0) ? "DA" : "NU");
sr.WriteLine("Fisier de tip arhiva: {0}", ((file.Attributes &
FileAttributes.Archive) > 0) ? "DA" : "NU");
sr.WriteLine("Fisier temporar: {0}", ((file.Attributes &
FileAttributes.Temporary) > 0) ? "DA" : "NU");
sr.WriteLine("Fisier comprimat: {0}", ((file.Attributes &
FileAttributes.Compressed) > 0) ? "DA" : "NU");
}
}

20 lect. dr. Marius Apetrii