Από χθες είμαι κι εγώ PC :)

Η καμπάνια I'm a PC είναι η απάντηση της Microsoft στις διαφημήσεις της Apple οι οποίες παρουσιάζουν κάποιον nerd τύπο ως PC και έναν cool looking τύπο ως Mac να έχουν αστείους διαλόγους που δείχνουν το υποτιθέμενο Mac goodness.

Στο I'm a PC μπορεί όποιος θέλει να στείλει μια φωτογραφία του ή ένα video και να μπει στο community των PC users. Όλοι οι χρήστες εμφανίζονται περιοδικά στα billboards της πλατείας Times και σε διάφορα διαφημιστικά banners σε sites όπως του MTV.

I'm live to the world λοιπόν!

Τις προάλλες με ρώτησε ένας μαθητής μου γιατί όταν γράφουμε ένα property, πχ

Public Property MyProperty As Integer

μόλις πατήσουμε το enter παράγται το

    Public Property MyProperty() As Integer
        Get

        End Get
        Set(ByVal value As Integer)

        End Set
    End Property

Που είναι το περίεργο; Οι παρενθέσεις μετά το MyProperty. Τι χρειάζονται;

Λοιπόν, μέσα σε αυτές τις παρενθέσεις μπορούμε να δηλώσουμε μια παράμετρο. Πχ

    Public Property MyProperty(ByVal Param As Integer) As Integer
        Get

        End Get
        Set(ByVal value As Integer)

        End Set
    End Property

Αυτή τη παράμετρο μπορούμε να τη χρησιμοποιήσουμε κανονικά μέσα στον κώδικα του Get/Set, πχ:

MyClass.MyProperty(5) = 3

όπου μέσα στο Set θα έχουμε value=3, Param=5. Ωραίο ε?!

Το θέμα είναι ότι όσο ωραίο κι αν είναι,δεν θα πρέπει να το χρησιμοποιείτε. Είναι ένα feature της VB.NET το οποίο δεν έχει όμως η C# (πράγμα που σημαίνει ότι για να χρησιμοποιήθει η κλάση μέσα από C# θα πρέπει να καταφύγει ο developer στο reflection - λέγεμε και work re-assurance) και ο λόγος που υπάρχει είναι για να διευκολύνεται ο προγραμματισμός με COM. 

Happy coding!

Σήμερα ανακοινώθηκε από τη Microsoft ότι οι χρήστες Windows Vista SP1 θα έχουν δωρεάν απεριόριστη βοήθεια μέσω e-mail και τηλεφώνου μέχρις τις 18 Μαρτίου 2009

Το μόνο που έχετε να κάνετε, είναι να επισκευθείτε τη διεύθυνση http://support.microsoft.com/oas/default.aspx?LN=el&prid=11274&gprid=500921&x=6&y=10

Σήμερα έπεσε στην αντίληψή μου το site που έχει στήσει η Renault για το νέο Ranault Laguna Coupe. Βασίζεται στο Silverlight και μπορείτε να δείτε το DeepZoom εν δράσει (στην επιλογή "Full Imersion") καθώς και τη χρήση video. Πολύ όμορφο... Μαζί με το Hard Rock Memorabilia και το Patient Journey Demonstrator, αποτελούν αντιπροσωπευτικά δείγματα της τεχνολογίας. Άντε να δούμε και το site των Ολυμπιακών αγώνων του Πεκίνου, με όλα τα απίθανα κόλπα περί video που έχουν ανακοινωθεί!

Κοιτάζοντας λοιπόν το site, πήγα στο Full Imersion και επέλεξα από κάτω το "Tag". Περίμενα ότι θα έβλεπα τα κλασικά tag clouds ωστόσο με αιφνιδίασε ευχάριστα το visualization που τοποθετεί τα tags σε τρισδιάστατο χώρο και αλληλεπιδρούν με το ποντίκι. Το tag cloud μοίαζει με πραγματικό cloud! Ουσιαστικά αυτό είναι όλο το θέμα: Ναι, μπορείς να κάνεις τη δουλειά σου με τις γκρι φόρμες και τα κλασικά grids, comboboxes και listboxes ωστόσο όταν υπάρχει intuitive visualization τότε ο χρήστης "αισθάνεται" καλύτερα την εφαρμογή με όλα τα συνεπακόλουθα. Όπως σίγουρα "μπορείς να κάνεις τη δουλειά σου" και με μία DOS εμπορολογιστική εφαρμογή. Στα δύο Post-Launch Events που παρουσίασα το WPF δέχθηκα και τις δύο φορές την ερώτηση "γιατί να πάω στο WPF;". Το θέμα του visualization είναι μια από τις πιο σημαντικές αιτίες. Αυτό σημαίνει όμως ότι αν τελικά αποφασίσει κάποιος να πάει στο WPF θα πρέπει να έχει το WPF mentality και να είναι πρόθυμος να φτιάξει το ανάλογο UI. Ερχόμαστε δηλαδή στην αρχή μιας νέας εποχής, όπως τότε που περάσαμε από τις DOS εφαρμογές στις Windows εφαρμογές. Μπορεί όχι τόσο ως προς το τεχνικό κομμάτι αλλά ως προς το UI κομμάτι.

Με τη σημερινή Post-launch ημερίδα ολοκληρώθηκε η σειρά από events σχετικά με το WPF, οπότε είπα και να μαζέψω σε ένα post όλο το σχετικό υλικό.

Αρχικά έχουμε το WPFPresenter, το power-point-like application μέσω του οποίου έδειξα τα βασικά περί WPF. Όπως σας ανέφερα, βασίζεται στο πρωτότυπο της Beatriz Costa, guru του WPF Data Binding. Μέσα από το blog της μπορείτε τα μάθετε τα πάντα περί Data Binding.

Επίσης, είπαμε για το white-paper που περιγράφει το "New Iteration" concept, τη συνεργασία μεταξύ developer και designer καθώς και τον ρόλο του integrator. Θα το βρείτε εδώ.

Το logon demo που έδειξα, προέρχεται από το Visual Studio 2008 and .NET Framework 3.5 Training Kit Μέσα στο kit θα βρείτε σπουδαίο υλικό για όλες τις τεχνολογίες του .ΝΕΤ Framework 3.5 όπως hands on labs, demos και παρουσιάσεις.

Κάτι άλλο που συζητήσαμε, ήταν αυτό το απίθανο παράδειγμα ιατρικής εφαρμογής που δείχνει πώς το WPF (υπό τη μορφή του Silverlight) μπορεί να χρησιμοποιηθεί για να υλοποιηθούν εφαρμογές που μέχρι σήμερα θα ήταν αδύνατον ή θα απαιτούσαν πολύ κώδικα για πράγματα που στο WPF είναι εκ των ων ουκ άνευ. Α! Μην ξεχάσετε να δείτε και αυτό το υποδειγματικό UI design από μια εφαρμογή που ακούει στο όνομα "Lawson Smart Client". Την είδατε; Ωραία, βάλτε αγγελία τώρα για designer.

Τώρα, στο 18ο dotNETZone.gr Community Event (WPF: Developing business applications) έδειξα ένα demo το οποίο μπορείτε να βρείτε εδώ. Στην κουβέντα περί unit testing στο WPF ανέφερα το WPF Application Quality Guide, έναν οδηγό που περιέχει ανεκτίμητο υλικό σχετικά με testing των WPF εφαρμογών. Ενδεικτικά στα περιεχόμενα βρίσκουμε: Τest methodologies,visual verification testing, media testing, performance best practices καθώς και μια λίστα από utilities που αφορούν στο debugging και στο testing των WPF εφαρμογών.

Τέλος, δεν μπορώ να μην αναφέρω ότι τεράστια βοήθεια βρήκα (και βρίσκω συνεχώς) στο blog του Josh Smith αλλά και στα άρθρα του στο CodeProject.com. Ειδικά στο άρθρο περί MVC, βασίζεται το τελευταίο demo που έδειξα στο event. Ο Josh Smith είναι ένας από τους δημιουργούς του Mole, ενός visualizer για το Visual Studio που κάνει το debugging απείρως ευκολότερο. Απλά, δε νοείται debugging στο WPF χωρίς το Mole.

