Εισαγωγή στη C#
και το .NET 4.0
ΣημειώσειςΣεμιναρίου
Επιμέλεια: Βασίλης Κόλιας Ενότητα 1  Θεωρητικό Υπόβαθρο  Το .NET Framework και η C#  To Visual Studio 1.0.0
ΠίνακαςΠεριεχομένων
Πίνακας Περιεχομένων ............................................................................................................................... 2 1. Εισαγωγή .......................................................................................................................................... 3 1.1. Γλώσσες και γλώσσες προγραμματισμού .................................................................................... 3 1.2. Κύκλος ανάπτυξης λογισμικού ..................................................................................................... 4 1.3. Πρότυπα Προγραμματισμού ........................................................................................................ 6 2. 1.3.1. Προστακτικός Προγραμματισμός ........................................................................................ 8 1.3.2. Συναρτησιακός Προγραμματισμός ...................................................................................... 8 1.3.3. Λογικός Προγραμματισμός ................................................................................................. 8 1.3.4. Αντικειμενοστρεφής Προγραμματισμός ............................................................................. 9 Το .NET framework και η C# ........................................................................................................... 13 2.1. Λίγη Ιστορία ............................................................................................................................... 13 2.2. Χαρακτηριστικά του .NET Framework ........................................................................................ 14 2.2.2. Αρχιτεκτονική του .NET Framework .................................................................................. 16 2.2.3. Εκδόσεις του .ΝΕΤ Framework .......................................................................................... 21 2.3. Η γλώσσα προγραμματισμού C# ................................................................................................ 22 3. 2.3.1. Χαρακτηριστικά της γλώσσας C#....................................................................................... 22 2.3.2. Ιστορικό εκδόσεων της C# ................................................................................................. 23 2.3.3. Το πρώτο πρόγραμμα σε C# .............................................................................................. 25 2.3.4. Μεταγλώττιση και εκτέλεση ενός προγράμματος ............................................................ 26 Microsoft Visual Studio ................................................................................................................... 32 3.1. Εκδόσεις του Visual Studio ......................................................................................................... 32 3.1.1. Visual Studio Express ......................................................................................................... 32 3.1.2. Visual Studio LightSwitch ................................................................................................... 32 3.1.3. Visual Studio Professional .................................................................................................. 33 3.1.4. Visual Studio Premium ....................................................................................................... 33 3.1.5. Visual Studio Ultimate ....................................................................................................... 33 3.2. Εγκατάσταση .............................................................................................................................. 33 3.3. Το περιβάλλον του Visual C# 2010 Express ................................................................................ 36 3.3.1. Ο Solution Explorer ............................................................................................................ 36 3.3.2. Τα παράθυρα εργαλείων ................................................................................................... 40 3.3.3. Ο επεξεργαστής κειμένου ................................................................................................. 42 2 1. Εισαγωγή
Η C# είναι μια σχετικά καινούργια γλώσσα, ενώ έχει γίνει μια από τις πιο διαδεδομέ‐
νες αντικειμενοστρεφείς γλώσσες προγραμματισμού. Πριν ξεκινήσουμε ωστόσο την περι‐
γραφή του .NET Framework και την ανάπτυξη εφαρμογών με τη γλώσσα προγραμματισμού C#, θα αναφερθούμε σύντομα στο θεωρητικό υπόβαθρο που είναι χρήσιμο κανείς να γνωρί‐
ζει πριν προχωρήσει. Το κεφάλαιο αυτό αποτελεί μια συντετμημένη παρουσίαση των θεω‐
ρητικών (παράγραφοι 1.1, 1.3) αλλά και πρακτικών (παράγραφος 1.2) εννοιών που είναι πο‐
λύ πιθανό να συναντήσει ένας προγραμματιστής τόσο κατά την παρακολούθηση του σεμι‐
ναρίου αλλά κυρίως στην μετέπειτα πορεία του στο χώρο. 1.1. Γλώσσες και γλώσσες προγραμματισμού
Η C# είναι μια γλώσσα προγραμματισμού. Ξεκινάμε αναλύοντας αυτούς τους δύο όρους. Όταν αναφερόμαστε στη γλώσσα (language) σαν γενική έννοια μπορεί να εννοούμε α) τη νοητική ικανότητα των ανθρώπων να εκθέτουν γλωσσολογική συμπεριφορά β) ένα αυστηρό σύστημα συμβόλων που υπακούουν σε γραμματικούς και συντακτικούς κανόνες για την επικοινωνία εννοιών και γ) ένα σύστημα επικοινωνίας για την παραγωγή συνεργατι‐
κού έργου. Τα κυριότερα μέρη μιας γλώσσας είναι α) το λεξιλόγιο συμβόλων (λέξεων) που σχετίζονται με μια έννοια και β) η γραμματική που είναι το σύνολο των κανόνων μορφοποί‐
ησης και τοποθέτησης (συντακτικό) των λέξεων μέσα σε προτάσεις. Οι γλώσσες διακρίνο‐
νται σε φυσικές γλώσσες, όπου ανήκουν οι ανθρώπινες γλώσσες και σε τεχνητές γλώσσες των οποίων το λεξικό και η γραμματική έχουν συνειδητά δημιουργηθεί από ένα άτομο ή σύ‐
νολο ατόμων για διευκόλυνση της επικοινωνίας ιδεών ή τη δημιουργία τέχνης. Στη δεύτερη κατηγορία ανήκουν οι τυπικές γλώσσες (formal languages), των οποίων το λεξικό και η γραμματική είναι καθορισμένα από αυστηρούς κανόνες. Η μελέτη των δομικών προτύπων τέτοιων γλωσσών γίνεται στην επιστήμη των υπολογιστών, ενώ χρησιμοποιούνται και στα Μαθηματικά και τη Λογική. Οι γλώσσες προγραμματισμού είναι τυπικές γλώσσες εμπλουτισμένες με σημασιολο‐
γία (semantics) που χρησιμοποιούνται για τον έλεγχο της συμπεριφοράς των ηλεκτρονικών υπολογιστών για την πραγματοποίηση συγκεκριμένων εργασιών. Όλες οι γλώσσες προ‐
γραμματισμού έχουν κάποια θεμελιώδη δομικά στοιχεία για την περιγραφή των δεδομένων και των διεργασιών ή των μετασχηματισμών που εφαρμόζονται σε αυτά και ορίζονται χρη‐
σιμοποιώντας συντακτικούς και σημασιολογικούς κανόνες για τον προσδιορισμό της δομής και της σημασίας τους αντίστοιχα. Οι κανόνες αυτοί περιγράφονται σε μια προδιαγραφή, γνωστή ως προδιαγραφή γλώσσας προγραμματισμού (programming language specification) και συνήθως είναι διαθέσιμη στο κοινό. Η προδιαγραφή της C# είναι διαθέσιμη από το Mi‐
crosoft Developers Network (MSDN). Τα κυριότερα δομικά στοιχεία των γλωσσών προγραμματισμού είναι το συντακτικό (syntax), η σημασιολογία (semantics) και η κύρια βιβλιοθήκη τους (core library). Το συντα‐
κτικό μιας γλώσσας περιγράφει τους πιθανούς συνδυασμούς των συμβόλων της γλώσσας που στοιχειοθετούν ορθές φράσεις σε ένα πρόγραμμα. Το νόημα ενός συγκεκριμένου συ‐
ντακτικώς ορθού συνδυασμού λέξεων καθορίζεται στη σημασιολογία. Για παράδειγμα τα σύμβολα «”Hello” + “World”» να σημαίνουν τη συνένωση των λέξεων Hello World και όχι την πρόσθεση δυο μεταβλητών. Η κύρια βιβλιοθήκη μιας γλώσσας, που συνήθως αποτελεί και μέρος της προδιαγραφής της, είναι ένα σύνολο κώδικα για την τέλεση βασικών λειτουρ‐
γιών όπως το διάβασμα και το γράψιμο δεδομένων, ή παρέχει την υλοποίηση βασικών αλ‐
γορίθμων και δομών δεδομένων. Οι περισσότερες γλώσσες προγραμματισμού είναι καθαρά κειμενικές (textual): χρη‐
σιμοποιούν σειρές κειμένου που περιλαμβάνουν λέξεις, αριθμούς και σημεία στίξης. Υπάρ‐
χουν ωστόσο μερικές γλώσσες που είναι από στη φύση τους πιο οπτικές (visual program‐
ming languages), αφού χρησιμοποιούν εικονικές σχέσεις μεταξύ συμβόλων για να καθορί‐
3 σουν ένα πρόγραμμα. Παράδειγμα γραφικής γλώσσας είναι η γλώσσα G, που χρησιμοποιεί‐
ται στην πλατφόρμα LabVIEW. Οι γλώσσες προγραμματισμού δεν είναι εύκολο να κατηγοριοποιηθούν πρωταρχικά, καθώς συνδυάζουν τα στοιχεία τους με νέες ιδέες, ορισμένες εκ των οποίων μπορεί να μην είναι ευδιάκριτες στις φαινομενικά όμοιές τους. Διακρίσεις των γλωσσών προγραμματισμού ωστόσο μπορούν να γίνουν ανάλογα με το προγραμματιστικό πρότυπο (παράγραφος 1.3) που ακολουθούν και ενδεχομένως το πεδίο χρήσης για το οποίο προορίζονται. Επίσης οι γλώσσες προγραμματισμού χωρίζονται σε επίπεδα. Στο χαμηλότερο βρίσκεται η μοναδική γλώσσα την οποία «κατανοεί» ένας επεξεργαστής: ένα σύστημα εντολών που εκτελούνται κατευθείαν από αυτόν. Αυτό είναι το χαμηλότερο επίπεδο γλώσσας στο οποίο μπορεί να γραφτεί ένα πρόγραμμα και είναι γνωστό ως γλώσσα μηχανής. Το επίπεδο των υπόλοιπων γλωσσών εξαρτάται από το πόσο μοιάζουν με τον κώδικα μηχανής. Τα προγράμματα σε γλώσσες χαμηλού επιπέδου έχουν το πλεονέκτημα ότι μπορούν να εκμεταλλευτούν όλα τα χαρακτηριστικά που μπορεί να έχει η αρχιτεκτονική του συγκε‐
κριμένου επεξεργαστή όπου τρέχουν. Κατά συνέπεια, μπορεί να είναι πολύ αποδοτικά, α‐
φού χρησιμοποιούν τον επεξεργαστή με το βέλτιστο τρόπο. Η δημιουργία τέτοιων προ‐
γραμμάτων απαιτεί αρκετό χρόνο τόσο για την εκμάθηση του (σχετικά δύσκολου) συντακτι‐
κού τους όσο και για την ανάπτυξή τους, αλλά και πλήρη κατανόηση της λειτουργίας του ε‐
πεξεργαστή. Για το λόγο αυτό ο προγραμματισμός σε χαμηλό επίπεδο γίνεται για πολύ μι‐
κρά προγράμματα ή για τμήματα κώδικα που επιτελούν πολύ σημαντικές εργασίες και είναι απαραίτητο να τρέχουν όσο αποδοτικότερα γίνεται. Οι γλώσσες υψηλού επιπέδου αναπαριστούν αφηρημένα τις λεπτομέρειες του υπο‐
λογιστή, χρησιμοποιούν εκτενώς φυσική γλώσσα, είναι ευκολότερες στη χρήση και συνεπώς επιτρέπουν τη γρήγορη δημιουργία μεγάλων προγραμμάτων. Το τελικό πρόγραμμα μπορεί να μην είναι όσο αποδοτικό όσο το αντίστοιχο σε γλώσσα χαμηλού επιπέδου, ωστόσο το κέρδος στο χρόνο ανάπτυξης υπερκεράζει την απόδοση των τελικών προγραμμάτων. Υπάρ‐
χουν δύο κύρια μοντέλα εκτέλεσης των υψηλών γλωσσών προγραμματισμού: α) οι διερμη‐
νευμένες γλώσσες (interpreted languages) οι οποίες διαβάζονται από ένα ειδικό πρόγραμμα που καλείται διερμηνευτής (interpreter), μετατρέπονται σε γλώσσα μηχανής από αυτό και εκτελούνται άμεσα χωρίς φάση μεταγλώττισης (π.χ. η PHP και η Python) και β) οι μεταγλωτ‐
τισμένες γλώσσες (compiled languages) που πριν την εκτέλεσή τους μετατρέπονται σε μια εκτελέσιμη μορφή: είτε κώδικα μηχανής (π.χ. η C και η C++) είτε ενδιάμεσης μορφής που χρειάζεται να διερμηνευτεί για να εκτελεστεί (π.χ. η Java και η C#). Υπάρχουν επίσης και συνδυασμοί των παραπάνω μοντέλων όπως της Java, που συνδυάζουν τη μεταγλώττιση με τη διερμηνεία, χρησιμοποιώντας ταυτόχρονα και τη μέθοδο just‐in‐time compilation για τη βελτίωση της ταχύτητας της διερμηνείας. Σημαντικές γλώσσες στον προγραμματισμό είναι τέλος είναι και οι γλώσσες σήμαν‐
σης (markup languages). Μια γλώσσα σήμανσης είναι ένα μοντέρνο σύστημα προσθήκης σημάνσεων (markup) σε κείμενο με τέτοιον τρόπο ώστε να είναι συντακτικά ευδιάκριτες από το κείμενο στο οποίο προστίθενται. Οι γλώσσες σήμανσης δεν είναι γλώσσες προγραμ‐
ματισμού ωστόσο χρησιμοποιούνται ευρέως σε μια μεγάλη γκάμα εφαρμογών εξαιτίας της περιγραφικής δύναμής τους. Οι σημάνσεις που μπορούν να προστεθούν σε ένα κείμενο, μπορούν να είναι α) παρουσιαστικές (presentational markup) δηλαδή να χρησιμοποιούνται για να προσδιορίσουν το παρουσιαστικό του κειμένου στο οποίο αναφέρονται (π.χ. η HTML), β) διαδικαστικές (procedural markup) για να παρέχουν οδηγίες σε άλλα προγράμμα‐
τα για το πώς να επεξεργάζονται το κείμενο που περιέχουν (π.χ. η ΤΕΧ) και γ) περιγραφικές (descriptive markup) που απλώς παρέχουν μια ετικέτα στο κείμενο στο οποίο αναφέρονται (π.χ. η XML). 1.2. Κύκλος ανάπτυξης λογισμικού
Ένας απλός ορισμός που αποδίδει ικανοποιητικά την έννοια του προγραμματισμού υπολογιστών (computer programming) είναι η ικανότητα της επικοινωνίας του προγραμμα‐
τιστή με τον υπολογιστή σε μια αμοιβαίως αντιληπτή γλώσσα προγραμματισμού για την πραγματοποίηση χρήσιμων εργασιών. Ο προγραμματισμός ωστόσο αποτελεί μόνο ένα κομ‐
μάτι της ανάπτυξης λογισμικού. Κατά συνέπεια ένας προγραμματιστής είναι πιθανό να ε‐
μπλακεί σε δραστηριότητες πέραν της γραφής κώδικα, ειδικά αν συμμετέχει σε ολιγομελείς 4 ομάδες ανάπτυξης. Πέραν τούτου, είναι γενικά χρήσιμο να γνωρίζει τα στάδια που ακολου‐
θούνται στην ανάπτυξη έργων λογισμικού. Η διαδικασία της ανάπτυξης λογισμικού λοιπόν, περιλαμβάνει τις διαδικασίες της ανάλυσης απαιτήσεων, του σχεδιασμού, της γραφής, της δοκιμής, της αποσφαλμάτωσης και της διατήρησης του πηγαίου κώδικα των προγραμμάτων γραμμένων σε μια γλώσσα (ή και περισσότερες). Ένας προγραμματιστής είναι καλό να κατα‐
νοεί τις μεθόδους και τις πρακτικές που εφαρμόζονται σε κάθε μια από τις παραπάνω δια‐
δικασίες, δίνοντας έμφαση κατ’ εξοχήν στη γραφή κώδικα. Ωστόσο ο προγραμματισμός δεν περιορίζεται μόνο στις παραπάνω διαδικασίες: συχνά απαιτείται και η εξειδίκευση σε πολ‐
λαπλές διαφορετικές πρακτικές ή θεωρητικές έννοιες, όπως οι αλγόριθμοι και η λογική ή ακόμα και από άλλα επιστημονικά πεδία όπως η φυσική. Ανάλυση απαιτήσεων
Η επιτυχία οποιουδήποτε έργου λογισμικού εξαρτάται σε μεγάλο βαθμό από τον αρ‐
χικό εντοπισμό των απαιτήσεων του υπό ανάπτυξη συστήματος τόσο μέσα από τη λήψη των ζητουμένων των πελατών, όσο και από την ανάδειξη των διαφόρων υπο‐προβλημάτων που μπορεί να προκύψουν. Το πρώτο βήμα στην ανάπτυξη ενός έργου λογισμικού είναι η ανά‐
λυση απαιτήσεων (requirement analysis). Το αποτέλεσμα του πρώτου αυτού βήματος είναι προδιαγραφές τεχνολογικές, επιχειρηματικές, λειτουργικές, κόστους και χρονικής διάρκειας. Σχεδιασμός λογισμικού
Η διαδικασία του σχεδιασμού λογισμικού (software design) είναι το επόμενο βήμα κατά την ανάπτυξη λογισμικού οποιασδήποτε κλίμακας και περιλαμβάνει τη χάραξη του γε‐
νικού σχεδίου επίλυσης του προβλήματος το οποίο το λογισμικό καλείται να επιλύσει. Η δι‐
αδικασία του σχεδιασμού λαμβάνει σαν είσοδο α) τα αποτελέσματα της ανάλυσης λογισμι‐
κού που γενικά είναι τα «ευκολότερα» υπο‐προβλήματα στα οποία μπορεί να διαιρεθεί το αρχικό πρόβλημα προς επίλυση και β) τις δυνατότητες του περιβάλλοντος που θα φιλοξενή‐
σει το λογισμικό (π.χ. το λειτουργικό σύστημα ή η πλατφόρμα εκτέλεσης). Το αποτέλεσμα του σχεδιασμού μπορεί να είναι απλώς ένα διάγραμμα ροής (flow chart), ένα κείμενο που περιγράφει μια ακολουθία γεγονότων ή ένα μοντέλο σε κάποια γλώσσα μοντελοποίησης (modeling language) όπως η UML (Unified Modeling Language) ή η BPMN (Business Process Modeling Notation) μαζί φυσικά με την απαραίτητη τεκμηρίωση (documentation). Γραφή κώδικα
Η διαδικασία της γραφής κώδικα (coding) ή κωδικογράφησης, είναι η μετατροπή του σχεδιασμού και γενικότερα της λογικής του λογισμικού σε κώδικα μιας γλώσσας προγραμ‐
ματισμού. Η γραφή κώδικα απαιτεί πλήρη γνώση της χρησιμοποιούμενης γλώσσας προ‐
γραμματισμού (συντακτικό, σημασιολογία, κύριες βιβλιοθήκες) καθώς ελλιπής γνώση μπο‐
ρεί να οδηγήσει σε άσκοπο γράψιμο κώδικα που υπάρχει ήδη ή την επιλογή λανθασμένων μονοπατιών υλοποίησης. Σε μεγάλα έργα προγραμματισμού υιοθετούνται συχνά ένα σύνο‐
λο προτύπων, κατευθύνσεων ή συμβάσεων γραφής με σκοπό τη βελτίωση της ποιότητας, της αναγνωσιμότητας και της ευκολίας της συντήρησης του κώδικα. Τα πρότυπα αυτά περι‐
λαμβάνουν κανόνες ονομασίας και οργάνωσης των αρχείων ή των λέξεων στον κώδικα, τη δόμηση του κώδικα σε μπλοκ με εσοχές για να τονίζουν το επίπεδο ένθεσης του ή τη μορ‐
φοποίηση των διαφόρων εντολών. Τα πρότυπα μπορεί να διαφέρουν από γλώσσα σε γλώσ‐
σα και τα πιο διαδεδομένα είναι τα πρότυπα κωδικογράφησης GNU, το στυλ του πυρήνα BSD και οι συμβάσεις κώδικα στη Java. Αποσφαλμάτωση
Η γραφή κώδικα είναι μια ανθρώπινη διαδικασία και κατά συνέπεια είναι υποκείμε‐
νη σε σφάλματα που μπορεί να οφείλονται σε παραλήψεις ή απρόβλεπτους παράγοντες. Η αποσφαλμάτωση (debugging) είναι η μεθοδική διαδικασία της εύρεσης και του περιορισμού των σφαλμάτων (bugs) και των ελαττωμάτων στον κώδικα ενός προγράμματος. Γενικά απο‐
τελείται από τα βήματα της αναπαραγωγής του προβλήματος, της απομόνωσης του σημείου που εμφανίζεται το σφάλμα, της αναγνώρισης της αιτίας που το προκαλεί, της διόρθωσης του σφάλματος και της επιβεβαίωσης της απαλοιφής του προβλήματος. Η αποσφαλμάτωση 5 είναι μια αρκετά επίπονη διαδικασία και για το λόγο αυτό αναπτύχθηκαν ειδικά προγράμ‐
ματα για το σκοπό αυτό: οι debuggers (αποσφαλματωτές). Έλεγχος λογισμικού
Στη διαδικασία του ελέγχου λογισμικού (software testing) βεβαιώνεται ότι το αποτέ‐
λεσμα της συγγραφής πληροί τις προδιαγραφές όπως αυτές ορίστηκαν στην ανάλυση και το σχεδιασμό, ότι δουλεύει όπως αναμενόταν και ότι μπορεί να εγκατασταθεί για εφαρμογή με τα ίδια χαρακτηριστικά. Υπάρχουν διάφορες μέθοδοι ελέγχου που μπορούν να γίνουν σε δι‐
αφορετικά επίπεδα, ανάλογα με την πρόσβαση στο κάθε τμήμα κώδικα. Ο έλεγχος μπορεί να φτάσει στα θεμελιώδη τμήματα του κώδικα ή να αντιμετωπίσει την εφαρμογή στην ολό‐
τητά της. Ο έλεγχος μπορεί να πραγματοποιείται και για μεμονωμένα τμήματα κώδικα κατά την ανάπτυξη του αλλά παραδοσιακά γίνεται μετά την ολοκλήρωση της ανάπτυξης του. Συντήρηση κώδικα
Ακόμα και μετά την αποσφαλμάτωση και τον έλεγχο του λογισμικού μπορούν να ε‐
ντοπιστούν προβλήματα στο σχεδιασμό ή την υλοποίηση ή ακόμα και να προστεθούν νέες απαιτήσεις. Επειδή η αλλαγή είναι έμφυτη στην ανάπτυξη λογισμικού, η ανάγκη του ελέγ‐
χου της οργάνωσης και της εξέλιξης της ανάπτυξης του κώδικα είναι επιτακτική, ιδιαίτερα για τα έργα μεγάλης κλίμακας. Η διαδικασία της συντήρησης κώδικα (code maintenance) εί‐
ναι ουσιαστικά ο έλεγχος εκδόσεων (revision control) του πηγαίου κώδικα και περιλαμβάνει τον έλεγχο της εξέλιξης του μέσα στο χρόνο, κρατώντας ένα χρονικό για το σκεπτικό πίσω από τις υφιστάμενες αλλαγές. Υπάρχει μια πληθώρα συστημάτων ελέγχου εκδόσεων (revi‐
sion control systems) όπως τα CVS και Subversion (SVN) που χρησιμοποιούνται κατά κόρον σε έργα ανοιχτού κώδικα και τον Team Foundation Server για έργα στην πλατφόρμα .NET. Οι αρχές του προγραμματισμού είναι ανεξάρτητες της γλώσσας που χρησιμοποιείται. Κάθε γλώσσα έχει τα δυνατά και αδύναμα σημεία της, καθιστώντας έτσι την ανάπτυξη κά‐
ποιων προγραμμάτων ευκολότερη ή δυσκολότερη σε αυτές. Ένας πεπειραμένος προγραμ‐
ματιστής θα βρει σχετικά εύκολη τη μετάβαση από μια γλώσσα σε μια άλλη καθώς το ουσι‐
αστικότερο πράγμα που πρέπει να κάνει είναι να εντοπίσει πως υλοποιούνται οι προγραμ‐
ματιστικές αρχές στη νέα γλώσσα. Τα περισσότερα μαθήματα προγραμματισμού επικεντρώ‐
νονται στο γράψιμο των προγραμμάτων από το μηδέν. Ωστόσο αρκετά μεγάλο ποσοστό της ανάπτυξης λογισμικού καταναλώνεται αφού έχει γραφεί ο κώδικας και πιο συγκεκριμένα στην ανάγνωση, την κατανόηση και την τροποποίηση του αρχικού κώδικα. Η εκμάθηση της ανάγνωσης κώδικα είναι επίσης μια απαραίτητη ικανότητα για έναν προγραμματιστή ιδιαίτερα σήμερα, στην εποχή της επαναχρησιμοποίησης κώδικα και της συνεργατικής ανάπτυξης σε απαιτητικά εταιρικά περιβάλλοντα. Το λογισμικό ανοιχτού κώ‐
δικα (open source software) παρέχει πρόσβαση σε εκατομμύρια γραμμές κώδικα για ανά‐
γνωση, κριτική, τη δυνατότητα βελτίωσης από τον πεπειραμένο χρήστη και εκμάθησης για τον αρχάριο. Για το λόγο αυτό είναι καλή πρακτική η ανάγνωση ποιοτικού κώδικα που έχει γραφτεί για λογισμικό ανοικτού κώδικα, καθώς έχει συζητηθεί, συγκεκριμενοποιηθεί, γενι‐
κευτεί και τεκμηριωθεί από αρκετούς και κυρίως έμπειρους προγραμματιστές. Η ανάγνωση κώδικα επομένως είναι πιθανό να ανεβάσει το αισθητικό κριτήριο του προγραμματιστή για τον κώδικα που παράγει, όπως ακριβώς η ανάγνωση ποιοτικού πεζού λόγου εμπλουτίζει το λεξιλόγιο, ενεργοποιεί τη φαντασία και διευρύνει το νου του αναγνώστη. Δεν είναι τυχαίος λοιπόν ο χαρακτηρισμός του προγραμματισμού σαν μια μορφή τέχνης. 1.3. Πρότυπα Προγραμματισμού
Για να ξεκινήσει κανείς τη μελέτη της C# και του αντικειμενοστρεφούς προγραμματι‐
σμού τον οποίο αυτή ακολουθεί, πρέπει να κατανοήσει τη γενικότερη φιλοσοφία και τα χα‐
ρακτηριστικά του. Ταυτόχρονα θα ήταν σκόπιμο να τον συγκρίνει με τα κυριότερα προγραμ‐
ματιστικά πρότυπα (programming paradigms) που υπάρχουν. Σε αυτήν την παράγραφο, α‐
φού αναφερθούμε στην έννοια του προγραμματιστικού προτύπου, θα αναφέρουμε εν συ‐
ντομία τα θεμελιώδη χαρακτηριστικά μερικών σημαντικών προτύπων και θα καταλήξουμε με την αναλυτική παρουσίαση του αντικειμενοστρεφούς προγραμματισμού. Ξεκινώντας από τον αντίστοιχο αγγλικό όρο, η λέξη paradigm σημαίνει κάτι που χρη‐
σιμεύει σαν πρότυπο ή μοντέλο, σημαίνει δηλαδή ακριβώς ό,τι και η ελληνική λέξη παρά‐
6 δειγμα. Ωστόσο στη λέξη προσδόθηκε και μια ελαφρώς πιο πολύπλοκη έννοια, αυτή του θεωρητικού πλαισίου επιστημονικών αρχών όπου ενυπάρχει η θεωρία με την πράξη (δηλα‐
δή την απόδειξη ότι ισχύει η θεωρία) που την υποστηρίζει. Συχνά συνοδεύεται από τη λέξη scientific που της προσδίδει τη δεύτερη αυτήν έννοια. Η έννοια του προγραμματιστικού προτύπου στηρίζεται στη δεύτερη από τις παραπά‐
νω ετυμολογίες. Ένα προγραμματιστικό πρότυπο λοιπόν είναι μια προσέγγιση για τον προ‐
γραμματισμό υπολογιστών που βασίζεται σε κάποια μαθηματική θεωρία ή ένα αυστηρό σύ‐
νολο κανόνων. Κάθε πρότυπο περιέχει ένα σύνολο εννοιών που το καθιστούν ιδανικό για την επίλυση συγκεκριμένου είδους προβλημάτων. Για παράδειγμα, ο αντικειμενοστρεφής προγραμματισμός είναι ιδανικός για προβλήματα με ένα μεγάλο πλήθος αφαιρέσεων δεδο‐
μένων (data abstractions), οργανωμένων σε μια ιεραρχία ενώ ο λογικός προγραμματισμός (logic programming) είναι ιδανικός για το μετασχηματισμό πολύπλοκων συμβολικών δομών σύμφωνα με κανόνες λογικής. Υπάρχουν περίπου 27 διαφορετικά προγραμματιστικά πρό‐
τυπα, αρκετά από τα οποία ωστόσο έχουν κοινά στοιχεία μεταξύ τους. Τα προγραμματιστικά πρότυπα δεν πρέπει να συγχέονται με τις τεχνικές προγραμ‐
ματισμού (programming techniques) οι οποίες σχετίζονται με τις αλγοριθμικές ιδέες για την επίλυση προβλημάτων κάποιας συγκεκριμένης τάξης (π.χ. διαίρει και βασίλευε), ούτε και με το στυλ προγραμματισμού, δηλαδή την αποτύπωση της προσωπικής έκφρασης του προ‐
γραμματιστή μέσα στον τον κώδικα. Η επίλυση ενός προγραμματιστικού προβλήματος απαιτεί σωστές προσεγγίσεις. Α‐
κόμα και τα πιο απλά προβλήματα ενδέχεται να χρειάζονται διαφορετική προσέγγιση σε διάφορα μέρη τους (υπο‐προβλήματα). Για το λόγο αυτό, είναι ιδανικό μια γλώσσα προ‐
γραμματισμού να υποστηρίζει περισσότερα από ένα προγραμματιστικά πρότυπα. Κατά πολ‐
λούς είναι ατυχές το γεγονός ότι δημοφιλείς γλώσσες όπως η Java ή η C++ υποστηρίζουν ένα ή δυο πρότυπα μόνο. Η υποστήριξη πολλαπλών προτύπων σε μια γλώσσα επιτρέπει στους προγραμματιστές να επιλέξουν τις σωστές έννοιες όταν τις χρειάζονται άμεσα. Οι γλώσσες που υποστηρίζουν πολλαπλά πρότυπα συχνά καλούνται «πολυπρότυπες» (multiparadigm). Είναι δυνατόν ωστόσο να υλοποιηθεί, εν μέρει ή και πλήρως, ένα πρότυπο σε μια γλώσσα που δεν το υποστηρίζει, αφού αυτό έχει κατανοηθεί πλήρως. Για παράδειγμα ο συναρτησι‐
ακός προγραμματισμός είναι δυνατόν να υποστηριχθεί στην C#. Για να κατανοηθούν καλύτερα τα διαφορετικά προγραμματιστικά πρότυπα θα ήταν χρήσιμο να αναφερθούμε εν συντομία στην έννοια της κατάστασης ενός προγράμματος (program state) δηλαδή του μοντέλου αποθήκευσης δεδομένων στη μνήμη που ακολουθεί‐
ται από μια γλώσσα. Όσο τρέχει ένα πρόγραμμα, πρέπει να αποθηκεύονται και να ανακτώ‐
νται δεδομένα στη μνήμη. Το μέγεθος της μνήμης που απαιτείται, η τοποθεσία και ο τρόπος αποθήκευσής τους, εξαρτάται από τον τύπο τους. Ένα πρόγραμμα σε εκτέλεση χρησιμοποιεί δύο περιοχές όπου αποθηκεύονται το πρόγραμμα και τα δεδομένα: τη στοίβα (stack) και το σωρό (heap). Η στοίβα αποτελείται από θέσεις μνήμης όπου αποθηκεύονται δεδομένα με τη δομή last‐in, first‐out (LIFO). Όταν ένα πρόγραμμα εκτελείται, χρησιμοποιεί έναν ειδικό καταχω‐
ρητή (register), τον δείκτη στοίβας (stack pointer), ο οποίος δείχνει την εγγραφή ενεργοποί‐
ησης (activation record) στην κορυφή της στοίβας. Η στοίβα περιέχει μια εγγραφή ενεργο‐
ποίησης για κάθε κλήση μεθόδου ή συνάρτησης της οποίας η εκτέλεση δεν έχει ολοκληρω‐
θεί ακόμα στο πρόγραμμα. Όταν καλείται μια συνάρτηση, μια εγγραφή ενεργοποίησης ει‐
σάγεται (pushed) στη στοίβα, ενώ όταν τελειώνει η εκτέλεσή της, η εγγραφή ενεργοποίησης εξάγεται και ο δείκτης της στοίβας δείχνει στην αμέσως προηγούμενη εγγραφή. Μια εγγραφή ενεργοποίησης περιέχει πληροφορίες για τη συνάρτηση που εκτελείται μια δεδομένη χρονική στιγμή, όπως τις τοπικές μεταβλητές της συνάρτησης, την τιμή του μετρητή προγράμματος (program counter) πριν την κλήση της συνάρτησης ή οι παράμετροι που περνιούνται στη συνάρτηση. Τα δεδομένα που είναι διαθέσιμα από παντού στον κώδικα (καλούνται στατικά ή κα‐
θολικά) αποθηκεύονται ή όχι ανάλογα με τη γλώσσα προγραμματισμού που χρησιμοποιεί‐
ται και η τοποθεσία τους στη μνήμη εξαρτάται από την υλοποίηση του μεταγλωττιστή ή δι‐
ερμηνευτή. Στα δεδομένα αυτά περιλαμβάνονται οι σταθερές και οι καθολικές μεταβλητές οι οποίες είναι διαθέσιμες σε όλες τις μεθόδους/συναρτήσεις. Ένας προγραμματιστής, δεν χρειάζεται να επέμβει στη διαδικασία διαχείρισης της στοίβας, αφού την αναλαμβάνει το εκάστοτε σύστημα. Ωστόσο η κατανόηση της λειτουργι‐
7 κότητάς της δίνει μια καλύτερη αντίληψη του τι κάνει ένα πρόγραμμα όταν τρέχει και διευ‐
κολύνει την κατανόηση της τεκμηρίωσης μιας γλώσσας και της βιβλιογραφίας. Ο σωρός είναι μια περιοχή στη μνήμη για δυναμική δέσμευση/αποδέσμευση, δηλα‐
δή για χρήση της μνήμης κατά την εκτέλεση του προγράμματος. Κάθε δεδομένο που δημι‐
ουργείται κατά την εκτέλεση, αποθηκεύεται στο σωρό. Οι τιμές που βρίσκονται σε θέσεις μνήμης στο σωρό δεν συνδέονται με ονόματα αλλά με μεταβλητές που έχουν όνομα: τους δείκτες ή τις αναφορές. Επίσης η τοποθέτησή και η αφαίρεσή τους στο σωρό γίνεται με ο‐
ποιαδήποτε σειρά. Σε αρκετές γλώσσες προγραμματισμού, όπως η C#, η αφαίρεση (διαγρα‐
φή) δεδομένων από το σωρό δεν γίνεται από τον προγραμματιστή αλλά αυτόματα με έναν μηχανισμό γνωστό ως garbage collection. 1.3.1. Προστακτικός Προγραμματισμός
Στον προστακτικό προγραμματισμό (imperative programming) ένα πρόβλημα επιλύε‐
ται υπολογιστικά μέσω προτάσεων (statements) που αλλάζουν την κατάσταση του προ‐
γράμματος. Όπως στις φυσικές γλώσσες το προστακτικό ύφος εκφράζει εντολές που πρέπει να φερθούν εις πέρας από έναν άνθρωπο, τα προστακτικά προγράμματα ορίζουν μια ακο‐
λουθία εντολών προς εκτέλεση από τον υπολογιστή. Εδώ ο προγραμματιστής γράφει κώδικα που περιγράφει τα ακριβή βήματα που πρέ‐
πει να ακολουθήσει ένα πρόγραμμα για να πετύχει το στόχο του. Επομένως, ο κυριότερος στόχος του προστακτικού προγραμματισμού είναι να δεχθεί δεδομένα σαν είσοδο, να τα αλλάξει μέσω ενημερώσεων στη μνήμη και να παράγει έξοδο βασισμένη σε αυτά τα συνε‐
χώς αλλασσόμενα δεδομένα. Κάθε πρόγραμμα έχει μια αρχική κατάσταση, μια λίστα υπο‐
λογιστικών βημάτων που πρέπει να ολοκληρώσει σε μια σειρά που ελέγχεται από τις δομές ελέγχου και ένα σημείο εξόδου. Οι συνηθέστερες εντολές που προσφέρονται από τις προ‐
στακτικές γλώσσες προγραμματισμού αφορούν την ανάθεση τιμών και την είσοδο/έξοδο. Οι γνωστότερες γλώσσες που ακολουθούν αυτό το παράδειγμα είναι η C, η Basic, η Pascal και η Fortran. 1.3.2. Συναρτησιακός Προγραμματισμός
Στο συναρτησιακό προγραμματισμό (functional programming) ο στόχος του προ‐
γράμματος είναι ελαφρώς διαφορετικός και αυτό έχει επίπτωση στον τρόπο προγραμματι‐
σμού: δίνεται έμφαση στη μορφή της πληροφορίας που είναι επιθυμητή και στους μετα‐
σχηματισμούς που χρειάζονται για να φτάσει το πρόγραμμα σε αυτή. Το επίκεντρο εδώ εί‐
ναι οι κλήσεις συναρτήσεων (function calls). Ο κυριότερος τρόπος αλλαγής των δεδομένων είναι οι συναρτήσεις και το πέρασμα των παραμέτρων. Τα δεδομένα δεν αλλάζουν στο συναρτησιακό προγραμματισμό και οι νέες τιμές δη‐
μιουργούνται εκ νέου από παλιότερες. Κατά συνέπεια δεν υπάρχει η κλασική κατάσταση προγράμματος. Επίσης η διαφορά μεταξύ του προγράμματος και των δεδομένων εξαφανίζε‐
ται. Μια συνάρτηση είναι δεδομένα όπως κάθε άλλο στοιχείο δεδομένων. Για παράδειγμα οι ακέραιοι αριθμοί και οι συναρτήσεις είναι το ίδιο. Τα στατικά δεδομένα μπορεί να υπάρ‐
χουν αλλά παίζουν μικρό ρόλο στο συναρτησιακό προγραμματισμό. Εδώ η στοίβα αποκτά μεγαλύτερη σημασία καθώς η περισσότερη δουλειά πραγμα‐
τοποιείται με την κλήση συναρτήσεων. Στις συναρτησιακές γλώσσες λαμβάνεται μεγαλύτε‐
ρη μέριμνα στην απόκρυψη του σωρού από τον προγραμματιστή έτσι ώστε να μην είναι δι‐
αθέσιμος για επεμβάσεις. Τα δεδομένα είναι δυναμικά αλλά μόλις δημιουργούνται στο σω‐
ρό, αν ακολουθείται συναρτησιακό μοντέλο αυστηρά δεν μπορούν να αλλάξουν. Ωστόσο αρκετές γλώσσες παρακάμπτουν αυτόν τον κανόνα για να αντιμετωπίσουν θέματα απόδο‐
σης. Μερικές γλώσσες που ακολουθούν αυτό το παράδειγμα είναι η Clojure, η Erlang, η Haskell και η F#. 1.3.3. Λογικός Προγραμματισμός
Ο λογικός προγραμματισμός (logic programming) είναι αρκετά διαφορετικός από τα προηγούμενα πρότυπα. Εδώ ο προγραμματιστής δεν γράφει ένα πρόγραμμα με την παρα‐
δοσιακή του έννοια αλλά ένα σύνολο από λογικούς κανόνες που πρέπει να ισχύουν. Από αυτό το σύνολο το πρόγραμμα προσπαθεί να απαντήσει ερωτήσεις με ένα ναι ή όχι. Κατά 8 συνέπεια, η σειρά δήλωσης των κανόνων επηρεάζει την έξοδο του προγράμματος. Στο λογι‐
κό προγραμματισμό υπάρχει η έννοια του σωρού καθώς οι κανόνες αποτιμώνται κατά την εκτέλεση του προγράμματος και αυτή προϋποθέτει την δυναμική προσθήκη ή αφαίρεση κα‐
νόνων κατά την εκτέλεση. Ο λογικός προγραμματισμός είναι ιδιαίτερα χρήσιμος στο πεδίο της Τεχνητής Νοη‐
μοσύνης (Artificial Intelligence) όπου μπορεί να χρησιμοποιηθεί για την αναπαράσταση γνώσης με τη μορφή ενός λογικού προγράμματος. Η γνωστότερη γλώσσα στο λογικό προ‐
γραμματισμό είναι η Prolog. 1.3.4. Αντικειμενοστρεφής Προγραμματισμός
Ο αντικειμενοστρεφής προγραμματισμός καθιερώθηκε τη δεκαετία του 1990 (η γλώσσα που συνεισέφερε αρκετά σε αυτό ήταν η Java) αντικαθιστώντας σε μεγάλο βαθμό το παραδοσιακό πρότυπο του προστακτικού προγραμματισμού. Εδώ το βασικό στοιχείο του προγράμματος είναι το αντικείμενο (object) που συνδυάζει ιδιότητες και διαδικασίες που επενεργούν σε αυτές αλλάζοντας τα δεδομένα τους. Κάθε αντικείμενο αποθηκεύει δεδομέ‐
να σε μεταβλητές και απαντά σε μηνύματα εκτελώντας τις διαδικασίες που καλούνται και μέθοδοι (methods). Το αντικείμενο αποτελεί δεσμευμένο κομμάτι της μνήμης (και συγκε‐
κριμένα του σωρού) και καλείται και στιγμιότυπο (instance), ενός σύνθετου τύπου δεδομέ‐
νων (data type) που καλείται κλάση (class). Η κλάση είναι μία αυτοτελής και αφαιρετική α‐
ναπαράσταση κάποιας κατηγορίας αντικειμένων, είτε φυσικών αντικειμένων του πραγματι‐
κού κόσμου είτε νοητών, εννοιολογικών αντικειμένων και στην ουσία αποτελεί την προδια‐
γραφή των δεδομένων και των διαδικασιών που επιδρούν πάνω σε αυτά. Αν κανείς παρατηρήσει πως υλοποιούνται οι διάφορες εργασίες στον πραγματικό κόσμο, θα παρατηρήσει ότι αλληλεπιδρά σε έναν κόσμο που στρέφεται γύρω από αντικεί‐
μενα. Αν θέλει κάποιος να πάει σε ένα μέρος για παράδειγμα μπορεί να χρησιμοποιήσει το αυτοκίνητό του. Το αντικείμενο αυτοκίνητο αποτελείται από άλλα αντικείμενα, όπως η μη‐
χανή που με τη σειρά της αποτελείται από άλλα αντικείμενα κ.ο.κ. καθένα από τα οποία αλ‐
ληλεπιδρά με το άλλο για να πραγματοποιήσουν μια συγκεκριμένη εργασία, το σύνολο το οποίων όμως έχει σαν απώτερο στόχο να μετακινήσει το αυτοκίνητο από ένα σημείο σε ένα άλλο. Το αυτοκίνητο «ενεργοποιείται» με το στρίψιμο του κλειδιού στη μίζα. Αυτή στέλνει ένα μήνυμα (μέσω ενός ηλεκτρικού σήματος) στη μηχανή για να ξεκινήσει. Ο οδηγός, απο‐
μονώνεται από τις διαδικασίες αυτές και το πώς αλληλεπιδρούν για να ξεκινήσει το αυτοκί‐
νητο. Το μόνο που περιμένει είναι μια απόκριση, ότι το αυτοκίνητο ξεκίνησε ή όχι. Παρόμοια, αποκρύπτεται από τους τελικούς χρήστες ενός λογισμικού η λογική που χρειάζεται για να υλοποιηθεί μια διεργασία. Για παράδειγμα, όταν εκτυπώνει ένας χρήστης μια σελίδα από ένα πρόγραμμα επεξεργασίας κειμένου, ξεκινάει τη διαδικασία πατώντας το κουμπί εκτύπωσης και χωρίς να ξέρει τι γίνεται εσωτερικά στο πρόγραμμα, περιμένει να δει μια εκτυπωμένη σελίδα ή ένα μήνυμα αποτυχίας. Πίσω στο παράδειγμα με το αυτοκίνητο, μπορούμε να ορίσουμε μία προδιαγραφή της μορφής και της συμπεριφοράς μιας κλάσης αντικειμένων (π.χ. μία κλάση "αυτοκίνητο"), ορίζοντας τόσο τις ιδιότητες της (π.χ. μία μεταβλητή "τρέχουσα ταχύτητα") όσο και τις πρά‐
ξεις ή χειρισμούς επί αυτών των ιδιοτήτων (π.χ. μία διαδικασία "πάτημα του γκαζιού"). Στο παράδειγμα αυτό κάθε πραγματικό αυτοκίνητο αναπαρίσταται ως ξεχωριστό, "φυσικό" στιγμιότυπο αυτής της πρότυπης, ιδεατής κλάσης. Συνεπώς, αν υλοποιούσαμε αυτήν την προδιαγραφή στον υπολογιστή, τα αντικείμενα θα είναι αυτά που καταλαμβάνουν χώρο στη μνήμη του υπολογιστή ενώ οι κλάσεις αποτελούν απλώς τα "καλούπια" για τη δημιουργία τους. Οι έννοιες των κλάσεων και των αντικειμένων που δημιουργούνται από αυτές, φαίνο‐
νται στην Εικόνα 1.1. Η κλάση Mercedes SLK 2004, αποτελεί το σχέδιο σύμφωνα με το οποίο παράγονται αντικείμενα‐αυτοκίνητα καθένα από τα οποία έχει τα χαρακτηριστικά που προσδιορίζει το σχέδιο, ωστόσο είναι μοναδικό αφού έχει διαφορετικές τιμές στα χαρακτη‐
ριστικά του. Οι αιτίες που ώθησαν στην ανάπτυξη του αντικειμενοστρεφούς προγραμματισμού είναι η ευκολία συντήρησης, οργάνωσης, χειρισμού και επαναχρησιμοποίησης κώδικα με‐
γάλων και πολύπλοκων εφαρμογών και επικράτησε επειδή μπορούσε να αντεπεξέλθει σε προγράμματα πολύ μεγαλύτερου όγκου και πολυπλοκότητας. Σε αυτό συνετέλεσαν τα ακό‐
λουθα χαρακτηριστικά του αντικειμενοστρεφούς προγραμματισμού: 9 Ενθυλάκωση (encapsulation)
Η ιδιότητα της ενθυλάκωσης αναφέρεται στην απόκρυψη των δεδομένων και της υ‐
λοποίησης ενός αντικειμένου και είναι γνωστή και ως απόκρυψη δεδομένων (data hiding). Τα δεδομένα και ο κώδικας όταν ενθυλακώνονται, αποκρύπτονται από την εξωτερική πρό‐
σβαση. Όταν ένας εξωτερικός παρατηρητής βλέπει ένα αντικείμενο, μπορεί να το χρησιμο‐
ποιήσει μόνο μέσω της εξωτερικής διασύνδεσής του (interface), δηλαδή ό, τι είναι διαθέσι‐
μο προς χρήση, ενώ οι εσωτερικές λεπτομέρειες είναι κρυμμένες και δεν μπορούν να χρησι‐
μοποιηθούν. Έτσι τα ενθυλακωμένα δεδομένα δεν μπορούν να αλλάξουν και πιο συγκεκρι‐
μένα να ενημερωθούν άμεσα από εξωτερικά αντικείμενα. Για παράδειγμα η επιτάχυνση ε‐
νός αυτοκινήτου είναι διαθέσιμη για αλλαγή από το γκάζι (διασύνδεση) αλλά το πώς δου‐
λεύει εσωτερικά η μηχανή για την πετύχει, είναι κρυφό από τον οδηγό. Τα αντικείμενα στον αντικειμενοστρεφή προγραμματισμό περιέχουν μια ενθυλακωμένη τοπική για το αντικείμε‐
νο κατάσταση μαζί με δεδομένα που καθορίζουν την υπόστασή τους. Το πώς είναι υλοποιη‐
μένο ένα αντικείμενο πρέπει στην ιδανική περίπτωση να είναι κρυμμένο. Κλάση: Αυτοκίνητο Ρόδες: 4 Πόρτες: 3 ή 5 Κλάση: Mercedes SLK 2004 Ρόδες: 4 Πόρτες: 3 Μηχανή: 3.2L V6 Χρώμα:… Καθίσματα:… Αντικείμενο: SLK‐s Ρόδες: 4 Πόρτες: 3 Μηχανή: 3.2L V6 Χρώμα: Ασημί Καθίσματα: Δερμάτινα Αντικείμενο: SLK‐b Ρόδες: 4 Πόρτες: 3 Μηχανή: 3.2L V6 Χρώμα: Μπλε Καθίσματα: Δερμάτινα Αντικείμενο: SLK‐r Ρόδες: 4 Πόρτες: 3 Μηχανή: 3.2L V6 Χρώμα: Κόκκινο Καθίσματα: Δερματίνη Εικόνα 1.1 ‐ Ένα παράδειγμα κλάσης και αντικειμένων Αφαίρεση δεδομένων (Abstraction)
Η αφαίρεση δεδομένων είναι η αρχή που απαιτεί τα προγράμματα να μην λαμβά‐
νουν υπόψη συγκεκριμένες υλοποιήσεις ή εσωτερικές αναπαραστάσεις αλλά να έχουν μια γενική αφηρημένη ιδέα των αντικειμένων που χρησιμοποιούν. Στον αντικειμενοστρεφή προγραμματισμό κάθε αντικείμενο μπορεί να ζητηθεί να παρέχει δεδομένα ή υπηρεσίες λαμβάνοντας μηνύματα/αιτήσεις. Τον αιτούντα δεν τον απασχολεί πως το αντικείμενο θα παράξει την δεδομένα αλλά τα δεδομένα καθαυτά. Το πώς ‐ δηλαδή η υλοποίηση ή αλλιώς η δημιουργία της πληροφορίας ‐ είναι μια εσωτερική για το αντικείμενο υπόθεση. Επομένως δίνεται έμφαση στο τι αντί για το πώς κατά την αλληλεπίδραση μεταξύ δυο αντικειμένων. Η αφαίρεση δεδομένων προσπαθεί να μειώσει τις λεπτομέρειες και να τις ομαδοποιήσει σε 10 επίπεδα μιας υλοποίησης έτσι ώστε ο προγραμματιστής να επικεντρωθεί στις έννοιες που τον ενδιαφέρουν για την επίλυση ενός προβλήματος. Ταυτόχρονα ο προγραμματιστής δεν απασχολείται με την εκμάθηση συγκεκριμένων υλοποιήσεων, αλλά επικεντρώνεται στην ε‐
πίλυση του δεδομένου προβλήματος, γνωρίζοντας μόνο ό, τι χρειάζεται. Ένα σύστημα μπο‐
ρεί να έχει πολλαπλά επίπεδα αφαίρεσης, σε καθένα από τα οποία φανερώνονται διαφορε‐
τικές λεπτομέρειες. Για παράδειγμα, τα επίπεδα χαμηλού επιπέδου φανερώνουν λεπτομέ‐
ρειες του υλικού όπου τρέχει ένα πρόγραμμα, ενώ τα επίπεδα υψηλού επιπέδου ασχολού‐
νται με τη λογική του προγράμματος. Κληρονομικότητα (inheritance)
Τα αντικείμενα τείνουν να δομούνται βασισμένα σε άλλα αντικείμενα. Όταν δημι‐
ουργείται ένα νέο αντικείμενο (μέσα από μια κλάση), ουσιαστικά ορίζονται οι ιδιότητες που το κάνουν ξεχωριστό από τα υπόλοιπα αντικείμενα. Εξαιτίας της ομοιότητας πολλών αντι‐
κειμένων υπάρχει ένας μηχανισμός για τη μεταφορά των ιδιοτήτων κάποιων αντικειμένων σε άλλα αντικείμενα έτσι ώστε να αποφεύγεται ο άσκοπος ορισμός των χαρακτηριστικών σε κάθε αντικείμενο ξεχωριστά, αλλά και για να υπάρχει μια νοητή συγγένεια μεταξύ των αντι‐
κειμένων. Αυτός ο μηχανισμός καλείται κληρονομικότητα. Η κληρονομικότητα επιτρέπει στους προγραμματιστές την επαναχρησιμοποίηση των ορισμών δομών που έχουν οριστεί στο παρελθόν, μειώνοντας έτσι την εργασία κατά την ανάπτυξη προγραμμάτων. Πίσω στην Εικόνα 1, η κληρονομικότητα είναι αυτή που μεταφέρει τις ιδιότητες της γενικής κλάσης «Αυτοκίνητο» στην πιο ειδική κλάση Mercedes SLK 2004. Πολυμορφισμός (polymorphism)
Ο όρος πολυμορφισμός στην κυριολεξία αναφέρεται στην ιδιότητα του να έχει κάτι πολλαπλές μορφές. Στις γλώσσες προγραμματισμού τις περισσότερες φορές αναφέρεται στην ιδιότητα των μεθόδων να μπορούν να δέχονται και/ή να επιστρέφουν τιμές διαφορετι‐
κού τύπου. Για παράδειγμα μια μέθοδος που δέχεται ένα μόνο όρισμα είναι πολυμορφική αν μπορεί να δεχτεί παραμέτρους διαφορετικού τύπου. Ο πολυμορφισμός είναι διάχυτος στις αντικειμενοστρεφείς γλώσσες προγραμματισμού και συνδέεται αρκετά με την κληρο‐
νομικότητα καθώς ιδιότητες που κληρονομούνται μπορούν να έχουν διαφορετικές μορφές από το αντικείμενο πρόγονο στο αντικείμενο απόγονο. Στον Πίνακα 1 συνοψίζονται τα κυριότερα χαρακτηριστικά των προαναφερθέντων προγραμματιστικών προτύπων και στον Πίνακα 2 δίνεται το κλασικό πρόγραμμα “hello world” σε χαρακτηριστικές γλώσσες των αντίστοιχων προγραμματιστικών προτύπων. Πίνακας 1 ‐ Χαρακτηριστικά των βασικότερων προτύπων προγραμματισμού Πρότυπο
Προστακτικό Βασικό στοι‐
χείο Εντολή
Συναρτησιακό Συνάρτηση
Λογικό Πρόταση
Πρόγραμμα
Εκτέλεση Αποτέλεσμα
Ακολουθία Εντολών Συλλογή συ‐
ναρτήσεων Εκτέλεση εντο‐
λών Αποτίμηση συναρτήσεων Τελική κατά‐
σταση μνήμης Τιμή της κύρι‐
ας συνάρτη‐
σης Επιτυχία ή αποτυχία της απόδειξης Αξιώματα και Απόδειξη θεω‐
θεώρημα ρήματος 11 Πίνακας 2 ‐ Το "Hello World" σε γλώσσες από τα βασικότερα πρότυπα προγραμματισμού Προστακτικό (C) Συναρτησιακό (F#) Λογικό (Prolog) Αντικειμενοστρεφές (C#) #include <stdio.h>
#include <stdlib.h>
int main(void)
{
printf("Hello, imperative world\n");
return EXIT_SUCCESS;
}
let helloworld ruready = if ruready = 'y' then "hello
functional world" else "stickin with c#";;
hello_world :- write('Hello Logic World!').
class Hello
{
static void Main()
{
System.Console.WriteLine("Hello Object World!");
}
}
12 2. Το .NET framework και η C#
Το .ΝΕΤ Framework είναι ένα πλαίσιο λογισμικού (software framework)1 που προορί‐
ζεται για την πλατφόρμα των Windows. Αποτελείται από μια μεγάλη βιβλιοθήκη κλάσεων και υποστηρίζει μια πλειάδα γλωσσών προγραμματισμού με τη δυνατότητα η μια να μπορεί να χρησιμοποιηθεί από την άλλη. Τα προγράμματα που γράφονται για το .ΝΕΤ Framework εκτελούνται σε ένα περιβάλλον εκτέλεσης γνωστό ως Common Language Runtime (CLR), ε‐
νός ειδικού λογισμικού, σχεδιασμένου να υποστηρίζει την εκτέλεση προγραμμάτων και την απρόσκοπτη συνεργασία με το λειτουργικό σύστημα. Το CLR περιέχει μια εικονική μηχανή (virtual machine) που διαχειρίζεται την εκτέλεση ενός προγράμματος και παρέχει μια σειρά σημαντικών υπηρεσιών όπως ασφάλεια, διαχείριση μνήμης και διαχείριση εξαιρέσεων. Τα προγράμματα που γράφονται για το .ΝΕΤ χρησιμοποιούν τη βιβλιοθήκη κλάσεων (class library) του .ΝΕΤ, η οποία δίνει πρόσβαση στο περιβάλλον εκτέλεσής του (runtime en‐
vironment). Βασικές λειτουργίες όπως οι γραφικές διεπαφές χρηστών (Graphical User Inter‐
faces – GUIs), η επικοινωνία με βάσεις δεδομένων, η κρυπτογραφία, η ανάπτυξη web εφαρ‐
μογών και οι δικτυακές επικοινωνίες παρέχονται μέσω του Application Programming Inter‐
face (API) του .NET και μπορούν να συνδυαστούν με κώδικα από τους προγραμματιστές για τη δημιουργία ολοκληρωμένων εφαρμογών. Όσο ένα πρόγραμμα περιορίζεται στη χρήση της βιβλιοθήκης κλάσεων του .NET, μπορεί να τρέχει οπουδήποτε υπάρχει εγκατεστημένο το περιβάλλον εκτέλεσης του .NET. Η γλώσσα C# είναι μια από τις γλώσσες που υποστηρίζει το .NET. Ο μεταγλωττιστής της C# στοχεύει ειδικά στο .NET κάτι που σημαίνει ότι τα προγράμματα γραμμένα σε C# θα τρέχουν πάντα στο .ΝΕΤ Framework. Αυτό έχει δυο σημαντικές συνέπειες για τη γλώσσα:  Η αρχιτεκτονική της και οι μεθοδολογίες της αντικατοπτρίζουν τη δομή του .NET.  Σε πολλές περιπτώσεις, ειδικά χαρακτηριστικά της γλώσσας εξαρτώνται στην πραγματικότητα από τα χαρακτηριστικά του .NET ή τις βασικές κλάσεις του .NET. Εξαιτίας αυτής της εξάρτησης, είναι σημαντικό να κανείς να κατανοήσει την αρχιτε‐
κτονική και τη μεθοδολογία του .ΝΕΤ πριν προχωρήσει στον προγραμματισμό με τη C#. 2.1. Λίγη Ιστορία
Για να εκτιμήσει κανείς τη σημασία του .NET framework, είναι χρήσιμο να ταξιδέψει στο χρόνο, περίπου 18 χρόνια πριν και να θυμηθεί τη φύση των τεχνολογιών που υποστήρι‐
ζαν τα Windows. Παρόλο που μπορεί να φαίνεται το ίδιο, όλα τα λειτουργικά συστήματα από τα Windows 3.1 (εκδόθηκαν το 1992) μέχρι τα Windows 7 και Windows Server 2008 R2 έχουν το ίδιο Windows API στον πυρήνα τους. Με την εμφάνιση όμως των νέων εκδόσεων των Windows, έχει προστεθεί νέα λειτουργικότητα στο API, σαν φυσική απόρροια της εξέλι‐
ξης του API και όχι της αντικατάστασής του από ένα νέο. Το ίδιο μπορεί κανείς να πει για τις περισσότερες από τις τεχνολογίες και frameworks που χρησιμοποιούνται για την ανάπτυξη εφαρμογών σε Windows. Για παράδειγμα το πρό‐
τυπο COM (Component Object Model) ξεκίνησε σαν OLE (Object Linking and Embedding) και αρχικά αποτελούσε το μέσο με το οποίο διαφορετικοί τύποι εγγράφων του Office μπορού‐
σαν να συνδεθούν, ώστε για παράδειγμα να είναι εφικτό να προστεθεί ένας μικρός πίνακας Excel σε ένα έγγραφο Word. Από τότε το COM εξελίχθηκε στο DCOM (Distributed COM) και τέλος στο πρότυπο COM+, μια πολύπλοκη τεχνολογία που σχημάτισε τη βάση της επικοινω‐
1
Ένα software framework είναι ένα επαναχρησιμοποιήσιμο σύστημα λογισμικού, αποτελούμενο συνήθως από βιβλιοθήκες και υποπρογράμματα για την υποστήριξη της εκτέλεσης άλλων προγραμμάτων. Τα frameworks μπορούν να βελτιώσουν την παραγωγικότητα κατά την ανάπτυξη του λογισμικού καθώς αφήνουν τον προγραμμα‐
τιστή να επικεντρωθεί στην εφαρμογή προς ανάπτυξη και όχι στην υποδομή της. Η κύρια διαφορά με τις απλές βι‐
βλιοθήκες λογισμικού είναι η «αντιστροφή ελέγχου», κατά την οποία ο έλεγχος αρχικοποίησης και κλήσης αντικει‐
μένων μεταφέρεται στο framework, αντίθετα με τις βιβλιοθήκες που ήταν αποκλειστική δουλειά του προγραμματι‐
στή. 13 νίας σχεδόν όλων των components, όπως επίσης και την υλοποίηση των δοσοληψιών, των υπηρεσιών μηνυμάτων και του pooling αντικειμένων. Η Microsoft επέλεξε αυτή την εξελικτική προσέγγιση στο λογισμικό για τον προφανή λόγο της διατήρησης της συμβατότητας με τις προηγούμενες εκδόσεις (backward compati‐
bility). Μέσα στα χρόνια, η μεγάλη βάση του λογισμικού από άλλους παρόχους που γράφτη‐
κε για Windows, σίγουρα δεν θα γνώριζε την ίδια επιτυχία αν κάθε φορά που η Microsoft εισήγαγε μια νέα τεχνολογία, έσπαγε την υπάρχουσα υποδομή προγραμματισμού! Ήταν ξεκάθαρο ότι κάτι έπρεπε να αλλάξει. Η Microsoft δεν μπορούσε να επεκτείνει για πάντα τα ίδια εργαλεία λογισμικού και τις ίδιες γλώσσες, κάνοντάς τα πιο πολύπλοκα για να υποστηρίζουν το νέο υλικό (hardware) και ταυτόχρονα να είναι συμβατά με τις προη‐
γούμενες εκδόσεις. Κάποτε έρχεται ένα σημείο που πρέπει να γίνει επανεκκίνηση στη θεώ‐
ρηση της ανάπτυξης λογισμικού αν είναι επιθυμητά ένα απλό αλλά ταυτόχρονα μοντέρνο σύνολο γλωσσών προγραμματισμού, περιβαλλόντων και εργαλείων ανάπτυξης λογισμικού που διευκολύνει τους προγραμματιστές στην ανάπτυξη λογισμικού. Σε αυτό το σημείο έγινε ο ερχομός της C# και του .NET στην πρώτη τους ενσάρκωση. Με λίγες λέξεις το .NET είναι ένα σύστημα λογισμικού για την υποστήριξη του προγραμμα‐
τισμού στην πλατφόρμα των Windows. Μαζί με το .NET Framework, η C# είναι μια γλώσσα που σχεδιάστηκε από την αρχή για να το υποστηρίξει και να εκμεταλλευτεί όλη την πρόοδο πάνω στα περιβάλλοντα προγραμματισμού και την θεώρηση του αντικειμενοστρεφούς προ‐
γραμματισμού που είχε συντελεστεί τα τελευταία 25 χρόνια. Πριν συνεχίσουμε πρέπει να ξεκαθαρίσουμε ότι η συμβατότητα με τα παλιότερα συ‐
στήματα δεν χάθηκε κατά τη διαδικασία αυτή. Τα υπάρχοντα προγράμματα θα συνεχίσουν να δουλεύουν και το .NET σχεδιάστηκε με τη δυνατότητα να δουλεύει με το υπάρχον λογι‐
σμικό. Τώρα, η επικοινωνία μεταξύ διαφόρων components σε Windows γίνεται σχεδόν εξ’ ολοκλήρου σε COM. Λαμβάνοντας αυτό υπόψη, το .NET Framework έχει τη δυνατότητα να παρέχει wrappers για τα υπάρχοντα COM components έτσι ώστε τα .NET components να μπορούν να επικοινωνούν με αυτά. Ωστόσο, δεν είναι απαραίτητο να γνωρίζει κανείς C# για να προγραμματίσει στο .NET. Η Microsoft επέκτεινε τη C++ και άλλαξε σημαντικά τη Visual Basic για να την μετα‐
τρέψει σε μια πιο ισχυρή γλώσσα, έτσι ώστε να καταστήσει δυνατή τη χρήση τους για το .NET. Αυτές οι γλώσσες όμως, φέρουν το βάρος της εξέλιξης μέσα στα τελευταία χρόνια αντί να έχουν γραφτεί από την αρχή σύμφωνα με τις σύγχρονες απαιτήσεις. 2.2. Χαρακτηριστικά του .NET Framework
Πριν επεκταθούμε σε μια πιο αναλυτική παρουσίαση της δομής της πλατφόρμας .ΝΕΤ και των τεχνολογιών που την περιβάλλουν είναι σκόπιμο να παρουσιάσουμε τα σημα‐
ντικότερα χαρακτηριστικά και πλεονεκτήματά της: Υποστήριξη πολλαπλών γλωσσών
Παρόλο που το COM υποστήριζε πολλαπλές γλώσσες (κυρίως τη C++ και τη Visual Basic), οι δυνατότητες επικοινωνίας μεταξύ των διαφόρων γλωσσών περιορίζονταν στην υ‐
λοποίηση διασυνδέσεων (interfaces). Στο .ΝΕΤ, η διαλειτουργικότητα μεταξύ των γλωσσών επιτυγχάνεται μέσω της δια‐γλωσσικής κληρονομικότητας. Μαζί με ένα ενοποιημένο σύ‐
στημα τύπων, η συνένωση κώδικα γραμμένου σε διαφορετικές γλώσσες είναι πλέον εύκολη υπόθεση. Αυτό διευκολύνει και άλλα προγραμματιστικά πρότυπα όπως το συναρτησιακό της F#. Ανάπτυξη βασισμένη σε components
Η τέχνη της δημιουργίας ανεξάρτητων κομματιών λογισμικού που περιέχουν βιβλιο‐
θήκες κλάσεων και διαμοιράσιμα τμήματα λειτουργικότητας μιας εφαρμογής έχει γίνει πολύ πιο εύκολη από παλιότερα. Για παράδειγμα, δεν χρειάζεται υλοποίηση διεπαφών COM, ό‐
πως το IUnknown. Η διαμοιράσιμη μονάδα κώδικα στο .NET βασίζεται στην έννοια του as‐
sembly, το οποίο μεταφέρει πληροφορίες που απαιτούνται για τη χρήση της όπως η έκδοση της. 14 Μεταφερσιμότητα
Η μεταφερσιμότητα (portability) επιτυγχάνεται μέσω της εικονικής μηχανής στο CLR. H εικονική μηχανή αυτή είναι η προδιαγραφή μιας αφηρημένης εικονικής μηχανής για την οποία κώδικας γραμμένος σε οποιαδήποτε από τις .ΝΕΤ γλώσσες μεταγλωττίζεται σε μια εν‐
διάμεση γλώσσα γνωστή ως Common Intermediate Language (CIL) και περιέχεται σε ένα assembly. Ένα assembly είναι είτε ένα εκτελέσιμο αρχείο (exe) είτε ένα dll. Η μεταγλώττιση σε αυτήν την ενδιάμεση γλώσσα είναι που εξασφαλίζει και την ανεξαρτησία από την πλατ‐
φόρμα, η οποία ωστόσο μένει μόνο στη θεωρία, αφού η μοναδική πλήρης υλοποίηση του .NET είναι διαθέσιμη μόνο για την πλατφόρμα των Windows. Όμως είναι διαθέσιμη μια με‐
ρική υλοποίηση ανοιχτού κώδικα με το όνομα Mono. Απλή εγκατάσταση εφαρμογών
Αντίθετα με τα components που βασίζονται στο COM, δεν χρειάζεται καμία καταχώ‐
ρηση στο registry του συστήματος για την εγκατάσταση των assemblies καθώς μια απλή α‐
ντιγραφή αρκεί για τη χρήση τους. Επιπρόσθετα τα πιθανά προβλήματα της χρήσης των Dy‐
namic Link Libraries (DLLs) γνωστά και ως “DLL Hell” απαλείφθηκαν με την υποστήριξη της ύπαρξης πολλαπλών εκδόσεων του ίδιου component δίπλα δίπλα. Το ίδιο το .NET Frame‐
work είναι ένα καλό παράδειγμα αυτής της δυνατότητας, αφού είναι δυνατόν να υπάρχουν πολλαπλές εκδόσεις του framework εγκατεστημένες στο ίδιο μηχάνημα. Επικοινωνία με υπάρχων κώδικα
Παρόλο που η πλατφόρμα .ΝΕΤ προορίζεται να είναι ένα υποκατάστατο των παλαιό‐
τερων τεχνολογιών, υποστηρίζει τη χρήση κομματιών λογισμικού που έχουν αναπτυχθεί σε παλιότερες τεχνολογίες όπως της COM και παρέχει πρόσβαση σε λειτουργίες χαμηλού επι‐
πέδου του λειτουργικού συστήματος μέσω του μηχανισμού P/Invoke. Αξιοπιστία
To .NET είναι σχεδιασμένο για τη δημιουργία λογισμικού υψηλής αξιοπιστίας (ro‐
bustness). Πραγματοποιεί εκτεταμένους ελέγχους κατά τη μεταγλώττιση αλλά και κατά την εκτέλεση των προγραμμάτων. Τα χαρακτηριστικά του .ΝΕΤ από μόνα τους ωθούν τους προ‐
γραμματιστές στην απόκτηση αξιόπιστων προγραμματιστικών συνηθειών. Το μοντέλο δια‐
χείρισης της μνήμης είναι απλό: η δέσμευση μνήμης γίνεται με μια λέξη (new), δεν υπάρ‐
χουν δείκτες προς θέσεις μνήμης σαν τύποι δεδομένων, ούτε αριθμητική δεικτών ενώ η α‐
ποδέσμευση μνήμης γίνεται αυτόματα μέσω του μηχανισμού garbage collection. Αυτό το απλό μοντέλο διαχείρισης μνήμης απαλείφει ολόκληρες κατηγορίες λαθών που απασχολούν τους προγραμματιστές σε C και C++. Η ανάπτυξη προγραμμάτων γίνεται με την πεποίθηση ότι αρκετά λάθη θα εντοπιστούν από το σύστημα πολύ πριν την ολοκλήρωσή της. Αυτόματη διαχείριση μνήμης
Άλλο ένα σημαντικό χαρακτηριστικό του .NET Framework είναι η δυνατότητα αυτό‐
ματης διαχείρισης της μνήμης μέσω του Garbage Collector. Ιστορικά η διαχείριση της μνή‐
μης ήταν από τις δυσκολότερες εργασίες που είχε να κάνει ένας προγραμματιστής. Οι πα‐
λαιότερες προσεγγίσεις στη διαχείριση μνήμης ήταν είτε χαμηλού επιπέδου (όπως η mal‐
loc/free στη C και η new/delete στη C++), προκαλώντας διάφορα bugs, είτε αρκετά πολύ‐
πλοκη (όπως στην περίπτωση του COM). Ένας από τους στόχους του .ΝΕΤ και του CLR πιο συγκεκριμένα ήταν να απαλείψει από τους προγραμματιστές την ανάγκη διαχείρισης της μνήμης. Το CLR με το μηχανισμό Garbage Collector διαχειρίζεται τη μνήμη ερευνώντας πότε μπορεί να ελευθερωθεί με ασφάλεια μνήμη που δεν χρειάζεται άλλο σε ένα πρόγραμμα. Η μνήμη δεσμεύεται με την αρχικοποίηση των διαφόρων τύπων (αντικειμένων) από ένα δια‐
θέσιμο τμήμα της μνήμης που διαχειρίζεται το CLR γνωστό ως heap (σωρός). Όσο υπάρχει κάποια άμεση ή έμμεση (μέσω του γράφου των αντικειμένων) αναφορά προς ένα αντικεί‐
μενο, τότε αυτό θεωρείται πως χρησιμοποιείται. Στην αντίθετη περίπτωση, όταν δεν μπορεί να αναφερθεί από κάποιο άλλο τμήμα του κώδικα τότε είναι διαθέσιμο για καταστροφή. Ο garbage collector τρέχει ανά τακτά χρονικά διαστήματα σε ένα ξεχωριστό thread, εντοπίζει 15 ποια αντικείμενα είναι έτοιμα προς καταστροφή και αποδεσμεύει τη μνήμη που αυτά χρη‐
σιμοποιούσαν. Ασφάλεια
Το .ΝΕΤ είναι σχεδιασμένο να λειτουργεί σε κατανεμημένα περιβάλλοντα, η ασφά‐
λεια (security) των οποίων είναι υψίστης σημασίας. Με μέτρα που είναι ενσωματωμένα στις γλώσσες αλλά και κατά την εκτέλεση των προγραμμάτων, το .ΝΕΤ επιτρέπει τη δημιουργία προγραμμάτων που δεν μπορούν να προσβληθούν από έξω. Σε δικτυακά περιβάλλοντα οι εφαρμογές .ΝΕΤ είναι ασφαλείς από εισβολές μη εξουσιοδοτημένου κώδικα που επιχειρεί να δράσει στο παρασκήνιο και να εγκαταστήσει κακόβουλο λογισμικό ή να εισβάλει σε συ‐
στήματα αρχείων. Το περιβάλλον εκτέλεσης του .ΝΕΤ έχει ενσωματωμένο έναν μηχανισμό ασφάλειας με το όνομα Code Access Security (CAS) που απομονώνει τον κώδικα ανάλογα με την προέλευσή του, τον δημιουργό του ή άλλες πολιτικές. Το μοντέλο ασφάλειας συμβαδίζει με τους μηχανισμούς ασφάλειας που παρέχει το λειτουργικό σύστημα όπως οι Access Con‐
trol Lists και τα Windows security tokens. Απόδοση
Η ενδιάμεση γλώσσα στην οποία μεταγλωττίζονται τα προγράμματα στο .ΝΕΤ, μετα‐
γλωττίζεται πάντα με τη μέθοδο Just‐in‐Time (JIT). Ο μεταγλωττιστής JIT μεταγλωττίζει κάθε τμήμα του κώδικα στην ενδιάμεση γλώσσα όταν αυτό καλείται (just in time). Όταν έχει ήδη μεταγλωττιστεί κάποιο τμήμα κώδικα, το αποτέλεσμα αποθηκεύεται μέχρι η εφαρμογή να τερματίσει έτσι ώστε να μην χρειάζεται να ξαναμεταγλωττιστεί όταν ζητηθεί το συγκεκριμέ‐
νο τμήμα. Η διαδικασία αυτή είναι αποδοτικότερη σε σύγκριση με την απευθείας μεταγλώτ‐
τιση ολόκληρου του κώδικα, γιατί υπάρχει περίπτωση μεγάλα τμήματα κώδικα να μην εκτε‐
λεστούν ποτέ στην πραγματικότητα. Με τον μεταγλωττιστή JIT τέτοιος κώδικας δεν θα μετα‐
γλωττίζονταν ποτέ. Υποστήριξη με επαγγελματικά εργαλεία
Το .ΝΕΤ Framework συνοδεύεται από ένα σύνολο εργαλείων για την υποστήριξη της ανάπτυξης λογισμικού σε αυτό, όπως το σύστημα σχεδιασμού, τα frameworks για unit test‐
ing, την πλατφόρμα για build MSBuild και το σύστημα debugging, μέσα από το Visual Studio 2010. Το Visual Studio είναι ένα από τα καλύτερα Integrated Development Environments (IDEs). Χρησιμοποιείται για την ανάπτυξη όλων των ειδών εφαρμογών που μπορούν να α‐
ναπτυχθούν στο .ΝΕΤ: από console εφαρμογές και εφαρμογές με γραφικές διεπαφές (GUIs) μέχρι web εφαρμογές και web services σε managed αλλά και εγγενή κώδικα. Οι Premium και Ultimate εκδόσεις του Visual Studio στοχεύουν στην ομαδική ανάπτυξη μαζί με τον Team Foundation Server (TFS) που χρησιμοποιείται για την παρακολούθηση ενός έργου .NET, τη διαχείριση του κώδικα, τη διαχείριση των αναφορών αλλά και το διαμοιρασμό κώδικα, τεκ‐
μηριώσεων ή άλλων εγγράφων. 2.2.2. Αρχιτεκτονική του .NET Framework
Ένας προγραμματιστής στην πλατφόρμα Windows έχει πρωταρχικά δυο μονοπάτια που μπορεί να ακολουθήσει κατά την ανάπτυξη εφαρμογών. Το πρώτο είναι η ανάπτυξη εφαρμογών μη διαχειρισμένου κώδικα (unmanaged code) και περιλαμβάνει τον προγραμ‐
ματισμό κατευθείαν στο λειτουργικό σύστημα, χρησιμοποιώντας το Windows Application Programming Interface (Windows API) συνήθως με τη γλώσσα C++. Στόχος του Windows API είναι να δώσει τη δυνατότητα στους προγραμματιστές να αναπτύξουν προγράμματα με το λειτουργικό σύστημα για να αποφύγουν το γράψιμο κώδικα για τη δημιουργία components των Windows όπως φόρμες, κουμπιά μενού και άλλα. Με το Windows API ένας προγραμμα‐
τιστής καλεί τις συναρτήσεις και αφήνει το λειτουργικό σύστημα να δημιουργήσει αυτά τα components. Ο κύριος λόγος χρήσης του Windows API είναι η απουσία υποστήριξης διαφόρων λει‐
τουργιών από τη βασική έκδοση της χρησιμοποιούμενης γλώσσας προγραμματισμού. Η χρήση μιας λειτουργίας του Windows API από μια γλώσσα γίνεται με την κλήση της κατάλ‐
ληλης συνάρτησης. Ωστόσο, οι κλήσεις τέτοιων συναρτήσεων είναι συνήθως μια πολύπλοκη διαδικασία που μπορεί να προκαλέσει απρόβλεπτες συνέπειες αν δεν γίνει σωστά. Η πολυ‐
16 πλοκκότητα αυτή εείναι ένας απόό τους λόγουςς που οδήγησ
σε στη δημιου ργία του δεύττερου μο‐
νοπα
ατιού στην αννάπτυξη εφα
αρμογών, δηλλαδή την ανά
άπτυξη εφαρμμογών διαχειιρισμένου κώδιικα. μένος κώδικαςς (managed code) c
είναι ου
υσιαστικά κώδ
ώδικας που τρ
ρέχει στην Διαχειρισμ
πλαττφόρμα .ΝΕΤ. Το .NET Fram
mework αποττελείται από έ
ένα περιβάλλο
λον εκτέλεσηςς το οποίο διαχειρίζεται την εκτέλεση κώ
ώδικα μέσω κανόνων κ
ασφάλειας, αυτό ματης διαχείρισης της μνήμ
μης και αυστη
ηρότητας τύπ
πων, μειώνονττας έτσι σε μεγάλο μ
βαθμόό την πιθανόττητα πρό‐
κλησ
σης λαθών από αυτούς του ς παράγοντεςς. ρμα αποτελείτται από διάφορα μέρη καθ
θένα από τα οοποία παρέχεει ένα συ‐
Η πλατφόρ
γκεκριμένο κομμά
άτι των δυναττοτήτων της. Αυτά μπορείί να είναι αυττόνομα προγράμματα, βιβλιοθήκες ή βοη
ηθητικά αρχείία. Ακολουθεεί μια απεικόννιση της σχέσηης των μερώνν του .ΝΕΤ με τιις εφαρμογέςς μέσα από τα
α δύο μονοπ
πάτια ανάπτυξξης που αναφ
φέραμε, στην Εικόνα 2 αλλά
ά και μια αναλλυτική περιγρραφή των κυριότερων μερώ
ών του .ΝΕΤ: Εικόνα 2.11 ‐ Μια επισκκόπηση του .Ν
ΝΕΤ Framewo rk Com
mmon Lang
guage Runtiime
Το Commo
on Language Runtime (CLR
R) είναι μια υλοποίηση υ
τοου προτύπου Common Langguage Infrastructure (CLI) α
από τη Microssoft. Tο CLI πρ
ροσδιορίζει τηην υποδομή εεκτέλεσης που απαιτείται για τη χρήση managed κώ
ώδικα, έτσι ώστε ώ
διαφορεετικές βιβλιοθ
θήκες και σσες να συνεργάζονται απ
πρόσκοπτα. Υπ
πάρχουν και ά
άλλες υλοποιιήσεις του CLI από τρί‐
γλώσ
τουςς παρόχους όπ
πως το Mono Και το DotGN
NU Portable.N
NET αλλά και της Microsofft με το ό‐
νομα
α Shared Sourrce CLI (SSCLI) γνωστό και ω
ως Rotor, το οποίο τρέχει σσε πλατφόρμες όπως το FreeBSD. Αυτό θεωρητικά σημα
αίνει ότι κώδιικας που στοχχεύει στο .NETT όχι μόνο επιτρέπει τη αφορετικών γγλωσσών προγγραμματισμο ύ αλλά και τη
ην εκτέλε‐
διαλειτουργικότηττα μεταξύ δια
ση σε διαφορετικέές πλατφόρμεες. Η προδιαγρ
ραφή CLI και κκατά συνέπειια το CLR αποττελείται από ττρία κύρια σττοιχεία :  το
ο Virtual Execuution System (VES)  το
ο Common Typpe System (CTTS)  το
ο Common Lannguage Speciffication (CLS). Η VES είνα
αι η καρδιά τοου CLR και είίναι αυτή που
υ εξασφαλίζεει τη μεταφερ
ρσιμότητα ο format της ς ενδιάμεσης γλώσσας των προγραμμάτων σε .ΝΕΤ. Η VES αντιλλαμβάνεται το
α μεταδεδομένα που περιγγράφουν τον κκώδικα σε Common Intermediate Languagge (CIL) και τα
ήν την ενδιάμεεση μορφή. Ο
Ο κώδικας σε CIL μορφή είνναι ίδιος ανεξξάρτητα από ττο υλικό ή αυτή
την πλατφόρμα π
όπου ό
εκτελείτται. Η VES είνναι ουσιαστικ
κά μια εικονιική μηχανή διεργασίας (proccess virtual machine). m
Τέτοοιες μηχανές τρέχουν σαν κανονική εφ
φαρμογή μέσα
α στο λει‐
τουρ
ργικό σύστημα
α στο οποίο φ
φιλοξενούντα
αι και υποστη
ηρίζονται απόό μια διεργασ
σία. Η λει‐
τουρ
ργία τους ξεκιινά με την ένα
αρξη της διερ
ργασίας και παύει με τον ττερματισμό τη
ης. Ο σκο‐
17 πός των εικονικών μηχανών είναι να παρέχουν ένα περιβάλλον εκτέλεσης προγραμμάτων, ανεξάρτητο συνήθως από την πλατφόρμα που τρέχουν, η οποία κρύβει τις λεπτομέρειες του υποκείμενου υλικού ή λειτουργικού συστήματος, επιτρέποντας έτσι στα προγράμματα να τρέχουν με τον ίδιο τρόπο σε κάθε πλατφόρμα. Δεν πρέπει να συγχέονται με τις εικονικές μηχανές συστήματος (system virtual machines) που παρέχουν μια πλήρη πλατφόρμα για την εκτέλεση ενός ολόκληρου λειτουργικού συστήματος όπως η VirtualBox, VMWare ή η Hyper‐
V. Για να εκτελεστεί ο κώδικας μιας γλώσσας στο CLR, πρέπει πρώτα να μεταγλωττιστεί σε μια μορφή η οποία μπορεί να αναγνωριστεί κατά την εκτέλεση. Αυτή η μορφή είναι η Common Intermediate Language (CIL συχνά και σκέτο IL). Ο κώδικας που εκτελείται στο CLR είναι γνωστός ως managed κώδικας, σε αντίθεση με τον εγγενή κώδικα (native code) που ε‐
κτελείται κατευθείαν στον επεξεργαστή της μηχανής χωρίς επιπρόσθετη υποδομή εκτέλε‐
σης. Εκτός από τις εντολές σε IL για την εκτέλεση μιας εφαρμογής το CLR χρειάζεται μεταδε‐
δομένα (metadata) που περιγράφουν τη δομή και την οργάνωση των τύπων δεδομένων. Η χρήση των μεταδεδομένων απαλείφει την ανάγκη ύπαρξης header files και βοηθά διάφορα εργαλεία να επιθεωρήσουν τους τύπους. Ένα τέτοιο παράδειγμα είναι το Intellisense του Visual Studio. Η ενδιάμεση γλώσσα CIL περιέχεται μέσα στα assemblies τα οποία, εκτός από το ρόλο τους στην εκτέλεση ενός προγράμματος, αποτελούν και της βασικές μονάδες εγκα‐
τάστασης στο .NET. Εξαιτίας της αυτοπεριγραφικής φύσης τους που παρέχεται από τα μετα‐
δεδομένα, τα assemblies δεν χρειάζονται την βοήθεια πολύπλοκων οδηγών εγκατάστασης (installers) για την εγγραφή τους στο registry, αφού μια απλή αντιγραφή τους αρκεί, ενώ εί‐
ναι δυνατή η ύπαρξη πολλαπλών εκδόσεων των assemblies αφού ενσωματώνουν τον αριθ‐
μό έκδοσής τους. Ένα από τα σημαντικότερα κομμάτια του CLR είναι το CTS γιατί εξασφαλίζει τη δια‐
λειτουργικότητα μεταξύ των γλωσσών. Το CTS ορίζει τους προκαθορισμένους τύπους δεδο‐
μένων που είναι διαθέσιμες στην ενδιάμεση γλώσσα έτσι ώστε όλες οι γλώσσες του .ΝΕΤ να παράγουν μεταγλωττισμένο κώδικα που βασίζεται σε αυτούς τους τύπους. Για παράδειγμα ο τύπος δεδομένων Integer της Visual Basic 2010 είναι στην πραγματικότητα ένας 32‐bit προσημασμένος ακέραιος, ο οποίος αντιστοιχεί στην ενδιάμεση γλώσσα στον τύπο Int32. Επειδή ο μεταγλωττιστής της C# κατανοεί τον τύπο αυτόν δεν υπάρχει κάποιο πρόβλημα στη χρήση από τη C# ενδιάμεσου κώδικα παραγμένο από VΒ. Το τελευταίο σημαντικότερο κομμάτι του CLR είναι το Common Language Specifica‐
tion (CLS). Το CLS είναι ένα σύνολο κανόνων στο οποίο βασίζονται όλες οι γλώσσες του .ΝΕΤ για να εξασφαλίσουν ότι δεν τίθενται προς χρήση τύποι δεδομένων τους οποίους δεν μπο‐
ρούν να χειριστούν μερικές γλώσσες. Αν τηρούνται όλοι οι κανόνες ένας τύπος ορίζεται ως συμβατός με το CLS (CLS‐compliant) και κατά συνέπεια μπορεί να χρησιμοποιηθεί από όλες τις γλώσσες. Ένα παράδειγμα ενός κανόνα είναι ένας τύπος δεν μπορεί να έχει public μέλη που διακρίνονται μόνο από το αν οι χαρακτήρες τους είναι πεζοί ή κεφαλαίοι (π.χ. Bar και bar). Μερικές γλώσσες, όπως η Visual Basic, δεν κάνουν διάκριση σε πεζούς και κεφαλαίους χαρακτήρες και δεν θα μπορούσαν να αντιληφθούν τη διαφορά. Βιβλιοθήκες κλάσεων
Τα περισσότερα σύγχρονα λειτουργικά συστήματα παρέχουν ένα σύνολο επαναχρη‐
σιμοποιήσιμου κώδικα για τη διευκόλυνση της ανάπτυξης προγραμμάτων σε αυτά. Ο κώδι‐
κας αυτός παρέχεται συνήθως σαν ένα σύνολο βιβλιοθηκών που μπορούν να καλούν οι ε‐
φαρμογές κατά την εκτέλεσή τους, όπως οι Dynamic Link Libraries (dll) στα Windows και τα Dynamic Shared Objects (dso) στα συστήματα Unix. Τα DLLs αυτά, που βρίσκονται στο φάκε‐
λο Windows\System32, περιέχουν συναρτήσεις που χρησιμοποιούνται για την απρόσκοπτη λειτουργία του λειτουργικού συστήματος και τη διατήρηση ενός συνεπούς παραθυρικού περιβάλλοντος. Αυτά τα αρχεία αποτελούν το Windows API. Προφανώς, το περιβάλλον εκτέλεσης συνετέλεσε αρκετά στην επιτυχία του .ΝΕΤ αλ‐
λά πολύ σημαντικότερη για τους προγραμματιστές είναι η πλούσια βιβλιοθήκη κλάσεων (Class Library) η οποία δίνει πρόσβαση σε έναν πλούτο λειτουργικότητας που μπορεί να χρησιμοποιηθεί από τις εφαρμογές. Οι βιβλιοθήκες κλάσεων του .ΝΕΤ υπηρετούν κυρίως δύο σκοπούς: α) όπως άλλες βιβλιοθήκες παρέχουν ένα καλά ορισμένο σύνολο κώδικα για την πραγματοποίηση τετριμμένων εργασιών, όπως η διατήρηση λιστών αντικειμένων ή η 18 επεξεργασία συμβολοσειρών και β) παρέχουν μια αφηρημένη υλοποίηση για εργασίες που κανονικά θα απαιτούσαν πρόσβαση στο υλικό και το λειτουργικό σύστημα, όπως η χρήση του συστήματος αρχείων ή η πρόσβαση στο δίκτυο. Η βιβλιοθήκη κλάσεων του .NET έχει μεγαλώσει αρκετά από την πρώτη έκδοσή του περίπου το 2000. Σήμερα, είναι σχεδόν αδύνατο να δοθεί πλήρης κάλυψη του framework ακόμα και σε ένα βιβλίο. Αντίθετα είναι πολύ πιο σημαντικό να κατανοηθεί η βασική δομή του έτσι ώστε η εξερεύνησή του να γίνεται εύκολα. Σπάνια κανείς θα έχει την πλήρη λύση ενός προβλήματος όταν ξεκινάει την ανάπτυξη μιας εφαρμογής, αλλά έχοντας κατανοήσει τη δομή του, οτιδήποτε στη βιβλιοθήκη μπορεί να μαθευτεί και να χρησιμοποιηθεί. Δεδομένων των τεραστίων διαστάσεων της βιβλιοθήκης, είναι απαραίτητη η οργά‐
νωσή της για να διευκολυνθεί ο εντοπισμός των διαφόρων λειτουργιών της. Η προσέγγιση που ακολουθείται στο .ΝΕΤ είναι η ιεραρχική οργάνωση των παρεχόμενων τύπων με τη χρή‐
ση των namespaces, σε αντίθεση με το Win32 API όπου η οργάνωση είναι επίπεδη. Ακολου‐
θούν ορισμένα γνωστά namespaces και η λειτουργικότητα που παρέχουν:  Το System περιέχει τους primitive τύπους δεδομένων, όπως τους Int32, Dou‐
ble, String, Booleans.  Το System.Collections παρέχει πρόσβαση σε χρήσιμους τύπους συλλογών δεδομένων όπως λίστες, σύνολα και λεξικά.  Το System.Data που παρέχει λειτουργικότητα για την πρόσβαση σε online ή offline δεδομένα με κύριο στόχο τις βάσεις δεδομένων.  Το System.IO που παρέχει τις απαραίτητες δομές για τη διαχείριση της Εισό‐
δου/Εξόδου (input/output) με streams, αρχεία, pipes κ.α.  Το System.Net που περιέχει κλάσεις για τη μετάδοση δεδομένων μέσω δι‐
κτύου που υποστηρίζουν γνωστά πρωτόκολλα όπως το TCP, UDP και το HTTP.  To System.Security που ενσωματώνει όλη τη λειτουργικότητα σχετική με την ασφάλεια μιας εφαρμογής, όπως permissions και κρυπτογραφία.  Το System.Text που χρησιμεύει για τη διαχείριση κειμένου, υποστηρίζοντας διάφορες κωδικοποιήσεις αλλά και τη χρήση regular expressions.  Το System.Windows που φιλοξενεί διάφορες τεχνολογίες για γραφικά περι‐
βάλλοντα όπως τις Windows Forms και WPF.  Το System.XML που υποστηρίζει την επεξεργασία εγγράφων XML. Γλώσσες προγραμματισμού
Οι γλώσσες προγραμματισμού είναι θεωρητικά εκτός της έννοιας μιας πλατφόρμας λογισμικού, ωστόσο η σημασία τους στο .NET Framework είναι αρκετά μεγάλη. Το .NET υ‐
ποστηρίζει τη χρήση πολλαπλών γλωσσών για τη δημιουργία εφαρμογών και βιβλιοθηκών κλάσεων. Από την πρώτη έκδοση του .ΝΕΤ, τόσο η Microsoft όσο και τρίτοι πάροχοι προσέ‐
φεραν ένα πλούσιο σύνολο γλωσσών συμβατών με το περιβάλλον εκτέλεσης, το σύστημα τύπων και το CLS. Πάνω από 50 γλώσσες έχουν γραφτεί πάνω στο περιβάλλον εκτέλεσης. Οι κύριες γλώσσες που παρέχονται από τη Microsoft σαν κομμάτι του .NET Framework SDK ω‐
στόσο είναι τέσσερις:  Η Visual Basic .NET: Μια γλώσσα με την οποία εξοικειώνονται αμέσως όσοι έχουν γράψει κλασικά προγράμματα Visual Basic στο παρελθόν και που τώ‐
ρα στοχεύει στο .NET Framework με πλήρη υποστήριξη αντικειμενοστρέφι‐
ας.  Η C#: Η γλώσσα που αναπτύχθηκε παράλληλα με τη δημιουργία του περι‐
βάλλοντος εκτέλεσης του .ΝΕΤ και την πρώτη έκδοση των βιβλιοθηκών κλά‐
σεων. Βασίζεται στις αρχές του αντικειμενοστρεφούς προγραμματισμού και η φύση της είναι πολύ πρακτική.  Η C++/CLI: αρχικά γνωστή ως Managed Extensions for C++, επιτρέπει την ε‐
κτέλεση C++ κώδικα πάνω στο περιβάλλον εκτέλεσης του .NET, παρέχοντας ένα πολύ καλό εργαλείο για την αντιμετώπιση διαλειτουργικών προβλημά‐
ων. 19 
Η F#: η τελευταία προσθήκη στον πυρήνα γλωσσών του .ΝΕΤ που στοχεύει στην επιστημονική υπολογιστική και συνδυάζει τις αρχές του συναρτησιακού προγραμματισμού με τον πλούτο της βιβλιοθήκης κλάσεων του .ΝΕΤ. Εκτός των επίσημων γλωσσών της Microsoft, διάφορες άλλες γλώσσες έχουν εισαχθεί στο .ΝΕΤ Framework. Παραδείγματα αποτελούν η COBOL, η Smalltalk, η Delphi, η APL, η Pas‐
cal και άλλες. Το τοπίο των γλωσσών προγραμματισμού είναι πάντα ρευστό και η ενοποιημένη υ‐
ποδομή του .ΝΕΤ παρέχει έναν ασφαλή τρόπο για την εξυπηρέτηση των αναγκών των δια‐
φορετικών αυτών γλωσσών, δίνοντάς τους τη δυνατότητα να χρησιμοποιήσουν βιβλιοθήκες μεταξύ τους και να χρησιμοποιήσουν τα έτοιμα εργαλεία. Όλα αυτά επιτρέπουν στους προ‐
γραμματιστές με διαφορετικές προτιμήσεις σε γλώσσες προγραμματισμού να δουλέψουν μαζί και να επιλέξουν τα σωστά εργαλεία για κάθε έργο. Για παράδειγμα, ενώ η C# είναι μια πολύ καλή γλώσσα γενικού σκοπού για τη δημιουργία εταιρικών εφαρμογών, η F# είναι πιο ελκυστική για την ανάπτυξη επιστημονικών εφαρμογών. Εργαλεία του .ΝΕΤ Framework
Το .ΝΕΤ περιλαμβάνει ένα σύνολο εργαλείων για τη διευκόλυνση της δημιουργίας, εγκατάστασης και διαχείρισης εφαρμογών και components σε αυτό. Τα περισσότερα εργα‐
λεία εγκαθίστανται με την εγκατάσταση του Visual Studio. Όλα τα εργαλεία είναι δυνατόν να εκτελεστούν από τη γραμμή εντολών των Windows εκτός από το εργαλείο Assembly Cache Viewer που πρέπει να χρησιμοποιηθεί από τον Windows Explorer. Ο καλύτερος τρόπος ε‐
κτέλεσης των command‐line εργαλείων είναι μέσα από το Visual Studio Command Prompt (γνωστό και ως CMD Shell) που παρέχεται σε κάθε Visual Studio από την έκδοση 2005 και μετά. Ακολουθεί μια αναφορά σε επιλεγμένα εργαλεία του .ΝΕΤ και μια κατηγοριοποίησή τους:  Εργαλεία μεταγλώττισης: o Csc.exe (C Sharp Compiler): ο μεταγλωττιστής της C# λαμβάνει αρ‐
χεία που περιέχουν κώδικα C# και παράγει εκτελέσιμα αρχεία (exe), dynamic link libraries (dll) ή modules κώδικα (netmodule)  Εργαλεία Build, Deployment και Configuration o Ildasm.exe (MSIL Assembler): λαμβάνει ένα protable executable (PE) αρχείο που περιέχει κώδικα στην ενδιάμεση γλώσσα MSIL και πα‐
ράγει ένα text αρχείο που μπορεί να προωθηθεί στο εργαλείο MSIL Assembler (Ilasm.exe) o Mage.exe (Manifest Generation and Editing): Επιτρέπει τη δημιουρ‐
γία, επεξεργασία και υπογραφή των manifests μιας εφαρμογής.  Εργαλεία αποσφαλμάτωσης (Debugging) o MDbg.exe (.NET Framework Command‐Line Debugger): Βοηθάει τους προγραμματιστές να εντοπίζουν και να διορθώνουν bugs στα προγράμματα που τρέχουν στο CLR. Αυτό το εργαλείο χρησιμοποιεί το runtime debuggint API.  Εργαλεία ασφάλειας o Peverify.exe (PEVerify Tool): βοηθάει στην επιβεβαίωση ότι ο εν‐
διάμεσος κώδικας MSIL και τα αντίστοιχα μεταδεδομένα καλύπτουν τις απαιτήσεις ασφάλειας. o SignTool.exe (Sign Tool): υπογράφει αρχεία ψηφιακά, επιβεβαιώνει υπογραφές σε αρχεία και τους προσδίδει time‐stamps.  Εργαλεία διαλειτουργικότητας (Interop) o Regasm.exe (Assembly Registration Tool): διαβάσει τα μεταδεδομέ‐
να σε ένα assembly και προσθέτει τις απαράιτητες εγγραφές στο registry. Αυτό επιτρέπει στους COM clients να εμφανίζονται σαν κλάσεις του .ΝΕΤ.  Διάφορα άλλα εργαλεία: o SqlMetal.exe (Code Generation Tool): παράγει κώδικα και αντιστοι‐
χήσεις για το LINQ to SQL component του .ΝΕΤ. 20 o
Wincv.exe (Windows Forms Class Viewer): εμφανίζει πληροφορίες για μια κλάση ή σύνολο κλάσεων χρησιμοποιώντας το reflection API του CLR. 2.2.3. Εκδόσεις του .ΝΕΤ Framework
Η Microsoft ξεκίνησε την ανάπτυξη του .ΝΕΤ Framework στα τέλη της δεκαετίας του 1990 αρχικά με το όνομα Next Generation Windows Services. Στα τέλη του 2000 εκδόθηκε η πρώτη beta έκδοση του .NET 1.0. Από τότε έχουν εκδοθεί άλλες τρεις κύριες εκδόσεις και αρκετές δευτερεύουσες ενδιάμεσά τους. Κάθε έκδοση του .ΝΕΤ περιέχει το CLR σαν κύριο component και περιλαμβάνει επιπρόσθετα components όπως τη βιβλιοθήκη κλάσεων και άλλες managed βιβλιοθήκες. Κάθε νέα έκδοση του .ΝΕΤ Framework διατηρεί τα στοιχεία των προηγούμενων εκδόσεων και προσθέτει νέα χαρακτηριστικά. Παρόλο που το CLR είναι το κύριο component του .ΝΕΤ Framework, εκτός από τον αριθμό έκδοσης του .ΝΕΤ έχει και το δικό του αριθμό έκδοσης. Μερικές εκδόσεις του .ΝΕΤ περιλαμβάνουν μια νέα έκδοση του CLR, ενώ άλλες χρησιμοποιούν μια παλιότερη. Για παράδειγμα το .ΝΕΤ 4.0 περιλαμβάνει την τέταρτη έκδοση του CLR ενώ το .ΝΕΤ 3.5 περιλαμβάνει την δεύτερη έκδοση του CLR. Για κά‐
ποιο περίεργο λόγο δεν υπήρχε τρίτη έκδοση του CLR. Η έκδοση του CLR στο οποίο τρέχει μια εφαρμογή μπορεί να προσδιοριστεί λαμβάνοντας την τιμή της property Environ‐
ment.Version. Οι εκδόσεις του .ΝΕΤ Framework συνοψίζονται στον παρακάτω πίνακα: Έκδοση Έκδοση Έκδοση Έτος Έκ‐ Περιγραφή
.ΝΕΤ CLR Visual δοσης Studio 1.0 1.0 VS .NET 2000
Περιείχε την πρώτη έκδοση του CLR και την πρώτη έκδοση των base class libraries 1.1 1.1 VS .NET 2003
Περιείχε ενημερώσεις στην ASP.NET και το 2003 ADO.NET. Η έκδοση αυτή ενημερώθηκε δυο φορές με το Service Pack 1 και το Service Pack 2. Αυτή η έκδοση επέτρεπε στις εφαρ‐
μογές να τρέξουν σε διαφορετικές εκδόσεις του CLR 2.0 2.0 VS
2006
Εισήγαγε μια νέα έκδοση του CLR με προ‐
2005 σθήκες στις βασικές κλάσεις, όπως τα gener‐
ics, generic collections και σημαντικές προ‐
σθήκες στην ASP.NET. Αυτή η έκδοση ενη‐
μερώθηκε με δυο service packs 3.0 2.0 VS 2007
Η έκδοση αυτή είναι ουσιαστικά η έκδοση
2005 2.0 με την προσθήκη του Windows Presen‐
tation Foundation (WPF), Windows Commu‐
nication Foundation, Windows Workflow Foundation (WF) και του cardspace. Ενημε‐
ρώθηκε με το SP1 και το SP2 3.5 2.0 VS
2008
Προστέθηκαν νέα χαρακτηριστικά όπως τα 2008 AJAX‐enabled websites και η LINQ. Το SP1 πρόσθεσε το .ΝΕΤ Client Profile, Dynamic Data και άλλες μικρές ενημερώσεις 4.0 4.0 VS 2010
Περιλαμβάνει μια νέα έκδοση του CLR, επέ‐
2010 κταση στις βιβλιοθήκες κλάσεων και νέα χαρακτηριστικά όπως το Managed Extensi‐
bility Framework και το dynamic language runtime Δεν χρειάζεται να εγκατασταθούν προηγούμενες εκδόσεις του .NET ή του CLR πριν την εγκατάσταση της τελευταίας έκδοσης, αφού κάθε νέα έκδοση είναι θεωρητικά συμβατή με τις παλαιότερες, δηλαδή παρέχει όλα τα απαραίτητα components που χρειάζεται μια εφαρμογή φτιαγμένη σε παλιότερες εκδόσεις. Η συμβατότητα με προηγούμενες εκδόσεις 21 (backward compatibility) γενικά, σημαίνει ότι μια εφαρμογή που έχει αναπτυχθεί για μια συγκεκριμένη έκδοση μιας πλατφόρμας θα τρέξει σε επόμενες εκδόσεις της πλατφόρμας. Το .ΝΕΤ Framework προσπαθεί να μεγιστοποιήσει αυτή τη συμβατότητα έτσι ώστε κώδικας γραμμένος σε μια έκδοσή του να μεταγλωττίζεται σε επόμενες εκδόσεις του και binaries που τρέχουν σε μια έκδοση να τρέχουν με την ίδια συμπεριφορά και στις επόμενες εκδόσεις. Ωστόσο, για τη συμβατότητα με προηγούμενες εκδόσεις πρέπει να λαμβάνονται τα παρακά‐
τω υπόψη: Μια εφαρμογή .ΝΕΤ, προεπιλεγμένα τρέχει στην έκδοση του .ΝΕΤ για την οποία ανα‐
πτύχθηκε. Αν αυτή η έκδοση δεν είναι εγκατεστημένη στον υπολογιστή και το configuration file δεν ορίζει τις υποστηριζόμενες εκδόσεις, μπορεί να προκύψει λάθος στην εκκίνησή της και κάθε προσπάθεια εκτέλεσης της εφαρμογής θα αποτυγχάνει. Είναι δυνατόν να οριστούν συγκεκριμένες εκδόσεις του .ΝΕΤ στις οποίες θα τρέξει η εφαρμογή, προσθέτοντας ένα ή περισσότερα <supportedRuntime> elements στο configuration file της εφαρμογής. Κάθε τέ‐
τοιο element προσδιορίζει την υποστηριζόμενη έκδοση με σειρά προτίμησης: το πρώτο προσδιορίζει την πιο επιθυμητή έκδοση και το τελευταίο την λιγότερο επιθυμητή. Ένα component, σε αντίθεση με μια εφαρμογή, δεν μπορεί να ελέγξει την έκδοση του .NET Framework στην οποία θα τρέξει. Τα components και οι βιβλιοθήκες κλάσεων φορτώ‐
νονται στο πλαίσιο μιας εφαρμογής και κατά συνέπεια τρέχουν στην έκδοση του .ΝΕΤ στην οποία τρέχει η εφαρμογή. Εξαιτίας του περιορισμού αυτού, είναι σημαντικό να παρέχονται εγγυήσεις συμβατότητας των components με μια έκδοση. Από το .ΝΕΤ 4.0 και μετά είναι δυ‐
νατόν να προσδιορίζουμε το βαθμό στον οποίο ένα component αναμένεται να παραμείνει συμβατό με μια έκδοση εφαρμόζοντας σε αυτό το component, το attribute Sys‐
tem.Runtime.Versioning.ComponentGuaranteesAttribute. Η τιμή αυτού του attribute μπορεί να ελεγχθεί από διάφορα εργαλεία για να προσδιορίσουν μια πιθανή παραβίαση της εγγύ‐
ησης συμβατότητας σε μελλοντικές εκδόσεις του component. To .NET Framework 4.0 είναι συμβατό με εφαρμογές που φτιάχτηκαν με τις εκδόσεις 1.1, 2.0, 3.0 και 3.5. Με άλλα λόγια, εφαρμογές και components που φτιάχτηκαν με προη‐
γούμενες εκδόσεις του .ΝΕΤ, μπορούν να τρέξουν στο .ΝΕΤ 4.0. Υπάρχουν, ωστόσο περιπτώ‐
σεις στις οποίες αυτή η συμβατότητα μπορεί να σπάσει από ασυνεπείς αλλαγές στο frame‐
work ή αλλαγές στις προγραμματιστικές τεχνικές. Για παράδειγμα, βελτιώσεις στο .ΝΕΤ 4.0 μπορούν να προκαλέσουν συνθήκες συναγωνισμού (race conditions) που δεν προκαλούνταν στις προηγούμενες εκδόσεις. Επίσης κάθε έκδοση του .ΝΕΤ περιλαμβάνει διορθώσεις bugs και αλλαγές στην ασφάλεια που επηρεάζουν τη συμβατότητα μερικών εφαρμογών ή com‐
ponents. Κατά συνέπεια οι εφαρμογές και τα components πρέπει πάντα να υποβάλλονται σε ελέγχους για να εξασφαλίζεται η συμβατότητά τους με άλλες εκδόσεις του .ΝΕΤ 2.3. Η γλώσσα προγραμματισμού C#
Η C# είναι κατά κύριο λόγο μια αντικειμενοστρεφής γλώσσα προγραμματισμού που ενσωματώνει ωστόσο μερικά χαρακτηριστικά διαφόρων προγραμματιστικών προτύπων. Αναπτύχθηκε στη Microsoft, από μια ομάδα κάτω από την ηγεσία του Anders Hejlberg, σαν μέρος του .ΝΕΤ Framework. 2.3.1. Χαρακτηριστικά της γλώσσας C#
Η C# είναι μια συνεχώς εξελισσόμενη γλώσσα και με κάθε νέα της έκδοση προστίθε‐
νται νέα χαρακτηριστικά και συντακτικό, με μόνιμο στόχο να κάνει τα απλά πράγματα εύκο‐
λα, τα δύσκολα πράγματα εφικτά και τα άσχημα πράγματα δύσκολα. Ακολουθεί μια σύντο‐
μη επεξήγηση των χαρακτηριστικών της C#. Απλότητα (Simplicity)
Η C# είναι μια απλή γλώσσα που μπορεί να χρησιμοποιηθεί χωρίς εντατική εκμάθη‐
ση, ενώ ταυτόχρονα είναι εναρμονισμένη με σύγχρονες προγραμματιστικές πρακτικές. Οι θεμελιώδεις αρχές της γλώσσας μπορούν να κατανοηθούν γρήγορα κάτι που σημαίνει ότι οι προγραμματιστές θα είναι παραγωγικοί σε σύντομο χρονικό διάστημα. 22 Η C# έχει σχεδιαστεί έτσι ώστε να μειώνεται η πιθανότητα πρόκλησης λαθών από την πολυπλοκότητα του κώδικα, αφού τη μειώνει σε μεγάλο βαθμό με το απλουστευμένο συ‐
ντακτικό της και την οργάνωση κώδικά της. Αντικειμενοστρέφεια (Object-Orientation)
Η C# από τα θεμέλια της σχεδιάστηκε να είναι αντικειμενοστρεφής. Ο αντικειμενο‐
στρεφής προγραμματισμός επικράτησε σαν προγραμματιστικό πρότυπο την προηγούμενη δεκαετία και παραμένει στις πρώτες προτιμήσεις των προγραμματιστών. Οι ανάγκες για κα‐
τανεμημένα συστήματα πελάτη‐εξυπηρέτη συμπίπτουν με την ενθυλάκωση και την ανταλ‐
λαγή μηνυμάτων που είναι βασικά χαρακτηριστικά του αντικειμενοστρεφούς προγραμματι‐
σμού. Κατά πολλούς ειδικούς στις γλώσσες προγραμματισμού, η επιτυχής λειτουργία των προγραμματιστικών συστημάτων σε δικτυακά περιβάλλοντα αυξανόμενης πολυπλοκότητας βασίζεται στην αντικειμενοστρέφεια. Η C# παρέχει μια ξεκάθαρη και αποδοτική αντικειμε‐
νοστρεφή πλατφόρμα παρέχοντας στους προγραμματιστές μια συλλογή βιβλιοθηκών δοκι‐
μασμένων αντικειμένων που παρέχουν λειτουργικότητα που ποικίλει από απλούς τύπους δεδομένων, σε διεπαφές εισόδου/εξόδου ή δικτυακές και εργαλεία για τη δημιουργία πα‐
ραθυρικών εφαρμογών. Αυτές οι βιβλιοθήκες μπορούν να προσαρμοστούν στις ανάγκες του προγραμματιστή. Επιπρόσθετα η C# υποστηρίζει και τον προγραμματισμό βασισμένο σε components (component‐based programming) ο οποίος επιτρέπει τον προσδιορισμό αυτόνομων μονά‐
δων λειτουργικότητας (components) που είναι απομονωμένα και τεκμηριωμένα, παρουσιά‐
ζοντας ένα μοντέλο με ιδιότητες, μεθόδους, events και μεταδεδομένα για το component. Η C# υποστηρίζει αυτά τα χαρακτηριστικά άμεσα κάνοντας έτσι τη διαδικασία δημιουργίας και χρήσης των components πολύ εύκολη. Οικειότητα (Familiarity)
Στο ξεκίνημα της υλοποίησής της, οι δημιουργοί της τεχνολογίας C# απέρριψαν την ολοκληρωτική χρήση της C++ σαν γλώσσα υλοποίησης. Στη νέα γλώσσα ωστόσο, κράτησαν αρκετά χαρακτηριστικά της C++ αλλά και της Java και αφαίρεσαν την άχρηστη πολυπλοκότη‐
τα και των δύο. Έτσι έχοντας κρατήσει αρκετά από τα αντικειμενοστρεφή χαρακτηριστικά και τη γενική φιλοσοφία της C++ αλλά και τη γενική ευκολία της Java βελτιώνοντας ορισμένα σημεία της, είναι σχετικά εύκολη τη «μετακόμιση» στη C# δεδομένου ότι η C η C++ αλλά και η Java διδάσκονται σε μαθήματα εισαγωγής στον προγραμματισμό στις περισσότερες σχο‐
λές Πληροφορικής. 2.3.2. Ιστορικό εκδόσεων της C#
Από την πρώτη της έκδοση το 2000, η γλώσσα C# έχει εξελιχθεί αρκετά. Αυτή η εξέλι‐
ξη οφείλεται εν μέρει στην προτίμηση που της δείχνουν η προγραμματιστές μεταξύ των γλωσσών στο .ΝΕΤ. Τα περισσότερα χαρακτηριστικά που προστίθενται αντικατοπτρίζονται στο .NET Framework αφού, όπως προαναφέρθηκε, η γλώσσα C# είναι αναπόσπαστο κομμά‐
τι του. C# 2.0
Η ουσιαστικότερη προσθήκη στη C# 2.0 ήταν η υποστήριξη των generics. Το συντα‐
κτικό ήταν παρόμοιο με τις C++ templates, αλλά η κύρια διαφορά είναι ότι οι τύποι που δη‐
μιουργούνται από τα generics είναι δυναμικοί στη φύση τους, δηλαδή κατασκευάζονται κα‐
τά την εκτέλεση σε αντίθεση με άλλες γλώσσες προγραμματισμού, όπως τη C, που τους κα‐
τασκευάζουν κατά τη μεταγλώττιση. Στη C# 2.0 προστέθηκε και η υποστήριξη των anonymous μεθόδων. Μια anonymous μέθοδος, η οποία μερικές φορές καλείται και lambda function είναι αρκετά χρήσιμη στη δι‐
αχείριση των events. Στη C# 2.0 επίσης, προστέθηκε η υποστήριξη των iterator blocks. Τέτοιες δομές κώδι‐
κα χρησιμεύουν στην εύκολη προσπέλαση ενός αντικειμένου που συμπεριφέρεται σαν col‐
lection. Τέτοια αντικείμενα πρέπει να υλοποιούν το IEnumerable interface το οποίο περι‐
λαμβάνει την μέθοδο GetEnumerator. 23 Τέλος στη C# 2.0 προστέθηκε η υποστήριξη των partial types. Στις προηγούμενες εκ‐
δόσεις κάθε κλάση ήταν υποχρεωτικό να ορίζεται στο δικό της αρχείο (το οποίο ονομαζόταν compilation unit). Η απαίτηση αυτή χαλάρωσε με την εισαγωγή των partial τύπων που διευ‐
κολύνουν την επέκταση χρήσιμων τύπων δεδομένων που παράγονται αυτόματα από οδη‐
γούς όπως για παράδειγμα κατά τη δημιουργία Windows Forms. C# 3.0
Στην τρίτη έκδοση της C# εισήχθησαν μερικά πολύ χρήσιμα χαρακτηριστικά, τα πε‐
ρισσότερα από τα οποία χρησιμεύουν στην υποστήριξη της Language Integrated Query (LINQ). Όλα ωστόσο μπορούν να χρησιμοποιηθούν ανεξάρτητα. Μια πρώτη αλλαγή στη C# 3.0 είναι η υποστήριξη των τοπικών μεταβλητών με υπο‐
νοούμενους τύπους δεδομένων με τη χρήση της λέξης var. Είναι σημαντικό να σημειωθεί ότι αυτές οι μεταβλητές έχουν τύπο δεδομένων ο οποίος όμως προσδιορίζεται κατά την εκτέλε‐
ση και όχι κατά τη μεταγλώττιση όπως γίνεται με τις υπόλοιπες μεταβλητές. Άλλη μια χρήσιμη προσθήκη είναι η αυτόματη δημιουργία των properties μιας κλά‐
σης, μειώνοντας έτσι την πιθανότητα πρόκλησης λαθών που οφείλονται σε λάθος υλοποίη‐
σή τους, αφού δεν χρειάζεται να προστίθενται χειροκίνητα. Επίσης εισήχθησαν νέα χαρακτηριστικά που βοηθούν στην αρχικοποίηση νέων αντι‐
κειμένων με μια σύνθετη πρόταση (compound statement). Στη C# 3.0 εισήχθησαν οι partial methods σαν επέκταση των partial κλάσεων της C# 2.0. Έτσι λοιπόν είναι δυνατόν να δηλωθεί η signature μιας μεθόδου και να αφήνεται στο χρήστη‐προγραμματιστή η επιλογή της υλοποίησής της. Οι extension methods είναι άλλη μια χρήσιμη προσθήκη στη C# 3.0. Οι extension methods επιτρέπουν την προσθήκη μεθόδων σε υπάρχοντες τύπους δεδομένων χωρίς τη δημιουργία νέων τύπων δεδομένων (μέσω της κληρονομικότητας) ή την ανάγκη μεταγλώτ‐
τισης και κατά συνέπεια αλλαγής του αρχικού τύπου δεδομένων. Οι extension methods εί‐
ναι μια ειδική περίπτωση μιας static μεθόδου, αλλά καλούνται σαν να ήταν μέθοδοι στιγμι‐
οτύπου. Ακόμα πιο αξιοπρόσεκτη είναι η υποστήριξη των lambda expressions. Μια lambda expression είναι μια anonymous function που μπορεί να περιέχει expressions και statements που μπορούν να χρησιμοποιηθούν για τη δημιουργία delegates ή τύπους expression tree. Τέλος η σημαντικότερη προσθήκη στη C# 3.0, είναι η LINQ που βασίζεται πάνω στα προηγούμενα χαρακτηριστικά και κυριότερα στις extension methods, τις lambda expressions και τους anonymous τύπους. Εισάγει νέες δεσμευμένες λέξεις για το γράψιμο προτάσεων‐
ερωτήσεων (queries), συνενώνοντας έτσι τον αντικειμενοστρεφή κόσμο με τον κόσμο των δεδομένων. Η LINQ χρησιμοποιείται για την υποβολή ερωτήσεων με τον ίδιο τρόπο σε πολ‐
λαπλές και συχνά ετερογενείς πηγές δεδομένων, όπως σε βάσεις δεδομένων, XML εγγρά‐
φων ή ακόμα και συλλογές αντικειμένων, ενώ προστίθενται συνεχώς και η δυνατότητα υπο‐
βολής ερωτημάτων σε νέες πηγές δεδομένων όπως το Document Object Model. C# 4.0
Οι προσθήκες στην τελευταία έκδοση της C# επικεντρώνονται στην διαλειτουργικό‐
τητα. Εισήχθη ο τύπος dynamic που επιτρέπει την παράκαμψη του ελέγχου τύπου κατά τη μεταγλώττιση, διευκολύνοντας έτσι την πρόσβαση σε COM APIs όπως τα APIs για το Office. Άλλο ένα νέο χαρακτηριστικό της C# 4.0 είναι τα named arguments, η δυνατότητα δηλαδή περάσματος παραμέτρων χωρίς να παίζει ρόλο η σειρά εμφάνισής τους. Συχνά οι παράμετροι μιας μεθόδου είναι προαιρετικές. Έτσι με τη χρήση των named παραμέτρων εί‐
ναι δυνατόν να επιλεχθούν ποιες από τις παραμέτρους θα χρησιμοποιηθούν. Τέλος εισήχθησαν τα χαρακτηριστικά της covariance και contravariance τα οποία επι‐
τρέπουν την έμμεση μετατροπή αναφορών για παραμέτρους τύπου πινάκων, delegates και generics. Με την covariance διατηρούμε την συμβατότητα ανάθεσης ενώ με την contravari‐
ance την αντιστρέφουμε. Οι δύο αυτές έννοιες γίνονται αντιληπτές στην πράξη στις επόμε‐
νες ενότητες. 24 2.3.3. Το πρώτο πρόγραμμα σε C#
Η εκμάθηση μιας γλώσσας προγραμματισμού παραδοσιακά ξεκινάει με το πρόγραμ‐
μα “Hello World!”, ένα από τα απλούστερα προγράμματα που μπορούν να δημιουργηθούν. Ο κώδικας του φαίνεται στη λίστα 3.1. Λίστα 2.1 – HelloWorld.cs 1.
2.
3.
4.
5.
6.
7.
using System;
class Helloworld {
static void Main(String[] args) {
// Εμφάνιση χαιρετισμού στο παράθυρο της κονσόλας
Console.WriteLine(“Hello World!”);
}
}
Έξοδος Hello, World!
Παρόλο που το πρόγραμμα είναι σύντομο, περιλαμβάνει μερικά σημαντικά στοιχεία που είναι κοινά σε όλα τα προγράμματα σε C#. Ας εξετάσουμε κάθε κομμάτι του προγράμ‐
ματος ξεκινώντας με το όνομά του. Το όνομα ενός προγράμματος C# είναι αυθαίρετο. Αντίθετα με άλλες γλώσσες (όπως η Java) στις οποίες το όνομα του αρχείου είναι σημαντικό, στη C# δεν παίζει κάποιο ρόλο. Ωστόσο καλό είναι να είναι όσο το δυνατόν περιγραφικό για το περιεχόμενό του. Πολλοί προγραμματιστές ακολουθούν τη σύμβαση της Java και ονομάζουν το αρχείο σύμφωνα με την κύρια κλάση που περιέχει. Επίσης τα προγράμματα C# έχουν κατάληξη .cs. Στη γραμμή 1, ορίζεται ότι το πρόγραμμα χρησιμοποιεί το namespace System. Στη C# ένα namespace διατηρεί ένα σύνολο ονομάτων ξεχωριστά από ένα άλλο. Κατά συνέπεια τα ονόματα που ορίζονται στο ένα namespace δεν θα συγχέονται με τα ονόματα που ορίζονται σε ένα άλλο namespace, οπότε στην περίπτωση που είναι ίδια τα ξεχωρίζουμε με το namespace. Το namespace System είναι ένα δεσμευμένο namespace για αντικείμενα της βι‐
βλιοθήκης κλάσεων του .ΝΕΤ. Η δεσμευμένη λέξη using απλώς ορίζει ότι θα χρησιμοποιηθεί το namespace που ακολουθεί. Σε επόμενες ενότητες θα δούμε πως ορίζουμε τα δικά μας namespaces, μια διαδικασία που είναι απαραίτητη για τη σωστή οργάνωση των προγραμ‐
μάτων. Στη γραμμή 2 χρησιμοποιείται η δεσμευμένη λέξη class για να δηλωθεί ότι ορίζεται μια νέα κλάση. Μια κλάση είναι η βασική μονάδα ομαδοποίησης μεταβλητών και μεθόδων, δηλαδή των ιδιοτήτων και των συμπεριφορών μιας αφηρημένης έννοιας. Μετά τη λέξη class ακολουθεί το όνομα της κλάσης, στη συγκεκριμένη περίπτωση Helloworld. Τα περιεχόμενα της κλάσης εσωκλείονται σε αγκύλες ({}). Τα στοιχεία μεταξύ των αγκυλών καλούνται μέλη (members) μιας κλάσης. Προς το παρόν δεν χρειάζεται να ξέρουμε λεπτομέρειες για τις κλά‐
σεις, εκτός από το γεγονός ότι η περισσότερη δραστηριότητα ενός προγράμματος C# συμ‐
βαίνει σε αυτές. Στη γραμμή 3 ξεκινά η Main μέθοδος. Μια μέθοδος είναι η βασική μονάδα ομαδο‐
ποίησης εντολών και αντιστοιχεί στη συμπεριφορά μιας αφηρημένης έννοιας. Η μέθοδος Main είναι μια ειδική μέθοδος η οποία προσδιορίζει το σημείο έναρξης ενός προγράμματος. Όλες οι εφαρμογές C# ξεκινάνε την εκτέλεσή τους καλώντας τη μέθοδο Main(). Το πλήρες νόημα κάθε τμήματος της γραμμής θα εξεταστεί σε επόμενες ενότητες ωστόσο αναφέρουμε επιγραμματικά τη σημασία τους. Η παράμετρος της μεθόδου String[] args περιέχει τα ορίσματα γραμμών εντολών (command line arguments). Η δεσμευμένη λέξη static προσδιορίζει ότι η μέθοδος Main μπο‐
ρεί να κληθεί χωρίς την αρχικοποίηση της κλάσης. Όπως θα δούμε σε επόμενη ενότητα, οι περισσότερες μέθοδοι στη C# λειτουργούν μέσα σε αντικείμενα και οι static μέθοδοι δεν εί‐
ναι συχνές σε μεγάλα προγράμματα. Ωστόσο η main πρέπει να είναι πάντα static γιατί τρέχει πριν το πρόγραμμα μπορέσει να δημιουργήσει αντικείμενα. Η πρώτη γραμμή μέσα στη main (γραμμή 4) είναι ένα σχόλιο. Το σχόλιο αυτό είναι προς όφελος του αναγνώστη του πηγαίου κώδικα για να εξηγήσει τι κάνει η επόμενη εντο‐
λή. Κείμενο που ξεκινάει από // αγνοείται από το μεταγλωττιστή. 25 Οι εντολές στο κυρίως μέρος (body) της μεθόδου Main (δηλαδή οι εντολές μεταξύ των αγκίστρων {}) εκτελούνται μία προς μία. Κάθε εντολή λήγει με ένα ελληνικό ερωτηματι‐
κό (;). Η μέθοδος έχει μόνο μια εντολή στη γραμμή 5. Η εντολή αυτή εκτυπώνει μια γραμμή κειμένου και συγκεκριμένα την “Hello, World!”. Ωστόσο υπάρχουν πολλά μέρη όπου θα μπορούσε το πρόγραμμα να στείλει αυτό το κείμενο: σε ένα παράθυρο, σε ένα αρχείο ή σε έναν δικτυωμένο υπολογιστή στην άλλη άκρη του κόσμου. Χρειάζεται επομένως να ορίσου‐
με ότι ο προορισμός είναι η κονσόλα (Console) δηλαδή το παράθυρο της γραμμής εντολών. Το παράθυρο κονσόλας αναπαρίσταται στη C# με την κλάση Console. Για να χρησιμοποιήσουμε μια κλάση όπως την Console, προσδιορίζουμε τι θέλουμε να κάνουμε με αυτήν. Στην περίπτωση της Λίστας 2.1 θέλουμε να εκτυπώσουμε μια γραμμή κειμένου. Η static μέθοδος WriteLine πραγματοποιεί αυτήν την ενέργεια. Δεν χρειάζεται να υλοποιήσουμε αυτήν τη μέθοδο καθώς είναι έτοιμη, απλώς πρέπει να την καλέσουμε. Όταν καλούμε μεθόδους στη C# πρέπει να προσδιορίσουμε τρία πράγματα: 1. Την κλάση ή το αντικείμενο που θα χρησιμοποιήσουμε (σε αυτήν την περί‐
πτωση την κλάση Console) 2. Το όνομα της μεθόδου που θα χρησιμοποιήσουμε (σε αυτή την περίπτωση την WriteLine). 3. Ένα ζευγάρι παρενθέσεων, που περιέχουν κάθε άλλη πληροφορία που χρειάζεται η μέθοδος (σε αυτήν την περίπτωση το κείμενο “Hello, World!”). Αυτή η πληροφορία καλείται παράμετρος της μεθόδου. Μια ακολουθία χαρακτήρων μέσα σε ανωφερή εισαγωγικά (quotation marks) ‐ γνω‐
στά και ως διπλές αποστρόφους ‐ καλείται string. Πρέπει να εσωκλείουμε το περιεχόμενο του string σε εισαγωγικά για να μπορεί ο compiler να τα διακρίνει από τις υπόλοιπες λέξεις και κυρίως τις δεσμευμένες λέξεις της γλώσσας. Συνδυάζοντας το παράδειγμα με όσα αναφέραμε στην αρχή της παραγράφου 3.1 μπορούμε να καταλήξουμε στη συνηθέστερη γενική δομή ενός προγράμματος κονσόλας σε C#: //δήλωση namespace των οποίων τις κλάσεις θα χρησιμοποιήσουμε
using anexamplenamespace;
//δήλωση namespace στο οποίο θα ανήκουν οι παρακάτω κλάσεις
namespace anothernamespace;
//δήλωση της public κλάσης
class RandomClass {
static void main(String[] args) {
// Κλήση εντολών
}
}
2.3.4. Μεταγλώττιση και εκτέλεση ενός προγράμματος
Ανεξάρτητα του περιβάλλοντος ανάπτυξης λογισμικού που μπορεί να χρησιμοποιεί ένας προγραμματιστής, ακολουθείται πάντα ο κύκλος ανάπτυξης edit‐compile‐run. Το κύριο περιβάλλον ανάπτυξης εφαρμογών στη C# είναι φυσικά το Visual Studio. Για την εκτέλεση των περισσότερων παραδειγμάτων σε αυτό το σεμινάριο αρκεί οποιαδήποτε έκδοσή του, ωστόσο όσες χρησιμοποιούν στοιχεία της C# 4.0, χρειάζονται μια από τις εκδόσεις του Visual Studio 2010. Χρησιμοποιώντας το Visual Studio υπάρχουν δύο προσεγγίσεις για τη δημιουρ‐
γία, μεταγλώττιση και εκτέλεση ενός προγράμματος. Η πρώτη είναι με τη χρήση του Visual Studio IDE και η δεύτερη με τον μεταγλωττιστή γραμμής εντολών, csc.exe. Παρόλο που το Visual Studio IDE είναι αυτό που πιθανότερα θα χρησιμοποιήσει ένας προγραμματιστής στα διάφορα έργα είναι πιθανό κανείς να βρει απλούστερη τη χρήση του μεταγλωττιστή γραμ‐
μής εντολών, ειδικά για μικρά προγράμματα, όπως τα περισσότερα παραδείγματα εδώ, ε‐
πειδή δεν χρειάζεται να φτιάχνονται ολόκληρα projects. Χρήση του Command-Line Compiler
Βήμα 1 – Γράψιμο κώδικα Αρχικά γράφουμε το πρόγραμμα χρησιμοποιώντας έναν text editor και το αποθηκεύ‐
ουμε σε ένα αρχείο με την κατάληξη .cs. Αυτό το αρχείο που είναι ακόμα σε αναγνώσιμη 26 από τον άνθρωπο μορφή καλείται πηγαίο αρχείο (source file). Για τη γραφή μπορούμε να επιλέξουμε έναν απλό text editor όπως το notepad ή το notepad++. Βήμα 2 – Μεταγλώττιση σε ενδιάμεση γλώσσα Το επόμενο βήμα είναι η μεταγλώττιση του πηγαίου αρχείου. Για τη μεταγλώττιση χρησιμοποιούμε τον μεταγλωττιστή csc.exe στη γραμμή εντολών των Windows (Command Prompt). Ο μεταγλωττιστής βρίσκεται συνήθως στο directory C:\Windows\Microsoft.NET\Framework\v<αριθμός έκδοσης>. Με την επιτυχή ολοκλήρωση της μεταγλώττισης, δημιουργείται η μεταγλωττισμένη έκδοση του πηγαίου κώδικα σε μη αναγνώσιμη από τον άνθρωπο μορφή, την ενδιάμεση γλώσσα IL. Το αρχείο που περιέχει την IL καλείται assembly και έχει την κατάληξη .exe (αν προοριζόταν για εκτελέσιμο) ή .dll (αν προοριζόταν για βιβλιοθήκη – στην περίπτωση αυτή ο μεταγλωττιστής χρειάζεται επιπρό‐
σθετες παραμέτρους) ενώ το πρόθεμα είναι το ίδιο με του πηγαίου αρχείου. Όταν προκύπτουν λάθη στο πρόγραμμα θα εμφανίζεται ένα μήνυμα λάθους, αντίθε‐
τα δεν θα εμφανίζεται τίποτα ή θα εμφανίζεται ένα μήνυμα επιτυχίας. Τα λάθη που εντοπί‐
ζονται από τον μεταγλωττιστή καλούνται λάθη κατά τη μεταγλώττιση (compilation errors). Τέτοια λάθη προφανώς είναι τα ευκολότερα στον εντοπισμό και συνήθως γίνονται εξαιτίας της παράβασης των συντακτικών κανόνων της γλώσσας. Βήμα 3 ‐ Εκτέλεση Το τελευταίο βήμα είναι η εκτέλεση του assembly. Εκτελούμε ένα εκτελέσιμο assem‐
bly πολύ απλά καλώντας το με το όνομά του ή με διπλό κλικ στο εικονίδιό του. Τότε το CLR αναλαμβάνει να διατρέξει το αρχείο και να εκτελέσει τις εντολές του. To CLR χρησιμοποιεί αποκλειστικά τον just‐in‐time compiler για τη μεταγλώττιση της ενδιάμεσης γλώσσας σε γλώσσα μηχανής, καθιστώντας έτσι την εκτέλεση γρηγορότερη. Λάθη που εντοπίζονται από τον διερμηνευτή καλούνται λάθη κατά την εκτέλεση (runtime errors) και συνήθως οφείλονται σε σφάλματα στη λογική του προγράμματος. Χρήση του Visual Studio
Το Visual Studio είναι το Integrated Development Environment (IDE) της Microsoft. Δίνει τη δυνατότητα επεξεργασίας, μεταγλώττισης, εκτέλεσης και αποσφαλμάττωσης του κώδικα ενός προγράμματος (μεταξύ άλλων) μέσα από το περιβάλλον. Το Visual Studio διευ‐
κολύνει σημαντικά την ανάπτυξη εφαρμογών και είναι ιδιαίτερα αποτελεσματικό σε μεγάλα έργα. Τα βήματα που χρειάζονται για την επεξεργασία, μεταγλώττιση και εκτέλεση ενός προγράμματος C# με το Visual Studio 2010 περιγράφονται παρακάτω. Για τα βήματα αυτά έγινε χρήση του Visual Studio 2010, Visual C# 2010 Express. Βήμα 1 – Δημιουργία ενός νέου project Δημιουργούμε ένα νέο κενό project επιλέγοντας File | New | Project. Στη συνέχεια επιλέγουμε Empty Project από το μενού Installed Templates | Visual C# και πατάμε ΟΚ: 27 όνα 2.2 ‐ Δημιιουργία ενός κενού project από το Visuual Studio Εικό
oject και το Visual Studio θθα πρέπει να φαίνεται Μόλις έχειι δημιουργηθθεί το νέο pro
όπωςς στην παρακάτω εικόνα:
ώτη εικόνα μεετά τη δημιου
υργία ενός νέοου project Εικόννα 2.3 ‐ Η πρώ
οιονδήποτε λόόγο δεν φαίννεται το παρά
άθυρο Solutioon Explorer, μπορεί μ
να Αν για οπο
ενεργοποιηθεί απ
πό το μενού V iew. Βήμα 2 – Δ
Δημιουργία εννός πηγαίου α
αρχείου και π
προσθήκη κώδδικα Σε αυτό το
ο σημείο το pproject είναι άδειο και ά
χρειάζεται να τοου τοποθετήσ
σουμε ένα πηγα
αίο αρχείο. Αυ
υτό γίνεται πα
ατώντας δεξί κλικ στο όνο
ομα του projeect (το οποίο είναι Pro‐
ject1
1 σε αυτό το π
παράδειγμα) σστο παράθυρο Solution Exp
plorer και επιλ
ιλέγοντας Add
d. Θα φαί‐
νετα
αι κάτι σαν το παρακάτω: 28 όνα 2.4 ‐ Προοσθήκη ενός ννέου item από
ό το solution explorer Εικό
ας New Item, εεμφανίζεται ττο παράθυρο διαλόγου Addd New Item. Α
Από αυτό, Επιλέγοντα
επιλέέγουμε Code File από το μ ενού Installed
d Templates | Visual C# Iteems και πατάμ
με το κου‐
μπί A
Add. 2.5 ‐ Το παρά
άθυρο διαλόγγου κατά την π
προσθήκη ενόός νέου Item Εικόνα 2
πει να φαίνεται ως εξής: Το Visual Sttudio θα πρέπ
29 Το Visual Studdio μετά την π
προσθήκη ενό
ός νέου κενούύ αρχείου κώ
ώδικα Εικόνα 2.6 ‐ Τ
Το επόμενο
ο βήμα είναι ηη προσθήκη ττου κώδικα. Αντιγράφουμε τον κώδικα ττης Λίστας 2.1 σ
στο κύριο παρ
ράθυρο (χωρίίς τους αριθμ
μούς των γραμμών). Όταν τελειώσουμε το Visual Studio θα πρέπει ννα φαίνεται ω
ως εξής: Εικόνα 22.7 ‐ Προσθήκκη κώδικα στο νέο αρχείο Μεταγλώττισηη του προγρά
άμματος Βήμα 3 – Μ
Μεταγλωτττίζουμε το πρ όγραμμα επιλλέγοντας Build Solution αππό το μενού Bu
uild. Βήμα 4 – Ε
Εκτέλεση του π
προγράμματο
ος Εκτελούμε το πρόγραμμ
μα επιλέγοντα
ας Start Witho
out Debuggingg από το μενο
ού Debug. Κατά
ά την εκτέλεση
η του προγρά
άμματος θα φα
ανεί το παρακ
κάτω παράθυ ρο: 30 προγράμματοος Hello World
d Εικόνα 2..8 ‐ Το αποτέλλεσμα της εκττέλεσης του π
ου οι προηγούύμενες οδηγίεες είναι αρκεττές για τη μετταγλώττιση κα
αι εκτέλε‐
Παρόλο πο
ση των παραδειγμάτων σε αυττό το σεμινάρ
ριο, αν θέλου
υμε να χρησιμμοποιήσουμε το Visual ριο περιβάλλοον προγραμμα
ατισμού, θα π
πρέπει να εξοοικειωθούμε με τις δυ‐
Studio σαν το κύρ
ότητες και τα χχαρακτηριστικκά του. Είναι ένα πολύ δυννατό IDE και ββοηθάει στη δ
διαχείριση νατό
μεγά
άλων έργων. Αξίζει Α
το χρόννο και την πρ
ροσπάθεια για να εντρυφήήσει κανείς στη σ χρήση του V
Visual Studio, αφού είναι ττο εργαλείο πο
ου χρησιμοπο
οιείται στη συυντριπτική πλεειονότητα των π
περιπτώσεωνν ανάπτυξης έέργων στο .ΝΕΤ στους περισ
σσότερους ορργανισμούς. 31 3. Microsoft Visual Studio
Έχοντας δει τη δημιουργία και εκτέλεση ενός απλού προγράμματος με τον command line compiler και έναν απλό κειμενογράφο σαν το Notepad μπορούμε να φανταστούμε τι γί‐
νεται στο σενάριο που πρέπει να δουλέψουμε σε ένα project που περιλαμβάνει χιλιάδες γραμμές κώδικα. Είναι προφανές πως θα ήταν υπερβολικά δύσκολο να υλοποιήσουμε μια εφαρμογή ακολουθώντας αυτή τη διαδικασία. Ο απλός κειμενογράφος αγνοεί τη σύνταξη του κώδικα και δεν μπορεί να κάνει διαχωρισμό μεταξύ λέξεων που έχουν ειδική σημασία για τη γλώσσα. Ο προγραμματιστής θα έπρεπε να συντάξει τον κώδικα χωρίς κανένα ουσιαστικό βοήθημα από τον κειμενογράφο, στη συνέχεια να τον μεταγλωττίσει φεύγοντας από αυτόν και πηγαίνοντας σε κάποιο άλλο παράθυρο (του command line), ενώ στην περίπτωση που υπήρχαν λάθη, θα έπρεπε να τα εντοπίσει και να τα διορθώσει ελέγχοντας μια μια τις λέξεις του κώδικα που βρίσκονται κοντά στη γραμμή που του υπέδειξε ο compiler. Κάτι τέτοιο, όπως είναι λογικό, είναι εντελώς αντιπαραγωγικό. Για το λόγο αυτό αναπτύχθηκαν τα Ενιαία Περιβάλλοντα Υλοποίησης (Integrated Development Environments). Το Visual Studio είναι το Integrated Development Environment της Microsoft για την ανάπτυξη εφαρμογών που στοχεύουν στο .NET Framework και άλλες πλατφόρμες της Mi‐
crosoft: από εφαρμογές κονσόλας (console applications) μέχρι web services και εγγενή κώ‐
δικα (native code). Το Visual Studio περιλαμβάνει πλήθος εργαλείων για την υποστήριξη της ανάπτυξης εφαρμογών από τα πρώτα στάδια μέχρι και τα τελικά. Περιλαμβάνει έναν επεξεργαστή κώ‐
δικα (code editor) με αυτόματη συμπλήρωση (IntelliSence), που επιταχύνει το γράψιμο και ενσωματώνει έναν debugger (αποσφαλματωτή) για τον άμεσο εντοπισμό σφαλμάτων. Άλλα εργαλεία περιλαμβάνουν την σχεδίαση παραθυρικών εφαρμογών και τη σχεδίαση κλάσεων και βάσεων δεδομένων, ενώ μπορεί να επεκταθεί με τα διάφορα επιπρόσθετα εργαλεία που κυκλοφορούν από τη Microsoft ή τρίτους παρόχους. 3.1. Εκδόσεις του Visual Studio
Υπάρχουν πολλαπλές εκδόσεις του Visual Studio. Τα παραδείγματα του σεμιναρίου αυτού όμως βασίζονται στο Visual C# 2010 Express Edition το οποίο διατίθεται δωρεάν. Ω‐
στόσο ας δούμε τι προσφέρουν οι υπόλοιπες εκδόσεις. 3.1.1. Visual Studio Express
Οι εκδόσεις Visual Studio Express είναι ένα σύνολο ελαφρών ανεξάρτητων IDEs που παρέχονται σαν απογυμνωμένες εκδόσεις του Visual Studio δωρεάν, ανά πλατφόρμα και ανά γλώσσα. Πιο συγκεκριμένα οι εκδόσεις περιλαμβάνουν τα εργαλεία ανάπτυξης για τις αντίστοιχες πλατφόρμες (web, windows, phone) ή για τις αντίστοιχες γλώσσες (VB, C#). Το Visual Studio Express περιλαμβάνει μόνο ένα υποσύνολο των εργαλείων που παρέχονται στις άλλες εκδόσεις. Επίσης δεν υποστηρίζει plug‐ins. Οι μεταγλωττιστές για 64‐bit αρχιτε‐
κτονικές δεν συμπεριλαμβάνονται στις εκδόσεις express, ωστόσο μπορούν να εγκαταστα‐
θούν ξεχωριστά. Οι εκδόσεις express στοχεύουν στην εκπαίδευση και στους χομπίστες. Τέ‐
λος οι express εκδόσεις δεν χρησιμοποιούν την πλήρη MSDN Library αλλά την MSDN Essen‐
tials Library. 3.1.2. Visual Studio LightSwitch
Το Visual Studio LightSwitch είναι ένα απλοποιημένο IDE που επιτρέπει τη δημιουρ‐
γία εταιρικών εφαρμογών γρήγορα και εύκολα για το desktop ή το cloud. Οι εφαρμογές που παράγονται είναι αρχιτεκτονικά 3 επιπέδων: η διεπαφή χρήστη τρέχει σε Microsoft Silver‐
light, η λογική και το επίπεδο πρόσβασης δεδομένων βασίζεται σε WCF RIA Services και το Entity Framework ενώ φιλοξενείται στην ASP.NET. Επίσης υποστηρίζει και τον SQL Server αλλά και το Microsoft SQL Azure για την αποθήκευση δεδομένων. Περιλαμβάνει περιβάλλο‐
32 ντα σ
σχεδίασης για
α το σχεδιασμ
μό οντοτήτωνν και συσχετίσ
σεων αλλά κααι γραφικών δ
διεπαφών. Η λο
ογική της εφαρμογής μπορρεί να γραφτεί σε Visual Ba
asic ή C#. Η έ κδοση αυτή μ
μπορεί να εγκα
ατασταθεί αυττόματα ή μέσα
α στο Visual SStudio Professional. 3.1..3. Visual Studio Pro
ofessionall
Το Visual SStudio Professsional παρέχεει ένα IDE για όλες τις υποοστηριζόμενεςς γλώσσες στο .NET. Απλουσ
στεύει τη δημ
μιουργία, την αποσφαλμάττωση και την εγκατάσταση
η εφαρμο‐
ud. Η υπο‐
γών σε πολλαπλές πλατφόρμεςς, που συμπεριλαμβάνουνν το SharePoinnt και το Clou
στήρ
ριξη στο MSDN
N διατίθεται σστην έκδοση Essentials ή σ
στην πλήρη έκκδοση, ανάλο
ογα με την άδεια που αγοράστηκε. Υποσττηρίζει την επεξεργασία XM
ML και XSLT κααι μπορεί να δημιουρ‐
γήσεει πακέτα εγκα
ατάστασης ποου χρησιμοπο
οιούν τις τεχνο
ολογίες ClickO
Once και MSI. Συμπερι‐
λαμβ
βάνει εργαλείία όπως τον Seerver Explorer για την ενοπ
ποίηση με τονν SQL Server. 3.1..4. Visual Studio Pre
emium
Η έκδοση Premium είνα
αι ένα πλήρες σύνολο εργγαλείων που απλουστεύει την ανά‐
πτυξξη εφαρμογώνν ατομικά αλλλά και στα πλλαίσια ομάδω
ων ανάπτυξηςς. Ουσιαστικά περιλαμ‐
βάνεει όλα τα εργα
αλεία της έκδοοσης Professional αλλά και εργαλεία γιαα την ανάλυση του κώ‐
δικα, εργαλεία για
α profiling αλλλά και για dattabase unit testing. 3.1..5. Visual Studio Ulttimate
Η έκδοση Ultimate αποοτελεί μετονο
ομασία της έκ
κδοσης Team Suite. Η έκδοση αυτή παρέέχει ένα σύνο
ολο εργαλείωνν για την υπο
οστήριξη της σ
συνεργατικήςς ανάπτυξης έέργων στο .ΝΕΤΤ. Επιπρόσθεττα των χαρακκτηριστικών το
ου Visual Studio Premium,, συμπεριλαμ
μβάνονται και εεργαλεία για ττην ανάπτυξη βάσεων δεδο
ομένων, την α
ανάλυση του κώδικα, την α
αρχιτεκτο‐
νική μιας εφαρμογής, τη δοκιμ
μή αλλά και ερ
ργαλεία reporting. 3.2
2. Εγκατάσταση
Για να εγκα
αταστήσουμε το Visual C# 2
2010 Express στον υπολογιιστή μας ακολλουθούμε τα επ
πόμενα βήματτα: 1. Έχχοντας πρόσββαση στο Web
b, από το web
bsite της Mic rosoft για το Visual C# 20
010 Express κατεβάζουμεε τον οδηγό εγκατάστασηης του Visual C# 2010 Exxpress (vcs_weeb.exe). 2.
Σττην ερώτηση αν θέλουμ
με να εκτελέ
έσουμε ή ναα αποθηκεύσ
σουμε το vccs_web.exe, εεπιλέγουμε Run αν θέλουμε να εγκατααστήσουμε άμεσα ά
την εφ
φαρμογή ή Saave αν θέλουμ
με να την εγκαταστήσουμεε αργότερα. ΣΣτη δεύτε‐
ρη
η περίπτωση π
πρέπει να θυμ
μηθούμε να έχουμε πρόσββαση στο Interrnet. 33 3.
4.
5.
φού φορτώσεει τα αρχεία π
που χρειάζετα
αι, ο οδηγός εεγκατάστασης εμφανί‐
Αφ
ζει ένα μήνυμα
α καλωσορίσμ
ματος όπου επ
πιλέγουμε αν θέλουμε να σ
στείλουμε άσταση στη Microsoft. πλληροφορίες γιια την εγκατά
Σττη συνέχεια εεπιλέγουμε ανν αποδεχόμα
αστε τους όροους της άδεια
ας χρήσης τη
ης εφαρμογήςς. Σττη συνέχεια επ
πιλέγουμε τα
α επιπρόσθετα
α προϊόντα ποου θέλουμε να εγκατα‐
στταθούν. Οι δ ιαθέσιμες επ
πιλογές είναι α) Microsoftt Silverlight και κ β) Mi‐
crosoft SQL Serrver 2008 Exp
press Service P
Pack 1. Στα πλλαίσια του σεεμιναρίου 34 δεεν θα διδαχθεεί η τεχνολογία Silverlight οπότε μποροούμε να μην ττην επιλέ‐
ξο
ουμε για εγκα
ατάσταση. Ανττίθετα θα χρε
ειαστούμε τοον SQL Server 2008 Ex‐
prress οπότε πρέέπει να τον επ
πιλέξουμε για
α εγκατάστασηη. 6.
7.
υμε το Visual Studio Έπ
πειτα επιλέγοουμε που θέλουμε να εγκαταστήσου
ε
Exxpress. Αν δενν έχουμε κάπ
ποιο συγκεκριμένο λόγο, εππιλέγουμε την προεπι‐
λεεγμένη θέση κκαι πατάμε το κουμπί Insttall, αφού βεββαιωθούμε ότι έχουμε διαθέσιμο τον απαραίτητο για την εφαρ
ρμογή χώρο σστο σκληρό δίσκο. δ
Στο πα
αράθυρο αυτόό βλέπουμε κκαι μια επισκό
όπηση του τι θα εγκατασταθεί στον υπ
πολογιστή μα ς. Σττη συνέχεια οο οδηγός εγκκατάστασης κατεβάζει κ
καιι εγκαθιστά τα τ αρχεία πο
ου χρειάζοντα
αι. 35 8.
ατά την ολοκλλήρωσή της εγγκατάστασης,, ο οδηγός εμμφανίζει μήνυμα επιτυ‐
Κα
χία
ας. Το Visual SStudio Expresss είναι έτοιμο
ο για χρήση. 3.3
3. Το περ
ριβάλλον
ν του Visual C# 2010 Expresss
Έχοντας εγγκατεστημένοο το Visual Sttudio μπορούμε να το ξεκκινήσουμε επιλέγοντας διαδ
δοχικά Start 
 All Program
