#41: Scaricare il contenuto HTML di una pagina web con VB.NET

Nel precedente post abbiamo visto come è possibile estrarre il testo semplice da una pagina HTML registrata sul disco fisso. In questo post, invece, vedremo come è possibile scaricare il contenuto HTML di una pagina web, fornendo semplicemente l’URL, e come da questa è possibile estrarre il testo semplice.

Procediamo per gradi: innanzi tutto creiamo una nostra classe (ScaricaURL) per gestire la comunicazione con il web server.

Imports System.Text

Imports System.IO

Imports System.Net

Public Class ScaricaURL

   Private m_strURL As String

   Public Sub SetURL(ByVal strURL As String)

      m_strURL = strURL

   End Sub

   Public Function Scarica() As String

      Dim wreq As WebRequest = WebRequest.Create(m_strURL)

      Dim wres As WebResponse = wreq.GetResponse()

      Dim iBuffer As Integer = 0

      Dim buffer( 128 ) As [Byte]

      Dim stream As Stream = wres.GetResponseStream()

      iBuffer = stream.Read(buffer, 0, 128 )

      Dim strRes As New StringBuilder(“”)

      While iBuffer <> 0

         strRes.Append(Encoding.ASCII.GetString(buffer, 0, iBuffer))

         iBuffer = stream.Read(buffer, 0, 128 )

      End While

      Return strRes.ToString()

   End Function

End Class

Successivamente inseriamo in un form: due pulsanti (Button1 e Button2) e un textbox (TextBox1). Quest’ultimo dovrà essere configurato come nel post precedente: proprietà Multiline a True e Scrollbar verticale.

Il codice dei gestori degli eventi Click dei due pulsanti sono i seguenti:

Public Class Form1

   Private Sub Button1_Click(ByVal sender As System.Object, _
         ByVal e As System.EventArgs) Handles Button1.Click

      Dim URL As String

      URL = “http://community.visual-basic.it/mario/” & _
         “archive/2008/06/29/23164.aspx”

      Dim objScaricaURL As New ScaricaURL

      objScaricaURL.SetURL(URL)

      Me.TextBox1.Text = objScaricaURL.Scarica

   End Sub

   Private Sub Button2_Click(ByVal sender As System.Object, _
         ByVal e As System.EventArgs) Handles Button2.Click

      Dim URL As String

      URL = “http://community.visual-basic.it/mario/” & _
         “archive/2008/06/29/23164.aspx”

      Dim objScaricaURL As New ScaricaURL

      objScaricaURL.SetURL(URL)

      Me.TextBox1.Text = _
         System.Text.RegularExpressions.Regex.Replace( _
         objScaricaURL.Scarica, “<[^>]*>”, “”)

   End Sub

End Class

Vedrete quindi che premendo il primo pulsante il programma scaricherà la pagina e visualizzerà il relativo codice HTML, mentre nel secondo caso scaricherà la pagina ed estrarrà solamente il testo semplice, eliminando tutti i tag HTML.

#40: Estrarre il testo da una pagina HTML con VB.NET

Le espressioni regolari sono uno strumento estremamente potente per estrarre del testo da una pagina HTML registrata su disco.

Una delle cose più interessanti è il fatto che possiamo raggiungere questo obiettivo con una sola riga di codice!

Ecco qui la nostra funzione:

Public Function EstraiTestoDaHTML(ByVal HTML As String) As String

   ‘ rimuove i tag HTML

   Return System.Text.RegularExpressions.Regex.Replace( _

      HTML, “<[^>]*>”, “”)

End Function

 

… ed ecco il codice, inserito nel gestore dell’evento Click di un pulsante:

Dim testoHTML As String

testoHTML = My.Computer.FileSystem.ReadAllText(“C:\paginaX.html”)

Me.TextBox1.Text = EstraiTestoDaHTML(testoHTML)

 

A questo punto basta inserire una casella di testo di nome TextBox1, impostare la sua proprietà Multiline a True e definire la scrollbar verticale e il gioco è fatto!

 

#39: Aggiungere un collegamento ai Preferiti con VB.NET

Tempo addietro ho avuto la necessità di creare un piccolo programma per aggiungere un collegamento ai Preferiti, per permettere a un numero consistente di utenti dell’azienda dove lavoro di collegarsi a un nostro sito interno, nella Intranet aziendale.

Il programma è estremamente semplice, come si può vedere dal seguente codice:

Public Class Form1

   Private Sub Button1_Click(ByVal sender As System.Object, ByVal e As System.EventArgs) Handles Button1.Click

      CreaShortcut(“Prova”, “http://www.visual-basic.it”)

   End Sub

 

   Public Sub CreaShortcut(ByVal Titolo As String, ByVal URL As String)

      ‘ crea uno shortcut nella cartella Preferiti

      Dim strCartellaPreferiti As String

      ‘ recupera la cartella Preferiti

      strCartellaPreferiti = System.Environment.GetFolderPath( _

         Environment.SpecialFolder.Favorites)

      ‘ crea uno shortcut basato su Titolo

      Dim objSW As System.IO.StreamWriter = _

         System.IO.File.CreateText(strCartellaPreferiti & _

         “\” & Titolo & “.url”)

      ‘ scrive l’URL nel file

      objSW.WriteLine(“[InternetShortcut]“)

      objSW.WriteLine(“URL=” & URL)

      ‘ chiude il file

      objSW.Close()

   End Sub

End Class

 

Nel form ho inserito un pulsante che semplicemente richiama la Sub CreaShortcut, passandogli il titolo del collegamento e l’indirizzo (URL) del collegamento vero e proprio.

Nella Sub CreaShortcut, invece, viene prima di tutto recuperato il percorso della cartella speciale dei Preferiti, poi viene aperto uno stream per la scrittura del file, all’interno del quale vengono inserite due righe di testo: la prima con un “tag” speciale che specifica che il file costituisce una “scorciatoia” a un indirizzo internet e la seconda con l’URL vero e proprio. Infine il file viene correttamente chiuso.

N.B.: questo mio post fa parte di alcuni suggerimenti di programmazione per i quali traggo ispirazione, spesso, da richieste che vedo nelle liste VB T&T oppure in giro per la Rete. Spero che vi possano interessare…  

#38: spostare un file nel Cestino con VB.NET

Per permettere agli utenti dei vostri programmi di spostare un file nel Cestino di Windows (alias “Recycle Bin”) dobbiamo utilizzare una funzione della libreria di sistema shell32.dll.

Per rendere più semplici le cose, potete utilizzare il seguente modulo di codice:

Imports System.IO

Module SpostaFileCestino

    Private Structure ShFileOpStruct

        Dim hwnd As Integer

        Dim wFunc As Integer

        Dim pFrom As String

        Dim pTo As String

        Dim fFlags As Short

        Dim fAnyOperationAborted As Boolean

        Dim hNameMappings As Integer

        Dim lpszProgressTitle As String

    End Structure

 

    Private Const SFC_DELETE As Short = &H3S

    Private Const SFC_ALLOWUNDO As Short = &H40S

    Private Const SFC_NOCONFIRMATION As Short = &H10S

 

    Private Declare Function ShFileOperation _

        Lib “shell32.dll” _

        Alias “SHFileOperationA” _

        (ByRef lpFileOp As ShFileOpStruct) As Integer

 

    Public Function Ricicla(ByRef sPath As String) As Integer

        Dim FileOp As ShFileOpStruct

        If Not File.Exists(sPath) Then

            MessageBox.Show(“File “ & sPath & ” non trovato.”)

            Return -1

            Exit Function

        End If

        With FileOp

            .wFunc = SFC_DELETE

            .pFrom = sPath & vbNullChar

            .pTo = vbNullChar

            .fFlags = SFC_NOCONFIRMATION Or SFC_ALLOWUNDO

            .lpszProgressTitle = “Invio file “ & _

                sPath & ” al Cestino di Windows.”

        End With

        Try

            ShFileOperation(FileOp)

        Catch ex As Exception

            MessageBox.Show(ex.Message)

        End Try

        Return 0

    End Function

End Module 

 

 

Infine, per utilizzare effettivamente la funzione Ricicla potete fare riferimento al seguente esempio:

Dim esito As Integer = 0

esito = Ricicla(“C:\prova.txt”)

If esito = -1 Then

   MessageBox.Show(“Errore: operazione annullata!”)

Else

   MessageBox.Show(“Spostamento nel Cestino “ & _

      “eseguito correttamente.”)

End If

 

 

 

L’utilizzo non richiede ulteriori commenti, dato che è sufficiente passare alla funzione Ricicla il nome del file completo del percorso.

#37: Trucco per commentare blocchi di codice con VB.NET

Come è noto a tutti i programmatori Visual Basic, con questo linguaggio non è possibile commentare blocchi di codice o di testo e ci si deve rassegnare a commentare riga per riga con l’apice singolo (‘). I programmatori C#, C++ e JAVA, invece, hanno una sintassi specifica estremamente comoda che si presenta così:

/*
   Qui posso scrivere quello che voglio
   senza nessun problema!!
*/

Con il seguente trucco, però, possiamo simulare la stessa situazione di cui sopra: è sufficiente utilizzare la direttiva #If … #End If.

Create una nuova applicazione Windows Forms (linguaggio Visual Basic) e aggiungete un pulsante nel form principale. Sostituite poi il codice sottostante con il seguente:

Public Class Form1
   Private Sub Button1_Click( _
        ByVal sender As System.Object, _
         ByVal e As System.EventArgs) _
         Handles Button1.Click
      MessageBox.Show(“Trucco per ” & _
         “commentare blocchi di codice…”)

#If False Then
   MessageBox.Show(“Questo non dovrebbe apparire…”)
   Posso scrivere qualsiasi cosa!
#End If

      MessageBox.Show(“Fine trucco!”)
   End Sub
End Class

Eseguendo il programma, vedrete apparire il primo messaggio (“Trucco per…”) e poi l’ultimo messaggio (“Fine trucco!”), mentre tutto ciò che è stato inserito nel blocco #If … #End If è totalmente ignorato, sia che si tratti di un’istruzione valida, sia che si tratti di puro testo.

Certo, non è così ordinato e intuitivo come la coppia /* … */ di C#, ma è utile per commentare velocemente parti di codice che vogliamo temporaneamente disattivare o per inserire lunghi commenti descrittivi.

Come funziona? Il blocco #If … #End If è tecnicamente una direttiva per il compilatore: quest’ultimo, trovando #If, eseguirà il test indicato subito dopo. Se il test risulterà negativo (False), come nel caso sopra illustrato, ignorerà tutto ciò che troverà successivamente fino a #End If, se invece risulterà positivo (True), eseguirà il codice contenuto al suo interno.

Uno degli usi più importanti di questa direttiva è, oltre tutto, eseguire del codice condizionale a seconda che ci si trovi in modalità di DEBUG o in modalità RELEASE.

Guasto al server di Visual Basic Tips & Tricks (VB T&T)

Questa mattina ho segnalato che il sito di Visual Basic Tips & Ticks (VB T&T – www.visual-basic.it), dove si trova anche il mio blog principale su Visual Basic, rispondeva solo con pagine bianche, senza alcuna segnalazione di errore.

Mi è stato così comunicato che il problema è già noto e che riguarda un guasto al server che ospita tutti i servizi della nostra Community.  

Di conseguenza non funzionano più il sito web, i blog, le mailing list, i forum e le caselle di posta elettronica con il dominio @visual-basic.it.

Spero vivamente che il guasto si possa riparare al più presto possibile. 

#36: Calcolare il tempo di esecuzione di un frammento di codice (VB.NET)

Sviluppando o studiando una nuova tecnica, in un qualsiasi linguaggio di programmazione, spesso abbiamo bisogno di avere una valutazione oggettiva del tempo di esecuzione di più frammenti di codice, per poter valutare quale dei due impiega meno tempo. Infatti il minore tempo di esecuzione di certe parti di codice, specialmente quelle ripetute più volte nel corso del programma o utilizzate in più parti del programma stesso, ha per conseguenza un minore tempo di esecuzione dell’intero programma e quindi migliori prestazioni che vengono percepite positivamente dall’utente.

In questo post vedremo quindi come si crea e come si utilizza una classe in grado di memorizzare il momento iniziale di un test e la differenza tra un momento successivo e il momento iniziale.

La classe è la seguente:
 

Public Class Cronometro

   Private inizio As DateTime

   Private durata As TimeSpan

   Public Sub New()

      inizio = New DateTime

      durata = New TimeSpan

   End Sub

   Public Sub ferma()

      durata = CType(DateTime.Now.Subtract(inizio), TimeSpan)

   End Sub

   Public Sub avvia()

      GC.Collect()

      GC.WaitForPendingFinalizers()

      inizio = DateTime.Now

   End Sub

   Public ReadOnly Property Result() As TimeSpan

      Get

         Return durata

      End Get

   End Property

End Class

 

Le istruzioni GC.Collect() e GC.WaitForPendingFinalizers() servono per avviare la “raccolta della spazzatura” da parte del Garbage Collector, cioè l’eliminazione degli oggetti non più utilizzati. Infatti, come sappiamo, gli oggetti non vengono eliminati immediatamente al termine del loro utilizzo, ma rimangono in memoria finché il Garbage Collector non decide di eliminarli. In particolare la seconda istruzione (GC.WaitForPendingFinalizers) attende che siano terminati tutti i metodi Finalizer degli oggetti in corso di eliminazione.

Perché avviare esplicitamente il Garbage Collector? E’ presto detto: vogliamo che nel corso del nostro test non avvenga la “raccolta dei rifiuti” che rallenterebbe l’esecuzione e causerebbe l’invalidazione del test stesso.

In un’applicazione Console possiamo poi testare la classe Cronometro con questo codice:

Option Strict On

Imports System.Console

Module Module1

   Sub Main()

      Dim numeri(99999) As Integer

      BuildArray(numeri)

      Dim tObj As New Cronometro()

      tObj.avvia()

      ScriviNumeri(numeri)

      tObj.ferma()

      Console.WriteLine(“tempo in secondi: “ & _

         tObj.Result.TotalSeconds)

      Console.Read()

   End Sub

   Sub BuildArray(ByVal arr() As Integer)

      Dim indice As Integer

      For indice = 0 To 99999

         arr(indice) = indice

      Next

   End Sub

   Sub ScriviNumeri(ByVal arr() As Integer)

      Dim indice As Integer

      For indice = 0 To arr.GetUpperBound(0)

         Console.Write(arr(indice) & ” “)

      Next

   End Sub

End Module

 

Quella che abbiamo visto è la soluzione “classica” che viene spesso utilizzata e che, peraltro, va bene con qualsiasi linguaggio OOP (anche quelli non-.NET, fatti gli opportuni adattamenti).

E’ possibile ottenere una soluzione più ordinata e pulita utilizzando la classe System.Diagnostics.Stopwatch, implementata in tutti i Framework .NET dalla versione 2.0 in poi. Per esempio questo è il codice di un’applicazione Console che fa uso di tale classe:

Public Class Test

    Shared Sub main()

        Dim str As String = “”

        Dim watch As New System.Diagnostics.Stopwatch()

        watch.Start()     ‘ avvio del cronometro

        ‘ … fai qualcosa …

        Dim i As Integer = 0

        For i = 1 To 100

            str &= “*”

            Console.WriteLine(“<” & str & “>”)

        Next

        watch.Stop()    ‘ stop del cronometro

        Console.WriteLine(“Tempo impiegato: “ + watch.Elapsed.ToString())

        Console.ReadLine()

    End Sub

End Class

 

Attenzione che il test può non funzionare perfettamente in tutti i casi: se il nostro computer è pieno di programmi e servizi in esecuzione, potremmo ottenere dei risultati non corretti. In particolare, quando dobbiamo confrontare i tempi di due versioni di codice diverse (per esempio due algoritmi di ordinamento diversi), lo stato del computer dovrebbe essere il più possibile uguale in entrambe le esecuzioni, altrimenti si rischia di falsare i risultati.

Il consiglio è sempre quello, se possibile, di utilizzare un’installazione “pulita”, con solo i programmi e i servizi indispensabili per l’esecuzione del programma e del relativo test.

 

[Visual Studio] Componenti visuali DevExpress

Tutti noi programmatori di ambienti visuali e, in particolare, noi che utilizziamo Visual Studio e Visual Basic nelle più disparate versioni, abbiamo ben presente l’importanza di avere a disposizione controlli visuali sempre più efficienti, più utili, più comodi e versatili e anche più belli da vedere, per soddisfare “il palato” degli utenti più esigenti.

All’interno di questo contesto, sta emergendo sempre di più il set di controlli visuali di DevExpress (www.devexpress.com) che ha ottenuto un importante riconoscimento al TechEd Developers Awards a Orlando (Florida). Ecco qui il comunicato ufficiale che DevExpress sta inviando via e-mail agli utenti registrati:

Hello
We wanted to let all of our loyal customers know that we received 2 additional awards at this year’s Best of TechEd Developers Awards in Orlando, Florida.
CodeRush was awarded the Breakthrough Product of the Year and DXperience was awarded the Attendee’s Pick as Overall Winner by Windows IT Pro Magazine.
These 2 awards are in addition to the 9 awards we won in the Readers’ Choice Awards last month conducted by ASPnet Pro Magazine. They included:

Product of the Year – DXperience ASP.NET
Best Component Set – DXperience ASP.NET
Best Grid – ASPxGridView Suite
Best Add-In – CodeRush with Refactor! Pro
Best Printing/Reporting Tool – XtraReports Suite
Best Charting – XtraCharts Suite
Best Navigation Suite – ASPxperience Suite / ASPxNavBar
Best Online Editor – ASPxHTML Editor
Best Scheduling/Calendar Tool – ASPxScheduler Suite

Our deepest thanks and appreciation go out to all of you for placing your faith and confidence in our tools and we look forward to delivering the very best tools we can in the coming months.
Best wishes,

The Developer Express Team
www.devexpress.com

Vi ricordo che, previa registrazione, è possibile scaricare un set di controlli gratuiti per Visual Studio!

 

E’ uscito il mio nuovo libro su Visual C# 2008

Ebbene, ecco l’annuncio che molti si aspettavano, viste le numerose richieste che mi sono arrivate via e-mail: le copie del mio libro “Visual C# 2008 spiegato a mia nonna” sono finalmente arrivate ai magazzini della FAG e quindi è ora possibile ordinarli via Internet (sito www.fag.it).

Alcuni riferimenti utili sono i seguenti:

• indice con tutti gli argomenti del libro: http://www.deghetto.it/blog/download/LibroVCSharp2008indice.pdf (71 kb)
• tutti gli esempi del libro: http://www.deghetto.it/blog/download/mdgVCSHARP2008_esempi.zip(6,735 Mb)
• capitolo 10 di esempio: http://www.deghetto.it/blog/download/VCSharp2008_Cap10.zip (756 kb)
• scheda del libro: http://www.fag.it/scheda.aspx?ID=24756
• booksite: http://www.fag.it/booksite/694-3.htm

Il libro è composto da 552 pagine ed è edito dalla FAG Edizioni – Milano al prezzo di 39,00 Euro.

E’ possibile ordinarlo con la seguente tempistica:

da oggi stesso, per gli acquisti online;

entro la prossima settimana, in tutta la Lombardia e presso i principali bookshop online (IBS, BOL eccetera);

successivamente, nelle librerie in tutta Italia.

Ecco l’elenco dettagliato degli argomenti trattati nel libro:

Cap. 1 – Il primo capitolo è introduttivo, per avvicinare gradualmente il lettore alla programmazione senza spaventarlo dai nuovi concetti a cui andrà incontro. Ecco perché, quindi, abbiamo adottato uno stile molto discorsivo e amichevole (in informatica diremmo user friendly) in grado di mostrare al lettore cos’è la programmazione, basandoci su oggetti comunemente usati. Potranno anche avere una piccola simpatica sorpresa tutti coloro che pensano che il computer non possa fare il caffè!

Cap. 2 – Il secondo capitolo introduce le caratteristiche principali del Framework .NET e del linguaggio Visual C#, con un breve cenno su tutte le più importanti tecnologie correlate.

Cap. 3 – Nel terzo capitolo iniziamo a vedere l’ambiente di sviluppo realmente in azione. Potrete quindi vedere quali strumenti visuali principali troverete all’avvio del software e alcune indicazioni sul loro uso.

Cap. 4 – Il quarto capitolo potremmo definirlo un male necessario: non si può parlare di un linguaggio di programmazione senza prima capire cosa sono le variabili e i tipi di dato. In questo capitolo esamineremo quindi tutti i tipi di dato elementari e vedremo come si utilizzano.

Cap. 5 – Nel quinto capitolo continuiamo il discorso dei tipi di dati elementari introducendo le matrici. Anche in questo capitolo ci sarà molto codice per vedere l’uso pratico di queste strutture.

Cap. 6 – Con il sesto capitolo iniziamo a vedere le istruzioni del linguaggio Visual C# e molti esempi sulle istruzioni condizionali e sulla programmazione strutturata.

Cap. 7 – Finalmente, nel settimo capitolo, tratteremo in modo esteso la programmazione orientata agli oggetti. Come vedrete, la programmazione  in .NET è completamente orientata agli oggetti: in .NET tutto è un oggetto, anche l’utente! Vedremo quindi molti esempi per scrivere delle buone classi e per gestire correttamente gli oggetti.

Cap. 8-9 – I capitoli ottavo e nono riguardano rispettivamente i form e i controlli basati sulla tecnologia Windows Forms. Questi argomenti fanno parte della programmazione visuale e, tutto sommato, sono forse la parte più divertente della programmazione. Alla fine di ciascun capitolo abbiamo inserito dei brevi cenni sulla nuova tecnologia emergente per la programmazione visuale: Windows Presentation Foundation (WPF).

Cap. 10 – Il decimo capitolo illustra l’uso di tutte le finestre comuni di dialogo e dei menu. Con questo obiettivo, abbiamo realizzato un’applicazione di esempio perfettamente funzionante che ci permette di gestire i file di testo.

Cap. 11 – Nel capitolo undicesimo trattiamo un argomento molto importante: la gestione degli errori o, come si dice in .NET, la gestione delle eccezioni. Sebbene questo argomento compaia in una posizione molto avanzata del libro, è un argomento che va sempre tenuto presente tra le principali attenzioni del programmatore.

Cap. 12 – Il capitolo dodicesimo fornisce numerose informazioni per la gestione delle stringhe e dei file di testo.

Cap. 13 – Il tredicesimo e ultimo capitolo introduce la più recente tecnologia per l’accesso ai dati e precisamente LINQ. Vengono spiegate le novità apportate al linguaggio e alla gestione delle classi e degli oggetti quale presupposto per l’utilizzo di LINQ e vengono mostrati alcuni esempi della sintassi di quest’ultimo per la gestione dei dati.

Appendici - Ho messo a disposizione anche quattro appendici: la prima illustra passo per passo le installazioni delle versioni Espress e Professional e della documentazione di MSDN Library, mentre le altre tre forniscono alcune tabelle accessorie che talvolta è utile avere a portata di mano.

Ovunque troverete anche molto codice Visual C#: mini-programmi di prova per spiegare in modo semplice una tecnica e qualche programma completo e funzionante.

Tutti gli elementi dell’interfaccia grafica e dell’ambiente di sviluppo (nomi di finestre, voci di menu, ecc.) sono tratti dalla versione in lingua italiana e, tra parentesi, dalla versione in lingua inglese. Questa scelta è stata fatta per accontentare sia chi vuole utilizzare il software nella nostra lingua, sia per chi ritiene più opportuno utilizzarlo nella lingua originale. Questa impostazione è altresì utile per facilitare le ricerche nella documentazione MSDN, dato che i documenti migliori sono sempre espressi in lingua inglese.

FEEDBACK: spero che il libro vi piacerà. In ogni caso, come ho già più volte affermato, sono graditi consigli, suggerimenti, critiche e segnalazioni di errori (e-mail mario@deghetto.it). Qualunque cosa possa aiutarmi a migliorare, sarà ben accetto. Gli insulti saranno immediatamente cestinati    

#35: Cancellare la lista dei progetti

Sono molti i programmatori che sentono la mancanza di un metodo per cancellare la lista (o una parte della lista) dei progetti nell’ambiente di sviluppo.

L’unico modo per farlo è quello di intervenire a livello di registro di sistema, eliminando le chiavi contenute nelle seguenti voci di registro:

Visual Studio 2008 Professional:

HKEY_CURRENT_USER\Software\Microsoft\VisualStudio\9.0\ProjectMRUList

Visual Basic 2008 Express:

HKEY_CURRENT_USER\Software\Microsoft\VBExpress\9.0\ProjectMRUList

Visual Web Developer 2008 Express:

HKEY_CURRENT_USER\Software\Microsoft\VWDExpress\9.0\ProjectMRUList

Visual C# 2008 Express:

HKEY_CURRENT_USER\Software\Microsoft\VCSExpress\9.0\FileMRUList

NOTA – attenzione alle modifiche che apportate al registro di sistema: basta molto poco per danneggiare l’installazione di Windows!

*** AGGIORNAMENTO ***

Su questo argomento si sono “sbizzarriti” anche, dapprima, Alessandro Del Sole che ha pubblicato nel suo blog l’annuncio di un add-in creato da lui stesso e pubblicato su Code Gallery di MSDN, poi Diego Cattaruzza che ha pubblicato nel suo blog l’annuncio di un “non-add-in” per le versioni Express.

In conclusione, ora avete anche degli strumenti più “user-friendly” per eliminare la lista dei progetti anche senza rischiare di maneggiare maldestramente il registro di sistema!