Exista numeroase modalitati de a controla modul de prezentare a
datelor si interactiunea dintre sistem si utilizator.Dintre acestea,cele
mai simple sunt: Consola si Fereastra Windows.Consola este o fereasta
de tip Windows,dotata cu minimum de metode pentru functii de intrare/
iesire (I/O).Consola este definita in System,sub forma de obiect separat.
Este util sa studiati proprietatile si metodele acestui obiect.
EXEMPLU:
using System;
class Date1 {
public static void Main() {
Console.BackgroundColor = ConsoleColor.Yellow;
Console.ForegroundColor = ConsoleColor.Blue;
Console.WriteLine("Introduceti numele: ");
String name = Console.ReadLine();
Console.WriteLine("Hello, {0}! ",name);
Console.ReadLine();
}}
Salvati fila cu numele Consola1.cs si compilati.
Datele pot fi afisate si intr-o fereastra System.Windows.Forms.
EXEMPLU:
using System;
using System.Drawing;
using System.Windows.Forms;
public class MyForm : System.Windows.Forms.Form {
public MyForm(){}
protected override void OnPaint(PaintEventArgs ev1)
{
Graphics text1 = ev1.Graphics;
Brush creion = new SolidBrush(Color.Blue);
text1.DrawString("Textul dorit:",Font,creion,0,0);
}
static void main() { Application.Run(new MyForm()); }
}
Salvati fila cu numele Exemplu1.cs si compilati.Acest exemplu poate fi
compilat si cu: csc /target:winexe Exemplu1.cs (pt un executabil Windows).
-15-
Exista numeroase alte solutii pentru a exploata datele procesate in
program.Exemple: fluxul de iesire poate fi salvat intr-o fila auxiliara,
intr-un tabel sau intr-o baza de date,poate fi expediat prin e-mail,sau
poate fi arhivat intr-un tampon temporar de memorie,poate fi expediat la
o adresa de Internet sau spre un telefon mobil...etc.Totusi,cele mai
multe aplicatii,afiseaza datele in Consola,sau intr-o fereastra Windows.
Compilatorul C# verifica extrem de sever formatul datelor si domeniul
de reprezentare.Din acest motiv,se spune despre C# ca este un limbaj
puternic tipizat.Spre deosebire de Delphi sau PHP,limbajul C# nu contine
nici un tip de data "variabila" si nu executa nici un fel de conversii
automate.Din acest motiv,tipul de data trebuie ales cu mare atentie,
inainte de a incepe codificarea.Exista si conversii naturale,ce se pot
executa direct.Exemplu: valorile de tip "int" pot fi convertitie la tipul
"long" fara riscul de a pierde date.In schimb,daca se face conversia
inversa: din "long" in "int",exista riscul de a pierde toate datele ce
depasesc domeniul de reprezentare "int".
EXEMPLU: long 2147483649 devine int -1 (deoarece int max= 2147483648)
Pentru majoritatea conversiilor se poate utiliza obiectul Convert.
EXEMPLU:
using System;
class Date1 {
public static void Main() {
Console.BackgroundColor = ConsoleColor.Yellow;
Console.ForegroundColor = ConsoleColor.Blue;
Console.WriteLine("Introduceti primul numar: ");
double nr1 = System.Convert.ToDouble(Console.ReadLine());
Console WriteLine("Introduceti al doilea numar: ");
double nr2 = System.Convert.ToDouble(Console.ReadLine());
double nr3 = nr1*nr2;
Console.ForegroundColor = ConsoleColor.Red;
Console.WriteLine("Rezultatul este: {0:N}!",nr);
Console.ReadLine();
}}
Salvati fila cu numele Consola2.cs si compilati.
In exemplul de mai sus,se face pur si simplu inmultirea dintre doua
numere.Valorile introduse de la tastatura cu Console.ReadLine() se citesc
intr-un stream de tip string.Prin urmare,trebuie sa fie convertite la
un tip numeric,inainte de a executa orice fel de operatie aritmetica.
Deoarece nu se poate prevedea ce valori doreste utilizatorul,se va prefera
tipul double,pentru a acoperii prectic intregul domeniu de valori
reprezentabile.Tipul de data se poate alege in functie de utilitatea
programului.De exemplu,intr-o situatie concreta,in care valorile din
program sunt mai mici de 250 si sunt strict de tip "integer",nu are
rost sa fie utilizat tipul "double" si se va utiliza tipul de data cel
mai adecvat,adica tipul "byte".In acest caz,tipul "byte" nu numai ca
ocupa mai putina memorie si se executa mai rapid,dar elimina automat
orice valoare mai mare decat domeniul de reprezentare.
Exemplu: pentru a tasta un numar de telefon,nu se vor utiliza decat
cifre de la 0 la 9.
-16-
Aceleasi solutii sunt necesare si pentru a prezenta datele intr-o
fereastra Windows.Fie ca se apeleaza la componente de tip Label,fie ca
se afiseaza datele cu DrawString(),valorile numerice trebuie sa fie
convertite initial la valori de tip "string".
EXEMPLU:
using System;
using System.Drawing;
using System.Windows.Forms;
public class MyForm : System.Windows.Forms.Form{
public MyForm() {}
protected override void OnPaint(PaintEventArgs ev1)
{
double nr1 = 3.141592;
double nr2 = 2.72;
double nr3 = nr1 * nr2;
string t2 = "3.141592 x 2.72 = ";
Graphics text1 = ev1.Graphics;
Brush creion = new SolidBrush(Color.Blue);
text1.DrawString(t2,Font,creion,0,0);
text1.DrawString(System.Convert.ToString(nr3),Font,creion,100,0);
}
static void Main(){ Application.Run(new MyForm());}
}
Salvati fila cu numele Exemplu2.cs si compilati.
Datorita faptului ca toate tipurile de data din C# sunt obiecte,se
spune despre C# ca ofera un sistem unificat de tipuri de data.Ca rezultat
direct,orice tip de data accepta metode mostenite de la tipul radacina
System Object.Astfel,toate tipurile de data pot fi convertite la tipul
string,cu ajutorul metodei ToString().
EXEMPLU: Console.WriteLine(3.ToString));
este perfect corecta si executabila,deoarece si valorile numerice
directe sunt tot obiecte derivate din System.Object.
Acest sistem are importanta si atunci cand se compara doua siruri,fie
ca valori de tip string,fie ca obiecte.
EXEMPLU:
using System;
class Test1 {
static void Main() {
string s = "Test";
string t = string.Copy(s);
Console.WriteLine(s==t);
Console.WriteLine((object)s == (object)t);
Console.ReadLine();
}}
Salvati fila cu numele Consola3.cs si compilati.
Sirul t a fost creat copiat prin clonarea sirului s.Daca se face o
comparatie a celor doua siruri,rezultatul este "true",dar daca se face
o comparatie a celor doua obiecte,rezultatul este "false",deoarece doua
obiecte sunt egale doat atunci cand sunt referinte ale aceluiasi obiect,
sau daca sunt nule (s si t sunt doua obiecte distincte).
-17-
Chiar daca sunt obiecte distincte,tipurile de data predefinite sunt
importate din biblioteca System si au vizibiliate globala.Daca se creaza
un obiect derivat dintr-un tip de data,procesul poarta numele de "boxing"
(impachetare) iar daca se creaza un tip numeric dintr-un astfel de obiect,
procesul poarta numele de "unboxing" (despachetare).
EXEMPLU: int i = 123;
object numar1 = i; // boxing
int x = (int) numar1; // unboxing
Impachetarea sau despachetarea unui tip numeric,are rost fie pentru
a izola datele intr-un anumit spatiu de vizibiliate,fie pentru a adauga
un set nou de metode,sau dimpotriva pentru a elimina un set de metode
supraincarcate.
EXEMPLU: daca se lucreaza cu o stiva de obiecte,este esential ca datele
numerice sa fie impachetate,inainte de a putea fi introduse in stiva.
Dintre tipurile referinta,se va exemplifica in acest capitol doar tipul
arie (restul sunt prezentate in capitole separate).Tipul arie este un tip
complex,extrem de util,ce poate inlocui cu succes tabelele si bazele de
date,atunci cand volumele de date sunt mici.Tot ariile se utilizeaza si
pentru a prelua segmente de date,din tabele si baze de date.Ariile pot
fi uni,bi sau multidimensionale.Pentru operatiile cu arii,C# utilizeaza
obiectul Array (vezi referinta).Una dintre avantajele majore oferite de
arii,este sortarea automata,in functie de indexul numeric,sau in functie
de un cod cheie,utilizat pentru organizarea ariei.
EXEMPLU:
using System;
using System.Collections;
public class ExempluArie {
public static void Main() {
String[] myKeys = { "Rosu","Verde","Galben","Albastru"};
String[] myValues = {"Capsuni","Pere","Lamai","Afine"};
Console.WriteLine("Aria initiala:");
Scrie(myKeys,myValues);
Array.Sort(myKeys,myValues);
Console.WriteLine("Dupa sortare: ");
Scrie(myKeys,myValues);
Console.ReadLine();
}
public static void Scrie( String[] myKeys,String[] myValues){
for (int i=0;i
Console.WriteLine(" {0,-20}:{1}",myKeys[i],myValues[i]);
}
Console.WriteLine();
}
}
Salvati fila cu numele Consola4.cs si compilati.
In exemplul de mai sus am creat doua arii cu elemente de tip string,
apoi am sortat elementele cu ajutorul cheii de indexare myKey.Pentru a
citi si edita elementele din arie,am definit metoda Scrie,in care fiecare
element din arie este citit si editat in ordinea de indexare dictata de
myKeys.Acest gen de operatii sunt extrem de utile,atunci cand aria contine
sute sau zeci de inregistrari,imposibil de evaluat direct.
-18-
O alta facilitate oferita de arii,este optiunea de a cauta rapid un
anumit obiect cu ajutorul metodei BinarySearch().
EXEMPLU:
using System;
public class ExempluArie {
public static void Main() {
Array a1 = Array.CreateInstance(typeof(Int32),5);
a1.SetValue(8,0);
a1.SetValue(2,1);
a1.SetValue(6,2);
a1.SetValue(3,3);
a1.SetValue(7,4);
Array.Sort(a1);
object.obj1 = 6;
Cauta(a1,obj1);
Console.ReadLine();
}
public static void Cauta(Array myArr,object obj2)
{ int ind1=Array.BinarySearch(myArr,obj2);
Console.WriteLine("Obiectul ({0}) este la index {1}.",ind1,obj2);
}
}
Salvati fila cu numele Consola5.cs si compilati.
In exemplul de mai sus,am creat o arie numerica formata din 5 elemente in
care numarul de indexare este de tip Int32.In acest mod,aria va putea fi
extinsa pana la peste 2 miliarde de inregistrari.Apoi am introdus primele
5 valori,impreuna cu cheia lor de indexare numerica.Dupa sortare,toate
elementele si-au schimbat pozitia din arie.Pentru a gasi un anumit
element,am scris metoda Cauta(),ce are la baza metoda Array.BinarySearch()
si apoi am identificat noua pozitie a elementului dorit.Acest mecanism
este extrem de util,atunci cand aria este multidimensionala si contine
mii de inregistrari asemanatoare.
Ariile pot fi incluse una in alta,pentru a crea arii intricate,
denumite si "jagged array" (arii in zig-zag).
EXEMPLU: class Test {
static int void Main() {
int[] a1 = new int[] { 1,2,3};
int[,] a2 = new int[,] {{1,2,3},{4,5,6}};
int[,,] a3 = new int[10,20,30];
int[][] j2 = new int[3][];
j2[0] = new int[] {1,2,3};
j2[1] = new int[] {1,2,3,4,5,6};
j2[2] = new int[] {1,2,3,4,5,6,7,8,9};
}}
In exemplul de mai sus,j2 este o "arie de arii".
Pentru fiecare metoda,obiectul Array contine seturi alternative de
metode supraincarcate,cu diferiti parametri sau cu solutii diferite de
procesare.Este bine sa studiati cu atentie toate aceste optiuni,inainte
de a defini o metoda noua.Metodele standardizate,predefinite,sunt mai
simple si mai sigure decat cele improvizate la moment.
-19-
Probabil ca tipul de data cel mai frecvent utilizat,este tipul "string".
Din acest motiv,obiectul System.String contine un set foarte bogat de
metode,dintre care cele mai frecvent utilizate sunt: Compare,Concat,Format
Indexof,Insert,Join,Replace,Split,Substring,ToLower,ToUpper,Trim.
Cu ajutorul acestor metode,se pot excuta toate tipurile posibile de
operatii,cu si asupra datelor de tip caracter.
Cea mai simpla operatie este separarea unui text in cuvinte,cu ajutorul
metodei Split() si a unui set de caractere,utilizate ca separatori.
EXEMPLU:
using System;
public class SplitTest{
public static void Main() {
string words = "Lista de fructe:mere,pere,prune.";
string[] arie1 = words.Split(new Char[]{' ',',','.',':'});
foreach (string s in arie1) { Console.Write(s); }
Console.ReadLine();
}
}
Salvati fila cu numele Consola6.cs si compilati.
Se pot utiliza numeroase combinatii de caractere separator,pentru a
putea separa cuvintele din orice context,sau chiar si din tabele.
O alta aplicatie simpla o reprezinta cautarea unui cuvant,intr-un sir
de caractere,sau intr-o pagina de tip text.
EXEMPLU:
using System;
class Exemplu {
public static void Main() {
string s1 = "Paza buna trece primejdia rea.";
string s2 = "rea";
bool b;
b = s1.Contains(s2);
Console.Write("Sirul s1 contine sirul s2= {0}",b);
Console.ReadLine();
}
}
Salvati fila cu numele Consola7.cs si compilati.
Pentru a schimba formatul de reprezentare numerica,se poate utiliza
metoda Format().
EXEMPLU:
using System;
public class Exemplu2 {
public static void Main() {
long[] values={ Int16.MinValue,-2773,10,10423,Int16.MaxValue};
Console.WriteLine("{0,10] {1,10}\n","Decimal","hex");
foreach (short value in values) {
string formatat = String.Format("{0,10:G} : {0,10:X}",value);
Console.WriteLine(formatat);
}
Console.ReadLine();
}}
Salvati fila cu numele Consola8.cs si compilati.
-20-
De cele mai multe ori,datele de tip text sunt arhivate in file de tip
.txt sau .doc.Pentru a putea deschide o astfel de fila,se utilizeaza
obiectul File din System.IO.In continuare,fiecare linie din text poate
fi citita intr-un string si prelucrata dupa algoritmul dorit.
EXEMPLU:
using System;
using System.IO;
class Test {
public static void Main(){
string path = @"c:\text.txt";
string[] readText = File.ReadAllLines(path);
foreach (string s in readText)
{ Console.WriteLine(s); }
Console.ReadLine();
}
}
Salvati fila cu numele Consola9.cs si compilati.
In exemplul de mai sus,se preiau datele din fila test.txt (creata intr-un
exercitiu anterior).Incercati sa dezvoltati exercitiul in asa fel,incat
sa deschideti o fila text si apoi sa verificati existenta unui anumit
cuvant,introdus de la tastatura.
Pentru a formata textul,sunt admise urmatoarele secvente de control:
SECVENTA SEMNIFICATIE ECHIVALENT UNICODE
-----------------------------------------------------------------------
\0 Null 0x0000
\a Alert(beep) 0x0007
\b Backspace 0x0008
\t Horizontal tab 0x0009
\n New line 0x000A
\v Vertical tab(printing) 0x000B
\f Form feed (printing) 0x000C
\r Carriage return 0x000D
\" Double quote 0x0022
\' Single quote 0x0027
\\ Backslash 0x005C
\uABCD Unicode character 0xABCD
\xABCD idem
------------------------------------------------------------------------
Doua variabile,sau doua constante de tip string sunt echivalate a fi
egale,atunci cand au aceeasi lungime (numar de caractere),contin exact
aceleasi caractere,situate in exact aceeasi pozitie,sau daca ambele sunt
nule.
EXEMPLU: s1 = "Sirul de control";
s2 = "Sirul de control \n";
Cele doua siruri vor fi afisate identic,dar daca se face o operatie
de comparare,cele doua siruri nu vor fi egale.
Pentru a putea afisa orice alt tip de data compatibil,se poate apela
metoda ToString().
Pentru a forma expresii,variabiele si constantele din tipurile de mai
sus,sunt relationate prin operatori,la care se pot adauga unul sau mai
multe cuvinte cheie,cu rol de modificatori.
-21-
OPERATORI
Pentru a forma expresii,limbajul C# utilizeaza un set de operatori
comun cu cel utilizat de limbajul C++.In functie de numarul de membri din
expresie,operatorii pot fi: unari,binari sau ternari.Tabelul urmator,
prezinta acesti operatori in ordinea descrescatoare a precedentei.
------------------------------------------------------------------------
| Categorie | Operatori | Asociativitate|
-------------------------------------------------------------------------
| Primari | x.y f(x) a[x] x++ x-- new typeof | stanga-dreapta|
| | checked unchecked | |
-------------------------------------------------------------------------
| Unari | + - ! ~ ++x --x (T)x | stanga-dreapta|
-------------------------------------------------------------------------
| Multiplicare | * / % | stanga-dreapta|
-------------------------------------------------------------------------
| Aditie | + - | stanga-dreapta|
-------------------------------------------------------------------------
| Salt binar | << >> | stanga-dreapta|
-------------------------------------------------------------------------
| Relationali | < > <= >= is as | stanga-dreapta|
-------------------------------------------------------------------------
| Egalitate | == != | stanga-dreapta|
-------------------------------------------------------------------------
| Logic AND | & | stanga-dreapta|
-------------------------------------------------------------------------
| Logic XOR | ^ | stanga-dreapta|
-------------------------------------------------------------------------
| Logic OR | | | stanga-dreapta|
-------------------------------------------------------------------------
| Conditie AND | && | stanga-dreapta|
-------------------------------------------------------------------------
| Conditie OR | || | stanga-dreapta|
-------------------------------------------------------------------------
| Ternar | ? : (conditional) | dreapta-stanga|
--------------------------------------------------------------------------
| Atribuire | = *= /= += -= <<= >>= &= ^= |= | dreapta-stanga|
-------------------------------------------------------------------------
Precedenta si asociativitatea intervin doar atunci cand expresia
contine mai multi operatori.Executia se va face initial in functie de
precedenta:
EXEMPLU: a + b * c <= y + x++
Se executa initial x++,apoi b*c,apoi a+ rezultatul si y+ rezultatul si
in ultimul rand se verifica conditia <=.
Daca in expresie exista mai multi operatori cu aceeasi precedenta (din
aceeasi categorie),atunci ordinea de executie este data de tipul de
asociativitate (stg-dr sau dr-stg).
EXEMPLU: a + b + c + d = x se executa de la stanga la dreapta
a += b -= c *= d se executa de la dreapta la stanga
Pentru a clarifica o expresie,se pot utiliza si parantezele rotunde.
-22-
Ori de cate ori este posibil,se vor prefera expresiile simple si clare,
usor de depanat.Atunci cand expresiile complexe sunt indispensabile,se
vor verifica toate valorile extreme ale expresiei.La nevoie se va include
expresia in una sau mai multe bucle de tip try...catch,pentru a putea
adauga si solutii de tratare a exceptiilor.Aceste bucle au rost mai ales,
pentru a evita operatiile imposibile,sau cu redundanta infinita,si pentru
a impiedeca blocarea executiei(Exemplu: procesorul nu poate gasi o anumita
valoare si cauta la infinit in memorie,sau asteapta introducerea acelei
date de la un periferic,sau din retea).
Tipurile de data,impreuna cu operatorii pot deja forma expresii
matematice simple.Pentru calcule matematice mai complexe,sau pentru a
putea utiliza si functiile trigonometrice,biblioteca System contine si
clasa Math,destinata special functiilor matematice.Printre membrii acestei
clase se numara si: Abs(),Asin(),Acos(),Ceiling(),Cos(),Sin(),Cosh(),Log()
Exp(),Floor(),Max(),Min(),Pow(),Round(),Sign(),Sqrt(),Tan(),Atan(),Tanh(),
Truncate() etc.
Apelul acestor functii se face direct,apeland membrii clasei Math().
EXEMPLU:
using System;
class Matematica {
public static void Main()
{
for (int i=90;i<100;i++){
double nr1 = Math.Sqrt(i);
Console.WriteLine("Radical din: {0:D} este= {1:N}",i,nr1);
nr1 = Math.Pow(i,2);
Console.WriteLine("Patratul lui: {0:D} este= {1:N}",i,nr1);
}
Console.ReadLine();
}
}
Salvati fila cu numele Consola10.cs si compilati.
Observati ca metoda Console.WriteLine() permite formatarea datelor de
output.( EXEMPLU: {0:D} si {1:N} ).Valorile acceptabile sunt:
C -format pentru valori monetare (bani)
D -format decimal
E -format exponential (stiintific)
F -format in virgula mobila
G -format general (E sau F in functie de necesitati)
N -format numeric
P -format procentual
X -format hexazecimal
Nu este necesara nici o operatie prealabila de conversie sau formatare.
Datele pot fi afisate direct in formatul dorit (vezi metoda).
Daca este necesar,codul poate fi insotit de comentarii explicative.
Comentariile lungi vor fi incluse intre: /* si */ iar cele care nu
sunt mai lungi de un singur rand,pot fi precedate de grupul "//".
EXEMPLU: // comentariu pe un singur rand
/* Comentariu ce se poate
extinde pe mai multe
randuri din program */
-23-
INSTRUCTIUNI
Denumite si directive de procesare,instructiunile au rostul de a seta
mediul de operare,sau de a organiza mediul de executie dupa o anumita
regula,astfel incat ordinea de executie a operatiilor sa asigure un flux
de date corect.Exista si instructiuni de preprocesare,semnalate tot cu
semnul # ca si in C++,cu rostul de a seta mediul de operare inainte de a
incepe procesarea codurilor din program (sunt la fel ca si in C++).
Unii autori,prefera termenul de instructiuni pentru controlul fluxului,
pentru a sublina faptul ca au rostul de a organiza ordinea de executie.
Importanta acestor instructiuni,depinde de stilul de programare.In cazul
programelor imperative,de tip "listing",rolul lor este esential,in timp
ce in cazul programarii structurate pe obiect,rolul lor este preluat mai
degraba de functii,metode si evenimente.Principalele instructiuni pentru
controlul fluxului sunt:
1. Liste si blocuri de instructiuni:
EXEMPLU: static void main(){ F();G();H();M(); }
2.Etichete si salturi "goto":
EXEMPLUL Functie(){ if(args.Length == 0)
goto sfarsit;
Dostları ilə paylaş: |