.NET Frameworkadiftene/C_SHARP/Ziua01/1.02... · 2014-02-01 · Elemente cheie ale platformei .NET...

.NET Framework Limbajul C#

Limbajul C# şi platforma .NET

Limbajul C# a fost dezvoltat în cadrul Microsoft. Principalii creatori ai

limbajului sunt Anders Hejlsberg, Scott Wiltamuth şi Peter Golde. Mii de

programatori de C, C++ şi Java, au migrat cu uşurinţă spre C#, graţie

asemănării acestor limbaje, dar mai ales calităţilor noului limbaj.

C# este:

• un limbaj de programare simplu, modern, de utilitate generală, cu

productivitate mare în programare. ƒ

• un limbaj orientat pe obiecte.

• ƒpermite dezvoltarea de aplicaţii industriale robuste, durabile.

• ƒoferă suport complet pentru dezvoltarea de componente software,

foarte necesare de pildă în medii distribuite.

În strânsă legatură cu Arhitectura .NET (.NET Framework) pe care funcţionează, C# gestionează în mod automat memoria utilizată. Eliberarea memoriei ocupate (garbage collection) de către obiectele care nu mai sunt necesare aplicaţiei, este o facilitate importantă a limbajului.

În C# se scriu de asemenea aplicaţii pentru sisteme complexe care funcţionează sub o mare varietate de sisteme de operare, cât şi pentru sisteme dedicate (embeded systems):

• dispozitive portabile: ceasuri digitale, telefoane mobile, MP3 playere

• dispozitive staţionare ca semafoare de trafic, sau controlere pentru automatizarea producţiei.

Din punct de vedere sintactic C# derivă din limbajul C++, dar include şi influenţe din alte limbaje, mai ales Java.

Limbajul C# şi platforma .NET

.NET Framework Arhitectura .NET este o componentă software care oferă un mediu de programare şi de execuţie a aplicaţiilor pentru sistemele de operare Microsoft.

.NET Framework este un mediu care permite dezvoltarea şi rularea aplicaţiilor şi a serviciilor Web, independente de platformă.

.NET pune la dispoziţie o colecţie impresionantă de clase organizate în biblioteci, pe care C# le utilizează.

C# funcţionează având .NET ca infrastructură, dar .NET suportă şi alte limbaje, cum este C++, Visual Basic sau Java. În oricare dintre aceste limbaje programaţi, aveţi la dispoziţie aceleaşi biblioteci de clase. .NET se realizează în acest fel interoperabilitatea limbajelor.

.NET Framework

.NET este constituit din două entităţi

importante:

• ƒCommon Language Runtime (CLR)

Acesta este mediul de execuţie al programelor. Este modulul care se ocupă cu managementul şi execuţia codului scris în limbaje specifice .NET. CLR furnizează de asemenea servicii importante, cum sunt securitatea aplicaţiilor, portabilitatea acestora, managementul memoriei şi tratarea excepţiilor.

• ƒ Base Class Library

Este vorba despre Biblioteca de Clase .NET. Această bibliotecă acoperă o arie largă a necesităţilor de programare, incluzând interfaţa cu utilizatorul, conectarea cu bazele de date şi accesarea datelor, dezvoltarea aplicaţiilor web, comunicarea în reţele şi altele.

Programatorii combină propriul cod cu codul Bibliotecii de Clase .NET pentru producerea de aplicaţii.

Ce este platforma .NET?

Platforma .NET oferă facilităţile:

• creare de software care să permită conectarea, în mod unitar, a sistemelor de tipuri diferite, interoperarea la nivelul tehnologiilor de tipuri diferite.

Exemple: programe pentru desktop, aplicaţii pentru dispozitive mobile, aplicaţii şi servicii web sau servicii Windows, programe izolate, sisteme distribuite (Un sistem distribuit este o colectie de calculatoare independente care apar utilizatorilor sistemului ca un singur calculator) care să ruleze atât cu tehnologii Unix, cât şi Windows.

• programare într-o serie de limbaje de programare de nivel înalt.

Exemple: C#, Visual Basic.NET, Managed C++, C++/CLI, J# ("jay-sharp“) etc.

• Mediul de execuţie este strict controlat de un motor de execuţie, care oferă o serie de facilităţi ce ridica mult nivelul de calitate al aplicaţiilor.

Exemple: managementul automat al memoriei, securitatea.

http://msdn.microsoft.com/vbasic/





http://msdn.microsoft.com/library/en-us/netstart/html/cpcsvbvcjscript_managed_c__.asp



http://msdn.microsoft.com/visualc/homepageheadlines/ecma/default.aspx

http://msdn.microsoft.com/vjsharp/

Elemente cheie ale platformei .NET

• Developer tools – interfaţa şi unelte pentru proiectarea, crearea, rularea şi dezvoltarea soluţiilor.

Exemple: .NET Framework, Visual Studio .NET

• Servers – infrastructura pentru construirea şi dezvoltarea soluţiilor.

Exemple: Microsoft Windows *** Server, Microsoft .NET Enterprise Servers

• XML Web Services – servicii predefinite, rutine comune care permit dezvoltatorilor să creeze propriile servicii.

Exemple: Microsoft Windows 7 for computers

Compilarea programelor pe platforma .NET În urma compilării unui program C#, nu se crează un cod executabil. Se creează

un fişier numit assembly care de regulă se identifică cu extensia .exe sau .dll. Un

asemenea fişier nu poate fi executat pe un sistem pe care nu există infrastructura

.NET. Fişierul conţine un tip special de cod, numit CIL (Common Intermediate

Language). Limbajul CIL defineşte un set de instrucţiuni portabile, independente

