Transcript 1.lekcija - Rēzeknes Augstskola

Rēzeknes Augstskola
Inženieru fakultāte
Datorzinātņu un matemātikas katedra
Programminženierija I
M.sc.ing., lekt. Aleksejs Zorins
E-pasts: [email protected]
Lekciju materiāli: www.ru.lv/~alex
.NET Framework apskats
C#
Visual
Basic
C++
XML Web Services
Perl
ASP.NET
J#
…
User Interface
ADO.NET: Data and XML
.NET Framework Class Library
Common Language Runtime
Application Services (COM+, IIS un citi)
Windows
2
.NET Framework apskats
Strādājot Windows vidē Framework ļauj izmantot tādus lietojumu servisus, kā dažādu
komponenšu servisus, Internet Information Server (IIS) un citus caur klašu bibliotēku.
Common Language Runtime – vienotā vide, kura ļauj vienkāršot aplikāciju
izstrādi ar plašām iespējam (vienu un to pašu vidi var izmantot Windows un Web
aplikāciju izstrādei).
Tiek nodrošināts vairāku programmēšanas valodu atbalsts (C#, C++, J#, Visual
Basic un citu izstrādātāju valodas). Šī iespēja tiek realizēta ar Microsoft
Intermediate language (MSIL) kompilatora palīdzību.
ADO.NET dod iespēju strādāt ar datu bāzes objektiem bez pieslēguma datu bāzei
(disconnected programming model), kā arī ļauj plaši izmantot XML.
ASP.NET paredzēta Web aplikāciju veidošanai.
XML Web Services ir programmatiskās Web komponentes, kuras var kopīgi
izmantot caur Internet vai intranet.
User Interfaces iekļauj sevī instrumentus Web un Windows formu izstrādei, kā
arī konsoles aplikācijām.
3
.NET Framework klašu bibliotēka
.NET Framework klašu bibliotēka ļauj izmantot plašu funkcionalitāti ar namespace
(vārdkopa) palīdzību. Namespace ir loģiskā telpa (krātuve), kura apvieno vairākās
klases pēc kādas pazīmes.
Daži vārdvietu piemēri:
System – iekļauj sevī klases ar parasti lietojamiem datiem, notikumiem un notikumu
apstrādātājiem, interfeisiem, atribūtiem un izņēmumu apstrādātājiem, kā arī citus;
System.IO – ievads un izvads failos, plūsmas utt.;
System.Data – klases ADO.NET modeļa lietošanai (piem., DataSet klase);
System.Xml – XML atbalsts;
System.Web – web aplikāciju veidošanai paredzētas klases;
System.Windows.Forms - klases klienta aplikācijas lietotāja saskarnes veidošanai.
4
Pamata izvada operācijas
Konsoles aplikācijās par ievadu un izvadu ir atbildīga Console klase, kura strādā ar:
- standarta ievadu no tastatūras;
- standarta izvadu monitorā;
- standarta kļūdu izvadu monitorā.
Console.Write un Console.WriteLine metodes izvada informāciju uz
monitora ekrāna, pie tam WriteLine papildus pārvieto kursoru nākamajā rindā.
Metode var izmantot string formātu un/ vai parametrus:
Console.WriteLine(100);
Console.WriteLine(“Hello!”);
Parametrus sākumā definē ar speciālo marķieru palīdzību un pēc tam norāda
parametru vērtības:
Console.WriteLine(“{0}+{1}={2}”, 5, 7, 5+7);
Izvadā būs:
5+7=12
5
Izvada formatēšana
Parametru definējumā var norādīt līdzinājumu, piemēram:
Console.WriteLine(“Skaitlis: {0, -10};”, 100);
Console.WriteLine(“Skaitlis: {0, 10};”, 100);
Izvadā būs:
Skaitlis: 100
Skaitlis:
;
100;
{0,10} – nozīmē līdzināts pa labi laukā ar platumu 10;
{0,-10} – nozīmē līdzināts pa kreisi laukā ar platumu 10
Skaitļu izvada formatēšanai var lietot dažādus formātus, kuru pieraksta veids ir:
{N:Format}, kur N – parametra numurs, Format – formatējuma veids.
Pastāv vairāki formatējuma veidi, piem., C – naudas, E – eksponenciālais, D- vesels
skaitlis, F – skaitlis ar fiksētu ciparu skaitu aiz komata un citi).
Console.Write(“{0:F2}”, 255.76654);
→ 255.77
6
Pamata ievada operācijas, komentāri
Metode Console.Read nolasa nākamo simbolu, savukārt metode
Console.ReadLine nolasa visu ievada rindu. Nākošais programmas koda
piemērs ļauj ievadīt kādu simbolu rindu un tā tiks izvadīta monitora ekrānā:
string ievads = Console.ReadLine();
Console.WriteLine(“{0}”, ievads);
C# valoda ļauj izmantot divu veidu komentārus:
//Tas ir vienas rindas komentārs
/*šīs ir
vairāku
rindu
komentārs*/
7
C# datu tipi
Vienotās izstrādes vides sastāvdaļa ir kopīgā tipu sistēma (Common Type System),
kura nodrošina vērtību un referenču tipu mainīgu izmantošanu.
Type
Value Type
Reference Type
Vērtību tipi (Value Type) tieši satur datus vienā eksemplārā, un operācijas ar šiem
datiem nevar ietekmēt citus mainīgus.
Referenču tipi (Reference Type) satur atsauces uz datiem. Dati šiem tipiem tiek
glabāti objektos, un ir pieļauts, ka divi referenču tipi atsaucās uz vienu un to pašu
objektu, tādēļ operācija ar vienu šāda tipa manīgo var ietekmēt cita mainīga datus.
8
Vienkāršie C# datu tipi
Nosaukums
Vērtību intervāls
Izmērs
sbyte
-128 līdz 127
8 bitu vesels skaitlis
byte
0 līdz 255
8 biti pozitīvs vesels skaitlis
char
U+0000 līdz U+ffff
16 bitu simbols
short (ushort)
-32,768 līdz 32,767
16 bitu vesels (pozitīvs) skaitlis
int (uint)
-2,147,483,648 īdz 2,147,483,647
32 bitu vesels (pozitīvs) skaitlis
long (ulong)
-9,223,372,036,854,775,808 līdz
9,223,372,036,854,775,807
64 bitu vesels (pozitīvs) skaitlis
float
±1.5e−45 līdz ±3.4e38
32 biti (precizitāte 7 cipari)
double
±5.0e−324 līdz ±1.7e308
64 biti (precizitāte 15-16 cipari)
bool
true vai false
8 biti (loģiskā vērtība)
decimal
±1.0 e−28 to ±7.9e28
128 biti (precizitāte līdz 29 cipariem)
Lietotāja definētie tipi
Sakārtotās secības (Enumeration)
class Program
{
enum Color { Red, Green, Blue }
static void Main()
{
Color colorPalette = Color.Red;
Console.WriteLine("{0}", colorPalette);
}
}
Lietotāja tipus definē pirms vai pēc Main funkcijas. Pēc noklusējuma katrai
pirmajai secības vērtībai piešķir 0. Atsaukties var izmantojot konkrētus
nosaukumus vai vērtību numurus:
colorPalette = (Color)0;
10
Lietotāja definētie tipi
class Program
{
public struct Darbinieki //definējam struktūras tipu
{
//string datu tipā var saglabāt patvaļīgā
//garuma simbolu virkni
public string uzvards;
public int vecums;
}
static void Main()
{
Darbinieki firmasDarbinieki; /*definējam mainīgo
un piešķīrām vērtības*/
firmasDarbinieki.uzvards = "Vaivods";
firmasDarbinieki.vecums = 35;
Console.WriteLine("{0},{1}",
firmasDarbinieki.uzvards,
firmasDarbinieki.vecums);
}
11
}
Datu tipu konvertācija
Pastāv netiešā (implicit) un tiešā (explicit) konvertācija.
Netiešā konvertācija vienmēr būs veiksmīgi izpildīta un nekad nenovedīs pie datu
zaudējuma. To pielieto mazāku (gan izmēra, gan precizitātes ziņā) datu tipu
konversijai lielākos (bet ne otrādi!), piemēram:
isais 100= garo 100
int i=100;
long j = i;
Console.WriteLine(“isais {0} = garo {1}”, i, j);
Pretējā gadījumā jāizmanto tiešā konvertācija, kura var novest arī pie datu un vai
precizitātes zaudējuma, piemēram:
double i=100.57;
dalskaitlis 100.57= veselu 100
int j = (int)i;
Console.WriteLine(“dalskaitlis {0} = veselu {1}”, i, j);
12
Iterāciju izteikumi
C# valodā ir ieviests jauns cikla veids foreach, kuru ērti izmantot dažādu ierakstu
kolekciju apstrādei (šīs cikla veids pārlasa visus kolekcijas elementus).
using System;
using System.Collections;//satur ArrayList objektu
class Program
{
static void Main()
{
//definējam jauno ArrayList objektu “skaitli”
ArrayList skaitli = new ArrayList();
for (int i=0;i<10;i++)
skaitli.Add(i);//piešķiram viņam i vērtības
//cikls pārlasa visus elementus mūsu objektā “skaitli”
foreach (int j in skaitli)
Console.WriteLine(j);
}
}
13
Izņēmumu situāciju apstrāde
Tradicionālā izņēmumu situāciju apstrāde nav ērta, jo programmas kods ir slikti
saprotams un kļūdas kodi parasti nenes nekādas informācijas, piemēram:
int ErrorCode=0;
int n = int.Parse(textBox1.Text);
int m = int.Parse(textBox2.Text);
if (m == 0)
ErrorCode = 1;
else if (n > 200 || m > 200)
ErrorCode = 2;
else
{
int z = n / m;
label1.Text = z.ToString();
}
switch (ErrorCode)
{
case 1: MessageBox.Show("Division by zero"); break;
case 2: MessageBox.Show("Memory overflow"); break;
}
14
Izņēmumu situāciju apstrāde
.NET Framework paredz izņēmumu apstrādi ar klasēm, kuros ir definētas dažādas
izņēmumu situācijas, piemēram:
OverflowException – atmiņas bufera pārpildīšana;
DivideByZeroException – dalīšana ar nulli;
IndexOutOfRangeException – mēģinājums atsaukties uz
neeksistējošo masīva indeksu;
FileNotFoundException – nav atrast fails ar norādīto nosaukumu;
OutOfMemoryException – trūkst atmiņas turpmākai programmas
izpildīšanai.
15
Exception klases
Exception
SystemException
ApplicationException
OutOfMemoryException
DivideByZeroException
Citas klases
OverflowException
Citas klases
16
try un catch bloku izmantošana
Izņēmumu situāciju apstrāde tiek veikta ar try un catch bloku palīdzību šādā veidā:
try
{
//programmas kods, kurš var izraisīt izņēmuma situāciju
}
catch (viena no Exception klases, nosaukums)
{
//programmas kods, kurš tiek izpildīts izņēmuma gadījumā
}
Tādā veidā programmas kods ir strikti sadalīts divās daļās. Pirmajā daļā ir parastais
programmas kods, kurš var izraisīt izņēmuma situāciju (kļūdu). Ja kļūdas nebija,
programmas turpina savu darbību izlaižot catch bloku.
Ja izņēmumu situācija ir notikusi try blokā, vadība tiek nodota catch blokam,
kura parametrs ir viens no izņēmumu situācijas objektiem.
17
try un catch bloku izmantošana
//pārbaudām šo kodu pret izņēmumu situācijām
try
{
int n = int.Parse(textBox1.Text);
int m = int.Parse(textBox2.Text);
int z = n / m;
label1.Text = z.ToString();
}
//izpildās ja notiek dalīšana ar nulli
catch (DivideByZeroException d)
{
MessageBox.Show(d.ToString());
}
//izpildās ja notiek atmiņas bufera pārpildīšana
catch (OverflowException o)
{
MessageBox.Show(o.ToString());
}
18
try
{
try un catch bloku izmantošana
int n = int.Parse(textBox1.Text);
int m = int.Parse(textBox2.Text);
int z = n / m;
label1.Text = z.ToString();
}
catch (DivideByZeroException d)
{
MessageBox.Show(d.ToString());
}
catch (OverflowException o)
{
MessageBox.Show(o.ToString());
}
//izpildās visu pārējo kļūdu gadījumos
catch (Exception i)
{
MessageBox.Show("Kaut kas nav labi");
}
19
Exception klašu hierarhija
try
{
int n = int.Parse(textBox1.Text);
int m = int.Parse(textBox2.Text);
int z = n / m;
label1.Text = z.ToString();
}
catch (Exception i)
{
MessageBox.Show("Kaut kas nav labi");
}
catch (DivideByZeroException d)
{
Šeit būs kļūda, jo
MessageBox.Show(d.ToString());
Exception
}
objekts ir vispārīgāks
catch (OverflowException o)
par pārējiem
{
MessageBox.Show(o.ToString());
}
20
Masīvi
Masīvi ļauj uzglabāt vienāda tipa mainīgus. Masīvu definēšana C# notiek šādi:
int [] masivs;
masivs = new int[10];
Masīvu inicializēt un norādīt tās izmēru var arī vienā rindā:
int [] masivs = new int[10];
Vairāku dimensiju masīviem ir nepieciešams norādīt visu dimensiju izmērus:
int [,] masivs = new int[3,4];
Atšķirībā no C++, C# var inicializēt masīvu, kuras izmērs tiks noteikts programmas
darbības gaitā:
string s = textBox1.Text;
int size = int.Parse(s);
double [] mas = new double [size];
21
Masīvu elementu skaits un pieeja tiem
Pēc masīva inicializācijas un tā izmēra definēšanas jebkura programmas vietā var
noteikt šī masīva garumu ar Length īpašības palīdzību:
int [] masivs = new int[10];
label1.Text = masivs.Length.ToString();
Tādā pašā veidā var noteikt arī vairāku dimensiju masīvu garumu:
Abos
gadījumos
garums=10
int [,] masivs = new int[2,5];
label1.Text = masivs.Length.ToString();
Pieeja atsevišķam masīva elementam notiek ar masīva nosaukumu un elementa
indeksa numuru:
//izvada masīva elementus textBox logā
foreach (int j in masivs)//foreach nevar mainīt elementus
{
string t = masivs[j].ToString();
textBox3.Text = textBox3.Text+t;
22
}
Masīvi un kolekcijas
Masīvu priekšrocības:
- aizņem mazāk atmiņas;
- ātrākā apstrāde.
Kolekciju priekšrocības:
- ļauj mainīt savu izmēru pēc izveidošanas;
- var uzglabāt dažāda tipa datus;
- pastāv iespēja pievienot “read-only” elementus, kurus pēc tam nevar mainīt.
Viens no kolekcijas piemēriem ir ArrayList klase, kura definēta
System.Collections vārdvietā.
//tiek izveidots ArrayList objekts ar nosaukumu masivs
ArrayList masivs = new ArrayList();
23
Masīvu elementu inicializācija
//piešķiram vērtības uzreiz pēc inicializācijas
int [] m1 = new int [3] {1,2,3};
int [,] m2 = new int [2,3] {
{1,2,3},
{4,5,6},
};
//inicializējam masīvu
int [,] mas = new int [5,10];
//piešķiram masīva elementiem vērtības
for (int i=0; i<mas.GetLength(0);i++)
for (int j=0; j<mas.GetLength(1);j++)
mas[i,j]=i+j;
GetLength īpašība ļauj noteikt katras dimensijas izmēru vairāku dimensiju
masīvu gadījumos.
24
Masīvu īpašības un metodes
Darbam ar masīviem .NET Framework ir arī paredzēta sava klase System.Array.
Šī klase satur vairākas metodes un īpašības, kuras atvieglo masīvu apstrādi.
Īpašība Length ļauj iegūt masīva kopējo elementu skaitu, bet GetLength - katras
dimensijas garumu. Vēl viena īpašība Rank parāda masīva dimensiju skaitu. Visas
šīs īpašības ir “read-only”.
int[,,] mas = new int[3, 4, 5];
string t = mas.Length.ToString();
textBox1.Text = textBox1.Text + t+" "; //elementu skaits=60
t = mas.GetLength(0).ToString();
textBox1.Text = textBox1.Text + t + " "; //1.dimensija=3
t = mas.GetLength(1).ToString();
textBox1.Text = textBox1.Text + t + " "; //2.dimensija=4
t = mas.GetLength(2).ToString();
textBox1.Text = textBox1.Text + t + " "; //3.dimensija=5
t = mas.Rank.ToString();
textBox1.Text = textBox1.Text + t; //dimensiju skaits=3
25
Masīvu īpašības un metodes
Metode Sort ļauj šķirot viendimensiju masīva elementus augošā secībā:
int[] mas = new int[5] {4,3,1,5,2};
Array.Sort(mas);
for (int i=0; i<5; i++)
12345
{
string t = mas[i].ToString();
textBox1.Text = textBox1.Text + t + " ";
}
Metode Clear piešķir nulles vērtības norādītiem masīva elementiem. Pirmais
metodes parametrs ir masīva nosaukums, otrais – elementa indekss, ar kuru sākam
tīrīšanu un trešais – elementu skaits:
int[] mas = new int[5] {4,3,1,5,2};
Array.Clear(mas, 1, 3);
for (int i=0; i<5; i++)
40002
{
string t = mas[i].ToString();
textBox1.Text = textBox1.Text + t + " ";
}
26
Masīvu īpašības un metodes
Ar Clone metodes palīdzību var veidot masīvu kopijas. Piešķirot kopijas saturu
citam masīvam ir nepieciešama tiešā datu tipu konvertācija:
int[] mas = new int[5] {4,3,1,5,2};
//izveidojam pirmā masīva kopiju un piešķiram to otram masīvam
int[] kopija = (int [])mas.Clone();
//iztīram pirmo masīvu
Array.Clear(mas, 0, mas.Length);
//izvadam abu masīvu elementu vērtības
for (int i=0; i<5; i++)
{
string t = mas[i].ToString();
textBox1.Text = textBox1.Text + t + " ";
t = kopija[i].ToString();
textBox2.Text = textBox2.Text + t + " ";
}
27
Kolekcijas un darbības ar tām
Plašāk lietojamie kolekciju veidi ir šādi:
ArrayList – sakārtotu objektu kolekcija, pieeja pie kuriem tiek
nodrošināta ar indeksu palīdzību;
Hashtable – atšķirībā no ArrayList indeksi tiek definēti ar nosaukumu
palīdzību (optimizēti meklēšanai);
Queue – realizē rindas struktūru, kad pieeja pie elementiem notiek pēc
principa “pirmais iekšā, pirmais ārā”;
Stack – realizē stekus, kad pieeja pie elementiem notiek pēc principa
“pirmais iekšā, pēdējais ārā”.
28
Darbs ar ArrayList klasi
Metode Add ļauj pievienot jauno objektu kolekcijai, savukārt metode AddRange
ļauj pievienot kolekcijai elementu virkni no citas kolekcijas:
ArrayList kolekcija = new ArrayList();//izveidojam kolekciju
kolekcija.Add(10);//un trīs pievienojam elementus
kolekcija.Add("otrais");
kolekcija.Add(100);
ArrayList lielaKolekcija = new ArrayList();//vēl kolekcija
lielaKolekcija.Add(1);//pievienojam elementu
lielaKolekcija.AddRange(kolekcija);//un visus no pirmās kolekcijas
for (int i = 0; i < kolekcija.Count;i++ )
{//foreach ciklu izmantot nevaram, jo kolekcijā ir dažāda tipa mainīgie
string t = kolekcija[i].ToString();
textBox1.Text = textBox1.Text + t + " ";
}
for (int i = 0; i < lielaKolekcija.Count; i++)
{
string t = lielaKolekcija[i].ToString();
textBox2.Text = textBox2.Text + t + " ";
29
}
Darbs ar ArrayList klasi
Metode Remove nodzēš objektu no kolekcijas pēc norādītas vērtības, savukārt
metode RemoveAt nodzēš elementu ar norādīto indeksu:
ArrayList kolekcija = new ArrayList();
kolekcija.Add(10);
kolekcija.Add("otrais");
kolekcija.Add(100);
//dzēšam elementu ar nosaukumu otrais
kolekcija.Remove("otrais");
//kolekcijā palika 2 elementi, tagad dzēšam 1.elementu
kolekcija.RemoveAt(0);
for (int i = 0; i < kolekcija.Count; i++)
{
string t = kolekcija[i].ToString();
textBox1.Text = textBox1.Text + t + " ";
}
100
30
Darbs ar ArrayList klasi
Metode RemoveRange nodzēš objektus norādītajā indeksu intervālā, bet
metode Clear nodzēš visus elementus no kolekcijas:
ArrayList kolekcija = new ArrayList();
kolekcija.Add(10);
kolekcija.Add("otrais");
kolekcija.Add(100);
kolekcija.Add(“ceturtais”);
//dzēšam elementu ar nosaukumu otrais
kolekcija.RemoveRange(1,2);
//palika 10 un “ceturtais”
kolekcija.Clear();
//tagad ir tukša kolekcija
Metode TrimToSize ierobežo kolekcijas iespējamo elementu skaitu ar tajā jau
eksistējošiem elementiem.
31
Darbs ar ArrayList klasi
Metode Insert ieraksta kolekcijā elementu ar norādīto indeksu:
ArrayList kolekcija
kolekcija.Insert(0,
kolekcija.Insert(1,
kolekcija.Insert(2,
kolekcija.Insert(3,
kolekcija.Insert(4,
= new ArrayList();
“Tāda");
"kolekcija");
"satur");
"svarīgu");
"informāciju");
Metode Sort sašķiro kolekcijas elementus augošā kārtībā (simboliskās informācijas
gadījumā pēc alfabēta), bet metode Reverse maina elementu kārtību uz pretējo:
kolekcija.Sort();
informāciju kolekcija satur svarīgu Tāda
kolekcija.Reverse();
Tāda svarīgu satur kolekcija informāciju
32
Darbs ar ArrayList klasi
Darbam ar kolekcijām var izmantot kursorus, kurus var izveidot no klases
IEnumerator. Šāda tipa kursors pārvietojas pa kolekcijas elementiem un satur
tikai divas metodes – MoveNext (pāriet pie nākošā) un Reset (atgriezties
kolekcijas sākumā):
ArrayList kolekcija = new ArrayList();
kolekcija.Insert(0, "Tāda");
kolekcija.Insert(1, "kolekcija");
kolekcija.Insert(2, "satur");
kolekcija.Insert(3, "svarīgu");
kolekcija.Insert(4, "informāciju");
//izveidojam kursoru mūsu kolekcijai
IEnumerator kursors = kolekcija.GetEnumerator();
//cikls izpildās kamēr visi elementi nebūs izskatīti
while (kursors.MoveNext())
{
//piešķiram mainīgajam t kursora tekošo vērtību
string t = kursors.Current.ToString();
textBox1.Text = textBox1.Text + t + " ";
}
33