blogs.ASPItalia.com

HTML 5 vs RIA? Niente di nuovo

Daniele Bochicchio — Wed, 01 Jul 2009 16:45:00 GMT

Nel 1998 Javascript avrebbe dovuto salvare il mondo. Nel 2009 forse jQuery l'ha reso un po' pi� divertente.

Nel 1999 c'era XML, le Data Island e chiss� cosa. Poi XHTML. Poi Flash. Poi Javascript, che ritorna sempre. Poi AJAX, le RIA. Ora HTML 5.

Sempre la solita identica cosa: guerre di religione inutili tra questo vs quest'altro. Possibile che non ci sia nessuno al mondo che riesce a capire che l'alternativa � la cosa migliore? Tanto poi alla fine, come dimostra la storia, o vince una soluzione, oppure, beatamente, si usano entrambe.

Comunque mi fa ridere questa "corsa" ad HTML 5 quando le specifiche non sono ancora finali e, soprattutto, il fatto che l'unico browser a supportarle � uscito ieri mi fa davvero pensare che siamo una strana razza, noi che lavoriamo sul web. E non � esattamente una buona cosa.

Tags: Javascript, Silverlight, XAML, AJAX, XML

Migliorare la lettura di un sito

Andrea Zani — Thu, 25 Jun 2009 18:02:20 GMT

Mi piace il progetto Readibility, da un sito pieno di riquadri, banner e inutilit� varie (IMHO), � possibile con un solo click passare per esempio da:

Comodo per stampe. Ed � anche personalizzabile. Il tutto grazie ad un sapiente uso di Javascript. Carino.

Mia nota personale e domanda a me stesso: se ci si trova in due o pi� a condividere un'idea, � giusto buttarsi in ci� che c'� gi� nell'inutilit� generale dell'insulsaggine del gi� visto?

Tags: Javascript, XHTML

.NET Framework 4.0 beta 1: ASP.NET MVC

Daniele Bochicchio — Tue, 09 Jun 2009 18:56:00 GMT

ASP.NET MVC sar� incluso in ASP.NET 4.0 e VS 2010, con una versione specifica, che al momento ha come version number 2.0, ma sono certo che avranno tempo e modo di trasformare in 4.0, perch�, come dimostra anche Entity Framework, le novit� da introdurre sono talmente tante che merita un salto di versione cos� elevato...

Ironia su queste sottigliezze a parte, stando a Phil Haack, PM di ASP.NET MVC, in beta 2 "rientreranno" diretti, senza necessit� di installare add-on.

L'installer (con i template che mancano) si pu� scaricare da CodePlex (e la versione � la 1.1, anche se poi diventer� 2.0), con tanto di release notes. Dove c'� anche la roadmap verso la 2.0, per ora molto fumosa.

Ci sono anche gli snippet per VS 2010, che sono davvero interessanti perch� semplificano il lavoro ripetitivo e sono una novit� assoluta di questa versione per il markup (mentre c'erano gi� per il codice vero e proprio).

Non � dato sapere se ASP.NET MVC 2.0 sar� legato al .NET Framework 4.0, rilascio dopo, durante o prima la RTM. Pare che invece ci sar� comunque compatibilit� con la versione 3.5 SP 1 e VS 2008 SP 1.

Tags: ASP.NET, .NET Framework, .NET Framework 4.0, ASP.NET 4.0, ASP.NET MVC, Visual Studio

Entity Framework e le performance con la Like

Stefano Mostarda — Tue, 09 Jun 2009 05:00:00 GMT

Nel bel mezzo della notte insonne ho deciso di fare qualche test per verificare quanto il problema mostrato in questo script fosse rilevante.

Ho creato una tabella con un solo campo di tipo varchar(50) e l'ho popolata con 500.000 righe. poi ho creato una console application ed ho eseguito la stessa query per 100 volte utizzando prima la sintassi LINQ To Entities e poi quella Entity SQL.

Il risultato � abbastanza impietoso perch� la sintassi LINQ To Entities impiega 1'02''815 mentre quella Entity SQL impiega 1''221. La differenza di 1 minuto su 100 query � enorme. questo fatto � da considerare quando si vogliono fare applicazioni scalabili con Entity Framework.. tenetelo a mente

Stay Tuned...

Tags: ADO.NET Entity Framework, LINQ

Bing! Rieccomi!

Alessandro Catorcini — Sat, 06 Jun 2009 20:48:00 GMT

Dopo un lungo silenzio e' tempo di ricominciare a scrivere qualcosa su questo blog. Per chi si chieda che cosa e' successo negli ultimi dodici mesi di silenzio la risposta e' un url semplice e breve : http://www.bing.com
Negli ultimi mesi io ed il mio team siamo stati parecchio indaffarati: le interfacce per l'autosuggerimento durante la digitazione delle query, i provider per Firefox, i nuovi tipi per le Bing API... Non ci siamo annoiati.
Se non avete ancora provato Bing e le Bing API, fatelo (e fatemi sapere che ne pensate ;-) )
A presto con news su nuovi tool e librerie.
--Alessandro