Ελπίζω να μην ξέχασα τίποτα από αυτά που είχα υποσχεθεί να σας δώσω. Αν υπάρχει κάτι, μου αφήνετε μήνυμα.

Για όλα αυτά τα legacy applications που έχουν ξεμείνει στην Visual Basic 6, υπάρχουν κάποια νέα βοηθήματα για την περίπτωση που θα αποφασιστεί το migration σε .NET.

O Francesco Balena, guru της VB6 που τα βιβλία του διαβάσαμε και αγαπήσαμε, τα τελευταία χρόνια έχει κάνει σπουδαία δουλειά στο θέμα του migration. Πρόσφατα, κυκλοφόρησε το VB Migration Partner, ένα προϊόν που χειρίζεται άνετα και με εντυπωσιακά ποσοστά επιτυχίας όλα εκείνα τα τμήματα κώδικα που κάνουν Visual Basic Upgrade Wizard να σηκώνει τα χέρια ψηλά.

Παράλληλα, μόλις χθες, έδωσε προς δωρεάν χρήση ένα utility που ονομάζεται VB6 Bulk Analyzer. Πρόκειται για ένα command-line utility το οποίο αναλύει τα VB6 projects που βρίσκονται σε κάποιο directory tree και δημιουργεί ένα report το οποίο δίνει μια σαφή εικόνα για το τι έχει να αντιμετωπίσει ο άμοιρος, εεε ο developer κατά το έργο του migration.

Η αλήθεια είναι ότι οι εφαρμογές που έχουν γραφτεί VΒ6 έχουν αρκετά χμμμ... "μη τυποποιημένα" τμήματα κώδικα, κολπάκια, κλπ έτσι ώστε να υπερκεραστούν οι εγγενείς περιορισμοί της γλώσσας. Ακριβώς αυτά τα τμήματα κώδικα είναι που αποτελούν προκλήσεις για τα εργαλεία μετατροπής κώδικα. Σε όσους λοιπόν το σκέφτονται, τώρα πλεόν είναι πολύ εύκολο να περάσουν τις VB6 εφαρμογές τους σε .NET. Άντε, και καλή τύχη!

Χθες παρατήρησα ότι αυτόν τον καιρό υπάρχουν αρκετά events για το WPF. Αν κάποιος τα παρακολουθήσει θα μπορεί να πάρει μια πάρα πολύ καλή ιδέα για το αντικείμενο και θα μπει σε καλό δρόμο για να το ψάξει παραπάνω με τη βοήθεια ενός βιβλίου ή με on-line resources. Έχουμε και λέμε:

29 Μαΐου: Microsoft Hellas Event: 2008 Post Launch Event

Στο τρίτο session, θα παρουσιάσω τα εισαγωγικά περί WPF και θα δείξω τη συνεργασία Developer – Designer μέσω του Expression Blend. Το event αυτό γέμισε λίγες ώρες μετά την ανακοίνωσή του! Όποιος δεν πρόλαβε, ας έχει το νού του γιατί θα βγει ανακοίνωση για επαναληπτικό στις 5 Ιουνίου.

31 Μαΐου: 9o StudentGuru event: Hands-on WPF

Πρόκειται για ένα τρίωρο hands-on lab που θα τρέξουν τα παιδιά του StudentGuru. 3D ακούω, Blend ακούω, data binding ακούω... Προβλέπεται ενδιαφέρον!

3 Ιουνίου: 18ο dotNETZone.gr Community Event - WPF: Developing business applications

Σε αυτό το event θα παρουσιάσω τα χαρακτηριστικά του WPF που σχετίζονται με τη δημιουργία business εφαρμογών, καθώς αλλάζουν αρκετά πράγματα σε σχέση με τον τυπικό τρόπο που γράφουμε desktop ή web εφαρμογές.

Την Παρασκευή που μας πέρασε έπαθα ένα πολύ χαζό ατύχημα... Με το ψιλόβροχο που είχε, γλύστρισα στις κίτρινες πλάκες που βοηθούν τους τυφλούς και έσπασα το χέρι μου στο ύψος του όμου. Άσχημο σπάσιμο, δεν παίρνει γύψο, έκανα εγχείριση και μόλις σήμερα επέστρεψα σπίτι με ειδικό νάρθηκα. Για 2 μήνες θα είμαι πλέον εκτός μάχης, μονόχερος και αργός, ας είναι καλά τα sticky keys που επιτρέπουν να πληκτρολογώ λίγο-λίγο.

Με τσάντισε πάρα πολύ όλο αυτό το πράγμα. Έχασα το launch, θα χάσω και το MVP Summit, ακυρώθηκαν όλα τα επαγγελματικά σχέδια και είχα τρομερά άσχημη διάθεση, μέχρι που μπήκα στο νοσοκομείο τη Δευτέρα και είδα ότι θα μπορούσα να ήμουν πολύ χειρότερα. Υπάρχουν άλλοι που βρίσκονται σε πολύ περισσότερο πόνο.

Υπομονή... Το μόνο καλό είναι ότι θα έχω ποοοοολύ χρόνο στα χέρια μου στο χέρι μου για να παρακολουθήσω web casts και να διαβάσω.

Αυτόν τον μήνα δεν έχω τεχνικά posts, έχω πέσει με τα μούτρα στο διάβασμα. Είναι και η προετοιμασία για το launch, είναι και το σεμινάριο "Introduction to Linq", όλα αυτά δεν αφήνουν πολύ χρόνο για blogging. Ωστόσο, δεν μπόρεσα να αντισταθώ στο παρακάτω:

Ας υποθέσουμε ότι είναι μια εταιρεία που μέσω του s/w update service της "σπρώχνει" τη νέα έκδοση του browser της, χαρακτηρίζοντας το update ως "important". Μάλιστα, στο σχετικό pop-up παράθυρο, η default ενέργεια είναι το να εγκατασταθεί το update. Πως σας φαίνεται αυτό; Όχι και τόσο καλή πρακτική ε;

Αν τώρα σας πω ότι αυτή η εταιρεία είναι η Apple και το update service τρέχει μέσω του iTune ή του QuickTime τώρα πώς σας φαίνεται; Ακόμα χειρότερη πρακτική ε;

Αν σας πω επίσης ότι το EULA του νέου Safari - που όχι και τόσο κομψά μπήκε στον υπολογιστή του ανυποψίαστου χρήστη αφού το QuickTime τον έπεισε ότι είναι αναγκαίο update - αναφέρει ότι "This License allows you to install and use one copy of the Apple Software on a single Apple-labeled computer at a time", αυτό πως σας φαίνεται πάλι;

Τέλος, αν σας πώ ότι δεν είσαστε και τόσο παράνομοι αφού στο site της Apple επιτρέπεται τελικά η εγκατάσταση του Safari σε non-Apple-labeled computers, ε, αυτό δεν ρωτάω πώς σας φαίνεται! Είναι απλά γελοίο!

Από την άλλη μεριά όμως έχω να προτείνω την εξής επιχειρηματική ιδέα (ας είναι καλά ο Steve): Αν έχετε κάποια εφαρμογή που τρέχουν οι πελάτες σας, να  βάλετε ένα update service και να σπρώξετε και τις υπόλοιπες εφαρμογές σας. Με ένα καλό EULA, μπορείτε να τους πάρετε στο κυνήγι κατόπιν

Αν το είχε κάνει αυτό η Microsoft...