ms  Microsoft Visual Studio 2010 Expreess  Microssoft Visual C# 20
010 Express. Η
Η αρχική σελίίδα θα φαίνετται ως εξής: Εικόνα 3.1 ‐ Η
Η αρχική σελλίδα του Visua
al C# 2010 Exppress ε
μμια σελίδα γννωστή ως Προεπιλεγμένα, όταν ξεεκινάμε το Visual Studio εμφανίζεται Startt Page. Σε αυττήν εμφανίζοννται μηνύματτα καλωσορίσ
σματος, βίντεοο με οδηγούςς και πλη‐
ροφο
ορίες όπως τα
α projects στα
α οποία δουλεεύαμε τελευταία αλλά και μια επιλογή γγια τη λή‐
ψη ττων τελευταίω
ων νέων μέσα
α από RSS Fee
eds. Στην έκδο
οση express, ω
ωστόσο δεν μ
μπορούμε να ρυθμίσουμε τη
η συμπεριφορρά της. Ακολο
ουθεί μια ανα
αφορά σε ορρισμένα από ττα βασικά ά στοιχεία ωσ
στόσο έχουν ααφεθεί σκόπιμα για να στοιχχεία του Visual C# 2010 Exxpress. Αρκετά
περιγγραφτούν στιις ενότητες ποου τους αντισττοιχούν. 3.3..1. Ο Solu
ution Explo
orer
Όταν δημιο
ουργούμε μια
α νέα, ανοίγουμε μια υπάρ
ρχουσα εφαρμμογή, ή ακόμ
μα και ένα μόνο
ο αρχείο, το V
Visual Studio 22010 χρησιμο
οποιεί την ένννοια του soluttion (λύσης) γγια να ορ‐
γανώ
ώσει τα πάντα
α. Συνήθως έννα solution α
αποτελείται απ
πό ένα ή περρισσότερα pro
ojects, κα‐
θένα
α από τα οποίία περιλαμβάννει πολλαπλά
ά άλλα αρχεία
α. Το παράθυρρο εργαλείου του Solu‐
tion Explorer (Ctrl+Alt+L) παρέέχει μια βολικκή οπτική ανα
απαράσταση του solution, των pro‐
ω. Σε αυτήν τηην εικόνα μπο
ορούμε να jectss και των αρχεείων, όπως αυυτή της εικόνας παρακάτω
36 δούμ
με τρία projects σε μια δεεντρική μορφή. Κάθε proje
ect συνοδεύεεται από ένα εικονίδιο που συνήθως υπο
οδεικνύει καιι το είδος του
υ project αλλά
ά και τη γλώσσσα προγραμ
μματισμού πάρχουν και εξαιρέσεις σε
ε αυτόν τον κκανόνα όπωςς τα setup στηνν οποία είναι γραμμένο. Υπ
projeects που δεν έέχουν κάποια α γλώσσα. θυρο του solu
ution explorerr Εικόνα 33.2 ‐ Το παράθ
Ένας κόμβο
ος ξεχωρίζει, γιατί το font του είναι bold. Αυτό υποδδεικνύει ότι ττο project είναιι το startup project, δηλαδδή αυτό που θ
θα τρέξει ότανν επιλέξουμε Debug  Sta
art Debug‐
ging ή πιέσουμε ττο F5. Για να αλλάξουμε ττο startup pro
oject, κάνουμεε δεξί κλικ σττο project S as StartUpp Project. Είναι επίσης που θέλουμε να θέσουμε σανν startup και επιλέγουμε Set ατό να θέσουμε πολλαπλά
ά projects σανν startup από το διάλογο SSolution Prope
erties που δυνα
μπορ
ρούμε να βρούμε επιλέγονντας Propertie
es πατώντας δ
δεξί κλικ στον κόμβο Solutio
on. Η γραμμή εργαλείων σττην κορυφή ττου Solution E
Explorer επιτρρέπει την προ
οσαρμογή της εεμφάνισης τω
ων περιεχομέννων του παρα
αθύρου και δίνει συντομεύύσεις στις διά
άφορες ό‐
ψεις των περιεχομ
μένων. Για πα
αράδειγμα το κουμπί Show
w All Files, επεεκτείνει το solution εμ‐
ρόσθετα αρχεεία και φακέλλους που δενν εμφανίζοντααι προεπιλεγμ
μένα. Ένα φανίίζοντας επιπρ
πράγγμα που πρέπ
πει να θυμόμα
αστε είναι όττι αν αλλάξει κάτι από το ffile system, οι αλλαγές δεν θ
θα φαίνονται άμεσα στον SSolution Explo
orer. Το κουμπ
πί Refresh αναανεώνει τα αρ
ρχεία που φαίννονται έτσι ώσ
στε να είμαστεε σίγουροι όττι βλέπουμε τα
α σωστά αρχεεία. Εκτός από έναν βολικό ττρόπο εμφάνισης των projjects και των δδιαφόρων ite
ems, ο So‐
lution Explorer έχχει ένα δυναμ
μικό μενού πο
ου προσαρμόζζεται ανάλογαα με το είδοςς του item ώσει την πρόσ
σβαση στις πιο συχνές εργγασίες, όπως το να κά‐
που επιλέγεται γιια να μας δώ
με build το solution ή ένα μ
μεμονωμένο p
project, να χειριστούμε τονν configuratio
on manag‐
νουμ
er το
ου build και να ανοίγουμε αρχεία. Οι πα
αραλλαγές το
ου μενού αυτοού φαίνονταιι στην πα‐
ρακά
άτω εικόνα. Εικόνα 3.3 ‐ Οι π
παραλλαγές ττου μενού που εμφανίζετα
αι με δεξί κλικκ για διάφορο
ους κόμ‐
olution explorer βους του so
37 αι το κεντρικό μενού σχεττίζονται με το
ο building Οι πρώτες επιλογές στοο αριστερό κα
ολόκκληρου του so
olution ή ενόςς μεμονωμένο
ου project. Στις περισσότερρες περιπτώσ
σεις, το να επιλέέγουμε το Build είναι η πιοο αποδοτική εεπιλογή, γιατί build γίνεται μόνο στα pro
ojects που έχου
υν αλλάξει. Υπ
πάρχουν περιιπτώσεις όμω
ως που χρειάζζεται να κάνοουμε Rebuild, κάτι που σημα
αίνει ότι θα γίίνει build σε όόλα τα σχετικά
ά projects ανε
εξαρτήτως τηςς κατάστασής τους. Προ
οσθήκη νέω
ων Projects κκαι Items
Μια από τιις πιο συνηθισσμένες ενέργεειες που γίνοννται με τον Soolution Explorrer είναι η προσ
σθήκη, η αφα
αίρεση και η μ
μετονομασία των projects και των itemss. Για την προ
οσθήκη ε‐
νός ννέου project σ
σε μια υπάρχχουσα solution
n, επιλέγουμε
ε Add  New
w Project από το μενού που εμφανίζεται με δεξί κλικ σστον κόμβο So
olution. Αυτό εμφανίζει τοο παρακάτω π
παράθυρο ηθούν ως προ
ος το όνομα. Ο χώρος στα δεξιά εμ‐
διαλόγου. Οι επιλλογές μπορούύν να ταξινομη
ρίες για το επ
πιλεγμένο pro
oject, όπως το
ον τύπο του κκαι την περιγρ
ραφή του. φανίίζει πληροφορ
Στο Visual V
C# 201
10 Express ο χχώρος Installe
ed Templates περιλαμβάνεει ένα υποσύ
ύνολο των temp
plates των εμ
μπορικών εκδόόσεων του Viisual Studio και κ φυσικά μόόνο για τη γλλώσσα C#. Με την τ επιλογή των τ Online Teemplates μπο
ορούμε να ταξινομήσουμε και να αναζητήσουμε temp
plates με τον ίδιο τρόπο π
που κάνουμε με τα Installe
ed Templates, , αλλά με περ
ρισσότερα κριτή
ήρια. προσθήκη ενόός ή περισσοττέρων projectts, θα χρειασττεί η προσθήκη ενός ή Μετά την π
περισσοτέρων items μέσα στο project αυτό.. Είναι σημανττικό να προσέέξουμε τη δια
αφορά με‐
αι ενός αρχείοου. Παρόλο πο
ου αρκετά tem
mplates περιέέχουν μόνο έννα αρχείο ταξύ ενός item κα
ρχουν και οριισμένα που π
περιέχουν πολλλαπλά. Επιλέ
έγοντας τον κόόμβο ενός project, πα‐
υπάρ
τάμεε δεξί κλικ για
α να εμφανισττεί το μενού κκαι από εκεί ε
επιλέγουμε Addd. Στο υπο‐μ
μενού που εμφα
ανίζεται επιλέέγουμε New Ittem για να εμ
μφανιστεί το π
παράθυρο διααλόγου Add N
New Item. Το παράθυρο αυττό είναι όμοιοο με το παράθ
θυρο διαλόγο
ου για την προοσθήκη ενός νέου pro‐
ρή πλευρά υπά
άρχει η λίστα με τα Installe
ed Templates που αφορούνν το είδος ject. Στην αριστερ
μας επιτρέπει να αναζητήσσουμε το item
m που ψά‐
του project που έέχουμε επιλέξξει η οποία μ
υμε από τη λίσ
στα, αλλά κα ι να δούμε τιις online temp
plates που έχοουν παραχθεί από τρί‐
χνου
τουςς παρόχους. Εικόνα
α 3.4 ‐ Παράθυ
υρο διαλόγου
υ για τη δημιο
ουργία ενός ννέου project 38 Εικόννα 3.5 ‐ Παράθ
θυρο διαλόγο
ου για την προσθήκη ενός νέου Item Προ
οσθήκη ανα
αφορών
Ένας από ττους τρόπους με τους οποίίους το Visual Studio υποσστηρίζει την εεπαναχρη‐
σιμο
οποίηση των componentss είναι μεε τον μηχαννισμό της ππροσθήκης αναφορών α
(refeerences). Μια αναφορά, ουυσιαστικά επιττρέπει στον compiler να ανναγνωρίσει τύ
ύπους δε‐
δομέένων, ιδιότητεες, πεδία και μεθόδους έττσι ώστε να γίίνει build. Αν χρειαστεί να χρησιμο‐
ποιήσουμε μια κλλάση ενός τρρίτου παρόχου, ή ακόμα και κ ένα δικό μμας .NET assembly θα αστεί να προσ
σθέσουμε μια
α αναφορά πρ
ρος αυτό. Αυτό
ό γίνεται απόό το μενού που εμφανί‐
χρεια
ζεται με δεξί κλικ σε κάποιο κόόμβο project και την επιλο
ογή Add Refe rence. Η επιλλογή αυτή ανίζει το παρα
ακάτω παράθθυρο διαλόγου
υ. εμφα
Εικόνα
α 3.6 ‐ Παράθ
θυρο διαλόγο
ου για την προ
οσθήκη μιας αναφοράς Κατά το άννοιγμα του πα
αραθύρου αυττού, το Visual Studio αναζηητά στον τοπικκό υπολο‐
γιστή
ή, την Global Assembly Cacche και το αννοιχτό solution
n και κατασκεευάζει μια λίσ
στα με τις γνωσ
στές βιβλιοθή
ήκες που μπορρούν να προσ
στεθούν. Αυτέ
ές περιλαμβάν
άνουν και τις α
αναφορές του ..NET και του COM που εμφ
φανίζονται σεε διαφορετικά
ά tabs, αλλά και αυτές τωνν projects και ττων πρόσφατα
α χρησιμοποιιημένων αναφ
φορών. Αν το component ππου θέλουμε να χρησι‐
μοπο
οιήσουμε δενν βρίσκεται σσε κάποια από
ό αυτές τις λίστες τότε μππορούμε να το τ εντοπί‐
σουμ
με μέσω του B
Browse tab κα
ατευθείαν από
ό το file system. Είναι δυνα
ατό να προσθέέσουμε αναφ
φορά σε κανοννικά projects μέσα στο τρέέχον solu‐
tion, αντί να αναφ
φερθούμε στα
α μεταγλωττισ
σμένα binary components.. Μια τέτοια π
προσθήκη ημα ότι μποροούμε να κάνο
ουμε ευκολόττερα debug κααι σιγουρευόμαστε ότι έχει το πλεονέκτη
σιμοποιούμε ττην τελευταία
α έκδοση όλωνν των compon
nents. χρησ
Προ
οσθήκη ανα
αφορών σε services
Ένας άλλοςς τύπος αναφ
φορών που μπ
πορούμε να π
προσθέσουμε σε ένα proje
ect από το Visuaal Studio είνα
αι η αναφορέςς σε services. Πατώντας δεξί κλικ σε οποοιονδήποτε κό
όμβο pro‐
ject εμφανίζεται η επιλογή Addd Service Refference. Αυτή
ή εμφανίζει τοο παράθυρο διαλόγου 39 Add Service Referrence, το οποοίο φαίνεται σ
στην παρακάττω εικόνα. Παατώντας το κο
ουμπί Dis‐
ριοχή Ser‐
coveer εμφανίζονται τα πιθανά services που υπάρχουν στο τρέχον Soluution στην περ
vicess. Στην περιοχχή Operationss εμφανίζοντα
αι οι διαθέσιμ
μες λειτουργίεες που παρέχο
ονται από μια υ
υπηρεσία. Ακριβώς από κά
άτω εμφανίζεεται μια περιο
οχή κειμένου όπου εμφανίίζονται τα μηνύ
ύματα επιτυχίίας ή αποτυχία
ας κατά τη σύ
ύνδεση με τηνν επιλεγμένη υυπηρεσία. Στην κάτω αριστερά γω
ωνία του παρα
αθύρου διαλό
όγου υπάρχειι το κουμπί Advanced. A
Το παράθυρο π
δια
αλόγου Servicce Reference Settings που εμφανίζεται επιτρέπει τη
η ρύθμιση των ττύπων που ορίζονται σαν κομμάτι της α
αναφοράς. Πρ
ροεπιλεγμέναα, υποτίθεται ότι οι το‐
πικοίί τύποι δεδομ
μένων αντισττοιχίζονται σεε αυτούς που δημοσιεύοντται από την υπηρεσία. υ
Αν δεν ισχύει κάττι τέτοιο, μποορούμε να προσδιορίσουμε
ε τις τιμές σττην περιοχή το
ου διαλό‐
Type. Στο ίδιο παράθυρο διαλόγου, υπά
άρχει το κουμπ
μπί Add Web R
Reference γου αυτού Data T
ποίο επιτρέπεει την προσθήήκη πιο παρα
αδοσιακών σε
ε .NET Web Seervices. Παρό
όλο που η το οπ
υποσ
στήριξη πλέονν ρίχνεται στοο Windows Co
ommunication
n Foundation η υποστήριξη
η στις πα‐
ραδο
οσιακές web sservices είνα ι βολική αν υπάρχουν περιορισμοί στηνν εφαρμογή μ
μας ή πρέ‐
πει ννα υπάρχει δια
αλειτουργικόττητα με παλιό
ότερα συστήμ
ματα. 3.3..2. Τα παρ
ράθυρα ε ργαλείων
Πριν ξεκινή
ήσει κανείς τηη δημιουργία μιας εφαρμογής, είναι σημμαντικό να εξξοικειωθεί με τα
α αποτελούμεενα μέρη του Visual Studio
o. Τα μενού κα
αι οι γραμμές εργαλείων είίναι τοπο‐
θετη
ημένες στο πά
άνω μέρος τουυ παραθύρου και ένα σύνο
ολο από μικρόότερα παράθυ
υρα ή χώ‐
ρουςς εμφανίζεταιι στα αριστερά
ά, δεξιά και κκάτω από την κύρια περιοχχή του παραθύρου. Στο κέντρ
ρο υπάρχει ο κύριος χώρο ς για τον επεξεργαστή κειμ
μένου: όποτε ανοίγουμε έννα αρχείο πηγα
αίου κώδικα, ένα έγγραφο XML, μια φόρ
ρμα ή οποιοδ
δήποτε άλλο ααρχείο, θα εμφανίζεται σε αυτόν το χώρο
ο για επεξεργα
ασία. Με κάθε νέο αρχείο που ανοίγει, δημιουργείτα
αι ένα νέο ύμε να επιλέγγουμε ποιο θα
α δούμε μεταξξύ των ανοιχττών αρχείων. tab γγια να μπορού
Σε κάθε πλλευρά του χώρρου για τον επ
πεξεργαστή κ
κειμένου υπάρρχει ένα σύνο
ολο παρα‐
θύρω
ων που αντισ
στοιχούν σε ερργαλεία. Αυτά τα παράθυρα παρέχουνν επιπρόσθετεες πληρο‐
φορίίες ανάλογα μ
με τη λειτουρργικότητα που
υ τους έχει πρ
ροσδοθεί. Η ππροεπιλεγμένη
η τοποθέ‐
τηση
η των παραθύρων περιλαμ βάνει τον Solution Explorer στα δεξιά, εενώ στα αρισττερά περι‐
λαμβ
βάνει το Toolb
box και τα Daata Sources. ΤΤα εργαλεία σ
στα αριστερά εμφανίζονταιι στην συ‐
ντετμ
μημένη (collapsed) μορφή τους γνωστή
ή και ως unpinned (ξε‐καρρφιτσωμένη). Αν επιλέ‐
ξουμ
με τον τίτλο ενός παραθύρρου, εμφανίζεεται σε εκτετα
αμένη (expannded) μορφή, αλλά συ‐
ντέμ
μνεται ξανά αν α μετακινήσοουμε τον κέρ
ρσορα κάπου αλλού. Ότανν ένα παράθυρο είναι στηνν εκτεταμένη μορφή του, εεμφανίζονται τρία εικονίδια όπως φαίννονται στην παρακάτω π
εικόννα: ογές ενός παρ
ραθύρου εργα
αλείων Εικόνα 3.7 ‐ Οι γενικές επιλο
στή και ως Αν θέλουμε το παράθυρρο να παραμεείνει στην εκττεταμένη μορρφή του γνωσ
pinned (καρφιτσω
ωμένη), πατά με το μεσαίο
ο κουμπί που μοιάζει με κκαρφίτσα. Η καρφίτσα ά 90 μοίρες γιια να δείξει ότι το παράθυρο είναι καρφ
φιτσωμένο. Το πάτημα περιστρέφει κατά
πιού, του Χ, κλλείνει το παρά
άθυρο. Αν αρ
ργότερα θελήσσουμε να ξανναεμφανί‐
του ττρίτου κουμπ
σουμ
με το παράθυρο αυτό μπορρούμε να το εεπιλέξουμε απ
πό το μενού VView. 40 Εικκόνα 3.8 ‐ Λίσττα με τους διιαφορετικούςς τρόπους τοπ
ποθέτησης ενόός παραθύρο
ου εργα‐
λείων λ
Αν επιλέξουμε το πρώτοο εικονίδιο (ττο κάτω βελάκ
κι), εμφανίζετται μια λίστα που ανα‐
παριιστά έναν δια
αφορετικό τρόόπο τοποθέτη
ησης του παρ
ραθύρου. Η εππιλογή Float επιτρέπει την ττοποθέτηση ττου παραθύροου οπουδήποτε στην οθόνη ανεξαρτήτω
ως του κυρίου
υ παραθύ‐
ρου. Κάτι τέτοιο εείναι χρήσιμοο όταν έχουμεε πολλαπλές ο
οθόνες, γιατί μπορούμε να
α μεταφέ‐
με τα εργαλείία στη δεύτερρη οθόνη καιι να αφήσουμ
με την πρώτηη μόνο για τα
α το κύριο ρουμ
παρά
άθυρο, μεγισττοποιώντας έέτσι το διαθέσ
σιμο χώρο. Η επιλογή Dockk as Tabbed D
Document τοπο
οθετεί το παράθυρο σε ένα
α επιπρόσθετο tab στον κεντρικό χώρο. Τέλος η επιλλογή Hide, όπωςς δηλώνει το όνομά της, απ
ποκρύπτει το παράθυρο. Αλλ
λάζοντας την τοποθεσία
α ενός παραθύρου
οθετεί μερικά παράθυρα ερργαλείων αριστερά και Προεπιλεγμένα το Visuaal Studio τοπο
μερικά δεξιά στηνν οθόνη. Είνα
αι δυνατό να α
αλλαχθεί αυττή η τοποθέτηηση. Για να αλλλαχθεί η οθέτηση πρέπ
πει να επεκτείίνουμε ένα παράθυρο, π
να
α επιλέξουμε την μπάρα τίίτλου του τοπο
παρα
αθύρου και να
α σύρουμε τοο παράθυρο σ
στη νέα θέση του. Για να μμας βοηθήσει,, το Visual Studio εμφανίζει 5 κουτιά, ένα
α για κάθε πιθ
θανή επιλογή για τη νέα τοοποθεσία του
υ παραθύ‐
ρου. θεσία ενός πα
αραθύρου Εικόννα 3.9 ‐ Πιθαννές επιλογές γγια την τοποθ
ποθετήσουμε ένα παράθυρ
ρο σε οποιαδ
δήποτε πλευρρά, απλώς σύ
ύρουμε το Για να τοπ
άθυρο και το αφήνουμε σττο αντίστοιχο κουτί. Κατά ττο σύρσιμο, ππαρατηρούμε ότι το με‐
παρά
σαίο
ο μεγάλο σταυ
υρωτό κουτί α
αλλάζει θέση ανάλογα με ττην τρέχουσαα θέση του πα
αραθύρου προςς μετακίνηση.. Το μεγάλο α
αυτό κουτί χρ
ρησιμεύει για την τοποθέττηση δύο ή περισσοτέ‐
ρων παραθύρων σ
στην ίδια περριοχή στο Visu
ual Studio: Επιιλέγουμε ένα παράθυρο προς μετα‐
ση, το σύρουμε προς την περιοχή που θέλουμε να το τοποθετή σουμε και επ
πιλέγουμε κίνησ
από το κεντρικό μ
μεγάλο κουτί ττη θέση του σ
στη νέα αυτή περιοχή. Αν εεπιλέξουμε το
ο κεντρικό μπί στο κουτί θα τοποθετηηθεί σε tabbed μορφή. Επιλέγοντας οποοιοδήποτε απ
πό τα υπό‐
κουμ
41 λοιπα κουτιά, τοπ
ποθετούμε τοο παράθυρο αριστερά, δεξιά, πάνω ή κάτω από το υπάρχον άθυρο σε εκείίνη την περιοχχή που επιλέξξαμε. παρά
Εικό
όνα 3.10 ‐ Πα
αράδειγμα τοπ
ποθέτησης εννός παραθύρο
ου εργαλείωνν στο δεξιό μέέρος του Visu
ual Studio 3.3..3. Ο επεξξεργαστής
ς κειμένου
υ
Όπως τα πεερισσότερα ID
DEs, το Visual Studio έχει στο επίκεντρό του ένα παρά
άθυρο για την επεξεργασία ε
κώδικα. Ο επ
πεξεργαστής αυτός έχει εξελιχτεί μέσαα στα χρόνια και είναι πολλλά περισσότερ
ρα από ένας α
απλός επεξερ
ργαστής κειμένου. Παρόλο που υπάρχου
υν διάφο‐
ροι d
designers για την πραγματτοποίηση εργα
ασιών όπως ττη δημιουργίαα φορμών, τη
ην αλλαγή των ρυθμίσεων τω
ων projects κα
αι την επεξερ
ργασία των διαφόρων πόρω
ων των εφαρμογών, οι ογραμματιστέ ς ξοδεύουν το
ον περισσότερ
ρο χρόνο τουςς στη γραφή κκώδικα με περισσότεροι προ
αυτό. Για το λλόγο αυτό αξίίζει να ρίξουμ
με μια ματιά σστο πώς να ρυ
υθμίζουμε τον εεπεξεργαστή α
την εεμφάνισή του για να δουλεεύουμε πιο απ
ποδοτικά με α
αυτόν. Όταν ανοίγγουμε ένα αρρχείο κώδικα για επεξεργα
ασία, δουλεύοουμε με το παράθυρο π
επεξεργασίας κώδ
δικα (code ed itor window). Το παράθυρο
ο αυτό φαίνετται ως εξής: Εικκόνα 3.11 ‐ Το
ο code editor w
window 42 wn που βοηθ
θούν στην Πάνω από το χώρο του κώδικα υπάρχουν δύο λίστες drop‐dow
περιήγηση σε μεγγάλα αρχεία κκώδικα. Η πρ
ρώτη drop‐dow
wn λίστα εμφ
φανίζει τις κλάσεις στο ον αρχείο κώ
ώδικα και η δ εύτερη drop‐‐down λίστα εμφανίζει ε
τα μέλη της επιλεγμένης τρέχο
κλάσ
σης από την π
πρώτη λίστα. ΕΕμφανίζονται σε αλφαβητική σειρά για ννα είναι πιο εεύκολο να βρού
ύμε μια μέθοδ
δο ή μέλος μέέσα στο αρχείο. Περ
ριοχές
ων συνήθως έχει σαν αποττέλεσμα τη δη
ημιουργία Η αποτελεσματική σχεδδίαση κλάσεω
κλάσ
σεων που υπη
ηρετούν έναν μόνο σκοπό και δεν είναι ιδιαίτερα πολ
ολύπλοκες ή μ
μακροσκε‐
λείς. Υπάρχουν όμ
μως περιπτώσσεις που ανα
αγκαστικά μια
α κλάση πρέπεει να είναι μεεγάλη και ά συνέπεια δύ
ύσχρηστη. Σε τέτοιες περιπ
πτώσεις είναι καλό να σπάάμε τον κώδικα σε πολ‐
κατά
λαπλλά αρχεία ή να ν χρησιμοποοιούμε περιοχχές κώδικα (rregions), κάνοοντας έτσι ευ
υκολότερη την π
περιήγηση στο
ον κώδικα. Η εισαγωγή των μερικώ
ών κλάσεων (p
partial classes)), όπου ο ορισσμός μιας κλά
άσης μπο‐
ρεί ννα διαιρεθεί σ
σε πολλαπλά α
αρχεία, σημαίνει ότι κατά ττη σχεδίαση μμιας κλάσης μ
μπορούμε να το
οποθετήσουμ
με κώδικα σε διαφορετικά αρχεία αναπ
παριστώντας έέτσι μια λογικκή κλάση. Το π
πλεονέκτημα χχρήσης διαφοορετικών αρχεείων είναι ότι μπορούμε ννα ομαδοποιή
ήσουμε ό‐
λες ττις μεθόδους που έχουν κά
άποια σχέση μ
μεταξύ τους, όπως για παρράδειγμα ότα
αν υλοποι‐
ούμεε μια διασύνδ
δεση (interfacce). Το πρόβλη
ημα που δημιιουργείται με αυτήν την πρ
ροσέγγιση όμωςς είναι ότι πρ
ρέπει να διαχεειριζόμαστε π
πολλά αρχεία και να εναλλλάσσουμε συννεχώς με‐
ταξύ τους. μασμένων πεεριοχών κώδικα για να Μια εναλλλακτική προσέέγγιση είναι η χρήση ονομ
συμπ
πυκνώνουμε ττμήματα κώδδικα που δεν μας ενδιαφέρ
ρουν ή δεν χρρησιμοποιούμ
με μια δε‐
δομέένη στιγμή. Ορίζουμε σαν π
περιοχή το τμ
μήμα του κώδικα που εσωκκλείεται μεταξύ των di‐
rectives #region <
<όνομα> και ##endregion κα
αι χρησιμοποιώντας τις ενδ
νδείξεις – και + συμπυ‐
κνώννουμε και επεεκτείνουμε τιςς περιοχές ανττίστοιχα. Εικ
κόνα 3.12 ‐ Εμ
μφάνιση και α
απόκρυψη πε
εριοχών στον κώδικα Outtlining
ματης σύμπτυξξης και εμφάνισης των Το Visual Studio έχει επίίσης τη δυναττότητα αυτόμ
τμημ
μάτων ενός αρ
ρχείου κώδικα
α, όπως μεθό
όδων, σχολίωνν και κλάσεωνν. Μπορούμεε να χειρι‐
στού
ύμε το outlinin
ng μέσα από ττο μενού Edit  Outlining, το οποίο παρρέχει ένα σύννολο εντο‐
λών για την απόκκρυψη/εμφάννιση των τμημ
μάτων κώδικα
α. Έτσι για πααράδειγμα, σττην παρα‐
ω εικόνα παρατηρούμε ότιι το Visual Stu
udio πέραν τω
ων περιοχών, δίνει αυτόμα
ατα τη δυ‐
πάνω
νατό
ότητα σύμπτυξξης του const ructor Class1((). Μορ
ρφοποίηση κώδικα
S
βοηθά
άει προεπιλεγμένα τον προ
ογραμματιστήή να δημιουργεί δομη‐
Το Visual Studio μένο
ο κώδικα, προ
οσθέτοντας α
αυτόματα εσο
οχές και κάνο
οντας αυτόμαατη στοίχιση. Όπως τα περισσότερα χαρακτηριστικά ττου Visual Studio, και η μορφοποίηση μ
ρ
μπορεί να ρυθμιστεί. ols  Options επιλέγουμε TText Editor  C#  Formattting. Από το μενού Too
Το χαρακτη
ηριστικό της π
προσθήκης εσοχών στη C#
# καλείται sm
mart indentingg. Μεταξύ ων προσθέτει αυτόματα εσσοχές κατά τη
ην προσθήκη μπλοκ κώδικαα μέσα σε έννα αρχείο. άλλω
Αν για οποιοδήπο
οτε λόγο δεν μορφοποιήσεει σωστά τον κώδικα, υπάάρχει και η δυ
υνατότητα ου κώδικα ή τμήματός του. επανναμορφοποίησης ολόκληροου του αρχείο
43 Επισ
σήμανση Αν
ναφορών
Ένα νέο χα
αρακτηριστικόό στο Visual Studio 2010 S
είναι ε
η επισήμμανση των ανναφορών. Όλεςς οι χρήσεις ττου τρέχοντοςς επιλεγμένου
υ προσδιοριστή (όπως π.χχ. μιας μεθόδο
ου ή μιας prop
perty) μέσα σε σ μια εμβέλεεια επισημαίννονται. Έτσι γίνεται γ
πιο εύύκολο να ενττοπίσουμε που αλλού χρησιμ
μοποιείται αυ τός ο προσδιο
οριστής μέσα στον κώδικα . Εικόνα 3.113 ‐ Επισήμαννση αναφορώ
ών στον κώδικκα Cod
de Zooming
g
Χρησιμοπο
οιώντας το συυνδυασμό Ctrl + Mouse Wheel, μπορούύμε να μεγαλώ
ώσουμε ή να μ
μικρύνουμε το
ο μέγεθος τουυ κώδικα. Αυττό μπορεί να φ
φανεί χρήσιμοο όταν παρου
υσιάζουμε τον κώδικα σε τρ
ρίτους. Το zooom μπορεί να
α οριστεί και από τη λίσταα της γωνίας κκάτω αρι‐
ρά στον επεξεργαστή. στερ
Worrd Wrap
ο word wrap εννοούμε τηνν αυτόματη διαχείριση γρααμμών έτσι ώ
ώστε ο κώ‐
Με τον όρο
δικας να χωράει σ
στο προκαθορρισμένο πλαίσ
σιο του επεξεργαστή κειμέένου. Πηγαίνο
οντας από μ
Tools   Options, επ
πιλέγουμε Te
ext Editor  C#  Forma tting  Wrapping και το μενού μπορ
ρούμε να αλλάξουμε τις επ
πιλογές για το wrapping. Αρίθ
θμηση Γραμ
μμών
Ένα πολύ χχρήσιμο εργαλ
αλείο που δεν είναι ενεργοποιημένο απόό την αρχή, είναι η εμ‐
φάνιιση του αριθμ
μού των γραμ μών σε κάθε αρχείων κώδικα. Για να εμμφανιστούν οι γραμμές αριθ
θμημένες από
ό το μενού Toools  Options, επιλέγουμ
με αρχικά στοο παράθυρο επιλογών που εμφανίζεται SShow all setti ngs κάτω αριιστερά. Στη συ
υνέχεια, κάτω
ω από την επιλλογή Text or  All Langguages  Genneral επιλέγουμε Line num
mbers κάτω ααπό την ομάδα
α Display. Edito
Τώρα
α τα αρχεία κώ
ώδικα θα εμφ
φανίζονται αρ
ριθμημένα. Εικόνα 3.14 ‐ Αρίθμη
ηση γραμμών
ν στον editor Fonts και χρώμα
ατα
Ένα από τα
α πρώτα πράγγματα που ίσω
ως χρειαστεί να αλλάξει καανείς στο Visu
ual Studio είναιι τα fonts και τα χρώματα ττου κύριου επ
πεξεργαστή κε
ειμένου. Η εππιλογή του κατάλληλου font και των χρωμ
μάτων που είίναι ευκολοδιιάβαστα για ττον καθένα μππορεί να τον κάνει πιο αγωγικό και ννα γράφει κώδδικα για περιισσότερο χρόννο χωρίς να κκουράζεται. Μ
Μπορούμε παρα
να α
αλλάξουμε τα fonts και τα χχρώματα από
ό το μενού To
ools  Optionns και από την επιλογή Envirronment επιλέγουμε Fontss and Colors όπως φαίνεταιι στην παρακάάτω εικόνα: 44 όνα 3.15 ‐ Επιλλογές για γρα
αμματοσειρέςς και τα χρώμματά τους Εικό
Από το ίδιο
ο παράθυρο μπορούμε να
α αλλάξουμε τις επιλογές γγια οποιοδήπ
ποτε άλλο παρά
άθυρο κειμένου του Visua l Studio επιλέέγοντας το απ
πό τη λίστα S how settings for. Κατά την εεπιλογή ενός font πρέπει ννα θυμόμαστεε ότι περισσόττερο αποτελεεσματικά είνα
αι τα fonts σταθ
θερού μήκουςς και για το λόόγο αυτό εμφ
φανίζονται με έμφαση στη λίστα των δια
αθέσιμων fontss. Full--Screen Mod
de
Αν έχουμε ενεργά πολλλαπλά παράθυρα εργαλείω
ων, τότε μπορρεί να ξεμείνο
ουμε από χώρο
ο για τον επεξεργαστή κειιμένου. Για το
ο λόγο αυτό το τ Visual Studdio έχει διαθέέσιμη μια full‐sscreen mode που μπορούμ
με να χρησιμ
μοποιήσουμε από το μενούύ View  Fu
ull Screen. Εναλλλακτικά μπορ
ρούμε να επιλ
ιλέξουμε Shiftt+Alt+Enter γιια να εισέλθοουμε και να εεξέλθουμε από αυτό το mod
de. Όπως παρρατηρούμε, δεεν εμφανίζονται οι γραμμέές εργαλείωνν ή τα πα‐
υρα των εργα
αλείων, ενώ ττο παράθυρο
ο είναι πλήρω
ως μεγιστοποοιημένο. Το full‐screen ράθυ
mode μπορεί να φ
φανεί ιδιαίτερρα χρήσιμο, α
αν χρησιμοποιιούμε πολλαππλές οθόνες. Εικόνα 3.16 ‐‐ Full Screen m
mode ρακολούθησ
ση Αλλαγών
ν
Παρ
Το Visual Studio S
έχει τηην επιλογή τη
ης παρακολούθησης των αλλαγών στο
ον κώδικα ανά γραμμή για να υποδείχνει ποιες γραμμέές κώδικα έχο
ουν αλλάξει καατά τη γραφή
ή ενός αρ‐
υ. Όταν ανοίγγει ένα αρχείοο για επεξεργα
ασία, δεν θα υπάρχουν χρ ωματισμένες γραμμές. χείου
Ωστό
όσο, όταν ξεκινάμε το γρά ψιμο θα παρατηρήσουμε ότι εμφανίζετται μια κίτριννη ένδειξη δίπλα από κάθε γγραμμή που έέχει αλλάξει. Ό
Όταν το αρχείο αποθηκεύεεται, οι γραμμ
μές αλλά‐
45 ζουνν χρώμα: από κίτρινο γίνετα
αι πράσινο δεείχνοντας με αυτόν τον τρόόπο ότι έχουνν γίνει αλ‐
λαγέές από το άνο
οιγμα του αρχχείου και ότι αυτές οι αλλα
αγές έχουν απποθηκευτεί. Η
Η επιλογή της παρακολούθη
π
ησης των αλλλαγών μπορείί να αλλάξει από το μενο ύ Tools  Options O
 Text Editor  Ge
eneral και απ ό την ομάδα Settings ενερ
ργοποιούμε ήή απενεργοπο
οιούμε το Changes”. checck box “Track C
7 ‐ Πως εμφα
ανίζονται οι α
αλλαγές με τη
ην παρακολούύθηση αλλαγών Εικόνα 3.17
ενεργοποιημένη Splitt View
ορετικά κομμάάτια του ίδιου
υ αρχείου Μερικές φορές είναι χρ ήσιμο να βλέέπουμε διαφο
ταυττόχρονα. Αυτό
ό μπορεί να γίίνει με τη Split View, η οπο
οία επιτρέπειι τη διαίρεση του ενερ‐
γού π
παραθύρου ττου επεξεργασστή κειμένου σε δυο οριζό
όντιους χώρουυς που χωρίζο
ονται από μια μ
μπάρα. Αυτοί οι χώροι μποορούν να γίνο
ουν scrolled ξε
εχωριστά και να εμφανίζου
υν διαφο‐
ρετικκά κομμάτια ττου ίδιου αρχεείου ταυτόχρονα. Η διαίρεση
η του κύριου π
παραθύρου μ
μπορεί να γίνε
ει από το μεννού Window 
 Split. Η μπάρ
ρα διαχωρισμ
μού μπορεί να
α ρυθμιστεί, σ
σύροντας την π
πάνω ή κάτω.. Εικόνα 3.18 ‐ Split View
w Άλλ
λες λειτουργίες
Για να είνα
αι κανείς έναςς αληθινά παρ
ραγωγικός προ
ογραμματιστήής είναι χρήσιμο να ξέ‐
ρει κάποιες κ
προχωρημένες λε ιτουργίες του
υ επεξεργαστή κειμένου ππου είναι δεν είναι ευ‐
διάκριτες αλλά μπ
πορούν να εξοοικονομήσουνν πολύ χρόνο κατά την ανάάπτυξη.  Σχχολιασμός / α
από‐σχολιασμ
μός ενός μπλο
οκ κώδικα: Συυχνά χρειάζετται να το‐
πο
οθετήσουμε σσε σχόλια, κώ
ώδικα που εκττείνεται σε πο
πολλές γραμμέές. Για να απ
ποφύγουμε τηην τοποθέτησ
ση σχολίων γρ
ραμμής χειρο κίνητα και τη
ην αποφυ‐
γή
ή της πιθανόττητας εισαγω
ωγής πολλαπλ
λών σχολίων πολλαπλών γραμμών, γ
χρ
ρησιμοποιούμ
με τον αυτόμα
ατο σχολιασμ
μό του Visual Studio. Από το μενού Ed
dit επιλέγουμ
με Advanced 
 Comment Selection για α το σχολιασμ
μό και Ad‐
va
anced  Uncoomment για ννα αφαιρέσουμε τα σχόλια.. 46 




Επιλογή μπλοκ: γνωστή και ως επιλογή ορθογωνίου, είναι η δυνατότητα επι‐
λογής κειμένου σε μπλοκ αντί της κανονικής επιλογής γραμμών. Για να επι‐
λέξουμε μπλοκ κειμένου, απλώς πιέζουμε το πλήκτρο alt ενώ επιλέγουμε το κείμενο με το ποντίκι. Εναλλακτικά με το πληκτρολόγιο πατάμε Shift+Alt+Βέλος Επεξεργασία πολλαπλών γραμμών: ένα νέο χαρακτηριστικό στο Visual Studio 2010 είναι η δυνατότητα μετά την επιλογή ενός μπλοκ με τον παραπάνω τρόπο να επιτρέπεται η εισαγωγή νέου κειμένου που θα αντικαταστήσει το επιλεγμένο. Αυτό μπορεί να φανεί χρήσιμο όταν θέλουμε να αλλάξουμε για παράδειγμα τους προσδιοριστές πρόσβασης μιας ομάδας μεταβλητών. Διαχείριση clipboard: το Visual Studio διατηρεί τα τελευταία 20 snippets κει‐
μένου που έχουν τοποθετηθεί στο clipboard (με copy ή paste). Κρατώντας πατημένα Ctrl+Shift και πατώντας V διαδοχικά εμφανίζονται τα snippets, ένα κάθε φορά. Go to Definition : για να πάμε γρήγορα στον ορισμό μιας κλάσης, μεθόδου ή μέλους κλάσης που υποδεικνύεται από τον κέρσορα πατάμε δεξί κλικ και go to definition, ή απλώς πατάμε F12. Find all References: Μπορούμε να βρούμε από πού καλείται μια μέθοδος ή property με το να πατήσουμε δεξί κλικ στον ορισμό της και από το μενού ε‐
πιλέγοντας Find All References ή πατώντας Shift+F12. Αυτό ενεργοποιεί το εργαλείο Find Symbol Results και εμφανίζει τις τοποθεσίες όπου υπάρχουν αναφορές της μεθόδου ή property. Μπορούμε να επιλέξουμε κάποια από αυτές τις τοποθεσίες και να εμφανίσουμε κατευθείαν τη γραμμή όπου εμ‐
φανίζεται η αναφορά. 47 

DINNER - Flame Restaurant | Costa Navarino

IB Diploma Programme Course Descriptions 2013-14

43 - Άποψη

Προϋποθέσεις απαλλαγής αγροτών από την τήρηση βιβλίων

ΓΑΛΑΚΤΩΜΑΤΑ ΚΑΙ ΚΡΕΜΕΣ

επιδραση μη-νευτωνικων υγρων στη συγκρατηση της αεριας φασης

απαντηση σε επιστολες ο.σ.μ.α.ε.ς.

Ανεπίσημες απαντήσεις σε ερωτήσεις για το Ενιαίο

Τεκμηρίωση ερευνητικών εργασιών, διπλωματικών και

URNEX Cafiza

ΡΥΘΜΙΣΗ ΟΦΕΙΛΩΝ

Επιστημολογικές τάσεις της Εκπαιδευτικής Έρευνας Δράσης στην

Σύγχρονη Φυσική Ι, Μέρος Δεύτερο Περιεχόμενα K0. Εισαγωγή K1

ADR Ανανέωση

6. Γλώσσες Προγραμματισμού

Κατά - Νέα Υγεία

ΚΕΦΑΛΑΙΟ 1 Ο Υπολογιστής

κυπριακη δημοκρατια σχεδιο χορηγιων για ενθαρρυνση της χρησης

Ερευνητική εργασία-Project

Ιδιωτικού Τομέα ως αναπτυξιακό εργαλείο της πρωτοβάθμιας

5. Διαγνωστικές δυνατότητες εξετάσεων

collezioni piccolo 2012:Layout 1