Entity Framework e la generazione di codice POCO

Stefano Mostarda — Tue, 02 Jun 2009 18:22:55 GMT

Una delle cose pi� Sgradite di Entity Framework 4.0 � il fatto che il designer non genera classi POCO. Questa scelta � ovvia e rimarr� quella di default anche in RTM per mantenere la compatibilit� col passato. La buona notizia � che per la RTM il team dovrebbe anche includere un template T4 per la generazione di classi POCO.

La certezza assoluta � che questo template generer� le classi aggiungendole allo stesso assembly in cui si trova l'EDMX. Ora che finalmente abbiamo un sistema OTTIMO-FANTASTICO-ECCEZIONALE-MERAVIGLIOSO-PERFETTO di generazione del codice, questa limitazione si pu� superare. Cercando un p� in rete e partendo dalla base del template esistente, sono arrivato a creare un template che permette di:

Generare le classi e l'objectcontext in classi separate.

Aggiungere le classi ad un assembly diverso da quello in cui si trova l'edmx. Nell'assembly dell'ObjectModel o del DomainModel ad esempio. (Facoltativo).

Aggiungere l'objectcontext ad un assembly diverso da quello in cui si trova l'edmx. Nell'assembly del DAL ad esempio. (Facoltativo).

Mantenete il proprio codice aggiunto alle entities anche quando l'entit� viene rigenerata.

Ovviamente il tutto � molto Beta 1 ma credo sia un ottimo punto di partenza per capire come funziona il T4 e per avere classi POCO da subito. In altri post vedremo come ho risolto alcuni problemi. nel frattempo potete scaricare il template a questo indirizzo.

Tags: .NET Framework, .NET Framework 4.0, ADO.NET Entity Framework, ORM

Silverlight - Real time audio peak meter

Cristian "Ricciolo" Civera — Sun, 31 May 2009 09:14:00 GMT

In un post precedente ho mostrato di come si pu� realizzare un misuratore di picchi per l'audio di un MediaElement precalcolandoli con un'applicazione console. Ovviamente questa non � la prassi normale di tutti i lettori normali, dove il calcolo della FFT applicata ai samples avviene in real time, man mano che questi vengono renderizzati sulla periferica audio.

Da Silverlight 2.0 sull'oggetto MediaElement � presente un metodo SetSource che accetta uno Stream oppure un'oggetto MediaStreamSource. Questa classe ha dei metodi che MediaElement chiama, come OpenMediaAsync, GetSampleAsync, SeekAsync per chiederci di aprire la sorgente, di restituirgli gruppi di samples o di posizionarci ad uno specifico timestamp. Con i metodi ReportOpenMediaCompleted, ReportGetSampleCompleted e ReportSeekCompleted non si fa altro che notificargli l'avvenuta operazione e ciclicamente mandargli pacchetti audio/video.

La brutta notizia � che i samples audio e video devono essere compressi (MP4, WMV) e quindi quello che noi possiamo fare � solo fare da tramite per fonire tracce audio e video con i protocolli che vogliamo: RTP, UPNP, streaming custom. Questa � una brutta notizia perch� per applicare la FFT occorre avere i samples grezzi, gi� decodificati. L'oggetto MediaElement non permette di caricare file WAV direttamente, ma il MediaStreamSouce permette invece di passare anche i samples raw, che il file WAV appunto contiene. Sebbene si potrebbe scrivere un decoder MP3, non sono cos� pazzo da farlo :-), perci� ho scelto di creare un file WavMediaStreamSource che carica tramite WebRequest un file wav e legge l'header per conoscere il numero di canali, i samples al secondo (solitamente 44100) e i bit (8/16). L'implementazione poi non fa altro che rigirare i byte al MediaElement.