de orice tip de procesor şi platformă.

În momentul în care un program este executat, CLR activează un compilator

special, numit JIT (just in time). Acesta preia codul CIL şi îl transformă în cod

executabil. Un program compilat în format CIL poate rula pe orice sistem pe care

s-a instalat Common Language Runtime. Aceasta asigură portabilitatea

aplicaţiilor .NET. Fişierul .exe sau .dll produs la compilare conţine pe lângă codul

CIL, aşa numitele metadate. Metadatele descriu datele utilizate de către aplicaţie.

Introducere în limbajul C#

Limbajul C# fost dezvoltat de o echipă restrânsă de

ingineri de la Microsoft, echipă din care s-a evidenţiat Anders

Hejlsberg (autorul limbajului Turbo Pascal şi membru al echipei

care a proiectat Borland Delphi).

C# este un limbaj simplu, cu circa 80 de cuvinte cheie, şi

12 tipuri de date predefinite. El permite programarea

structurată, modulară şi orientată obiectual, conform

perceptelor moderne ale programării profesioniste.

Introducere în limbajul C#

Limbajul C# moşteneşte sintaxa şi principiile de

programare din C++. Utilizăm o serie de tipuri noi de date sau

funcţiuni diferite ale datelor din C++, iar în spiritul realizării

unor secvenţe de cod sigure (safe), unele funcţiuni au fost

adăugate (de exemplu, interfeţe şi delegări), diversificate (tipul

struct), modificate (tipul string) sau chiar eliminate (moştenirea

multiplă şi pointerii către funcţii).

Unele funcţiuni (cum ar fi accesul direct la memorie

folosind pointeri) au fost păstrate, dar secvenţele de cod

corespunzătoare se consideră ”nesigure”.

Windows Presentation Foundation

static void Main(string[] args)

{

Console.WriteLine("Versiune sistem de operare: " + Environment.OSVersion);

Console.WriteLine("Service Pack:" + Environment.OSVersion.ServicePack);

Console.WriteLine("Versiune CLR: " + Environment.Version);

Console.WriteLine("Sistemul de operare este pe 64 de biti: " +

Environment.Is64BitOperatingSystem);

Console.WriteLine("Utilizator: " + Environment.UserName);

Console.WriteLine("Computer: " + Environment.MachineName);

Console.WriteLine("Sistemul este instalat in: " + Environment.SystemDirectory);

Console.ReadLine();

}

WPF Application exemplu

Console Application exemplu

Windows Forms Application exemplu




Crearea aplicaţiilor consolă

Structura unui program C#

O aplicaţie C# este formată din una sau

mai multe clase, grupate în spaţii de

nume (namespace). Este obligatoriu ca

doar una din aceste clase să conţină un

„punct de intrare” (entry point), şi

anume metoda (funcţia) Main.

Primele patru linii reprezintă directive

care specifică faptul că se vor folosi

clase incluse în spaţiul de nume

System. În exemplul nostru se va folosi

clasa Console folosită pentru operaţiile

de intrare/ieşire şi se apelează metoda

WriteLine din această clasă, pentru

afişarea mesajului dorit pe ecran. Orice

program C# este alcătuit din una sau

mai multe clase.

Spaţiul nostru de nume

Structura unui program C#

Spaţiu de nume

Clasă

Metodă

Cod

În C#, un program poate fi

privit ca având mai multe „straturi”:

avem cod în interiorul metodelor,

care la rândul lor se află în

interiorul claselor, aflate în interiorul

namespaces-urilor.

O clasă este formatã din date şi

metode (funcţii).

Apelarea unei metode în cadrul clasei în care a fost definitã

aceasta presupune specificarea numelui metodei. Apelul unei

metode definite în interiorul unei clase poate fi invocată şi din

interiorul altei clase, caz în care este necesară specificarea clasei şi

apoi a metodei separate prin punct. Dacă în plus, clasa aparţine

unui spaţiu de nume neinclus în fişierul curent, atunci este necesară

precizarea tuturor componentelor numelui: spaţiu.clasã.metodã

sau spaţiu.spaţiu.clasã.metodã etc.

Fereastra Solution Explorer

Când creaţi o aplicaţie consolă se generează un fişier cu

extensia .cs. Redenumirea lui se poate realiza din fereastra Solution Explorer pe care o puteţi afişa cu ajutorul combinaţiei de taste Ctrl+W sau din meniul View.

Sintaxa limbajului - Nume

Prin nume dat unei variabile, clase, metode etc. înţelegem o

succesiune de caractere care îndeplineşte următoarele reguli:

numele trebuie să înceapă cu o literă sau cu unul dintre

caracterele ”_” şi ”@”;

primul caracter poate fi urmat numai de litere, cifre sau un caracter

de subliniere;

numele care reprezintă cuvinte cheie nu poate fi folosit în alt scop

decât acela pentru care a fost definit;

cuvintele cheie pot fi folosite în alt scop numai dacă sunt precedate

de @

două nume sunt distincte dacă diferă prin cel puţin un caracter.

Sintaxa limbajului - Cuvinte cheie în C#

Cuvintele cheie sunt identificatori predefiniţi cu semnificaţie specială pentru compilator. În general, aceste cuvinte nu pot fi folosite în programele pe care le scriem cu o altă semnificaţie. În cazul în care, totuşi, dorim să le dăm o altă semnificaţie va trebui să le scriem cu simbolul „@” ca prefix.

abstract as base bool break

byte case catch char checked

class const continue decimal default delegate do double else enum

event explicit extern false finally

fixed float for foreach goto

if implicit in int interface

internal is lock long namespace