Στον κόσμο του .NET framework υπάρχουν πολλές φορές περιπτώσεις όπου είναι απαραίτητο ο managed κώδικας να μιλήσει με unamanaged κώδικα. Τυπικές τέτοιες περιπτώσεις είναι για παράδειγμα όταν υποχρεωνόμαστε να χρησιμοποιήσουμε legacy unmanaged κώδικα ή δεν καλυπτόμαστε από το .ΝΕΤ Framework API και πρέπει να χρησιμοποιήσουμε το COM ή το Win32 API. Όταν λοιπόν συμβαίνει κάτι τέτοιο, το CLR χρησιμοποιεί έναν μηχανισμό που ονομάζεται interop που αναλαμβάνει να γεφυρώσει τους δύο κόσμους κάνοντας αυτό που λέμε "marshaling" στα δεδομένα που ανταλλάσσονται. Η δουλειά αυτή είναι εύκολη όσο τα δεδομένα που περνούν πάνω από αυτή τη γέφυρα έχουν τη μορφή απλών structures. Οτιδήποτε άλλο, αρχίζει να δυσκολεύει το πράγμα με αποτέλεσμα να εμφανίζονται περίεργα exceptions και απρόβλεπτες συμπεριφορές.

Όσοι έχουν ασχοληθεί με το sport θα έχουν σίγουρα χρησιμοποιήσει το www.pinvoke.net, το wiki που τρέχει από την Red-Gate με σκοπό να υποστηρίξει το δωρεάν plug-in της. Εδώ και μερικές ημέρες υπάρχει το utility που ονομάζεται "PInvoke Interop Assistant" που έρχεται να βοηθήσει σε αυτόν τον τομέα. Το utility αποτελεί προϊόν συνεργασίας της ομάδας της VB.NET με αυτή του CLR και από μια πρώτη ματιά που του έριξα φαίνεται εξαιρετικό γι αυτή τη δουλειά!

Περισσότερα εδώ: http://blogs.msdn.com/vbteam/archive/2008/03/14/making-pinvoke-easy.aspx σε αυτό το link θα βρείτε και το σχετικό άρθρο στο MSDN που αναφέρει όλες τις φρικιαστικές λεπτομέρειες σχετικά με το marshaling.

Σήμερα, κατά το επίσημο launch των Windows Server 2008, SQL Server 2008 και Visual Studio 2008 ανακοινώθηκε από τo SQL Server Performance team ότι κατάφεραν σε συνεργασία με τη Unisys να τρέξουν διαδικασία ETL που μετέφερε 1TB δεδομένων σε λιγότερο από 30 λεπτά! Κάποιες πρόχειρες πληροφορίες βρίσκονται εδώ και είμαστε σε αναμονή για white paper. Επιπρόσθετα, εδώ μπορείτε να βρείτε κάποιες απίθανες πληροφορίες σχετικά με το γενικότερο performance του SQL Server 2008. To συμπέρασμα που προκύπτει από όλα αυτά είναι ότι ο νέος SQL Server δεν είναι απλά ο 2005 με κάποια νέα χαρακτηριστικά αλλά ένα προϊόν που έχει αλλάξει και εσωτερικά, αφού υπάρχει υπολογίσιμη διαφορά στις επιδόσεις σε σχέση με την προηγούμενη έκδοση. Προς το παρόν έγινε διαθέσιμη η CTP Φεβρουαρίου με την οποία μπορείτε να παίξετε και να ανακαλύψετε όλα τα νέα χαρακτηριστικά.

Μήπως ψάχνετε για ένα event όπου θα ακούσετε για όλες τις εξελίξεις στις γλώσσες προγραμματισμού, το managed execution περιβάλλον, τους compilers και τα περιβάλλοντα ανάπτυξης της Microsoft; Στο Lang.NET συζητήθηκαν όλα αυτά! Πραγματοποιήθηκε στα τέλη Ιανουαρίου, στο Redmond με κορυφαίους ομιλητές και πλέον είναι διαθέσιμα τα videos στο http://langnetsymposium.com.

Enjoy!

Hint: Τα videos είναι σε Silverlight, ωστόσο μπορείτε να κατεβάσετε και για off-line χρήση με μια μικρή αλλαγή στο url. Για παράδειγμα:

Silrverlight: http://langnetsymposium.com/talks/2-00%20-%20Democratizing%20the%20Cloud%20with%20Volta%20-%20Erik%20Meijer.html

WMV download: http://langnetsymposium.com/talks/videos/2-00%20-%20Democratizing%20the%20Cloud%20with%20Volta%20-%20Erik%20Meijer.wmv

Credits: Download hint από τον Bill McCarthy, heads up από τον Paul Vick

Το Windows Presentation Foundation ως markup μηχανισμός μας δίνει νέες δυνατότητες στη δημιουργία rich client εφαρμογών με στοιχεία που μέχρι σήμερα είχαμε διαθέσιμα μόνο στις ASP.NET εφαρμογές. Ένα κλασικό θέμα είναι η δημιουργία του UI on-the-fly, κατά το runtime, βάσει meta-data που μπορεί να έρχονται από οποιαδήποτε πηγή. Ήδη μου έλεγε ο Παναγιώτης Καναβός τις προάλλες για το ASP.NET Dynamic Data Support που επιτρέπει τη δημιουργία data-driven web εφαρμογών μέσω templates χωρίς να χρειάζεται να γίνει βάλει χέρι ο προγραμματιστής. Κατόπιν, σκέφτηκα κάλλιστα αυτά τα templates θα μπορούσαν να είναι σε XAML οπότε τελικά να καταλήγει κανείς σε WPF αντί ASP.NET εφαρμογή. Μάλιστα, παίζοντας τις προάλλες με το Linq To XML και τα XML Literals της VB, είπα να σκαρώσω κάτι ανάλογο. Έχουμε και λέμε λοιπόν:

Ξεκινάμε με ένα XAML window που έχει ένα button και ένα frame:

<Window x:Class="Window1"
    xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
    xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
    Title="Window1" Height="300" Width="300">
    <Grid>
        <Button Height="23" Name="Button1" HorizontalAlignment="Left" 
         Margin="10,10,0,0"  VerticalAlignment="Top" Width="75">
         Button</Button>
        <Frame Margin="10,50,12,12" Name="Frame1" />
    </Grid>
</Window>

Κατόπιν, ορίζουμε μία κλάση που θα περιέχει τα meta-data

    Public Class Field
        Private _Name As String
        Public Property Name() As String
            Get
                Return _Name
            End Get
            Set(ByVal value As String)
                _Name = value
            End Set
        End Property


        Private _Description As String
        Public Property Description() As String
            Get
                Return _Description
            End Get
            Set(ByVal value As String)
                _Description = value
            End Set
        End Property
    End Class

Στη συνέχεια, στο click event του button κάνουμε τα εξής: Γεμίζουμε ένα List(Of T) με τα data. Στη συγκεκριμένη περίπτωση με χαζό τρόπο αφού τώρα δεν είναι αυτό το ζητούμενο:

Dim Fields As New List(Of Field)(New Field() _
       { _
          New Field With {.Name = "LastName", _
                          .Description = "Last Name"}, _
          New Field With {.Name = "FirstName", _
                          .Description = "First Name"}, _
          New Field With {.Name = "Salary", _
                          .Description = "Salary"} _
       })

Και τώρα έρχεται το μαγικό! Στο click event του Button1 αρχικά θα φτιάξουμε το template μας:

Dim GeneratedXAML As XElement = _
 <StackPanel Margin="0,46,0,0" Name="StackPanel2">
     <%= From Field In Fields Select _
         <DockPanel>
             <Label Width="100"><%= Field.Description %></Label>
             <TextBox Name=<%= Field.Name & "TextBox" %>></TextBox>
         </DockPanel> %>
 </StackPanel>

Ουσιαστικά, θα τρέξει το Linq to XML query και θα παραχθεί το παρακάτω:

<StackPanel Margin="0,46,0,0" Name="StackPanel2">
 <DockPanel>
     <Label Width="100">Last Name</Label>
     <TextBox Name="LastName"></TextBox>
 </DockPanel>
 <DockPanel>
     <Label Width="100">First Name</Label>
     <TextBox Name="FirstName"></TextBox>
 </DockPanel>
 <DockPanel>
     <Label Width="100">Salary</Label>
     <TextBox Name="Salary"></TextBox>
 </DockPanel>