Ho portato poi l'algoritmo FFT e di calcolo dei picchi sulla mia libreria Silverlight e diviso il controllo del post precedente in due parti: DataAudioPeakMeter e SamplesAudioPeakMeter. Il primo lavora con il file dat precalcolato e funziona con tutti i formati supportati da SL. Il secondo lavora solo con i file WAV, ma funziona in real time. Entrambi poi fanno uso della BarVisualization per l'animazione.

L'utilizzo � piuttosto semplice:

<MediaElement AutoPlay="False"
              x:Name="media" />

<!-- Visualization -->
<a:SamplesAudioPeakMeter x:Name="sa">
    <a:BarVisualization BarSegmentHeight="4"
        BarMargin="1"
        BarSegmentMargin="1"
        StrokeBrush="Yellow"
        StrokeThickness="1">
        <a:BarVisualization.BarBrush>
            <LinearGradientBrush StartPoint="0,0" EndPoint="0,1">
                <GradientStop Offset="1"
                              Color="Black" />
                <GradientStop Offset="0"
                              Color="Blue" />

            </LinearGradientBrush>
        </a:BarVisualization.BarBrush>
    </a:BarVisualization>
</a:SamplesAudioPeakMeter>

Da codice poi dobbiamo legare la sorgente wav sia al MediaElement che al SamplesAudioPeakMeter:

WavMediaStreamSource source = new WavMediaStreamSource(new Uri("test1.wav", UriKind.RelativeOrAbsolute));
source.Loop = true;

// Binding Source -> Visualization
sa.SetSource(source);
// Binding Source -> MediaElement
media.SetSource(source);

Ed ecco il risultato:

Ovviamente i file wav sono di grandi dimensioni quindi questa tecnica � adatta per file di piccola di dimensione sulla quale fare loop, ma meglio di niente :-). Poi speriamo che magari nella RTM di Silverlight 3.0 ci sia la possibilit� di accedere ai samples gi� decodificati.

Infine le performance: escludendo l'animazione sono rimasto piuttosto colpito. La mia CPU resta su un 2% per calcolare FFT e picchi. Includendo l'animazione si arriva poi ad un 25/30%, ma va considerato che SL tenta sempre di andare al massimo di frame rate per l'esecuzione delle animazioni.
Presto metter� i sorgenti: promesso!

Tags: Silverlight, Silverlight - animazioni, Silverlight 2.0, XAML

Salvare immagini Bitmap con Silverlight 3.0

Cristian "Ricciolo" Civera — Fri, 29 May 2009 17:56:00 GMT

In Silverlight 3.0 � stato aggiunta la possibilit� di salvare file in locale attraverso la SaveFileDialog. Per motivi di sicurezza, questa pu� essere visualizzata solo all'interno di un evento scatenato dall'utente (pressione del pulsante, ecc) mentre attraverso OpenFile � possibile poi aprire uno Stream per la scrittura sulla quale � possibile scrivere qualsiasi cosa.

In una discussione con Marco ci � venuto il dubbio se si poteva salvare immagini in locale, ma purtroppo la cosa non � molto semplice da raggiungere. In SL infatti non ci sono API per effettuare encoding ed decoding di immagini ad eccezione del passare uno Stream da visualizzare. Inoltre con WriteableBitmap � stata aggiunta la possibilit� di caricare uno Stream o di renderizzare un UIElement su un'immagine, ma poi non � possibile accedere ai byte. Insomma, se si ha un'immagine gi� codificata in JPEG/PNG basta semplicemente travasare lo Stream sorgente verso il file locale, altrimenti se si ha solo i byte grezzi dell'immagine occorre scriversi il motore di encoding e di creazione del contenitore.

Per fortuna c'� il buon vecchio file BMP, la cui definizione si pu� trovare qui, che � abbastanza semplice da creare e a parte dover accodare i byte dell'immagine dal basso verso l'altro, non necessita di algoritmi di compressione. Ovviamente il file risultante � di grandi dimensioni, ma non dev'essere trasportato in rete, ma bens� salvato direttamente in locale. Ho scritto quindi un BitmapEncoder e un BitmapFrame per salvare un'immagine in BMP, lo trovate completo di sorgente qua. L'esempio allegato genera un'immagine con un algoritmo e la mostra anche attraverso un WriteableBitmap.

