Borsalino Moreno

Quelli di Azure sono troppo avanti

2011-12-18T16:54:34Z

tratto dalla pagina http://www.windowsazure.com/it-it/develop/downloads/

IE9 bello ma …

2011-04-08T08:38:00Z

Dopo molte peripezie sono riuscito ad installare un ie9 su un portatile touchscreen. Effettivamente IE9 e’ piu’ veloce ma l’interfaccia e’ peggiorata, con le icone cosi’ piccole non riesco piu’ ad usare il browser solo con le dita. Ma Ipad non ha insegnato niente ? E’ vero che Microsoft sui tablet si e’ storicamente fissata su quelli da usare con la penna ma sarebbe bello predisporre tutti gli applicativi di una doppia interfaccia per il mouse e le dita. Non dovremo mica aspettare Windows 8 per scoprire sta cosa ?

IE9 ed il mistero dei gadgets scomparsi

2011-03-16T08:54:00Z

Preso dall’emozione non ho saputo resistere ed ho installato IE9 su un pc con windows 7 su cui ho appena messo la SP1. Ho aspettato la versione finale di IE poiche’ non mi fido piu’ a provare cose in preview, ctp, beta, rc e simili. Installo e ….. I gadgets non funzionano piu’ . Restano neri o bianchi oppure ne appare solo un pezzettino e comunque non funzionano. Provato a toglierli e rimetterli, provato a reinstallarli ma niente di niente, tutto inutile. Alloro disinstallo IE9 e torno all’8 ma I gadgets restano sballati
Ora cerco su Google se qualche altra anima sfortunata ha qualche soluzione

Ipad

2010-11-06T19:08:00Z

Titolo ermetico per alcune riflessioni nate dopo una prova approfondita di un Ipad.

Oggetto fantastico sotto tutti i punti di vista. Unico dubbio: ma ci voleva proprio Apple per tirarlo fuori e farne un successo ?
I concetti alla base di Ipad sono tutti fattibili con altre tecnologie e piattaforme anzi erano realizzabili da molto molto tempo ma nessuno ci ha creduto, nemmeno Microsoft. Già nel 2003 avevo provato dei tablet pc al Cebit e li consideravo molto interessanti se solo avessere avuto un’interfaccia meno computereccia e più “umana”. Ci sono voluti 7 anni per vedere quell’idea realizzata.
Microsoft con il multitouch su Windows 7 aveva in parte illuso ma il multitouch è scomparso fino a diventare qualcosa di nicchia, per fare scena. Già trovare un monitor multitouch è un’impresa, per non parlare dei tablet multitouch. Ne sto usando uno della Acer e le uniche applicazioni che ho trovato sono quelle del Microsoft Touch Pack for Windows 7.
Per carità! Sono molto belle e sembra proprio di usare un Ipad. Ma ci si ferma li, non ce ne sono altre ne da parte di Microsoft ne di altri.
OK, direte che non vale la pena farle se poi pochissimi possono utilizzarle. Concordo, ma qui secondo me è colpa di un mercato lasciato a se stesso senza una guida forte. Per esempio, su Windows Phone 7 Microsoft impone restrizioni HW ben precise. Se avesse fatto lo stesso anche sul Windows 7 da tavolo imponendo per esempio uno schermo obbligatoriamente multitouch forse le cose sarebbero diverse (io avrei obbligato a mettere anche un gps, un g-sensor ed un modulo 3G ma è una mia fissa personale). Forse il fenomeno Ipad non sarebbe stato cosi’ tanto fenomeno. Forse ci sarebbero comunque migliaia di applicazioni per Ipad ma esisterebbe forse l’equivalente per Win7. Perchè i giornali si sono buttati a fare lettori di giornale per Ipad ed invece sul pc devo leggermi il giornale con il browser ? Eppure un’aplicazioncina wpf che fa scorrere un testo (magari col dito) non è fantascienza. Si,Ok, di Ipad ne vendono a milioni mentre di Win7 multitouch molto meno.