</StackPanel>

Οπότε μένει να δούμε πως θα το περάσουμε κατά το runtime μέσα στο Frame. Θα χρησιμοποιήσουμε το property Content στο οποίο θα κάνουμε assign ένα νέο StackPanel που θα προέλθει από το XElement. Εδώ θα μας βοηθήσει η κλάση XamlReader η οποία επιτρέπει τον μετασχηματισμό XAML markup σε object. Ας τα δούμε όλα μαζί:

Dim parser As New ParserContext()
parser.XmlnsDictionary.Add("", _
    "http://schemas.microsoft.com/winfx/2006/xaml/presentation")
parser.XmlnsDictionary.Add("x", _
    "http://schemas.microsoft.com/winfx/2006/xaml")

Dim stream As MemoryStream = New MemoryStream( _
    System.Text.Encoding.UTF8.GetBytes(GeneratedXAML.ToString))
Dim newPanel As StackPanel = _
    CType(XamlReader.Load(stream, parser), StackPanel)
Frame1.Content = newPanel

Ουσιαστικά, όλη η δουλειά γίνεται με τις δύο τελευταίες γραμμές κώδικα. Όλα τα προηγούμενα μπορούμε να τα παραλείψουμε και να μην χρησιμοποιήσουμε το MemoryStrean καθώς και το ParserContext, απλά γράφοντας

Dim newPanel As StackPanel = _
    CType(XamlReader.Load(GeneratedXAML.CreateReader), StackPanel) 
Frame1.Content = newPanel

όμως τότε θα πρέπει να βάλουμε τα namespaces μέσα στο XML literal σε διάφορα σημεία, πράγμα που κάνει τον κώδικα λιγότερο ευανάγνωστο.

Πατάμε το κουμπάκι λοιπόν και από

έχουμε

Happy Coding!

Σε παλιότερο post μου, είχα αναφερθεί στα Anonymous Types, τα οποία μαζί με το Type Inference και τους Object Initializers αποτελούν στοιχεία απαραίτητα για το LINQ. Σε αντίθεση με το Type Inference (που είναι απλό ως concept και παρόμοιο στις δύο γλώσσες) και τους Object Initializers (κι αυτό παρόμοιο στις δύο γλώσσες) τα Anonymous Types κρύβουν μια σημαντική διαφορά (λέγε με breaking change) στην υλοποίησή τους! Πιστεύω ότι αυτή η διαφορά είναι απαραίτητο να τη γνωρίζει κανείς, είτε γράφει τακτικά και στις δύο γλώσσες, είτε πετύχει κάποιο code sample και πρέπει να το μετατρέψει από VB.NET σε C# ή το αντίστοφο.

Στη C#, όταν δύο anonymous types δημιουργούνται με properties που έχουν ίδιο όνομα, ίδια σειρά και ίδιο τύπο, τότε και τα anonymous types έχουν ίδιο τύπο. Αν αντίστοιχα objects έχουν properties με ίδιες τιμές, τότε τα δύο instances έχουν ίδιο τύπο και είναι equal. Δηλαδή στο

var w = new { FirstName = "Manos", LastName = "Kelaiditis" };
var x = new { FirstName = "Manos", LastName = "Kelaiditis" };
var y = new { FirstName = "Kelaiditis", LastName = "Manos" };
var z = new { LastName = "Kelaiditis" , FirstName = "Manos"};
Console.WriteLine(w.Equals(x) ? "Match" : "NoMatch");
Console.WriteLine(w.Equals(y) ? "Match" : "NoMatch");
Console.WriteLine(w.Equals(z) ? "Match" : "NoMatch");

μόνο το w είναι ίδιο με το x. Tο Equals στα anonymous types χρησιμοποιεί το hashcode του instance το οποίο υπολογίζεται προσθέτοντας το hashcode από κάθε member. Με λίγα λόγια, το hashcode εξαρτάται από τη δομή και τις τιμές. Τώρα το θέμα είναι το εξής: Σε συνέπεια του παραπάνω το hashcode χρησιμοποιείται σε πολλές περιπτώσεις, όπως όταν τα anonymous types μπαίνουν σε collections τύπου HashTable, όταν χρησιμοποιούμε grouping και filtering στα Linq queries αλλά ακόμα και στο data binding των collections. Ουσιαστικά τo hashcode παίζει το ρόλο κλειδιού. Αυτό σημαίνει ότι το hashcode δεν επιτρέπεται να αλλάξει ποτέ στη διάρκεια ζωής του object. Γι αυτό και οι σχεδιαστές της C# αποφάσισαν ότι τα Anonymous Types θα είναι Immutable. Όταν διαβάζετε Immutable θα σκεφτόσαστε "χαραγμένα σε πέτρα". Αυτό σημαίνει ότι αν τολμήσω να γράψω το παρακάτω:

z.LastName = "Georgiou";

θα πάρω το λάθος:

Error    1    Property or indexer 'AnonymousType#1.LastName' cannot be assigned to -- it is read only   

καθώς τα instances από anonymous types είναι read only. Οι σχεδιαστές της C# θεώρησαν ότι τα "read-only" instances από anonymous types δεν φαίνεται να είναι ιδιαίτερο πρόβλημα αφού τα anonymous types έχουν περιορισμένη χρήση καθότι τυπικά δεν μπορούν να χρησιμοποιηθούν εκτός του context που έχουν δημιουργηθεί.

Τώρα, στη ομάδα της VB, είδαν ότι αν υιοθετούσαν το immutable χαρακτηριστικό για τα anonymous types θα ήταν (για λόγους συμβατότητας) μια απόφαση μονόδρομος που θα τους εμπόδιζε να είναι ευέλικτοι αφού αφενός λόγω late binding μπορεί να ανατραπεί το προηγούμενο και αφετέρου μελλοντικά θα προστεθούν χαρακτηριστικά όπως nominal anonymous types και dynamic interfaces.

Έτσι λοιπόν στη VB υπάρχει ο modifier "Key" για τα πεδία από τα anonymous types. Ο Key modifier κάνει το πεδίο read-only και καθοδηγεί τον compiler να κάνει override τις μεθόδους Equals και GetHashCode. Ας δούμε ένα παράδειγμα:

Dim x = New With {.FirstName = "Manos", _
                  .LastName = "Kelaiditis"}
Dim y = New With {.FirstName = "Manos", _
                  .LastName = "Kelaiditis"}
Dim z = New With {.LastName = "Manos", _
                  .FirstName = "Kelaiditis"}
Console.WriteLine(If(x.GetType() Is y.GetType(), _
                     "TypeMatch", "NoTypeMatch")) ' TypeMatch
Console.WriteLine(If(x.GetType() Is z.GetType(), _
                     "TypeMatch", "NoTypeMatch")) ' NoTypeMatch

Το πρώτο αποτέλεσμα δίνει TypeMatch ενώ το δεύτερο NoTypeMatch καθώς τα member του z είνα σε διαφορετική σειρά σε σχέση με το y. Μέχρι εδώ καλά. Ας δούμε το παρακάτω:

Dim x1 = New With {.FirstName = "Manos", _
                   .LastName = "Kelaiditis"}
Dim y1 = New With {.FirstName = "Manos", _
                   .LastName = "Kelaiditis"}
Console.WriteLine(If(x1.Equals(y1), _
                     "Match", "NoMatch")) ' NoMatch

Σε αντίθεση με αυτό που ισχύει στη C#, εδώ δεν παίρνουμε "Match" γιατί έχουμε mutable types αφού δεν έχουμε προσδιορίσει το Key. Απόδειξη είναι ότι μπορούμε άνετα να γράψουμε

x1.LastName = "Georgiou" 

Άρα, για να έχουμε αντιστοιχία με τη C# θα πρέπει να γράψουμε

Dim x2 = New With {Key .FirstName = "Manos", _
                   Key .LastName = "Kelaiditis"}
Dim y2 = New With {Key .FirstName = "Manos", _
                   Key .LastName = "Kelaiditis"}