Purtroppo non serve a tantissimo, perch� attualmente la WriteableBitmap non permette di accedere ai pixel e quindi non � possibile salvare screenshot effettuati sugli elementi. Potenzialmente si pu� creare qualsiasi file, ma ovviamente non � semplice doversi riscrivere librerie di creazione di file, non potendosi appoggiare a oggetti COM.

Tags: Silverlight, XAML, Silverlight 3.0

.NET Framework 4.0 beta 1: Tuple

Cristian "Ricciolo" Civera — Wed, 27 May 2009 04:00:00 GMT

Altro post per un'altra novit� del .NET Framework 4.0: le classi Tuple. In pratica sono delle classi generiche con tanti argomenti generici quanti sono le relative propriet� che esse espongono.

Per esempio Tuple<T1, T2> ha una propriet� Item1 di tipo T1 e una propriet� Item2 di tipo T2. Ci vengono molto comode per quelle volte che nei nostri algoritmi, per velocizzare la scrittura del codice (o per pigrizia :-) ), abbiamo bisogno di una classe che faccia da repository dei valori. Inoltre la loro caratteristica � di implementare GetHashCode, Equals e l'interfaccia IComparable, IStructuralEquatable (nuova in .NET 4.0) e IStructuralComparable (nuova in .NET 4.0) in modo che a parit� dei valori, due istanze di Tuple diverse risultino uguali. Si comportano quindi come un valore atomico e sono l'ideale per essere utilizzate come chiavi per dictionary o per hash set.

Per capirci quindi:

var t = Tuple.Create<Int32, String>(2, "ciao");
var t2 = Tuple.Create<Int32, String>(2, "ciao");

Console.WriteLine(t.Item2);
Console.WriteLine("Reference equals: {0}", Object.ReferenceEquals(t, t2));
Console.WriteLine("Equals: {0}", t.Equals(t2));

stampa a video:

ciao
Reference equals: False
Equals: True

In effetti c'� una forte somiglianza agli anonymous type sebbene quest'ultimi sono generati dal compilatore e hanno propriet� dal nome che vogliamo. In comune hanno infatti che due istanze diverse, ma con identici valori, risultano uguali se comparati tra loro. Non implementano per� IStructuralEquatable, ma non credo che questo sia un problema. Se necessitiamo di lavorare a livello d'interfaccia allora tanto vale restituire una tuple nelle nostre query.

Tags: .NET Framework, .NET Framework 4.0

.NET Framework 4.0 beta1: le classi Lazy<T> e LazyVariable<T>

Cristian "Ricciolo" Civera — Tue, 26 May 2009 16:42:00 GMT

Tra le tante piccole e grandi novit� del .NET Framework 4.0 ci sono le classi Lazy<T> e LazyVariable<T>. Il concetto � molto semplice: istanziamo un tipo passando un delegate ad una funzione che restituisce un valore; la prima volta che interroghiamo la propriet� Value, il delegate viene chiamato e il valore persistito per le successive interrogazioni.

Ecco un esempio:

static void Main(string[] args)
{
    Lazy<String> v = new Lazy<String>(GetValue);
    Lazy<String> v2 = v;

    Console.WriteLine(v.Value);
    Console.WriteLine(v.Value);
    Console.WriteLine(v2.Value);
}

private static string GetValue()
{
    Console.WriteLine("GetValue called");
    return "ciao";
}

che stampa a video:

GetValue called
ciao
ciao
ciao

La differenza con LazyVariable � che questa � una struct invece che una classe. Perci� il seguente codice:

static void Main(string[] args)
{
    LazyVariable<String> v = new LazyVariable<String>(GetValue);
    LazyVariable<String> v2 = v;

    Console.WriteLine(v.Value);
    Console.WriteLine(v.Value);
    Console.WriteLine(v2.Value);
}

stampa:

GetValue called
ciao
ciao
GetValue called
ciao