Quello che Microsoft ha fatto molto bene è invece Surface, un oggetto fantastico ma … un po’ imgombrante. Forse se ne sono accorti e stanno calibrando il tiro. C’è un promettente tool in beta per realizzare applicazioni stile surface su un pc : Microsoft® Surface® Toolkit for Windows Touch Beta Vedremo che cosa succederà sul lungo termine. Anche un certo movimento dei costruttori verso I tablet sembra smuovere finalmente le acque. Si parla pero’ tanto di Android e poco di Windows 7. Peccato. Speriamo non diventi un’altra occasione perduta.

Insomma tante parole per dire che ho messo fianco a fianco Ipad e Acer tablet e non vedo differenze se solo Acer avesse un’interfaccia alla Ipad e tante tante applicazioni quante ne ha Ipad. Forse dovrebbe essere Microsoft, visto il peso, a muoversi ed agitarsi in prima persona, ed invece niente. Si, ok, si agita su altri fronti ma su questo nulla, neanche una produzione di maggiori applicazioni per Win7 da usare col dito. OK, non chiedo un Visual studio per il dito ma almeno una versione di IE9 con UI finger-easy ? Una mappa da usare solo con le dita ? Un media player o un media center un po’ più ditoso ? Oppure ci sono ma non riesco a trovarli ?

Pensieri pruriginosi da giorno di pioggia ? Mah …forse si.

Vinci 2000 $ con Open Kinect Project

2010-11-06T17:35:00Z

Tra pochi giorni Kinect sarà disponibile nei negozi. La publicità sui volantini già lo mostra e 149 Euro per l’oggetto del desiderio (non solo dei bambini) alla portata di tutti…beh, avendo un Xbox ovviamente…o forse no ?

Alcuni lo hanno già smontato e sezionato nelle più piccole parti : Microsoft Kinect Teardown

Ma la notizia che voglio segnalare è un premio di 2000 US $ offerto da Adafruit a chi per primo crea un driver open source per Kinect. Ed a quel punto non servirebbe piu’ Xbox

Il driver deve essere accompagnato da 2 applicazioni di test, una che mostra il video catturato dal sensore e una che mostra la distanza rilevata dal sensore.

The Open Kinect project – THE OK PRIZE – get $2,000 bounty for Kinect for Xbox 360 open source drivers (now $2k)

Expression Encoder 4 Live Performance Tool

2010-10-03T19:02:00Z

Il nuovo Expression Encoder 4 è un tool per la codifica di video anche di qualità HD ma richiede hw molto potente. Per testare se il nostro hw può farcela Microsoft offre un tool scaricabile qui :

Expression Encoder 4 Live Performance Tool

Informazioni su come realizzare un sistema di smooth streaming live si puo’ trovare in quest’articolo:

Live IIS Smooth Streaming in Expression Encoder 4

JumpControl risolve il problema del reboot su W7 in remoto

2010-09-02T16:21:00Z

Con Windows 7 avevo il problema frequente di dover fare reboot o shutdown a computer via Remote Desktop. Purtroppo nel menu di start si puo’ fare solo LogOff o Lock. Mi ero organizzato usando dei comandi tipo:

'shutdown -f -s -t 1' per lo shutdown
'shutdown -f -r -t 1' per il restart

Poi su Channel 10 e’ uscito un articolo su JumpControl che aggiunge un bottone nella taskbar che permette di fare Shutdown e Restart. Una meraviglia!

Quando il risveglio del Media Center è sgradito

2010-04-16T21:04:00Z

Il Media Center è per me la versione piu’ piacevole per uso casalingo. Tuttavia ha uno sgradevole difetto. Il PC si risveglia per scaricare l’aggiornamento della guida TV e poi resta acceso. La cosa mi da veramente fastidio ma ancor di piu’ il fatto che disabilitare questo comportamento non è proprio facile. Mettere una riga tra i settings era troppo semplice ?

La causa : il task mcupdate_scheduled risveglia il computer per scaricare la guida. L’ora di esecuzione è modificabile.

La soluzione : disabilitare il risveglio del pc per eseguire il task.

Ecco come. Aprire il Task Scheduler e cercare il task da modificare :

Start > All Programs > Accessories > System Tools > Task Scheduler

Nell’albero di sinistra aprire Task Scheduler Library > Microsoft > Windows > Media Center

Nell’elenco dei Task nel pannello centrale cercare mcupdate_scheduled. Tasto destro del mouse per selezionare “Properties”. Selezionare il tab Conditions e quindi disabilitare il check "wake the computer to run this task".

