Oggi mi sono trovato ad affrontare un problema di quelli banali, ma che (come al solito) mi ha fatto perdere un bel pò di tempo.
Il mio problema era ricavare un elenco di ID e Title dato un array di questi ID.

In SQL quello che avrei fatto sarebbe stato semplicissimo e con l’operatore IN avrei rislto in questo modo:

select id, title from Pages where id in (1,2,3,8,9)

Nel progetto a cui stò lavorando stò però utilizzando LINQ to SQL e trovare l’equivalente query è stata davvero dura (è il primo progetto dove uso seriamente LINQ to SQL), ma alla fine grazie al Contains sono riuscito a trovare la soluzione:

int[] pagesID = new int[] {1,2,3,8,9};

var pages = (from p in dc.Pages

             where pagesID.Contains(p.ID)

             select new { p.ID, p.Title });

Questa invece è la query generata da LINQ per recuperare i dati, che come vedete è simile a quella che avremmo realizzato noi:

exec sp_executesql N'SELECT [t0].[id] AS [ID], [t0].[Titolo] AS [Title]

FROM [dbo].[Pages] AS [t0]

WHERE [t0].[id] IN (@p0, @p1)',N'@p0 int,@p1 int',@p0=701,@p1=694

La soluzione è davvero banale, ma lo posso dire solo ora, dopo che ci ho sbattuto la testa, e la posto qui nel caso servisse anche a qualcuno di voi, o a me nel caso perdessi la memoria. ;-)

Lo spunto per la soluzione l’ho trovata in questo post: Creating IN Queries With Linq To Sql

Era da tempo che avevo iniziato la cosa, ma per un motivo o per un'altro avevo sempre posticipato. Ecco che ora il mio blog gira su BlogEngine e non più su WordPress.

Perchè questo?
Semplice perchè BlogEngine è sviluppato in .NET e questo mi permette di personalizzarlo e aggiungergli funzionalità a mio piacimento, senza dipendere da plugin di terze parti.
WordPress è una piattaforma di blog davvero stupenda, e credo proprio di poter dire che è la migliore che conosca, e la consiglierei a tutti....ma purtroppo è in PHP e non ho la voglia (e il tempo) di approfondirlo come argomento (dite pure che è pigrizia). Ecco il motivo di questo cambiamento.
In questo modo avrò anche la possibilità di testare le ultime tecnologie riguardanti il mondo del .NET Framework direttamente nel mio blog, e non è una cosa da poco.

Cambia il blog e cambia anche il dominio.
Il nuovo dominio ora è http://blog.dottor.net perchè il target del mio blog è un pò cambiato da quando ho iniziato, e "il silenzio di un urlo" ha poco a che vedere con i post relativi alle tecnologie Microsoft .NET.
Ma non ho intenzione di far morire quel dominio perchè ci sono proprio affezionato...lo terrò quindi per qualche idea/progetto futuro (che non si sa mai).

Dal vecchio blog è attivo un redirect (redirect 301) che ridirige i vecchi url verso quelli nuovi (e per questo rigrazio Roberto che mi ha dato una mano a riguardo), e spero di esser riuscito a redirigerli tutti. Spero poi che google mi dia una mano, a riposizionare il mio nuovo blog allo stesso livello di quello vecchio, per permettervi di trovare velocemente i miei vecchi post.

Il feed invece rimane invariato, e per chi non lo ha ancora sottoscritto, ecco qui: http://feeds.dottor.net/ilsilenziodiunurlo

Inoltre, se riscontrate qualche problema, non esitate a contattarmi.

Vi avevo promesso che lo avrei postato, ed eccomi qui. 

All'ultimo meeting alcuni mi voi mi hanno chiesto cosa fosse la scrollbar che utilizzavo in Visual Studio.

Altro non è che un tool che va a rimpiazzare la normare scroolbar e al suo posto ci mette una miniatura del testo presente nel file, evidenziando la parte di testo correntemente visualizzata.

Una dele caratteristiche che mi piace, è la possibilità di fare doppio click su di una parola, e vedere evidenziate tutte le occorenze di quel testo all'interno del file.

