Pietro Brambati Blog

Developer's stories

  • Pietro Brambati Blog

    Come odinare numeri pari e dispari ...

    • 31 Comments

    Forse un po' per divertimento (forse non per tutti), ma Stefano mi segnala questo simpatico quesito risolto con LINQ: data una lista di numeri pari e dispari non in ordine (ad esempio : 1,7,9, 2, 3, 4, 3, 4, 2, 3, 4, 5, 2, 0, 9) come si separano i numeri pari da quelli dispari ?

    List<int> elenco = new List<int> { 1,7,9, 2, 3, 4, 3, 4, 2, 3, 4, 5, 2, 0, 9 };
    var pariEdispari = elenco.OrderBy(s => s % 2 != 0);
    var pariEdispariOrdinati = elenco.OrderBy(s => s % 2 != 0).ThenBy(s => s);
    
    foreach (var item in pariEdispariOrdinati)
    {
          Console.WriteLine(item);
    }

    L'operatore ThenBy si può applicare dopo la OrderBy perchè può essere applicato solo ad una IOrderedEnumerable<T> e non ha una IEnumerable<T>

    Quante righe di codice ci vorrano mai se non si usasse LINQ ?

    Mahh?? Sicuramente non ci penserò durannte il week-end.

    Pietro   Click to IM Pietro
  • Pietro Brambati Blog

    LINQ to SQL e LINQ to Entities

    • 22 Comments

    image

    In questi intensi giorni che sto vivendo qui al TechEd a Barcellona ho avuto la possibilità di intervistare Luca Bolognese, italiano di nascita e ormai da tempo in quel di Redmond, dove lavora come Lead Program Manager.

     

    In questo video intervista Luca ci parla di LINQ to SQL e LINQ to Entities e delle future direzioni che questi due framework potranno avere, degli scenari per il loro utilizzo e di come LINQ cambierà il modo in cui programmiamo oggi.

    Un piccolo riassunto tecnico, che spero sia utile come introduzione al video:

    LINQ to SQL è una delle implementazioni di LINQ che verranno rilasciate con Visual Studio 2008. LINQ to SQL è il modo più semplice per poter lavorare con SQL Server usando un nuovo modello di programmazione in C# 3.0 e Visual Basic 9. In questo modo nel nostro linguaggio .NET preferito scriviamo del codice che si avvicina ad una sintassi SQL rendendo di fatto meno complicato far "parlare" le nostre applicazioni fatte di classi, clicli e quant'altro con SQL Server, un DBMS relazionale in cui "vediamo" tabelle.

    LINQ to Entities è un'altra implementazione di LINQ fatta per paralre con l' ADO.NET Entity Framework (EF), sia l'EF che LINQ to Entities verranno rilasciati dopo Visual Studio 2008, l' EF è infatti attualmente in Beta 2. L'EF è un framework che consentirà agli sviluppatori di lavorare con un maggior livello di astrazione, cioè uno sviluppatore si concentrerà solo sul modello concettuale proprio del modello Entità-Relazione, in maniera indipendente dallo storage sottostante sia esso SQL Server o un altro database. Ad esempio potrò lavorare con un' entità Cliente che potrà mapparsi su uno storage relazione anche su più di una tabella. Se volete saperne di più sulla Beta 2 dell' ADO.NET Entity Frameowrk, seguite pure questo link, in cui trovate una breve introduzione all' EF e a LINQ to Entites.

    Spero sia utile

    -Pietro

  • Pietro Brambati Blog

    Uno sguardo a ASP.NET Dynamic Data – parte 1

    • 21 Comments

    Una delle novità presenti nella SP1 di .NET 3.5 sono i Dynamic Data (DD), o meglio ASP.NET Dynamic Data. In estrema sintesi i DD consentono di generare un sito web completo partendo da un modello dei dati. Vi è mai capitato di dover costruire un’applicazione web in poco tempo, niente di eccezionale, solo per poter permettere di fare operazioni di interrogazione e modifica su una sorgente dati?

    Bene, i DD sono pensati proprio per questi scenari: si parte da un modello dei dati costruito con LINQ to SQL o Entity Framework (ma non solo..) e su questo, delle pagine aspx fungono da template generici, essendo in grado di capire quali tabelle sono presenti nel modello dei dati, di capire come sono fatte e di visualizzarle così come renderle modificabili. Esiste quindi un template unico (condiviso da tutte le tabelle) per le operazioni tipiche che su queste potremmo fare (interrogazione, modifica etc).

    Un altro aspetto importante riguarda il motore di routing su cui si basano, che consente di non legare l’url che chiamiamo nel browser per richiedere una specifica pagina a dove la pagina fisica risieda oppure a come questa si chiami. Inoltre è possibile modificare il comportamento del motore di routing tramite delle regole, in un unico punto, senza dover modificare alcunché nelle singole pagine e come queste si richiamino tra di loro.

    Partiamo con un semplice esempio:

    Da Visual Studio 2008 SP1 ( oppure con Visual Web Development Express 2008 SP1) scegliamo uno dei due nuovi template disponibili:

    image

    Scegliamo Dynamic Data Web Application, perché pensiamo di generare il modello dei dati con LINQ to SQL, se volessimo usare Entity Framework dovremmo scegliere Dynamic Data Entities ….

    Date ora un rapido sguardo al progetto generato che contiene la cartella DynamicData, che a sua volta contiene i template che vi dicevo sopra, in particolare guardate la sottocartella PageTemplates che contiene i template usati dai DD. Qui trovate una descrizione delle pagine incluse di default.

    E’ interessante anche il folder FiledTemplate in cui trovate come viene eseguito il rendering di uno specifico tipo, ad esempio il file Boolean.ascx e Boolean_Edit.ascx contengono il codice che viene generato a runtime tutte le volte che si deve generare la parte di pagina che visualizza una colonna del database di tipo boolean e, come avrete capito, il comportamento cambia se siamo in fase di visualizzazione piuttosto che editing del campo. Quindi, in un unico punto, è stato centralizzato il comportamento per la visualizzazione e la modifica dei singoli campi delle tabelle del database. Posso modificare il codice qui e vedere le modifiche apportate ogni volta che viene visualizzata una colonna che fa riferimento ad un campo boolean su db, di una qualsiasi pagina che venga renderizzata. I DD hanno anche un meccanismo che consente di fare un po’ il contrario: di specificare cioè che un particolare campo boolean, di una particolare tabella sia visualizzato in modo completamente diverso che dagli altri. Vedremo meglio questo meccanismo di estendibilità in un altro post.

    Per ora procediamo oltre e aggiungiamo un modello dei dati basato su LINQ to SQL. Dal menù: Add new Item, quindi scegliamo Linq to SQL Classes, “agganciamo” il nostro database Northwind, o quello che preferite, e senza preoccuparcene troppo facciamo drag & drop di tutte le tabelle, alla fine ci troviamo più o meno nella situazione in figura:

    image

    Nella figura trovate evidenziati il folder DynamicData e il file del modello dei Dati Northwind.dbml.

    Ora andiamo nel file global.asax, semplicemente scommentiamo la riga di codice in cui informiamo i DD del nostro modello, “registrandolo” e aggiungendo il DataContext che mi ha creato il designer, NorthwindDataContext , imponendo a true l’attributo ScaffoldAllTables, che in soldoni dice ai DD di utilizzare tutte le tabelle del mio modello dei dati. E’ doveroso ricordare, come il commento nella stessa pagina global.asax ricorda, questa può non essere la cosa migliore da fare, ma per ora, per il mio esempio, può andare.

    Premendo F5 vediamo la nostra applicazione già bella che fatta. In figura vedete la prima schermata che mostra l’elenco delle tabelle

    image

    Per renderci conto di quanto sia potente il meccanismo di discovery del modello dei dati usato dai DD, premiamo il link che ci porta alla tabella Products, la pagina list.aspx che viene invocata, è un template completamente generico, è in grado di visualizzare correttamente la tabella Products.

    Nella seguente figura, ho evidenziato gli aspetti notevoli che i DD ci mettono a disposizione gratuitamente:

    image

    I DD si accorgono :

    • che la tabella Products ha una relazione di foreign-key con la tabella Category ed invece di mostrarci l’ID della Categoria, ad esempio 1 per il primo prodotto, ci mostra il nome della categoria, cioè Beverages. Potente, no! Lo stesso vale per Supplier.
    • Mettono a disposizione un menù per fare operazione di filtraggio: guardate Discontinued, Category, Supplier: che è generato dinamicamente in base a quali campi boolean e alle relazioni foreign-key presenti nella tabella prodotti.
    • Seguendo i link Edit, Delete e Details si giunge a delle pagine che servono proprio per le operazioni suddette, che ovviamente sono generate a partire dagli altri template, anch’essi generici e adattabili a qualsiasi tabella.

    Il tutto finora semplicemente scrivendo una riga di codice nel file global.asax.

    Il Routing

    Se torniamo al file global.asax, noterete come viene generato l’url per navigare l’applicazione web generata:

    image

    L’url viene composto con il nome della tabella e il nome delle action, a cui viene aggiunta l’estensione aspx. Ora cos’è l’action ? Possiamo pensare alle action come alle azioni eseguite sulla pagina dall’utente. Esiste l’enum PageAction che contiene le action usate di default dai DD. Con un esempio si potrebbe dire che se l’utente clicca sul link Edit, per modificare come è fatto un singolo prodotto, la pagina esegue la relativa action PageAction.Edit e il motore di routing invoca la corrispondente pagina, nell’esempio sopra sarà dunque la pagina Edit.aspx, che trovate nel folder dei template in Page templates.

    Per renderci conto di quanto sia flessibile il motore di routing, possiamo provare ad aggiungere due nuove regole. Le regole seguenti valgono solo sulla tabella “Supplier”.

    image

    Attenzione : le regole hanno una precedenza, quindi dobbiamo applicare queste due regole prima di quella presente di default che è più generica. Questa regola agisce quando scegliamo la tabella Supplier (durante la navigazione ). In questo caso sia che l’utente scelga di selezionare la lista di tutti i supplier (PageAction.List), che scelga di selezionare il singolo supplier (PageAction.Details), la pagina che la visualizza sarà la ListDetails.aspx (anche questa è una delle 4 pagine presenti di default nel folder Page Templates). Nella definizione della regola ViewName è il nome della pagina aspx (senza estensione) che deve farne il rendering. Mentre in verde vedete l’url che apparirà nella address bar del browser, che può essere quello che volete, in questo caso ho semplicemente rimosso l’estensione “.aspx” alla fine dell’url.

    Conclusione

    I DD vanno ad arricchire le funzionalità delle WebForms, offrendo un framework per realizzare applicazioni web data-driven. In questo post abbiamo visto brevemente come iniziare ad usarli vedendo i principi di base del loro funzionamento.

    I DD offrono comunque un meccanismo che permette molte forme di personalizzazione, permettono di usare dei template particolari per fare il rendering di campi specifici di una tabella usando ad esempio i controlli dell’ AJAX Control Toolkit o di terze parti ad esempio per selezionare un calendario, oppure uno slider per decidere una quantità numerica. Le pagine degli ASP.NET Dynamic Data sono già pensate per sfruttare i controlli ASP.NET AJAX.

    Altri attributi consentono di impostare delle regole di validazione sul modello dei dati, ad esempio posso impostare tali regole direttamente sulle proprietà delle classi generate da LINQ to SQL, creando delle partial class. Questo meccanismo consente di accentrare le regole di validazione, che poi “fluiscono” nella UI e valgono in qualsiasi pagina web si faccia riferimento a quella specifica classe...

    Spero di avere stuzzicato la vostra curiosità , almeno per chi non ha ancora avuto modo di provare i nuovi ASP.NET Dynamic Data.

    Link utili

    MSDN library ASP.NET Dynamic Data

    www.asp.net/dynamicdata/

  • Pietro Brambati Blog

    Silverlight 3 e i .NET RIA Services – parte 1

    • 18 Comments

    I .NET RIA Services (attualmente in Preview rilasciata dopo il MIX09) sono molto interessanti per chi scrive applicazioni e vuole esporre entità tramite servizi e poi consumarle da Silverlight 3. Pensiamo ad esempio ad una piccola applicazione, costruiamo lo strato di accesso ai dati con Entity Framework, vogliamo poi costruire uno strato di servizi per esporre gli stessi dati ad un’applicazione silverlight 3.

    Requisiti

    Per seguire il mio esempio dovete avere installato:

    Attenzione: se sulla vostra macchina sviluppate anche con Silverlight 2, usate una macchina virtuale per Silverlight 3 beta, perchè dopo l’installazione dei tool la macchina sarà configurata per questa versione di Silverlight, la 3 appunto e non vi sarà supporto per creare progetti Silverlight 2.

    Esempio

    Creiamo un nuovo progetto Silverlight 3,  potete anche usare il nuovo template Silverlight Navigation …

    image

    Nella maschera successiva, lasciate impostato il flag “Link to ASP.NET server project”. Questo creerà un legame tra il nostro servizio e l’applicazione client (Silverlight) generando ad ogni compilazione delle classi per Silverlight ed il relativo modello che permetteranno l’interazione con la corrispondente parte lato server.

    image 

    Creiamo uno strato di accesso ai dati

    Ora al nostro progetto aggiungiamo un semplice strato di accesso ai dati fatto con Entity Framework, usando northwind e prendendo la tabella Customers, che creerà la corrispettiva classe, immagino fino a qui sia più o meno tutto noto e le immagini seguenti siano esplicative:

    image

    image

    Nel disegno futuro potrete usare qualunque tecnologia per lo strato di accesso ai dati usata insieme ai .NET RIA Services: LINQ to SQL, vari ORM, semplici oggetti .NET etc, etc.

    Creiamo ora il mid-Tier usando i RIA Service

    Ora, sempre sul progetto web, che contiene ora il nostro file.edmx, possiamo aggiungere un DomainDataService. Questo nuovo template per VS 2008:

    • crea un servizio REST-based, rendendo possibili operazioni CRUD sulla nostra sorgente dati.
    • ci permette di esporre i metadati relativi alle nostre entità. Questi possono essere molto utili in caso volessi aggiungere delle regole di validazione sul modello stesso dei dati (vedete dopo).

    Quindi, Add New Item, selezionare Domain Service Class, chiamiamo il nostro servizio ad esempio CustomersService, ad esempio

    image

    Ora nella schermata seguente abbiamo la possibilità di selezionare le Entità e se abilitare la modifica su queste, questo creerà dei metodi di Update, Insert e Delete. Inoltre selezionate il flag per creare la classe dei metadati, che ci servirà dopo per la validazione.

    image

    l’opzione Enable Client Access è importante: questa crea il legame tra il mid-tier, il nostro progetto web che espone dati, ed il progetto Silverlight 3. Ogni volta che compilo l’applicazioni vengono create delle classi proxy, che si mappano sul modello.

    Le classi lato server

    Sul server ora vengono create due classi, la prima customerModel, contiene i metoti per ottenere/inserire/modificare e cancellare i nostri customers, le entità del nostro modello:

    image

    la classe CustomersModel.metadata.cs contiene i metadati relativi

    Le classi lato client: Silverlight

    Se compiliamo il progetto, vengono prodotte in automatico delle classi proxy, per vederle in Visual Studio, possiamo usare il bottone per visualizzare tutti i file:

    image

    Scriviamo il codice dell’applicazione Silverlight 3

    Ora, per renderci conto di come usare i RIA Services (un primo modo per la verità), inseriamo una semplice DataGrid nel progetto Silverlight e poi scriviamo il codice seguente nel file di code-behind:

    image

    image

    Se lancio l’applicazione ho i dati visualizzati nelle griglia:

    image

    il metodo LoadCustomers è il corrispondente metodo associato al metodo GetCustomers definito a livello di servizio. I RIA Services usano questa convenzione nella nomenclatura, che comunque può essere personalizzata e/o modificata usando l’attributo [Query] sul metodo del Servizio.

    Nella prossima parte ci occuperemo di:

    • filtraggio, ordinamento, paginazione
    • nuovi controlli RIA
    • validazione
    • operazioni CRUD
  • Pietro Brambati Blog

    Uno sguardo a ASP.NET Dynamic Data – parte 2

    • 14 Comments

    Nel primo post di questa serie abbiamo visto come realizzare una prima applicazione con ASP.NET Dynamic Data (DD). Come dicevo i DD sono pensati per scenari di rapida prototipazione, dove con poco realizziamo un sito completo partendo dalla basedati. Ci tengono a ricordare che questa è solo una possibilità in più, non in meno, possiamo naturalmente partire da zero usando WebForms o, quando sarà rilasciato, ASP.NET MVC e in base ai gusti scrivere più o meno codice oppure optare per un modello piuttosto che per l’altro.

    Nonostante siano pensati per scenari RAD, però, i DD danno una buona possibilità di personalizzazione: in questo post vedremo come:

    • Esporre solo alcune tabelle
    • Visualizzare o meno le colonne delle tabelle esposte
    • Personalizzare il comportamento di visualizzazione delle colonne

    Quali tabelle esporre

    Usando l’attributo scaffoldAllTables nel global.asax abbiamo infatti esposto tutte le tabelle del nostro db. Potremmo, invece, operare selettivamente impostando a false tale attributo e andando a abilitare la/le singole tabelle. Per ogni tabella su db, LINQ to SQL, ha creato una classe partial, che possiamo vedere nel codice del file .dbml. Vediamo ora proprio come estendere queste classi, aggiungiamo un nuovo file Order.cs , che definisce una nuova classe parziale con qualche attributo in più, come mostrato nel seguito:

    image

    Il nuovo namespace System.ComponentModel.DataAnnotation consente di usare l’attributo ScaffoldTalble, con cui possiamo rendere o meno visibile la tabella ai DD. Quindi nel nostro caso abbiamo impostato l’attributo scaffoldAllTables in global.asax a false, mentre abbiamo impostato per la classe Order (e anche Product ) l’attributo ScaffoldTable a true. Se lanciamo l’applicazione ora vedremo “scovate” dai DD due tabelle, come in figura:

    image

    Controllare le colonne che vengono esposte

    Se andiamo a vedere le colonne della tabella Orders, cliccando sul link, notiamo che sono presenti tutte le colonne definite nella tabella, nella figura vedete evidenziata anche la colonna shippedDate, che andremo a modificare nel seguito:

    image

    Se per qualche ragione non volessimo visualizzarla, ecco che possiamo operare sempre sulla classe parziale precedentemente definita, aggiungendo un attributo ScaffoldColumn, dal comportamento intuitivo, come mostrato in figura:

    image

    Questa volta abbiamo dovuto scrivere un po’ di codice in più (bene :-)), definire un MetadataType, una classe nella quale poi definiamo un po’ il comportamento relativo alla colonna ShippedDate. Il comportamento, a meno di errori :-), è quello atteso: se lanciamo il sito e andiamo nella tabella Order, non vederemo più  la colonnaShippedDate, l’attributo in questione, infatti, ha detto ai DD di non visualizzarlo più. Ometto l’immagine, potete immaginare …

    Controlliamo il comportamento delle colonne

    Il comportamento in fase di visualizzazione e modifica dei singoli campi della tabella è definito, come abbiamo visto nel primo post, dai template che si trovano nella directory DynamicData\FieldTemplate, dove trovate come viene visualizzato ogni campo di uno specifico tipo: guardate ad esempio il codice di Boolean.ascx e Boolean_Edit.ascx. Ora, se volessi modificare come vengono visualizzati i campi di uno specifico tipo di tutte le tabelle potrei modificare questi template, ma se volessi operare solo sul singolo campo (ShippedDate ad esempio) di una specifica tabella (Orders) potrei (come ho fatto) sfruttare alcuni meccanismi di estendibilità offerti dai DD. Guardate il pezzo di codice qui di seguito:

    image

    In questo caso sto usando l’attributo DisplayFormat per definire il formato di come deve essere visualizzato il campo in questione (la ShippedDate), in questo caso è una data che verrà visualizzata nel formato mostrato in figura. Inoltre grazie all’attributo UIHint sto indicando ai DD di non usare il template di default per il rendering dell’attributo, ma ho creato un nuovo field template che utilizza il controllo Calendar dell’ AJAX Control Toolkit. Non vi mostro il codice che ho usato per la personalizzazione del controllo, che non è molto, lo sto finendo di preparare per la sessione dei Microsoft Days 08. Il risultato visualizzato è il seguente:

    image
    Dove si nota il calendar in fase di editing della colonna ShippedDate.

    Conclusione

    In questo post avete visto come utilizzare alcune tecniche per personalizzare il comportamento di default dei DD, potendo non solo abilitare\disabilitare specifiche tabelle “scovate” dal runtime, ma anche personalizzando il singolo comportamento di un singolo campo di una specifica tabella, aprendo di fatto a molteplici utilizzi. I DD sono, in oltre, già compatibili con ASP.NET AJAX e anche con l’AJAX Control Toolkit, non ultimo potreste anche voler utilizzare controlli di terze parti per specifiche esigenze…. insomma non male, vero?

  • Pietro Brambati Blog

    Microsoft Days08: le mie sessioni [slide]

    • 13 Comments

    Ormai la prima data dei Microsoft Days08 si avvicina e ora che Silverlight 2 è stato ufficialmente rilasciato, posso darvi i titoli definitivi delle mie sessioni.

    Sarò presente (salute permettendo) a tutte le tappe del tour: Firenze, Roma, Padova, Torino, Milano e Bari e non mi voglio perdere neanche i Community After Hours.

    Potete lasciare commenti e postare le vostre foto dell’evento su Facebook.

    image

    image

    <Materiali>

    Eccole slide delle presentazioni fatte a Firenze, ci vediamo alle prossime tappe …

    SIlverlight 2: pptx, pdf, esempio

    ASP.NET Dynamic Data e IE 8: pptx , pdf, esempio

    </Materiali>

  • Pietro Brambati Blog

    LINQ to SQL vs LINQ to Entities

    • 13 Comments

    In questo post cercherò di spiegare la differenza di approccio nell'uso di LINQ to SQL e LINQ to Entities e per fare questo riprendo il magnifico esempio fatto da Davide Mauri di UGISS [lo User Group Italiano su SQL Server] che mi ha dato l'idea per approfondire l'argomento. Ammetto che è anche una delle domande più frequenti che mi vengono rivolte quando partecipo ad eventi e che spero quindi, almeno in parte, di chiarire.

    In breve la differenza è quella che riprendo dal mio post precedente.

    Per scaricare l'esempio di Davide, seguete il link [Aggiornato]

    LINQ to SQL è una delle implementazioni di LINQ che sono state rilasciate con Visual Studio 2008. LINQ to SQL è il modo più semplice per poter lavorare con SQL Server usando un nuovo modello di programmazione in C# 3.0 e Visual Basic 9. In questo modo nel nostro linguaggio .NET preferito scriviamo del codice che si avvicina ad una sintassi SQL rendendo di fatto meno complicato far "parlare" le nostre applicazioni fatte di classi, clicli e quant'altro con SQL Server, un DBMS relazionale in cui "vediamo" solo tabelle. Con LINQ to SQL in sostanza mappiamo uno a uno le tabelle di SQL Server con delle classi e grazie al framework messo a disposizione siamo in grado di fare le classiche operazioni di Insert, Update, Delete e Query.

    LINQ to Entities è un'altra implementazione di LINQ fatta per parlare con l' ADO.NET Entity Framework (EF), sia l'EF che LINQ to Entities sono attualmente in Beta 3. L'EF è un framework che consentirà agli sviluppatori di lavorare con un maggior livello di astrazione; cioè uno sviluppatore si concentrerà solo sul modello concettuale proprio del modello Entità-Relazione, in maniera indipendente dallo storage sottostante sia esso SQL Server o un altro database. Ad esempio potrò lavorare con un' entità Cliente che potrà mapparsi su uno storage relazione anche su più di una tabella.

    Da questa rapida descrizione emerge almeno una considerazione.

    • Il modello ad oggetti usato con EF è diverso da quello usato dal designer di Visual Studio per LINQ to SQL. Possiamo infatti lavorare usando l'EF con relazioni molti-a-molti. Ad esempio possiamo pensare di avere una relazione del tipo autori-libri (cioè un autore può aver scritto più libri e un libro può essere scritto da più autori). Nell'esempio seguente il concetto sarà più chiaro.

    ok, vediamo di chiarirci meglio le idee sul codice partendo dall'esempio di Davide: in cui trovate lo stesso database utilizzato prima in un progetto che usa LINQ to SQL e poi uno che usa LINQ to Entities e quindi l'EF.

    1) Il Database

    Il nostro database potrebbe essere un semplice modello per rappresentare la realtà di un'ipotetica biblioteca, dove un utente[tabella Users] può prendere in prestito [tabella Loans] un libro. Dal punto di vista del nostro esempio ci interessano però le altre tre tabelle quella dei libri [tabella Books] e quella degli autori [Authors]. Che se concettualmente rappresentano una relazione molti-a-molti,dal punto di vista di un database relazione sono mappati come in figura con relazioni uno-a-molti e molti-a-uno, quindi si usa la tebella di "appoggio" BooksAuthors per mantenere le corrette relazioni.

    image

    Vedremo ora come si comporta il designer di Visual Studio 2008 per creare delle classi su questo database e poi vedremo  come usare EF.

    2.1) Designer di Visual Studio 2008

    Il designer di Visual Studio 2008 ci dà un grande aiuto nel creare le classi, che potremmo creare anche a mano e che di fatto rappresentano il nostro modello applicativo. Se guardate la figura seguente che è il risultato di tale procedura vi accorgerete che le tre tabelle del nostro database sono state mappate uno a uno con le classi che useremo poi nella nostra applicazione.

    Nella figura seguente notate il designer delle classi:

    image

    Ciò provoca la creazione di classi parziali (ad esempio una per Author, una per BookAuhtor e una per Book).

    2.2) Usiamo LINQ to SQL

    Avendo tre classi, che fanno parte del nostro DataContext specializzato, cioè della classe con cui ci interfacciamo a livello di codice per fare le operazioni di query,insert, update e delete, se vogliamo inserire un libro scritto da due autori dobbiamo in LINQ to SQL scrivere il codice seguente:

    image

    In buona sostanza una classe Book, due classi Authors e due classi BookAuthors per mantenere le relazioni. Il codice SQL che viene mandato a SQL Server è il seguente:

    image

    Quello che succede sul database è quello che ci aspettiamo, viene inserito il primo libro poi il primo autore, quindi avendo l'id generato per l'autore viene inserito un record nella tabella BooksAuthors, per mantenere il legame logico molti-a-molti tra autori e libri.

    Vediamo ora cosa cambia con l'EF:

    3.1) Designer dell' Entity Framework (EF)

    Se usiamo il designer dell' EF, attualmente in CTP 2, vediamo come possiamo descrivere il nostro modello applicativo. Ecco che dall'esempio in questione notiamo subito una cosa interessante: cioè nonostante il database sia quello dell'esempio precedente, possiamo mappare relazioni molti-a-molti come mostrato in figura:

    image

    Nella nostra applicazione avremo una classe Book ed una Authors da utilizzare, non più come in precedenza la classe di appoggio. A livello di designer la differenza è che abbiamo mappato la relazione molti-a-molti (**)  sulla tabella di appoggio BooksAuthors.

    3.2) Usiamo LINQ to Entities

    A questo punto usiamo LINQ to Entities per lavorare e inserire un libro associato a due autori. Spero sia chiaro la semplificazione delle istruzioni LINQ che seguono, solo legate alla differenza di approccio concettuale nella strutturazione delle classi. Questo è una delle differenze quando si usa l'EF. Avrei potuto anche mappare il mio database uno-a-uno come fatto con l'esempio di LINQ to SQL, questo è quello che farebbe in automatico il designer se importassimo direttamente il database.

    image 

    In questo caso, il codice per inserire un libro e due autori utilizza un numero inferiore di classi. In LINQ to Entities non esite la possibilità di tracciare il codice SQL mandato sul database direttamente nella console application.

    Conclusione

    Nel post avete visto il diverso approccio usato da EF, LINQ to Entities e LINQ to SQL per affrontare un database semplice come quello presentato. L'esempio tende a porre l'attenzione sul supporto di relazioni molti-a-molti. Questa non è l'unica differenza tra le due implementazioni di LINQ, ma è a mio parere quella più significativa.

    EF permette di descrivere il proprio modello applicativo pensando al Modello Entità-Relazioni. E' possibile mappare poi il modello creato, sulle tabelle del database relazionale sottostante (sia esso SQL Server o un altro DBMS di quelli che saranno supportati dall 'EF). L'architettura realizzata si basa sull'uso di tre file XML, che in questo post non ho descritto e la cui complessità è nascosta dal Designer. In generale EF sarà più adatto (al momento come vi dicevo è in Beta 3, mentre il designer usato è in CTP) ad ambienti in cui viene richiesto il supporto a database diversi da SQL Server e in cui l'evolzione del database stesso avviene spesso ad opera di persone diverse da quelle che scrivono le applicazioni. In questi scenari è tipico avere un elevato numero di tabelle che rappresentano logicamente un'entità (Cliente ad esempio) o relazione di ereditarietà tra queste (Persone e Cliente).

    LINQ to SQL rappresenta la giusta soluzione per realizzare applicazioni RAD o per realizzare applicazioni in cui il mapping più sofisticato di EF non è necessario, in questo scenario LINQ to SQL rappresenta il modo più rapido di lavorare con LINQ e SQL Server.

    Vi consiglio la lettura di questo articolo (in Inglese) per ulteriori approfondimenti e spero che questo post sia almeno parzialmente utile a capire il diverso contesto di utilizzo delle due implementazioni di LINQ.

    Ciao

  • Pietro Brambati Blog

    Windows Live Tools for Microsoft Visual Studio - Parte I

    • 10 Comments

    Nel mio post precedente ho mostrato come sia più semplice
    pubblicare video su Silverlight Streaming grazie al nuovo plug-in scaricabile gratuitamente per Expression Encoder.

    Come utilizzare il video pubblicato in streaming da una nostra applicazione ASP.NET ?

    Windows Live vi permette di farlo in maniere molto semplice: mette infatti a disposizione dei tool (Windows Live Tools for Microsoft Visual Studio è il nome corretto) per Visual Studio 2008 che potete scaricare gratuitamente qui.(Questi tool sono attualmente in CTP).

    imageUna volta scaricati e installati, aprite Visual Studio 2008, quindi New Web Site e trovate un nuovo template: ASP.NET Windows Live Web Site.

    Questo template mette a disposizione un nuovo progetto e una serie di nuovi controlli ASP.NET per realizzare applicazioni usando la piattaforma per sviluppatori Windows Live.

    image

    Nell'immagine a fianco notate la lista dei controlli che consentono di utilizzare alcuni, ad oggi, dei servizi Window Live.  Nel post di oggi mi occuperò di solo uno di questi controlli, quello che va sotto il nome di SilverlightStreamingMedia.

    Facendo drag-and drop del controllo sulla pagina della form, avete la possibilità di configurare facilmente lo skin che andrà a costituire il player all'interno della vostra applicazione, ma soprattuto un facile wizard vi aiuterà ad accedere al  vostro video pubblicato su Silverlight Streaming, come segue:

    image

    Cliccando sul bottone con i tre puntini  (...), come evidenziato in figura, quello che succede è che viene aperta la finestra seguente in cui dopo aver inserito le apposite chiavi che vi vengono generate quando create il vostro account su Silverlight Streaming, potete navigare fino a trovare il video già pubblicato che volete lanciare in streaming.

    image

    A questo punto la vostra applicazione è "bella e pronta", premete F5 per far partire Visual Studio e godetevi il filmato che viene erogato in streaming da Silverlight Streaming e visualizzato da Silverlight nella vostra applicazione web.

    image

    Nel mio calso sto lanciando lanciando l'applicazione dal mio computer in locale, usando l' ASP.NET developer Server, quindi senza necessariamente dover pubblicare l'applicazione su IIS o su un server web esterno, e al contempo sto vedendo il filmato erogato in streaming!

    Quello che è sucesso dopo l'operazione fatta in precedenza è che è stato aggiunto un po' di codice per la gestione del controllo ASP.NET ed inoltre nel file web.config dell'applicazione trovate configurate come parametri le due chiavi usate per accedere al servizio di Windows Live Streaming. In ultimo due reference nella forlder bin del progetto.

    Nella figura seguente trovare il codice generato nel mio progetto(nell'immagine e parzialemente tagliato, ma è giusto per dare un'idea):

    image 

    Conclusioni

    I Windows Live Tools for Microsoft Visual Studio semplificano nel mio esempio la configurazione del palyer per Silverlight e la configurazione verso Silverlight Streaming.

    Se volete vedere e approfondire i servizi alle applicazioni offerti da Windows Live ecco un buon punto da cui partire dev.live.com.

    Ciao

    -Pietro

  • Pietro Brambati Blog

    Come mostrare la vostra 'presenza' on-line sul vostro sito.

    • 9 Comments

    Cioè?

    Riprendo il post di Giuseppe Guerrasio sull'argomento e lo applico al mio blog.

    Windows Live mette a disposizione una vera e propria piattaforma applicativa per noi developer. Un esempio è il Messenger, ormai da tutti utilizzano per comunicare con amici, colleghi etc. Come developer sono sempre stato più interessato a come utilizzare queste tecnologie per scrivere codice.

    Quindi vorrei inserire nel mio blog un' immagine che faccia capiere a chi lo vistita che io sono on-line ed eventualmente comunicare con me, anche se non è tra i miei contatti del Messenger!

    1) Abilito il mio Messenger ad essere contattato da utenti anonimi

    image La prima cosa da fare è abilitare il proprio account Windows Live ID ad essere contattato da utenti anonimi. Seguite il link, che vi porta alla pagina web per le impostazioni del vostro Messenger, quindi fleggate il check-box che abilita i siti web a vedere il vostro stato (on-line, off-line, busy...) del Messenger, quindi cliccate su Save.

    Attenzione: impostando quel flag, siete visibili anche da persone che non fanno parte dei vostri contatti Messenger, quindi se non volete essere contattati in questo modo non impostate questo flag. Ad ogni modo se volete solo fare una prova potete abilitarlo per un periodo di tempo limitato e poi disabilitarlo.

    2) Creo un iframe con Windows Live da inserire nel mio blog

    image Cliccando ora su "Create HTML" la schermata vi produce il codice HTML e JavaScript contenuto in un iframe che serve da inserire nel votro sito (nel mio caso nel mio blog). Io ho scelto di inserire solo l'immagine con il mio stato, ma potrei anche inserire un template di codice HTML che assomiglia alla finestra del messenger, ma senza la lista dei votri contatti, che non verranno quindi visualizzati. Potete anche segliere il colore di sfondo, blu nel mio caso.

     

     

     

     

    imageIl codice dell'iframe da inserire nel mio caso è il seguente (se ne vede solo una parte).

    La costruzione di questo codice si basa sulle Windows Live Presence API, che come il nome suggerisce sono delle API basate su protocollo Http che permettono di mostrare la nostra presenza o meno su internet, ma anche altro. Qui avete il link alla documentazione. La nostra presenza viene ritornata o tramite un'immagine o tramite del codice codificato usando JSON (JavaScript Object Notation): il formato della chiamata che viene fatta alle Presence API è il seguente.

    http://messenger.services.live.com/users/[ID]/[resource]/[?queryparameters]

    dove l'ID, cancellato in figura, è un ID che rappresenta l'utente di cui si vuole verificare la presenza.In resource è possibile richiedere che la presenza dell'utente venga restituita in formato JSON o venga restituita un'immagine. Se viene usato il parametro cb, che non è visibile in figura, il JSON resituito viene passato alla funzione di callback indicata dopo il parametro stesso, che nel nostro caso è la funzione contenuta nel file javascript referenziato in src del tag script in alto (PresenceButton.js). Se volete tutti i dettagli di come è possibile usare le Presence API, ecco qui.

    Il codice generato funziona com IE 6 e 7, Firefox 1.5 e 2 su Windows e MAC.

    3) Aggiungo il tutto al mio blog

    image Fatto questo aggiungo nelle news del mio blog l'iframe generato. Se cliccate sul bottone, vi si apre il messenger per parlare con me ...

     

     

     

     

     

     

    4) Comunico con me stesso !

    A questo punto si apre una nuova finestra del browser che contiente il Messenger per comunicare con me. In questo momento sto simulando la chiamata di un utente anonimo dalla mia macchina al mio messenger sulla stessa macchina.

    image

    Cliccate su Begin a Conversation, scegliete uno username e dopo aver inserito un C.A.P.T.C.H.A come in figura potete inviare un messaggio al mio messenger

    image

    In quest'ultima immagine vedete il Messenger dell'utente anonimo (aperto in una schermata del browser) e il mio Messenger vero e proprio che riceve il messaggio dell'utente anonimo!

    image

    Conclusione

    Le nuove API di Windows Live per il rilevamento della presenza on-line consentono di poter usare strumenti di comunicazione diffusi come Live Messenger e integare le informazioni sulla presenza nelle applicazioni web.

    Con il controllo IM è anche possibile invitare utenti a condividere il loro stato su un sito web. Trovate un esempio dell'uso, in questa quick app che potete provare live qui e di cui potete scaricare i codici sorgenti qui.

    -Pietro

  • Pietro Brambati Blog

    Uno sguardo a Silverlight

    • 9 Comments

    Microsoft ha da poco annunciato Silverlight. Una nuova tecnologia, precedente nota come WPF/E, per lo sviluppo di applicazioni web. Con Silverlight è possibile includere contenuti multimediali di natura diversa, offre supporto per grafica vettoriale 2D e molto altro ...

    Aprite questo link per farvi un'idea .. non necessariamente con IE.

    Cos'è?  Da un punto di vista architetturale Silverlight è un plug-in per il browser che offre una versione "ridotta" di WPF (Windows Presentation Foundation), che però è cross-browser e cross-platform e che quindi non richiede di avere sulla macchina installato il .NET Framework 3.0 e non richiede che sia usato solo Internet Explorer come browser. Infatti è possibile utilizzare come browser anche Firefox, Safari, Opera e può funzionare sia su piattaforma Windows che MAC.

    Attualmente sono disponibili due preview di Silverligh, la 1.0 (in versione Beta) e la 1.1 ( in alpha).

    Silverlight 1.0

    • plugindi circa 1.2 MB
    • si integra facilmente con le applicazioni AJAX, dato che con codice Javascript si può aggiornare sia HTML che il codice XAML
    • supporto per codec VMV, WMA, MP3 e VC-1, quest'ultimo permette di avere video di alta qualità (è lo stesso formato supportato da HD-DVD e Blueray DVD).
    • E' possibile scaricare una preview CTP di Expression Blend 2 e Expression Media Encoder se volete comincaire a realizzare un'applicazione con Silverlight e siete dei designer. Se siete invece più avvezzi all'uso di Visual Studio scaricate le ASP.NET Futures  (May CTP). Ad ogni modo trovate la lista completa di quello vi può servire per sviluppare con Silverlight qui, compreso il link per scaricare la Beta 1 di "Orcas", che contiene il template per un progetto Silverlight.

    Silverlight 1.1

    Con la versione 1.1 di Silverlight vengono aggiunge numerose altre funzionalità: in particolare il plug-in contiene un'implementazione del .NET Framework (CLR+BCL) e anche un DLR (Dynamic Language Runtime). Infatti è possibile sviluppare non solo usando i consueti linguaggi .NET (C#, VB), ma anche usando linguaggi dinamici come Python e Ruby. 

    • Il CLR è derivato direttamente da quello della versione completa di .NET Framework e include lo stesso sistema dei tipi, Garbage Collector, JIT etc
    • Include il supporto per una vasta serie di librerie: IO,Networking, LinQ, Generics
    • Managed HTML DOM API: cioè è possibile usare codice .NET per scrivere codice managed che interagisca con l'HTML della pagina
    • il tutto in soli 4MB di spazio!

    Ecco una visione d'insieme:

    Silverlight Architecture

    Per maggiori dettagli sull'architettura, consultate questo link.

    In sintesi Silverlight permette di usare in modo combinato sfruttando diverse tecnologie:

    • XAML per sfruttare tutta la potenza del 2D di WPF. La più grande differenza tra WPF e Silverlight è che, quest'ultimo non supporta il 3D, però permette una maggiore adozione essendo cross-broser e cross-platform.
    • JavaScript e alle estensioni a Javascript che permettono un maggior controllo della UI dell'applicazione web.
    • Integrazione con ASP.NET AJAX
    • Possibilità di utilizzare linguaggi managed e dinamici per lo sviluppo

     

    Da dove iniziare ? qui.

    -Pietro

  • Pietro Brambati Blog

    LINQ to SQL - Parte I

    • 9 Comments

    LINQ rappresenta una delle novità più importanti per lo sviluppo nella prossima release di Visual Studio.

    LINQ è una serie di estensioni al linguaggio, sia per C# che VB.NET, che ci permettono di utilizzare degli operatori "alla SQL" per lavorare su diverse sorgenti dati.

    Questa è la terza parte di una serie di post. Negli altri post ho affrontato i segueti argomenti:

    Ora vi racconto l'implementazione di Linq più interessante: LINQ to SQL. LINQ to SQL ed il designer di Visual Studio 2008 sono pensati per reallizzare applicazioni che usano SQL Server come database. Il designer genera molto del codice che fare a mano sarebbe tedioso, ma al contempo ci lascia la possibilità di intervenire con soluzioni più mirate, dandoci la possibilità di cambiare o estendere il codice generato.

    LINQ to SQL

    Linq to SQL vi permette di utilizzare la sintassi vista in precedenza per interrogare SQL Server, la query espressa verrà poi convertita in una chiamata ADO.NET. Visual Studio 2008 mette a disposizione nell' IDE  un designer che ci aiuta, a partire da un database SQL Server esistente, a mappare le tabelle alle classi che useremo nella nostra applicazione.

    Configuriamo Northwind

    Negli esempi seguenti userò come database  il famosissimo Northwind, che potete scaricare qui.  Come DBMS ho usato SQL Server 2005 Express Edition SP2, che potete scaricare gratuitamente; allo stesso link potete trovare anche la SQL Server Management Studio Express, l'applicazione client per l'amminstrazione.

    Aggiungiamo il database Northwind alla lista di quelli gestiti da SQL Server Express. Apriamo la console di SQL Server Management Studio Express.

    image

    Tasto destro su Databases, quindi Attach, appare la schermata sopra in figura, dove possiamo aggiungere il file Northwnd.MDF: premere il tasto Add ... e quindi scegliere la directory in cui è copiato il file.

    Alla fine il nostro database verrà aggiunto alla lista di quelli gestiti. Chiudiamo il Management Studio.

    Creiamo l'applicazione di test con Visual Studio 2008 ed usiamo il designer

    Creiamo ora una console application con Visual Studio 2008, in VB.NET o in C#.  Aggiungiamo alla lista delle connessioni in Visual Studio quella al database Northwind che verrà visualizzata nel Server Explorer (per visualizzarlo View -> Server Explorer). Quindi premendo il bottone "connect to database" possiamo visualizzare direttamente da Visual Studio il nostro database e avere accesso agli elementi che lo costituiscono: tabelle, store procedues, viste etc.

    image

    Per accedere al Designer che ci consente di effettuare il mappaggio delle tabelle alle classi aggiungiamo un nuovo item, tra la lista dei templates troviamo LINQ to SQL Classes come mostrato in figura.

    linq2_thumb[4]

    Una volta rinominato il file in Northwnd.dbml e aggiunto al progetto, l' IDE di VS 2008 ci dà la possibilità di fare il drag-and-drop delle tabelle del database al fine di costruire le classi ad esse associate. Così in figura ho fatto il drag-and-drop delle tabelle Products, Categories, Orders, Customers che hanno generato le relative classi Product, Category, Order e Customer.

    image

    Se diamo un'occhiata ai file del nostro progetto vedrete che sono stati aggiunti tre file, se aprite il file Northwind.designer.cs potete notare che cosa ha creato il designer di Visual Studio.

    Vi faccio notare che è stata generata una classe NorthwindDataContext che deriva dalla classe DataContex. Come vedrete a breve la query che faremo sul database sarà sullo stile di quelle viste con Linq To XML e Linq to Objects. La classe DataContext ha la funzione di "mascherare" la connessione verso il database e di rendere possibili le operazioni di aggiornamento verso il database. Ogni tabella del nostro database sarà accedibile come proprietà pubblica di questa classe e sarà, a sua volta, una classe di tipo Table. Ad esempio ci sarà la possibilità di accedere alla classe Products che è di tipo Table<Product>. La classe Product viene descritta nel prossimo paragrafo. In breve quindi la classe DataContext è l'entry point per poter utilizzare Linq To SQL.

    Come funziona il mapping del designer tra il database e le classi ?

    Sempre all'interno del file generato trovate una serie di attributi che specificano il mappaggio con il database, le tabelle e le classi.  La classe NorthwindDataContext viene mappato sul database Northwind. 

    image

    La classe Product viene  mappata sulla tabella Products.

    image

    All'interno della classe Product la proprietà ProductID viene mappata sulla corrispondente colonna della tabella del db e vengono inoltre indicate altre caratteristiche: ad esempio che è un chiave primaria ed il tipo che la rappresenta nello schema del db. L'attributo AutoSync stabilisce che relazione di sincronizzazione ci deve essere tra la proprietà dell'oggetto e la row del db. Nel nostro caso la proprietà dell'oggetto viene valorizzato quando un prodotto viene effettivamente inserito nel database, notate che sul database la colonna è una IDENTITY. Qui il dettaglio sull'attributo Column.

    image

    Il mappaggio che abbiamo visto si basa sul fatto che le classi della nostra applicazione ad esempio Products, che useremo con LINQ, sono mappate tramite una serie di attributi al nostro database. Questa non è l'unica soluzione adottabile: è infatti possibile disaccopiare la classe dall'attributo che la mappa sul database e usare un file XML per effettuare tale mappaggio, ma questo sarà un argomento di un altro post ...Per chi vuole subito informazioni su come costruire il proprio modello ad oggetti con Linq To SQL, segua il link.

    Una semplice query ...

    Vogliamo ora ottenere il nome dei prodotti della categoria "Beverages", scriviamo quindi:

    C#:

    image

    Cosa c'è da notare?:

    Ho aggiunto il namespace a System.Data.Linq; per utilizzare le estensioni al linguaggio per Linq To SQL

    Notatate che p è di tipo Products, cioè una classe con un tipo ben preciso, quello che abbiamo visto nei paragrafi sul mappaggio, inoltre da p posso accedere non solo alla proprietà Category, ma anche al nome della categoria stessa! Se andiamo a vedere la tabella Products sul database ci accorgiamo che contiene solo la colonna CategoryID che in relazione con la chiave primaria della tabella Categories. E' proprio in questa tabella che si trova la colonna CategoryName.

    image

    L'output dell'applicazione è il seguente: la lista dei prodotti della categoria cercata:

    image

    in VB.NET:

    image

    la cui logica è equivalente a quella vista in precedenza.

    Che codice SQL viene generato e quando ?

    Penso di prevedere una vostra domanda, anzi due.

    Per vedere il codice generato, inseriamo la seguente riga di codice e rieseguiamo l'applicazione:

    image

    Come vediamo ora nella console application viene mostrato il codice SQL che viene eseguito in SQL Server:

    image

    Come vedete viene eseguita una prima chiamata SELECT in LEFT OUTER JOIN tra la tabella Products e la tabella Categories, questo perchè è solo in quest'ultima tabella che troviamo il nome della categoria. Ricordate quanto è stato semplice con Linq scrivere p.Category.CategoryName, senza preoccuparci del Join tra le tabelle. Il modello ad oggetti offerto forniva già la possibilità di navigare in relazioni 1 a molti. La seconda query è stata generata perchè abbiamo voluto avere il nome della categoria nel ciclo for each. Operazione che certamente potevamo evitare, almeno in questo semplice esempio.  

    Quando viene eseguita la query sul database? Se mettiamo un break-point (F9) sul cliclo foreach nell'esempio di codice, potremmo essere sorpresi di una cosa. Se guardiamo infatti la console application non vediamo ancora visualizzato il codice di esecuzione su SQL. Questo perchè non è ancora stato eseguito! Infatti nostante ci potremmo aspettare che il codice Linq viene immediatamente tradotto in codice SQL standard, non è così. Premiamo F10 un po' divolte e ci accorgiamo che il codice viene eseguito quando serve, cioè durante l'enumerazione del ciclo. Linq utilizza un modello di esecuzione differtita (deferred execution). Questo perchè LINQ analizza le operazioni che fino a quel momento sono state eseguite prima di comporre la query. In certi scenari questo comportamento è sicuramente desiderabile, in altri sarebbe desiderabile l'opposto. E quindi possibile eseguire la query una volta e riutilizzarla successivamente. Per fare questo è sufficiente convertire il risultato della query in una collezione standard usando gli operatori ToList() o ToArray().

    In breve ...

    In questo primo post abbiamo visto come, in pochi semplici passi, possiamo trarre beneficio da Linq to SQL e dal O/R (Object Relational) Designer di VS 2008. L'uso di quest'ultimo è sicuramente di aiuto nello sviluppo di applicazioni RAD e in alcuni scenari non riechiede di scrivere codice ulteriore a quello già generato. Tuttavia nei prossimi post vedremo come personalizzare il codice gerato per adattarlo agli scenari di altri tipi di applicazioni.

    Linq to SQL ci consente di accedere ai dati in modo diverso da quello fatto tradizionalmente con ADO.NET, realizzando uno strato di software per l'accesso ai dati, che ci consente di mappare uno a uno classi e tabelle di un database SQL e di lavorare a livello applicativo concentrandoci solo sugli oggetti senza preoccuparci troppo della struttura del nostro database SQL Server.

    Nelle prossime "puntate":

    Nei prossimi post vedremo come fare operazioni di scrittura sul database e come estendere e modificare il codice generato in automatico.

    Link utili:

    In questo articolo LINQ to SQL viene presentato in modo chiaro e completo.

    LINQ to SQL: .NET Language-Integrated Query for Relational Data (articolo MSDN in inglese)

    Percorso:

    Per chi non ha seguito passo-passo consiglio il seguente percorso con laboratori:

    1. Scaricare la beta 2 di Visual Studio 2008
    2. Laboratori di Linq in C#
    3. Laboratori di Linq in VB.NET

    Ciao e alla prossima.

    -Pietro

  • Pietro Brambati Blog

    Windows Academic Program .... il kernel di Windows

    • 8 Comments

    Ciao, ho già fatto un post sull'argomento, ma in occasione dell' estate io e Mauro, new entry nel team, abbiamo deciso di parlarne più diffusamente.

    WAP è un programma per le università pensato per l'insegnamento del kernel di Windows nei corsi di sistemi operativi.  Si compone di tre parti:

    • Curriculum Resource Kit (CRK): slide per tenere un corso di sistemi operativi. Le slide sono divise in moduli, in modo da poter essere utilizzate anche solo in parte. Ci sono anche laboratori, quiz etc.
    • Windows Research Kernel (WRK): i sorgenti del kernel di Windows 2003 SP1 (x86,x64) e Windows XP(x64), con un ambiente di build per la compilazione e le istruzioni per l'installazione su una virtual machine con Virtual PC.  Scusate ... nel video ho sbaglio il nome del WRK .... ho proprio bisogno di ferie.
    • Project OZ: un semplice sistema operativo per fare esperimenti ...

    Nel video potete saperne di più... e vedere la compilazione del kernel di Windows incluso nel WRK!

    Video: Windows Academic Program

    Per i docenti è inoltre da poco attivo un sito web a loro dedicato: il Faculty Connection, dove possono recuperare materiale didattico sulle tecnologie Microsoft, compreso il WAP.

    Scusate per la scarsa qualità audio/video del filmato, ah... per la cronaca ... io sono quello con la maglietta nera Imagine Cup :-)

    -Pietro

  • Pietro Brambati Blog

    Percorso formativo su LINQ e le novit&amp;#224; dei linguaggi .NET

    • 8 Comments

    linq6Da qualche giorno abbiamo lanciato il nuovo percorso formativo dedicato alle novità dei linguaggi .NET (C# 3.0 e VB 9) e a LINQ. Da ieri sono disponibili tutti i video scaricabili sul PC, oltre che la visione in streaming.

    Come anticipato è la prima volta che usiamo questo nuovo "format" in cui i video sono scaricabili da subito.

    Rimane l'ultimo webcast di Q&A a cui vi invito a partecipare.

    Ecco gli argomenti trattati:

    • LINQ: Introduzione
    • C# 3.0: Novità del linguaggio
    • Visual Basic 9: Novità del linguaggio
    • LINQ to Objects – Parte 1
    • LINQ to Objects – Parte 2
    • LINQ to SQL
    • LINQ to XML
    • LINQ e ASP.NET

    Buona visione.

    -Pietro

  • Pietro Brambati Blog

    IIS 7 URL Rewriter Tech Preview 1

    • 8 Comments

    Una domanda tipica che mi viene fatta quando parlo di IIS 7 è se esista qualche meccanismo di rewrite degli url già fatto.  Un meccanismo/engine di rewrite degli url può avere diverse funzionalità, come quella di mascherare l’url “vero”, che gestisce la nostra richiesta, di rendere più facile da ricordare un url, piuttosto che facilmente indicizzabile da un motore di ricerca.

    Bene, da poco è disponibile una Techical Preview per IIS 7 di un modulo di URL Rewrite.

    Queste le funzionalità:

    • Motore basato su regole: a fronte di una richiesta http è possibile definire una regola per il match dell’url e definire quindi un’azione (Rule Action) da intraprendere.
    • Supporto alla sintassi delle regular expression e wildcard per il riconoscimento dell’url (pattern matching)
    • Le regole possono essere definite a livello globale ( nel file applicationHost.Config) o a livello locale (usando il file web.config)
    • Accesso agli header http e alle server variable, che possono essere usate per le scelte da intraprendere
    • Rule Actions: un’azione può far intraprendere diverse strade: abort di una request, invio di un codice custom al client etc.
    • Rewrite Maps: possibilità di definire coppie nome-valore tra url ricevuto come richiesta http e url che effettivamente viene eseguito.
    • UI integrata nella nuova console di IIS 7.
    • Tool per importare regole di rewrite definite con mod_rewrite di Apache.

    Per provarlo:

    Installate il file msi da uno dei link riportati sotto ( per piattaforma x86 e x64):

    image

    Ora aprite la console di IIS 7 (io sto usando Vista SP1, ma potete usare anche Windows Server 2008) e troverete una nuova opzione

    image

    Premendo add Rule nella scherma successiva potete ora creare una nuova regola , con le modalità elencate sopra

    image 

    A questo link trovate un tutorial che vi guiderà passo-passo nella realizzazione di una semplice regola, ma dove comunque vengono messe in luce le funzionalità di questo modulo.

    Potete anche vedere come realizzare una permalink per WordPress su una macchina configurata con FastCGI e WordPress.

     

    Link utili:

    Annuncio BillS IIS blog

    Tutorial: Using Url Rewrite Module

    Url Rewrite Module Configuration

    Download x86 CTP per IIS 7.0: http://www.iis.net/downloads/default.aspx?tabid=34&g=6&i=1691

    Download x64 CTP per IIS 7.0: http://www.iis.net/downloads/default.aspx?tabid=34&g=6&i=1692

  • Pietro Brambati Blog

    Windows Live Tools for Microsoft Visual Studio - Parte III

    • 7 Comments

    Nei precedenti post sull'argomento avete visto un'introduzione a come utilizzare i controlli SilverlightStreamingMediaPlayer e Contacts presenti nei Windows Live Tools for Microsoft Visual Studio 2008 che sono attualmente in CTP.

    Ora vediamo gli altri due IDLogin e IDLoginView, che permettono di utilizzare molto semplicemente Windows Live ID in un'applicazione web.

    Windows Live ID è il servizio di autenticazione e identificazione delle utenze di Windows Live utilizzabile sia nelle applicazioni web che client tramite opportuni SDK. Windows Live ID vi permette di accedere con un unico account a tutti i siti che utilizzano Windows Live ID o ai servizi Windows Live.  Potete scaricare l'SDK per utilizzare Windows Live ID da una qualsiasi applicazione web, anche non .NET, al momento Java, Perl, PHP, Python, Ruby.

    Se lavorate con ASP.NET potete trarre vantaggio da i due controlli che vi introduco brevemente oggi. Questi controlli estendono i corrispettivi controlli ASP.NET 2.0 che permettono di interagire direttamente con il provider ASP.NET della membership. In questo modo abbiamo la possibilità di:

    • integrare facilmente Windows Live ID in un'applicazione Web
    • se usiamo già la membership di ASP.NET, il nostro sito ha già degli utenti profilati, possiamo chiedere così all'utente di associare il proprio account all' account Windows Live ID ed implementare dunque un'unica autenticazione. Il nostro utente si troverà loggatto contemporaneamente al nostro sito e con Windows Live ID.

    La prima cosa che faremo nel nostro esempio e creare un semplice sito d'esempio che sfrutta alcuni dei servizi di membership a cui poi, questa è la parte più nuova, andremo ad aggiungere l'integrazione con Windows Live ID tramite i due nuovi controlli.

    Nota: L'esempio non è esaustivo di tutti i servizi offerti da ASP.NET 2.0 per autenticazione/autorizzazione nè sul funzionamento interno delle API e Servizi descritti.Per seguire l'esempio è necessario aver installato Visual Studio 2008 o Visual Web Developer 2008 e SQL Server 2005 Express Edition ed i Windows Live Tools December CTP.

    1) Creiamo un sito che utilizza la Membership di ASP.NET

    imageCreiamo il nostro sito web utilizzando il template Windows Live, come già mostrato qui che troverete dopo aver installato i tools. Trovate ora i controlli di ASP.NET 2.0 per lavorare con la membership nella toolbox sotto il tab Login. Un approccio che possiamo seguire nel nostro esempio è quello di utilizzare l'ASP.NET Web Site Administration Wizard, cliccando sul bottone che vedete in figura e che apre una nuova istanza del browser con un'applicazione web che permette di abilitare i servizi di membership sul sito web che andiamo a costruire.

    1.1) Configurazione del sito e creazione di un utente

    Essendo l'argomento già noto, metto ora alcuni screen-shot dei passi che seguo per la creazione del sito di esempio. Potrete poi trovare l'intero esempio scaricabile alla fine del post.

    image

    image

     image

     image

     image

    Dopo aver seguito il wizard, quello che è successo alla vostra applicazione è che viene creato un database che trovate sotto la cartella App_Data, che ha il nome ASPNETDB. MDF e viene inoltre modificato il file web.config per abilitare i servizi richiesti. In questo momento solo l'autenticazione di tipo Form.

    image

    1.2) Uso dei controlli di Login di ASP.NET 2.0

    Aggiungiamo una pagina di Login.aspx e facciamo drag&drop del controllo Login che fornisce un controllo con le textbox ed i bottoni necessari per interfacciarsi con le API di Membership ed effettuale la login dell'utente creato in precedenza.

    image

    Nella pagina di Default.aspx aggiungiamo invece il controllo LoginStatus, come mostrato in figura. Possiamo inserire anche il controllo LoginName, che ci darà informazione sul nome dell'utente una volta che questo si è autenticato.

    image

    Ora se lanciamo la nostra applicazione sulla pagina di Default.aspx, il controllo precedentemente inserito ci dice che non siamo autenticati indicando un link con la scritta Login. Seguendo il link si viene indirizzati alla pagina di login.aspx. Inserite e validate le credenziali ritorniamo alla pagina Default.aspx. Questa volta autenticati, il link precedente ha ora cambiato la scritta da Login a LogOut e se abbiamo inserito il controllo LoginName ora appare il nostro nome o meglio quello dell'utente che abbiamo creato in precedenza.

    Cosa succede se inseriamo il controllo dei Contatti visto nella seconda parte di questa mini-serie ?

    L'utente del nostro ipotetico sito si troverà nella condizione di dover autenticarsi con Windows Live ID per poter utilizzare il controllo dei contatti ed autenticarsi con il proprio account per usufruire dei servizi del sito, possiamo vedere l'immagine seguente in cui l'utente sta navigando come anonimo nel sito e vede il controllo dei contatti che chiede l'autenticazione e anche il link alla Login con il proprio account del sito.

    image

    Se effettua la login con il suo account del sito deve poi loggarsi con l'account Windows Live ID per poter avere a disposizione i propri contatti del Messenger.Quello che vogliamo fare e fare in modo che l'utente possa associare il suo account Windows Live ID con quello offerto dalla Membership.

    2) Aggiungiamo il controllo IDLoginStatus e IDLoginView

    Cominciamo ad usare i nuovi controlli di Windows Live. Questi controlli estendono i corrispondenti controlli di ASP.NET aggiungendo la necessaria integrazione con WL ID.

    Inseriamo dunque il controllo IDLoginStatus, clicchiamo su new Application ID. Avere un Application ID è necessario. Quello che va fatto è registrare l'url alla pagina del nostro sito a cui verremo rediretti dopo l'autenticazione tramite Windows Live. Nel nostro esempio usiamo un url locale: localhost, con la porta utilizzata dall' ASP.NET Development Server di Visual Studio. Ricordiamoci di impostare come fissa la porta, che altrimenti verrebbe rigenerata da VS ad ogni riavvio dell' ASP.NET Dev Server: nelle properties del sito, Use Dynamic Ports: impostare a false. Dopo questa operazione Windows Live sarà in grado di riportarci sul nostro sito dopo l'autenticazione dell'utente.

    Dopo aver aggiunto il controllo, sempre in Visual Studio 2008, clicchiamo su Create new Application. Si apre una finestra per la registrazione. Loggiamoci con WLID, quindi possiamo registrare una nuova applicazione come mostrato in figura. Tra le informazioni importanti ci sono il Return Url e una chiave segreta che può essere rigenerata. In figura è illustrato parte del processo.

    image

    Il Wizard creerà l'"Application ID" che insieme al "Secret" verranno impostati nel file web.config: cercate wll_appid e wll_secret. In figura sono evidenziati solo alcuni dei campi necessari per la registrazione della nuova applicazione ...

    Nella nostra pagina Default.aspx avremo un link in più "Sign-in", premendo il quale effettuiamo l'autenticazione tramite Windows Live ID, con l'effetto che una volta ritornati nella pagina anche il controllo dei contatti risulterà già autenticato, come mostrato in figura in cui si vede che siamo loggati per Windows Live, ma non con l'account del nostro sito.

    image

    Aggiungiamo ora alla nostra pagina il controllo IDLoginView, questo controllo, che come già detto estende il controllo standard LoginView, si basa sull'uso di template (di codice dichiarativo) che vengono visualizzati in diversi stati della pagina.

    • AnonymousTemplate: viene presentato all'utente se non è autenticato
    • LoggedInTemplate: se l'utente è loggato con il suo profilo della membership di ASP.NET
    • LoggedInIDTemplate: se l'utente è loggato con il suo account Windows Live ID
    • LoggedInAlltemplate: se l'utente è loggato sia con il suo account ASP.NET che Windows Live.
    • AssociateTemplate: viene chiesto all'utente se vuole associare il suo account ASP.NET a quello di Windows Live ID

    Quest'ultimo template è quello che fa al caso nostro. Il comportamento è influenzato dalla proprietà AutomaticallyAssociateAuthentication, che se impostata a true chiede all'utente di fare l'associazione la prima volta che l'utente si logga con entrambe le modalità

    Nell'immagine seguente si vede il codice del controllo IDLoginView con i vari template:

    image

    Nel file web.config troverete configurato il provider LiveMembershipProvider. Spostando inoltre il controllo dei contatti nel template LoggedInAlltemplate, posso ad esempio visualizzarlo solo in quel particolare "stato" della mia applicazione.

    Ma vediamo quale può essere una possibile interazione dell'utente: 1) Si logga con il suo account ASP.NET 2) Si logga con il suo account Windows Live 3) Dà il consenso all'associazione, come mostrato in figura:

    image

    Dalla figura si nota che sono autenticato sia con l'account ASP.NET che Windows Live ID, infatti i due controlli LoginStatus e IDLoginStuatus mi danno la possibilità di fare la logout e la sign-out rispettivamente. Premendo ora sul tasto yes avviene l'associazione vera e propria.

     

    Dopo aver dato il consenso all' associazione ecco il risultato atteso.

    image

    Da questo momento in poi il mio account Windows Live ID è associato all'account ASP.NET. Quindi se mi loggo premendo il link sign-in mi loggo contemporaneamente con il mio account del sito e con Windows Live. Mentre se seguo il solo link LogIn mi loggo solo con l'account di ASP.NET come in precedenza.

    Conclusione

    In questo ultimo post della serie abbiamo visto come utilizzare i controlli IDLoginView e IDLoginStatus per integrare in modo semplice e rapido il sistema di autenticazione Windows Live ID in un sito web che utilizzi il sistema di membership di ASP.NET. Il risultato è che un utente che abbia un account Windows Live ID che già utilizzi per accedere a siti che supportano WL possa utilizzarlo anche con il nostro sito d'esempio, previa un'associazione di account. L'utente potrà comunque mantenere il suo account "standard" del sito e utilizzarlo in modo indipendente.

    Se volete altre informazioni sulla piattaforma Windows Live per sviluppatori vi consiglio di partire da dev.live.com.

    Download Esempio

    Vi allego per comodità l'esempio che ho costruito durante il post. Spero possa essere d'aiuto.

  • Pietro Brambati Blog

    Parliamo di LINQ ...

    • 7 Comments

    Dopo il rilascio della beta 2 di Visual Studio 2008, penso sia giunta l'ora di cominciare a parlare di LINQ anche nel mio blog  e quindi inauguro una nuova categoria.

    LINQ (language integrated query) rappresenta una delle novità più importanti introdotte con il .NET Framework 3.5. In poche parole rappresenta un nuovo modello di programmazione con cui possiamo usare una sintassi "alla SQL", per intenderci, direttamente da C# o da VB.NET. Questa nuova sintassi non si applica solo per interrogazioni eseguite su database relazionali, ma anche alle collezioni di oggetti e all' XML.

    Pensando a VS 2008 è interessante approfondire almeno le seguenti implementazioni di questo modello di programmazione:

    • LINQ to Objects
    • LINQ to XML
    • LINQ to SQL
    • LINQ to DataSet

    LINQ si basa su delle estensioni al linguaggio che rendono possibile implementare lo stesso approccio di programmazione anche verso altre sorgenti dati.

    Vediamo qualche semplice esempio con VS 2008 per capire meglio, partiamo da LINQ to Objects, nei prossimi post mi occuperò delle altre implementazioni. LINQ to SQL ed il supporto offerto da VS 2008 in particolare è sicuramente una degli aspetti più intersessanti e di maggior utilità in molte applicazioni.

    LINQ to Objects

    Creiamo una semplice console application in C# 3.0. Notiamo come prima cosa la presenza di un nuovo namespace System.Linq. Creiamo una semplice array di stringe e poi usiamo LINQ per effettuare un'operazione di filtraggio

    linq1

    Da queste poche righe notiamo alcune cose importanti: abbiamo utilizzato LINQ per filtrare un array di stringhe, nell'esempio è molto chiaro cosa vogliamo ottenere e la sintassi che usiamo assomiglia molto a quella che avremmo usato per fare una query su un database. Nel codice f è una stringa e anche l'IDE di VS lo riconosce come tale.

    linq5

    Notate che f ha il metodo StartWith, normalmente presente per le stringhe e nella figura anch VS la riconosce con l'IntelliSense.

    Una nuova keyword "var" appare nel codice in C#. Grazie all'uso di var il compilatore stabilisce il tipo della variabile a partire dalla sua dichiarazione. Quindi la variabile nell'esempio è una stringa. Allo stesso modo scrivendo "var i = 1; var b = true;" il compilatore è in grado di inferire che la variabile i è un intero e che b è di tipo boolean.

    L'output del nostro programma è quello che ci aspettiamo la variabile fruttiPreferiti contiene le due stringhe che iniziano con la lettera "m", cioè mela e mandarino.

    Avremmo potuto utilizzare non solo stringhe ma anche dei tipi custom, come ad esempio una lista di clienti e effetuare altre operazioni utilizzando altri operatori standard di LINQ, si veda ad esempio il seguente codice:

    linq4

    Nell'esempio di codice sopra riportato si vuole ottenenere la lista dei clienti odinati in modo discendente di sola nazionalità italiana.

    Notiamo alcune cose interessanti: nella classe cliente le proprietà sono dichiarate con una sintassi semplificata. Anche questa è una delle novità introdotta dal C# 3.0. Comoda vero?

    Nella creazione della lista clienti i nuovi clienti sono creati e allo stesso tempo sono inizializzate le proprietà Nome e Nazione. Questo nuovo costrutto del linguaggio viene chiamato Object Initializer. Notate che la classe Cliente, non ha costruttori a cui passare i due parametri per inizializzare le proprietà. 

    Infine ho utilizzato due nuovi operatori orderby e descending, il cui significato mi sembra scontato.  Alla fine ecco l'output della nostra applicazione:

    image

     Usiamo VB.NET

    Fino ad ora abbiamo scritto il codice utilizzando C# ed in particolare il C# 3.0 con alcune delle nuove estensioni al linguaggio, come la keywork var, la generazione automatica delle proprietà e l'Object Initializer. Tuttavia anche VB.NET mette a disposizione le stesse estensione e altre nel nuovo VB.NET 9.0.

    Ecco un esempio:

    image

    Da notare:

    La classe Person non ha costruttori. Abbiamo creato una lista di people ed abbiamo usato anche in questo caso l'Object Initializer per creare istanze delle classe e inizializzare le relative proprietà, notate l'uso delle parentesi graffe.

    Anche in questo caso il compilatore è in grado di inferire il tipo diteeagers e di teen usato nel ciclo For Each.

    Ecco infinre l'output:

    image

    Da dove partire ...

    Spero di avere stimolato la curiosità di chi si avvicina per la prima volta a LINQ. Per chi vuole cominciare a fare qualche prova consiglio questo percorso:

    1. Scaricare la beta 2 di Visual Studio 2008
    2. Laboratori di Linq in C#
    3. Laboratori di Linq in VB.NET

     

    Qualche link utile

    The LINQ Project

    Esempi VS08 Beta 2, anche HOL (laboratori) su LINQ

    C# 3.0 Language Specification

     

    Interessante vero? Ai prossimi post su LINQ.

    -Pietro

  • Pietro Brambati Blog

    Visual Studio 2008 e le versioni del .NET Framework

    • 6 Comments

    Ho ricevuto alcune domande riguardanti le versioni del .NET Framework installate con VS 2008 e vorrei tentare di fare un po’ di chiarezza, spero J…

    Con Visual Studio 2005 uscì la versione 2.0 del .NET Framework, cioè la v2.0.50727

    Poi uscì Windows Vista con cui fu rilasciata la versione 3.0 del .NET Framework che in sostanza aggiungeva i seguenti componenti: WCF, WPF, WF e WCS.

    La versione 3.5 del .NET Framework aggiungerà altre funzionalità che andranno ad appoggiarsi a quelle del Framework 3.0. Quindi potremmo vedere la cosa in questo modo, come illustrato in figura:

    image

    Come potete notare dalla figura ho evidenziato per le versioni di NET 3.0 e 2.0 anche il terzo e quarto gruppo di numeri: infatti l’installazione di .NET 3.5 porta con sè degli aggiornamenti anche per le versioni 2.0 e 3.0 di .NET, tali aggiornamenti riguardano in generale fix e miglioramenti delle performance.

    Per renderci conto di questi aggiornamenti possiamo andare a vedere la versione di mscorie.dll sotto C:\Windows\Microsoft.NET\Framework\v2.0.50727, su una macchina con Windows Vista, dove non è stato installato .NET 3.5, la versione del Framework 2.0 dovrebbe essere 2.0.50727.312, notate gli ultimi numeri della revisione, mentre su una macchina in cui è installata la beta 2 di VS 2008 trovate la versione 2.0.50727.1318, come vedete dalle figure seguenti, dove la prima si riferisce ad un Windows Vista in cui non è installato VS 2008, mentre nella seconda siamo su una macchina con la Beta 2 installata.

    image image

    Un' ultima cosa: mentre quando siamo passati dalle versioni 1.x di .NET alla 2.0 è stato aggiornato anche l'engine del CLR, questo non avviente passando dalla versione 2.0 alle 3.0 e/o alla 3.5. Questo ci fa capiere che le novità introdotte ai linguaggi (C# 3.0, VB 9) sono delle vere e proprie estensioni al CLR.

    Riassumendo

    Visual Studio 2008 verrà rilasciato insieme alla versione 3.5 del .NET Framework e a degli aggiornamenti per la versione 3.0 e 2.0 di .NET su cui esso stesso si basa.  Quindi le vostre applicazioni scritte con .NET 2.0 e .NET 3.0 continuerranno a funzionare, certo a meno che non abbiate sfuttutato qualche bug del Framework che verrà corretto :-)

  • Pietro Brambati Blog

    Serializzazione delle Entità dell' Entity Framework con WCF in NET 3.5 SP1

    • 6 Comments

    Un titolo un po' complicato, certo, vediamo di chiarire meglio il contenuto di questo post. Lo scopo è di illustrare con un po' di codice una delle novità della SP1 di .NET 3.5, in particolare il supporto di WCF per la serializzazione delle entità generate dall' Entity Framework, anche quest'ultimo, come forse avete letto, lo trovate ora, insieme al designer installando la SP1. Potete leggere le novità della SP1 qui.

    Costruiamo il servizio WCF

    Dopo aver installato l'SP1 su una macchina di test, creiamo dunque un progetto di tipo WCF Service Application, come mostrato in figura:

    image 

    Aggiungiamo ora un nuovo item di tipo ADO.NET Entity Data Model. Due parole sull' Entity Data Model (EDM), per chi non ne ha mai sentito parlare, per gli altri saltate pure il paragrafo. L' EDM  rapprenta il cuore dell ' Entity Framework (EF), consentendovi di "rappresentare" il dominio applicativo della vostra applicazione. L'insieme delle classi che ne scaturiscono non sono necessariamente legate a come è fatto il vostro database in termini di tabelle etc.L' EDM è implementato attraverso un file CSDL, come descritto nella documentazione. Nella sua intimità il designer di VS, che useremo nell'esempio, crea tre file XML: il CSDL descrive appunto le entità con cui la nostra applicazione vuole parlare, ad esempio un cliente ed un ordine, un secondo file SSDL descrive invece come è la struttura relazionale del nostro database, che può non necessariamente mapparsi in modo diretto sulle entità, ad esempio posso avere più tabelle che rappresentano sul db come è fatto un customer. Un terzo e ultimo file MDL descrive invece il mapping tra le entità e le tabelle sul database. Il designer che Visual Studio 2008 ci mette a disposizione crea un file .edmx, che al suo interno è fatto appunto dai tre file XML. Ok, scusate la brevità, ma potete leggere un'introduzione a EF e EDM a questo link.

    Nella figura seguente aggiungiamo quindi un nuovo item  e seguendo il wizard proposto utilizzate come database il classico Northwind e per gli scopi di questo post inserite solo le tabelle Customers e Orders.

    image 

    Il risultato mostrato nel designer dell'EF sarà qualcosa del genere, in cui vedete espressa, una relazione 1-a-molti tra le entità, ad ogni entità corrisponde una classe che poi useremo nell'applicazione. Infatti il designer creerà delle classi, oggetti .NET, che useremo per scrivere il codice e una classe NorthwindEntities che serve a EF e che sarà il nostro entry-point per poter lavorare con EF.

    image 

    Ora vogliamo esporre un servizio WCF con un semplice metodo che restituisca l'elenco dei client e dei relativi ordini, per fare questo per prima cosa modifichiamo il file IService1 creato in automatico quando abbiamo aggiunto il progetto WCF, come in figura:

    image

    Nella figura vedete che ho aggiunto il namespace NorthwindModel, che mi è stato creato quando ho usato il designer dell' EF, quindi ho definito nell'interfaccia un unico metodo che restituisce l'elenco di customers, il numero massimo è controllato dal parametro del metodo. Il metodo ha intenzione di restituire l'elenco di clienti e relativi ordini all'applicazione client che invocherà il servizio. Implementiamo ora il servizio  nel file service1.svc.cs usando una query LINQ to Entities. LINQ to Entities è una delle modalità di interrogazione che offre EF, potete anche usare Entity SQL in diversi scenari... questi argomenti sono fuori dallo scopo di questo post.

    image

    Nell'esempio vedete una semplice query LINQ to Entities, che espone i Customers (al massimo il numero indicato). Nella query notate la clausola Include. Questa viene usata perchè l'EF ha un meccanismo esplicito per il caricamento delle entità, possiamo vedere la query generata su database ad esempio usando il Profiler di SQL Server. Se volete saperne di più sulle strategie di caricamento dell' EF e modalità di interrogazione, leggete questo interessante articolo.

    Costruiamo l'applicazione di Test

    Bene, ora aggiungiamo una semplice console application e aggiungiamo un riferimento al servizio WCF presente nella solution, come mostrato in figura, in cui stiamo, per l'appunto, aggiungendo una Service Referece all'applicazione  console.

    image

     

    Ora scriviamo il codice necessario per mostrare l'elenco dei clienti, diciamo i primi due e i relativi ordini

    Codice scritto senza la SP1

    Quello che succede è che l'applicazione client non vede la classe Orders, poichè questa non è stata serializzata, perdiamo quindi la possibilità di navigare da un generico Customer a tutti i suoi Orders, se non esponendo gli ordini direttamente dal metodo WCF.

    Codice scritto con la SP1

    Le novità introdotte a WCF nella SP1 supportano la serializzazione del grafo delle entità generate dall'Entity Framework, quindi possiamo scrivere il seguente codice, che ci permette di fare sul client quello che volevamo senza complicare il metodo del servizio WCF.

    Ecco il codice, in cui vedete che abbiamo accesso, dato un cliente, anche alla lista degli ordini.

    image

    Il risultato è quello atteso:

    image

    Potete scaricare l'esempio di codice a questo link.

  • Pietro Brambati Blog

    Prossima fermata Perugia …

    • 6 Comments

    Il tour di Lancio è ormai quasi finito, sono infatti concluse le tappe “ufficiali”, in cui abbiamo toccato ben sette città italiane insieme a migliaia di persone. Le sessioni registrate a Milano sono live sul sito BE-IT, ma …. Il tour continua, infatti mancano ancora due date Perugia e Ancona dove le nostre community proseguiranno a raccontare le novità più importanti per gli sviluppatori …. e anche qualcosa in più.

    Non potrò purtroppo essere presente all’evento di .NetMarche, ma per chi di voi passa da Perugia, siete invitati all’evento di .NetUmbria. La prossima settimana sarà una buona occasione per incontrarci.

    L’evento di Perugia è molto fitto di argomenti interessanti e come ogni bravo speaker vi racconto qualcosa in anteprima sulla mia sessione.

    Diversamente dalla mia sessione sulle novità di Visual Studio 2008 per il web, la presentazione sarà incentrata su LINQ e l’ ADO.NET Entity Framework, quest’ultimo, ci tengo a ricordarlo, non è ancora stato rilasciato, ma è comunque scaricabile in versione beta.

    Cercherò di chiariare e dare risposta ad alcune domande, molte delle quali arrivano da quello che mi avete chiesto più volte ?

    • Cos'è LINQ ?
    • Come funziona LINQ to SQL ? (Vedremo anche come usare le Store Procedure :-))
    • Che relazione c'è tra LINQ to SQL e LINQ to Entities ? Quando usare l'uno e quando usare l'altro ?
    • Cos'è l' ADO.NET Entity Framework  e che relazione c'è con LINQ to Entities ?

    A presto e ci si vede a Perugia

  • Pietro Brambati Blog

    Internet Explorer 8 : Developer’s Quick Guide

    • 6 Comments

    Ho collezionato una serie di link utili per capire le novità di Internet Explorer 8 e in particolare relativamente alla beta 2. Ho cercato di rendere il più ridotta possibile la lista dei link in modo da non perdere troppo tempo a rileggere le stesse cose.

    • What's New in Internet Explorer 8: qui trovate una carrellata di tutte le novità presenti in IE8 per sviluppatori e non solo, troverete segnato con un asterisco quelle relative alla beta 2.
    •  image Modalità di visualizzazione delle pagine (Document Compatibility): La compatibilità con gli standard ( in particolare CSS 2.1) è uno dei requisiti di progettazione di IE8; per garantire però che vengano visualizzate correttamente le pagine web realizzate per versioni precedenti del browser, IE 8 mette a disposizione diverse modalità di rendering della pagina. Il comportamento di IE 8 può essere influenzato dall’utente finale attraverso la Compatibility View, ma anche da chi sviluppa l’applicazione usando un tag <Meta> o un header http.
    • Document Compatibility: spiega come modificare la visualizzazione di IE 8 usando il tag o un header http
    • Introducing Compatibility View: parla della Compatibilità View, ma anche del nuovo parametro IE=EmulateIE8
    • image WebSlices:
    • image Accelerators (le Activities della beta 1):
    • Search Providers
    • Il filtro XSS: questo nuovo filtro è in grado di prevenire attacchi Type-1 Cross-Site Scripting. Leggendo il post che vi ho segnalato noterete che l'effetto per l'utente finale è di essere minimamente invasivo, così da non dover far compiere scelte difficoltose e a volte impossibili a molti. Come developer,  potete disabilitare questo filtro per le vostre pagine, mettendo un apposito header Http: X-XSS-Protection.
    • image IE 8 Developer Tools: è un’applicazione integrata in IE8 che consente di testare la pagina web visualizzata: HTML, CSS, Javascript e altro. In particolare è interessante la possibilità di testare il comportamento di una pagina nelle diverse modalità di visualizzazione di IE, il tutto in modo dinamico, modificando i parametri Browser Mode e Document Mode. Nel terzo ducumento viene spiegata la differenza tra queste due opzioni in apparenza poco chiare: la prima inluenza lo user agent e il version vector, mentre la seconda influenza il comportamento di IE in base alla presenza o meno del document tag eventualmente presente.

    Testing di siti esistenti

    Scarica la Internet Explorer Application Compatibility VPC Image che contiene anche una nuova immagine con Windows XP SP3 e IE8 Beta 2: queste immagini vi consentono di avere una macchina virtuale già pronta per fare il testing dei vostri siti con la beta 2 di IE8.

    Se trovate qualche altro link utile su IE 8, lasciate pure un commento; nei prossimi giorni è probabile ci sia un maggiore aggiornamento della documentazione dalla beta1 alla beta 2.

  • Pietro Brambati Blog

    Controlli Open Source per Silverlight 2

    • 6 Comments

    Mentre sono in giro per l’Italia a parlare del nuovo Silverlight 2, ecco che a meno di due settimane dal lancio appaiono i primi controlli Open Source per Silverlight2, che trovate sul progetto Silverlight Contrib.

    Provate la demo live

    image

  • Pietro Brambati Blog

    Silverlight 2 RC0 + ADO.NET Data Service + Entity Framework

    • 6 Comments

    [Updated Silverlight Client code VB & C#]

    Qualche giorno fa discutevo con un amico sulle seguenti problematiche:

    • Qual è il modo migliore da Silverlight 2 di fare una chiamata verso un servizio che espone dei dati provenienti da un database ?
    • Voglio poter serializzare le entità del mio modello dei dati ? Sì, ma non solo, voglio serializzare l’intero grafo di una relazione master/details. Devo costruirmi tutto a mano ?

    Ok ,vediamo una possibile soluzione che adotta l’uso di ADO.NET Data Service (DS) e ADO.NET Entity Framework (rilasciati con la RTM della SP1 di Visual Studio 2008) e la RC0 di Silverlight 2, in quest’ultima versione, da poco rilasciata, sono infatti state aggiornate le librerie client che consentono di lavorare con gli ADO.NET Data Service.

    Ma cosa sono gli ADO.NET Data Service?

    Beh, per chi non li conosce vi consiglio di dare uno sguardo alla prima parte di questo webcast. In estrema sintesi però posso dire che i DS permettono un accesso REST verso sorgenti dato esposte , in questo caso con EF. In realtà basta una qualsiasi sorgente dati che supporti l’interfaccia IQueryable.

    I DS mi consentono così di accedere via http/https con i semplici verbi GET, PUT, POST, DELETE ad una sorgente dati, che restituirà i dati in formato JSON o ATOMpubs.

    Se ad esempio voglio recuperare l’elenco dei customers(le mie entità) posso effettuare una chiamata GET del tipo http://localhost:48248/SilverlightADOnetDataServicesDemo.Web/NorthwindWebDataService.svc/Customers , dove NorthwindWebDataService.svc è il servizio che espone la mia sorgente dati; se voglio che mi venga restituito l’elenco dei Customers, aggiungo “/Customers” alla chiamata GET del servizio.

    Costruiamo un esempio

    Vado veloce nella prima parte, perché mi aspetto sia più nota, alla fine di questo post trovate scaricabile l’esempio completo. Dunque Creiamo un’applicazione Silverlight 2, ricordate che però questo esempio funziona solo con la RC e non con la beta 2; facciamo in modo che oltre alla creazione del progetto Silverlight 2 venga creato anche il sito web ASP.NET, ora come prima cosa aggiungiamo un nuovo template ADO.NET Entity Data Model, come in figura

    image

    Il wizard vi guiderà fino alla scelta di un database, prendiamo Northwind, quindi alla scelta delle tabelle da inserire e scegliamo Cutomers e Orders, per avere una relazione del tipo (0,1) a Molti, quindi avremo:

    image

    Ok ora viene il bello, aggiungiamo un nuovo template ADO.NET Data Service, come in figura:

    image

    Chiamiamolo NorthwindWebDataService, o come vogliamo, a questo punto nel nostro progetto web ci troviamo più o meno quello indicato in figura:

    image

    Andiamo ora nel file .cs in figura NorthwindWebDataService.cs, in questo caso dobbiamo abilitare quali entità del nostro dominio applicativo vogliamo siano rese visibili all’esterno dai data Service. Per fare questo basta registrare come vedete nel codice seguente il modello dei dati e specificare quali permessi vogliamo vengano dati a quali entità. Nel mio esempio ho optato per la scelta più sbrigativa, attenzione a non fare lo stesso in produzione.

    image

    Ora possiamo fare qualche prova dal browser ed invocare il nostro servizio con delle chiamate come le seguenti: http://localhost:48248/SilverlightADOnetDataServicesDemo.Web/NorthwindWebDataService.svc/

    che dà la lista delle entità esposte, aggiungendo in coda a questo url:

    • /Customers ottengo un file XML con l’elenco dei customers e le informazion su db
    • /Customers(‘ALFKI’) per avere le informazioni su uno specifico customer
    • /Customers?&expand=Orders : che dà l’elenco dei clienti ma anche i relativi ordini

    In questo ultimo caso abbiamo proprio un esempio di quello che ci serviva: i clienti ed i relativi ordini in una sola chiamata; ok è da valutare quando questo sia o meno conveniente o se al limite si poteva raffinare la ricerca selezionando meglio solo alcuni clienti. Vi mostro comunque il risultato del browser , il primo riquadro è l’ID del primo customer e gli altri due sono gli id dei primi due ordini, potete immaginare il resto…

    image

    Il client, Silverlight 2 in questo caso

    Bene, vediamo ora come chiamare gli ADO.NET Data Service da Silverlight 2 RC. Per essere completi dovrei aggiungere che posso utilizzarli, usando delle librerie client per AJAX e delle librerie client per Windows, quindi potrei usarli da WPF o da una Windows Form, oppure direttamente via http, anche se poi dovrei occuparmi del parsing del file XML o JSON.

    Dal progetto SL aggiungiamo il riferimento all’ assembly System.Services.Data.Client.

    Ora la mia applicazione SL si compone di due semplici ListBox, la prima che dà la lista dei clienti e la seconda la lista degli ordini per uno specifico cliente. Non vorrei soffermarmi sugli aspetti di databinding della UI, ma evidenziare come fare la chiamata da SL. Il modo più rapido è aggiungere un riferimento dal progetto Silverlight verso il servizio offerto dai Data Service, quindi verso il file .svc come se fosse un qualsiasi Web Service.

    Ora nel code behind della pagina page.xaml.cs aggiungiamo queso codice:

    image

    La classe DataServiceContext si occupa di gestire il contesto della chiamata, facendo il tracking delle entità aggiunte etc. La seconda chiamata è quella vera e propria dove definiamo cosa vogliamo ottenere; dovreste vedere la stringa che prima chiamavamo dal browser; quindi definiamo la funzione di call-back che verrà invocata alla fine della chiamata asincrona.

    image

    La nostra funzione di call-back semplicemente aggancia una lista di oggetti Customers al DataContext della nostra prima lista, che mostra quindi l’elenco dei Customer (alcune informazioni).

    Ora agganciamo all’evento SelectionChanged il fatto che vogliamo visualizzare gli ordini del cliente selezionato nella seconda lista.

    image

    Direi che il gioco è fatto, ecco la nostra applicazione funzionante: ok ammetto la grafica non è affascinante, ma spero di aver reso l’idea.

    image

    Conclusione

    L’uso degli ADO.NET Data Services aiuta in molti scenari in cui si voglia esporre via REST sorgeti dati, offrendo un meccanismo che ne semplifica il modo d’interrogare, filtrare, ordinare e modificare la sorgente dati sottostante. Può essere usato sia per lo sviluppo per il web ma anche per Windows e insieme a Entity Framework consente anche la facile serializzazione di grafi con relazioni master/detail.

    Potete scaricare il codice di esempio di questo post da qui. [Ho aggiornato il codice scrivendo lo stesso client anche in Visual basic]

  • Pietro Brambati Blog

    Having fun with Windows 7 Sensor API and XNA Game Studio

    • 6 Comments

    One of the coolest features in Windows 7 are the new Sensor (and Location) APIs. The API are native, but you can use them from .NET Framework if you download the Windows API Code Pack 1.0.

    If you would like to test the Sensor API you can do even without a real hardware sensor, in fact in the Windows 7 SDK you can find (both x86 and x64) a Virtual Light Sensor (you can check from this link how to install the Virtual Light Sensor), a simple app that simulate an Ambient Sensor, that, after installed, you can see from Windows 7 sensor’s panel. In the following image you see the app running.

    image 

    1) Buy a sensor

    But if you would like to test a real-hardware sensor, you can buy this one from Freescale. You can see the front and back side in picture taken from my phone:

    mobile 008 mobile 009

    The Freescale’s board has the following sensors:

    • Ambient light sensor
    • 3D accelerometer
    • Dual touch strips

    2) Update the firmware

    To use it with Windows 7 you have to download the Windows 7 Sensor Development Kit from here and update the firmware first, following the readme file. To update the firmware you have first to mount a driver on your system. Tips: to do that, following the instructions, you have to touch the E4 button BEFORE the led display stop says “Press E4 to enter bootloader.”.

    In the following picture I’ve highlighted the led display and the touch E4 Button.. so press the touch button quickly.

    image

    3) Test the sensor with Windows 7

    If you would like to test the 3 sensor on board you can launch the test application (SensorDevKitDiagnosticApp.exe) in the tools\Diagnostic\Binaries Tool directory of the Win 7 Sensor Development kit:

    image

    Ok , now I’ve tested the sensor, but how to have MORE fun ?

    4) Installing XNA Game Studio 3.0

    On codeplex you can download some classes that you can use to extend one of the starter kit that comes with XNA Game Studio … all  in .NET. Because not all the code is implemented , l’ll show you how to minimally do that to drive the car with the accelerometer, of course just for fun and to show how you can use .NET to interact with Windows 7 Sensor API.

    1. Install Microsoft XNA Game Studio 3.0 (62 MB)
    2. Install Microsoft XNA Racing Game Starter Kit (127 MB)
    3. Download Windows 7 Sensor XNA Racing Game (inside you’ll find two classes and a dll).

    Now you can create a simple racing Game Project from Visual Studio 2008:

    image

    After that you have to follow the instruction on the sample from codeplex

    • add the Windows7.SensorAndLocation.dll that contains the wrapper that expose the native API to the .NET world.
    • copy in the Shaders folder, PreScreenSkyCubeMapping.cs (\RacingGame\Shaders\ PreScreenSkyCubeMapping.cs. This file is used to change the light in the sky based on the sensor input
    • In the GameLogic folder, replace Input.cs (\RacingGame\GameLogic\Input.cs) : this file contains all the code used to get the input from different device: mouse, keyboard and with the accelerometer. You can look the Initialize method that initialize the sensor and expose the acceleration in the X and Y axis, as show in the code:

    image

    The code exposes tree properties:

    image

    The first is used to see if an accelerometer is connected and the other two are used to return the real value from the accelerometer. From my test I’ve seen value from –1 o 1.

    Now you have the value returned from accelerometer but how to use in the gaming app ? You first have to initialize the sensor to make the app aware of it, than we have to control the acceleration, deceleration of the car, the left/right turn.

    • go to Graphics\BaseGame.cs in the end of the BaseGame constructor and call the Input.Initialize() that as show before initialize the Accelerometer3D sensor.
    • go to GameLogic\CarPhysics.cs in the Update method you can control the X Axis, for example, value to make the car turn left and right:

    image

    I’ve tried some experiment to correct the sensibility and you can change the 3.0f value to do it yourself.

    To make the car accelerate and go straight or backward  I added this code in the same method:

    image

    Ok probably if you are a XNA Game developer you’ll find a smarter approach to do that, but ok this is another story :-)

    You can download my sample classes from here.

    5) Have fun with Windows 7 Sensor API !

    Now, you can press F5 and play the game with you sensor!

    mobile 011

    6) More on Sensor API.. 

    If you would like to know more about the sensor and location API in Windows 7 and see the video that inspired me to have some fun: watch here.

  • Pietro Brambati Blog

    ASP.NET MVC 2 Preview 2: Client-Side Validation

    • 6 Comments

    In my opinion one of the most interesting features of ASP.NET MVC 2.0 Preview 2 is the support for client-side validation.

    How-to enable Client-Side validation

    Client-side validation enable your application to perform client-side validation based on model’s validation by JQuery validation library. Ok, it’s simpler than it sounds.

    The client-side validation framework is even extensible, but for now it suits my simple needs.

    In my post on ASP.NET MVC 2.0 Preview 1 I’ve added server-side validation to my application model using metadata as ASP.NET Dynamic Data does. So, for example, in the the picture below I’ve added a partial class to my model and a class for metadata describing my requirements for validation. In the following code the attribute ‘Titolo’ must be not null, and I’ve added an Error Message if something’s wrong.

    image

    If I run the application all works fine: I show a view page to the user, user enters some value and press Save to submit to server. If the user doesn’t fill the title field he gets an error as soon as we made a POST to server. You can see the page flickering in the browser.

    Client-side validation prevent your app going to the server for validation and all happens client side, but using the rules you have defined on the partial class you saw before.

    To enable client side validation, you can follow these easy steps:

    • use Html.EnableClientValidation method on the View file
    • insert three javascript files : jquery-1.3.2.js, jquery.validate.js, MicrosoftMvcJQueryValidation.js. These files are included in the Scripts directory coming with ASP.NET MVC 2 Preview 2 project template. 

    I’ve put the code in my view page for editing some simple fields.

    image

    Now I can run my application and see the results, I’m using HttpWatch to see that no requests are performed to the server and the validation logic works as expected.

    image

    As soon as I type something into the textbox the red message disappears.

    Nice feature! You can download the ASP.NET MVC 2 Preview 2 from here and read about all the features on Phil Haack post.

    Enjoy :-).

  • Pietro Brambati Blog

    Silverlight 3 e i .NET RIA Services – parte 2

    • 5 Comments

    Nel primo post di questa serie avete visto un piccolo esempio di come costruire uno strato di mid-tier che usi i .NET RIA Services, attualmente in preview.  Nella parte finale ho collegato in binding una datagrid di Silverlight per visualizzare i dati, istanziando da codice il DomainContext che, in automatico con la compilazione, viene prodotto lato client. Il nostro DomainContext contiene la collezione delle entità su cui stiamo lavorando, Customers etc, i metodi per le operazioni di lettura, modifica, inserimento e cancellazione sugli stessi.

    Facciamolo in modo dichiarativo

    Ora rimuoviamo il codice C# , nella MainPage  e per proseguire aggiungiamo l’assembly System.Windows.Ria.Controls.dll che si trova nella directory di installazione dei .NET RIA Services: “C:\Program Files\Microsoft SDKs\RIA Services\v1.0\Libraries\Silverlight” e una serie di namespace alla pagina XAML che ci serviranno più avanti:

    image

    image

    Inoltre aggiungiamo il namespace al progetto locale che contiene il DomainContext generato dai RIA Services, nel mio caso si tratta di quello dell’applicazione web. Aggiungo anche questo namespace perchè voglio istanziare in XAML, in modo dichiarativo, l’oggetto CustomersContext che prima istanziavo in C#, quindi:

    image

    Ora, il controllo DomainDataSource, che conterrà l’istanza del nostro CustomersModel nome del metodo Loadcustomers:

    image

    Ora, uso la proprietà ItemsSource della DataGrid per collegare la proprietà Data, dell’elemento appenda dichiarato che si chiama (x:Name) customersDataSource.

    image

    Il risultato fino a qui raggiunto è lo stesso di quello ottenuto alla fine del post fatto in precedenza, ma mi dà l’occasione di continuare l’esempio…

    Ordinamento

    Se ora voglio aggiungere l’ordinamento di default alla DataGrid, usando sempre l’oggetto DomainDataSource, scrivo il codice nell’immagine dove PropertyPath identifica in questo caso il nome della proprietà di cui voglio ottenere l’ordinamento dell’entità Customer.

    image

    Filtraggio

    Ora aggiungo un semplice TextBox dove l’utente può inserire l’iniziale della città per eseguire il filtraggio dei miei Customers, poi come nel caso seguente modifico il mio DomainDataSource per dare supporto al filtraggio via TextBox.

    image

    image

    Paginazione

    Aggiungiamo ora il controllo DataPager, impostiamo il numero di dati per pagina uguale a 5 e colleghiamo la sorgente per la paginazione sempre al nostro customersDataSource

    image

    Il risultato è quello che vedete nell’immagine sottostante:

    image

    Se ricordate all’inizio, il numero di Customers che venivano recuperati dalla query era pari a 20 e la paginazione avviene per pagine di 5 elementi. Questo vuol dire che dopo il primo roundtrip con il server che recupera i 20 clienti, la paginazione nel mio caso avviene, per quegli elementi, sul client, quindi senza andare a chiamare il server quando non è necessario.

    Nella prossima parte useremo il nuovo controllo DataForm, aggiungeremo la validazione ed il supporto per le operazioni di update sul database.

Page 1 of 11 (261 items) 12345»