Questo perch� quando si assegna v a v2, viene copiata l'intera struttura e non mantenuto un riferimento alla classe come avviene con Lazy.
Entrambe le classi sono inoltre serializzabili e accettano nel costruttore un LazyExecutionMode che dispone di tre valori: NotThreadSafe, EnsureSingleThreadSafeExecution, AllowMultipleThreadSafeExecution. In questo modo possiamo decidere se accedere a Value indicando che solo un thread ci acceder�, oppure pi� thread ci possono accedere e solo una volta il delegate viene eseguito (tramite lock), oppure pi� thread ci accedono e una o pi� volte il delegate potrebbe essere eseguito (il default). Mi piacerebbe che implementassero anche la conversione implicita verso T cos� da non dover interrogare Value, ma forse lo faranno :-)

Tags: .NET Framework, .NET Framework 4.0

C# 4.0 Beta 1, quello che io ho visto

Andrea Zani — Sun, 24 May 2009 18:33:00 GMT

Gioved� ho trovato il tempo di installare sulla mia macchina la nuova versione di Visual Studio 2010 beta 1. Leggendo i vari documenti sulle novit�, la mia curiosit� � stata attratta dalle novit� del linguaggio C# della version 4.0. Da quel che ho capito sono quattro le novit�:

Dynamic Typed Objects
Optional and Named Parameters
Improved COM Interoperability
Co/Contra-Variance

Sui dynamic ho avuto proprio una discussione sul fatto che la keywork dynamic non centra nulla con var. La dichiarazione di un oggetto come dynamic, crea effettivamente un oggetto di tipo dinamico in runtime ed elaborato in late-binding, con tutti i problemi che ne derivano!

Scrivere queste linee di codice ora � perfettamente corretto:

dynamic az = "Andrea";
Console.WriteLine(az); // Andrea
az = 14;
az = 14 * 2;
Console.WriteLine(az); // 28
az = new System.Data.DataTable();
Console.WriteLine(az.GetType()); // System.Data.DataTable

Ma questo nuovo oggetto � utilizzabile anche nelle dichiarazioni di metodi e altro:

Dynamic1("aa");
Dynamic1(12);
...

static void Dynamic1(dynamic value)
{
   if (value is string)
      Console.WriteLine(value + " is a string!");
   if (value is int)
      Console.WriteLine(value + " is a int!");
}

Ma la potenzialit� del dynamic vanno ben oltre. E' possibile ora chiamare oggetti COM in modo molto pi� semplice, ed � diventato anche banale caricare runtime una dll e utilizzarne i metodi. Per esempio, avevo questa classe in una dll esterna:

namespace TestDynamic
{
    public class Utilities
    {
        public string GetAll(string name)
        {
            return string.Format("{0}: {1}", name, DateTime.Now);
        }
    }
}

Possiamo caricarla e utilizzarla con i dynamic (senza reference). Un esempio di codice che fa questo:

dynamic mya = Assembly.LoadFile("../class.dll");
Type myaClassType = mya.GetType("TestDynamic.Utilities");
dynamic myaDemoClassObj = Activator.CreateInstance(myaClassType);
string val = myaDemoClassObj.GetAll("az");

Facile e comodo? Pu� essere, ma l'utilizzo del dynamic non � immune da problemi. Innanzitutto prestazionale: come detto prima, tutto ci� che � dynamic � elaborato in runtime/late-binding, dunque con tutti i problemi di prestazioni che ne derivano. L'esempio di codice qui sopra, se confrontato con un metodo tradizionale di loading di una dll e utilizzo del reflector o, meglio, di interfacce, perde su tutti i fronti. Secondo problema: Visual Studio 2010 non � in grado di fornici l'intellisense:

L'utilizzo dei parametri opzionali o dichiarandone il nome � una di quelle novit� che ricordano tanto ci� che Visual Basic offre da parecchio tempo:

public string MyMethod(int Id = 0, string Name = "AZ")
{
...
}

Che crea in automatico gli overload del metodo passando ai parametri i valori di default specificati:

            MyMethod();
            MyMethod(1);
            MyMethod(1, "Andrea");

E se nell'esempio sopra volessimo passare solo il parametro Name e non l'Id? Questo codice ci darebbe errore, perch� si aspetta in ogni caso come primo parametro un int:

MyMehotd("Andrea");

Una delle altre novit� di C# 4.0, � la possibilit� di dichiarare oltre al valore anche il parametro a cui sar� assegnato:

MyMethod(Name: "Andrea");
MyMethod(Name: "Andrea", Id: 1);