Oltre a questo, ci sono altre funzionalità davvero carine come la possibilità di riconoscere direttamente dalla barra le parti di testo commentate, e anche le righe di codice che sono state modificate.

Per scaricarlo e per maggiori info, vi riporto al post dell'autore Scott Hanselman: Introducing RockScroll

Navigando un pò su msdn.microsoft mi è capitato di imbattermi in uno statement che (ammetto) non conoscevo.

Se si vuole interrompere l'esecuzione di una parte di codice all'interno di un ciclo for, continuando comunque a ciclare gli item, ci viene in soccorso uno statement comodissimo, che si chiama continue.

Ad esempio, con il seguente codice:

for (int i = 1; i <= 10; i++) 

{

    if (i < 9) 

        continue;  //  <<-----

    Console.WriteLine(i);

}

verrrà renderizzato come output:

9

10

perchè l'istruzione continue eviterrà di eseguire la parte di codice posta tra questo statement e la fine del ciclo for (che in questo esempio corrisponde solamente a Console.WriteLine(i);).

Perchè posto una cosa così semplice?!
Il motivo è che fino all'altro giorno, quello che avrei fatto sarebbe stato racchiudere parte del codice all'interno di un if, e ad una determinata condizione non l'avrei eseguito.
Ma devo ancora decidermi su quale delle due metodologie sia più elegante e corretta. Secondo voi?