Console.WriteLine(If(x2.GetType Is y2.GetType, _
                     "TypeMatch", "No TypeMatch"))
Console.WriteLine(If(x2.Equals(y2), _
                     "Match", "NoMatch"))

Βέβαια, anonymous types χρησιμοποιούμε και στα Linq queries. Τα παρακάτω είναι ισοδύναμα καθώς παράγονται immutable objects και στις δύο περιπτώσεις:

var query1 = from customer in customers
             select new { customer.FirstName, customer.LastName };

Dim query2 = From customer In customers _ 
             Select customer.FirstName, customer.LastName

Εκεί που υπάρχει διαφορά και χρειάζεται προσοχή είναι όταν χρησιμοποιούμε το New στη VB:

Dim query3 = From customer In customers _
             Select New With {.FirstName = customer.FirstName, _
                              .LastName = customer.LastName}

To παραπάνω query δεν είναι ισοδύναμο με το query2, παράγει mutable objects! Για να γράψουμε ισοδύναμο query με το query1 χρησιμοποιώντας το New, θα πρέπει να γράψουμε:

Dim query3 = From customer In customers _ 
             Select New With {Key .FirstName = customer.FirstName, _
 	                     Key .LastName = customer.LastName}

Τωρά, εκεί που ενδέχεται να κολλήσετε αν μεταφράζετε κώδικα από VB σε C# είναι αν σας τύχει το παρακάτω query:

Dim query = From prod In Products _
            Select New With {Key prod.Name, _
                             Key prod.CostPrice, _
                             prod.SalesPrice}

Παρατηρήστε ότι μόνο το Name και το CostPrice έχουν Key modifier ενώ το SalesPrice δεν έχει. Αυτό δεν μπορείτε να το περάσετε σε C# και θα πρέπει να καταφύγετε στη χρήση κανονικών κλάσεων. Βέβαια, το παραπάνω δίνει αρκετή ευελιξία καθώς για παράδειγμα το αποτέλεσμα του query μπορεί να γίνει data bound σε ένα grid και να επιτρέπονται οι αλλαγές στο πεδίο SalesPrice.

Λοιπόν αυτό είναι κάτι που δεν το είχα παρατηρήσει, μέχρι που πιάσαμε την κουβέντα περί FxCop και Globalization rules.

Αν χρησιμοποιήσετε το String.ToLower ή String.ToUpper και κάνετε ανάλυση του κώδικα μέσα από το Visual Studio θα χτυπήσει το CA1304 warning

Warning    9    CA1304 : Microsoft.Globalization : Because the behavior of 'String.ToUpper()' could vary based on the current user's locale settings, replace this call in 'Module1.Main()' with a call to 'String.ToUpper(CultureInfo)'. If the result of 'String.ToUpper(CultureInfo)' will be displayed to the user, specify 'CultureInfo.CurrentCulture' as the 'CultureInfo' parameter. Otherwise, if the result will be stored and accessed by software, such as when it is persisted to disk or to a database, specify 'CultureInfo.InvariantCulture'.    C:\Users\Manos\AppData\Local\Temporary Projects\ConsoleApplication1\Module1.vb    21    ConsoleApplication1

Αυτό είναι ένα unicode πρόβλημα που οφείλεται στο ότι σε πολλά cultures η μετατροπή από Lower σε Upper και ξανά σε Lower δεν είναι κυκλική! Δηλαδή αν ξεκινήσεις από ένα string πεζών, το μετατρέψεις σε κεφαλαία και ξανά σε πεζά, το πρώτο με το τρίτο string δεν είναι πάντοτε ίδια. Στα Ελληνικά υπάρχει πρόβλημα με το τελικό Σ και τα τονούμενα πεζά με διαλυτικά. Ας πούμε, το

"ΐΰ" = "ΐΰ".ToUpper.ToLower

δίνει False!

Σε άλλες γλώσσες που χρησιμοποιούν latin characters, το πρόβλημα είναι πιο έντονο (πχ βλ. εδώ σχετικά με το Τούρκικο locale).

Το πρόβλημα είναι ότι υπάρχει περίπτωση, κώδικας που παίρνει security αποφάσεις βάσει μετατροπών .ToLower και .ToUpper να μην συμπεριφερθεί σωστά. Γι αυτό καλό είναι

• Να χρησιμοποιηθεί η String.ToUpper(CultureInfo) και String.ToLower(CultureInfo)
• Να χρησιμοποιηθεί η String.Equals η οποία διαθέτει overloaded κλήση που καθορίζει το culture sensitivity
• Να χρησιμοποιηθεί η String.Compare με το IgnoreCase option

Περισσότερα για το θέμα αυτό:

http://msdn2.microsoft.com/en-us/library/bb386042.aspx

http://blogs.msdn.com/michkap/archive/2005/04/04/405174.aspx

http://msdn2.microsoft.com/en-us/library/5bz7d2f8(VS.71).aspx

Το πρόβλημα αυτό ανάγεται σε επίπεδο .NET Framework, δηλαδή είναι ανεξάρτητο γλώσσας, οπότε παίξτε by-the-book για να έχετε το κεφάλι σας ήσυχο...

Σε συνέχεια του post περί late binding, ας δούμε πως μπορούμε να πετύχουμε σωστό late binding, χωρίς να καταφύγουμε στο quick-and-dirty Option Strict Off.

H μαγική λέξη είναι "Reflection". Τι είναι το Reflection μέσα σε 10'': Είναι ένας μηχανισμός που επιτρέπει την αναζήτηση πληροφοριών σχετικές με μια κλάση κατά το runtime. Δηλαδή, μπορούμε κατά το runtime να βρούμε τι members έχει μια κλάση, τι παραμέτρους δέχονται και τι τιμές επιστρέφουν. Αυτό είναι εξαιρετικά χρήσιμο! Είναι ο μηχανισμός πάνω στον οποίο βασίζεται τo Intellisence και τώρα θα τον χρησιμοποιήσουμε για late binding.

Ας ορίσουμε μια κλάση:

Class TestClass
    Public Function DoSomething(ByVal value As Integer) As Integer
        Return value * 2
    End Function
End Class

Και τώρα ας δούμε πώς θα τη χρησιμοποιήσουμε:

        Dim objTest As New TestClass
        Dim myType As Type
        Dim param(0) As Object
        Dim rslt As Integer

        Dim parameter As String = 5
        Dim functionName As String = "DoSomething"

        param(0) = CType(parameter, Integer)


        
        myType = objTest.GetType 

        rslt = CType(myType.InvokeMember(functionName, _
                     Reflection.BindingFlags.Default Or _
                     Reflection.BindingFlags.InvokeMethod, _
                     Nothing, objTest, param), Integer)

        Console.WriteLine(rslt)

Στην πρώτη ομάδα Dim ορίζουμε το object που θα χρησιμοποιήσουμε, και το array από παραμέτρους που θα περάσουμε ως όρισμα στη μέθοδο που θα καλέσουμε. Στη δεύτερη ομάδα Dim ορίζουμε το όνομα της μεθόδου και τις τιμές των παραμέτρων. Κατόπιν με την GetType διαβάζουμε πληροφορίες της κλάσης που ορίσαμε από το manifest. Τι είναι το manifest σε 20'': Πρόκειται για ένα σύνολο από πληροφορίες που εμπεριέχονται σε κάθε assembly (assembly ονομάζεται στο .NET το παραγόμενο αποτέλεσμα του compilation - το dll ή το exe) που αφορά στην περιγραφή του ίδιου του assembly, πχ όνομα του assembly, έκδοση, culture και - αυτό που μας ενδιαφέρει -type reference πληροφορίες).

Οπότε ερχόμαστε και στο ζουμί:

Πάνω στο myType μπορούμε να καλέσουμε την InvokeMember η οποία (όπως και λέει το όνομά της) θα κάνει την κλήση βάσει των ορισμάτων: Το πρώτο είναι το όνομα της μεθόδου. Το δεύτερο, τα BindingFlags, καθοδηγούν το CLR στο πώς θα κάνει το binding. To τρίτο ορίζει το binder. Με το Nothing αφήνουμε το default binder (με custom binders έχουμε επιπρόσθετο έλεγχο κατά την επιλογή της μεθόδου κατά το Invoke). Με την τέταρτη παράμετρο ορίζουμε το πραγματικό object που θα χρησιμοποιηθεί και με την τελευταία περνάμε τις παραμέτρους της μεθόδου. Γενικά, ο κώδικας παραπάνω είναι απλουστευμένος με την έννοια ότι ξέρουμε ήδη ότι η μέθοδος μας επιστρέφει έναν ακέραιο. Στην πραγματικότητα, θα μπορούσαμε να πάρουμε κι αυτή τη πληροφορία μέσω Reflection.

Φυσικά, όλα τα παραπάνω παίζουν και στη C# δηλαδή η διαφορά που έχει η VB με τη C# στο late binding είναι ο πρώτος τρόπος που είδαμε στο προηγούμενο post. Αυτός ο τρόπος είναι by file late binding καθώς καθορίζεται με το Option Strict setting που είναι per file. Από την άλλη μεριά έχει το πλεονέκτημα ότι καθιστά την VB.NET ένα ιδανικό εργαλείο για εφαρμογές office automation και γενικότερα COM interop καθώς απλουστεύει κατά πολύ το implementation (αρκεί να ξέρει κανείς τι κάνει, αυτό που λέμε Static Typing Where Possible, Dynamic Typing When Needed)

To late binding παρότι ως θέμα είναι παλιό, αποτελεί ένα βασικό μηχανισμό ώστε η VB και η C# να αποκτήσουν dynamic χαρακτηριστικά και γι αυτό τώρα αποκτά νέα δυναμική (pun intended). Στην τωρινή μορφή με χρήση Reflection δεν είναι και τόσο εύκολη διαδικασία και γι αυτό ήδη το team της C# σκέφτεται το πως θα ενσωματώσει το late binding στη γλώσσα. Όπως και να έχει, ένα πράγμα είναι σίγουρο: οι εξελίξεις στις γλώσσες του .NET Framework θα είναι συνεχείς και πολύ ενδιαφέρουσες. Αν μπορούσαμε να στρβλώσουμε και τον χρόνο για να βγάλω 30 ώρες στο 24ωρο, θα ήταν ακόμα καλύτερα.

Στο νέο report της Gartner "Magic Quadrant for Business Intelligence Platforms" που αξιολογεί BI λύσεις, η πλατφόρμα της Microsoft που βασίζεται στον SQL Server ξεπέρασε τις λύσεις της Business Objects και της Cognos που θεωρούνται leaders στην αγορά.

Δεν θεωρώ τόσο σημαντικό το ποιός είναι πρώτος και ποιός δεύτερος, όσο τα επιμέρους συμπεράσματα της έρευνας:

• Ενώ πέρισυ η λύση ήταν στην κατηγορία "challenger", φέτος πέρασε στην κατηγορία "leader"
• To ΒΙ από εξειδικευμένο και ακριβό γίνεται commodity
• Η πελάτες έδειξαν ότι η πλατφόρμα έχει το ποιό ποιοτικό s/w σε σχέση με τις υπόλοιπες σε ασύγκριτα πιο ανταγωνιστική τιμή

Θεωρώ πραγματικά κρίμα το γεγονός ότι το BI είναι από τα πιο παραγνωρισμένα features που προσφέρει ο SQL Server και είναι κρίμα από τη στιγμή που όποιος έχει αγοράσει τον SQL Server έχει αγοράσει και αυτό το ισχυρότατο εργαλείο που του επιτρέπει να αναλύσει τα data που αποθηκεύει σε αυτόν ώστε να εξάγει χρήσιμα επιχειρηματικά συμπεράσματα. Το BI μπορεί να βρει εκατοντάδες εφαρμογές, από ανάλυση των πωλήσεων μέχρι το click-stream ενός web server. Καιρός να δούμε κινήσεις και στην Ελληνική αγορά και να αρχίσει να θεωρείται από την κάθε επιχείρηση τόσο στρατηγικό, όσο και η δραστηριοποίηση στο internet.

Με αφορμή αυτό το post σκέφτηκα να γράψω δύο πράγματα σχετικά με το late binding και το Option Strict, αυτά που συνήθως αγνοούν οι νέοι προγραμματιστές VB.NET.

Το late binding προέρχεται από τον κόσμο του COM, είναι κάτι που υπήρχε και στη VB, ωστόσο ας μην μπλέξουμε το COM και ας το δούμε λίγο πιο απλά το πράγμα. Στον παρακάτω κώδικα φαίνεται ένα παράδειγμα late binding.

    Private Sub Form1_Load(ByVal sender As Object, 
                           ByVal e As System.EventArgs) _
                           Handles Me.Load
        AddHandler Button1.Click, AddressOf Button1_Click
    End Sub

    Private Sub Button1_Click(ByVal sender As System.Object, _
                              ByVal e As System.EventArgs)
        Debug.WriteLine(sender.text)
    End Sub

Στο Button1_Click χρησιμοποιούμε το text property στο sender object και με μια πρώτη ματιά φαίνεται να τρέχει σωστά. Σε υποψίες ότι κάτι δεν πάει καλά με αυτή τη γραμμή κώδικα θα πρέπει να μας βάλει το intellisense το οποίο μόλις γράψουμε "sender" και πατήσουμε "." δεν μας εμφανίζει στη λίστα το text property. Ουσιαστικά, εκείνη τη στιγμή λέμε στον compiler "Μην ανησυχείς που αυτό το sender πράγμα δεν έχει text property, όταν τρέξει το πρόγραμμα σου εγγυώμαι ότι ο τύπος του object θα έχει". Όπως αντιλαμβάνεστε, κάτι τέτοιο είναι αρκετά επικίνδυνο γιατί αν κατά το runtime το object δεν έχει τελικά text property θα πάρω ένα ωραιότατο System.MissingMemberException.

Στην C# δεν υπάρχει περίπτωση να γίνει κάτι τέτοιο, θα χτυπήσει η γραμμή κατά το compilation. Στη VB.NET υπάρχει το Option Strict On|Off που καθορίζει αν θα επιτρέπεται η συμπεριφορά που περιέγραψα (Option Strict Off) ή αν θα χτυπάει κατά το compilation (Option Strict On). Και έτσι ερχόμαστε σε έναν πολύ σημαντικό κανόνα. Αν ως προγραμματιστές θα πρέπει να ακολουθείτε έναν και μόνο κανόνα, αυτός είναι ο παρακάτω:

Πάντοτε προγραμματίζουμε με Option Strict On

Μπορούμε είτε να πάμε στα project properties, στα Compile Options και να ενεργοποιήσουμε το On για να ισχύει για όλο το project, είτε να το γράφουμε στη αρχή κάθε vb αρχείου. Προσωπικά προτιμώ το δεύτερο ώστε να το βλέπω, να το θυμάμαι και να είμαι σίγουρος ότι είναι On.

To Option Strict On αποτελεί πολύ καλή προγραμματιστική τακτική καθώς προστατεύει από ύπουλα bugs αφού επιβάλει πάντοτε να γίνεται explicit conversion. Για παράδειγμα, απαγορεύει το παρακάτω:

    Dim b As Double 
    Dim c As Integer

    c = b

Χμμμ.... Ωραία, γιατί όμως υπάρχει το Option Strict Off; To Option Strict Off οφείλεται στην "κληρονομιά" της Visual Basic 6. Εκεί, διευκόλυνε τον προγραμματισμό σε COM objects, ιδιαίτερα με εφαρμογές που χρησιμοποιούσαν το automation του MS Office. Έτσι λοιπόν χρειάστηκε και στη VB.NET λόγω του upgrade που θα έπρεπε να γίνει σε όλες αυτές τις εφαρμογές. Σήμερα - μέχρι το VSTO να γίνει mainstream - το Option Strict Off συνεχίζει να χρησιμεύει για εφαρμογές MS Office Automation, ιδιαίτερα με παλιότερες εκδόσεις του MS Office. Πέρα από αυτό όμως θα πρέπει μην χρησιμοποιείται καθώς μπορεί να οδηγήσει σε κώδικα που συντηρείται δύσκολα και επιτρέπει τη δημιουργία bugs.

