blogs.ASPItalia.com

Entity Framework. Una tabella due Entity senza discriminazioni

Andrea Zani — Sat, 06 Sep 2008 08:52:04 GMT

In un blog precedente avevo parlato del Single Table Inheritance. Grazie ad un campo apposito � possibile decidere a quale entity far� parte il record di quella nostra tabella.

Il problema che sto cercando di risolvere in questi giorni si basa sul quesito:

E' possibile dividere una tabella in due entity senza questo campo?

Ma prima che subentri la confusione, il mio obbiettivo non � quello di creare due entity parallele come nel caso di quel blog (TextContents e LinkContents), ma una entity di base da cui deriva un'altra entity. Per esempio, da questa tabella:

*Nome campo*	*Tipo*
Id	int
Title	nvarchar(50)
LongDescriptions	ntext

Vorrei ottenere una struttura come questa (poi spiegher� il perch�):

Il problema che mi ero posto � molto semplice: in caso volessi visualizzare tutti i record della tabella in un menu di scelta, la richiesta dei dati presenti in un'unica entity avrebbe richiesto tutti i campi anche quelli ntext (che potrebbero contenere, per assurdo, mega di documenti di testo), come si pu� evitare questo?

Ah, dimenticavo, visto che questi dati devono attraversare dei layer dell'applicativo, non voglio usare gli anonynous type, altrimenti sarebbe troppo facile scrivere:

var coll=from d in Context.Documents
select new { Id=d.Id, Title=d.Title };
return coll;

Anche se questa soluzione porta l'Entity Framework a inviare la giusta query al database:

SELECT
1 AS [C1],
[Extent1].[Id] AS [Id],
[Extent1].[Title] AS [Title]
FROM [dbo].[Descriptions] AS [Extent1]

Una soluzione che mi hanno suggerito � creare una classe che ospiti solo quei dati:

public class Elenco
{
public int Id { get; set; }
public string Title { get; set; }
}

var coll = from c in context.Descriptions
select new Elenco { Id = c.Id, Title = c.Title };
foreach (var item in coll)
{
Response.Write(string.Format(
"{0} {1} <br />",
item.Id,
item.Title
));
}

Pu� andare. Si potrebbe trovare un'altra soluzione con l'uso delle viste. Creata questa vista:

select Id,Title from Descriptions

Si possono creare due entity distinte all'interno dell'editor di Visual Studio 2008:

Lo schifo � che sono due entity distinte, ma risolvono in parte il problema. Segnalo che, importata questa vista nell'editor, i campi vengono visti entrambi come key. Non � sufficiente modificare le propriet� nell'editor, � necessario aprire il file .edmx con un editor xml e cancellare la doppia key:

Poco sopra nell'xml � possibile vedere com'� importata la vista:

<EntitySet Name="DescriptionsTitles" EntityType="TestEntitiesModel.Store.DescriptionsTitles" store:Type="Views" store:Schema="dbo" store:Name="DescriptionsTitles">
<DefiningQuery>SELECT
[DescriptionsTitles].[Id] AS [Id],
[DescriptionsTitles].[Title] AS [Title]
FROM [dbo].[DescriptionsTitles] AS [DescriptionsTitles]
</DefiningQuery>
</EntitySet>

Questo comporta, alla richiesta dei dati, l'esecuzione di questa query:

SELECT
[Extent1].[Id] AS [Id],
[Extent1].[Title] AS [Title]
FROM (SELECT
[DescriptionsTitles].[Id] AS [Id],
[DescriptionsTitles].[Title] AS [Title]
FROM [dbo].[DescriptionsTitles] AS [DescriptionsTitles]) AS [Extent1]

Alla fine c'� la soluzione compatibile con l'Entity Framework e la mia necessit�. Ma si deve mettere mano alla struttura del database. Si deve dividere quella tabella in due, spostando il campo LongDescriptions nella seconda naturalmente collegando il tutto. L'EF non far� una piega e vedr� il tutto in modo corretto e otterrei ci� che voglio.

Posso avere tutto ci� che voglio? No, non � possibile.

Intellisense in Sql Server 2008

Andrea Zani — Thu, 04 Sep 2008 17:48:52 GMT

C'è una tabella:

L'intellisense c'è?

Che bello. Cancello la tabella. Rifaccio una query e cosa mi compare?

Ma se l'ho cancellata!!!

Il bello avviene anche con tabelle nuove che non vengono viste dall'intellisense del Managment Studio di Sql Server 2008. Lo si deve riavviare per aggiornare il tutto.

O mi è sfuggito qualcosa? La delusione però c'è. Bel bug!!!