Links:
continue (C# Reference)
Jump Statements (C# Reference)

Ed ecco che XeDotNet si fa partecipe anche dell'evento community afterhour che si terrà dopo l'evento 2008 Launch Roadshow nella tappa di Padova, e lo fa con un team d'eccezione:
Andrea Boschin,
Andrea Dottor,
Davide Senatore,
Mirco Vanini e
Davide Vernole.

Gli EROI sono {qui}: Gli speaker e i community Expert di XeDotNet

Iscrizioni: Iscriviti all'evento

In un componente COM (sviluppato in .net e utilizzato in una pagina ASP) che si occupa di decriptare alcuni messaggi, accadeva che dopo il suo utilizzo venisse generata un'eccezione di tipo CryptographicException con il messaggio "Keyset does not exist".

Ho sbattuto la testa per diverso tempo per capire dove venisse generata questa eccezzione e il perchè accadesse dopo l'utilizzo del componente (con un ritardo variabile).

Agganciandomi in Remote Debugging (come vi ho detto nel precedente post) ho avuto qualche dato in più, ed esattamente:

System.Security.Cryptography.CryptographicException was unhandled
Message="Keyset does not exist"
Source="mscorlib"
StackTrace:
at System.Security.Cryptography.CryptographicException.ThrowCryptogaphicException(Int32 hr)
at System.Security.Cryptography.SafeKeyHandle._FreeHKey(IntPtr pKeyCtx)
at System.Security.Cryptography.SafeKeyHandle.ReleaseHandle()
at System.Runtime.InteropServices.SafeHandle.InternalFinalize()
at System.Runtime.InteropServices.SafeHandle.Dispose(Boolean disposing)
at System.Runtime.InteropServices.SafeHandle.Finalize()

che mi ha fatto capire che fosse scatenata al passaggio del Garbage Collection per fare un pò di pulizia.

Con questi dati in più, e googlando un pò in rete ho trovato questo commento ad un post su codeproject ".NET Encryption Simplified" che dava un suggerimento per la soluzione del problema, e cioè quello di avere un KeyContainerName diverso per ogni istanza di utilizzo.

Con questa indicazione sono riuscito a risolvere il problema passando al costruttore del RSACryptoServiceProvider un CspParameters che avesse un KeyContainerName diverso ad ogni utilizzo della funzione nel seguente modo:

CspParameters param = new CspParameters();

param.KeyContainerName = "Decryption.RSACryptoServiceProvider." + Guid.NewGuid().ToString();

RSACryptoServiceProvider rsa = new RSACryptoServiceProvider(param);

In un progettino che stò sviluppando avevo la necessità di fare l'upload e scompattare un archivio zip. Per fare ciò mi sono appoggiato alla liberia #ziplib che si è dimostrata di una facilità estrema, infatti con poche righe di codice sono riuscito nel mio intento:

/// <summary>

/// Unzip the zip file.

/// </summary>

/// <param name="fileZipPath">The path of file zip.</param>

private void UnZipFile(string fileZipPath)

{

    using (ZipInputStream s = new ZipInputStream(File.OpenRead(fileZipPath)))

    {

        ZipEntry entry;

        while ((entry = s.GetNextEntry()) != null)

        {

            // Prelevo solo il nome del file all'interno dello zip

            string fileName = Path.GetFileName(entry.Name);

            // Combino il path su disco con quello che il file ha all'interno del file zip

            string filePath = Path.Combine(Path.GetDirectoryName(fileZipPath), entry.Name);

            // Se la directory non esiste la creo

            if (!Directory.Exists(Path.GetDirectoryName(filePath)))

                Directory.CreateDirectory(filePath);

            if (fileName != String.Empty)

                using (FileStream streamWriter = File.Create(filePath))

                {

                    int size = 2048;

                    byte[] data = new byte[2048];

                    while (true)

                    {

                        size = s.Read(data, 0, data.Length);

                        if (size > 0)

                        {

                            streamWriter.Write(data, 0, size);

                        }

                        else

                        {

                            break;

                        }

                    }

                }

        }

    }

}

Credo (appena avrò tempo) di  approfondire un pò meglio questa libreria perchè mi sembra proprio fatta bene.
Ecco il link alla pagina di downlad.

Technorati tags: ClickOnce, Firefox, plugin

Il Redirect 301 "Moved Permanently" è molto importante per chi fa SEO (Search engine optimization). Questo redirect indica che la pagina è stata spostata definitivamente al nuovo indirizzo, facendo in modo che gli spider indicizzino la pagina nuova al posto di quella vecchia.

Per eseguire un Redirect 301 "Moved Permanently" da ASP .NET sono sufficienti le seguenti righe:

HttpContext.Current.Response.StatusCode = 301;
HttpContext.Current.Response.AddHeader("Location", redirectUrl);

L'errore comune è quello di fare un Response.Redirect dopo aver settato lo status a 301, e questo è sbagliatissimo in quanto causa un redirect 302 "Moved Temporarily" (che indica che la pagina è stata mossa temporaneamente, ed in questo caso gli spider non indicizereranno il contenuto della pagina di destinazione).

Per maggiori informazioni a riguardo delle ottimizzazioni SEO con ASP .NET, vi consiglio di guardare il Webcast di Andrea Boschin:
Link:  Tecniche di Search Engine Optimization con ASP.NET 2.0

Sono riuscito ad iscrivermi alla track Web Developer del 29 maggio 07 dove verranno trattari argomenti come ASP .NET AJAX, AJAX Control Toolkit, Orcas e WPF/E.

Per non mancare ho dovuto prendermi (per sicurezza) un giorno di ferie perchè non volevo proprio lasciarmela scappare. Se volete iscrivervi a questa track vi consiglio di muovervi, in quanto dovrete superare una lista di attesa.

Se vi state chiedendo cos'è il REMIX07, vi riporto la descrizione dal sito Microsoft:

REMIX 2007 è la conferenza, organizzata da Microsoft, dedicata alle nuove tecnologie e programmi per il Web. REMIX propone le sessioni più importanti presentate al MIX07 di Las Vegas. Gli esperti di Microsoft Corporation saranno in Italia, a Milano, per questa conferenza esclusiva articolata in due giornate, 29 e 30 maggio, dedicata a sviluppatori e designer che fanno del Web il proprio business principale. È un’occasione da non perdere per valutare le nuove tecnologie disponibili per lo sviluppo, individuare nuove opportunità di crescita aziendale e nuovi mercati, ridurre i costi di realizzazione e rilascio delle applicazioni e imparare a realizzare user experience innovative.

Link: Microsoft - REMIX 2007
         Microsoft - MIX07 di Las Vegas