L'ultima novit�, Covariance e Contravariance. La covariance permette di trattare gli oggetti come il tipo da cui deriva. Per esempio, avendo le classi:

    public class First
    {
    }
    public class Second : First
    {
    }

Possiamo scrivere:

First[] coll = new Second[20];

Ma non possiamo in alcun modo utilizzare questa possibilit� nel caso dei generic essendo il C# a cui siamo abituati invariant:

List<Second> xsecond = new List<Second>();
List<First> xfirst = xsecond;

Cannot implicitly convert type 'System.Collections.Generic.List<Test1.Second>' to 'System.Collections.Generic.IList<Test1.First>'.

Attualmente ci sono altri metodi per copiare un oggetto o una collection di oggetti (cast o Linq). Con la nuove versione di C#, abbiamo una nuova tecnica ma, come scritto sopra, per ora � possibile solo con le interfacce e delegate modificare questo comportamento:

public class Other<T> where T : First // Or without constraint
{
}
public class Other2<T> : IOther2<T>
{
}
interface IOther2<out T>
{
}

Ora, grazie all'interfaccia (e la specifica del generic T con out), possiamo utilizzare anche gli oggetti derivati della nostra classe:

var xot2 = new Other2<Second>();
IOther2<First> xot21 = xot2;

La keyword out � utilizzata per specificare gli oggetti in output, mentre in come � facilmente intuibile � utilizzabile come parametro input di metodi con i delegate, eccole utilizzare entrambe con i delegate:

delegate T Func1<out T>();
delegate void Action1<in T>(T a);
...
// Covariance
Func1<Second> secondx = () => new Second();
Func1<First> firstx = secondx;
// Contravariance
Action1<First> act1 = (ani) => { Console.WriteLine(ani.ToString()); };
Action1<Second> cat1 = act1;
cat1(new Second());

Ho detto qualcosa di inesatto? E' facile che sia cos�: il mio studio sulle novit� di questo linguaggio si basano su test e letture che il poco tempo libero attuale mi permette. Questa scusa mi lascia scevro di responsabilit�? Se ne sono convinto io...

Tags: .NET Framework, .NET Framework 4.0, Visual Studio

Silverlight - Audio peak meter

Cristian "Ricciolo" Civera — Sat, 23 May 2009 16:59:00 GMT

Qualche tempo fa realizzai un controllo per l'analisi dello stream audio e la visualizzazione dei picchi attraverso WPF. Nel tempo libero del tempo libero, da appassionato di DirectShow e di fuffologie mi son chiesto se si poteva fare una cosa simile anche in Silverlight.

Il problema � che in Silverlight non si ha a disposizione DirectShow, non si pu� usare codice unmanaged ne si pu� accedere allo stream audio. L'unico oggetto che abbiamo � MediaElement che permette di riprodurre audio e video; nella versione 2.0 c'� la classe MediaStreamSource, ma sebbene non abbia avuto ancora modo di provarla a fondo, permette di accedere allo stream codificato e non quello decodificato, perci� scrivere un decoder mp3 in codice managed non � proprio una passeggiata :-). Per poter applicare FFT e calcolare decibel e picchi dobbiamo infatti avere i byte grezzi, come i file wav.

Siccome per la maggior parte dei casi pu� bastare un piccolo loop su una canzone ho trovato una facile soluzione: precalcolare. In pratica ho realizzato una console application, interamente managed, che apre un file audio, calcola FFT ecc e salva in un file tutti i byte rappresentativi dei picchi, circa 12 suddivisi per 19 frequenze al secondo.

Una volta che si ha il file audio e il file .dat contenente i picchi, tramite un controllo posso mostrarne i valori. Il controllo AudioMeter ha bisogno del file .dat e del MediaElement sul quale basarsi per mostrare i picchi in funzione della posizione. Ecco il risultato:

Per rendere il pi� fluido possibile l'animazione intercetto CompositionTarget.Rendering che viene scatenato ad ogni frame dell'applicazione Silverlight che viene renderizzato. Le barre che vanno su e gi� sono invece animate da DoubleAnimation.

Devo dire che sono molto soddisfatto del risultato. Anche se il video non rende moltissimo, l'animazione � molto fluida e ben sincronizzata, meglio di quanto avevo fatto con WPF.

Tags: Silverlight, Silverlight - animazioni, Silverlight 2.0, Silverlight 3.0, XAML

.NET Framework 4.0 beta 1: modifiche agli assembly