Technorati Tags: Media Center,Windows 7

Estrarre la product key di SQL Server

2011-01-17T22:12:33Z

Tempo fa avevo installato un server TFS 2010 di prova prendendo la versione di valutazione basata su un'immagine per Hyper-V già preinstallata. Adesso il periodo di valutazione è scaduto ma vorrei inserire delle chiavi regolari per renderlo operativo senza scadenze. Tutto fattibile tranne che per SQL Server. Infatti sia su MSDN che su volume license non viene fornita la product key ma solo installazione con chiave precablata.

Ma per riattivare un'installazione di SQL Server 2008 scaduta c'è bisogno della chiave. Altrimenti bisogna reinstallare tutto.

Bisogna lanciare "SQL Server Installation Center", fare click su Maintenance a sinistra e poi click su Edition Upgrade.
Cliccando un po' di volte su Next si arriva alla pagina Product Key in cui bisogna inserire la chiave. Ma dove prenderla ?

Esistono dei programmi che dicono di essere capaci di estrarre la chiave usata nell'installazione ma mi sono salvato trovando un pezzettino di codice powershell che estrare la chiave e funziona perfettamente. L'ho verificato su Sql Server 2008 e 2008 R2.

function Get-SQLserverKey {
    ## function to retrieve the license key of a SQL 2008 Server.
    ## by Jakob Bindslet (jakob@bindslet.dk)
    param ($targets = ".")
    $hklm = 2147483650
    $regPath = "SOFTWARE\Microsoft\Microsoft SQL Server\100\Tools\Setup"
    $regValue1 = "DigitalProductId"
    $regValue2 = "PatchLevel"
    $regValue3 = "Edition"
    Foreach ($target in $targets) {
        $productKey = $null
        $win32os = $null
        $wmi = [WMIClass]"\\$target\root\default:stdRegProv"
        $data = $wmi.GetBinaryValue($hklm,$regPath,$regValue1)
        [string]$SQLver = $wmi.GetstringValue($hklm,$regPath,$regValue2).svalue
        [string]$SQLedition = $wmi.GetstringValue($hklm,$regPath,$regValue3).svalue
        $binArray = ($data.uValue)[52..66]
        $charsArray = "B","C","D","F","G","H","J","K","M","P","Q","R","T","V","W","X","Y","2","3","4","6","7","8","9"
        ## decrypt base24 encoded binary data
        For ($i = 24; $i -ge 0; $i--) {
            $k = 0
            For ($j = 14; $j -ge 0; $j--) {
                $k = $k * 256 -bxor $binArray[$j]
                $binArray[$j] = [math]::truncate($k / 24)
                $k = $k % 24
         }
            $productKey = $charsArray[$k] + $productKey
            If (($i % 5 -eq 0) -and ($i -ne 0)) {
                $productKey = "-" + $productKey
            }
        }
        $win32os = Get-WmiObject Win32_OperatingSystem -computer $target
        $obj = New-Object Object
        $obj | Add-Member Noteproperty Computer -value $target
        $obj | Add-Member Noteproperty OSCaption -value $win32os.Caption
        $obj | Add-Member Noteproperty OSArch -value $win32os.OSArchitecture
        $obj | Add-Member Noteproperty SQLver -value $SQLver
        $obj | Add-Member Noteproperty SQLedition -value $SQLedition
        $obj | Add-Member Noteproperty ProductKey -value $productkey
        $obj
    }
}

Per ottenere la chiave sul PC locale:

Get-SQLserverKey

Per ottenere la chiave da uno o piu' server remoti:

Get-SQLserverKey "pc1", "pc2", "server999", "server777"

Il codice proviene da questo post SQL Server Product Key di Jakob Bindslet.

Grazie Jakob !

[EF] QueryCompilate e MergeOption

2010-01-17T20:49:00Z

Per ottenere il massimo delle prestazioni quando si devono usare LINQ query è consigliato precompilarle e quando possibile usare anche l’opzione MergeOption.NoTracking. Quest’ultima evita di salvare le informazioni sulle modifiche degli oggetti nell’ObjectContext. E cosi’ ho fatto; ho compilate le query e le ho usate per leggere delle entità e modificarle. Ma ad un certo punto saltava fuori un errore sulla SaveChanges che non poteva essere eseguita poichè la query era stata compilata con l’opzione MergeOption.NoTracking.

