Sadržaj Sadržaj.............................................................................................................................................1 Spisak slika......................................................................................................................................9 Lista korišćenih skraćenica............................................................................................................13 Skraćenica..........................................................................................................13 Originalno značenje............................................................................................13 Opis....................................................................................................................13
UVOD............................................................................................................................................14 1. Uvod u ADO.NET.....................................................................................................................15 1.1 ADO.NET..........................................................................................................15 1.2 Konektovani scenario......................................................................................15 1.2.1 Korišćenje ADO.NET klasa u konektovanom scenariju...............................15 1.2.2 Prostori imena i nazivi klasa......................................................................16 1.2.3 Klase konektovanog scenarija...................................................................16 1.3 Diskonektovani scenario..................................................................................16 1.3.1 Korišćenje ADO.NET klasa u diskonektovanom scenariju..........................16 1.3.2 Klase konektovanog scenarija...................................................................17
2. Uspostavljanje konekcije sa bazom podataka............................................................................18 2.1 ODBC...............................................................................................................18 2.2 DAO.................................................................................................................18 2.3 OLE-DB............................................................................................................ 19 2.4 ADO i ADO.NET................................................................................................19 2.5 .NET snabdevači podataka (Data Providers)....................................................19 2.6 OLE DB snabdevači podataka..........................................................................20 2.7 ODBC .NET snabdevač podataka.....................................................................20 ADO.NET
Strana 1
2.8 Konekcije......................................................................................................... 20 2.9 Connection objekat..........................................................................................20 2.10 Svojstva interfejsa IdbConnection.................................................................20 2.11 Metode interfejsa IdbConnection...................................................................21 2.12 SQL Server – ConnectionString......................................................................21 2.13 Konekcija kod Windows autentifikacije..........................................................22 2.14 OLE DB konekcija..........................................................................................22 2.14.1 Čuvanje konekcionog stringa u konfiguracionom fajlu............................23 2.15 Konekcije i obrada izuzetaka.........................................................................23 2.16 Connection Pooling........................................................................................24 2.17 Događaji konekcije.......................................................................................24
3. Rad u konektovanom okruženju................................................................................................25 3.1 Objekat Command...........................................................................................25 3.2 Svojstva interfejsa IdbCommand.....................................................................25 3.3 Metode interfejsa IdbCommand......................................................................25 3.3.1 SqlCommand konstruktor – I.....................................................................25 3.3.2 SqlCommand konstruktor – II....................................................................26 3.3.3 Izvršavanje komande koja vraća jednu vrednost......................................26 3.3.4 Ažuriranje baze podataka..........................................................................27
4. Rad sa parametarskim upitima u ...............................................................................................28 konektovanom okruženju...............................................................................................................28 4.1 Parametri komande.........................................................................................28 4.1.1 Primer parametarskog upita......................................................................28 4.2 Kreiranje uskladištenih procedura...................................................................29 4.3 Izvšavanje parametarskog upita korišćenjem uskladištene procedure...........29 4.4 Uskladištene procedure sa izlaznim parametrima...........................................30 ADO.NET
Strana 2
4.5 Definisanje izlaznih parametara......................................................................30 4.6 Definisanje povratne vrednosti........................................................................32 4.7 Izvođenje parametara.....................................................................................33
5. Objekat DataReader...................................................................................................................34 5.1 DataReader..................................................................................................... 34 5.1.1 Svojstva i metode DataReader objekta.....................................................34 5.1.2 Primer upotrebe DataReader-a.................................................................34 5.1.3 Uskladištene procedure i DataReader.......................................................35 5.2 Procedura CustOrderHist.................................................................................36 5.3 Metapodaci o rezultujućem skupu zapisa........................................................36 5.4 Primer čitanja metapodataka..........................................................................36
6. Objekat DataAdapter.................................................................................................................38 6.1 Klasa DataAdapter...........................................................................................38 6.2 Rad u diskonektovanom okruženju..................................................................38 6.3 Struktura DataAdaptera..................................................................................39 6.4 Karakteristike objekta DataAdapter................................................................40 6.5 Svojstva i metode DataAdaptera.....................................................................40 6.6 Kreiranje objekta DataAdapter........................................................................40 6.6.1 Punjenje DataSet-a....................................................................................41 6.6.2 Kreiranje objekta DataAdapter (2).............................................................42 6.6.3 Punjenje DataSet-a korišćenjem uskladištene procedure..........................42
7. Objekat DataSet.........................................................................................................................43 7.1 DataSet...........................................................................................................43 7.2 Svojstva objekta DataSet................................................................................43 7.3 Kreiranje objekta DataSet................................................................................43 7.4 Kreiranje prostog primarnog ključa.................................................................44 ADO.NET
Strana 3
7.5 Kreiranje složenog primarnog ključa...............................................................44 7.6 Unique ograničenje..........................................................................................45 7.7 Ograničenje ForeignKey..................................................................................45 7.8 Kreiranje ograničenja ForeignKey....................................................................46
8. Objekat DataTable.....................................................................................................................47 8.1Struktura objekta DataTable............................................................................47 8.2 Punjenje objekta DataTable korišćenjem DataAdaptera..................................47 8.3 Punjenje DataSeta koristeći više adaptera......................................................48 8.4 Primer pristupa atributu kod tipiziranog i netipiziranog DataSeta...................48 8.5 Pronalaženje vrste u tabeli..............................................................................48 8.6 Pretraživanje po prostom ključu......................................................................49 8.7 Pretraživanje po složenom ključu....................................................................49 8.8 Filtriranje i sortiranje DataRow objekata u objektu DataTable.........................49 8.9 Modifikovanje podataka u bazi korišćenjem DataAdaptera.............................50 8.10 Definisanje insert komande DataAdaptera....................................................50 8.11 Ubacivanje zapisa u bazu podataka..............................................................50 8.12 Update komanda DataAdaptera....................................................................51 8.13 Ažuriranje podataka u bazi............................................................................52 8.14 Delete komanda DataAdaptera.....................................................................52 8.15 Brisanje podataka u bazi...............................................................................53
9. Objekat DataView.....................................................................................................................54 9.1 Kreiranje DataView objekta.............................................................................54 9.2 Karakteristike objekta DataView.....................................................................54 9.3 Svojstva objekta DataView..............................................................................54 9.4 Primer upotrebe DataView objekta..................................................................55 9.5 Metoda FindRows............................................................................................55 ADO.NET
Strana 4
9.6 Dodavanje DataRowView objekta u objekat DataView....................................56 9.7 Editovanje DataRowView objekta koji se nalazi u DataView objektu...............57 9.8 Brisanje DataRowView objekta........................................................................57
10. Rad sa relacionim podacima....................................................................................................58 10.1 Objekat DataRelation....................................................................................58 10.2Primer kreiranja DataRelation objekta............................................................58 10.3 Navigacija relacionih podataka......................................................................59
11. Izvršavanje diskonektovanih operacija....................................................................................60 korišćenjem wizard........................................................................................................................60 11.1 Netipizirani i tipizirani DataSetovi.................................................................60 11.2 Kreiranje tipskog DataSeta korišćenjem DataSet dizajnera...........................60 11.3 Dataset Designer prozor................................................................................61 11.4 TableAdapter Configuration Wizard...............................................................61 11.4.1 Definisanje upita korišćenjem Query Buildera.........................................63 11.4.2 Prozor Advanced Options........................................................................64 11.5 Uskladištena procedura kao komanda DataSeta...........................................66 11.6 Dodavanje relacije između tabela.................................................................67 11.7 Definisanje veze između tabela u DataSetu..................................................68 11.8 Izgled šeme DataSet-a..................................................................................69 11.9 Prevlačenje tabele iz Server Explorera..........................................................69 11.10 DataSource Configuration wizard................................................................70 11.11 Primer kreiranog dataSeta...........................................................................71 11.12 ClassView prozor.........................................................................................71 11.13 Primer upotrebe TableAdaptera..................................................................72 11.14 Primer upotrebe generisanih metoda i klsa.................................................72
12. Povezivanje podataka u windows obrascima..........................................................................74 ADO.NET
Strana 5
12.1 Povezivanje podataka....................................................................................74 12.2 BindingSource kontrola.................................................................................74 12.3 Definisanje izvora podataka za BindingSource kontrolu................................74 12.4 Automatski generisani kod............................................................................75 12.5 Ostala svojstva BindingSource kontrole........................................................75 12.6 Jednostavno povezivanje...............................................................................76 12.6.1 Jednostavno povezivanje – kod...............................................................76 12.7 Povezivanje PictureBox kontrole sa Image kolonom......................................77 12.8 Povezivanje DateTimePicker kontrole sa DateTime kolonom........................78 12.9 Povezivanje CheckBox kontrole sa Boolean kolonom....................................79 12.10 Kompleksno povezivanje.............................................................................79 12.10.1 Kompleksno povezivanje – kod..............................................................80 12.10.2 Prikaz proizvoda date kategorije...........................................................80 12.10.3 Prikaz proizvoda date kategorija – GUI..................................................81 12.11 Dve kontrole povezane na izvor podataka kroz istu BindingSource kontrolu .............................................................................................................................. 82 12.12 BindingNavigator.........................................................................................82 12.12.1 BindingNavigator – primer.....................................................................83 12.13 Kreiranje Master – Detalji odnosa između kontrola......................................83
13. DataGridView kontrola...........................................................................................................85 13.1 Uvod u DataGridView....................................................................................85 13.2 Osobine DataGridView kontrole.....................................................................85 13.3 Povezivanje DataGridView kontrole sa tabelom iz koda................................85 13.4 Povezivanje DataGridView kontrole sa tabelom u dizaj modu.......................86 13.5 DataGridView objekti.....................................................................................86 13.6 Šematski prikaz DataGridView objekata........................................................87 ADO.NET
Strana 6
13.7 DataGridViewColumn objekat........................................................................87 13.8 Prikaz header-a kolona..................................................................................88 13.9 DataGridViewRow objekat.............................................................................88 13.10 Klase izvedene iz klase DataGridViewColumn.............................................89 13.11 Kreiranje DataGridView kontrole koja nije povezana sa izvorom podataka. 89 13.11.1 Prikaz kreirane DataGridView kontrole..................................................90 13.12 Selekcija ćelije.............................................................................................91 13.13 Svojstva DataGridView kontrole vezana za selekciju...................................91 13.14 Provera selektovanih ćelija..........................................................................91 13.14.1 Provera selektovanih ćelija – GUI..........................................................92 13.15 Ubacivanje ComboBox kontrole u ćeliju DataGridView kontrole..................92 13.16 Promena tipa kolone....................................................................................93 13.17 Povezivanje ComboBox kolone sa izvorom podataka..................................94 13.18 Izgled DataGridView kontrole sa ComboBox kolonom.................................94
14. Vodič za izradu praktičnih primera.........................................................................................95 14.1 Kreiranje Windows Forms projekta................................................................95 14.2 Cuvanje Windows Forms projekta.................................................................97 14.3 Vodič za izradu aplikacije „Imenik 2010“......................................................99 14.3.1 Dodavanje kontrola.................................................................................99 14.3.2 Kodiranje aplikacije...............................................................................103 14.4 Vodič za izradu aplikacije „SQL Vezba“.......................................................112 14.4.1 Dodavanje kontrola...............................................................................112 14.4.2 Kodiranje aplikacije...............................................................................113 14.5 Vodič za izradu aplikacije „ADO.NET“..........................................................116 14.5.1 Dodavanje kontrola...............................................................................116 14.5.2 Kodiranje aplikacije...............................................................................117 ADO.NET
Strana 7
14.6 Vodič za izradu aplikacije „LogIn“...............................................................125 14.6.1 Dodavanje kontrola...............................................................................125 14.6.2 Kodiranje aplikacije...............................................................................129 14.7 Vodič za izradu aplikacije „Kolekcija filmova“.............................................136 14.7.1 Dodavanje kontrola ..............................................................................136 14.7.2 Kodiranje aplikacije...............................................................................141
Zaključak.....................................................................................................................................149 Literatura......................................................................................................................................151
ADO.NET
Strana 8
Spisak slika Slika 1: Osnovne klase...................................................................................................................15 .......................................................................................................................................................17 Slika 2: Korišćenje ADO.NET klasa u diskonektovanom scenariju.............................................17 Slika 3: ODBC (Open Database Connectivity).............................................................................18 Slika 4: DAO (Data Access Objects).............................................................................................18 Slika 5: OLE-DB (Object Linking and Embedding Database).....................................................19 Slika 6: Primena pojedinih ADO.NET objekata pri radu u diskonektovanom okruženju.............38 Slika 7: Struktura DataAdapter-a...................................................................................................39 Slika 8: Mapiranje tabele Table123 iz baze u tabelu Enployees u DataSet-u...............................40 Slika 9: Struktura objekta DataTable.............................................................................................47 Slika 10: Prozor Add New Item.....................................................................................................60 Slika 11: DataSet Designer prozor................................................................................................61 Slika 12: TableAdapter Configuration Wizard..............................................................................61 Slika13: Biranje pristupa TableAdaptera podacima iz baze..........................................................62 Slika 14: Definisanje SELECT komande TableAdaptera.............................................................63 Slika 15: Add Table prozor............................................................................................................63 Slika 16: Query Builder prozor......................................................................................................64 Slika 17: Advanced Options prozor...............................................................................................64 Slika 18: Definisanje metode koju wizard treba da generise.........................................................65 Slika 19: Poslednji korak TableAdapter wizarda..........................................................................66 Slika 20: Odabir postojeće uskladištene procedure.......................................................................67 Slika 21: Dodavanje relacije između tabela...................................................................................67 Slika 22: Relation prozor DataSet-a..............................................................................................68 ADO.NET
Strana 9
Slika 23: Prikaz šeme DataSet-a....................................................................................................69 Slika 24: Server Explorer...............................................................................................................69 Slika 25: DataSource onfiguration Wizard....................................................................................70 Slika 26: Kreirani DataSet.............................................................................................................71 Slika 27: ClassView prozor...........................................................................................................71 Slika28: Definisanje izvora podataka za BindingSource kontrolu................................................74 Slika 29: Povezivanje Text svojstva TextBox kontrole sa vrednošću atributa CategoryID..........76 Slika 30: Povezivanje PictureBox kontrole sa Image kolonom.....................................................77 Slika 31: Povezivanje DateTimePicker kontrole sa DateTime kolonom......................................78 Slika 32: DateTimePicker kontrola...............................................................................................78 Slika 33: Povezivanje kontrole ComboBox sa kolonom CategoryID...........................................79 Slika 34: ComboBox kontrola.......................................................................................................80 Slika 35: Prikaz proizvoda u ListBox kontroli..............................................................................81 Slika 36: Korisnički interfejs aplikacije........................................................................................82 Slika 37: BindingNavigator kontrola.............................................................................................83 Slika 38: Konfigurisanje ComboBox kontrole..............................................................................83 Slika 39: Prevlačenje tabele na formu...........................................................................................84 Slika 40: Povezivanje DataGridView kontrole sa tabelom u dizaj modu.....................................86 Slika 41: Šematski prikaz DataGridView objekata.......................................................................87 Slika 42: DataGridViewColumn objekat.......................................................................................87 Slika 43: DataGridView kontrola..................................................................................................90 Slika 44: Grafički prikaz selektovanih ćelija.................................................................................92 Slika 45: Editovanje izabrane kolone u DataGridView kontroli...................................................92 Slika 46: Promena tipa kolone u DataGridView kontroli..............................................................93 Slika 47: Povezivanje ComboBox kolone sa izvorom podataka...................................................94 ADO.NET
Strana 10
Slika48: Izgled DataGridView kontrole sa ComboBox kolonom.................................................94 Slika 49: Prozor Microsoft Visual C# 2008 Express Edition........................................................95 Slika 50: Kreiranje novog projekta................................................................................................96 Slika 51: New Project dialog.........................................................................................................96 Slika 52: Razvojno okruženje Visual C#-a....................................................................................97 Slika 53: Čuvanje projekta.............................................................................................................97 Slika 54: Save Project prozor........................................................................................................98 Slika 55: Project Location prozor..................................................................................................98 Slika 56: Izgled Imenik aplikacije I deo........................................................................................99 Slika 57: Izgled Imenik aplikacije II deo.....................................................................................101 Slika 58: Izgled Imenik aplikacije III deo...................................................................................103 Slika 59: Namespace Szstem.Data.OleDb...................................................................................104 Slika 60: Prikaz podataka selektovane osobe..............................................................................110 Slika 61: Izgled aplikacije SQL Vezba........................................................................................113 Slika 62: MessageBox – uspela konekcija...................................................................................115 Slika 63: Rezultat nakon izvršenog upita....................................................................................115 Slika 64: Izgled aplikacije ADO.NET.........................................................................................117 Slika 65: Dodavanje nove klase projektu....................................................................................118 Slika 66: Prikaz podataka u ADO.NET aplikaciji.......................................................................123 Slika 67: Podaci smešteni u tekstualnom fajlu............................................................................123 Slika 68: Podaci smešteni u xml fajlu..........................................................................................124 Slika 69: Izgled LogIn prozora....................................................................................................126 Slika 70: Izgled profil prozora.....................................................................................................127 Slika 71: Izgled prozora za registraciju.......................................................................................129 Slika 72: Prikaz logovanog korisnika..........................................................................................135 ADO.NET
Strana 11
Slika 73: Izgled aplikacije Kolekcija filmova.............................................................................137 Slika 74: Tab – pretraga po nazivu..............................................................................................138 Slika 75: Tab – pretraga po kategoriji.........................................................................................139 Slika 76: Tab – pretraga po pogledu............................................................................................139 Slika 77: Tab – pretraga po godini..............................................................................................140 Slika 78: Izgled Izmeni prozora...................................................................................................141 Slika 79: Prilaz rezultata pretrage za date godine........................................................................149
ADO.NET
Strana 12
Lista korišćenih skraćenica
Skraćenica
Originalno značenje
Opis
ADO
ActiveX Data Objects
Skup objekata namenjen pristupu izvorima podataka
XML
Extensible Markup Language
Konvencija za kodiranje i formatiranje sadržaja
SQL
Structured Query Language
Strukturni upitni jezik
Application Programming Interface
Softverski implementiran interfejs koji omogućava komunikaciju sa drugim softverom
COM
Component Object Model
Standard za softverske komponente
CLR
Common Language Runtime
Osnovna komponenta Microsoft .NET-a
JIT
Just In Time
Način poboljšavanja efikasnosti računarskog programa
OO
Object Orientated
Objektno orijentisan
Object Linking And Embedding For Databases
Pristup podacima sa različitih izvora podataka
Open Database Connectivity
Obezbeđuje standardni softverski interfejs za pristup bazi podataka sistema za upravljanje
Graphical User Interface
Grafički korisnički interfejs
API
OLE DB
ODBC
GUI
ADO.NET
Strana 13
UVOD ADO.NET je komponenta za pristup podacima novog Microsoftovog .NET okruzenja. ADO.NET predstavlja neku vrstu neizbežnosti koja prati razvoj .NET okruženja i pojavu novog pristupa podacima API. Moguće je nastaviti sa korišćenjem ADO-a u .NET aplikacijama kroz COM interoperabilnost, međutim postoje opravdani razlozi zašto ADO nije predvidjen za novo .NET okruženje. Svrha diplomskog rada je da, kroz teoriju i praktične primere, prikaže koje su sve mogućnosti i na koje sve načine možemo uspostaviti povezivanje sa bazama podataka preko ADO.NET klasa, korišćenjem C# programskog jezika i naprednih objektno orjentisanih mogućnosti. Rad je podeljen po poglavljima i to: •
Uvod u ADO.NET gde se upoznajemo sa klasama koje obezbeđuju mogućnost konektovanja na izvor podataka. Upoznajemo se sa konektovanim i diskonektovanim scenariom.
•
Uspostavljanje konekcije sa bazom podataka - prikazuje tehnologije za pristup bazi podataka hronološkim redom.
•
Rad u konektovanom okruženju gde upoznajemo objekat Command koji dozvoljava direktan pristup podacima u bazi u konektovanom okruženju.
•
Rad sa parametarskim upitima u konektovanom okruženju. Upoznavanje sa uskladištenim procedurama i definisanje izlaznih parametara.
•
Poglavlja 5, 6, 7, 8, 9 su namenjena upoznavanju svojstva i metoda ADO.NET objekata i to: DataReader, DataAdapter, DataSet, DataTable i DataView objekta.
•
Rad sa relacionim bazama je poglavlje gde se susrećemo sa DataRelation objektom.
•
Izvršavanje diskonektovanih operacija korišćenjem wizard-a – upoznajemo se sa tipiziranim i netipiziranim DataSet-ovima.
•
Povezivanje podataka u windows obrascima. Prikazana je tehnika u kojoj se podaci iz baze podataka koriste za popunjavanje kontrola na windows ili web formi uz minimalni napor od strane programera.
•
DataGridView kontrola – prikazane su osobine i mogućmosti ove kontrole.
•
Vodič za izradu praktičnih primera. Ovo je poslednje poglavlje i predstavlja samu srž diplomskog rada, tj obuhvata vodič za kreiranje Windows aplikacija koje u svojoj strukturi sadrže ADO.NET klase.
ADO.NET
Strana 14
1. Uvod u ADO.NET 1.1 ADO.NET ADO.NET je skup klasa za rad sa podacima. Snabdevači podataka su klase koje obezbeđuju mogućnost konektovanja na izvor podataka. Osnovni snabdevači podataka su SQL Server snabdevači podataka i OLE DB snabdevači podataka. Pri radu u ADO.NET okruženju koriste se prostori imena System.Data, System.Data.SqlClient, System.Data.OleDb, System.Data. SqlTypes, System.Xml.
1.2 Konektovani scenario U ADO.NET-u postoje dva osnovna načina rada: konektovani i diskonektovani. Kod konektovanog scenarija resursi se uzimaju sa servera sve dok se konekcija ne zatvori. Korisnik je konstantno povezan na izvor podataka. Prednost konektovanog scenarija je da su podaci uvek ažurni, konkuretni pristup resursima servera se lakše kontroliše. Nedostatak konektovanog rada je da mora da postoji konstantna mrežna konekcija, kao i mala skalabilnost aplikacije. 1.2.1 Korišćenje ADO.NET klasa u konektovanom scenariju U nastavku su prikazane osnovne klase koje se koriste u konektovanom scenariju. Redosled izvršavanja operacija pri radu u konektovanom scenariju je: otvaranje konekcije, izvršavanje komande, obrada zapisa u reader-u, zatvaranje reader-a i zatvaranje konekcije.
Slika 1: Osnovne klase ADO.NET
Strana 15
1.2.2 Prostori imena i nazivi klasa Da bi se koristio SQL Server .NET snabdevač podataka potrebno je uključiti prostor imena System.Data.SqlClient. U ovom prostoru imena klase počinju sa prefiksom Sql, npr. SqlConnection. Da bi se koristio OLE DB .NET snabdevač mora se uključiti prostor imena System.Data.OleDb prostor imena. Klase počinju sa prefiksom OleDb, npr. OleDbConnection.
1.2.3 Klase konektovanog scenarija Klasa XxxConnection (Xxx označava odgovarajući prefiks npr Sql) omogućava uspostavljenje konekcije na odgovarajući izvor podataka. Klasa XxxCommand izvršava SQL komandu nad odgovarajućim izvorom podataka. Klasa XxxDataReader služi za čitanje podataka iz odgovarajućeg izvora podataka.
1.3 Diskonektovani scenario U diskonektovanom scenariju podskup podataka iz baze podataka se kopira na lokalnom računaru. Dok se korisnik nalazi u diskonektovanom radu ostali korisnici mogu da koriste konekciju. Diskonektovani rad povećava skalabilnost aplikacije. Podaci koji predstavljaju lokalnu kopiju dela baze podataka nisu uvek ažurni. Kada se podacima iz lokalne kopije podataka ažurira baza može doći do konflikta.
1.3.1 Korišćenje ADO.NET klasa u diskonektovanom scenariju U nastavku su prikazane osnovne klase koje se koriste u diskonektovanom scenariju. Redosled izvršavanja operacija pri radu u diskonektovanom scenariju je: otvaranje konekcije, punjenje DataSet objekta podacima iz baze, zatvaranje konekcije, obrada podataka u DataSet-u, ponovo otvaranje konekcije, ažuriranje baze podataka podacima iz DataSet-a, zatvaranje konekcije.
ADO.NET
Strana 16
Slika 2: Korišćenje ADO.NET klasa u diskonektovanom scenariju
1.3.2 Klase konektovanog scenarija Klasa XxxDataAdapter klasa koristi Connection, Command i DataReader klase da bi popunila DataSet. XxxConnection objekat uspostavlja konekciju sa specificiranim izvorom podataka. XxxCommand objekat izvršava komandu nad odgovarajućim izvorom podataka. XxxDataReader čita podatke iz izvora podataka.
ADO.NET
Strana 17
2. Uspostavljanje konekcije sa bazom podataka U nastavku teksta su prikazane tehnologije za pristup bazi podataka hronološkim redom.
2.1 ODBC ODBC (Open Database Connectivity) je prva tehnologija za pristup bazi podataka razvijena od strane Microsofta. Obezbenuje C/C++ API (aplikacioni programski interfejs) niskog nivoa za pristup podacima iz baze. Teška je komunikacija sa nerelacionim izvorima podataka.
Slika 3: ODBC (Open Database Connectivity)
2.2 DAO DAO (Data Access Objects) je skup COM (Component Object Model) interfejsa za pristup bazi podataka. DAO je jednostavniji za korišćenje nego ODBC API. Za pristup bazi koja nije Access DAO interno koristi ODBC kao što je to prikazano na slici. Na taj način se uvodi jedan dodatni sloj za pristup ODBC izvoru podataka.
Slika 4: DAO (Data Access Objects)
ADO.NET
Strana 18
2.3 OLE-DB OLE-DB(Object Linking and Embedding Database) tehnologija omogućava pristup kako relacionim tako i nerelacionim izvorima podataka. Da bi se koristila ova tehnologijapotrebno je instalirati OLE-DB snabdevač podataka (data provider) koga obezbenuje proizvonač baze podataka.
Slika 5: OLE-DB (Object Linking and Embedding Database)
2.4 ADO i ADO.NET ADO je skup ActiveX komponenti koje obezbenuju objektno orijentisani pristup ka OLEDB. ADO se može shvatiti kao COM omotač oko OLE DB-a. ADO se može koristiti sa bilo kojim programskim jezikom koji podržava COM. ADO.NET je nastao razvojem ADO-a i koristi sve prednosti .NET okruženja.
2.5 .NET snabdevači podataka (Data Providers) .NET snabdevač podataka je skup klasa koje se koriste za konektovanje na izvor podataka. Unutar .NET Framework-a nalaze se SQL Server .NET snabdevač podataka i OLE DB.NET snabdevač podataka. SQL Server .NET snabdevač podataka koristi Tabular Data Stream (TDS) protokol za slanje zahteva i primanje odgovora od SQL Server-a. Ima visoke performanse jer je protokol TDS veoma brz jer pristupa SQL Server-u direktno bez OLE DB ili ODBC sloja. Klase SQL Server .NET snabdevača podataka nalaze se u prostoru imena System.Data.SqlClient. Ovaj snabdevač podataka se preporučuje za sve aplikacije koje rade sa SQL Server 7 verzijom ili više.
ADO.NET
Strana 19
2.6 OLE DB snabdevači podataka On komunicira sa izvorom podataka sa OLE DB provajderom specifičnim za taj izvor podataka. Preporučuje se korišćenje ovog snabdevača podataka za aplikacije koje komuniciraju sa Accessom. Klase ovog snabdevača podataka nalaze se u prostoru imena System.Data.OleDb.
2.7 ODBC .NET snabdevač podataka Isporučuje se uz .NET Framework 1.1. Drajveri koji su kompatibilni sa ODBC.NET snabdevačem podataka su: Microsoft SQL Server ODBC Driver, Microsoft ODBC Driver for Oracle, Microsoft Access (Jet) ODBC Driver. Klase ovog snabdevača podataka nalaze se u prostoru imena System.Data.Odbc. Ovi snabdevači podataka se koriste ako ne postoje neki drugi .NET snabdevač ili ODBC snabdevač.
2.8 Konekcije Pre bilo kakvog rada sa bazom podataka potrebno je kreirati a zatim otvoriti konekciju. U ADO.NET-u se kreira objekat klase Connection. Klasa System.Data.SqlClient.SqlConnection omogućava kreiranje konekcije na SQL Server bazu podataka. Klasa System.Data.OleDb.OleDbConnection omogućava kreiranje konekcije na svaki izvor podataka sa pridruženim OLE DB provajderom.
2.9 Connection objekat Svaki Connection objekat implementira System.Data.IDbConnection interfejs. Najčešće korišćene metode ovog interfejsa su Close( ) i Open( ) kao i property ConnectionString.
2.10 Svojstva interfejsa IdbConnection U nastavku je dat tabelarni prikaz svojstava interfejsa IDbConnection. Svaki objekat implementira tj. realizuje metode ovog interfejsa.
ADO.NET
Strana 20
Member ConnectionString
ConnectionTimeout
Database
State
Description A string with name-value pairs of connection settings. These settings often include information such as the user to log in and the location of the database server. This is the only writeable property. The time to wait for a connection to open before failing with a providerspecific exception(such as SqlException or OleDbException). The default is15 second; 0 waits indefinitely. This valu must be set trought the connection string; the property is read-only. The name of the database to use once the connection is open. This can be set in the connection string and changed with Changedatabase( ) method. Oracle databse don’t support this property. A bitwise connection of values from the ConnectionState enumeration. Currently, only Open and Closed are supported, and information isn’t provide about whether the connection is currently retrievingdata or executing a query. Tabela 1: Svojstva interfejsa IdbConnection
2.11 Metode interfejsa IdbConnection U nastavku su prikazane metode IDbConnection interfejsa. Member
Description
BeginTransaction( )
Programmatically starts a database transaction.
Changedatabase( )
Sets a new database to be used for subsequent operations. Alternatively, you can execute the SQL USE command with SQL server. Oracle databases don’t support this method.
CreateCommand( )
Returns a provider-specific IdbCommand object that is set to use this connection. This method is primarly useful when writing provideragnostic code.
Open( ) and Close( )
Attempts to connect to or disconnect from the data source. Tabela 2: metode IDbConnection interfejsa
2.12 SQL Server – ConnectionString
ADO.NET
Strana 21
Konekcija na SQL Server bazu podataka kreira se instanciranjem klase SqlConnection. Kreiranje SqlConnection objekta može se izvršiti pozivom podrazumevanog konstruktura. Zatim se preko svojstva ConnectionString definišu parametri konekcije koji se pišu u obliku stringa. Drugi način kreiranja SqlConnection objekta je da se konstruktoru ove klase prosledi string koji opisuje konekciju na SQL server bazu podataka. Konekcija na SQL server zavisi od tipa autentifikacije. U nastavku je prikazano kreiranje konekcionog stringa za SQL server autentifikaciju. Konekcioni string ima parametre DataSource koji predstavlja ime SQL Servera sa kojim se radi (npr. localhost za lokalni SQL Server), Initial Catalog odrenuje bazu podataka na SQL Serveru sa kojom se radi, user id predstavlja korisničko ime na SQL serveru a password predstavlja šifru tog korisnika. Pri kreiranju konekcionog stringa atributi se razdvajaju znakom “;”. SqlConnection con = new SqlConnection(); con.ConnectionString = "..."; SqlConnection con = new SqlConnection("..."); //SQL Server autentifikacija SqlConnection con = new SqlConnection(); string konekcioniString = "Data Source=localhost;" + "Initial Catalog=Northwind;user id=userid;password=password "); con .ConnectionString = konekcioniString;
2.13 Konekcija kod Windows autentifikacije U slučaju windows autentifikacije korisnik se ne mora prijavljivati na SQL Server već je dovoljno da bude korisnik domena na kome SQL server radi. Zbog toga korisnik koji ima windows nalog na domenu može pristupiti SQL Serveru koristeći izraz Integrated Security=SSPI umesto specificiranja korisničkog imena i šifre. SqlConnection con = new SqlConnection(); string konekcioniString = "Data Source=localhost;" + "Initial Catalog=Northwind;Integrated Security=SSPI"); con.ConnectionString = konekcioniString;
2.14 OLE DB konekcija Za izvor podataka koji nije SQL Server u konekcionom stringu se mora navesti parametar Provider. Za pristup Access bazi podataka može se koristiti provajder Microsoft.Jet.OLEDB.4.0. Na slajdu je dat primer definisanja provajdera za konektovanje na SQL Server verziju 6.5 i Oracle bazu podataka. OleDbConnection con = new OleDbConnection(); string konekcioniString = "Data Source= c:\Nortwdind.mdb;" + "Provider=Microsoft.Jet.OLEDB.4.0"); ADO.NET
Strana 22
SQL Server 6.5 Provider=SQLOLEDB;Data Source=London;Initial Catalog=pubs;User ID=sa;Password=2389; Oracle Server: Provider=MSDAORA;Data Source=ORACLE8I7; User ID=OLEDB;Password=OLEDB;
2.14.1 Čuvanje konekcionog stringa u konfiguracionom fajlu Naziv konekcije i vrednost konekcionog stringa se može čuvati u konfiguracionom fajlu. Konfiguracioni fajl se nalazi u bin folderu gde se nalazi i exe fajl aplikacije. Ime konfiguracionog fajla se kreira tako što se na puno ime exe fajla uključujući i ekstenziju dodaje ekstenzija config. Ovaj način čuvanja parametara konekcije je moguć kod konzolnih i web aplikacija, stim što se kod web aplikacija radi o tzv. web.config fajlu. U nastavku je prikazano korišćenje konfiguracionog fajla za čuvanje parametara konekcije. U config fajl se dodaje ključ konekcioniString i njemu pridružuje vrednost konekcionog stringa. Da bi se koristio konfiguracioni fajl potrebno je uključiti prostor imena System.Configuration i onda pročitati vrednost ključa: ConfigurationSettings.AppSettings["konekcioniString"]).
2.15 Konekcije i obrada izuzetaka Preporučuje se da se operacije nad bazom podataka koje mogu da dovedu do greške u programu pišu unutar try bloka. Unutar try bloka vrši se i otvaranje konekcije pozivom metode Open objekta klase SqlConnection. Samo kreiranje konekcije trebalo bi da bude izvan try bloka jer bi u protivnom ograničili oblast važenja ovog objekta. Ukoliko done do izuzetaka oni su objekti klase SqlConnection. Poželjno je i definisanje finally bloka u kojem će se vršiti zatvaranje konekcije bez obzira da li je pri izvršavanju sql komandi došlo do grešaka ili nije.
ADO.NET
Strana 23
try { con.Open(); // (Izvrsavanje ADO.NET komandi) } catch (SqlException err) { Console.WriteLine(err.ToString()); } finally { con.Close(); }
2.16 Connection Pooling Kada se neka konekcija zatvori ona se stavlja u konekcioni bazen. Kada se pozove ponovo Open metoda provajder prvo pretražuje bazen i ako konekcioni objekat ne postoji u bazenu kreira novi, ako postoji koristi ga. Definiše se maksimalni broj konekcija u bazenu. Definiše se i Connection Lifetime što odrenuje dužinu života konekcije u bazenu.
2.17 Događaji konekcije Objekat SqlConnection ima doganaj StateChange koji se trigeruje kada konekcija menja stanje iz otvorenog u zatvoreno i obrnuto. Trenutno stanje konekcije se može iščitati korišćenjem propertija CurrentState, a prethodno stanje konekcije se iščitava korišćenjem propertija OriginalState. Ukoliko se pokuša da se ponovo otvori već otvorena konekcija generiše se izuzetak. private void cnNorthwind_StateChange(object sender, System.Data.StateChangeEventArgs e) { MessageBox.Show("Tekuce stanje: " + e.CurrentState.ToString() + " Prethodno stanje: " + e.OriginalState.ToString()); }
ADO.NET
Strana 24
3. Rad u konektovanom okruženju 3.1 Objekat Command Command objekat dozvoljava direktan pristup podacima u bazi u konektovanom okruženju. Ovaj objekat sadrži referencu na SQL komandu ili uskladištenu proceduru koje se mogu izvršavati direktno. Objekat Command implementira IDbCommand interfejs.Ako se kao snabdevač podataka izabere SQL Server .NET snabdevač onda se odgovarajući komandni objekat dobija instanciranjem klase SqlCommand. Ako se kao snabdevač podataka odabere OLE DB.NET snabdevač podataka onda se komandni objekat dobija instanciranjem klase OleDbCommand. Koristeći odgovarajući Comand objekat moguće je izvršavati Select, Insert, Update i Delete naredbe nad elementima baze podataka.
3.2 Svojstva interfejsa IdbCommand Svojstvo CommandText uključuje tekst SQL komande ili naziv uskladištene procedure koje treba izvršiti. Svojstvo CommandType specificira o kakvom se tipu komande radi tj. da li je to Text odnosno napisana SQL komanda ili je to StoredProcedure odnosno uskladištena procedura. Svojstvo Connection ukazaje na Connection objekat koji se koristi za komuniciranje sa bazom podataka. Svaki komandni objekat može imati nula ili više parametara što se specificira svojstvom Parameters.
3.3 Metode interfejsa IdbCommand Metoda ExecuteScalar izvršava komandu koja vraća skalarnu vrednost. Metoda ExecuteReader izvršava komandu koja vraća skup zapisa iz baze. Metoda ExecuteNonQuery izvršava komandu koja ažurira bazu podataka ili menja strukturu baze podataka. Ovde se pod ažuriranjem podrazumeva i ubacivanje i brisanje podataka iz baze. 3.3.1 SqlCommand konstruktor – I U nastavku je prikazano instanciranje SqlComand objekta korišćenjem podrazumevanog i jednoargumentnog konstruktora. Kada se za kreiranje komandnog objekta koristi podrazumevani konstruktor, tada se mora specificirati svojstvo CommandText koje odrenuje komandu koju će komandni objekat predstavljati i svojstvo Connection koje specificira odgovarajući konekcioni objekat kojim sepristupa bazi podataka. Svojstvo CommandType je Text što znači da se radi o SQL naredbi a ne o proceduri. Ako se prilikom instanciranja objekta Command specificira text ADO.NET
Strana 25
komande koji se proslenuje kao string konstruktoru tada je potrebno samo specificirati odgovarajući Connection objekat pomoću koga se uspostavlja konekcija. SqlCommand myCommand = new SqlCommand(); myCommand.CommandText = "SELECT * FROM Categories ORDER BY CategoryID"; myCommand.Connection = new SqlConnection(myConnectString); myCommand.CommandType = CommandType.Text; string mySelectQuery = "SELECT * FROM Categories ORDER BY CategoryID"; SqlCommand myCommand = new SqlCommand(mySelectQuery); myCommand.Connection = new SqlConnection(myConnectString); myCommand.CommandType = CommandType.Text;
3.3.2 SqlCommand konstruktor – II SqlCommand objekat se može instancirati korišćenjem dvoargumentnog konstruktora. Prvi parametar konstruktora predstavlja tekst sql komande ili naziv procedure sa kojom se radi. Drugi parametar je odgovarajući SqlConnection objekat pomoću koga se vrši konekcija na bazu podataka. string mySelectQuery="SELECT * FROM Categories ORDER BY CategoryID"; string myConnectString = "Integrated Security=SSPI;database=northwind;server=mySQLServer"; SqlConnection myConnection = new SqlConnection(myConnectString); SqlCommand myCommand = new SqlCommand(mySelectQuery,myConnection); myCommand.CommandType = CommandType.Text;
3.3.3 Izvršavanje komande koja vraća jednu vrednost Najpre se definiše konekcioni string koji služi za definisanje SqlConnection objekta i string označen sa SQL koji predstavlja tekst SQL komande koju treba izvršiti nad datim izvorom podataka. Zatim se instancira SqlCommand objekat tako što se poziva konstruktor koji ima dva parametra i proslenuju mu se tekst SQL komande i odgovarajući SqlConnection objekat. Najpre se otvara konekcija poyivom Open metode. Poziva se metoda ExecuteScalar SqlCommand objekta koja vraća odgovarajuću sklarnu vrednost boksovanu u object tip. Zato se mora izvršiti anboksovanje tj. kastovanje tipa object u tip int. Na kraju se konekcija zatvara. string connectionString = "Data Source=localhost;" + "Initial Catalog=Northwind;Integrated Security=SSPI"; string SQL = "SELECT COUNT(*) FROM Orders WHERE " + "OrderDate >= '1996-01-01' AND OrderDate < '1997-01-01'"; SqlConnection con = new SqlConnection(connectionString); ADO.NET
Strana 26
SqlCommand cmd = new SqlCommand(SQL, con); // Izvrsavanje komandi con.Open(); int result = (int)cmd.ExecuteScalar(); con.Close(); // Prikazi rezultat operacije Console.WriteLine(result.ToString() + " vrsta u 1996"); Console.ReadLine();
3.3.4 Ažuriranje baze podataka Za izvršavanje Insert, Update, Delete komandi koristi se ExecuteNonQuery metoda SqlCommand objekta. Ova metoda vraća celobrojnu vrednost koja predstavlja broj vrsta u tabelama baze podataka na koje je ažuriranje uticalo.Procedura kreiranja odgovarajuće konekcije i komandnog objekta je ista kao i u prethodnom nastavku. To se odnosi i na otvaranje i zatvaranje konekcije. string connectionString = "Data Source=localhost;" + "Initial Catalog=Northwind;Integrated Security=SSPI"; string SQL = "UPDATE Categories SET CategoryName='Beverages'"+"WHERE CategoryID=1"; // Kreiranje konekcije i objekta command SqlConnection con = new SqlConnection(connectionString); SqlCommand cmd = new SqlCommand(SQL, con); // Izvrsi komandu con.Open(); int rowsAffected = cmd.ExecuteNonQuery(); // INSERT, UPDATE, DELETE con.Close(); // Prikazi rezultat komende Console.WriteLine(rowsAffected.ToString() + " vrsta promenjeno"); Console.ReadLine();
ADO.NET
Strana 27
4. Rad sa parametarskim upitima u konektovanom okruženju 4.1 Parametri komande SQL komande i uskladištene procedure mogu imati ulazne i izlazne parametre. Uskladištene procedure mogu imati i povratne vrednosti. Objekti klase SqlCommand ili OleDbCommand imaju kolekciju Parameters. Ova kolekcija sadrži skup SqlParameter ili OleDbParameter objekata koji predstavljaju ulazne ili izlazne parametre komande. Pre izvršavanje komande mora se dodeliti vrednost svakom ulaznom parametru. U nastavku je najpre instanciran objekat klase SqlCommand tako što mu je proslenen tekst komenade i objekat SqlConnection.Zatim je instanciran objekat klase SqlParameter na način predstavljen na slajdu. Kada se instancira parametar njegovo ime mora počinjati sa znakom @ i mora se specificirati tip vrednosti parametra i u zavisnosti od tipa prametra odgovarajuća dužina (npr SqlDbType.VarChar, 80). Svakom parametru se mora dodeliti vrednost korišćenjem svojstva Value. Instancirani parametar se dodaje u Parameters kolekciju SqlCommand objekta korišćenjem metode Add. U nastavku je prikazan i način čitanja vrednosti parametara. Parametru se pristupa ili na osnovu njegove pozicije u kolekciji koja je bazirana na indeksu nula ili na osnovu njegovog imena. SqlCommand cmd = new SqlCommand(commandText, con); SqlParameter param = new SqlParameter("@Description", SqlDbType.VarChar, 80); param.Value = "This is the description"; cmd.Add(param); // Uzmi param = // Uzmi param =
prvi parametar cmd.Parameters[0]; parametar sa imenom "@Description". cmd.Parameters["@Description"];
4.1.1 Primer parametarskog upita U nastavku je definisana Update komanda koja ima dva ulazna parametra. Prvi parametar je tip NVarChar dužine 15 i nazvan je @CategoryName. Drugi parametar je tipa Int i nazvan je @CategoryID. Praksa je da nazivi parametar odgovarjau odgovarajućim atributima u bazi podataka stim što se dodaje prefiks @. Obično se pri setovanju vrednosti parametar vrši iščitavanje odgovarjućih tekst boksova u koje je korisnik uneo podatke. Na taj način se izvršava parametarski upit a vrednosti parametara definiše korisnik.
ADO.NET
Strana 28
string connectionString = "Data Source=localhost;" + "Initial Catalog=Northwind;Integrated Security=SSPI"; string SQL = "UPDATE Categories SET CategoryName=@CategoryName " + "WHERE CategoryID=@CategoryID"; SqlConnection con = new SqlConnection(connectionString); SqlCommand cmd = new SqlCommand(SQL, con); SqlParameter param1 = new SqlParameter("@CategoryName",SqlDbType.NVarChar,15); cmd.Parameters.Add(param1); param1.Value = "Beverages"; SqlParameter param2 = new SqlParameter("@CategoryID",SqlDbType.Int); cmd.Parameters.Add(param2); param2.Value = 2; // Izvrsi komandu con.Open(); int rowsAffected = cmd.ExecuteNonQuery(); con.Close(); // Prikazi rezultate Console.WriteLine(rowsAffected.ToString() + " row(s) affected"); Console.ReadLine();
4.2 Kreiranje uskladištenih procedura U nastavku je prikazano kreiranje uskladištene procedure UpdateCategory. Uskladištena procedura je skup SQL komandi koje se zajedno parsiraju. Uskladištene procedure se čuvaju na database serveru. Prikazana uskladištena procedura ima dva ulazna parametra. CREATE PROCEDURE UpdateCategory ( @CategoryID int, @CategoryName nvarchar(15) ) AS UPDATE Categories SET CategoryName=@CategoryName WHERE CategoryID=@CategoryID
4.3 Izvšavanje parametarskog upita korišćenjem uskladištene procedure Kada se kao SqlCommand objekat koristi odgovarajuća uskladištena procedura to se mora naznačiti korišćenjem svojstva CommandType. Vrednost ovog svojstva treba da bude CommandType.StoredProcedure. Svojstvo CommandText objekta SqlCommand je naziv uskladištene procedure. Sada se Command objektu dodaju ulazni parametri koji odgovaraju ulaznim parametrima uskladištene procedure. ADO.NET
Strana 29
string connectionString = "Data Source=localhost;" + "Initial Catalog=Northwind;Integrated Security=SSPI"; string SQL = "UpdateCategory"; //Kreiraj ADO.NET objekte SqlConnection con = new SqlConnection(connectionString); SqlCommand cmd = new SqlCommand(SQL, con); cmd.CommandType = CommandType.StoredProcedure; SqlParameter param; param = cmd.Parameters.Add("@CategoryName", SqlDbType.NVarChar, 15); param.Value = "Beverages"; param = cmd.Parameters.Add("@CategoryID", SqlDbType.Int); param.Value = 1; // Izvrsi komandu con.Open(); int rowsAffected = cmd.ExecuteNonQuery(); con.Close(); // Prikazi rezultate operacije Console.WriteLine(rowsAffected.ToString() + " vrsta promenjeno"); Console.ReadLine();
4.4 Uskladištene procedure sa izlaznim parametrima U nastavku je prikazana procedura koja pored tri ulazna parametra ima i jedan izlazni parametar označen sa @CustomerID. Za označavanje izlaznih parametara koristi se ključna reč OUTPUT. Pošto je kolona CustomerID kolona identiteta (IDENTITY,autoincrement ili autonumbering) pri svakom ubacivanju podataka u tabelu vrednost atributa CustomerID se inkrementira a ta vrednost se može pročitati iščitavanjem sistemske promenljive @@Identity. Vrednost ove promenljive se dodeljuje izlaznom parametru uskladištene procedure. CREATE Procedure CustomerAdd ( @FullName nvarchar(50), @Email nvarchar(50), @Password nvarchar(50), @CustomerID int OUTPUT ) AS INSERT INTO Customers1 ( FullName, EMail, Password ) VALUES ( @FullName, @Email, @Password ) SELECT @CustomerID = @@Identity GO
4.5 Definisanje izlaznih parametara ADO.NET
Strana 30
U nastavku je prikazan primer definisanja izlaznog parametra odgovarajućeg SqlCommand objekta. U Parameters kolekciju SqlCommand objekta se dodaju najpre ulazni parametri koji odgovaraju ulaznim parametrima uskladištene procedure. Kao što se vidi nije neophodno pozivati konstruktor SqlParametar klase za kreiranje parametara već se direktno u Parametars kolelciju pomoću metode Add dodaje parametar tako što se specificira najpre njegov naziv a zatim i tip podatak koji on predstavlja. Izlazni parametar označen sa @CustomerID se kreira na potpuno isti način kao i ulazni stim što se za odgovarajući SqlParametar objekat mora postaviti svojstvo Direction na vrednost ParameterDirection.Output. string connectionString = "Data Source=localhost;" + "Initial Catalog=Northwind;Integrated Security=SSPI"; string procedure = "CustomerAdd"; SqlConnection con = new SqlConnection(connectionString); SqlCommand cmd = new SqlCommand(procedure, con); // Konfigurisi komandu i dodaj ulazne parametre cmd.CommandType = CommandType.StoredProcedure; SqlParameter param; param = cmd.Parameters.Add("@FullName", SqlDbType.NVarChar, 50); param.Value = "John Smith"; param = cmd.Parameters.Add("@Email", SqlDbType.NVarChar, 50); param.Value = "
[email protected]"; param = cmd.Parameters.Add("@Password", SqlDbType.NVarChar, 50); param.Value = "opensesame"; // Dodaj izlazni parametar param = cmd.Parameters.Add("@CustomerID", SqlDbType.Int); param.Direction = ParameterDirection.Output; // Izvrsi komandu con.Open(); cmd.ExecuteNonQuery(); con.Close(); Console.WriteLine("Novi korisnik ima ID " + param.Value); Console.ReadLine(); //Povratna vrednost uskladištene procedure
Osim ulaznih i izlaznih parametara uskladištena procedura može imati i povratnu vrednost. Ključna reč Return predstavlja bezuslovni izlazak iz uskladištene procedure. Povratna vrednost uskladištene procedure je 0 ukoliko je uskladištena procedura uspešno izvršena. Korisnički definisane povratne vrednosti imaju prednost u odnosu na SQL Serverove sistemski definisane povratne vrednost. U primeru u nastavku povratna vrednost uskladištene procedure je ID poslednje ubačene vrste u tabeli. ALTER Procedure CustomerAdd ( @FullName nvarchar(50), @Email nvarchar(50), ADO.NET
Strana 31
@Password nvarchar(50), ) AS INSERT INTO Customers ( FullName, EMailAddress, Password ) VALUES ( @FullName, @Email, @Password ) RETURN @@Identity GO
4.6 Definisanje povratne vrednosti Definisanje parametra koji predstavlja povratnu vrednost uskladištene procedure je slično definisanju izlaznih parametara. U ovom slučaju se za svojstvo Direction odgovarajućeg objekta klase Parameters setuje vrednost ParameterDirection.ReturnValue. Povratna vrednost se može pročitati iz odgovarajućeg Command objekta na sledeći način: cmd.Parameters ["@RETURN_VALUE"].Value. string connectionString = "Data Source=localhost;" + "Initial Catalog=Northwind;Integrated Security=SSPI"; string procedure = "CustomerAdd"; SqlConnection con = new SqlConnection(connectionString); SqlCommand cmd = new SqlCommand(procedure, con); cmd.CommandType = CommandType.StoredProcedure; SqlParameter param; // Dodaj parametar koji predstavlja povratnu vrednost param = cmd.Parameters.Add("@CustomerID", SqlDbType.Int); param.Direction = ParameterDirection.ReturnValue; // Dodaj ulazne parametre param = cmd.Parameters.Add("@FullName", SqlDbType.NVarChar, 50); param.Value = "John Smith"; param = cmd.Parameters.Add("@Email", SqlDbType.NVarChar, 50); param.Value = "
[email protected]"; param = cmd.Parameters.Add("@Password", SqlDbType.NVarChar, 50); param.Value = "opensesame";
ADO.NET
Strana 32
// izvrsi komandu con.Open(); cmd.ExecuteNonQuery(); con.Close(); param = cmd.Parameters["@CustomerID"]; Console.WriteLine("ID novog korisnika je " + param.Value); Console.ReadLine();
4.7 Izvođenje parametara Ukoliko uskladištena procedura radi samo sa jednom tabelom moguće je umesto kreiranja parametara izvršiti njihovo iščitavanje iz baze podataka. To se radi korišćenjem klase SqlCommandBuilder i njene metode DeriveParameters. U kolekciji parametara kreiranoj na ovaj način na prvom mestu se nalazi povratna vrednost. U nastavku je najpre izvršeno izvonenje parametara, zatim je ulaznim parametrima dodeljena vrednost, izvršena je uskladištena procedura i pročitana je povratna vrednost uskladištene procedure. Treba napomenuti da izvonenje parametara usporava izvršavanje procedure jer je neophodna jedna komunikacija sa bazom u cilju iščitavanja parametara.
SqlConnection con = new SqlConnection(connectionString); SqlCommand cmd = new SqlCommand(procedure, con); cmd.CommandType = CommandType.StoredProcedure; con.Open(); SqlCommandBuilder.DeriveParameters(cmd); cmd.Parameters[1].Value = "Faria MacDonald"; cmd.Parameters[2].Value = "
[email protected]"; cmd.Parameters[3].Value = "opensesame"; cmd.ExecuteNonQuery(); con.Close(); Console.WriteLine("Novi korisnik ima ID: " + cmd.Parameters["@RETURN_VALUE"].Value); Console.ReadLine();
ADO.NET
Strana 33
5. Objekat DataReader 5.1 DataReader DataReader je brz (read-only, forward-only) kursor koji se pomera kroz skup zapisa. Kada se izvršava SQL komanda koja vraća skup zapisa koristi se objekat DataReader da bi se prošlo kroz zapise. Kada se pozove metoda ExecuteReader objecta SqlCommand vraća se objekat klase DataReader. Objekat SqlCommand u ovom slučaju može predstavljati bilo koju Select naredbu ili uskladištenu proceduru koja sadrži Select naredbu. Objekat DataReader poseduje strogo tipizirani metod da pročita vrednost odrenene kolone u tekućem zapisu. Kada se skup zapisa obranuje korišćenjem objekta DataReader konekcija na bazu je zauzeta sve dok se objekat DataReader ne zatvori. 5.1.1 Svojstva i metode DataReader objekta Metoda Read čita red iz skupa rezultata. Kada se prvi put pozove ova metoda Reader se pozicionira na prvi red rezultata. Metoda vraća vrednost true ukoliko ima još redova za čitanje ili false ukoliko se Redaer pozicionirao na poslednji zapis. Item svojstvo daje vrednost kolone sa specificiranim imenom ili pozicijom. Vraćene vrednosti su u izvornom formatu i potrebno je izvršiti njihovo kastovanje da bi mogle da se koriste. Item je indekser za DataReader objekat. Ako je aReader instanca DataReader –a onda se odgovarajućoj koloni pristupa sa aReader[“ImeKolone”] ili aReader[“PozicijaKolone”]. Objekat DataReader ima strogo tipizirane metode GetDateTime, GetDouble,GetInt32 itd. Ove metode se koriste kada se znaju tipovi podataka u zapisima. GetValues metoda vraća niz objekata koji sadrže vrednosti iz tekuće vrste. Metoda IsDbNull testira da je vrednost kolone u tekućem zapis null vrednost. 5.1.2 Primer upotrebe DataReader-a Kreira se objekat DataReader pozivanjem metode ExecuteReader objekta cmd klase SqlCommand. Kao što se može uočiti objekat cmd predstavlja Select naredbu. Naredbom while (r.Read()) vrši se iteracija kroz sve redove dobijene izvršavanjem Select naredbe. Za svaki red iščitava se atribut(kolona) ContactName i dodaje u kombo boks. Na kraju se zatvara DataReader objekat i zatvara se konekcija. string SQL = "SELECT ContactName FROM Customers"; SqlConnection con = new SqlConnection(connectionString); SqlCommand cmd = new SqlCommand(SQL, con); SqlDataReader r = null;
ADO.NET
Strana 34
try { con.Open(); r = cmd.ExecuteReader(); while (r.Read()) { lstNames.Items.Add(r["ContactName"]); } } catch (Exception err) { MessageBox.Show(err.ToString()); } finally { if (r != null) r.Close(); con.Close(); }
5.1.3 Uskladištene procedure i DataReader SqlCommand objekat u nastavku predstavlja uskladištenu proceduru CustOrderHist. Izvršavanjem uskladištene procedure CustOrderHist kao rezultat se dobija skup zapisa. Zato se koristi metoda ExecuteReader SqlCommand objekta. Korišćenjem while petlje čitaju se svi zapisi iz rezultujećeg skupa zapisa. Iz svakog zapisa čitaju se kolone Total i ProductName, kreira se string koji se dobija nadovezivanjem ove dve kolone i štampa se na standardnom izlazu. string procedure = "CustOrderHist"; SqlConnection con = new SqlConnection(connectionString); SqlCommand cmd = new SqlCommand(procedure, con); SqlDataReader r = null; // Konfiguriši komandu i dodaj parametar cmd.CommandType = CommandType.StoredProcedure; SqlParameter param; param = cmd.Parameters.Add("@CustomerID", SqlDbType.NChar, 5); param.Value = "ALFKI"; // Izvrši komandu con.Open(); r = cmd.ExecuteReader(); while (r.Read()) { Console.WriteLine(r["Total"].ToString() + " of " + r["ProductName"].ToString()); }
ADO.NET
Strana 35
5.2 Procedura CustOrderHist U nastavku je dato telo procedure CustOrderHist koja je napravljena u bazi podataka Northwind na SQL Serveru da bi primer sa prethodnog slajda mogao da se isproba. Potrebno je još napraviti odgovarajuću konekciju na bazu podataka ili iz koda ili grafički. CREATE PROCEDURE CustOrderHist @CustomerID nchar(5) AS SELECT ProductName, Total=SUM(Quantity) FROM Products P, [Order Details] OD, Orders O, Customers C WHERE C.CustomerID = @CustomerID AND C.CustomerID = O.CustomerID AND O.OrderID = OD.OrderID AND OD.ProductID = P.ProductID GROUP BY ProductName GO
5.3 Metapodaci o rezultujućem skupu zapisa Metoda GetName DataReader-a vraća ime kolone sa specificiranom pozicijom. Metoda GetOrdinal vraća poziciju kolone sa specificiranim imenom. Metoda GetSchemaTablevraća objekat klase DataTable koja sadrži jednu vrstu za svaku kolonu u rezultujućem skupu zapisa, dok je kolone (atributi) te tabele bliže odrenuju.
5.4 Primer čitanja metapodataka U nastavku je prikazan primer čitanja metapodataka iz objketa DataReader. Korišćenjem metode GetSchemaTable dobijena je tabela sa metapodacima. Za svaku vrste te tabele pročitani su svi njeni atributi i prikazani na standardnom izlazu. SqlDataReader r; DataTable schema; // Izvrsi upit try { con.Open(); r = cmd.ExecuteReader(); schema = r.GetSchemaTable(); } finally ADO.NET
Strana 36
{
con.Close(); } foreach (DataRow row in schema.Rows) { foreach (DataColumn col in schema.Columns) { Console.WriteLine(col.ColumnName + " = " + row[col]); } Console.WriteLine(); }
ADO.NET
Strana 37
6. Objekat DataAdapter 6.1 Klasa DataAdapter Klasa DataAdapter predstavljamost između podataka i objekta DataSet. Objekat DataSet se koristi za čuvanje lokalne kopije podatakaiz baze. Pri čitanju podataka iz baze objekat DataAdapter prima podatke od objekta Connection i prosleđuje ih objektu DataSet. Promene na podacimaiz objekta DataSet prosleđuje nazad do objekta Connection kako bi se podaci ažurirali u samom izvoru podataka.
6.2 Rad u diskonektovanom okruženju
Slika 6: Primena pojedinih ADO.NET objekata pri radu u diskonektovanom okruženju Na slici je ilustrovana primena primena pojedinih ADO.NET objekata pri radu u diskonektovanom okruženju. Objekat DataSet sadrži jednu ili više lokalnih kopija tabela iz baze podataka. Za svaku tabelu u DataSet-u se kreira po jedan objekat DataAdapter koji kao što je već receno služi kao most između izvora podataka i njegove lokalne kopije koja se nalaz unutar objekta DataSet. DataAdapter objekat predstavlja skup SQL komandi i konekcije na bazu koja se koristi da se napuni objekat DataSet podacima iz baze i da se promenama izvršenim na objektu DataSet ažurira baza podataka. Dva osnovna DataAdapter-a koja su integrisana u Visual Studio.NET su OleDbDataAdapter i SqlDataAdapter. Izvor adaptera zavisi od baze sa kojom se radi odnosno od snabdevača podataka koji se koristi.
ADO.NET
Strana 38
6.3 Struktura DataAdaptera
Slika 7: Struktura DataAdapter-a Objekat DataAdapter sadrži SelectCommand objekat, InsertCommand objekat, UpdateCommand objekat i DeleteCommand objekat. DataAdapter takođe sadrži kolekciju TabelMapings koja služi za mapiranje naziva tabele i njihovih atributaiz baze podataka u odgovarajuć tabele u DataSet-u. Podrazumevano su nazivi kolona u bazi podataka i odgobarajućem DataTable objektu koji se nalazi u DataSet-u identični.
ADO.NET
Strana 39
Slika 8: Mapiranje tabele Table123 iz baze u tabelu Enployees u DataSet-u
6.4 Karakteristike objekta DataAdapter Koristi Command objekteda komunicira sa bazom. SelectCommand predstavlja komandu kojom se čitaju podaci iz baze. Insert, Update i Delete se koristi da se promene nad podacima u DataSet-u iskoriste za ažuriranje podataka u bazi. Pri kreiranju DataAdapter objekta mora se specificirati SELECT komanda.
6.5 Svojstva i metode DataAdaptera Svojstvo SelectCommand objekta klase SqlDataAdapter (ili OleDbDataAdapter) vraća SqlCommand objekat koji predstavlja SELECT komandu za čitanje zapisa iz baze podataka. Slično svojstva InsertCommand, UpdateCommand i DeleteCommand vraćaju odgovarajuće SqlCommand objekte koji predstavljaju INSERT, UPDATE i DELETE komandu. Metoda Fill objekta SqlDataAdapter klase se koristi za punjenje tabele unutar DataSet objekta podacima iz baze. Metoda Update se koristi za ažuriranje baze podataka promenama u DataSet objektu.
6.6 Kreiranje objekta DataAdapter Kreira se pozivom jednog od konstruktora: SqlDataAdapter () SqlDataAdapter (SqlCommand mySqlCommand) SqlDataAdapter (string selectCommandString, SqlConnection mySqlConnection) SqlDataAdapter (string selectCommandString, string connectionString) //Kreiranje Adaptera 1 ADO.NET
Strana 40
//kreira se konekcija za svaki adapter SqlDataAdapter da1 = new SqlDataAdapter(sqlSelectUpit, konekcioniString); SqlDataAdapter da2 = new SqlDataAdapter(sqlSelectUpit, mojaSqlKonekcija); SqlDataAdapter da3 = new SqlDataAdapter(komanda); SqlDataAdapter da4 = new SqlDataAdapter(); da4.SelectCommand = komanda;
Gore vidimo kreiranje objekta SqlDataAdapter korišćenjem SELECT naredbe. Ilustrovana je upotreba različitih konstruktora ove klase. U prvom slučaju konstruktoru klase SqlDataAdapter se prosleđuje SELECT upit i odgovarajući konekcioni string. U drugom slučaju konstruktoru se prosleđuje SELECT upit i odgovarajući SqlConnection objekat. U trecem slučaju je najpre kreiran SqlCommand objekat koji predstavlja SELECT naredbu a zatim je on prosleđen kao parametar konstuktoru. U četvrtom slučaju poziva se podrazumevani konstruktor, a odgovarajućem SqlDataAdapter objektu se preko svojstva SelectCommand dodeljuje odgovarajući SqlCommand objekat koji predstavlja SELECT komandu. 6.6.1 Punjenje DataSet-a SqlCommand mojaKomanda = new SqlCommand(); mojaKomanda.Connection = mojaKonekcija(); mojaKomanda.CommandText = “SELECT TOP 5 ProductID, productName, UnitPrice “ + “FROM Products “ + “ORDER BY ProductID“; SqlDataAdapter mojDataAdapter = new SqlDataAdapter(); mojDataAdapter.SelectCommand = mojaKomanda; DataSet mojDataSet = new dataSet(); mojaKonekcija.Open(); int brojVrsta = mojDataAdapter.Fill(mojDataSet, “Products“); mojaKonekcija.Close();
Iznad je prikazano kreiranje DataAdapter objekta korišćenjem SELECT komande kao i njegova upotreba za punjenje odgovarajućeg DataSet-a. Da bi se pozvala Fill metoda DataAdapter-a najpre se mora otvoriti konekcija. Posle poziva Fill metode konekcija se zatvara. Prvi parametar Fill metode je naziv DataSet-a a drugi naziv tabele koju treba kreirati u DataSet-u.
ADO.NET
Strana 41
6.6.2 Kreiranje objekta DataAdapter (2) Najpre se kreira SqlCommand objekat kome se kao parametri prosleđuju naziv uskladištene procedure i odgovarajući konekcioni string. Specificira se CommandType svojstvo objekta na vrednost CommandType.StoredProcedure. Kreira se SqlDataAdapter objekat primenom podrazumevanog konstruktora. Za SelectCommand svojstvo objekta klase SqlDataAdapter postavi se gore kreirani objekat SqlCommand. 6.6.3 Punjenje DataSet-a korišćenjem uskladištene procedure SqlCommand mojaSqlKomanda = new SqlCommand(); mojaSqlKomanda.Connection = mojaSqlKonekcija; mojaSqlKomanda.CommandType = CommandType.StoredProcedure; mojaSqlKomanda.CommandText = “CustOrderHist“; SqlParameter parametar = mojaSqlKomanda.Parameters.Add(“@CustomerID“, SqlDbType.NvarChar, 5); parametar.Value = “ALFKI“; SqlDataAdapter mojSqldataAdapter = new SqlDataAdapter(); mojSqlDataAdapter.SelectCommand = mojaSqlKomanda; DataSet mojDataSet = new DataSet(); mojaSqlKonekcija.Open(); int numberOfRows = mojSqlDataAdapter.Fill(mojdataSet, “CustOrderHist“); mojaSqlKonekcija.Close(); - - - - - - - - - DataTable myDataTable = mojDataSet.Tables(“CustOrderHist“);
Sada je SELECT komanda DataAdapter-a uskladištena procedura koja sadrži parametre. Punjenje DataSet-a je identično kao i u slučaju korišćenja SELECT komande.
ADO.NET
Strana 42
7. Objekat
DataSet
7.1 DataSet DataSet je memorijska predstava podataka, koja uključuje tabele, relacije izmenu tabela I ograničenja. Objekat DataTable se koristi da bi se predstavila tabela u DataSet-u. Konekcija sa bazom podataka nije neophodna da bi se manipulisalo sa podacima u DataSet-u. Podaci u DataSet-u se čuvaju na sličan način kao što se čuvaju u relacionoj bazi podataka. Podaci iz DataSet-a mogu se prikazati u XML formatu.
7.2 Svojstva objekta DataSet Klasa DataSet ima Tables svojstvo koje daje koekciju DataTable objekata u DataSet-u. DataSet ima svojstvo Relations koje daje kolekciju objekata DataRelation koji se koriste za opis veza izmenu tabela u DataSet-u. Objekat DataTable ima sledeće kolekcije: • • • •
Columns (kolekcija objekta DataColumn) Rows (kolekcija objekta DataRow) Constraints (kolekcija objekta Constrant) ChildRelations (kolekcija objekta DataRelation)
7.3 Kreiranje objekta DataSet DataSet ds = new DataSet(“Northwind"); DataTable dt = new DataTable("MojaTabela"); ds.Tables.Add(dt); DataColumn colCustomerID = new DataColumn(“CustomerID”, typeof(Int32)); dt.Colums.Add(colCustomerID); ili DataColumn colCustomerID =dt.Columns.Add(“CustomerID”, typeof(Int32)); colCustomersID.AllowDBNull = false; colCustomersID.Unique = true;
Gornji kod prikazuje kreiranje objekta DataSet. Ako se konstruktoru ne prosledi ime DataSet-a onda će mu biti dodeljeno podrazumevano ime NewDataSet. Zatim se instancira DataTable objekat i dodaje u kolekciju Tables DataSet objekta. Kada se prvi put kreira DataTable objekat ADO.NET
Strana 43
on nema šemu. Zato se moraju kreirati objekti klase DataColumn i dodati u Columns kolekciju objekta klase DataTable.Objekat. DataColumn se može kreirati pozivom DataColumn konstruktora kao što je to ilustrovano unutar drugog pravougaonika. Drugi način je direktno dodavanje naziva kolone i tipa podataka za kolonu u Columns kolekciju objekta DataTable kao u trećem pravougaoniku. Ako vrednosti NULL nisu dozvoljene za kolonu onda se to specificira korišćenjem svojstva AllowDBNull i njegovim setovanjem na false. Ako želimo da vrednosti u koloni imaju jedinstvene vrednosti onda se to definiše korišćenjem svojstva Unique.
7.4 Kreiranje prostog primarnog ključa myDataTable.PrimaryKey = new DataColumn[ ] { myDataTable.Columns["CustomerID"] }; Constraint pkCustomers = dtCustomers.Constraints.Add (“PK_Customers”,dtCustomers.Columns[CustomerID], true);
Za svaki objekat DataTable koji se nalazi unutar DataSet-a potrebno je definisati primarni ključ. Kada se primarni ključ sastoji samo od jednog atributa tabele radi se o prostom primarnom ključu. Svojstvu PrimaryKey objekta DataTable mora se dodeliti niz objekata klase DataColumn. U slučaju prostog ključa ovaj niz se sastoji samo od jednog člana. Drugi način kreiranja primarno ključa je korišćenje Constraints kolekcije objekta DataTable. Prvi parametar Add metode je naziv ograničenje, drugi parametar je naziv kolone koja predstavlja primarni ključ, a treći parametar mora imati vrednost true da bi se naznačilo da se radi o primarnom ključu.
7.5 Kreiranje složenog primarnog ključa dtEmployess.PrimaryKey = new DataColumn[ ] { dtEmployess.Colums[“LastName”] , dtEmployess.Colums[“LastName”] }; mojDataSet.Tables["Order Details"].Constraints.Add("PK_OrderDetails", new DataColumn[] { mojDataSet.Tables["Order Details"].Columns["OrderID"], mojDataSet.Tables["Order Details"].Columns["ProductID"] }, true);
U sledećem kodu prikazano je kreiranje složenog primarnog ključa. Složeni primarni ključ sastoji se od dva ili više atributa tabele nad kojom je definisan. Kreiranje složenog ključa je slično kreiranju prostog primarnog ključa. ADO.NET
Strana 44
7.6 Unique ograničenje public UniqueConstraint( string name, DataColumn[ ] columns, bool isPrimaryKey ); public UniqueConstraint( string name, DataColumn column ); ds.Tables[“Products”].Constraints.Add( new UniqueConstraint (“UC_ProductName”, ds.Tables[“Products”].Columns[“ProductName”]);
Ovo ograničenje označava da vrednost atributa ili grupe atributa nad kojim je definisano ovo ograničenje mora biti jedinstvena. Kreira se instanciranjem klase UniqueConstraint. U gornjem kodu su prikazana dva konstruktora ove klase. Prvi se može iskoristiti za kreiranje tzv. složenog Unique ograničenja a drugi konstruktor samo za kreiranje prostog Unique ograničenja, tj. ograničenja nad jednim atributom tabele.
7.7 Ograničenje ForeignKey public ForeignKeyConstraint( string constraintName, DataColumn parentColumn, DataColumn childColumn );
Da bi se u tabeli koja se nalazi unutar DataSet-a kreiralo ograničenje strani ključ DataSet mora imati najmanje dva tabele. Roditeljska tabela mora imati primarni ključ. U kodu je prikazan konstruktor klase ForeignKeyConstraint. Potrebno je definisati naziv ovog ograničenja, kolonu primarnog ključa u roditeljskoj tabeli i kolonu stranog ključa u tabeli potomku.
ADO.NET
Strana 45
7.8 Kreiranje ograničenja ForeignKey U sledećim kodovima su data dva načina kreiranja stranog ključa. Prvi je instanciranje klase ForeignKeyConstraint i dodavanje objekta u Constraints kolekciju: ForeignKeyConstraint mojFK = new ForeignKeyConstraint("FK_Orders_OD", mojDataSet.Tables["Orders"].Columns["OrderID"], mojDataSet.Tables["Order Details"].Columns["OrderID"] ); mojDataSet.Tables["Order Details"].Constraints.Add(mojFK);
Drugi način je direktno dodavanje stranog ključa korišćenjem metode Add kolekcije Constraint: mojDataSet.Tables["Order Details"].Constraints.Add( "FK_Pr_OD" ,mojDataSet.Tables["Products"].Columns["ProductID"], mojDataSet.Tables["Order Details"].Columns["ProductID"] );
Potrebno je definisati naziv ovog ograničenja, kolonu primarnog ključa u roditeljskoj tabeli i kolonu stranog ključa u tabeli potomku.
ADO.NET
Strana 46
8. Objekat DataTable 8.1Struktura objekta DataTable
Slika 9: Struktura objekta DataTable Objekat DataTable sadrži kolekciju DataColumnCollection koja sadrži objekte klase DataColumn koji predstavljaju odgovarajuće kolone tabele. Takone sadrži kolekciju dataRowCollection koja sadrži objekte klase DataRow (predstavljaju redove tabele) kao I kolekciju ConstraintCollection koja sadži objekte klase Constraint (predstavljaju ograničenja definisana nad tabelom).
8.2 Punjenje objekta DataTable korišćenjem DataAdaptera Objekat DataTable koji se nalazi unutar objekta DataSet se može napuniti korišćenjem Fill metode DataAdapter objekta. Metoda Fill DataAdaptera izvršava njegovu SELECT komandu. U sledećem kodu Fill metode se u DataSet-u kreira tabela Customers i puni podacima iz baze podataka: mySqlDataAdapter.SelectCommand = mySelectCommand; DataSet myDataSet = new DataSet(); mySqlConnection.Open(); int numOfRows = mySqlDataAdapter.Fill(myDataSet, "Customers"); mySqlConnection.Close();
ADO.NET
Strana 47
8.3 Punjenje DataSeta koristeći više adaptera Za punjenje DataSet-a može se koristiti više DataAdaptera. Svaki DataAdapter puni odrenenu tabelu u DataSetu. Pored DataSet-ova koji se kreiraju instanciranjem klase DataSet i koji se nazivaju netipizirani DataSet-ovi, postoje i tzv. tipizirani DataSet-ovi. Tipski DataSet-ovi se kreiraju na osnovu već postojećeg izvora podataka i pridružena im je XML šema. Tipski DataSet se može kreirati grafički u okruženju Visual Studio.NET. Najpre se kreira odgovarajući DataAdapter npr. SqlDataAdapter prevlačenjem SqlDataAdapter kontrole koja se nalazi u Data delu Toolbox-a. Na ovaj način se kreira objekat označen sa sqlDataAdapter1. Sada se klikne desnim tasterom miša na ovaj objekat i izabere se opcija Generate DataSet. Na ovaj način se DataSet objektu pridružuje xsd šema koja predstavlja xml dokument koji opisuju strukturu tabele iz koje Dataadapter čita podatke. Tipizirani DataSet je izveden iz klase DataSet pa zadržava sve osobine i metode netipiziranog DataSet-a. Kod tipiziranog DataSeta znatno je olakšan pristup njegovim članovima npr. tabelama se pristupa direktno a ne preko Tables kolekcije. Netipski DataSet // vise data adaptera pune jedan DataSet myDataAdapter.Fill(myDataSet, "Customers"); myDataAdapter1.Fill(myDataSet, "Employees");
Tipski DataSet daCustomers.Fill(dsCustOrders.Customers); daOrders.Fill(dsCustOrders.Orders);
8.4 Primer pristupa atributu kod tipiziranog i netipiziranog DataSeta // netipizirani DataRow myRow = dsNorthwind.Tables["Categories"].Rows[0]; string categoryName = (string) myRow ["CategoryName"]; // tipizirani String categoryName = dsNorthwind.Categories[0].CategoryName;
Na slajdu je prikazan način pristupa atributu CategoryName u prvoj vrsti tabele Categories za slučaj tipiziranog i netipiziraog DataSet-a.
8.5 Pronalaženje vrste u tabeli Pronalaženje konkretnog DataRow objekta u objektu DataTable sastoji se iz nekoliko koraka: • •
Korišćenjem objekta DataAdapter puni se tabela podacima. Kreira se primarni ključ za tabelu ukoliko se radi o netipiziranom DataSetu.
ADO.NET
Strana 48
•
•
Ako je DataSet tipiziran primarni ključ objekta DataTable postoji ako postoji ključ za odgovarajuću tabelu u bazi. Poziva se Find() metoda kolekcije DataRowCollection.
8.6 Pretraživanje po prostom ključu Najpre se iz DataSet-a uzme odgovarajući objekat DatTable. Definiše se primarni ključ objekta DataTable ukoliko se radi o netipiziranom DataSet-u. Svostvo Rows objekta DataTable vraća DataRowCollection kolekciju koja sadrži kolekciju objekata DataRow. Pronalazi se DataRow objekat korišćenjem Find metode DataRowCollection kolekcije čija je vrednost ključa jednaka zadatoj vrednosti. Na kraju se iščitavaju atributi te vrste.
8.7 Pretraživanje po složenom ključu Kreira se object niz čije su vrednosti jednake vrednostima atributa koji ulaze u sastav primarnog ključa. Potrebna vrsta nalazi se korišćenjem Find metode kolekcije DataRowCollection. Kada se pronane željena vrsta pristupa se iščitavanju njenih atributa.
8.8 Filtriranje i sortiranje DataRow objekata u objektu DataTable public DataRow[ ] Select( string filterExpression, string sort ); filterExpression – koje redove prikazati sort – kako sortirati
Iznad je prikazana deklaracija metode Select objekta klase DataTable. Ova metoda vraća niz objekata klase DataRow odnosno skup zapisa koji zadovoljavaju specificirani kriterijum. Ako je productDataRows naziv niza objekata DataRow koji je dobijen izvršavanjem Select naredbe objekta DataTable tada se atributi svake vste u rezultujućem skupu zapisa mogu dobiti korišćenjem dve foreach petlje: foreach (DataRow myDataRow in productDataRows) { foreach (DataColumn myDataColumn in productsDataTable.Columns) { Console.WriteLine(myDataColumn + "= " + myDataRow[myDataColumn]); } }
ADO.NET
Strana 49
8.9 Modifikovanje podataka u bazi korišćenjem DataAdaptera Potrebno je pored SELECT komande DataAdaptera (koja služi za čitanje podataka iz baze i punjenje DataSet-a), definisati i INSERT, UPDATE i DELETE komande. Promene u DataSet-u se proslenuju do baze pozivanjem Update() metode DataAdapter-a.
8.10 Definisanje insert komande DataAdaptera // INSERT KOMANDA SqlCommand myInsertCommand = mySqlConnection.CreateCommand(); myInsertCommand.CommandText = "INSERT INTO Customers(CustomerID, CompanyName, Address ) VALUES (@CustomerID, @CompanyName, @Address)" ; myInsertCommand.Parameters.Add("@CustomerID", SqlDbType.NChar,5, "CustomerID"); myInsertCommand.Parameters.Add("@CompanyName", SqlDbType.NVarChar,40, "CompanyName"); myInsertCommand.Parameters.Add("@Address", SqlDbType.NVarChar,60, "Address"); mySqlDataAdapter.InsertCommand = myInsertCommand;
Potrebno je kreirati SqlCommand objekat koji će predstavljati INSERT naredbu. Osim poziva konstruktora objekat SqlCommand je moguće kreirati i pozivom metode CreateCommand odgovarajućeg SqlConnection objekta. Uobičajeno je korišćenje parametarskog INSERT upita gde će vrednosti parametara definisati korisnik. Posle dodavanja parametara InsertCommand svojstvu objekta klase DataAdapter pridružuje gore kreirani SqlCommand objekat.
8.11 Ubacivanje zapisa u bazu podataka // Korak 1: koriscenje NewRow() metoda objekta DataTable // za kreiranje nove vrste- DataRow DataRow novaVrsta = mojaTabela.NewRow(); // Korak 2: postavi vrednosti za DataColumn objekte // za novu vrstu - DataRow novaVrsta["CustomerID"] = CustID; novaVrsta["CompanyName"] = Company; novaVrsta["Address"] = addr; // Korak 3: Pozivanje Add() metode kroz Rows property // da bi se dodao novi DataRow objekta u objekat DataTable ADO.NET
Strana 50
mojaTabela.Rows.Add(novaVrsta); // Korak 4: Koriscenje Update() metode DataAdaptera mojaKonekcija.Open(); brojVrsta = mojAdapter.Update(mojaTabela); mojaKonekcija.Close();
Poziva se NewRow() metoda objekta DataTable čime se kreira DataRow objekat koji ima istu strukturu kao i tabela. Za objekat DataRow definišu se vrednosti za atribute te vrste. Ovako ažurirani objekti DataRow se dodaju u Rows kolekciju tabele. Otvara se konekcija sa bazom podataka. Poziva se Update metoda DataAdaptera i proslenuje mu se kao parametar objekat DataTable koji je promenjen. Na ovaj način se promene nastale u DataSetu upisuju trajno u bazu podataka. Pri završenom ažuriranju potrebno je zatvoriti konekciju.
8.12 Update komanda DataAdaptera SqlCommand myUpdateCommand = mySqlConnection.CreateCommand(); myUpdateCommand.CommandText = "UPDATE Customers SET CompanyName = @NewCompanyName, Address = @NewAddress WHERE CustomerID = @OldCustomerID"; myUpdateCommand.Parameters.Add("@NewCompanyName", SqlDbType.NVarChar,40, "CompanyName"); myUpdateCommand.Parameters.Add("@NewAddress", SqlDbType.NVarChar,60, "Address"); myUpdateCommand.Parameters.Add("@OldCustomerID", SqlDbType.NChar,5, "CustomerID"); mySqlDataAdapter.UpdateCommand = myUpdateCommand;
U kodu je prikazano kreiranje Update komande DataAdaptera. Ukoliko se DataAdapter kreira grafički u okruženju Visual Studio.NET onda se INSERT, UPDATE i DELETE komanda kreira automatski.
ADO.NET
Strana 51
8.13 Ažuriranje podataka u bazi // korak 1: postavi PrimaryKey svojstvo za objekat DataTable mojaTabela.PrimaryKey = new DataColumn[] { mojaTabela.Columns["CustomerID"] }; // korak 2: koriscenjem Find() metode lociraj DataRow DataRow myEditDataRow = mojaTabela.Rows.Find(idVrste); // korak 3: promeni DataColumn vrednosti objekta DataRow myEditDataRow["CompanyName"] = kompanija; myEditDataRow["Address"] = adresa; // Korak 4: koriscenje Update() metoda za // azuriranje baze mojaKonekcija.Open(); int brojVrsta = mojAdapter.Update(mojaTabela); mojaKonekcija.Close();
Ukoliko se radi o netipiziranom DataSetu mora se najpre definisati primarni ključ DataTable objekta na osnovu koga će se vršiti pretraživanje. Korišćenjem Find metode kolekcije DataRowCollection pronalazi se DataRow objekat sa željenom vrednošću primarnog ključa. U pomenutom redu se izvrši promena željenih atributa tako što se atributu unutar reda pristupa preko imena ili indeksa. Pozove se Update metoda DataAdaptera i prosledi joj se ažurirani objekat DataTable.
8.14 Delete komanda DataAdaptera SqlCommand myDeleteCommand = mySqlConnection.CreateCommand(); myDeleteCommand.CommandText = "DELETE FROM Customers WHERE CustomerID = @OldCustomerID"; myDeleteCommand.Parameters.Add("@OldCustomerID", SqlDbType.NChar,5, "CustomerID"); mySqlDataAdapter.DeleteCommand = myDeleteCommand;
U ovom kodu je dat primer DELETE komande DataAdptera. Uobičajeno je da se pronalaženje vrste za brisanje vrši po primarnom ključu.
ADO.NET
Strana 52
8.15 Brisanje podataka u bazi // Korak 1: postavi PrimaryKey svojstvo za DataTable myDataTable.PrimaryKey = new DataColumn[] { myDataTable.Columns["CustomerID"] }; // Korak 2: koriscenje Find() metode za pronalzenje vrste DataRow myRemoveDataRow = myDataTable.Rows.Find(id); // Korak 3: koriscenje metoda Delete() za brisanje vrste try { myRemoveDataRow.Delete(); Console.WriteLine("myRemoveDataRow.RowState = " + myRemoveDataRow.RowState); // Korak 4: koriscenje Update() metode za brisanje vrste iz baze podataka mySqlConnection.Open(); int numOfRows = mySqlDataAdapter.Update(myDataTable); Console.WriteLine("brojVrsta = " + numOfRows); Console.WriteLine("myRemoveDataRow.RowState = " + myRemoveDataRow.RowState); } catch(Exception exc) { Console.WriteLine(exc.Message); } finally { mySqlConnection.Close(); }
Prvi korak je definisanje primarnog ključa objekta DataTable ukoliko se radi o netipiziranom DataSetu. Drugi korak je korišćenje Find metode kolekcije vrsta za pronalaženje vrste za specificirani ID. Treći korak je brisanje vrste unutar DataTable objekta tj. brisanje vrste iz lokalne kopije. Četvrti korak je ažuriranje izvora podataka koristeći Update metodu DataAdapter objekta kome se kao parametar proslenuje izmenjeni objekat DataTable.
ADO.NET
Strana 53
9. Objekat DataView 9.1 Kreiranje DataView objekta Objekat DataView sličan je objektu view u SQL Server-u s tim što objekat DataView prikazuje podatke iz samo jedne tabele. Sadrži podskup podataka iz objekta DataTable nad kojim je definisan. Kreira se korišćenjem konstruktora DataView tako što mu se kao ulazni parametar prosledi objekat DataTable koji se nalazi u DataSetu: DataView view = new DataView(ds.Tables["Customers"]);
Svaki objekat DataTable poseduje svojstvo DefaultView: DataView view = ds.Tables["Customers"].DefaultView;
Ovo svojstvo vraća DataView objekat nad tabelom koji se može iskoristiti za filtriranje i sortiranje podataka u tabeli.
9.2 Karakteristike objekta DataView DataView objekat omogućava filtriranje podataka korišćenjem svojstva RowFilter. Svojstvu RowFilter se pridružuje string koji odgovara WHERE klauzuli prilikom pisanja običnog SELECT upita sa filtriranjem podataka (npr. dvKorisnik.RowFilter = "Country = 'UK'"). Svojstvo Sort omogućava sortiranje podataka. Svojstvu Sort se pridružuje string koji odgovara klauzuli ORDER BY prilikom sortiranja podataka u običnom SELECT upitu. Svaka tabela ima DefaultView. Povezivanje podataka u Windows obrascima uvek se radi posredstvom odgovarajućeg view objekta iako se to ne naglašava uvek eksplicitno: dataGrid1.DataSource = ds.Tables["Customers"].DefaultView;
DataViewManager klasa predstavlja view celog DataSet-a. DataGrid je jedina Windows kontrola koja može da vrši povezivanje podataka iz celog DataSeta.
9.3 Svojstva objekta DataView Svojstvo Table služi da se postavi ili pročita odgovarajući objekta DataTable za koji je View vezan. DataRowView predstavlja view definisan za objekat DataRow. Odnosno DataRowView se može shvatiti kao red unutar DataView objekta.Metoda Find() objekta DataView nalazi vrstu
ADO.NET
Strana 54
u odgovarajućem objektu DataView sa specificiranom vrednošću atributa po kome se sortira. Metoda Find vraća indeks vrste koja odgovara traženom kriterijumu.
9.4 Primer upotrebe DataView objekta DataView dvKorisnik = new DataView(myDataSet.Tables["Customers"]); dvKorisnik.RowFilter = "Country = 'UK'"; dvKorisnik.Sort = "CustomerID ASC"; int indeksVrste = dvKorisnik.Find("ISLAT"); Console.WriteLine(dvKorisnik[indeksVrste][0]); Console.WriteLine(dvKorisnik[indeksVrste][1]); foreach (DataRowView mojDataRowView in dvKorisnik) { for (int count = 0; count < dvKorisnik.Table.Columns.Count; count++) { Console.WriteLine(mojDataRowView[count]); } Console.WriteLine(""); }
Kreiran je objekat DataView nad tabelom Customers koja se nalazi u DataSetu. DataView prikazuje samo one redove tabele Customers kod kojih atribut Country ima vrednost UK. Redovi se prikazuju sortirani po atributu CustomerID u rastućem poretku. Korišćenjem metode Find objekta DataView traži se indeks reda u objektu DataView kod koga je vrednost atributa CustomerID jednaka ISLAT. Odgovarajućem DataRowView objektu se pristupa korišćenjem izraza dvKorisnik[indeksVrste] gde je indeksVrste vrednost koju je vratila metoda Find. Prvom atributu ovog DataRowView objekta pristupa se korišćenjem izraza dvKorisnik[indeksVrste][0], drugom dvKorisnik[indeksVrste][1] itd. Broj kolona tabele nad kojom je View definisan može se dobiti korišćenjem izraza dvKorisnik.Table.Columns.Count jer svojstvo Table vraća odgovarajući DataTable objekat koji ima Column kolekciju. Broj članova kolekcije Columns se dobija korišćenjem svojstva Count a to je ujedno i broj kolona te tabele odnosno objekta DataView koji je nad njom definisan.
9.5 Metoda FindRows DataView pogled2 = new DataView(myDataSet.Tables["Customers"]); pogled2.Sort = "Country"; DataRowView[] vrste = pogled2.FindRows("Germany"); if (vrste.Length == 0) { Console.WriteLine("Nema pronadjenih vrsta."); } else { foreach (DataRowView vrsta in vrste) ADO.NET
Strana 55
{ Console.WriteLine(vrsta["CustomerID"].ToString() + " odgovara."); } }
Ova metoda vraća niz objekata DataRowView koji odgovaraju zadatoj vrednosti atributa po kome se vrši sortiranje objekta DataView. Za kretanje kroz ovaj skup DataRowView objekata može se iskoristiti foreach naredba na način predstavljen na slajdu. U primeru se štampa atribut CustomerID za sve vrste iz DataView-a koje odgovarju kriterijumu traženja.
9.6 Dodavanje DataRowView objekta u objekat DataView DataView dvKorisnik = new DataView(); dvKorisnik.Table = tabelaKorisnik; dvKorisnik.RowFilter = "Country = 'UK'"; // dodaj novi DataRowView //-------------------------------------------------DataRowView korisnikDRV = dvKorisnik.AddNew(); korisnikDRV.BeginEdit(); korisnikDRV["CustomerID"] = "J7COM"; korisnikDRV["CompanyName"] = "J7 Company"; korisnikDRV["Country"] = "UK"; Console.WriteLine("korisnikDRV.IsNew = " + korisnikDRV.IsNew); Console.WriteLine("korisnikDRV.IsEdit = " + korisnikDRV.IsEdit); korisnikDRV.EndEdit(); prikazi(dvKorisnik);
Dodavanje redova u DataTable objekat je moguće uraditi kroz DataView. To se postiže dodavanjem objekta DataRowView u objekat DataView. Pozivanjem metode AddNew objekta DataView kreira se objekat DataRowView čija je šema identična šemi odgovarajućeg DataView objekta. Objekat DataRowView ima metodu BeginEdit koja ozbačava da se objekat nalazi u režimu editovanja. Ukoliko želimo da sačuvamo promenu u DataRowView objektu na kraju editovanja pozivamo metodu EndEdit ili CancelEdit ukoliko želimo da poništimo promene.
ADO.NET
Strana 56
9.7 Editovanje DataRowView objekta koji se nalazi u DataView objektu // EDITOVANJE PRVE VRSTE dvKorisnik[0].BeginEdit(); dvKorisnik[0]["CompanyName"] = "Link group."; Console.WriteLine("dvKorisnik[0][\" CustomerID\"] = " + dvKorisnik[0]["CustomerID"]); Console.WriteLine("dvKorisnik[0][\" CompanyName\"] = " + dvKorisnik[0]["CompanyName"]); Console.WriteLine("dvKorisnik[0].IsNew = " + dvKorisnik[0].IsNew); Console.WriteLine("dvKorisnik[0].IsEdit = " + dvKorisnik[0].IsEdit); dvKorisnik[0].EndEdit(); prikazi(dvKorisnik);
Odgovarajućem DataRowView objektu koje se nalazi unutar DataView objekta pristupamo na osnovu indeksa vrste. Indeks može biti definisan ukoliko se unapred zna indeks vrste koju treba editovati ili se može naći na osnovu nekog kriterijuma koristeći metodu Find objekta DataView na već opisani način. Posle pozicioniranja na odgovarajući red pristupa se editovanju željenih atributa npr. dvKorisnik[0]["CompanyName"] ="Link group." tj. atribut CompanyName prve vrste u DataView objektu dobija novu vrednost Link group. Pre početka editovanja poziva se metoda BeginEdit a po završetku editovanja metoda EndEdit.
9.8 Brisanje DataRowView objekta dvKorisnik.Delete(1); Console.WriteLine("dvKorisnik[1].IsNew = " + dvKorisnik[1].IsNew); Console.WriteLine("dvKorisnik[1].IsEdit = " + dvKorisnik[1].IsEdit); prikazi(dvKorisnik);
Da bi se izbrisao DataRowView objekat iz objekta DataView poziva se Delete metoda objekta DataView i proslenuje joj se kao parametar indeks vrste koju treba obrisati. Indeks može biti definisan ukoliko se unapred zna indeks vrste koju treba obrisati ili se može naći na osnovu nekog kriterijuma koristeći metodu Find objekta DataView na već opisani način.
ADO.NET
Strana 57
10. Rad sa relacionim podacima 10.1 Objekat DataRelation Svaki DataSet sadrži DataRelationCollection kolekciju koja sadrži DataRelation objekte. Ovi objekti predstavljaju veze izmenu tabela u DataSetu. Kreira se pozivom DataRelation konstruktora DataRelation pri čemu je prvi parametar naziv relacije, drugi parametar je roditeljska kolona a treći parametar je kolona potomak. Kreirani DataRelation objekat je potrebno dodati u kolekcijuDataRelationCollection. Kada se kreira DataRelation objekat za roditeljsku tabelu se kreira UniqueConstraint ukoliko već nije definisano, a za child tabelu se kreira ForeignKeyConstraint ograničenje. Kod netipiziranog DataSeta takone je neophodno definisati primarne ključeve tabele. Alternativni način definisanja primarnih ključeva tabele je korišćenje svojstva MissingSchemaAction objekta klase DataAdapter koji puni Dataset objekat. Vrednost svojstva MissingSchemaAction treba da bude MissingSchemaAction.AddWithKey. Kreiranje DataRelation objekata i njihovo dodavanje u kolekciju je neophodno samo kod netipizirnih DataSetova.
10.2Primer kreiranja DataRelation objekta DataColumn roditeljskKolona = dsCategorijeProizvodi.Tables["Categories"].Columns["CategoryID"]; DataColumn childKolona = dsCategorijeProizvodi.Tables["Products"].Columns["CategoryID"]; DataRelation relacija = new DataRelation("Kategorije_Proizvoda",roditeljskKolona,childKolona); dsCategorijeProizvodi.Relations.Add(relacija);
U kodu je prikazan primer kreiranja DataRelation objekta u DataSetu. Najpre se kreiraju dva DataColumn objekta koji će predstavljati roditeljsku kolonu i kolonu potomak. Objekti DataColumn se uzimaju iščitavanjem DataColumns kolekcije objekata DataTable koji se nalaze u DataSetu. Zatim se kreiraDataRelation objekat pozivom njegovog konstruktora pri čemu se konstruktoru kao parametri proslenuju naziv relacije, roditeljska kolona, kolona potomak. Na kraju se kreirani DataRealation objekat dodaje u DataRelationCollection kolekciju DataSeta.
ADO.NET
Strana 58
10.3 Navigacija relacionih podataka foreach (DataRow parent in ds.Tables["Categories"].Rows) { // za svaku kategoriju uzmi sve proizvode koji joj // pripadaju foreach (DataRow child in parent.GetChildRows("Cat_Prod")) { // obrada proizvoda koji pripadaju selektovanoj kategoriji } }
Ideja je da se za vrstu u roditeljskoj tabeli dobiju sve vrste u tabeli potomak koje odgovaraju roditeljskoj vrsti. Na primer ako je roditeljska tabela tabela Categories koja predstavlja kategorije proizvoda potrebno je za neku od tih kategorija prikazati spisak svih proizvoda koji pripadaju toj kategoriji. To se postiže korišćenjem metode GetChildRows objekta DataRow roditeljske vrste. Kao parametar metodi treba proslediti naziv relacije izmenu roditeljske tabele i tabele potomka. Rezultat izvršavanja metode je niz objekata DataRow koji predstaljaju tražene redove u child tabeli. Roditeljska tabela se može prikazati u kontroli DataGrid i kada se klikne na neku vrstu ove tabele u drugom DataGridu se prikazuju sve vrste iz tabele potomak tj. u konkretnom slučaju svi proizodi iz selektovane kategorije. Takone treba pomenuti metode GetParentRow i GetParentRows koje služe za inverznu operaciju. Metoda GetParentRow se koristi ako izmenu parent i child tabele postoji veza 1 prema više dok se metoda GetParentRows koristi za vezu više prema više.
ADO.NET
Strana 59
11. Izvršavanje diskonektovanih operacija korišćenjem wizard 11.1 Netipizirani i tipizirani DataSetovi Kod netipiziranih DataSetova koriste se klase DataSet, DataTable, DataColumn i DataRow. Ove klase sadrže kolekcije koje vraćaju standardne objekte nezavisno od tipa podataka u DataSet-u. Npr. Columns kolekcija DataRow objekta uvek vraća objekte tipa DataColumn nezavisno od tipa podataka u tim kolonama. Kolekcija Tables objekta klase DataSet uvek prikazuje objekte tipa DataTable nezavisno od toga koja se tabela koristi. Standardna DataSet klasa koja je ugranene u .NET biblioteku predstavlja netipizirani DataSet. Visual Studio 2008 omogućava kreiranje i tzv. tipiziranih DataSetova. Tipizirani DataSetovi su klase koje su izvedene iz klase DataSet , i sadrže svojstva i metode koje omogućavaju pristup sadržajima unutar DataSeta na tipski bezbedan način (type-safe). Struktura tipskog DataSeta se predstavlja XML šemom, tj. fajlom koji ima xsd ekstenziju.
11.2 Kreiranje tipskog DataSeta korišćenjem DataSet dizajnera
Slika 10: Prozor Add New Item
ADO.NET
Strana 60
Na slici je prikazan prozor Add New Item koji se otvara desnim klikom na ikonicu projekta u Solution Exploreru. Od ponunenih šablona treba odabrati Add New DataSet čime se otvara DataSet dizajner. Potrebno je definisati ime DataSetu pri čemu je ekstenzija xsd.
11.3 Dataset Designer prozor
Slika 11: DataSet Designer prozor Vidimo prikazan prozor DataSet dizajner koji omogućava da se u dizajn modu kreira tipizirani DataSet. DataSet dizajner ima sopstvenu paletu alatki.
11.4 TableAdapter Configuration Wizard
Slika 12: TableAdapter Configuration Wizard ADO.NET
Strana 61
Prevlačenjem TableAdapter kontrole na površinu dizajnera pokreće se TableAdapter Configuration wizard. U prvom prozoru ovog wizarda se bira konekcija na bazu podataka sa kojom će DataAdapter da radi. Ukoliko željena konekcija ne postoji u ComboBox kontroli, može se kreirati nova klikom na dugme New Connection. U primeru na slici uspostavlja se konekcija sa bazom Adwenture Works. Klikom na dugme Next posle definisnja konekcije na bazu podataka prelazi se na sledeći korak wizarda.
Slika13: Biranje pristupa TableAdaptera podacima iz baze
U ovom koraku wizarda treba definisati kako TableAdapter pristupa podacima iz baze, pri čemu se može izabrati opcija da se definiše sql komanda, da se kreira nova uskladištena procedura, ili da se koristi postojeća uskladištena procedura.U primeru na slici izborom opcije Use SQL Statements odabrali smo da definišemo SQL komandu na osnovu koje će TableAdapter da pristupa podacima iz baze. Klikom na dugme Next prelazi se na sledeći korak wizarda.
ADO.NET
Strana 62
Slika 14: Definisanje SELECT komande TableAdaptera U ovom koraku wizarda treba definisati SELECT komandu TableAdaptera. Komanda se može uneti ručno u prikazanoj tekst oblasti ili se može definisati grafički klikom na dugme Query Builder... 11.4.1 Definisanje upita korišćenjem Query Buildera
Slika 15: Add Table prozor ADO.NET
Strana 63
Slika 16: Query Builder prozor Klikom na dugme Query Builder otvara se najpre prozor Add Table koji omogućava da se odaberu tabele nad kojima će biti pisan upit. U primeru na slici odabrana je tabela ProductCategory. Tabela biva prikazana unutar prozora Query Buildera. Sada se čekiraju potrebne kolone ove tabele čime se grafički kreira SELECT upit nad ovom tabelom. 11.4.2 Prozor Advanced Options
Slika 17: Advanced Options prozor Klikom na dugme Advanced Options otvara se istoimeni prozor. Ukoliko je SQL upit definisan nad jednom tabelom baze podataka u prozoru Advanced Options se nudi mogućnost da se na ADO.NET
Strana 64
osnovu SELECT komande TableAdaptera automatski generišu INSERT, UPDATE i DELETE komanda.
Slika 18: Definisanje metode koju wizard treba da generise U ovom prozoru wizarda treba definisati koje metode wizard treba da generiše. Postoji mogućnost generisanja tzv. Fill metode kojoj treba proslediti tabelu kao parametar da bi je napunila podacima iz baze. Drugi tip metode je GetData koja vraća tabelu napunjenu podacima na osnovu definisane SELECT komande TableAdaptera.
ADO.NET
Strana 65
11.4.3 Poslednji korak wizarda
Slika 19: Poslednji korak TableAdapter wizarda U poslednjem koraku wizarda korisniku se prikazuje obaveštenje šta je korišćenjem wizarda generisano.
11.5 Uskladištena procedura kao komanda DataSeta Ukoliko se odlučimo prilikom otvaranja TableAdapter Configuration wizarda da SELECT komanda TableAdaptera predstavlja neku od postojećih uskladištenih procedura dobija se prozor kao na slici. U ovom prozoru treba odabrati neku od postojećih uskladištenih procedura.
ADO.NET
Strana 66
Slika 20: Odabir postojeće uskladištene procedure
11.6 Dodavanje relacije između tabela
Slika 21: Dodavanje relacije između tabela
ADO.NET
Strana 67
Pokretanjem TableAdapter Configuration wizarda u DataSet se dodaje odgovarajuća tabela i njoj pridruženi DataAdapter. Ista procedura se ponavlja za svaku od tabela koju želimo da dodamo u DataSet. Ukoliko želimo da kreiramo povezane tabele unutar DataSet-a, kao što su povezane u samoj bazi onda to radimo na način koji je prikazan na slici. Desnim tasterom kliknemo na tabelu i odaberemo opciju Add Relation.
11.7 Definisanje veze između tabela u DataSetu
Slika 22: Relation prozor DataSet-a Sada se otvara Relation prozor u kome treba definisati tabele koje se povezuju kao i atribute na osnovu kojih se vrši povezivanje tabela. Treba odabrati roditeljsku tabelu i definisati njen primarni ključ. Takođe, treba definisati i child tabelu i definisati strani ključ u toj tabeli. Takođe u ovom prozoru se mogu definisati i akcije referencijalnog integriteta, tj šta se dešava sa child vrstama kada se briše ili ažurira njima odgovarajuća parent vrsta. Ukoliko su tabele povezane u bazi podataka, automatski će biti povezane i u DataSet-u.
ADO.NET
Strana 68
11.8 Izgled šeme DataSet-a
Slika 23: Prikaz šeme DataSet-a Na slici je prikazan DataSet sa definisanim vezama između tabela.
11.9 Prevlačenje tabele iz Server Explorera
Slika 24: Server Explorer
ADO.NET
Strana 69
Tabela se u DataSet može ubaciti i njenim prevlačenjem iz Server Explorera. Prethodno je potrebno da se u Server Exploreru klikom na dugme Connect to Database uspostavi konekcija sa bazom podataka. Prevlačenjem tabele na površinu DataSet dizajnera u DataSetu se kreira tabela i u njoj odgovarajući TableAdapter ali nije moguce detaljnije konfigurisati SELECT komandu TableAdaptera. Prevlačenjem dve tabele koje su povezane u bazi podataka, vrši se njihovo automatsko povezivanje i u DataSetu.
11.10 DataSource Configuration wizard
Slika 25: DataSource onfiguration Wizard Izborom stavki menija Data >Add New DataSource pokreće se DataSource Configuration wizard koji služi za kreiranje DataSeta. Potrebno je izabrati tabele koje će ući u sastav DataSeta.
ADO.NET
Strana 70
11.11 Primer kreiranog dataSeta
Slika 26: Kreirani DataSet Na slici je prikazan primer kreiranog DataSeta nakon izbora tabela u DataSource Configuration wizardu. Takođe, kao I za slučaj prevlačenja tabela iz Server Explorera, nije moguće detaljno konfigurisati SELECT naredbe pojedinih TableAdaptera.
11.12 ClassView prozor
Slika 27: ClassView prozor Prikažimo ClassView prozor u Visual Studiu, ukoliko on nije prikazan. U ovom prozoru vide se klase koje su kreirane nakon konfigurisanja DataSeta. Ko što se sa slike može videti kreira se ADO.NET
Strana 71
tipizirani DataSet kao I tipizirane DataTable klase, pa čak I klase koje predstavljaju vrste u pojedinim tipiziranim tabelama.
11.13 Primer upotrebe TableAdaptera private NortwindDataSet nDS = new NortwindDataSet(); public Form2() { InitializeComponent(); } private void Form2_Load(object sender, EventArgs e) { CategoriesTableAdapter cta = new CategoriesTableAdapter(); ProductsTableAdapter pda = new ProductsTableAdapter(); cta.Fill(nDS.Categories); pda.Fill(nDS.Products); listBox1.DataSource = nDS.Categories; listBox1.DisplayMember= nDS.Categories.CategoryNameColumn.ColumnName; }
U prikazanom kodu vrši se instanciranje tipiziranog data seta NortwindDataSet. U Load proceduri forme instanciraju se tipizirani TableAdapteri koji rade sa tabelama Categories i Poducts. Zatim se pozivom Fill metode odgovarajućeg tipiziranog DataSeta vrši punjenje podacima odgovarajućeg tipiziranog DataTable objekta. Podaci iz tabele Categories se koriste za punjenje ListBox kontrole.
11.14 Primer upotrebe generisanih metoda i klsa private void listBox1_SelectedIndexChanged(object sender, EventArgs e) { listBox2.Items.Clear(); DataRowView drv = (DataRowView) listBox1.SelectedItem; NortwindDataSet.CategoriesRow kategorija = (NortwindDataSet.CategoriesRow) drv.Row; NortwinddataSet.ProductsRow[]proizvodi= kategorija.GetProductsRow(); foreach(Nortwind.DataSet.ProductsRow proizvod in priozvodi) { listBox2.Items.Add(proizvod.ProductName); } }
Na osnovu selektovane stavke u ListBox kontroli koja je povezana sa tabelom Categories iz DataSeta kreira se DataRowView objekat koji predstavlja pogled na odgovarajući DataRow ADO.NET
Strana 72
objekat tj. vrstu iz tabele Categories. Zatim se kastovanjem kreira odgovarajući CategoriesRow objekat koji predstavlja tipizirani DataRow objekat. Svaki CategoriesRow objekat ima metodu GetProductsRows koja je kreirana automatski na osnovu postojanja veze između tabela Categories i Products. Pozivom metode GetProductsRows objekta CategoriesRow kreira se niz ProductsRow objekata koji odgovaraju datom CategoriesRow objektu. Primetimo da se klasama CategoriesRow i ProductsRow pristupa posredstvom NortwindDataSet klase.
ADO.NET
Strana 73
12. Povezivanje podataka u windows obrascima 12.1 Povezivanje podataka Povezivanje podataka (Data binding) je tehnika u kojoj se podaci iz baze podataka koriste za popunjavanje kontrola na windows ili web formi uz minimalni napor od strane programera. Povezivanje podataka sa kontrolom označava povezivanje nekog svojstva kontrole sa vrednošću iz izvora podataka. Npr. kod kontrola kao što su Label i TextBox vrši se jednostavno povezivanje njihovog Text svojstva sa kolonom jedne vrste tabele iz baze podataka (jedne ćelije tabele). Takone se mogu povezivati kontrole kao što su ComboBox , ListBox sa kolonom iz tabele u bazi podataka i tada se radi o kompleksnom povezivanju. Kompleksnije kontrole kao što su DataGridView omogućavaju prikaz kompletnog sadržaj tabele ili pogleda.
12.2 BindingSource kontrola Kontrola BindingSource služi kao posrednik izmenu kontrole i izvora podataka. Ona obezbenuje uobičajeni interfejs i funkcionalnost koja omogućava da se kontrola poveže sa izvorom podataka. Kada god se povezuje kontrola sa izvorom podataka u dizajn modu ili korišćenjem wizarda , kreira se BindingSource kontrola. Instanca ove kontrole se može dodati na windows formu i manuelno. Prvi korak u konfigurisanju BindingSource kontrole je definisanje njoj pridruženog izvora podataka, tj. njenog svojstva DataSource.
12.3 Definisanje izvora podataka za BindingSource kontrolu
Slika28: Definisanje izvora podataka za BindingSource kontrolu ADO.NET
Strana 74
Na slikama je prikazan postupak povezivanja kontrole BindingSource sa izvorom podataka. Uobičajeno je da se kao izvor podataka za ovu kontrolu specificira prethodno kreirani tipizirani DataSet. Pored svojstva DataSource potrebno je specificirati i svojstvo DataMember, odnosno specificirati tabelu u izvoru podataka sa kojom se povezuje BindingSource kontrola.
12.4 Automatski generisani kod private System.Windows.Forms.BindingSource bindingSource1; private Northwind northwind; private BindSourceKontrola.NorthwindTableAdapters.CategoriesTableAdapter categoriesTableAdapter; private void Form1_Load(object sender, EventArgs e) { // TODO: This line of code loads data into the 'northwind.Categories' table. You can move, or remove it, as needed. this.categoriesTableAdapter.Fill(this.northwind.Categories); }
Povezivanjem BindingSource kontrole sa izvorom podataka na način prikazan u prethodnom tekstu vrši se generisanje koda koji je prikazan. Odnosno vrši se deklarisanje i instanciranje klase BindingSource i klase CategoriesTableAdapter. Takone se u Load proceduri forme vrši punjenje DataSeta podacima iz baze posredstvom Fill metode TableAdapter objekta.
12.5 Ostala svojstva BindingSource kontrole Svojstvo AlowNew odrenuje da li kontrola koja je povezana sa izvorom podataka može da dodaje nove stavke. Svojstvo Filter definiše filterski izraz koji odrenuje koji će se podaci prikazati u kontroli. Svojstvo Sort definiše kolone po kojima će se vršiti sortiranje, kolone su razdvojene zarezima i mogu se koristiti ključne reči ASC i DESC.
ADO.NET
Strana 75
12.6 Jednostavno povezivanje
Slika 29: Povezivanje Text svojstva TextBox kontrole sa vrednošću atributa CategoryID Jednostavno povezivanje podrazumeva povezivanje kontrole na web formi sa jednom skladnom vrednošću iz baze podataka, npr. sadržajem neke ćelije tabele. Na slici je prikazano povezivanje Text svojstva TextBox kontrole sa vrednošću atributa CategoryID u jednom redu tabele. 12.6.1 Jednostavno povezivanje – kod this.textBox1.DataBindings.Add(new System.Windows.Forms.Binding("Text",this.bindingSource1, "CategoryID", true));
ADO.NET
Strana 76
Iznad je prikazan automatski generisan kod koji predstavlja proces povezivanja podatka iz baze sa kontrolom. U DataBindigs kolekciju TextBox kontrole dodaje se DataBinding objekat čiji konstruktor ima četiri parametra. Prvi parametar definiše svojstvo kontrole koje se povezuje sa podacima iz baze, u ovom slučaju to je svojstvo Text. Drugi parametar ukazuje na BindingSource kontrolu posredstvom koje se vrši povezivanje. Treći parametar specificira tzv. DataMeber odnosno naziv atributa tabele koji se prikazuje u kontroli.Četvrti parametar označava da je moguće vršiti formatiranje podatka iz baze koji će biti prikazan u TextBox kontroli.
12.7 Povezivanje PictureBox kontrole sa Image kolonom
Slika 30: Povezivanje PictureBox kontrole sa Image kolonom Kod PictureBox kontrole vrši se povezivanje svojstva Image sa kolonom iz baze podataka koja sadrži slike. Jednostrukim povezivanjem vrši se povezivanje datog svojstva kontrole sa nekim atributom tabele i to njene prve vrste. Dakle, potrebno je obezbediti mehanizam kretanja kroz redove te tabele da bi data kontrola mogla prikazati u ovom slučaju sliku osobe čiji ID nije 1. this.pictureBox1.DataBindings.Add(new System.Windows.Forms.Binding("Image",this.employeesBindingSource, "Photo", true));
ADO.NET
Strana 77
Iznad je prikazan kod generisan od strane Visual Studia nakon povezivanja PictureBox kontrole sa Image kolonom. Objašnjenje je slično kao i za slučaj povezivanja Text svojstva TextBox kontrole.
12.8 Povezivanje DateTimePicker kontrole sa DateTime kolonom
Slika 31: Povezivanje DateTimePicker kontrole sa DateTime kolonom
Slika 32: DateTimePicker kontrola ADO.NET
Strana 78
Kod DateTimePicker kontrole vrši se povezivanje njenog Value svojstva sa nekom kolonom iz tabele koja je tipa DateTime. Treba, ponovo naglasiti da u slučaju jednostavnog povezivanje treba obezbediti mehanizam kretanja kroz redove tabele.
12.9 Povezivanje CheckBox kontrole sa Boolean kolonom Kod CheckBox kontrole vrši se povezivanje njenog Checked svojstva sa kolonom iz baze podataka koja je tipa Boolean.
12.10 Kompleksno povezivanje
Slika 33: Povezivanje kontrole ComboBox sa kolonom CategoryID
ADO.NET
Strana 79
Slika 34: ComboBox kontrola Kontrole kao što su ComboBox i ListBox i još neke kontrole omogućavaju kompleksno povezivanje. Takve kontrole mogu prikazati celu kontrolu neke tabele ili čak celu tabelu. Kao i u slučaju jednostavnog povezivanja podrazumeva se da je DataSet kreiran i da su tabele unutar njega napunjene podacima iz baze. Kontrola ComboBox može prikazati vrednosti iz neke kolone iz baze podataka. Najjednostavniji način povezivanja ComboBox kontrole je da se u prozoru ComboBox Tasks čekira opcija Use Data Bound Items nakon čega se definišu svojstva DataSource, DisplayMember i ValueMember. 12.10.1 Kompleksno povezivanje – kod this.ComboBox1.DataSource = this.bindingSource1; this.ComboBox1.DisplayMember = “CategoryName“; this.ComboBox.ValueMember = “CategoryID“;
Prikazani kod je kod koji je kreirao Visual Studio nakon povezivanja ComboBox kontrole sa kolonom iz baze podataka. Svojstvo DisplayMember definiše kolonu iz tabele koju treba prikazati. Svojstvo ValueMember je obično kolona – primarni ključ iz parent tabele sa kojom su posredstvom stranog ključa povezane kolone iz child tabele. 12.10.2 Prikaz proizvoda date kategorije private void comboBox1_SelectedIndexChanged(object sender, e) { int ID = Convert.ToInt32(comboBox1.SelectedValue); listBox1.Items.Clear(); Nortwind.CategoriesDataTable kategorijeTabela = ADO.NET
EventArgs
Strana 80
nortwind.Categories; Nortwind.CategoriesRow vrstaKategorija = kategorijeTabela.FindByCategoryID(ID); if (vrstaKategorija == null) return; Nortwind.ProductsRow[ ] vrsteProducts = vrstaKategorija.GetProductsRows(); foreach (Nortwind.ProductsRow vrsta in vrsteProducts) { listBox1.Items.Add(vrsta.ProductsID.ToString() + “ ” + vrsta.ProductsName); } }
U prikazanom kodu ilustruje se proces navigacije relacionih podataka. Za izabranu vrednost kategorije prouzvoda u ComboBox kontroli, u ListBox kontroli se prikazuju svi proizvodi koji pripadaju toj kategoriji. Pomoću svojstva SelectedValue ComboBox kontrole iščitava se ID kategorije za koju treba prikazati proizvode. Iz tipiziranog nortwind DataSeta pristupa se tipiziranoj tabeli tipa CategoriesDataTable. Zatim se pronalazi vrsta ove tabele, odnosno objekat klase CategoriesRow čiji je ID jednak selektovanom. Dalje se pomoću metode GetProductRow pronalazi niz vrsta iz tabele Products koje su povezane sa datom vrstom iz tabele Categories. 12.10.3 Prikaz proizvoda date kategorija – GUI
Slika 35: Prikaz proizvoda u ListBox kontroli Na slici je prikazan korisnički interfejs aplikacije koja ilustruje proces navigacije relacionih podataka. ADO.NET
Strana 81
12.11 Dve kontrole povezane na izvor podataka kroz istu BindingSource kontrolu
Slika 36: Korisnički interfejs aplikacije Ako se nawindows formi nalaze dve windows kontrole koje su povezane na izvor podataka posredstvom iste BindingSource kontrole tada će one prikazati sinhronizovane vrednosti. U primeru na slajdu TextBox kontrola prikazuje ID kategorije dok ComboBox kontrola prikazuje naziv kategorije. Kada se promeni selektovana stavka ComboBox-a tj. promeni se kategorija proizvoda, promeniće se i vrednost u TextBox-u na vrednost ID atributa selektovane kategorije.
12.12 BindingNavigator BindingNavigator je kontrola koja je izvedena iz kontrole ToolStrip i omogućava navigaciju kroz podatke korišćenjem standardnog interfejsa. Omogućava kretanje kroz vrste neke tabele, kao i skok na prvu vrstu ili na poslednju vrstu tabele. Takođe postoje dugmad za dodavanje ili brisanje vrste iz tabele u DataSetu. Njeno svojstvo BindingSource mora biti postavljeno na vrednost neke instance klase BindingSource.
ADO.NET
Strana 82
12.12.1 BindingNavigator – primer
Slika 37: BindingNavigator kontrola Kao BindingSource svojstvo kontrole BindingNavigator postavljen je BindingSource objekat koji uspostavlja vezu sa tabelom kategorija proizvoda. Klikom na dugmad za navigaciju na BindingNavigator kontroli, menjaju se vrednosti u kontrolama koje su povezane na isti BindingSource objekat kao i BindingNavigator. Na ovaj način BindingNavigator omogućava kretanje kroz zapise neke tabele.
12.13 Kreiranje Master – Detalji odnosa između kontrola
Slika 38: Konfigurisanje ComboBox kontrole
ADO.NET
Strana 83
ComboBox kontrola prikazuje podatke iz tabele kategorija, tačnije njigove nazive. Sada želimo da bez pisanja koda za selektovanu kategoriju prikažemo sve proizvode koji joj pripadaju.
Slika 39: Prevlačenje tabele na formu U DataSources prozoru pronađimo tabelu Productsali unutar čvora tabele Categories. Sve što treba da uradimo je da ovu tabelu prevučemo na windows formu. Na slici je prikazano kako je ovim postupkom konfigurisan productsBindingSource koji predstavlja izvor podataka DataGridView kontrole, koja je takođe automatski ubačena na formu.
ADO.NET
Strana 84
13. DataGridView kontrola 13.1 Uvod u DataGridView DataGridView je moćna, fleksibilna kontrola, jednostavna za korišćenje, koja se koristi za prikaz tabelarnih podataka. Može da se poveže sa jednom tabelom iz baze ili sa objektom koji je izveden iz tabele. Korišćenjem svojstva DataSource povezuje sa sa objektom klase DataTable ili objektom klase koja je izvedena iz klase DataTable. Ako se izvrši povezivanje sa objektom klase DataSet mora se specificirati i njeno svojstvo DataMember kojim se naznačava sa kojom tabelom se vrši povezivanje. DataGridView kreira jednu kolonu za svaku kolonu iz izvora podataka. Header kolone kreira na osnovu naziva odgovarajućeg atributa iz tabele. Dozvoljava različite tipove selekcije: može se selektovati jedna ili više vrsta, jedna ili više kolona, jedna ili više ćelija, ili cela tabela (klikom na ćeliju u gornjem levom uglu).
13.2 Osobine DataGridView kontrole Korišćenjem tastera Tab prelazi se iz jedne u drugu ćeliju tabele. Ima automatski tooltip kojim se prikazuje ceo sadržaj ćelije kada se pokazivač miša nalazi iznad nje. Podržava automatsko sortiranje, klikom na header kolone. Dvostrukim klikom izmenu header-a kolona vrši se automatsko podešavanje širine kolone. Omogućava unos sadržaja u ćeliju nakon dvostrukog klika na ćeliju.
13.3 Povezivanje DataGridView kontrole sa tabelom iz koda dataGridView1.DataSource = nds.Products; dataGridView1.DataSource = nds; dataGridView1.DataMember = "Products";
Pomoću svojstva DataSource specificira se tabela iz tipiziranog DataSet objekta sa kojom se povezuje DataGridView kontrola. Drugi način je da se kao DataSource svojstvo specificira DataSet objekat, ali se u ovom slučaju mora definisati DataMember svojstvo, odnosno tabela iz DataSeta sa kojom se vrši povezivanje.
ADO.NET
Strana 85
13.4 Povezivanje DataGridView kontrole sa tabelom u dizaj modu
Slika 40: Povezivanje DataGridView kontrole sa tabelom u dizaj modu Klikom na strelicu u gornjem desnom uglu DataGridView kontrole otvara se prozor DataGridView Tasks. U ovom prozoru se klikom na ComboBox kontrolu Choose Data Source specificira tabela iz DataSeta koju treba prikazati unutar DataGridView kontrole. Ovim postupkom se automatski kreira odgovarajući BindingSource objekat kao i punjenje tabele iz DataSeta podacima iz baze podataka primenom TableAdapter klase. Kod koji puni tabelu unutar DataSeta se dodaje u Load proceduri forme.
13.5 DataGridView objekti Svojstvo Colums objekta klase DataGridView daje kolekciju DataGridViewColumn objekata. Svojstvo Rows daje kolekciju DataGridViewRow objekata. DataGridViewRow objekat ima svojstvo Cells kojim se prikazuje kolekcija DataGridViewCell objekata.
ADO.NET
Strana 86
13.6 Šematski prikaz DataGridView objekata
Slika 41: Šematski prikaz DataGridView objekata Na slici je dat šematski prikaz objekata koji ulaze u sastav DataGridView objekta.
13.7 DataGridViewColumn objekat
Slika 42: DataGridViewColumn objekat
ADO.NET
Strana 87
DataGridViewColumn objektima date DataGridView kontrole se pristupa korišćenjem svojstva Columns. Svojstvo Colums vraća kolekciju DataGridViewColumn objekata. Sada se pojedininim kolonama tabele tj. DataGridViewColumn objektima pristupa ili korišćenjem rednog broja vrste u tabeli ili korišćenjem njenog naziva. Kada se u prozoru DataGridView Tasks klikne na opciju Edit Columns otvara se prozor EditColums u kome možemo iščitati naziv odrenene kolone koja ulazi u sastav DataGridView kontrole. U primeru na slici obranuje se Click doganaj na kontrolu Button. Unutar event handlera za klik doganaj na dugme, korišćenjem foreach petlje se iščitavaju nazivi svih kolona koje ulaze u sastav DataGridView kontrole.
13.8 Prikaz header-a kolona DataGridViewColumn col = dataGridView1.Columns[0]; col.HeaderText = "ID proizvoda"; foreach (DataGridViewColumn dgvC in dataGridView1.Columns) { listBox1.Items.Add(dgvC.HeaderText); }
Korišćenjem svojstva HeaderText se iz koda može iščitati ili promeniti heder tj. zaglavlje odrenene kolone koja ulazi u sastav DataGridView objekta. U gornjem kodu, korišćenjem foreach petlje unutar ListBox kontrole se prikazuju header-i svih kolona naše DataGridView kontrole.
13.9 DataGridViewRow objekat private void button3_Click(object sender, EventArgs e) { // pristup drugoj vrsti DataGridViewRow dgvR = dataGridView1.Rows[1]; // prikazi sadrzaj celija druge vrste foreach (DataGridViewColumn dgvC in dataGridView1.Columns) { listBox1.Items.Add(dgvR.Cells[dgvC.Name].Value); } }
Korišćenjem svojstva Rows objekta klase DataGridView, pristupa se kolekciji DataGridViewRow objekata, koji predstavljaju vrste DataGridView kontrole. Vrstama unutar DataGridView kontrole se isključivo pristupa na osnovu njenog rednog broja, tj. indeksa koji je baziran na broju 0. U primeru na slajdu pristupa se drugoj vrsti, tj. pristupa se objektu klase DataGridViewRow koji predstavlja drugu vrstu grida. DataGridViewRow objekat ima svojstvo Cells koje vraća kolekciju DataGridViewCell objekata odnosno ćelije date vrste. Pojedinim ADO.NET
Strana 88
ćelijam jedne vrste tj. ćelijama DataGridViewRow objekta pristupa se ili korišćenjem rednog broja kolone kojoj ćelija pripada ili korišćenjem naziva kolone kojoj ćelija pripada.
13.10 Klase izvedene iz klase DataGridViewColumn DataGridViewButtonColum klasa prikazuje dugmad tj. Button kontrole unutar jedne kolone DataGridView kontrole. Njoj odgovarjuća klasa za ćeliju je DataGridViewButtonCell. Sledeća klasa je DataGridViewLinkColumn i njoj odgovarajuća klasa za ćeliju DataGridViewLinkCell čija je funkcionalnost slična funkcionalnosti Button kolone, ali se tekst prikazuje u formi linka. DataGridViewCheckBoxColumn (DataGridViewCheckBoxCell se automatski kreira pri vizuelnom povezivanju DataGridView kontrole za tabelu koja sadrži Boolean tip podataka. DataGridViewComboBoxColumn (DataGridViewComboBoxCell) se koristi se u situacijama kada je potrebno ograničiti unos u ćeliju tj. omogućiti korisniku da u ćeliju odabere jednu vrednost iz datog skupa vrednosti. DataGridViewImageColumn (DataGridViewImageCell ) se koristi se za prikaz slika. DataGridViewTextBoxColumn (DataGridViewTextBoxCell se koristi za prikaz teksta i predstavlja podrazumevani tip kolone u DataGridView kontroli.
13.11 Kreiranje DataGridView kontrole koja nije povezana sa izvorom podataka DataGridViewTextBoxColumn col1 = new DataGridViewTextBoxColumn(); col1.Name = "ID"; col1.HeaderText = "ID proizvoda"; dataGridView1.Columns.Add(col1); DataGridViewComboBoxColumn col2 = new DataGridViewComboBoxColumn(); col2.Items.Add("Stampaci"); col2.Items.Add("Skeneri"); col2.Name = "Category"; col2.HeaderText = "Kategorijaa"; dataGridView1.Columns.Add(col2); DataGridViewRow dataGridRow = new DataGridViewRow(); DataGridViewTextBoxCell txt1 = new DataGridViewTextBoxCell(); DataGridViewComboBoxCell cmb1 = new DataGridViewComboBoxCell(); cmb1.Items.Add("Stampaci"); cmb1.Items.Add("Skeneri"); txt1.Value = "1"; ADO.NET
Strana 89
cmb1.Value = "Skeneri"; dataGridRow.Cells.Add(txt1); txt1.ReadOnly = true; dataGridRow.Cells.Add(cmb1); dataGridRow.Height = 20; dataGridView1.Rows.Add(dataGridRow);
Uobičajena upotreba DataGridView kontrole je prikaz podataka iz neke tabele ili drugog izvora podataka. Menutim, DataGridView kontrola se može iskoristiti za prikaz bilo kakvih podataka. U gornjem primeru najpre je na formu dodata DataGridView kontrola da bi se izvršilo instanciranje odgovarajuće klase. DataGridView kontrola nije povezana ni sa jednim izvorom podataka. Zatim se kreiraju se dve kolone DataGridView kontrole. Prva kolona je tipa DataGridViewTextBoxColumn a druga kolona je tipa DataGridViewComboBoxColumn. Posle inicijalizacije ovih kolona moraju se dodati u Columns koleciju DataGridView kontrole čime se kreira struktura DataGridView kontrole. Zatim se iz koda kreira i jedna vrsta DataGridView kontrole. Da bi se kreirala vrsta prethodno je neophodno kreirati ćelije koje ulaze u sastav ove vrste. U primeru to su ćelije tipa DataGridViewTextBoxCell i DataGridViewComboBoxCell. Tip ćelije koja ulazi u sastav reda mora odgovarati tipu kolone kojoj ta ćelija pripada. 13.11.1 Prikaz kreirane DataGridView kontrole
Slika 43: DataGridView kontrola Na slici je prikazana DataGridView kontrola čija je struktura (i podaci) kreirana iz koda u gornjem primeru.
ADO.NET
Strana 90
13.12 Selekcija ćelije DataGridView kontrola ima svojstvo SelectionMode koje može imati sledeće vrednosti: CellSelect, FullColumnSelect, FullRowSelect, ColumnHeaderSelect i RowHeaderSelect. Sam naziv moda selekcije ukazije na to šta se može selektovati unutar DataGridView kontrole. Svojstvo MultiSelect postavljeno na vrednost True omogućava selektovanje više redova, kolona ili ćelija.
13.13 Svojstva DataGridView kontrole vezana za selekciju SelectedCells svojstvo vraća kolekciju DataGridViewCell objekat nezavisno od moda selekcije DataGridView kontrole. Svojstvo SelectedRows daje selekciju selektovanih vrsta, dok svojstvo SelectedColumns daje kolekciju selektovanih kolona DataGridView kontrole.
13.14 Provera selektovanih ćelija private void button1_Click(object sender, EventArgs e) { richTextBox1.AppendText(“Ukupno selektovanih celija: ” + dataGridView1.SelectedCells.Count.ToString() + “\n”); foreach (DataGridViewCell celija in dataGridView1.SelectedCells) { richTextBox1.AppendText(“vrsta: ” + celija.RowIndex.ToString() + “kolona: ” + celija.ColumnIndex.ToString() + “ vrednost celije: ” + celija.Value + “\n”); } }
Pomoću svojstva SelectedCells DataGridView objekta pristupa se kolekciji selektovanih ćelija, tako da svojstvo Count ove kolekcije daje ukupan broj selektovanih ćelija. Primenom foreach petlje se prolazi kroz kolekciju selektovanih ćelija i za svaku od njih se prikazuje broj vrste i kolone kojima ćelija pripada kao i vrednost tj. podatak koji se nalazi u ćeliji.
ADO.NET
Strana 91
13.14.1 Provera selektovanih ćelija – GUI
Slika 44: Grafički prikaz selektovanih ćelija Na slici je prikazan korisnički interfejs aplikacije u kome se demonstrira kod dat u prethodnom primeru.
13.15 Ubacivanje ComboBox kontrole u ćeliju DataGridView kontrole
Slika 45: Editovanje izabrane kolone u DataGridView kontroli
ADO.NET
Strana 92
Najpre se izvrši povezivanje DataGridView kontrole sa tabelom iz baze podataka. Zatim se klikom na strelicu koja se nalazi u gornjem desnom uglu DataGridView kontrole otvara prozor DataGridView Tasks. Sada se u ovom prozoru odabere opcija Edit Columns... Selektuje se kolona kojoj želimo da promenimo tip. U primeru na slici DataGridView prikazuje Proizvode iz baze podataka Nortwind. Tabela proizvoda je povezana sa tabelom kategorija posredstvom atributa CategoryID koji predstavlja ID kategorije. Želimo da korisniku umesto ovog atributa prikažemo naziv kategorije kome proizvod pripada. Za početak će mo promeniti Header-ove kolone u kategorije.
13.16 Promena tipa kolone
Slika 46: Promena tipa kolone u DataGridView kontroli Sada ćemo koloni Kategorije promeniti tip. Unesto DataGridViewTextBoxColumn tipa kolone, postavićemo DataGridViewComboBoxColumn kolonu. Sada ovu kolonu treba povezati sa izvorom podataka, da bi podaci u tabeli proizvoda bili koegzistentni, odnosno da bi promena tipa kolone bila moguća.
ADO.NET
Strana 93
13.17 Povezivanje ComboBox kolone sa izvorom podataka
Slika 47: Povezivanje ComboBox kolone sa izvorom podataka Najpre se definiše DataSource svojstvo ComboBox kolone tj. tabela Categories iz DataSeta. Ovime se automatski kreira odgovarajući BindingSource objekat koji komunicira sa tabelom kategorija. Kao svojstvo DisplayMember postavi se kolona CategoryName tj. naziv kategorije, i to je vrednost koja će biti prikazana u ComboBox koloni. Kao svojstvo ValueMember postavi se kolona CategoryID, čime se omogućava veza sa starom TextBox kolonom.
13.18 Izgled DataGridView kontrole sa ComboBox kolonom
Slika48: Izgled DataGridView kontrole sa ComboBox kolonom
ADO.NET
Strana 94
14. Vodič za izradu praktičnih primera U ovom delu prelazimo sa teorije na praksu. Sledi detaljno uputstvo za izradu Windows aplikacija koje u svojoj strukturi sadrže ADO.NET klase, iz kojih može da se vidi ustvari kako sve to funkcioniše. Svi primeri su rađeni u Microsoft Visual C# 2008 Express Edition-u.
14.1 Kreiranje Windows Forms projekta Da bi ste kreirali Windows Forms projekat, prvo morate da pokrenete Microsoft C# 2008. To će te uraditi tako što će te naći lokaciju ovog programa preko Start – All Programs - ..., ili jednostavno preko prečice dvostrukim klikom na ikonicu programa. Kada to uradite otvara vam se prozor koji je dat na sledećoj slici:
Slika 49: Prozor Microsoft Visual C# 2008 Express Edition Nakon startovanja programa potrebno je izabrati meni File, a zatim stavka New Project... ADO.NET
Strana 95
Slika 50: Kreiranje novog projekta Otvara se dialog New Project gde treba selektovati Windows Forms Application templejt, a u polju Name uneti naziv aplikacije.
Slika 51: New Project dialog Klikom na dugme OK, vraćate se u razvojno okruženje Visual C#-a, a to je ujedno i poslednji korak kreiranja novog projekta.
ADO.NET
Strana 96
Slika 52: Razvojno okruženje Visual C#-a
14.2 Cuvanje Windows Forms projekta Nakon kreiranja novog projekta ostaje još i da se sačuva isti. To će te uraditi tako što će te izabrati meni File – Save All.
Slika 53: Čuvanje projekta Klikom na ovu opciju otvara se Save Project prozor.
ADO.NET
Strana 97
Slika 54: Save Project prozor U poljima Name i Solution Name stoji ime koje ste definisali prilikom kreiranja projekta, koja naravno ako to želite možete da promenite. U polju Location nalazi se putanja, tj. mesto gde će projekat biti sačuvan. To možete promeniti klikom na dugme Browse...
Slika 55: Project Location prozor Kada odaberete putnju, kliknite na dugme OK koje vas vraća na Save Project prozor na kome vam jedino preostaje da kliknete na dugme Save, a to je ujedno i poslednji korak.
ADO.NET
Strana 98
14.3 Vodič za izradu aplikacije „Imenik 2010“ Ova aplikacija, kao što i sam naziv kaže, predstavlja program u kome možete držati neke osnovne podatke svojih prijatelja, kolega, poznanika... Jednostavnog je interfejsa tako da je veoma koristan i lak za upotrebu. Za čuvanje podataka koristi Access-ovu bazu podataka. Sastoji se od jedne forme preko koje možete vršiti čitanje, unos novih ili editovanje već postojećih podataka, tj u ovom slučaju osoba. 14.3.1 Dodavanje kontrola Da bi ste kreirali ovaj projekat pratite sledeće korake. Celokupnu grafiku koja je korišćena pri izradi možete naći u folderu Resources. 1. Otvorite Visual C# i kreirajte nov Windows Forms projekat. U polju predvidjenom za ime projekta unesite ’Imenik’. 2. Desni klik na Form1 pa zatim Propertis. Otvara se Propertis prozor u kome treba izmeniti sledeće atribute: Atribut BackGroumdImage FormBorderStyle MaximizeBox Size StartPosition Text Vaša forma bi trebalo da izgleda ovoako:
Vrednost frm_bg.png FixedSingle False 730, 520 CenterScreen Imenik 2010
Slika 56: Izgled Imenik aplikacije I deo
ADO.NET
Strana 99
3. Kao što vidite forma je, pomoću pozadinske slike, podeljena na dva dela. Na levom delu biće postavljena lista sa imenima osoba, dok će desna strana služiti za prikaz podataka selektovane osobe. Sa ToolBox-a prevucite sledeće kontrole i podesite njene atribute vrednostima iz tabele. Kontrola
Label
ListBox
Label TextBox
Button
Button
Atribut BackColor BorderStyle Font ForeColor MinimumSize Text TextAlign BackColor Font ForeColor HorizontalScrollBar ItemHeight Size Sorted Font Text Name Font Size Name FlatStyle Image Size Text Name FlatStyle Image Size Text
Vrednost System/Info FixedSingle Magneto, 18pt, style=Bold Web/Navy 280, 30 Kontakt MiddleLeft Web/WhiteSmoke Tahoma, 15.75pt Web/Navy True 25 280, 329 True Kristen ITC, 12pt, style=Bold Traži po imenu: txtTrazi Kristen ITC, 8.25pt, style=Bold 200, 22 btnTrazi Popup Search-64.png 32, 32 btnOsvezi Popup Refresh-32.png 32, 32
Kontrole rasporedite kao na sledećoj slici:
ADO.NET
Strana 100
Slika 57: Izgled Imenik aplikacije II deo 4. Prevucite GroupBox kontrolu na formu (Location: 293, 41; Size: 425, 442). 5. Prevucite dve Panel kontrole i podesite vrednosti sledećih atributa: Kontrola
Atribut BackColor BorderStyle Font Location Size BackColor BorderStyle Location Size
Panel
Panel
Vrednost System/ActiveBorder FixedSingle Magneto, 18pt, style=Bold 6, 13 413, 42 Web/Ivory FixedSingle 6, 55 413, 380
6. Prevucite Label kontrolu i podesite joj sledeće vrednosti za atribute: Kontrola Label
Atribut Name Text Visible
Vrednost lblID 0 False
7. Prevucite pet Button kontrola i podesite sledeće vrednosti: ADO.NET
Strana 101
Kontrola
Atribut Name Image Location Size Name Enable Image Location Size Name Enable Image Location Size Name Enable Image Location Size Name Enable Image Location Size
Button
Button
Button
Button
Button
Vrednost btnDodaj Add_user_32.png 4, 0 52, 40 btnIzmeni False Edit_user_32.png 62, 0 52, 40 btnSacuvaj False Save_32.png 120, 0 52, 40 btnIzbrisi False User_delete_32.png 178, 0 52, 40 btnOdustani False Cancel-arrow-32.png 356, 0 52, 40
8. Prevucite devet TextBox kontrola i podesite sledeće vrednosti: Kontrola TextBox TextBox
MaskedTextBox TextBox TextBox TextBox TextBox ADO.NET
Atribut Name Size Name Multiline Size Name Mask Size Name Size Name Size Name Size Name
Vrednost txtIme 217, 20 txtAdresa True 217, 56 txtDatum 00/00/0000 151, 20 txtTel 151, 20 txtMobTel 151, 20 txtDrTel 151, 20 txtMeil Strana 102
Size Name Size Name Multiline Size
TextBox TextBox
217, 20 txtSajt 217, 20 txtInfo True 217, 56
9. Prevucite deset Label kontroli (Font: Kristen ITC, 8.25pt, style=Bold) i podesite atribut Text na sledeće vrednosti: Ime i prezime:, Adresa:, Datum rodjenja:, dd/mm/gggg, Telefon:, Mobilni Tel:, Drugi relefon:, Meil:, Sajt:, Info:. Kontrole podesiti kao na sledećoj slici:
Slika 58: Izgled Imenik aplikacije III deo
14.3.2 Kodiranje aplikacije Nakon što smo uradili interfejs aplikacije, ostaje nam da formu povežemo sa bazom podataka, a takođe moramo i neke kontrole međusobno povezati. Pratite uputstvo: 1. Desini klik na formu pa zatim izaberite opciju View Code. Prvo ćemo direktivom using uvesti namespace System.Data.OleDb jer koristimo Access-ovu bazu podataka.
ADO.NET
Strana 103
Slika 59: Namespace Szstem.Data.OleDb 2. U telu klase Form1 definišemo: private string selected; string connString = (@"Provider=Microsoft.Jet.OLEDB.4.0;Data Source=| DataDirectory|\imenikDB.mdb;"); OleDbConnection conn; OleDbCommand cmd = new OleDbCommand(); OleDbDataReader dr = null;
3. Kreiramo privatnu metodu sa nazivom PopuniListu koja će se konektovati na bazu i pomoću SQL komande pročitati sve vrednosti kolone ’ime’ iz tabele ’kontakt’. Tim podacima popunićemo listBox1 kontroluSledi kod: private void PopuniListu() { listBox1.Items.Clear(); conn = new OleDbConnection(connString); conn.Open(); cmd.Connection = conn; cmd.CommandType = CommandType.Text; cmd.CommandText = "SELECT ime FROM kontakt"; dr = cmd.ExecuteReader();
}
while (dr.Read()) { listBox1.Items.Add(dr.GetValue(0)); } dr.Close(); conn.Close();
4. Kreiramo privatnu metodu PopuniFormu koja će služiti da, u zavisnosti od selektovane osobe, izvuče podatke iz baze o toj osobi, i njima popuni TextBox-ove koji se nalaze na formi. private void PopuniFormu()
ADO.NET
Strana 104
{
conn = new OleDbConnection(connString); conn.Open(); cmd.Connection = conn; cmd.CommandType = CommandType.Text; cmd.CommandText = "SELECT * FROM kontakt WHERE ime = '" + selected +"'"; dr = cmd.ExecuteReader(); dr.Read(); lblID.Text = dr["ID"].ToString(); txtIme.Text = dr["ime"].ToString(); txtAdresa.Text = dr["adresa"].ToString(); txtDatum.Text = dr["datum"].ToString(); txtTel.Text = dr["telefon"].ToString(); txtMobTel.Text = dr["mobTel"].ToString(); txtDrTel.Text = dr["drTel"].ToString(); txtMeil.Text = dr["meil"].ToString(); txtSajt.Text = dr["sajt"].ToString(); txtInfo.Text = dr["info"].ToString(); dr.Close(); conn.Close(); }
5. Dostrukim klikom na kontrolu listBox1 kreiraće se handler za event SelectedIndexChanged sa nazivom listBox1_SelectedIndexChanged. U telu metode listBox1_SelectedIndexChanged trba upisati kod koji će da pozove metodu koja vraća podatke za izabranu osobu private void listBox1_SelectedIndexChanged(object sender, EventArgs e) { btnIzbrisi.Enabled = true; btnIzmeni.Enabled = true; btnSacuvaj.Enabled = false; btnOdustani.Enabled = false; selected = listBox1.SelectedItem.ToString(); PopuniFormu(); }
6. Kreiramo privatnu metodu FormaPasivna koja će služiti da omogući samo čitanje podataka selektovane osobe bez bilo kakvih slučajnih izmena private void FormaPasivna() { txtIme.ReadOnly = true; txtIme.BackColor = Color.Ivory; txtAdresa.ReadOnly = true; txtAdresa.BackColor = Color.Ivory; txtDatum.ReadOnly = true; txtDatum.BackColor = Color.Ivory; txtTel.ReadOnly = true; txtTel.BackColor = Color.Ivory;
ADO.NET
Strana 105
txtMobTel.ReadOnly = true; txtMobTel.BackColor = Color.Ivory; txtDrTel.ReadOnly = true; txtDrTel.BackColor = Color.Ivory; txtMeil.ReadOnly = true; txtMeil.BackColor = Color.Ivory; txtSajt.ReadOnly = true; txtSajt.BackColor = Color.Ivory; txtInfo.ReadOnly = true; txtInfo.BackColor = Color.Ivory; }
7. Pošto aplikacija ima mogućnost izmene postojećih podataka, kao i unos novih, moramo da kreiramo i metodu FormaAktivna koja će nam omogućiti pristup izmeni postojećih podataka kao i unos novih private void FormaAktivna() { txtIme.ReadOnly = false; txtIme.BackColor = Color.White; txtAdresa.ReadOnly = false; txtAdresa.BackColor = Color.White; txtDatum.ReadOnly = false; txtDatum.BackColor = Color.White; txtTel.ReadOnly = false; txtTel.BackColor = Color.White; txtMobTel.ReadOnly = false; txtMobTel.BackColor = Color.White; txtDrTel.ReadOnly = false; txtDrTel.BackColor = Color.White; txtMeil.ReadOnly = false; txtMeil.BackColor = Color.White; txtSajt.ReadOnly = false; txtSajt.BackColor = Color.White; txtInfo.ReadOnly = false; txtInfo.BackColor = Color.White; }
8. Dvostrukim klikom na dugme btnTrazi kreiramo handler za event Click. Ovom metodom ćemo korisniku omogućiti brzu pretragu liste za željenom osobom. Preko SQL komande izvršićemo upit nad bazom, i listu popuniti samo imenima koja odgovaraju kriterijumu unetom u txtTrazi kontrolu private void btnTrazi_Click(object sender, EventArgs e) { listBox1.Items.Clear(); conn = new OleDbConnection(connString); conn.Open(); cmd.Connection = conn; cmd.CommandType = CommandType.Text; cmd.CommandText = "SELECT ime FROM kontakt WHERE ime LIKE '" + txtTrazi.Text + "%'";
ADO.NET
Strana 106
dr = cmd.ExecuteReader(); while (dr.Read()) { listBox1.Items.Add(dr.GetValue(0)); } dr.Close(); conn.Close(); }
9. Dvostrukim klikom na dugme btnOsvezi kreiramo handler za event Click. Ovom metodom ćemo pozivati metodu koja će popunjavati listu svim imenima iz baze, tj bez ikakvih kriterijuma private void btnOsvezi_Click(object sender, EventArgs e) { txtTrazi.Text = ""; txtTrazi.Focus(); PopuniListu(); }
10. Dvostruki klik na Form1 da bi smo kreirali handler za event Load. Ovom metodom ćemo pozvati metode koje će prilikom startovanja forme popuniti listu I omogućiti samo čitanje podataka sa forme private void Form1_Load(object sender, EventArgs e) { PopuniListu(); FormaPasivna(); }
11. Dvostrukim klikom na dugme btnDodaj kreiramo handler za event Click. Ova metoda će nam omogućiti da formu iz pasivnog moda prebacimo u aktivni kao i da spremi formu za unos novih podataka private void btnDodaj_Click(object sender, EventArgs e) { FormaAktivna(); txtIme.Text = ""; txtAdresa.Text = ""; txtDatum.Text = ""; txtTel.Text = ""; txtMobTel.Text = ""; txtDrTel.Text = ""; txtMeil.Text = ""; txtSajt.Text = ""; txtInfo.Text = ""; btnIzmeni.Enabled = false; btnIzbrisi.Enabled = false; btnSacuvaj.Enabled = true; btnOdustani.Enabled = true; listBox1.Enabled = false; lblID.Text = "0"; }
ADO.NET
Strana 107
12. Dvostrukim klikom na dugme btnIzmeni kreiramo handler za event Click. Ovom metodom formu prebacujemo u mod u kome možemo da vršimo izmenu postojećih podataka private void btnIzmeni_Click(object sender, EventArgs e) { FormaAktivna(); btnIzmeni.Enabled = false; btnIzbrisi.Enabled = false; btnSacuvaj.Enabled = true; btnOdustani.Enabled = true; listBox1.Enabled = false; txtIme.Focus(); }
13. Dvostrukim klikom na dugme btnSacuvaj kreiramo handler za event Click. Ovom metodom ćemo čuvati promene koje vršimo nad podacima. U zavisnosti od vrednosti kontrole lblID pozvaće se jedan od dva SQL upita. I to, ako vrednost kontrole lblID odgovara ID vrednosti neke osobe izvršiće se upit koji će UPDATE-ovati podatke za tu osobu. U suprotnom, znaćemo da se radi o novoj osobi koje nema u bazi I tada će se izvršiti INSERT-ovanje podataka private void btnSacuvaj_Click(object sender, EventArgs e) { if (txtIme.Text == "") { MessageBox.Show("Niste uneli ime!", "Greska", MessageBoxButtons.OK, MessageBoxIcon.Information); FormaAktivna(); txtIme.Focus(); return; } try { if (lblID.Text == "0") { conn = new OleDbConnection(connString); conn.Open(); cmd.Connection = conn; cmd.CommandType = CommandType.Text; cmd.CommandText = string.Format("INSERT INTO [kontakt] (ime, adresa, datum, telefon, mobTel, drTel, meil, sajt, info) VALUES ('{0}', '{1}', '{2}', '{3}', '{4}', '{5}', '{6}', '{7}', '{8}')", txtIme.Text, txtAdresa.Text, txtDatum.Text, txtTel.Text, txtMobTel.Text, txtDrTel.Text, txtMeil.Text, txtSajt.Text, txtInfo.Text); int responce = cmd.ExecuteNonQuery(); conn.Close(); PopuniListu(); } else { conn = new OleDbConnection(connString); conn.Open(); cmd.Connection = conn; cmd.CommandType = CommandType.Text;
ADO.NET
Strana 108
cmd.CommandText = @"UPDATE txtIme.Text + "', adresa = '" + txtAdresa.Text txtDatum.Text + "', telefon = '" + txtTel.Text txtMobTel.Text + "',drTel = '" + txtDrTel.Text + "', sajt = '" + txtSajt.Text + "', info = '" " + lblID.Text + ""; cmd.ExecuteNonQuery(); conn.Close(); }
kontakt SET ime = '" + + "', datum = '" + + "', mobTel = '" + + "', meil = '" + txtMeil.Text + txtInfo.Text + "' WHERE ID =
14. Dvostrukim klikom na dugme btnIzbrisi kreiramo handler za event Click. Ovom metodom ćemo krisniku omogućiti da izbriše postojeći kontakt private void btnIzbrisi_Click(object sender, EventArgs e) { if (MessageBox.Show("Da li sigurno hocete da izbrisete ovaj kontakt?", "Upozorenje", MessageBoxButtons.YesNo, MessageBoxIcon.Warning, MessageBoxDefaultButton.Button2) == DialogResult.Yes) { FormaPasivna(); conn = new OleDbConnection(connString); conn.Open(); cmd.Connection = conn; cmd.CommandType = CommandType.Text; cmd.CommandText = "DELETE FROM kontakt where ID = " + lblID.Text + ""; cmd.ExecuteNonQuery(); conn.Close(); PopuniListu(); txtIme.Text = ""; txtAdresa.Text = ""; txtDatum.Text = ""; txtTel.Text = ""; txtMobTel.Text = ""; txtDrTel.Text = ""; txtMeil.Text = ""; txtSajt.Text = ""; txtInfo.Text = ""; }
}
15. Dvostrukim klikom na dugme btnOdustani kreiramo handler za event Click. Ovom metodom vraćamo formu u pasivni mod, bez čuvanja bilo kakvih promena koje smo do tada izvršili private void btnOdustani_Click(object sender, EventArgs e) { FormaPasivna(); btnIzmeni.Enabled = true; btnIzbrisi.Enabled = true; btnSacuvaj.Enabled = false; btnOdustani.Enabled = false; listBox1.Enabled = true; }
ADO.NET
Strana 109
16. Pritisnite F5 i testirajte aplikaciju. 17. Vaša aplikacija bi trebalo da izgleda ovako:
Slika 60: Prikaz podataka selektovane osobe
ADO.NET
Strana 110
Korišćenjem menija možete uraditi sledeće: Kontrola
Opis Klikom na ovo dugme, forma prelazi u mod namenjen unosu nove osobe. Klikom na ovo dugme, forma prelayi u aktivni mod, što znači da možete da menjate podatke selektovane osobe. Klikom na ovo dugme, omogućava vam da sačuvate sve promene koje ste izvršili na formi. Klikom na ovo dugme, brišete selektovanu osobu iz baze podataka. Klikom na ovo dugme, formu vraćate u pasivni mod, bez čuvanja bilo kakvih promena koje ste do tada izvršili.
ADO.NET
Strana 111
14.4 Vodič za izradu aplikacije „SQL Vezba“ Ovo je vrlo jednostavna aplikacija, koja omogućava vežbanje SQL upita nad Access-ovim bazama podataka. Vrlo je korisna za učenike ili studente koji tek počinju da uče i savladavaju SQL jezik. Jednostavnog je interfejsa tako da je veoma lak za korišćenje. Sastoji se iz jedne forme na kojoj se nalazi TextBox kontrola u koju se upisuju upiti. Ukoliko je upit tačno unet, DataGridView kontrola će prikazati rezultat unetog upita. 14.4.1 Dodavanje kontrola Da bi ste kreirali ovaj projekat pratite sledeće korake. Celokupnu grafiku koja je korišćena pri izradi možete naći u folderu Resources. 1. Otvorite Visual C# i kreirajte nov Windows Forms projekat. U polju predvidjenom za ime projekta unesite ’SQLVezba’. 2. Desni klik na Form1 pa zatim Propertis. Otvara se Propertis prozor u kome treba izmeniti sledeće atribute: Atribut
Vrednost
FormBorderStyle MaximizeBox Size StartPosition Text
FixedSingle False 677, 490 CenterScreen SQL Vezba
3. Sa ToolBox-a prevucite sledeće kontrole i popunite njihove atribute vrednostima iz tabele. Kontrola TextBox
Button
Button
Button ADO.NET
Atribut Name Location Multiline Size Name Image Location Size Text Name Image Location Size Text Name
Vrednost txtUpit 12, 12 True 518, 167 btnOtvori Open_32.png 11, 188 127, 38 Izaberi bazu btnIzvrsi Check_32.png 543, 12 116, 38 Izvrsi upit btnObrisi Strana 112
Image Location Size Text DataGridView Location Size Vaša forma bi trebalo da izgleda ovako:
Delete_all_32.png 543, 56 116, 38 Obrisi upit 12, 256 647, 190
Slika 61: Izgled aplikacije SQL Vezba 14.4.2 Kodiranje aplikacije 1. Desini klik na formu pa zatim izaberite opciju View Code. Prvo ćemo direktivom using uvesti namespace System.Data.OleDb jer koristimo Access-ovu bazu podataka (slika 59). 2. U telu klase Form1 definišemo: private string connString;
3. Dvostrukim klikom na dugme btnOtvori kreiramo handler za event Click. Ovom metodom ćemo pozvati instancu klase OpenFileDialog, preko koje ćemo moći da otvorimo bilo koju Access-ovu bazu podataka private void btnOtvori_Click(object sender, EventArgs e) { OpenFileDialog opn = new OpenFileDialog(); opn.Filter = "Access files(*.mdb)|*.mdb"; opn.ShowDialog(); try
ADO.NET
Strana 113
{
String txt = opn.FileName.ToString(); connString = @"Provider=Microsoft.Jet.OLEDB.4.0;Data Source=" + txt + ";Persist Security Info=True"; MessageBox.Show("Konekcija je uspela. Mozete krenuti sa vezbom!", "Obavestenje", MessageBoxButtons.OK, MessageBoxIcon.Information); txtUpit.Focus(); } catch { return; } }
4. Dvostrukim klikom na dugme btnIzvrsi kreiramo handler za event Click. Ovom metodom ćemo pozvati kod, koji će izvršiti upit koji unesemo TextBox kontrolu private void btnIzvrsi_Click(object sender, EventArgs e) { try { OleDbConnection conn = new OleDbConnection(@"Provider=Microsoft.Jet.OLEDB.4.0;Data Source=" + connString + ";Persist Security Info=True"); conn.Open(); OleDbCommand cmd = new OleDbCommand(); cmd.Connection = conn; DataTable dt = null; OleDbDataAdapter da = null; dataGridView1.DataSource = null; cmd.CommandType = CommandType.Text; cmd.CommandText = txtUpit.Text; dt = new DataTable(); da = new OleDbDataAdapter(cmd); da.Fill(dt); dataGridView1.DataSource = dt; conn.Close(); } catch (Exception ex) { MessageBox.Show("Greska: " + ex, "Greska", MessageBoxButtons.OK, MessageBoxIcon.Warning); txtUpit.Focus(); } }
5. Dvostrukim klikom na dugme btnObrisi kreiramo handler za event Click. Ovom metodom ćemo brisati upit iz TextBox kontrole, kao I rezultat izvrsenog upita koji se nalazi u DataGridView kontroli private void btnObrisi_Click(object sender, EventArgs e) { txtUpit.Text = ""; dataGridView1.DataSource = null;
ADO.NET
Strana 114
}
6. Pritisnite F5 I testirajte aplikaciju. 7. Kliknućemo na dugme Izaberi bazu, I otvoriti Northwind.mdb bazu podataka. Kada to učinimo pojaviće nam se obaveštenje, o tome da je konekcija uspela
Slika 62: MessageBox – uspela konekcija 8. U tekstualno polje unećemo jedan prost upit I kliknuti na dugme Izvrsi upit. Rezultat bi trebalo da izgleda ovako
Slika 63: Rezultat nakon izvršenog upita Rezultat su svi podaci zaposlenih iz tabele Employees, koji žive u Londonu.
ADO.NET
Strana 115
14.5 Vodič za izradu aplikacije „ADO.NET“ Ova aplikacija je napravljena kako bi prikazali da za podatke koje želimo da sačuvamo na lokalni disk, ne moramo isključivo koristiti klasične baze podataka (Access, SQL...), već da podatke možemo smestiti u txt i xml fajlove, kao i da te iste fajlove možemo koristiti za popunjavanje DataSet-a. Da bi smo smestili podatke u tekstualni fajl, moramo prvo da napravimo klasu koja će čitati podatke iz txt fajla, i tim podacima popunjavati DataSet. Što se tiče čuvanja podataka u xml formatu i čitanja istih, za to već postoje integrisane klase WriteXml i ReadXml. 14.5.1 Dodavanje kontrola Da bi ste kreirali ovaj projekat pratite sledeće korake. Celokupnu grafiku koja je korišćena pri izradi možete naći u folderu Resources. 1. Otvorite Visual C# i kreirajte nov Windows Forms projekat. U polju predvidjenom za ime projekta unesite ’ADO.NET’. 2. Desni klik na Form1 pa zatim Propertis. Otvara se Propertis prozor u kome treba izmeniti sledeće atribute: Atribut
Vrednost
FormBorderStyle MaximizeBox Size StartPosition Text
FixedSingle False 465, 388 CenterScreen ADO.NET
3. Sa ToolBox-a prevucite sledeće kontrole i popunite njihove atribute vrednostima iz tabele. Kontrola DataGridView
Button
Button
Button ADO.NET
Atribut Location Size Name Image Location Size Text Name Image Location Size Text Name
Vrednost 12, 12 435, 246 btnSaveAsTxt txt_32.png 12, 264 134, 37 Sacuvaj kao tekst btnOpenTxt fileopen_32.png 152, 264 10 4, 37 Otvori tekst btnSaveAsXml Strana 116
Image Location Size Text Name Image Button Location Size Text Button Name Location Text Vaša forma bi trebalo da izgleda ovako
xml_32.png 12, 307 134, 37 Sacuvaj kao XML btnOpenXML fileopen_32.png 152, 307 104, 37 Otvori XML btnRestart 323, 264 Izbaci podatke iz DataGridViewa
Slika 64: Izgled aplikacije ADO.NET 14.5.2 Kodiranje aplikacije 1. Desini klik na formu pa zatim izaberite opciju View Code. Prvo ćemo direktivom using uvesti namespace System.Data.OleDb jer koristimo Access-ovu bazu podataka (slika 59) , kao I namespace System.IO jer ćemo koristiti klasu StreamWriter za kreiranje novog txt fajla.
ADO.NET
Strana 117
2. Kreiramo klasu koja će čitati podatke iz txt fajla. To ćete učiniti tako što ćete kliknuti na liniju menija, a zatim iz padajućeg menija AddNewItem izabrati Add New Class…
Slika 65: Dodavanje nove klase projektu 3. U polje Name unesite Txt2DataSet I kliknite na dugme Add. 4. Unesite sledeći kod u kreiranu klasu using using using using using using
System; System.Collections.Generic; System.Linq; System.Text; System.Data; System.IO;
namespace Cuvanje_i_citanje_podataka__xml_i_txt_ { class Txt2DataSet { public Txt2DataSet() { } public static DataSet Convert(string File, string TableName, string delimiter) { DataSet result = new DataSet(); StreamReader s = new StreamReader(File); string[] columns = s.ReadLine().Split(delimiter.ToCharArray()); result.Tables.Add(TableName); foreach (string col in columns) { bool added = false; string next = ""; int i = 0; while (!added) { string columnname = col + next; columnname = columnname.Replace("#", ""); columnname = columnname.Replace("'", "");
ADO.NET
Strana 118
columnname = columnname.Replace("&", ""); if (! result.Tables[TableName].Columns.Contains(columnname)) { result.Tables[TableName].Columns.Add(columnname); added = true; } else { i++; next = "_" + i.ToString(); } } } string AllData = s.ReadToEnd(); string[] rows = AllData.Split("\r\n".ToCharArray()); foreach (string r in rows) { string[] items = r.Split(delimiter.ToCharArray()); } return result; }
}
}
5. Vraćamo se na Form1. Dvostrukim klikom na dugme btnSaveAsTxt kreiramo handler za event Click. Ovom metodom ćemo omogućiti kreiranje tekstualnog fajla sa posebnim formatom. Nakon čitanja jedne ćelije iz DataGridView kontrole automatski ćemo stavljati znak #, kako bi kasnije tako formatiran tekst mogli da iskoristimo za popunjavanje DataSet-a. Kada nebi stavili ovaj, ili neki drugi specijalni znak, ceo tekstualni fajl bi se učitao u prvu ćeliju DataGrid-a private void btnSaveAsTxt_Click(object sender, EventArgs e) { SaveFileDialog svd = new SaveFileDialog(); svd.Filter = "Text files(*.txt)|*.txt"; svd.ShowDialog(); try { OleDbDataReader dr; OleDbCommand cmd = new OleDbCommand(); OleDbConnection conn = new OleDbConnection(connString); conn.Open(); cmd.Connection = conn; cmd.CommandType = CommandType.Text; cmd.CommandText = "select * from Tabela"; dr = cmd.ExecuteReader(); String txt = dataGridView1.Columns[0].HeaderText; int br = dataGridView1.Columns.Count; for (int i = 0; i < dataGridView1.Columns.Count; i++)
ADO.NET
Strana 119
{
mojNiz = dataGridView1.Columns[i].HeaderText; } using (StreamWriter writer = new StreamWriter(svd.FileName, false))
{ for (int i = 0; i < dataGridView1.Columns.Count; i++) { mojNiz = dataGridView1.Columns[i].HeaderText; writer.Write(mojNiz + "#"); } for (int r = 0; r < dataGridView1.Rows.Count; r++) { while (dr.Read()) { writer.WriteLine(); for (int i = 0; i < dataGridView1.Columns.Count;
i++)
{ erText] + "#");
writer.Write(dr[dataGridView1.Columns[i].Head
} }
} writer.Close(); dr.Close(); } } catch { return; } }
6. Dvostrukim klikom na dugme btnOpenTxt kreiramo handler za event Click. Ovom metodom ćemo, preko OpenFileDialog-a omogućiti otvaranje txt fajla, I punjenje DataSet-a podacima iz izabranog fajla private void btnOpenTxt_Click(object sender, EventArgs e) { OpenFileDialog opn = new OpenFileDialog(); opn.Filter = "Text files(*.txt)|*.txt"; opn.ShowDialog(); try { DataSet myDS = Cuvanje_i_citanje_podataka__xml_i_txt_.Txt2DataSet.Convert(opn.FileName, "tblName", "#"); dataGridView1.DataSource = myDS; dataGridView1.DataMember = "tblName"; dataGridView1.Columns.Remove("Column1"); for (int i = 0; i < dataGridView1.Rows.Count - 1; i++) { if (i % 2 != 0)
ADO.NET
Strana 120
{ }
dataGridView1.Rows[i].Visible = false;
}
btnSaveAsTxt.Enabled = true; btnSaveAsXML.Enabled = true;
} catch { return; } }
7. Dvostrukim klikom na dugme btnSaveAsXML kreiramo handler za event Click. Ovom metodom ćemo omogućiti čuvanje podataka u xml formatu private void btnSaveAsXML_Click(object sender, EventArgs e) { SaveFileDialog svd = new SaveFileDialog(); svd.Filter = "XML files(*.xml)|*.xml"; svd.ShowDialog(); try { dt.TableName = "myDT"; dt.WriteXml(svd.FileName, XmlWriteMode.WriteSchema); } catch { return; } }
8. Dvostrukim klikom na dugme btnOpenXML kreiramo handler za event Click. Ovom metodom ćemo, preko OpenFileDialog-a otvoriti xml fajl I njime popuniti DataTable private void btnOpenXML_Click(object sender, EventArgs e) { OpenFileDialog opn = new OpenFileDialog(); opn.Filter = "XML files(*.xml)|*.xml"; opn.ShowDialog(); try { DataTable mDT = new DataTable(); mDT.ReadXml(opn.FileName); dataGridView1.DataSource = mDT; btnSaveAsTxt.Enabled = true; btnSaveAsXML.Enabled = true;
} catch { return; } }
ADO.NET
Strana 121
9. Dvostrukim klikom na dugme btnRestart kreiramo handler za event Click. Ovom metodom ćemo brisati trenutne podatke iz DataGrid kontrole private void btnRestart_Click(object sender, EventArgs e) { dataGridView1.DataSource = null; btnSaveAsTxt.Enabled = false; btnSaveAsXML.Enabled = false; }
10. Sada ćemo kreirati metodu PopuniGrid, preko koje ćemo popuniti DataGrid kontrolu podacima it Access-ove baze private void PopuniGrid() { OleDbConnection conn = new OleDbConnection(connString); conn.Open(); dt = null; OleDbDataAdapter da = null; OleDbCommand cmd = new OleDbCommand(); cmd.Connection = conn; cmd.CommandType = CommandType.Text; cmd.CommandText = "select * from Tabela"; dt = new DataTable(); da = new OleDbDataAdapter(cmd); da.Fill(dt); dataGridView1.DataSource = dt; conn.Close(); }
11. Dvostrukim klikom na Form1 kreiramo handler za event Load. Ovde ćemo pozvati metodu PopuniGrid private void Form1_Load(object sender, EventArgs e) { PopuniGrid(); }
12. Pritisnite F5 I testirajte aplikaciju.
ADO.NET
Strana 122
Slika 66: Prikaz podataka u ADO.NET aplikaciji Klikom na dume Sacuvaj kao tekst moći ćete da podatke iz DataGrid-a sačuvate kao txt fajl koji je u formatu prikazanom na sledećoj slici
Slika 67: Podaci smešteni u tekstualnom fajlu Klikom na dugme Sacuvaj kao XML podatke možete sačuvati u xml formatu
ADO.NET
Strana 123
Slika 68: Podaci smešteni u xml fajlu Klikom na dugmiće Otvori tekst i Otvori XML moćete otvoriti fajlove koje ste u predhodnom koraku kreirali.
ADO.NET
Strana 124
14.6 Vodič za izradu aplikacije „LogIn“ LogIn aplikacija, se veoma lako može spojiti sa bilo kojom drugom aplikacijom, a glavni cilj joj je da onemogući pristup glavnoj aplikaciji neregistrovanim korisnicima. Naravno, na sebi ima dugme koje vas vodi do registarske forme, tako da novi korisnici mogu sa lakoćom da se registruju i na taj način pristupe glavnoj aplikaciji. Za smeštanje podataka o korisnicima koristi Access-ovu bazu podataka. Veoma je korisna kada želite da vidite ko sve pristupa vašoj aplikaciji, mada veću primenu ima na Web aplikacijama, kada želite da dobijete informacije o svojim posetiocima. 14.6.1 Dodavanje kontrola Da bi ste kreirali ovaj projekat pratite sledeće korake. Celokupnu grafiku koja je korišćena pri izradi možete naći u folderu Resources. 1. Otvorite Visual C# i kreirajte nov Windows Forms projekat. U polju predvidjenom za ime projekta unesite ’LogIn’. 2. Desni klik na Form1 pa zatim Propertis. Otvara se Propertis prozor u kome treba izmeniti sledeće atribute: Atribut BackgroundImage FormBorderStyle Size StartPosition Text
Vrednost logIn.png None 370, 220 CenterScreen LogIn
3. Sa ToolBox-a prevucite sledeće kontrole i popunite njihove atribute vrednostima iz tabele. Kontrola TextBox
TextBox
Button Button ADO.NET
Atribut Name Location Size Name Location Size UseSzstemPasswordChar Name Location Size Text Name Location
Vrednost txtIme 162, 72 192, 20 txtPass 162, 116 192, 20 True btnLog 140, 166 101, 30 Prijava btnReg 247, 166 Strana 125
Size Text Image Button Location Size Vaša forma bi trebalo da izgleda ovako:
101, 30 Registracija Exit_32.png 349, 2 20, 20
Slika 69: Izgled LogIn prozora 4. Dodajte novu Formu i podesite sledeće atribute: Atribut
Vrednost
BackColor ControlBox FormBorderStyle ShowInTaskbar Size StartPosition
32, 54, 111 False FixedSingle False 445, 355 CenterScreen
5. Sa ToolBox-a prevucite sledeće kontrole i popunite njihove atribute vrednostima iz tabele. Kontrola Panel Label Label
PictureBox ADO.NET
Atribut BackColor Dock Name Location Name Location Text Image Location Size
Vrednost LemonChiffon Top lblkIme 51, 9 lblOdjava 366, 9 Odjavi se Bg_prof.png 259, 152 180, 180 Strana 126
6. Prevucite jos 13 Label kontrola i postavite ih kao na slici
Slika 70: Izgled profil prozora 7. Dodajte novu Formu i podesite sledeće atribute: Atribut BackColor ControlBox FormBorderStyle ShowInTaskbar Size StartPosition Text
Vrednost Linen False FixedSingle False 361, 419 CenterScreen Registracija
5. Sa ToolBox-a prevucite sledeće kontrole i popunite njihove atribute vrednostima iz tabele. Kontrola TextBox
TextBox TextBox ADO.NET
Atribut Name MaxLenght Size Name UseSzstemPasswordChar Size Name
Vrednost txtKime 15 195, 20 txtSifra True 195, 20 txtIme Strana 127
MaxLenght Size Name TextBox MaxLenght Size TextBox Name MaxLenght Size TextBox Name MaxLenght Size TextBox Name MaxLenght Size TextBox Name MaxLenght Size Button Name Size Text Button Name Image Size Text Button Name Image Size Text 6. Prevucite 15 Label kontrole i postavite ih kao na slici
ADO.NET
20 195, 20 txtPrezime 25 195, 20 txtGrad 20 195, 20 txtTelefon 20 195, 20 txtMail 30 195, 20 txtSite 30 195, 20 btnProvera 58, 21 Provera btnOk Check_32.png 75, 35 OK btnIzlaz exit_32.png 75, 35 Izlaz
Strana 128
Slika 71: Izgled prozora za registraciju 14.6.2 Kodiranje aplikacije 1. Prvo ćemo kreirati tri klase Korisnik, KorisnikBL i KorisnikDal (slika 65), koje će međusobno biti povezane, i utvrđivaće, da li je korisnik registrovan ili ne. 2. Kod klase Korisnik using using using using
System; System.Collections.Generic; System.Linq; System.Text;
namespace WindowsFormsApplication1 { class Korisnik { private string ime; private string password; public string Ime { get { return ime; } set { ime = value; } }
ADO.NET
Strana 129
}
public string Password { get { return password; } set { password = value; } }
}
3. Kod klase KorisnikBL using using using using
System; System.Collections.Generic; System.Linq; System.Text;
namespace WindowsFormsApplication1 { class KorisnikBL { public bool DaLiJeKorisnikRegistrovan(Korisnik korisnik) { korisnikDal dalKorisnik = new korisnikDal(); bool result = dalKorisnik.DaLiJeKorisnikRegistrovan(korisnik); return result; }
}
}
4. Kod klase KorisnikDal using using using using using using
System; System.Collections.Generic; System.Linq; System.Text; System.Data; System.Data.OleDb;
namespace WindowsFormsApplication1 { class korisnikDal { public bool DaLiJeKorisnikRegistrovan(Korisnik korisnik) { OleDbConnection conn =
ADO.NET
Strana 130
new OleDbConnection(@"Provider=Microsoft.Jet.OLEDB.4.0;Data Source=|DataDirectory|\logIn.mdb;Persist Security Info=True"); conn.Open(); OleDbCommand dbCom = new OleDbCommand(); dbCom.Connection = conn; dbCom.CommandType = CommandType.Text; dbCom.CommandText = String.Format("SELECT * FROM logIn " + "WHERE kime='{0}' AND sifra='{1}'", korisnik.Ime, korisnik.Password); object result = dbCom.ExecuteScalar(); conn.Close();
} }
if (result == null) { return false; } else { return true; }
}
5. Sada ćemo kodirati Form1. Dvostrukim klikom na dugme btnLogIn kreiramo handler za event Click. Ovom metodom ćemo pozvati predhodno kreirane klase I proveriti unesene podatke private void btnLog_Click(object sender, EventArgs e) { Korisnik korisnik = new Korisnik(); KorisnikBL blKorisnik = new KorisnikBL(); UzmiID uzmi = new UzmiID(); korisnik.Ime = txtIme.Text; korisnik.Password = txtPass.Text; bool result = blKorisnik.DaLiJeKorisnikRegistrovan(korisnik); if (result) { Form2 frm2 = new Form2(); frm2.txt = txtIme.Text; frm2.ShowDialog(); txtIme.Text = ""; txtPass.Text = ""; } else { MessageBox.Show("Neispravno korisnicko ime ili sifra!\nPokusajte ponovo.", "Greska", MessageBoxButtons.OK, MessageBoxIcon.Warning); txtIme.Focus();
ADO.NET
Strana 131
}
txtPass.Text = "";
}
6. Dvostrukim klikom na dugme btnReg kreiramo handler za event Click. Ovom metodom ćemo pozvati instancu Form3 klase I omogućiti novim korisnicima da se registruju private void btnReg_Click(object sender, EventArgs e) { Form3 frm = new Form3(); frm.ShowDialog(); }
7. Dvostrukim klikom na dugme button1 kreiramo handler za event Click. Ovom metodom ćemo moći da izađemo iz aplikacije private void button1_Click(object sender, EventArgs e) { Application.Exit(); }
8. Prelazimo na kodiranje Form2 forme. Dvostrukim klikom na label lblkIme kreiramo handler za event Click. Ovom metodom ćemo iz baze izvući podatke logovanog korisnika private void lblIme_Click(object sender, EventArgs e) { OleDbConnection conn = new OleDbConnection(@"Provider=Microsoft.Jet.OLEDB.4.0;Data Source=| DataDirectory|\logIn.mdb;Persist Security Info=True"); conn.Open(); OleDbCommand dbCom = new OleDbCommand(); dbCom.Connection = conn; OleDbDataReader rid = null; dbCom.CommandType = CommandType.Text; dbCom.CommandText = String.Format("SELECT * FROM logIn WHERE kime='" + lblkIme.Text + "'"); rid = dbCom.ExecuteReader(); rid.Read(); lblIme.Text = rid["ime"].ToString(); lblPrez.Text = rid["prezime"].ToString(); lblGrad.Text = rid["grad"].ToString(); lblTel.Text = rid["telefon"].ToString(); lblMeil.Text = rid["email"].ToString(); lblSajt.Text = rid["sajt"].ToString(); rid.Close(); conn.Close(); label1.Visible = true; label4.Visible = true; label5.Visible = true;
ADO.NET
Strana 132
}
label6.Visible = true; label7.Visible = true; label8.Visible = true; lblIme.Visible = true; lblPrez.Visible = true; lblGrad.Visible = true; lblTel.Visible = true; lblMeil.Visible = true; lblSajt.Visible = true;
9. Dvostrukim klikom na label lblkIme kreiramo handler za event Click. Ovom metodom ćemo odjavljivati sa forme private void label2_Click(object sender, EventArgs e) { this.Close(); }
10. Sada prelazimo na kodiranje Form3 forme. Dvostrukim klikom na dugme btnProveri kreiramo handler za event Click. Ovom metodom ćemo proveravati da li korisničko ime koje želimo da koristimo postoji u bazi. Ono mora biti jedinstveno da bi uspešno završili registraciju private void button2_Click(object sender, EventArgs e) { if (txtKime.Text != "") { OleDbConnection conn = new OleDbConnection(@"Provider=Microsoft.Jet.OLEDB.4.0;Data Source=| DataDirectory|\logIn.mdb;Persist Security Info=True"); conn.Open(); OleDbCommand dbCom = new OleDbCommand(); dbCom.Connection = conn; dbCom.CommandType = CommandType.Text; dbCom.CommandText = String.Format("SELECT kime FROM logIn " + "WHERE kime='{0}'", txtKime.Text); object result = dbCom.ExecuteScalar(); conn.Close();
je slobodno";
if (result == null) { lblProvera.Visible = true; lblProvera.Text = "Korisnicko ime '" + txtKime.Text + "' lblProvera.ForeColor = Color.Green;
} else {
lblProvera.Visible = true;
ADO.NET
Strana 133
lblProvera.Text = "Korisnicko ime '" + txtKime.Text + "'
je zauzeto"; }
lblProvera.ForeColor = Color.Red; ;
} else {
MessageBox.Show("Niste uneli korisnicko ime!", "Obavestenje", MessageBoxButtons.OK, MessageBoxIcon.Information); txtKime.Focus(); } }
11. Dvostrukim klikom na dugme btnOk kreiramo handler za event Click. Ovom metodom ćemo unete podatke sačuvati u bazu podataka private void button1_Click(object sender, EventArgs e) { try { if (txtKime.Text == "" || txtSifra.Text == "" || txtIme.Text == "" || txtPrezime.Text == "" || txtTelefon.Text == "") { MessageBox.Show("Unesite podatke u polja oznacena zvezdicom!", "Obavestenje", MessageBoxButtons.OK, MessageBoxIcon.Information); } else { OleDbConnection conn = new OleDbConnection(@"Provider=Microsoft.Jet.OLEDB.4.0;Data Source=| DataDirectory|\logIn.mdb;Persist Security Info=True"); conn.Open(); OleDbCommand cmd = new OleDbCommand(); cmd.Connection = conn; cmd.CommandType = CommandType.Text; cmd.CommandText = string.Format("INSERT INTO [logIn] (kime, sifra, ime, prezime, grad, telefon, email, sajt) VALUES ('{0}', '{1}', '{2}', '{3}', '{4}', '{5}', '{6}', '{7}')", txtKime.Text, txtSifra.Text, txtIme.Text, txtPrezime.Text, txtGrad.Text, txtTelefon.Text, txtMail.Text, txtSite.Text); cmd.ExecuteNonQuery(); conn.Close(); MessageBox.Show("Registracija je uspela!", "Obavestenje", MessageBoxButtons.OK, MessageBoxIcon.Information); }
this.Close();
} catch { MessageBox.Show("Proveite da li korisnicko ime vec postoji!", "Greska", MessageBoxButtons.OK, MessageBoxIcon.Warning); } }
ADO.NET
Strana 134
12. Dvostrukim klikom na dugme btnOk kreiramo handler za event Click. Ovom metodom ćemo izaći iz Registri forme bez čuvanja podataka private void button3_Click(object sender, EventArgs e) { this.Close(); }
13. Pritisnite F5 i testirajte aplikaciju. 14. Kada se aplikacija pokrene, ićićemo na dugme Registracija. Kada popunimo registri formu moćićemo da se logujemo na glavnu formu koja će se zvati kao naše korisničko ime. Klikom na label kontrolu koja nosi naše korisničko ime pojavljuju se ostali podaci (slika)
Slika 72: Prikaz logovanog korisnika Klikom na label Odjavi Se možemo se izlogovati sa aplikacije.
ADO.NET
Strana 135
14.7 Vodič za izradu aplikacije „Kolekcija filmova“ Ova aplikacija je namenjena za čuvanje nekih osnovnih informacija o filmovima koje posedujete u svojoj kolekciji. Vrlo lako možete dodavati nove filmove, ili brisati stare. Takođe, tu je i brza pretraga i to po Nazivu, Godini izdavanja, Kategoriji ili možete ptretražiti filmove koje jeste ili niste pogledali. Za čuvanje podataka koristi Access-ovu bazu. Jednostavnog je interfejsa tako da je veoma lak za upotrebu. 14.7.1 Dodavanje kontrola Da bi ste kreirali ovaj projekat pratite sledeće korake. Celokupnu grafiku koja je korišćena pri izradi možete naći u folderu Resources. 1. Otvorite Visual C# i kreirajte nov Windows Forms projekat. U polju predvidjenom za ime projekta unesite ’Kolekcija filmova’. 2. Desni klik na Form1 pa zatim Propertis. Otvara se Propertis prozor u kome treba izmeniti sledeće atribute: Atribut
Vrednost
FormBorderStyle MaximizeBox Size StartPosition Text
FixedSingle False 900, 567 CenterScreen Kolekciija filmova
3. Sa ToolBox-a prevučemo TabControl i kreiramo dva taba: Dodaj film i Pretraga/Editovanje baze. 4. Selektujemo prvi tab i na njega prevučemo sledeće kontrole Kontrola Button
TextBox TextBox TextBox ADO.NET
Atribut Name Image Size Text Name Size Name Size Name Size
Vrednost btnDodaj New_page.png 83, 37 Dodaj txtNaziv 332, 20 txtIzdavac 332, 20 txtGod 121, 20 Strana 136
ComboBox
RadioButton RadioButton PictureBox
Colection
Size Text Text Image Size
Avanturisticki, Komedija, Akcioni, Crtani film, Ljubavni Nadprirodni, Triler, Istorijski Drama, Horor, Sci-Fi, Kriminalisticki, Biografski, Dokumentarni 121, 21 Da Ne Bg1_png 500, 481
5. Dodajte Label kontrole i rasporedite ih kao na slici
Slika 73: Izgled aplikacije Kolekcija filmova 6. Slektujemo drugi tab TabControl-a i prevučemo sledeće kontrole Kontrola DataGridView
TabControl
Atribut BackgoundColor Size AddTab Size
ADO.NET
Vrednost White 850, 317 Pretraga po nazivu, Pretraga po kategoriji, Pretraga po pogledu, Pretraga po godini 850, 148 Strana 137
7. Sada ćemo na drugu TabControl-u na prvi tab prevući sledeće kontrole Kontrola
Atribut
Label
Text Name TextBox Size Name Button Image Size Name Button Image Size Prvi tab bi trebalo da izgleda ovako
Vrednost Naziv: txtNazivFilma 332, 20 btnTraziNaziv Search.png 75, 33 btnOsvezi refresh.png 75, 33
Slika 74: Tab – pretraga po nazivu 8. Sada ćemo na drugu TabControl-u na drugi tab prevući sledeće kontrole Kontrola
Atribut
Label
Text
ComboBox
Colection
Name Button Image Size Drugi tab bi trebalo da izgleda ovako
ADO.NET
Vrednost Kategorija: Avanturisticki, Komedija, Akcioni, Crtani film, Ljubavni Nadprirodni, Triler, Istorijski Drama, Horor, Sci-Fi, Kriminalisticki, Biografski, Dokumentarni btnTraziKategoriju Search.png 75, 33
Strana 138
Slika 75: Tab – pretraga po kategoriji 9. Sada ćemo na drugu TabControl-u na treći tab prevući sledeće kontrole Kontrola RadioButton RadioButton
Atribut
Text Text Name Button Image Size Treći tab bi trebalo da izgleda ovako
Vrednost Gledan Negledan btnTraziPogled Surch.png 75, 30
Slika 76: Tab – pretraga po pogledu 10. Sada ćemo na drugu TabControl-u na četvrti tab prevući sledeće kontrole Kontrola Label Label
Text Text Name Button Image Size TextBox Name TextBox Name Četvrti tab bi trebalo da izgleda ovako
ADO.NET
Atribut
Vrednost Pronadji film izmedju godine btnTraziGod Surch.png 75, 30 txtGod1 txtGod2
Strana 139
Slika 77: Tab – pretraga po godini 11. Projektu dodamo još jednu formu Atribut
Vrednost
FormBorderStyle MaximizeBox MinimizeBox Size StartPosition Text
FixedSingle False False 488, 308 CenterScreen Izmeni...
12. Novokreiranoj formi dodamo sledeće kontrole Kontrola GroupBox TextBox TextBox TextBox RadioButton RadioButton Button
Button
Atribut Size Text Name Size Name Size Name Size Text Text Name Image Size Name Image Size
Vrednost 457, 254 Izmeni film txtNaziv 332, 20 txtIzdavac 332, 20 txtGod 332, 20 Da Ne btnSacuvaj Save.png 103, 29 btnOdustani cancel.png 103, 29
13. odajte joč pet Label kontroli i postavite ih kao na slici
ADO.NET
Strana 140
Slika 78: Izgled Izmeni prozora 14.7.2 Kodiranje aplikacije Nakon što smo uradili interfejs aplikacije, ostaje nam da formu povežemo sa bazom podataka, a takođe moramo i neke kontrole međusobno povezati. Pratite uputstvo: 1. Desini klik na formu pa zatim izaberite opciju View Code. Prvo ćemo direktivom using uvesti namespace System.Data.OleDb jer koristimo Access-ovu bazu podataka (slika 59). 2. U telu klase Form1 definišemo: public OleDbConnection database; DataGridViewButtonColumn editButton; DataGridViewButtonColumn deleteButton; int movieIDInt;
3. Dvostrukim klikom na dugme btnDodaj kreiramo handler za event Click. Ovom metodom ćemo korisniku omogućiti da unese novi film u bazu podataka private void button6_Click(object sender, EventArgs e) { if (txtNaziv.Text == "") { MessageBox.Show("Niste uneli naziv filma!", "Upozorenje", MessageBoxButtons.OK, MessageBoxIcon.Warning); return; } string typeString; try { typeString = comboBox1.SelectedItem.ToString(); }
ADO.NET
Strana 141
catch { MessageBox.Show("Izaberite kategoriju filma!", "Upozorenje", MessageBoxButtons.OK, MessageBoxIcon.Warning); return; } int type = 0; string name = txtNaziv.Text.ToString(); string publisher = txtIzdavac.Text.ToString(); string year = txtGod.Text.ToString(); int yr = 0; try { if (year != "") { yr = CheckYear(year); } } catch { MessageBox.Show("Niste pravilno uneli godinu filma!", "Upozorenje", MessageBoxButtons.OK, MessageBoxIcon.Warning); return; } string previewed; if (radioButton1.Checked == true) { previewed = "Da"; } else { previewed = "Ne"; } if (yr != 1) { if (typeString == "Avanturisticki") type = 1; if (typeString == "Komedija") type = 2; if (typeString == "Akcioni") type = 3; if (typeString == "Crtani film") type = 4; if (typeString == "Ljubavni") type = 5; if (typeString == "Nadprirodni") type = 6; if (typeString == "Triler") type = 7; if (typeString == "Istorijski") type = 8; if (typeString == "Drama") type = 9; if (typeString == "Horor") type = 10; if (typeString == "Sci-Fi") type = 11; if (typeString == "Kriminalisticki") type = 12; if (typeString == "Biografski") type = 13; if (typeString == "Dokumentarni") type = 14; string SQLString =""; if (year == "") { SQLString = "INSERT INTO filmovi(Naziv, Izdavac, Gledan, KategorijaID) VALUES('" + name.Replace("'", "''") + "','" + publisher + "','" + previewed + "'," + type + ");"; }
ADO.NET
Strana 142
else { SQLString = "INSERT INTO filmovi(Naziv, Izdavac, Gledan, Godina, KategorijaID) VALUES('" + name.Replace("'", "''") + "','" + publisher + "','" + previewed + "'," + yr + "," + type + ");"; } OleDbCommand SQLCommand = new OleDbCommand(); SQLCommand.CommandText = SQLString; SQLCommand.Connection = database; int response = -1; try { response = SQLCommand.ExecuteNonQuery(); } catch { } if (response >= 1) MessageBox.Show("Film je dodat u bazu.","Uspesno",MessageBoxButtons.OK, MessageBoxIcon.Information); txtNaziv.Clear(); txtIzdavac.Clear(); txtGod.Clear(); comboBox1.ResetText(); radioButton1.Checked = radioButton2.Checked = false; } else { MessageBox.Show("Niste ispravno uneli godinu!", "Upozorenje",MessageBoxButtons.OK, MessageBoxIcon.Warning); txtGod.Clear(); txtGod.Focus(); } }
4. Dvostrukim klikom na dugme btnTraziNaziv kreiramo handler za event Click. Ovom metodom ćemo korisniku omogućiti da pretraži bazu po nazivu filma private void button1_Click(object sender, EventArgs e) { string title = txtNazivFilma.Text.ToString(); if (title != "") { string queryString = "SELECT filmID, Naziv, Izdavac, Gledan, Godina, Kategorija FROM filmovi,kategorije WHERE kategorije.KategorijaID = filmovi.KategorijaID AND filmovi.Naziv LIKE '" + title + "%'"; loadDataGrid(queryString); } else { MessageBox.Show("Unesite naziv filma","Upozorenje",MessageBoxButtons.OK,MessageBoxIcon.Warning); } }
ADO.NET
Strana 143
5. Dvostrukim klikom na dugme btnOsvezi kreiramo handler za event Click. Ovom metodom ćemo korisniku omogućiti da osveži bazu podataka private void button2_Click(object sender, EventArgs e) { txtNazivFilma.Clear(); string queryString = "SELECT filmID, naziv, Izdavac, Gledan, Godina, Kategorija FROM filmovi,kategorije WHERE kategorije.KategorijaID = filmovi.KategorijaID"; loadDataGrid(queryString); }
6. Dvostrukim klikom na dugme btnTraziKategoriju kreiramo handler za event Click. Ovom metodom ćemo korisniku omogućiti da pretraži bazu po kategoriji filma private void button5_Click(object sender, EventArgs e) { try { int type = 0; string typeString = comboBox2.SelectedItem.ToString(); if (typeString == "Avanturisticki") type = 1; if (typeString == "Komedija") type = 2; if (typeString == "Akcioni") type = 3; if (typeString == "Crtani film") type = 4; if (typeString == "Ljubavni") type = 5; if (typeString == "Nadprirodni") type = 6; if (typeString == "Triler") type = 7; if (typeString == "Istorijski") type = 8; if (typeString == "Drama") type = 9; if (typeString == "Horor") type = 10; if (typeString == "Sci-Fi") type = 11; if (typeString == "Kriminalisticki") type = 12; if (typeString == "Biografski") type = 13; if (typeString == "Dokumentarni") type = 14; string queryString = "SELECT filmID, Naziv, Izdavac, Gledan, Godina, Kategorija FROM filmovi,kategorije WHERE kategorije.KategorijaID = filmovi.KategorijaID AND filmovi.KategorijaID = " + type + ""; loadDataGrid(queryString); } catch { MessageBox.Show("Unesite kategoriju filma.", "Upozorenje", MessageBoxButtons.OK, MessageBoxIcon.Warning); }
}
7. Dvostrukim klikom na dugme btnTraziPogled kreiramo handler za event Click. Ovom metodom ćemo korisniku omogućiti da pretraži bazu po tom da li je film gledan ili ne private void button3_Click(object sender, EventArgs e) { string previewed;
ADO.NET
Strana 144
if (radioButton3.Checked == true) previewed = "Da"; else previewed = "Ne"; string queryString = "SELECT filmID, Naziv, Izdavac, Gledan, Godina, Kategorija FROM filmovi,kategorije WHERE kategorije.KategorijaID = filmovi.KategorijaID AND Gledan ='" + previewed + "'"; loadDataGrid(queryString); }
8. Dvostrukim klikom na dugme btnTraziGod kreiramo handler za event Click. Ovom metodom ćemo korisniku omogućiti da pretraži bazu po godini izdavanja filma private void button4_Click(object sender, EventArgs e) { try { string firstYear = txtGod1.Text.ToString(); string secondYear = txtGod2.Text.ToString(); ; int yr1 = CheckYear(firstYear); int yr2 = CheckYear(secondYear); if ((yr1 != 1 && yr2 != 1) && yr1 <= yr2) { string queryString = "SELECT filmID, Naziv, Izdavac, Gledan, Godina, Kategorija FROM filmovi,kategorije WHERE kategorije.KategorijaID = filmovi.KategorijaID AND filmovi.Godina BETWEEN " + yr1 + " AND " + yr2 + ""; loadDataGrid(queryString); } else { MessageBox.Show("Niste ispravno uneli godinu, pokusajte ponovo.", "Upozorenje", MessageBoxButtons.OK, MessageBoxIcon.Warning); txtGod1.Clear(); txtGod1.Focus(); txtGod2.Clear(); } } catch { MessageBox.Show("Niste ispravno uneli godinu, pokusajte ponovo.", "Upozorenje", MessageBoxButtons.OK, MessageBoxIcon.Warning); } }
9. Kreiramo metodu LoadDataGrid kojom ćemo puniti DataGrid kontrolu podacima iz baze. Takođe ćemo definisati I dve kolone koje će umesto podataka sadržati Button kontrole preko kojih ćemo moći da vršimo izmene nad selektovanim filmom, ili ga izbrisati public void loadDataGrid(string sqlQueryString) { OleDbCommand SQLQuery = new OleDbCommand(); DataTable data = null; dataGridView1.DataSource = null; SQLQuery.Connection = null;
ADO.NET
Strana 145
OleDbDataAdapter dataAdapter = null; dataGridView1.Columns.Clear(); // <-- clear columns //--------------------------------SQLQuery.CommandText = sqlQueryString; SQLQuery.Connection = database; data = new DataTable(); dataAdapter = new OleDbDataAdapter(SQLQuery); dataAdapter.Fill(data); dataGridView1.DataSource = data; dataGridView1.AllowUserToAddRows = false; // remove the null line dataGridView1.ReadOnly = true; dataGridView1.Columns[0].Visible = false; dataGridView1.Columns[1].Width = 340; dataGridView1.Columns[3].Width = 55; dataGridView1.Columns[4].Width = 50; dataGridView1.Columns[5].Width = 80; // insert edit button into datagridview editButton = new DataGridViewButtonColumn(); editButton.HeaderText = "Izmeni"; editButton.Text = "Izmeni"; editButton.UseColumnTextForButtonValue = true; editButton.Width = 80; dataGridView1.Columns.Add(editButton); // insert delete button to datagridview deleteButton = new DataGridViewButtonColumn(); deleteButton.HeaderText = "Izbrisi"; deleteButton.Text = "Izbrisi"; deleteButton.UseColumnTextForButtonValue = true; deleteButton.Width = 80; dataGridView1.Columns.Add(deleteButton); dataGridView1.AlternatingRowsDefaultCellStyle.BackColor = Color.LightSteelBlue; }
10. Sada ćemo kodirati drugu formu. Otvorite Form2. 1. Desini klik na formu pa zatim izaberite opciju View Code. Prvo ćemo direktivom using uvesti namespace System.Data.OleDb jer koristimo Access-ovu bazu podataka (slika 59). 11. U telu klase Form1 definišemo: public string year, publisher, title, previewed, type; public int movieID;
12. Dvostruki klik na pozadinu forme kreiraće se handler za event Load. private void Form2_Load(object sender, EventArgs e) { txtNaziv.Text = title; txtIzdavac.Text = publisher; txtGod.Text = year; comboBox1.Text = type; if (previewed == "Da") radioButton1.Checked = true; else if (previewed == "Ne") radioButton2.Checked = true;
ADO.NET
Strana 146
}
13. Dvostrukim klikom na dugme btnSacuvaj kreiramo handler za event Click. Ovom metodom ćemo sačuvati promene koje izvršimo nad filmom private void button6_Click(object sender, EventArgs e) { //sql query Form1 f1 = new Form1(); string typeString; title = txtNaziv.Text.ToString(); publisher = txtIzdavac.Text.ToString(); year = txtGod.Text.ToString(); int yr = 0; if (year != "") { yr = f1.CheckYear(year); } try { typeString = comboBox1.SelectedItem.ToString(); } catch (Exception ex) { MessageBox.Show("Selektujte kategoriju filma! \nError: " + ex.Message + ""); return; } int type = 0; if (radioButton1.Checked == true) { previewed = "Da"; } else { previewed = "Ne"; } if (yr != 1) { if (typeString == "Avanturisticki") type = 1; if (typeString == "Komedija") type = 2; if (typeString == "Akcioni") type = 3; if (typeString == "Crtani film") type = 4; if (typeString == "Ljubavni") type = 5; if (typeString == "Nadrealni") type = 6; if (typeString == "Triler") type = 7; if (typeString == "Istorijski") type = 8; if (typeString == "Drama") type = 9; if (typeString == "Horor") type = 10; if (typeString == "Sci-Fi") type = 11; if (typeString == "Kriminalisticki") type = 12; if (typeString == "Biografski") type = 13; if (typeString == "Dokumentarni") type = 14; string SQLUpdateString; if (year == "") {
ADO.NET
Strana 147
SQLUpdateString = "UPDATE filmovi SET Naziv ='" + title.Replace("'", "''") + "', Godina=NULL, Izdavac='" + publisher + "', KategorijaID=" + type + ", Gledan='" + previewed + "' WHERE filmID=" + movieID + ""; } else { SQLUpdateString = "UPDATE filmovi SET Naziv ='" + title.Replace("'", "''") + "', Godina=" + yr + ", Izdavac='" + publisher + "', KategorijaID=" + type + ", Gledan='" + previewed + "' WHERE filmID=" + movieID + ""; } OleDbCommand SQLCommand = new OleDbCommand(); SQLCommand.CommandText = SQLUpdateString; SQLCommand.Connection = f1.database; int response = SQLCommand.ExecuteNonQuery(); MessageBox.Show("Uspesno izvrsena promena!","Obavestenje",MessageBoxButtons.OK, MessageBoxIcon.Information); Close(); } else { MessageBox.Show("Pogresan format za godinu filma!\nMolimo Vas pokusajte ponovo.", "Upozorenje", MessageBoxButtons.OK, MessageBoxIcon.Warning); txtGod.Clear(); txtGod.Focus(); } }
14. Dvostrukim klikom na dugme btnOdustani kreiramo handler za event Click. Ovom metodom ćemo izaći iz forme bez čuvanja promena private void button1_Click(object sender, EventArgs e) { this.Close(); }
15.Pritisnite F5 I testirajte aplikaciju. Ako želimo da dodamo novi film, to ćemo uraditi tako što ćemo popuniti formu I kliknuti na dugme Dodaj. Ako unesemo neprihvatljive podatke, neće nam biti dozvoljeno da film sačuvamo. Sa druge strane, ako želimo samo da pregledamo koje filmove imamo, prebacujemo se na drugi tab, gde sa odgovarajućom pretragom možemo doći do željenog filma
ADO.NET
Strana 148
Slika 79: Prilaz rezultata pretrage za date godine Ovde recimo možemo videti pretragu filmova prema godini izdavanja. Rezultat su svi filmovi napravljeni između 1980. i 2000. godine. Kao što se može videti, svaki red ima dva dugmeta Izmeni i Izbriši preko kojih možemo vršiti izmene ili brisati selektovani film.
Zaključak Možemo zaključiti da ADO.NET u mnogome olakšava pristup izvorima podataka, koji predstavlja neku vrstu neizbežnosti koja prati razvoj .NET okruženja i pojavu novog pristupa podacima. Moguće je bilo i dalje korišćenje ADO-a, međutim postoje opravdani razlozi zašto ADO nije predviđen za novo .NET okruženje.
ADO.NET
Strana 149
ADO.NET je NET tehnologija za interakciju sa izvorom podataka. Imate nekoliko provajdera podataka koji omogućavaju komunikaciju sa različitim izvorima podataka, u zavisnosti od protokola koji koristite, ili od toga šta je ustvari baza podataka. Bez obzira koji se provajder koristi, vi ćete koristiti sličan skup objekata za interakciju sa izvorom podataka. Connection objekat vam omogućava da upravljate vezom sa izvorom podataka. Command objekat vam dozvoljava da razgovarate sa izvorom podataka i šaljete komande na njega. DataReader je tu kada želite brzo da pročitate podatke iz izvora podataka. Ako želite da radite u diskonektovanom okruženju, koristite DataSet, a možete i implementirati čitanje i pisanje iz izvora podataka koriđćenjem DataAdaptera.
ADO.NET
Strana 150
Literatura Internet resursi •
http://www.codeproject.com/KB/database/#ADO.NET
•
http://en.wikipedia.org/wiki/Ado.net
•
http://msdn.microsoft.com/en-us/library/e80y5yhx(VS.80)
•
http://www.csharp-station.com/Tutorials/AdoDotNet
•
http://www.sourcecodester.com/c-sharp
•
http://web.datadirect.com/resources/ado-net
•
http://www.c-sharpcorner.com
•
http://adonetsamples.codeplex.com/
•
http://www.devarticles.com/c/b/ADO.NET/
Ostali resursi •
Predavanja iz predmeta Projektovanje aplikacija baza podataka (Visoka Tehnička Škola Ktagujevac)
•
Materijal dobijen od profesora Zorana Mirovića.
ADO.NET
Strana 151