Άρα λοιπόν, αν θέλουμε late binding θα πρέπει υποχρεωτικά να χρησιμοποιήσουμε Option Strict Off; Όχι, σε προσεχές post θα δούμε τον σωστό τρόπο για να γίνεται late binding ακόμα και με το Option On. Μέχρι τότε, happy coding!

Έγινε χθες η περίφημη ομιλία του Bill Gates στο Μέγαρο Μουσικής. Λίγο πολύ ήταν η παρουσίαση που είχαμε δει σε web-casts από το CES 2008 στο Las Vegas με τη διαφορά ότι στην πρώτη σειρά καθόντουσαν celebrities από την Ελλάδα.  Ανάμεσα στα άλλα, είδαμε μια άποψη για το πως θα αλλάξει το μελλοντικό λογισμικό τη καθημερινότητα μας και τι εξελίξεις περιμένουμε από αυτό. Τα δυο  video το πρώτο με το παράδειγμα του super market που η νοικοκυρά χρησιμοποιεί το PDA και το δεύτερο με το manufacturing chain για τη σχεδίαση ενός καθίσματος αυτοκινήτου, ήταν εντυπωσιακά ωστόσο προσωπικά κατάφεραν να μου αφήσουν πικρή γεύση και να μου υπενθυμίσουν το πόσο πίσω είναι η Ελληνική πραγματικότητα. Αν αυτά που ανέφερε ο Bill είναι το τι θα συμβεί στα επόμενα δέκα χρόνια, υποθέτω θα τα δούμε εδώ στην Ελλάδα στα επόμενα είκοσι χρόνια. Κατά τ' άλλα, το demo του Surface αν και το έχουμε δει κι αυτό σε casts, είχε αρκετό ενδιαφέρον, κυρίως επειδή ήταν live.

Στο δεύτερο μέρος, είχαμε τον Ray Ozzie (λάθος εκ παραδρομής) Ron Jacobs ο οποίος μας μίλησε για το ...Oslo. Βρήκα την ομιλία του πολύ ενδιαφέρουσα καθώς ξεκίνησε από τις επιχειρηματικές ευκαιρίες που παρέχει το internet (το νέφος) δείχνοντας το παράδειγμα του YouTube και του Skype, δύο projects που γιγαντώθηκαν με ελάχιστα resources ενώ οι αντίστοιχοι ογκόλιθοι της αγοράς (NBC και BT) παρόλο που διαθέτουν πολλαπλάσια resources δεν εκμεταλλεύτηκαν το "νέφος" και έχασαν την ευκαιρία. Στη συνέχεια υπογράμμισε ότι το μέλλον είναι SOA αρχιτεκτονική και Software + Services και μας παρουσίασε το "Oslo".

Πρόκειται για ένα προϊόν που έχει στόχο να απλοποιήσει το σχεδιασμό, την υλοποίηση και τη διαχείριση SOA εφαρμογών σε όλο το πλάτος τους (δηλαδή μέχρι και το IT infrastructure). Θα βασίζεται στα επερχόμενα Microsoft Visual Studio 10, Microsoft System Center 5, BizTalk Server 6, BizTalk Services 1 και Microsoft .NET Framework 4. Περισσότερα για το "Oslo" μπορείτε να βρείτε εδώ.

Ένα ενδιαφέρον στοιχείο ήταν ότι μόλις ξεκίνησε να μιλάει ο Ray Ozzie Ron Jacobs , πολύ κόσμος έσπευσε να αποχωρίσει. Πολλοί από αυτούς ήταν ίσως ακριβώς αυτοί που θα έπρεπε να είχαν ακούσει αυτά που έλεγε περί "νέφους" και ευκαιριών! Με τις υγείες μας...

Το LINQPad είναι ένα database query tool που όμως αντί να χρησιμοποιεί SQL, χρησιμοποιεί LINQ! Μπορεί κανείς να γράψει SQL statements, C# expressions ή statements και VB expressions ή statements, να εκτελέσει τον κώδικα και κατόπιν να δει τα αποτελέσματα ή το αντίστοιχο lambda expression ή το SQL statement. Αυτό το χαρακτηριστικό, όπως επίσης ότι έρχεται μαζί με 200 παραδείγματα, το καθιστά ένα πολύ δυνατό εργαλείο για εκμάθηση. Επιπρόσθετα η υποστήριξη VB και C# σύνταξης προσφέρεται για να ελέγξει κανείς τις περιπτώσεις όπου ένα query δεν μεταφέρεται πλήρως ανάμεσα στις δύο γλώσσες (ναι, υπάρχουν τέτοιες περιπτώσεις, περισσότερα σε προσεχές post). Μπορείτε να το βρείτε στο http://www.linqpad.net/

Διάβαζα πριν λίγο το post του Γιώργου Χατζημανώλη και θυμήθηκα τις προάλλες που πάλευα με τα config αρχεία καθώς προσπαθούσα να σετάρω ένα WCF Service και τον αντίστοιχο client. H όλη διαδικασία μου έσπασε τα νεύρα! Και αυτό γιατί όταν χρησιμοποιείς τo out-of-box configuration όλα είναι ωραία και καλά. Όταν όμως θέλεις να υλοποιήσεις σενάριο όπως "SQL role & membership provider over HTTPS" πρέπει να πάρεις ανάσα και να βουτήξεις στα βαθειά νερά των config αρχείων. Μετά από αρκετή προσπάθεια και εν τέλει με τη πολύτιμη βοήθεια του "Windows Communication Foundation Step by Step" τα κατάφερα. Κατόπιν σκέφτηκα ότι όλα αυτά δεν θα έπρεπε να είναι καθόλου έτσι! Θα έπρεπε να υπήρχε ένας wizard-style scenario-driven config editor:

– Παρακαλώ, τι θα θέλατε;

– Θα ήθελα ένα secure public WCF service, hosted σε IIS με CardSpace authentication

– Φυσικά κύριε, ορίστε το web.config, το client app.config και αυτό το generated code sample για να τα δοκιμάσετε.

– Αχ, υπέροχα, ευχαριστώ πολύ.

Αυτό λέγεται "productivity". Αν ήθελα να κάνω edit σε XML αρχεία, δεν θα έγγραφα σε VB. Θα μου πείτε, υπάρχει ο WCF Configuration Editor αλλά ουσιαστικά πρόκειται για έναν property editor. Πιστεύω ο ρόλος μου είναι να λαμβάνω αποφάσεις. Που θα γίνεται hosting το service; Τι security μηχανισμό θα χρησιμοποιεί; Τι transport μηχανισμό; Δεν με νοιάζουν τα υπόλοιπα... Μακάρι να υπήρχε αυτό το wizard-style scenario-driven tool να καλύπτει το 80% των τυπικών σεναρίων και ας έκανα την βουτιά στο web.config για το υπόλοιπο 20% παρέα με το reference guide. Εξάλλου, εκεί που πραγματικά πάσχουν τα out-of-box generated services είναι η έλλειψη security μηχανισμών καθώς σχεδόν πάντοτε ένα service όταν πρόκειται να βγει σε production θα πρέπει να προστατευθεί.

Σίγουρα, το WCF παρέχει τεράστιο πλήθος από πιθανά configurations. Ωστόσο αν ο τρόπος δημιουργίας ενός set από ερωτήσεις και αντίστοιχα configuration settings είναι ανοιχτός, θα μπορούσε να να δημιουργηθεί ένα δημόσιο repository (βλ. Codeplex) για να συνεισφέρει ο καθένας. Πολύ ενδιαφέρον project αλλά δυστυχώς δεν ξέρω τόσο καλά WCF για να το ξεκινήσω...