Vediamo cosa era successo. Consideriamo il seguente codice che compila una query che ritorna un utente data la email. Poi ci sono due metodi che usano questa query; una che legge solamente il nome dell’utente e quindi viene preceduto dal NoTracking ed un secondo metodo che scrive il nome dell’utente e quindi implicitamente è preceduta da AppendOnly, il valore di default di MergeOption .

public class QueryCompiled

  public static Func<MyEntities, string, IQueryable<Users>> GetUserByEmail =

            CompiledQuery.Compile<MyEntities, string, IQueryable<Users>>(

                                             (MyEntities ctx, string email) =>

                                             from a in ctx.Users

                                             where a.Email == email

                                             select a);

public class A

  public string GetUserName(string email)

    using (MyEntities context = new MyEntities())

      context.Users.MergeOption = MergeOption.NoTracking;

      var users= (QueryCompiled.GetUserByEmail(context, email));

      return users.Name;

  public void SetUserName(string email, string name)

    using (MyEntities context = new MyEntities())

      var users= (QueryCompiled.GetUserByEmail(context, email));

      users.Name = name;

      context.SaveChanges();

Se l’ordine di esecuzione dei metodi della classe A è il seguente va tutto bene :

A classeA = new A();
classeA.SetUserName(“aaa@aaa.aa”, “pippo”);
classeA.GetUserName(“aaa@aaa.aa”);

Se l’ordine di esecuzione si inverte, come nel seguente caso, allora ottengo l’errore che dicevo prima :

A classeA = new A();
classeA.GetUserName(“aaa@aaa.aa”);
classeA.SetUserName(“aaa@aaa.aa”, “pippo”);

Il motivo è il seguente; quando la query compilata viene invocata la prima volta allora viene memorizzata in una chache una forma ottimizzata della query. Durante questa prima invocazione vengono memorizzate altre informazioni tra cui anche il tipo di MergeOption attivo nel momento dell’invocazione. Quest’ultimo è un particolare importante il cui dettaglio non avevo trovato nella documentazione ufficiale. Nel secondo caso indicato sopra succede che la prima volta viene invocata la query compilata con MergeOption.NoTracking e questo valore viene associato alla query compilata per cui quando dopo vado a richiamare la stessa query compilata per modificare un valore nel momento in cui si esegue SaveChanges la query fallisce perche’ risulta che è attivo il NoTracking. Notare che non cambia nulla se vado ad aggiungere un MergeOption.AppendOnly nel metodo SetUserName. Non cambia nulla anche se richiamo la query con un diverso ObjectContext; insomma, il MergeOption è associato indissolubilmente con la query compilata.
La soluzione è quella di duplicare la compilazione della query o meglio fare una compilazione separata per ogni valore della MergeOption che si intende usare. Purtroppo si ripeterebbe piu’ volte il codice della query LINQ. La soluzione ottimale è quella di usare un CompiledQueryReplicator che è una classe che permette di specificare la query LINQ una volta sola e automaticamente di compilare piu’ istanze della stessa. Le istanze vengono inserite in un Dictionary la cui Key è il tipo di MergeOption con cui si vuole compilare la query. L’idea è stata già esplicitata in questo progetto su CodePlex : http://dcutilities.codeplex.com e li si puo’ andare a recuperare le due classi CompiledQueryReplicator e EfCompiledQueryReplicatorFactory. Consiglio anche di leggere il tutorial per la spiegazione di come usarle. Di seguito riporto per semplicità il codice delle due classi.

    /// <summary>

    /// The CompiledQueryReplicator is a class that allows you to specify a LINQ query once, then

    /// automatically compile different instances of it. This is useful when you need multiple instances

    /// of the same query compiled with different <see cref="System.Data.Objects.MergeOption"/>s,

    /// for example. Each instance is identified with a particular key of type <typeparamref name="TKey"/>.

    /// </summary>

    /// <remarks>

    /// <para>

    /// If you're using the Entity Framework (LINQ to Entities), it is suggested that you use the

    /// <see cref="EfCompiledQueryReplicatorFactory{TKey}"/> class to instantiate instances of this

    /// class, as it makes the syntax shorter and automatically provides you with the Entity Framework

    /// compiled query compiler.

    /// </para>

    /// <para>

    /// This class is thread-safe.

    /// </para>

    /// </remarks>

    /// <typeparam name="TQuery">The type of the query</typeparam>

    /// <typeparam name="TKey">The type to use as the key</typeparam>

    public class CompiledQueryReplicator<TQuery, TKey>

        private readonly Expression<TQuery> _QueryExpressionTree;

        private readonly Func<Expression<TQuery>, TQuery> _Compiler;

        private readonly IDictionary<TKey, TQuery> _CompiledQueries;

        /// <summary>

        /// Creates a CompiledQueryReplicator using the specified query that will be compiled with

        /// the specified compiler.

        /// </summary>

        /// <param name="query">The query's expression tree</param>

        /// <param name="compiler">

        /// A delegate that can compile the query expression tree into an actual query

        /// </param>

        public CompiledQueryReplicator(Expression<TQuery> query, Func<Expression<TQuery>, TQuery> compiler)

            _QueryExpressionTree = query;

            _Compiler = compiler;

            _CompiledQueries = new Dictionary<TKey, TQuery>();

        /// <summary>

        /// Returns the compiled query instance associated with the specified key. If

        /// no query instance has been created for the specified key, one will be

        /// and it will be returned.

        /// </summary>

        /// <param name="key">The key</param>

        /// <returns>The compiled query.</returns>

        public TQuery this[TKey key]