Cristian "Ricciolo" Civera — Thu, 21 May 2009 20:22:00 GMT

La nuova versione del .NET Framework � un passo molto importante perch� oltre a contenere nuove tecnologie o migliorie, si pu� dire che si d� anche un po' una ripulita e una riorganizzazione visto che il framework era diventato un po' confuso quando dopo la versione 2.0 � stato aggiunta la 3.0 che era basata sempre sulla 2.0, poi allo stesso modo la 3.5 ed infine il service pack 1 che introduceva ancora novit�.

Innanzitutto date un occhio al MetadataDiffViewer che l'ho aggiornato alla versione 4.0 cos� non si perde nessuna novit�. Innanzitutto gli assembly sono tutti 4.0 e balzano all'occhio alcuni come System.Web.Routing o System.Web.Abstractions che esistono ancora, ma non contengono classi. Questo perch� le loro classi sono state trasferite, come giusto che sia, nell'assembly System.Web. Attraverso i due attributi TypeForwardedToAttribute (presente gi� dalla versione 2.0) e TypeForwaredFromAttribute si indica a compilatori, CLR e serializzatori vari di redirigere dalla vecchia posizione a quella nuova. In questo modo le applicazioni compilate per il 3.5 SP1 vengono rediretti alla nuova versione 4.0. Le nuove applicazioni invece verranno compilate con la referenza corretta.

Oltre alle novit� pi� importanti ho trovato qualcosa di interessante:

una classe System.AggregateException per raggruppare pi� eccezioni;
il nuovo namespace System.Collections.Concurrent contenente Queue, Dictionary e Stack gi� sincronizzate e quindi thread safe. Molto interessante la classe Partitioner per creare enumerazioni che smistano automaticamente il carico di lavoro tra pi� consumer che ne fanno richiesta;
il nuovo namespace System.Diagnostics.Contracts che contiene in particolare la classe Contract per indicare nel codice verifiche da effettuare in fase di compilazione e/o a runtime all'inizio o alla fine di una funzione (ne parler� in dettaglio con un altro post);
le classi relative a PLINQ, a ParallelFX, lock ottimizzati come: Task, Parallel, SpinLock, ecc.
le classi Tuple usate da F# per� quante volte pu� servire memorizzare delle informazioni in modo veloce senza creare una classe con propriet� apposite;
il nuovo namespace e assembly System.ComponentModel.Composition che contiene tutta la parte di Managed Extensibility Framework;
in System.Core tante nuove Action e Func :-) Per la parte di expression e delle query LINQ ci sono alcune nuove classi Expression che permettono di fare degli statement: GotoExpression, LoopExpression, SwitchExpression, TryExpression, ecc. Un bellissimo ExpressionVisitor per sfogliare un'espressione: ci voleva!;
i nuovi assembly. System.Web.DataVisualization e System.Windows.Forms.DataVisualization contenente i controlli di charting per web e windows.

E questo � solo l'inizio, che bello che bello, tante cose nuove :-)

Tags: .NET Framework, .NET Framework 3.5, .NET Framework 4.0, ASP.NET, ASP.NET 4.0, LINQ, Visual Studio

.NET Framework 4.0 beta 1: la documentazione

Daniele Bochicchio — Thu, 21 May 2009 08:51:00 GMT

Da qualche giorno � disponibile anche la documentazione per il .NET Framework 4.0 beta 1 e per VS 2010 beta 1.

Ecco i link:

Tutti i contenuti aggiornati sono nel nostro canale dedicato al .NET Framework 4.0.

Tags: .NET Framework, .NET Framework 4.0, ASP.NET, ASP.NET 4.0, Visual Studio

.NET Framework 4.0 beta 1: Visual Studio 2010 e Training Kit disponibili per tutti

Matteo Casati — Thu, 21 May 2009 07:25:06 GMT

Come preannunciato nel post precedente, il download di Visual Studio 2010 beta 1 � ora disponibile per tutti; inoltre anche il Training Kit su Visual Studio 2010 e il .NET Framework 4 � stato aggiornato alla beta 1.

Maggiori informazioni sul blog del team MSDN Italia qui e qui e, ovviamente, sul mini-sito in ASPItalia.

Buon download a tutti :-)

Tags: .NET Framework, .NET Framework 4.0, ASPItalia.com, Visual Studio