new null object operator out override params private protected public

readonly ref return sbyte sealed

short sizeof stackalloc static string

struct switch this throw true

try typeof uint ulong unchecked

unsafe ushort using virtual void

volatile while

Sintaxa limbajului - Constante

În C# există două modalităţi de declarare a constantelor:

folosind const sau folosind modificatorul readonly. Constantele

declarate cu const trebuie să fie iniţializate la declararea lor.

Exemple:

const int pr_v1=3;

readonly int x;

Sintaxa limbajului - Expresii şi operatori

Prin expresie se înţelege o secvenţă formată din operatori şi

operanzi. Un operator este un simbol ce indică acţiunea care se

efectuează, iar operandul este valoarea asupra căreia se execută

operaţia. Tabelul de priorităţi:

Prioritate Tip Operatori Asociativitate

0 Primar ( ) [ ] f() . x++ x-- new typeof sizeof checked unchecked ->

→

1 Unar + - ! ~ ++x --x (tip) true false & sizeof

→

2 Multiplicativ * / % →

3 Aditiv + - →

4 De deplasare << >> →

5 Relaţional < > <= >= is as →

6 De egalitate == != →

7 AND (SI) logic & →

8 XOR (SAU exclusiv) logic

^ →

9 OR (SAU) logic | →

10 AND (SI) condiţional && →

11 OR (SAU) condiţional || →

12 Condiţional(ternar) ?: ←

13 De atribuire = *= /= %= += -= ^= &= <<= >>= |=

←

Sintaxa limbajului – Exemplu

Sintaxa limbajului – Opţiuni de afişare

Pentru a avea control asupra modului de afişare a informaţiei

numerice se poate folosi următoarea formă a lui WriteLine():

WriteLine(" sir",var1,var2,…, varn); unde " sir" este format din două

elemente:

caracterele afişabile obişnuite conţinute în mesaje;

specificatorii de format ce au forma generală {nr_var, width:fmt}

unde nr_var precizează numărul variabilei (parametrului) care

trebuie afişată începând cu 0, width stabileşte lăţimea câmpului de

afişare, iar fmt stabileşte formatul.

Exemplu:

Sintaxa limbajului – Opţiuni de afişare

Exemplu de afişare a unui număr cu trei zecimale

static void Main(string[] args) { System.Console.WriteLine(" valoarea const PI este {0:#.###}", Math.PI); }

Sintaxa limbajului – Conversii

În C# există două tipuri de conversii numerice:

implicite;

explicite.

Conversia implicită se efectuează (automat) doar dacă nu este afectată valoarea convertită.

Exemplu de efectuare a unei conversii implicite:

static void Main(string[] args) { byte a = 13; // byte intreg fara semn pe 8 biti byte b = 20; long c; //intreg cu semn pe 64 biti c = a + b; Console.WriteLine(c); Console.ReadLine(); }

Sintaxa limbajului – Conversii implicite

din în

sbyte short, int, long, float, double, decimal

byte short, ushort, int, uint, long, ulong, float, double, decimal

short int, long, float, double, decimal

ushort int, uint, long, ulong, float, double, decimal

int long, float, double, decimal

uint long, ulong, float, double, decimal

long float, double, decimal

char ushort, int, uint, long, ulong, float, double, decimal

float double

ulong float, double, decimal

Sintaxa limbajului – Conversii explicite

din în

sbyte byte, ushort, uint, ulong, char

byte sbyte, char

short sbyte, byte, ushort, uint, ulong, char

ushort sbyte, byte, short, char

int sbyte, byte, short, ushort, uint, ulong, char

uint sbyte,byte, short, ushort, int, char

long sbyte, byte, short, ushort, int, uint, ulong, char

ulong sbyte, byte, short, ushort, int, uint, long, char

char sbyte, byte, short

float sbyte, byte, short, ushort, int, uint, long, ulong, char, decimal

double sbyte, byte, short, ushort, int, uint, long, ulong, char, float, decimal

decimal sbyte, byte, short, ushort, int, uint, long, ulong, char, float, double

Sintaxa limbajului – Conversia din tipul numeric în şir de

caractere şi invers

static void Main(string[] args) { int i = 13; string j = i.ToString(); Console.WriteLine(j); string s = "13"; int n = int.Parse(s); Console.WriteLine(n); }

Este o metodă virtuală

asociată unui tip de date

(override)

Sintaxa limbajului – Conversii boxing şi unboxing

Datorită faptului că în C# toate tipurile sunt derivate din clasa

Object (System.Object), prin conversiile boxing (împachetare) şi unboxing (despachetare) este permisă tratarea tipurilor valoare drept obiecte şi reciproc. Prin conversia boxing a unui tip valoare, care se păstrează pe stivă, se produce ambalarea în interiorul unei instanţe de tip referinţă, care se păstrează în memoria heap, la clasa Object. Unboxing permite conversia unui obiect în tipul valoare echivalent.

Exemplu: Prin boxing variabila i este asignată unui obiect ob:


{

int i = 13;

object ob = (object)i; //boxing explicit

}


{

int i = 13;

object ob = i; //boxing implicit

}

Sintaxa limbajului – Conversii între numere şi şiruri de caractere

Limbajul C# oferă posibilitatea efectuării de conversii între numere

şi şiruri de caractere.

Sintaxa pentru conversia număr în şir de caractere:

“ “ + număr

Pentru conversia inversă, adică din şir de caractere în număr,

sintaxa este:

şir int int.Parse(şir) sau Int32.Parse(şir)

şir long long.Parse(şir) sau Int64.Parse(şir)

şir double double.Parse(şir) sau Double.Parse(şir)

şir float float.Parse(şir) sau Float.Parse(şir)

Sintaxa limbajului – Conversii între numere şi şiruri de

caractere

Exemple de conversii: static void Main(string[] args) { string s; const int a = 13; const long b = 100000; const float c = 2.15F; double d = 3.1415; s = "" + a; Console.WriteLine("a={0} s={1}", a, s); s = "" + b; Console.WriteLine("b={0} s={1}", b, s); s = "" + c; Console.WriteLine("c={0} s={1}", c, s); s = "" + d; Console.WriteLine("d={0} s={1}", d, s); int a1=int.Parse("13"); Console.WriteLine("{0}\t{1}\tint", "13", a1); long b2=long.Parse("1000"); Console.WriteLine("{0}\t{1} \tlong", "1000", b2); float c2=float.Parse("2,15"); Console.WriteLine("{0}\t{1} \tfloat", "2,15", c2); double d2=double.Parse("3.1415"); Console.WriteLine("{0}\t{1}\tdouble", "3.1415", d2); Console.ReadKey(); }

Sintaxa limbajului – Tipuri de date

În C# există două categorii de tipuri de date:

tipuri valoare

tipul simple: byte, char, int, float etc.

tipul enumerare - enum

tipul structură – struct

tipuri referinţă

tipul clasă - class

tipul interfaţă - interface

tipul delegat - delegate

tipul tablou - array

Toate tipurile de date sunt derivate din clasa System.Object.

Toate tipurile valoare sunt derivate din clasa System.ValueType, derivată la rândul ei din clasa Object (alias pentru System.Object).

Limbajul C# conţine un set de tipuri predefinite (int, bool etc.) şi permite definirea unor tipuri proprii (enum, struct, class etc.).


Tip Descriere Alias pentru tipul

struct din spaţiul de

nume System

object rădăcina oricărui tip

string secvenţă de caractere Unicode System.String

sbyte tip întreg cu semn, pe 8 biţi System.Sbyte

short tip întreg cu semn, pe 16 biţi System.Int16

int tip întreg cu semn pe, 32 biţi System.Int32

long tip întreg cu semn, pe 64 de biţi System.Int64

byte tip întreg fără semn, pe 8 biţi System.Byte

ushort tip întreg fără semn, pe 16 biţi System.Int16

uint tip întreg fără semn, pe 32 biţi System.Uint32

ulong tip întreg fără semn, pe 64 biţi System.Uint64

float tip cu virgulă mobilă, simplă precizie,

pe 32 biţi (8 pentru exponent, 24

pentru mantisă)

System.Single

double tip cu virgulă mobilă, dublă precizie,

pe 64 biţi (11 pentru exponent, 53

pentru mantisă)

System.Double

bool tip boolean System.Boolean

char tip caracter din setul Unicode, pe 16

biţi

System.Char

decimal tip zecimal, pe 128 biţi (96 pentru

mantisă), 28 de cifre semnificative

System.Decimal

Domeniul de valori pentru tipurile numerice:


Tip Domeniul de valori

sbyte -128; 127

short -32768; 32767

int -2147483648; 21447483647

long -9223372036854775808; 9223372036854775807

byte 0; 255

ushort 0; 65535

uint 0; 4294967295

ulong 0; 18446744073709551615

float -3.402823E+38; 3.402823E+38

double -1.79769313486232E+308; 1.79769313486232E+308

decimal -79228162514264337593543950335;

79228162514264337593543950335

O valoare se asignează după următoarele reguli:


Sufix Tip

nu are int, uint, long, ulong

u, U uint, ulong

L, L long, ulong

ul, lu, Ul, lU, UL, LU, Lu ulong

Exemplu: float g = 1.234F; double h = 1.234; long b = 13L; double i = 1.234D; ulong c = 12; bool cond1 = true; ulong d = 15U; bool cond2 = false; ulong e = 16L; decimal j = 1.234M; ulong f = 17UL;

Tipul enumerare asemănător cu cel din C++, se defineşte de către

utilizator. Acest tip permite utilizarea numelor care, sunt asociate unor valori

numerice. Orice enum este derivat automat din clasa System.Enum,

derivată din System.ValueType.

În cazul în care nu se specifică tipul enumerării acesta este considerat

implicit int.

[atribute][modificatori]enum NumeEnumerare [: Tip]

{

lista

}

Folosirea tipului enumerare impune următoarele observaţii:

în mod implicit valoarea primului membru al enumerării este 0, iar fiecare

variabilă care urmează are valoarea (implicită) mai mare cu o unitate decât

precedenta;

valorile folosite pentru iniţializări trebuie să facă parte din domeniul de

valori al tipului enum;

nu se admit referinţe circulare.


Exemplu pentru tipul enum: enum lunaAnului { Ianuarie = 1, Februarie, Martie, Aprilie, Mai, Iunie, Iulie, August, Septembrie, Octombrie, Noiembrie, Decembrie } static void Main(string[] args) { Console.WriteLine("Luna Mai este a {0}", (int)lunaAnului.Mai + " luna din

an."); Console.ReadLine(); }


Instrucţiunea if are sintaxa:

if (conditie) Instructiuni_A;

else Instructiuni_B;

Exemplu: static void Main(string[] args)

{

int n;

n = Convert.ToInt32(Console.ReadLine());

if (n >= 0) Console.WriteLine("Nr.introdus este > 0");

else Console.WriteLine("Nr.introdus este < 0");

Console.ReadLine();

}

Sintaxa limbajului – Instrucţiuni condiţionale,

de iteraţie şi de control

Aplicaţie:

Sintaxa limbajului – Instrucţiuni condiţionale, de iteraţie

şi de control

static void Main()

{

double x1, y1, x2, y2, x3, y3;

x1 = Convert.ToDouble(System.Console.ReadLine());

y1 = Convert.ToDouble(System.Console.ReadLine());





double E = (x2 - x1) * (y3 - y1) - (x3 - x1) * (y2 - y1);

if (E == 0) System.Console.WriteLine("puncte coliniare");

else System.Console.WriteLine("puncte necoliniare"); }

Instrucţiunea while are sintaxa:

while (condiţie) Instrucţiuni;



Aplicaţii:

1. Determinaţi câte cifre pare are un număr natural introdus de

la consolă?

2. Înlocuiţi cifrele pare ale unui număr natural introdus de la

consolă cu cifra impară imediat următoare. Numărul astfel

obţinut va fi afişat tot la consolă.

Instrucţiunea do – while are

sintaxa:

do

Instrucţiuni;

while(condiţie);

Instrucţiunea for are sintaxa:

for(iniţializareCiclu; condiţieFinal; pas)

Instrucţiuni;



Programul următor verifică dacă un număr citit de la tastatură este

sau nu prim.

static void Main(string[] args) { int a, i; a = Convert.ToInt32(System.Console.ReadLine()); bool ok = true; for (i = 2; (i <= a / 2 && ok); i++) if (a % i == 0) ok = false; if (ok) System.Console.WriteLine("este prim"); else System.Console.WriteLine("nu este prim"); }

În cazul instrucţiunii switch în C/C++, dacă la finalul instrucţiunilor

dintr-o ramură case nu există break, se trece la următorul case.

În C# se semnalează eroare. Există şi aici posibilitatea de a face

verificări multiple (în sensul de a trece la verificarea următoarei condiţii

din case) doar dacă case-ul nu conţine instrucţiuni.

Instrucţiunea switch admite în C# variabilă de tip şir de caractere care

să fie comparată cu şirurile de caractere din case-uri.



Aplicaţie: Programul următor afişează ultima cifră a numărului 2n,

unde n este introdus de la consolă. static void Main(string[] args)

{

int n, k;

n = Convert.ToInt32(System.Console.ReadLine());

if (n == 0) System.Console.WriteLine("ultima cifra este 1");

else

{

k = n % 4;

switch (k)

{

case 1: System.Console.WriteLine("ultima cifra este 2"); break;




}

}

}



O instrucţiune nouă, pe care o aduce limbajul C#, este

foreach. Această instrucţiune enumeră elementele dintr-o colecţie,

executând o instrucţiune pentru fiecare element. Elementul care se

extrage este de tip read-only, nu poate fi transmis ca parametru şi

nici nu îşi poate schimba valoarea.

Exemplu:

string s="Curs"+" de"+" informatica";

foreach (char c in s) Console.Write(c);



Exemplu de utilizare a instrucţiunii foreach:

Considerăm un vector nume format din şiruri de caractere:

string[] nume = {"Ana", "Ionel", "Maria"}

Să afişăm acest şir folosind instrucţiunea for:

for(int i=0; i<nume.Length; i++)

{

Console.WriteLine("{0} ", nume[i]);

}

Acelaşi rezultat îl obţinem folosind instrucţiunea foreach:

foreach (string copil in nume)

{

Console.WriteLine("{0} ", copil); //Console.WriteLine(copil+" "); }



Exemplu:

Împărţirea unui şir de caractere în cuvinte. Se va afişa numărul de

cuvinte şi fiecare cuvânt în parte.

string sir = "Acesta este un sir";

char[] delimitator ={' ',',','.',':'};

Console.WriteLine("Sirul care va fi impartit in cuvinte \n‘{0}’", sir);

string[] cuvant = sir.Split(delimitator);

Console.WriteLine("Sunt {0} cuvinte in text:", cuvant.Length);

foreach (string s in cuvant)

{

Console.WriteLine(s);

}



Instrucţiunea continue permite reluarea iteraţiei celei mai apropiate instrucţiuni switch, while, do – while, for sau foreach.

Exemplu: int i = 0;

while (true)

{

Console.Write("{0} ", i);

i++;

if (i < 10) continue;

else break;

}

Console.ReadLine();



Instrucţiunile try-catch-finally şi throw

Prin excepţie se înţelege un obiect care încapsulează informaţii despre situaţii anormale. Ea se foloseşte pentru a semnala contextul în care apare o situaţie specială. Exemple: erori la deschiderea unor fişiere a căror nume este greşit, împărţire la 0 etc. Aceste erori se pot manipula astfel încât programul să nu se prăbuşească.

Când o metodă întâlneşte o situaţie dintre cele menţionate mai sus, se va „arunca” o excepţie care trebuie sesizată şi tratată.

C# poate arunca ca excepţii obiecte de tip System.Excepţion sau derivate ale acestuia. Aruncarea excepţiilor se face cu instrucţiunea throw

throw new System.Exception();

Prinderea şi tratarea excepţiilor se face folosind un bloc catch. Pot exista mai multe blocuri catch, fiecare dintre ele prinde şi tratează o excepţie.

Pentru a garanta că un anumit cod se va executa indiferent dacă totul decurge normal sau apare o excepţie, acest cod se va pune în blocul finally care se va executa în orice situaţie.

Sintaxa limbajului – Instrucţiuni condiţionale, de iteraţie

şi de control

Exemple: try { File.OpenRead("NuExistaFisierul"); } catch (FileNotFoundException a) { Console.WriteLine(a.ToString()); } catch (PathTooLongException b) { Console.WriteLine(b.ToString()); } finally { Console.WriteLine("Acest bloc se executa"); Console.ReadLine(); }



int a, b, c=0;

a = Convert.ToInt32(Console.ReadLine());

b = Convert.ToInt32(Console.ReadLine());

try

{

c = a / b;

}

catch (DivideByZeroException e)

{

Console.WriteLine("Exception: {0}", e);

}

finally

{

Console.WriteLine(c);

}

Console.ReadKey();

double N;

try

{

N = Convert.ToDouble(textBox1.Text);

label1.Text = Convert.ToString(Math.Sqrt(N));

}

catch(FormatException ex)

{

MessageBox.Show(ex.Message);

}

• int Op1 = 0, Op2 = 0,S = 0; • try • { • Op1 = Convert.ToInt32(op1.Text); • } • catch (FormatException) • { • MessageBox.Show("Valoare gresita"); • } • • try • { • Op2 = Convert.ToInt32(op2.Text); • } • catch (FormatException) • { • MessageBox.Show("Valoare gresita"); • } • • try • { • S = Convert.ToInt32(suma.Text); • } • catch (FormatException) • { • MessageBox.Show("Valoare gresita"); • }

double Op1, Op2,Rezultat = 0.00; string Operator; try { Op1 = double.Parse(textBox1.Text); Operator = textBox2.Text; Op2 = double.Parse(textBox3.Text); if (Operator != "+" && Operator != "-" && Operator != "*" && Operator != "/") throw new Exception(Operator); switch (Operator) { case "+": Rezultat = Op1 + Op2; break; case "-": Rezultat = Op1 - Op2; break; case "*": Rezultat = Op1 * Op2; break; case "/": Rezultat = Op1 / Op2; break; default: MessageBox.Show("Operatie gresita"); catch (FormatException) { MessageBox.Show("Numar gresit"); } catch (Exception ex) { MessageBox.Show("Operatorul " + ex.Message + " nu este acceptat"); } }

Limbajul C# tratează tablourile într-o manieră nouă faţă de alte limbaje (Pascal, C/C++). La declararea unui tablou, se creează o instanţă a clasei .NET, System.Array. Compilatorul va traduce operaţiile asupra tablourilor, apelând metode ale clasei System.Array.

Declararea unui tablou unidimensional se realizează astfel:

Tip[] nume;

Prin această declarare nu se alocă şi spaţiu pentru memorare. Pentru aceasta tabloul trebuie instanţiat:

nume = new Tip[NumarElemente];

Se pot face în acelaşi timp operaţiile de declarare, instanţiere şi iniţializare:

int[] v = new int[] {1,2,3};

sau

int[] v = {1,2,3};

Sintaxa limbajului – Tablouri

În cazul tablourilor cu mai multe dimensiuni facem distincţie între

tablouri regulate şi tablouri neregulate (tablouri de tablouri).

Declararea în cazul tablourilor regulate se face astfel:

Tip[,] nume;

iar instanţierea:

nume = new Tip[Linii,Coloane];

Declararea instanţierea şi iniţializarea

int[,] mat = new int[,] {{1,2,3},{4,5,6},{7,8,9}};

sau

int[,] mat = {{1,2,3},{4,5,6},{7,8,9}};


În cazul tablourilor neregulate (jagged array) declararea se face:

Tip [][] nume; //tablou neregulat cu doua dimensiuni iar instanţierea şi iniţializarea:

Tip [][] nume = new Tip[][] { new Tip[] {sir_0}, new Tip[] {sir_1}, ... new Tip[] {sir_n} }; sau Tip [][] nume = { new Tip[] {sir_0}, new Tip[] {sir_1}, ... new Tip[] {sir_n} };


Moduri de creare a unui array: // Tablou unidimensional

int[] v = new int[5] { 10, 2, 4, 8, 6 };

Array.Sort(v); //sortam crescator vectorul v

for (int i = 0; i < v.Length; i++)

Console.Write(v[i]+" ");

//sau

foreach (int x in v)

Console.Write(x.ToString()+" ");

// Tablou bidimensional

double[,] a = new double[5, 4];

for( int i = 0; i < 3; i++)

for(int j = 0; j < 4; j++)

a[i,j] = (i*3)+j+1;


// Tablou de tablouri (jagged array)

byte[][] b = new byte[5][];

// Creare tablou neregulat (jagged array)

for (int i = 0; i < b.Length; i++)

{

b[i] = new byte[i + 3];

}

// Tiparim lungimea fiecarei linii

for (int i = 0; i < b.Length; i++)

Console.WriteLine("Lngimea liniei {0} este {1}", i, b[i].Length);


Exemplu:

Citirea şi afişarea elementelor unui tablou

int[] v = new int[10];

int i, n;

n = Convert.ToInt32(System.Console.ReadLine());

for (i = 0; i < n; i++)

v[i] = Convert.ToInt32(System.Console.ReadLine());

for (i = 0; i < n; i++)

System.Console.WriteLine(v[i]);


Exemplu:

Afişează numărul de elemente de pe a doua linie a tabloului şi

numărul total de linii.

int[,] tab = { { 1, 2, 3 }, { 4, 5, 6 } };

//Reamintim ca prima linie are numarul de ordine 0

Console.WriteLine(tab.GetLength(1));

// Afisarea numarului de linii a tabloului tab

Console.WriteLine(tab.Rank);


În cazul tablourilor cu mai multe dimensiuni facem distincţie între tablouri regulate şi tablouri neregulate (tablouri de tablouri)

Declarare în cazul tablourilor regulate bidimensionale:

Tip[,] nume;

Instanţiere:

nume = new Tip[Linii,Coloane];

Acces:

nume[indice1,indice2]

Exemple:

int[,] mat = new int[,] {{1,2,3},{4,5,6},{7,8,9}}; sau

int[,] mat = {{1,2,3},{4,5,6},{7,8,9}}; sau

int[,] mat = new int[10,20];


Declarare în cazul tablourilor neregulate bidimensionale:

Tip[][] nume;

Instanţiere: nume = new Tip[Linii],[]; nume[0]=new Tip[Coloane1] ... nume[Linii-1]=new Tip[ColoaneLinii-1]

Acces: nume[indice1][indice2]

Exemple: int[][] mat = new int[][] { new int[3] {1,2,3}, new int[2] {4,5}, new int[4] {7,8,9,1} }; sau int[][] mat={new int[3] {1,2,3},new int[2] {4,5},new int[4] {7,8,9,1}};


Vectorii 3-D sunt utilizaţi frecvent în aplicaţiile grafice.

Exemple:

int[,,] vect=new int[2,3,5];

sau

int [,,] vect=new int[6,2,4,8];


Se definesc două tipuri de şiruri:

regulate;

de tip „verbatim”.

Tipul regulat conţine între

ghilimele zero sau mai multe

caractere, inclusiv secvenţe

escape.

Secvenţele escape permit

reprezentarea caracterelor care

nu au reprezentare grafică

precum şi reprezentarea unor

caractere speciale: backslash,

caracterul apostrof, etc.

Sintaxa limbajului – Şiruri de caractere

Secvenţă

escape

Efect

\’ apostrof

\” ghilimele

\\ backslash

\0 null

\a alarmă

\b backspace

\f form feed – pagină nouă

\n new line – linie nouă

\r carriage return – început

de rând

\t horizontal tab – tab

orizontal

\u caracter unicode

\v vertical tab – tab vertical

\x caracter hexazecimal

În cazul în care folosim multe secvenţe escape, putem utiliza şirurile

verbatim. Aceste şiruri pot să conţină orice fel de caractere, inclusiv

caracterul EOLN. Ele se folosesc în special în cazul în care dorim să

facem referiri la fişiere şi la regiştri. Un astfel de şir începe

întotdeauna cu simbolul ’@’ înaintea ghilimelelor de început.

string a = "un sir de caractere";

string b = "linia unu \nlinia doi";

string c = @"linia unu

linia doi";

string d = "c:\\exemple\\unu.cs";

string e = @"c:\exemple\unu.cs";

Console.WriteLine(a); Console.WriteLine(b);

Console.WriteLine(c); Console.WriteLine(d);

Console.WriteLine(e); Console.ReadLine();


Funcţii importante pentru şiruri


Numele funcţiei Descriere

CompareTo Compară valorile caracterelor individuale din două şiruri

Concat Copiază un şir la sfârşitul şirului curent

Equals Returnează valoarea true dacă două şiruri conţin aceleaşi

caractere

Insert Inserează un şir în şirul curent

Remove Şterge caracterele specificate dintr-un şir

Substring Returnează o parte din şirul curent

ToLower Întoarce o copie a şirului, scrisă cu litere mici

ToUper Întoarce o copie a şirului, scrisă cu litere mari

Funcţia Substring foloseşte doi parametri, primul indică poziţia din şir de unde începe extragerea subşirului, iar al doilea câte caractere extrage.

string a, b = "Functii importante pentru siruri"; a = b.Substring(8, 10); System.Console.WriteLine("a={0}", a); a = a.ToUpper(); System.Console.WriteLine("a={0}", a); Funcţia ToUpper transformă caracterul în majusculă.

Completând în continuare funcţia main cu următoarea linie de program, veţi avea posibilitatea de a observa cum se apelează şi cum lucrează funcţia Equals.

if (Equals(a, b)) System.Console.WriteLine("sunt egale"); else System.Console.WriteLine("nu sunt egale");


Un string este o clasă în C# . Variabilele clase din C# sunt tratate ca tipuri simple.

Astfel transmiterea valorii lor ca parametri nu diferă cu nimic faţă de ceea ce ştiaţi de la datele simple de până acum.

Se observă din listingul de mai jos că o funcţie poate returna un string la fel cum returnează orice tip de dată simplă.


{

string a = "prima valoare";

schimb1(a);

a = schimb2();

System.Console.WriteLine(a);

}

static void schimb1(string b)

{

System.Console.Write("am preluat "); System.Console.WriteLine(b);

b = " a doua valoare"; System.Console.WriteLine(b);

}

static string schimb2()

{

return (" ultima valoare");}


Compararea şirurilor de caractere

Pentru a compara două şiruri de caractere vom utiliza operatorii “==” şi

“!=”.

Definiţie: două şiruri se consideră egale dacă sunt amândouă null, sau

dacă amândouă au aceeaşi lungime şi pe fiecare poziţie au caractere

respectiv identice. În caz contrar şirurile se consideră diferite.

Pentru a compara două şiruri, unul dintre ele poate fi convertit la object.


Exemplu

string a = "Informatica", b = (string)a.Clone(); Console.WriteLine("a==b: {0}", a == b); Console.WriteLine("(object)a==b:{0}",(object)a == b);

Concatenarea şirurilor Pentru a concatena şirurile vom folosi operatorul “+”: string a = "Invat" + " " + " informatica"; Inserare subşir în şir s1= "programarea este usoara";s2= "in C#"; Console.WriteLine(s1.Insert(12, s2)); Căutare/înlocuire subşir s1 = "programarea in C# este usoara"; s2 = s1.Replace("C#", "Pascal");

Console.WriteLine(s2); Copiere şir s1= "string“; s2 = string.Copy(s1); Console.WriteLine(s2); Extragere subşir s1 = "Stringurile din C# ofera facilitati puternice"; s2 = s1.Substring(16); Console.WriteLine(s2); Eliminare spaţii început /sfârşit s1= " fara spatii de inceput si sfarsit " ; s2= s1.Trim(); Console.WriteLine(s2); Ştergere subşir s1 = "Stringurile din C# ofera facilitati puternice"; s2= s1.Remove(12,7); Console.WriteLine(s2);


Alte funcţii care permit prelucrarea şirurilor de caractere


Funcţia Descrierea

string ToUpper() converteşte toate caracterele şirului la

majuscule

string ToLower() converteşte toate caracterele şirului la

minuscule

int IndexOf(int c) returnează indicele primei apariţii a

caracterului c în şir

int IndexOf(string s) returnează indicele primei apariţii a

subşirului s

string Concat(string u, string v) concatenează şirurile u şi v

string Substring(int index) returnează un nou şir care este un subşir

al şirului inţial începând cu indicele index

string (char[] c) împarte un şir în funcţie de delimitatorii c

Administrarea fişierelor

Tehnica de citire şi scriere a datelor în şi din fişiere, utilizată pentru a

păstra aceste informaţii, reprezintă administrarea fişierelor.

Pentru accesarea unui fişier de pe disc se folosesc funcţii din spaţiul

de nume System.IO.

În acest spaţiu există mai multe clase: File, StreamWriter,

BinaryReader şi BinaryWriter.

Aceste clase sunt folosite pentru operaţiile de intrare-ieşire cu fişiere.

Obiectul File este o reprezentare a unui fişier de pe disc, iar pentru

a-l utiliza trebuie să îl conectăm la un flux (stream).

Pentru a scrie datele pe disc, se ataşează unui flux un obiect File.

Astfel se face administrarea datelor.

Limbajul C# oferă două tipuri de fişiere: fişiere text (stochează text) şi

fişiere binare (stochează date în format binar valid).

Sintaxa limbajului – Stocarea informaţiilor în fişiere

Scierea şi citirea datelor din fişiere text

Fişierele de intrare necesită utilizarea unui obiect StreamReader.

Fişierele de ieşire necesită utilizarea unui obiect StreamWriter.

Funcţia OpenText(), ce face parte din clasa File, deschide un fişier

şi creează obiectul StreamReader.

Funcţia CreateText(), ce face parte din clasa File, deschide un fişier

şi creează obiectul StreamWriter.


Exemplu string[] a = { "primul", " fisier", " creat ", "de mine", }; //deschiderea unui fisier si atasarea lui la un flux StreamWriter outputFile = File.CreateText("iesire.txt"); foreach (string b in a) { outputFile.WriteLine(b);//scrierea textului in fisier } outputFile.Close(); //deschidem din nou fisierul de data aceasta pentru a citi din el StreamReader inputFile = File.OpenText("iesire.txt"); //definim o variabila string care va parcurge fisierul pana la final string x; while ((x = inputFile.ReadLine()) != null) { System.Console.Write(x); } inputFile.Close(); Console.ReadKey();


Scrierea şi citirea datelor din fişiere binare

Fişierele binare pot conţine orice număr binar valid. Datele majorităţii

programelor sunt stocate în acest format binar.

Dacă la fişierele text tipul de flux folosit era StreamWriter, la cele

binare, pentru scrierea datelor programul creează un obiect

FileStream, la care trebuie ataşat şi un obiect BinaryWriter.


Exemplu: int i, j;int[,] a = new int[10, 10];

//se creeaza un fisier si un flux

FileStream f = new FileStream("dana2.dat", FileMode.CreateNew);

// se creeaza un scriitor binar si il ataseaza la flux

//acesta traduce datele fluxului in format binar

BinaryWriter outputFile = new BinaryWriter(f);

for (i = 1; i <= 4; i++)

for (j = 1; j <= 4; j++)

if (i == j) a[i, j] = 1;

else if (j == 5 - i) a[i, j] = 2;

else a[i, j] = 0;

for (i = 1; i <= 4; i++)

for (j = 1; j <= 4; j++)

outputFile.Write(a[i, j]);

//se inchide fisierul creat

outputFile.Close();

f.Close();


//incepe citirea datelor din fisierul creat anterior

//se creeaza un obiect FileStream

FileStream g = new FileStream("dana2.dat", FileMode.Open);

//se creeaza un obiect BinaryReader

BinaryReader f = new BinaryReader(g);

bool final;

for (final = false, i = 1; !final; i++)

{

for (final = false, j = 1; !final; j++)

{//se apeleaza functia PeekChar care face parte din clasa BinaryReader si examineaza urmatorul

// caracter din flux, daca acesta este diferit de -1 atunci se executa citirea urmatorului caracter

// din flux prin functia ReadInt32()

if (f.PeekChar() != -1)

{

x = f.ReadInt32(); System.Console.Write(x+” “);

}

}

System.Console.Write("\n");

}

f.Close();

g.Close();


• http://blog.zeltera.eu/?page_id=2183

Aplicaţii C++/C#

• http://blog.zeltera.eu/?page_id=1025

Tutorial C# (.NET)

• http://blog.zeltera.eu/?cat=64

Tips

http://blog.zeltera.eu/?page_id=2183







.NET Frameworkadiftene/C_SHARP/Ziua01/1.02... · 2014-02-01 · Elemente cheie ale platformei .NET...

Documents

Transcript of .NET Frameworkadiftene/C_SHARP/Ziua01/1.02... · 2014-02-01 · Elemente cheie ale platformei .NET...