get

                TQuery query;

                lock (_CompiledQueries)

                    if (_CompiledQueries.ContainsKey(key) == false)

                        query = _Compiler(_QueryExpressionTree);

                        _CompiledQueries.Add(key, query);

                    else

                        query = _CompiledQueries[key];

                return query;

    /// <summary>

    /// Factory class that makes it easier to create <see cref="CompiledQueryReplicator{TQuery,TKey}"/>

    /// instances that hold LINQ to Entities compiled queries.

    /// </summary>

    /// <typeparam name="TKey">T

    /// he type to use as the key for the CompiledQueryReplicators created

    /// </typeparam>

    public static class EfCompiledQueryReplicatorFactory<TKey>

        /// <summary>

        /// Creates a <see cref="CompiledQueryReplicator{TQuery,TKey}"/> that compiles LINQ to Entities

        /// queries.

        /// </summary>

        /// <typeparam name="TArg0">

        /// The <see cref="ObjectContext"/> that encapsulates the model connection and metadata.

        /// </typeparam>

        /// <typeparam name="TResult">

        /// The type of the query results returned by executing the delegate returned by the Compile method.

        /// </typeparam>

        /// <param name="query">The LINQ to Entities query expression to compile</param>

        /// <returns>The <see cref="CompiledQueryReplicator{TQuery,TKey}"/> created</returns>

        public static CompiledQueryReplicator<Func<TArg0, TResult>, TKey> Create<TArg0, TResult>(Expression<Func<TArg0, TResult>> query)

            where TArg0 : ObjectContext

            return new CompiledQueryReplicator<Func<TArg0, TResult>, TKey>(query, CompiledQuery.Compile);

        /// <summary>

        /// Creates a <see cref="CompiledQueryReplicator{TQuery,TKey}"/> that compiles LINQ to Entities

        /// queries.

        /// </summary>

        /// <typeparam name="TArg0">

        /// The <see cref="ObjectContext"/> that encapsulates the model connection and metadata.

        /// </typeparam>

        /// <typeparam name="TArg1">

        /// Represents the type of the parameter that has to be passed in when executing the delegate returned

        /// by the Compile method.

        /// </typeparam>

        /// <typeparam name="TResult">

        /// The type of the query results returned by executing the delegate returned by the Compile method.

        /// </typeparam>

        /// <param name="query">The LINQ to Entities query expression to compile</param>

        /// <returns>The <see cref="CompiledQueryReplicator{TQuery,TKey}"/> created</returns>

        public static CompiledQueryReplicator<Func<TArg0, TArg1, TResult>, TKey> Create<TArg0, TArg1, TResult>(Expression<Func<TArg0, TArg1, TResult>> query)

            where TArg0 : ObjectContext

            return new CompiledQueryReplicator<Func<TArg0, TArg1, TResult>, TKey>(query, CompiledQuery.Compile);

        /// <summary>

        /// Creates a <see cref="CompiledQueryReplicator{TQuery,TKey}"/> that compiles LINQ to Entities

        /// queries.

        /// </summary>

        /// <typeparam name="TArg0">

        /// The <see cref="ObjectContext"/> that encapsulates the model connection and metadata.

        /// </typeparam>

        /// <typeparam name="TArg1">

        /// Represents the type of the parameter that has to be passed in when executing the delegate returned

        /// by the Compile method.

        /// </typeparam>

        /// <typeparam name="TArg2">

        /// Represents the type of the parameter that has to be passed in when executing the delegate returned

        /// by the Compile method.

        /// </typeparam>

        /// <typeparam name="TResult">

        /// The type of the query results returned by executing the delegate returned by the Compile method.

        /// </typeparam>

        /// <param name="query">The LINQ to Entities query expression to compile</param>

        /// <returns>The <see cref="CompiledQueryReplicator{TQuery,TKey}"/> created</returns>

        public static CompiledQueryReplicator<Func<TArg0, TArg1, TArg2, TResult>, TKey> Create<TArg0, TArg1, TArg2, TResult>(Expression<Func<TArg0, TArg1, TArg2, TResult>> query)

            where TArg0 : ObjectContext

            return new CompiledQueryReplicator<Func<TArg0, TArg1, TArg2, TResult>, TKey>(query, CompiledQuery.Compile);

        /// <summary>

        /// Creates a <see cref="CompiledQueryReplicator{TQuery,TKey}"/> that compiles LINQ to Entities

        /// queries.

        /// </summary>

        /// <typeparam name="TArg0">

        /// The <see cref="ObjectContext"/> that encapsulates the model connection and metadata.

        /// </typeparam>

        /// <typeparam name="TArg1">

        /// Represents the type of the parameter that has to be passed in when executing the delegate returned

        /// by the Compile method.

        /// </typeparam>

        /// <typeparam name="TArg2">

        /// Represents the type of the parameter that has to be passed in when executing the delegate returned

        /// by the Compile method.

        /// </typeparam>

        /// <typeparam name="TArg3">

        /// Represents the type of the parameter that has to be passed in when executing the delegate returned

        /// by the Compile method.

        /// </typeparam>

        /// <typeparam name="TResult">

        /// The type of the query results returned by executing the delegate returned by the Compile method.

        /// </typeparam>

        /// <param name="query">The LINQ to Entities query expression to compile</param>

        /// <returns>The <see cref="CompiledQueryReplicator{TQuery,TKey}"/> created</returns>

        public static CompiledQueryReplicator<Func<TArg0, TArg1, TArg2, TArg3, TResult>, TKey> Create<TArg0, TArg1, TArg2, TArg3, TResult>(Expression<Func<TArg0, TArg1, TArg2, TArg3, TResult>> query)

            where TArg0 : ObjectContext

            return new CompiledQueryReplicator<Func<TArg0, TArg1, TArg2, TArg3, TResult>, TKey>(query, CompiledQuery.Compile);

Il codice di esempio riscritto con queste classi diventa :

public class QueryCompiled

  public static readonly CompiledQueryReplicator<Func<MyEntities, string, Users>, MergeOption>

             GetUserByEmail = EfCompiledQueryReplicatorFactory<MergeOption>.Create(

                                     (MyEntities ctx, string email) =>

                                     (from a in ctx.Users

                                     where a.Email == email

                                     select a).FirstOrDefault());

public class A

  public string GetUserName(string email)

    using (MyEntities context = new MyEntities())

      context.Users.MergeOption = MergeOption.NoTracking;

      var users= (QueryCompiled.GetUserByEmail[MergeOption.NoTracking](context, email));

      return users.Name;

  public void SetUserName(string email, string name)

    using (MyEntities context = new MyEntities())

      var users= (QueryCompiled.GetUserByEmail[MergeOption.AppendOnly](context, email));

      users.Name = name;

      context.SaveChanges();

Da notare che nell’invocazione della query si specifica il tipo di MergeOption che si intende usare. Se esiste una query compilata con quell’opzione nel dizionario viene ritornata altrimenti ne viene creata una.

Technorati Tags: Entity Framework,LINQ,CompiledQuery