Questo problema me l'ha fatto notare un collega, da quando c'è EF, Sql server non lo guardo più :-)

Tags: Database, SQL Server

Un Anello per domarli, un Anello per trovarli, Un Anello per ghernirli e nel buio incatenarli,

Marco Leoncini — Wed, 03 Sep 2008 23:24:00 GMT

il giorno si sta sempre pi� avvicinando...di che giorno si tratta? del giorno in cui ricevo l'anello... ma con meno poteri...l'anello del matrimonio.

Domenica 7 settembre alle 16:00:00

con tutta probabilit� sar� un�p� assente da giovedi sera, fino alla fine di settembre, a presto!

ciao marco

Tags: Off Topic

Google Chrome

Matteo Casati — Wed, 03 Sep 2008 13:29:10 GMT

La notizia del rilascio di un browser targato Google è ormai nota, anche se sono passate circa 24 ore dai primi rumors ufficiali.

Dalla pagina di download viene presentato come "un browser progettato per rendere più veloce, facile e sicuro l'uso del Web con un design minimo che non intralcia la navigazione."

Provandolo, seppur in modo decisamente sommario, ho cercato di verificare le "promesse" fatte:

Veloce

Niente di più vero: semplicemente impressionante!
Voto: 9

Facile

In che senso? Ci sono browser "difficili"? Se tralasciamo le funzionalità avanzata (che l'utente "normale" semplicemente ignora) hanno 4 bottoni in croce e una barra degli indirizzi...
Voto: n.a.

Sicuro

Sì, come no?! Ci sono volute ben.. poche ore per trovare la prima falla! Ok, è un bug noto e di facile risoluzione però...
Voto: 4

Design minimo

Su questo niente da dire. Resta da valutare se si tratta di un "pro" o di un "contro". IMHO è decisamente troppo minimal.
Voto: 4

Non intralcia la navigazione

Vedi quanto detto per "Facile": sembra una frase messa lì a caso per completare il periodo.
Voto: n.a.

Personalmente aggiungerei qualche altro aggettivo:

Povero

Mancano un sacco di funzionalità ormai basilari, presenti da anni in tutti gli altri browser: supporto RSS, anteprima di stampa, zoom, ecc.

Voto: 4

Efficiente

L'aspetto a mio avviso più interessante è l'isolamento dei singoli tab che dovrebbe garantire un'ottima stabilità.

Voto: 9

Approssimativo

Alcuni dettagli sembrano buttati lì con poca cura, come la scelta di alcuni termini (specie in italiano): "Roba da smanettoni", "Statistiche per nerd", ecc.
Senza contare dettagli implementativi come "Inspect element". In teoria identica alla versione presente in Safari, soffre di una serie di problemi e sviste considerevoli: manca la localizzazione, il dock alla finestra principale non funziona, lo stile grafico non è coerente (alcuni testi non sono leggibili perché in bianco su sfondo bianco), la visualizzazione delle risorse richiede un reload della pagina, ecc.

Prematuro

Al di là della mancanza di versioni per OS diversi da Windows, mancano plugin, skin e un sacco di altre cose che potrebbero invogliare l'utente a fare il salto. Sicuramente arriveranno ma al momento si può giusto tenere sott'occhio il prodotto in attesa di una versione "vera".

Voto: n.a.

Conclusioni

Ok, è una "beta", quindi è presto per dare un giudizio (sebbene Google ci abbia abituato ad avere prodotti decisamente funzionanti anche in beta).
Su molte cose ha però toppato e l'ha fatto in modo ingenuo: due anni di sviluppo e non hanno trovato un paio di giorni per sistemare qualche dettaglio?

In compenso l'engine sembra ottimo: basato sul migliore a disposizione (WebKit), velocissimo ed efficiente.

Resta la domanda del "perché" Google ha deciso di riaprire quella browser war che speravamo di esserci lasciati alle spalle. Al momento l'ipotesi che mi sembra più plausibile è quella fatta da Guy Barrette.

Resta il fatto che c'è un nuovo player da considerare e, vista da sviluppatore, un altro browser con cui fare i conti (grrrrrr!!!!): infatti ufficialmente quel che funziona su Safari dovrebbe andare anche su Chrome; il condizionale è d'obbligo, tant'è che ad esempio una libreria come Reflection.js già non funziona...

Voi che ne pensate?

Entity Framework e più tabelle in una entity

Andrea Zani — Wed, 03 Sep 2008 07:09:34 GMT

Breve e coinciso. Due tabelle in una sola entity. L'Entity Framework lo permette con pochi passaggi e non in automatico.

Mi servono due tabelle. Eccole:

Tutorials

Nome campo	Tipo e altro
Id	Int, key, Auto increment
Name	nvarchar
Description	Text

Tutorials2

Nome campo	Tipo e altro
Id	Int, key
Name	nvarchar
Description	Text

Ora importiamo le due tabelle nel designer di Visual Studio 2008. Creerà due entity distinte. Non ci servono a nulla. Vanno cancellate. Quindi dalla toolbar, inserire una nuovo oggetto Entity e si mappano all'interno le due tabelle e tutti i campi, naturalmente inserendo nell'editor tante proprietà quante ne servono. Il risultato finale deve essere simile a questo:

Tutto fatto. Ora possiamo farne quello che vogliamo:

using (pubsModel.pubsEntities context = new pubsModel.pubsEntities())
{
    pubsModel.Tutorials obj = new pubsModel.Tutorials();
    obj.Name1 = "A1";
    obj.Name2 = "A2";
    obj.Description1 = "D1";
    obj.Description2 = "D2";
    context.AddToTutorialsSet(obj);
    context.SaveChanges();
}

Un ringraziamento a David che mi ha dato un ottimo suggerimento a riguardo. Ora ho solo un unico dubbio e poi con l'EF spacco tutto: dividere una tabella in due o più entity.

L'Entity Framework e le custom class coinvolte nei where...

Andrea Zani — Sun, 31 Aug 2008 01:04:02 GMT

Riprendo il solito esempio di entity:

Ipotizzando di voler recuperare tutti gli Articles con un determinato colore si potrebbe essere spinti a scrivere:

var c=Context.Colors.Where(cc=>cc.Id==1).First();
var coll=from ar in Context.Articles.Include("Colors")
where ar.Colors=c
select ar;

Semplicemente, avendo una entity voglio vedere tutte le entity che hanno come property questo oggetto. Eseguita, per�, si ottienere questo errore:

Unable to create a constant value of type 'Closure type'. Only primitive types (for instance Int32, String and Guid) are supported in this context.

Questo perch� l'EF non permette il confronto tra oggetti complessi. La soluzione � banale, anzi, in qualche caso pi� semplice (nel caso di web control che ritornano un valore numerico per identificare una scelta di un utente, per sempio da un dropdownlist):

int c=int.Parse(ddl_colors.SelectedValue); // <- prendo il colore selezionato
var coll=from ar in Context.Articles.Include("Colors")
where ar.Colors.Id=c
select ar;

Oppure:

var c=Context.Colors.Where(cc=>cc.Id==1).First();
var coll=from ar in Context.Articles.Include("Colors")
where ar.Colors.Id=c.Id
select ar;

Soluzione semplice, ma � sempre bene saperla.

Entity Framework e l'ereditarietà (Single Table Inheritance)

Andrea Zani — Sat, 30 Aug 2008 13:07:56 GMT

Visto che in questi gioni sto usando parecchio con l'Entity Framework questa Table Per Hierarchy (Emanuele mi corregger� se, come al solito, sbaglio la nomenclatura), ecco due appunti su come si realizza con l'editor che mette a disposizione Visual Studio 2008.

L'inizio � questa semplice tabella dal nome BaseContents:

Da questa singola tabella � possibile estrarre due entity distinte. Nel mio caso:

TextContents
LinkContents

La prima utilizzata per memorizzare il contenuto reale di un eventuale testo, la seconda per link a risorse esterne. All'interno di questa singola tabella sono contenuti tutti i campi per memorizzare queste informazioni. L'unico campo aggiuntivo, che far� da discriminante, come si vedr� di seguito, � Type.

Creato in Visual Studio 2008 un nuovo oggetto ADO.Net Entity Data Model, e importanto all'interno di questo oggetto la tabella sopra mostrata, si avr� la prima entity creata in automatico dall'ambiente di sviluppo con tutti i campi interessati.

Ora � possibile aggiunere le entity mancanti, TextContents e LinkContents, ereditandole direttamente da questa (� sufficiente cliccare con il tasto destro all'interno dell'editor e selezionare Add -> Entity). Aggiunte le due entity ecco cosa abbiamo in VS 2008:

Ora possiamo spostare le property di nostro interesse nelle sottostanti entity per ottenere questo:

Dalla window Mapping details, mappiamo la tabella e assicurati che tutti i campi interessati siamo mappati correttamente, possiamo inserire la condizione discriminante, in modo che nell'uso di una o dell'altra entity, siano salvati i dati corretti nella tabella. Nulla di difficile, sempre da Mapping details, si aggiunge nelle condition:

In questo caso ho inserito il valore 1 in Type per il TextContents, e 2 per il LinkContents. Sembra tutto fatto, ma ecco l'amara sorpresa che ho trovato compilando il tutto:

Error 1 Error 3032: Problem in Mapping Fragment starting at line 49: Condition member 'BaseContents.Type' with a condition other than 'IsNull=False' is mapped. Either remove the condition on BaseContents.Type or remove it from the mapping.

Scopro che Type crea un problema. Il mio primo tentativo di cancellazione di questa property dall'entity BaseContents mi porta un nuovo errore:

Error 1 Error 3023: Problem in Mapping Fragments starting at lines 48, 54, 59: Column BaseContents.Type has no default value and is not nullable. A column value is required to store entity data.
An Entity with Key (PK) will not round-trip when:
(PK is in 'BaseContents' EntitySet AND Entity is type TestEntitiesModel.BaseContents)

Alla fine scopro la soluzione da un blog di Zeeshan Hirani (che spiega il tutto in modo molto pi� dettagliato, ma visto che ho scritto fino a qua, non ho voglia di buttare il tutto) che ringrazio perch� mi ha fatto trovare immediatamente la soluzione. E' sufficiente modificare la property Abstract dell'Entity BaseContents in true, per eliminare ogni errore.

Ora da codice possiamo inserire e leggere da questa tabella con due entity separate:

using (TestEntitiesModel.TestEntitiesEntities context = new TestEntitiesModel.TestEntitiesEntities())
{
TestEntitiesModel.TextContents c = new TestEntitiesModel.TextContents();
c.Name = "Example 1";
c.Content = "Content text bla bla bla";
context.AddToBaseContents(c);
TestEntitiesModel.LinkContents l = new TestEntitiesModel.LinkContents();
l.Name = "Example 2";
l.Link = "www.aspitalia.com";
l.Impressions = 0;
context.AddToBaseContents(l);
context.SaveChanges();
}

Visualizzando il contenuto della tabella troveremo:

Id	Name	Link	Impressions	Content	Type
1	Example1	null	null	Content text bla bla bla	1
2	Example2	www.aspitalia.com	1	null	2

Per leggere:

using (TestEntitiesModel.TestEntitiesEntities context = new TestEntitiesModel.TestEntitiesEntities())
{
var coll = from c in context.BaseContents.OfType<TestEntitiesModel.TextContents>()
orderby c.Content ascending
select c;
foreach (var item in coll)
{
Response.Write(string.Format("{0} {1} {2}<br />",
item.Id,item.Name,item.Content));
}
}

Questa volta per specificare l'entity da leggere, dobbiamo utilizzare l'OfType come da esempio. Se volessimo richiedere l'entity LinkContents, avremmo duvuto scrivere:

var coll = from c in context.BaseContents.OfType<TestEntitiesModel.LinkContents>()

Oltre al Table Per Hierarchy (Single Table Inheritance) l'EntityFramework mette a disposizione altri due tipi di inheritance:

Table Per Type
Table Per Concrete Class

Ma le cosa iniziano a complicarsi un po' con l'editor di VS2008.

Tags: Visual Studio

Abusi della parola chiave var e poca leggibilità dei generics

Cristian "Ricciolo" Civera — Fri, 29 Aug 2008 11:07:00 GMT

Con C# 3.0 hanno introdotto la nuova parola chiave var per inferire il tipo dalla dichiarazione il cui scopo � principalmente supportare e rendere possibile LINQ. Un po' di codice ormai in giro si trova, ma trovo che a volte questa parola chiave venga abusata.

Sono del parere che non debba essere strumento della nostra pigrizia, ma che venga usata sapientemente. Oltre alle situazioni in cui l'uso � d'obbligo, dove l'assegnazione restituisce un anonymous type, credo var possa essere usato in assegnazioni complesse, solitamente dovute ai generics. Per esempio

var people = new Dictionary>(); var f = new Func<String, Func<Int32, DateTime>>(miaFunzione);

Non lo userei invece, ma dichiarerei il tipo, per quando l'espressione � semplice e il tipo � ben conosciuto:

var s = "ciao"; var exists = (from c in people where c.City == "Brescia select true).FirstOrDefault(); var c = people.Count;

I motivi sono due:

se vedo il codice non capisco che tipo sono. Nemmeno l'intellisense te lo segnala finch� non lo usi almeno una volta e non sempre guardo codice da Visual Studio;
perdo un po' di controllo sui tipi. Se il metodo o la propriet� cambiano, il significato dell'assegnazione cambia e il codice potrebbe comunque compilare, ma funzionare diversamente. Inoltre, dove posso, preferisco lavorare a livello di interfacce o classi base, perci� specificare il tipo � d'obbligo.

Inoltre un'osservazione sulla leggibilit� del codice. Personalmente le assegnazioni, dove secondo me � giustificato usare la var, non piacciono molto. Sono un po' incasinate, non trovate? Se � una variabile di stack in effetti pu� andare bene cos�, ma se poi questo tipo lo si restituisce credo sia pi� appropriato a questo punto fare una classe apposita che ne semplifica l'utilizzo. Ad esempio:

public class Cities : Dictionary<ZipCodes> { } public class ZipCodes : List<ZipCode> { }

Non dimentichiamoci infine che esistono gli alias che trovo molto comodo quando uso delegate complessi, anche per uso interno, perch� di fatto non creano nuove classi o membri. Per esempio:

using MioInvoker = new Func<String, Func<Int32, DateTime>>;

Ovviamente questa � una mia opinione�stilistica personale, infatti l'ho scritta nel mio blog :-)

Tags: .NET Framework, .NET Framework 3.5, LINQ, Object Oriented Programming

Il mio primo libro in inglese: Entity Framework In Action

Stefano Mostarda — Thu, 28 Aug 2008 10:12:00 GMT

Sono mesi che ci sto lavorando e finalmente il risutato si vede. Ormai tutto � pronto quindi posso annunciare che dopo ASP.NET 3.5 per tutti, partir� con la stesura del mio primo libro da "single" in inglese: Entity Framework In Action.

Come si intuisce dal titolo, il libro � pubblicato dalla Manning. Molti mi hanno sconsigliato di scrivere un libro su questo argomento vista la grande impopolarit� di Entity Framework. Io rimango della mia idea che seppur limitato da alcune scelte di design, che verranno in parte migliorate nella v2, questo framework ha un engine molto potente ed in futuro dir� la sua contro colossi come NHibernate (visto anche che � incluso nel framework).

Confesso di essere un tantinello terrorizzato perch� scrivere un libro in inglese che verr� letto in tutto il mondo � una cosa non proprio semplice da affrontare, ma ormai come mi ha detto Daniele "hai voluto la bicicletta ..." :).

Chiudo con i ringraziamenti d'obbligo ad Alessandro, lui sa benissimo il perch�. Ora non mi rimane che buttarmi a capofitto nella stesura del libro, sperando di riuscire a convincere la gente che in realt� Entity Framework non � cos� malaccio come si dice :).

Stay Tuned...

Tags: .NET Framework, .NET Framework 3.5, ADO.NET Entity Framework, LINQ, ORM

L'entity Framework e i vincoli FOREIGN KEY

Andrea Zani — Thu, 28 Aug 2008 07:12:13 GMT

L'entity framework rende felice. Ti fa vedere il mondo dei database sotto un'altra ottica. Le complicazioni create dai soliti esperti di struttura dei database fanno ora sorridere, anzi, li si incita a complicare maggiormente la struttura delle tabella per normalizzazioni fino al quinto livello.

- Il terzo livello basta!
- No, andiamo fino al quinti livello di normalizzazione! - possono ora affermare i dev sorseggiando un caffè alle loro spalle.

A parte queste ciance, una delle attenzioni che si devono avere quando si usa l'Entity Framework è quando si cancellano delle entity dal database quando sono in gioco Foreign key e amenità simili. Inoltre, la cancellazione di una entità non elimina - giustamente - di suo eventuali proprietà collegate uno-a-uno con un'altra tabella (sempre che sul db non ci siano regole varie, ma in questo caso di deve prestare attenzione, perché la cache interna dell'Entity Framework la vedrà ancora presente). Buona regola, nel caso di voler cancellare tutti i record coinvolti in una entità, scrivere:

using (pubsModel.pubsEntities2 context = new pubsModel.pubsEntities2())
{
    var padre = context.Canc_Padre.Include("Canc_Figlia").First();
    var figlia = padre.Canc_Figlia;
    context.DeleteObject(figlia);
    context.DeleteObject(padre);
    context.SaveChanges();
}

In questo caso le tabelle di chiamano Canc_Padre e Canc_Figlia. L'ordine di cancellazione dev'essere anche quello mostrato (prima la tabella figlia e poi la padre), perché la cancellazione dell'entità padre farebbe perdere il collegamento con il record da cancellare con la necessità di una nuova query di select di ricerca.

Ma nel caso delle relazioni molti-a-molti? Prendiamo d'esempio un classico schema con tre tabelle:

authors
books
authorsbooks

Le prime due sono le classiche tabelle che conterranno i dati, la terza quella che collega i dati delle due.

Scrivendo questo codice:

using (pubsModel.pubsEntities2 context = new pubsModel.pubsEntities2())
{
    var coll = (from au in context.authors
               where au.name=="..."
               select au).First();
    context.DeleteObject(coll);
    context.SaveChanges();
}

Otterremo il classico errore:

L'istruzione DELETE è in conflitto con il vincolo REFERENCE "FK_authors_books_authors". Il conflitto si è verificato nella tabella "dbo.authorsbooks", column 'id_author' del database "pubs".

Per evitare questo problema, cioè cancellare il record dalla tabella authors e ogni suo riferimento dalla tabella authorsbooks, dovremo invece scrivere:

using (pubsModel.pubsEntities2 context = new pubsModel.pubsEntities2())
{
    var coll = (from au in context.authors.Include("books")
               where au.name=="..."
               select au).First();
    context.DeleteObject(coll);
    context.SaveChanges();
}

Se volessimo cancellare anche il record in book, dovremo fare come sopra: recuperata l'entity usare il DeleteObject.

PS: ieri sera ho dovuto aspettare venti minuti il pullman per tornare a casa.

Tags: Database

Data Service Viewer

Andrea Zani — Thu, 28 Aug 2008 07:09:20 GMT

Interessante questo tool. Anche se Astoria è una tecnologia che mi mette parecchi dubbi (dubbi che non voglio per ora divulgare qui) la trovo interessante. E se c'è un tool che permette di provare le richieste http in modo facile e che ti dà anche una mano, ben venga.

E' un exe scritto in .net. Alla prima richiesta richiede l'endpoint dove astoria è in attesa, per esempio:

http://localhost:1035/WebSiteEntity2/WebDataService.svc

Nel codice di questo ado.net web data service, è necessario obbligare quali entità possono essere utilizzate e come:

public class WebDataService : DataService<pubsModel.pubsEntities2>
{
    public static void InitializeService(IDataServiceConfiguration config)
    {
        config.SetEntitySetAccessRule("*", EntitySetRights.All);
        config.SetServiceOperationAccessRule("*", ServiceOperationRights.All);
    }
}

Qui ho specificato che è possibile operare su tutte le entità e che posso farci di tutto tra queste scelte possibili.

Ok, avviata la web application con questo nuovo oggetto, possiamo utilizzare il tool prima citato che il nome significativo "Data service viewer". Inserito l'endpoint, ecco la schermata:

Ma l'utilità vera è nella possibilità di provare le query avendo il supporto per l'intellisense durante la scrittura:

Qui si scopre un piccolo problema. L'elenco delle scelte possibile è selezionabile con i tasti cursore e la scelta è selezionabile solo con il tasto invio e con il mouse mentre il tasto tab manda al pulsante per l'esecuzione della query.

Lazy Loading con l'Entity Framework

Andrea Zani — Wed, 27 Aug 2008 11:33:57 GMT

Anche se qualcuno afferma il contrario, non cito la fonte, abbiamo a disposizione più metodi per caricare entità collegate. In tutti questi post dedicati all'Entity Framework ho fatto sempre esempio che riguardavano più tabelle (~entità) collegate.

Possiamo fare in modo che sia lo stesso Entity Framework a caricare con una query il tutto grazie a Include:

var coll=from c in EntityContext.Articles.Include("Authors")
select c;
foreach (var item in coll)
{
Response.Write(item.Title);
Response.Write(item.Authors.Name);
}

Oppure possiamo forzare il caricamente delle entità collegate, in questo caso Authors, ad ogni richiesta della stessa:

var coll=from c in EntityContext.Articles
select c;
foreach (var item in coll)
{
Response.Write(item.Title);
if (item.AuthorsReference.IsLoaded) // Controlla se già presente in memoria
    Response.Write(item.AuthorsReference.Value.Name);
else
{
    item.AuthorsReference.Load();
    Response.Write(item.Authors.Name);
}
}

In quest'ultimo caso all'inizio viene eseguita una query che richiede solo la lista degli Articles. Quindi viene verificato che l'entità per gli Authors non sia già presente in memoria; se presente la visualizza direttamente, altrimenti esegue una query al database.

Il numero di query inviate al database è N+(numero di autori richiesti differenti). Ipoteticamente, se tutti gli articoli fossero collegati ad un solo autore, il numero di query inviate al database sarebbero due.

PS: scusate la brevità ma il tempo è tiranno. O Tiràno?

4 desktop virtuali su Windows

Andrea Zani — Tue, 26 Aug 2008 12:01:02 GMT

Una peculiarità che ho sempre apprezzato nei desktop manager di Linux è la possibilità di dividere la zona di lavoro su più desktop virtuali. Leggo ora che è presente questo tool che lo permette anche su Windows. Scaricato e avviato. Funziona discretamente, ed è veloce e pesa poco. Il problema è un altro: non permette i passaggi di finestre tra un desktop all'altro con la stessa facilità che permette Gnome o Kde: vengono sì create più arie di lavoro, ma queste non sembrano poter comunicare.

Peccato.

A volte ritornano... GridView vs Repeater vs ListView vs Custom

Andrea Zani — Tue, 26 Aug 2008 07:20:37 GMT

Sono passati anni? Parecchio tempo fa avevo confrontato le prestazioni nel binding dei dati tra i più noti webcontrol. Ecco un refresh, questa volta con il Framework 3.5 e con lo scontro tra:

Gridview
Repeater
ListView
Custom code

Chiunque un po' smaliziato con il .net saprà già chi vince e chi è il peggiore tra questi. Ma per i novizi è sempre meglio saperlo. Innanzitutto, il codice per il popolamento delle tabelle html è il seguente:

List<Person> p;
p = new List<Person>(200);
for (int i = 0; i < 200; i++)
p.Add(new Person { Id=i, Age=i, Description="Desc "+i.ToString(), Name="Name "+i.ToString() });

Il gridview crea la table html con questo codice:

<asp:GridView ID="gw1" EnableViewState="false" runat="server" AutoGenerateColumns="false">
    <Columns>
        <asp:BoundField DataField="id" />
        <asp:BoundField DataField="name" />
        <asp:BoundField DataField="age" />
        <asp:BoundField DataField="description" />
    </Columns>
</asp:GridView>

Per il repeater abbiamo:

<asp:Repeater ID="rp1" runat="server" EnableViewState="false">
<HeaderTemplate><table border="1"></HeaderTemplate>
<FooterTemplate></table></FooterTemplate>
<ItemTemplate>
<tr>
    <td><%# Eval("id") %></td>
    <td><%# Eval("name") %></td>
    <td><%# Eval("age") %></td>
    <td><%# Eval("description") %></td>
</tr>
</ItemTemplate>
</asp:Repeater>

Ma siccome vogliamo ottimizzare un po', possiamo scrivere:

Ecco il ListView, semplice:

<asp:ListView ID="lw1" runat="server" EnableViewState="false">
    <LayoutTemplate>
        <table border="1">
            <asp:Panel ID="itemPlaceholder" runat="server" />
        </table>
    </LayoutTemplate>
    <ItemTemplate>
        <tr>
            <td><%# Eval("id") %></td>
            <td><%# Eval("name") %></td>
            <td><%# Eval("age") %></td>
            <td><%# Eval("description") %></td>
        </tr>
    </ItemTemplate>
</asp:ListView>

E ottimizzato:

E infine creiamo la griglia da codice con un banale StringBuilder da codice:

var sb = new StringBuilder(10000);
sb.Append("<table border='1'>");
for (int i = 0; i < p.Count; i++)
{
    sb.Append("<tr><td>");
    sb.Append(p[i].Id);
    sb.Append("</td><td>");
    sb.Append(p[i].Name);
    sb.Append("</td><td>");
    sb.Append(p[i].Age);
    sb.Append("</td><td>");
    sb.Append(p[i].Description);
    sb.Append("</td></tr>");
}
sb.Append("</table>");
pn1.Controls.Add(new LiteralControl(sb.ToString()));

pn1 è un panel. Ma vediamo le prestazioni (medie):

GridView	*0.122s*
Repeater	0.058s
Repeater ottimizzato	0.046s
ListView	0.059s
ListView ottimizzato	0.047s
Custom code	0.006s

A parte la tabella scritta con lo StringBuilder che mediamente risulta otto volte più veloce del ListView e del Repeater, la sorpresa è proprio il ListView che risulta veloce quanto il Repeater. In poche parole? Il DataGrid, DataList, DataGrid e Repeater sono diventati obsoleti e inutili dato il ListView non solo sostituisce in tutto questi webcontrol, ma ha prestazioni più che buone.

Inoltre, per avere un discreto guadagno, anche la visualizzazione con il casting di tipo nella colonna, invece dell'Eval, è consigliato.

Tags: ASP.NET, ASP.NET 2.0, ASP.NET 3.5, Databinding, Datagrid, GridView

L'Entity Framework e l'ObjectDataSource

Andrea Zani — Sun, 24 Aug 2008 19:26:00 GMT

Anche se con l'SP1 del Framework 3.5 � stato introdotto il nuovo EntityDataSource per collegare direttamente questi nuovi oggetti a web control come il ListView o il GridView, l'utilizzo dell'ObjectDataSource rimane sempre la soluzione migliore: come dice Daniele, i datasource come l'SqlDataSource e compagnia bella sono solo veramente utili per le demo.

Di base non ci sono problemi. Solo di base per�. Quando si cerca di fare qualcosa di pi� complesso saltano sempre fuori casini vari. Messo nella pagina un ListView collegato ad un bel ObjectDataSource che utilizza una classe apposita che ritorna le entit� (nel mio caso con l'ausilio dell'Entity Framework) non ci sono problemi: persino altre entit� memorizzate in propriet� vengono visualizzate correttamente. Come nell'esempio gi� visto:

I problemi nascono quando entrano in gioco gli update e gli insert. Come scritto sopra, di base, cio� con propriet� con tipi non complessi, non ci sono problemi. Definendo nell'InsertMethod dell'ObjectDataSource una nostra funzione come la seguente, tutto funziona:

Che bello! Eh s�, ma l'entit� qui trattata ha anche come propriet� la collection di Book collegati all'autore secondo il seguente schema:

Per visualizzare il tutto in modalit� edit si incotrano le prime rogne ma risolvibile. Ma cosa viene passato al metodo InsertAuthor prima mostrato? Tutto, tranne, ovviamente, eventuli aggiunte ai book. Qui l'esempio � un po' forzato, ma un caso reale potrebbe essere la creazione di un nuovo utente e il collegamento ad esso di una o pi� role per autorizzazione varie (visualizzate in modalit� edit come lista con checkbox).

Come inviare il tutto in modo corretto a quella funzione o quasi?

Io ho solo trovato un espediente, ma spero ci siano soluzioni pi� semplici che finora mi sono sfuggite. Utilizzando l'evento On_ItemInserting dell'ListView possiamo forza l'aggiunta di tutte le informazioni utili:

protected void lw_authors_ItemInserting(object sender, ListViewInsertEventArgs e)
{
// In Values troviamo tutti i valori letti dal objectdatasource (BoundColumn, Bind, ecc...)
// Inserisce un campo aggiuntivo perla data presente nel db ma non del ListView
e.Values.Add("CreationData", DateTime.Now);
var books = new System.Data.Objects.DataClasses.EntityCollection();
// Metodi che richiedono le entit� da collegare
books.Add( AZ.GetBookFromId(1) );
books.Add( AZ.GetBookFromId(2) );
e.Values.Add("Books", auths);
}

Innanzitutto, l'objectdatasource espone la connection come EntityConnection, quindi perch� possa essere riconosciuta dobbiamo inserire tutti gli item selezionati in questa collection. Sembra tutto ok, in questo modo all'evento di inserimento dovrebbe essere passato il tutto correttamente. Dovrebbe! Richiamato questo codice si ha come output un errore chiarissimo in merito proprio al momento dell'Add:

The object could not be added to the EntityCollection or EntityReference. An object that is attached to an ObjectContext cannot be added to an EntityCollection or EntityReference that is not associated with a source object.

Allora ecco l'escamotage:

protected void lw_users_ItemInserting(object sender, ListViewInsertEventArgs e)
{
    // ...
    var books = new System.Data.Objects.DataClasses.EntityCollection<Book>();
    books.Add(new Book { Id = 1 });
    books.Add(new Book { Id = 2 });
    e.Values.Add("Books", auths);
}

Creo due nuove classi Book dove inserisco gli Id dei valori selezionati nell'interfaccia grafica (qui inseriti da codice per rendere il tutto pi� semplice). Ora il codice per l'inserimento dovrebbe accettare anche questi dati aggiuntivi, ma ecco il secondo problema della giornata: quelle entit� verrebbero trattate come nuovi oggetti e inseriti nuovamente nel database. Ecco dunque l'ultima modifica al codice, questa volta nella funzione di inserimento:

[System.ComponentModel.DataObjectMethod(System.ComponentModel.DataObjectMethodType.Insert)]
public static void InsertAuthor(Author author)
{
using (TestEntitiesModel.TestEntitiesCode context = new TestEntitiesModel.TestEntitiesCode())
{
var coll = user.Books.Select(r => r.Id).ToArray<int>();
user.Books.Clear();
foreach (var item in coll)
    user.Books.Add( context.Books.Where( r=>r.Id==item ).FirstOrDefault() );
// Oppure
// foreach (var item in coll)
  // user.Books.Add( context.GetObjectbyKey( item ) );
  context.addAuthors(author);
context.SaveChanges();
}
}

E tutto funziona correttamente. Ma spero ci siano soluzioni pi� immediate e semplici. Vero? Ditemi di s�! :(