To Visual Studio 2008 διαθέτει ένα νέο component που έρχεται να βοηθήσει στη χρήση των DataSets. Μέχρι σήμερα, αν είχαμε ένα DataSet που είχε δύο ή παραπάνω πίνακες με σχέσεις PK-FK και θέλαμε να κάνουμε update στα περιεχόμενα όλων των πινάκων θα έπρεπε να κάνουμε ένα ιεραρχικό update, δηλαδή να γίνει το update με σειρά όπως:

• Insert στο master
• Insert στο detail
• Update στα details
• Update στο master
• Delete στα details
• Delete στο master

Το παραπάνω γίνεται με λίγες γραμμές κώδικα, χρησιμοποιώντας την GetChanges. Για παράδειγμα, αν θέλουμε να πάρουμε μόνο τις εγγραφές για inserts, θα πρέπει να πούμε κάτι σαν το παρακάτω:

Dim newOrders As NorthwindDataSet.OrdersDataTable = _
    CType(NorthwindDataSet.Orders.GetChanges( _
          Data.DataRowState.Added), _
          NorthwindDataSet.OrdersDataTable)

OrdersTableAdapter.Update(newOrders)

Βέβαια, όταν υπάρχουν πιο περίπλοκες σχέσεις με περισσότερους πίνακες, τότε χρειάζεται να γραφτεί περισσότερος κώδικας και είναι ακόμα πιο δύσκολο να διατηρηθεί η σωστή σειρά στο ιεραρχικό update. Επιπρόσθετα, ενδεχομένως να χρειάζεται να διαχειριστούμε το connection state και το transaction καθώς και να κάνουμε χειροκίνητο refresh του DataSet.

Τη λύση στο πρόβλημα έρχεται να δώσει ο TableAdapterManager. Αυτό είναι ένα component που πλέον προστίθεται αυτόματα όταν κάνει κανείς drag'n'drop κάποιο datasource στη φόρμα. Ουσιαστικά, ο νέος DataSet designer κάνει generate αυτό το component εφόσον θέσουμε σε true το "Hierarchical Update" property στο DataSet. Κατόπιν, το μόνο που χρειάζεται είναι απλά να καλέσουμε την UpdateAll του TableAdapterManager. Το component έχει επίσης το property BackUpDataSetBeforeUpdate το οποίο όταν είναι true επαναφέρει στην προηγούμενη κατάσταση το DataSet σε περίπτωση αποτυχημένου transactional update.

Μπορείτε να διαβάσετε περισσότερα στο msdn

Τα Relaxed Delegates είναι ένα νέο feature της VB 9 και αν αρέσουν τόσο πολύ στον Don Box, τότε μάλλον αξίζει να τα δούμε λίγο παραπάνω.

Ας αρχίσουμε από ένα VB 8 σενάριο ώστε να φανεί καλύτερα που χρησιμεύουν. Στο .NET Framework 2.0 εμφανίστηκαν τα generics που μας έδωσαν τη δυνατότητα να κάνουμε κάτι σαν το παρακάτω:

    Dim count As Integer
    Dim process As New Action(Of Customer)(AddressOf ProcessElement)

    Sub ProcessElement(ByVal element As Customer)
        count = count + 1
        Console.WriteLine("{0}: {1}", count, element)
    End Sub

    Sub Main()
        Dim list() As Customer = Customer.CreateCustomers
        count = 0
        Array.ForEach(Of Customer)(list, process)
 
        Console.ReadLine()
    End Sub

Το Array.ForEach method παίρνει ως όρισμα ένα array (duh!) και ένα delegate τύπου Action(Of T). Αυτό που κάνει είναι να περνάει ένα προς ένα κάθε item του Array στο delegate (ουσιαστικά στη μέθοδο ProcessElement), δηλαδή χρησιμοποιούμε αυτό αντί να γράφουμε loops.

Αυτό που πρέπει να παρατηρήσετε είναι ότι παντού (στο delegate function, στο delegate declaration αλλά και στο ForEach) χρειάζεται να ορίσουμε τον τύπο των περιεχομένων του Array. Για να φανεί αυτό έγραψα την εκτεταμένη μορφή του κώδικα. Η πιο compact (αλλά ισοδύναμη) είναι η παρακάτω:

    Dim count As Integer
 
    Sub ProcessElement(ByVal element As Customer)
        count = count + 1
        Console.WriteLine("{0}: {1}", count, element)
    End Sub

    Sub Main()
        Dim list() As Customer = Customer.CreateCustomers
        count = 0
        Array.ForEach(list, AddressOf ProcessElement) 

        Console.ReadLine()
    End Sub

Είναι προφανές από τα παραπάνω ότι σε περίπτωση που πέρα από objects τύπου Customer είχαμε και objects τύπου Order, τότε θα έπρεπε να φτιάξουμε την αντίστοιχη ProcessElement που να έχει όρισμα ένα Order object. Τα relaxed delegates της VB 9 come to the rescue! Στη VB 9 είναι απόλυτα σωστό το παρακάτω:

    Dim count As Integer

    Sub ProcessElement(ByVal element As Object)
        count = count + 1
        Console.WriteLine("{0} - {1}", count, element)
    End Sub

    Sub Main()
        Dim list() As Customer = Customer.CreateCustomers
        count = 0
        Array.ForEach(list, AddressOf ProcessElement)
        Console.WriteLine("{0} elements were processed.", count)

        Console.ReadLine()
    End Sub

Το list μπορεί να περιέχει οτιδήποτε μέσα, θα εξυπηρετηθεί όμως όπως και να έχει από την ProcessElement. Για την ακρίβεια η ProcessElement μπορεί να μην παίρνει ούτε καν παράμετρο! Ουσιαστικά η VB κάνει πλέον implicit conversion και στα delegates

Μια πιο απλή και πρακτική εφαρμογή των παραπάνω είναι το εξής σενάριο: Μέχρι και τη VB 8, αν ήθελα αντιστοιχήσω τον ίδιο κώδικα σε δύο διαφορετικά events (πχ KeyDown και MouseDow) θα έπρεπε να έφτιαχνα δύο handlers καθώς η KeyDown έχει ως δεύτερο όρισμα το e τύπου KeyEventArgs ενώ στη MouseDown το e είναι τύπου MouseEventArgs. Τώρα μπορώ απλά να πω:

    Private Sub JustDown() Handles Button1.KeyDown, Button1.MouseDown

    End Sub

Cheers!

Πρώτο blog-post της χρονιάς, ας πούμε κάτι λιγότερο programming και περισσότερο geek-fun. Στο τελευταίο Consumer Electronics Show (CES), ο Bill έδωσε (όπως είπε) το τελευταίο keynote του καθώς το καλοκαίρι αποσύρεται από τη Microsoft. Στο keynote λοιπόν μίλησε για το όραμά του για τους μελλοντικούς υπολογιστές (επικοινωνία σε φυσική γλώσσα, κλπ) αλλά το καλύτερο σημείο ήταν ένα video με το οποίο ξεκίνησε που δείχνει πως θα είναι η τελευταία μέρα του στη δουλειά...

Bill Gates’ last day at Microsoft (video)

Αν και όλοι το γνωρίζουμε ότι η VB είναι μια γλώσσα γενικής χρήσης, μέσα στο Χριστουγεννιάτικο πνεύμα, ο Chris Anderson, ο Don Box και η Amanda Silver την χρησιμοποιούν για να μας τραγουδίσουν ένα Χριστουγεννιάτικο τραγούδι.

http://channel9.msdn.com/ShowPost.aspx?PostID=367997%20%20

Τώρα που το σκέφτομαι, μάλλον ο Don Box δεν πρέπει να είναι ο ίδιος. Μάλλον έχει αντικατασταθεί από εξωγήινο. Τόσες αναφορές στη VB στο blog του...

Όπως και να έχει, ευχές για καλές γιορτές σε όλους!