AZ - Il blog di Andrea Zani

Come tutto deve ancora iniziare.

A quale età hai cominciato a programmare?

13 su C64

Come hai cominciato a programmare?

A scuola in terza media mi avevano insegnato il Basic.

Qual'è stato il tuo primo linguaggio di programmazione?

Basic.

Qual'è stato il primo programma vero che hai scritto?

Un programma geometrico.

Quali linguaggi hai usato da quando hai cominciato a programmare?

Basic, Pascal, C, linguaggio macchina (6502-6510 68000, 68020), Rexx, php, perl, vbscript, vb.net, c# (il mio sogno è sempre stato il C++ ma non solo sintatticamente: troppa gente si riempe la bocca dicendo di conoscerlo perché ha studiato le quattro routine scritte sui libri). E visto che fa tanto sborone - queste catene servono a questo - mi sono intrattenuto anche quasi un minuto anche su questi linguaggi (copia/incolla da wiki): ALGOL, B, BCPL, COBOL, Fortran, Forth, Hot, Soup, Processor, PL/I, POP, Ada, Modula-2, Ada95, Attack, BETA, Clarion, CLOS, D, Eiffel, Delphi, Java, Modula-3, Objective-C, OCaml, OpenGenera, Python, PowerBuilder, REALbasic, REBOL, Ruby, Scriptol, Simula, Smalltalk, Clarion, Clean, Haskell, Lisp, Logo, Scheme, Standard-ML, Caml, OCaml, Mercury, Prolog, Occam (non il rasoio)...

Quando è stato il tuo primo vero lavoro da programmatore?

2000.

Con il senno di poi, rifaresti lo stesso il programmatore? Ricominceresti a programmare?

No. Non mi sarei fatto scrupoli, mi sarei dopato e avrei fatto il ciclista professionista.

Se ci fosse una cosa che hai imparato nella tua carriera e che vorresti dire ai giovani programmatori, cosa diresti?

Se non hai la passione informatica e curiosità, lascia perdere.

Qual è la cosa più divertente che hai programmato?

Crack vari.

Adesso è l'ora di taggare qualcun'altro...

Li risparmio.

PS per chi ha inventato 'sta catena: qual è SENZA APOSTROFO!

Tags: Off Topic

Quale Binding scegliere con WCF

Di questo schema volevo farmi un poster da appendere in camera perché lo trovo molto chiaro e utile:

Rubato da questo blog di Pano dove si trovano moltre altre info.

Tags: .NET Framework 3.0, Windows Communication Foundation

Mono e Remoting: come scambiare informazioni tra Windows e Linux

In un blog precedente avevo spiegato come creare un servizio con C# e Mono per macchine Linux. Oggi voglio complicare un po' le cose, perché l'obbiettivo a cui voglio giungere è lo scambio di informazioni tra i due mondi.

La prima soluzione che potrebbe venire in mente è l'utilizzo dei web services. Subito però nasce un problema di base: per poterli utilizzare dobbiamo avere un web server che gira sulla macchina, e questo non è sempre una buona soluzione perché necessità di installazioni e sistemi operativi che consentono questa operazione. Nel mondo Windows è necessario avere almeno Windows Xp Professional oppure Vista. Con qualsiasi distribuzione Linux dobbiamo installare Apache e il modulo apposito perché possano essere elaborate le pagine asp.net. Ne vale la pena? No, perché il mondo .Net permette un mezzo più potente per lo scambio di dati tra ambienti in cui gira il Framework: il Remoting.

Quei quattro gatti che mi conoscono, sanno la mia passione per il Remoting fin dalla versione 1.1 del Framework. Questa tecnologia permette lo scambio di oggetti tra applicativi scritti in .Net senza la necessità di web server, inoltre possiamo utilizzare la serializzazione binaria per la trasmissione di dati molto più prestazionale che la tradizionale SOAP via HTTP (anche se con il Remoting possiamo utilizzare sia la serializzazione SOAP, sia il trasferimento con il protocollo HTTP). Dal Framework 3.0 è presente la tecnologia WCF, molto più potente, ma il mondo Mono è ancora indietro e l'implementazione di WCF e delle novità presenti dal Framework 3.0 (nome in codice Olive sotto Mono) sono ancora abbastanza indietro.

Un articolo che confrontava i due mondi - Remoting vs web services - lo potete trovare qui. Per spiegare meglio la soluzione proposta in questo blog, ho scritto un banale progetto con MonoDevelop che è possibile scaricare dal link a fondo pagina. Questo piccolo progetto ripropone quanto già detto nel blog riguardante la creazione di servizi con Mono. Per questa occasione ho aggiunto al servizio la possibilità di richiamare una funzione all'interno di una classe direttamente grazie al Remoting.

Innanzitutto, il file allegato presenta tre progetti:

Servizio che attende le chiamate via Remoting.
Client che richiama la funzione via Remoting al servizio.
Classe con l'interfaccia per lo scambio di informazioni.

Il progetto con l'interfaccia è una banale classe con questo codice:

using System;
public interface IRequestInformation
{
string GetNameAndDateTime(string name);
}

Molto banale: è una funzione che accetta come parametro una stringa e ritorna un'altra stringa. Ora nel servizio dobbiamo esporre questa interfaccia con una classe all'interno del servizio. Nulla di complesso:

private void _MainLoop ()
{
TcpChannel channel = new TcpChannel(1981);
ChannelServices.RegisterChannel(channel,false);
RemotingConfiguration.RegisterWellKnownServiceType(
typeof(Information),
"RemotingMessage",WellKnownObjectMode.SingleCall);
MainClass.WriteLog(ServiceName, "Remoting started...");
while (!stopThread)
Thread.Sleep (2000);
}

_MainLoop è la funzione che è possibile trovare spiegata nel blog precedente. In quell'esempio era presente solo il ciclo while, ora è stato aggiunto il codice per l'attesa di chiamate dalla porta Tcp 1981 della classe "Information":

namespace service1
{
public class Information:MarshalByRefObject, IRequestInformation
{
public Information()
{
}
public string GetNameAndDateTime (string name)
{
MainClass.WriteLog("Remoting", "received: "+name); // scrive log
return string.Format("{0}: {1}",name, DateTime.Now);
}
}
}

Questa classe espone l'interfaccia IRequestInformation e il metodo GetNameAndDateTime. Siccome mi manca la fantasia non faccio altro che tornare una stringa contenente il name passato insieme alla data e ora attuale.

Il progetto client allegato è una console application che richiama via remoting la funzione presente nel servizio:

using System;
using System.Runtime.Remoting;
using System.Runtime.Remoting.Channels;
using System.Runtime.Remoting.Channels.Tcp;

namespace client
{
class MainClass
{
public static void Main(string[] args)
{
try
{
string name="io"; // Stringa di default se non vengono passati parametri
if (args.Length>0) name=args[0];
IRequestInformation remot;
string location = "tcp://192.168.0.7:1981/RemotingMessage";
remot = (IRequestInformation)Activator.GetObject(
typeof(IRequestInformation), location);
Console.WriteLine(remot.GetNameAndDateTime(name));
}
catch (RemotingException)
{
Console.WriteLine("Impossibile comunicare con il server");
}
}
}
}

Anche qui viene usato l'interfaccia per la creazione automatica per l'utilizzo della classe presente nel servizio. Il Framework penserà al posto nostro alla creazione di una classe proxy per la serializzazione binaria e la trasmissione.

Se si è seguito il blog precedente e il servizio gira sulla macchina (sia che si tratti di Windows che Linux), possiamo richiamare il servizio direttamente dall'eseguibile client:

Questo anche da altre macchine Linux con Mono:

In entrambi i casi il servizio ha risposta ritornando correttamente la stringa passata con la data e l'ora della richiesta. Inoltre, il nostro servizio è in grado di loggare le richieste. Vediamo che cosa ha memorizzato:

Il codice presente nell'allegato ha l'ip e la porta memorizzati direttamente nel codice, per modificarli è necessario ricompilare i progetti. Potevo configurare il Remoting con il file di configurazione del progetto, lo so, ma non ne avevo voglia. Ma se volete provarlo o avete questa strada o fate in modo che il servizio sia memorizzato da una macchina con ip 192.168.0.7.

Una piccola divagazione a margine: come detto nel blog precedente i test sono stati fatti su una macchina con Ubuntu. A parte la versione vecchia di Mono presente nei repository di questa distribuzione, ho scoperto un'altra anomalia. Con l'esempio presente che comunica con porte TCP, mi aspettavo di dover configurare il firewall, proprio come Windows richiede. Con Ubuntu non ho avuto alcun problema. I pacchetti sono passati senza problemi. Dopo una piccola ricerca scopro che Ubuntu ha sì il firewall attivo, ma permette il passaggio indiscrimanto da qualsiasi porta! La più famosa, e forse utilizzata, distribuzione Linux ha un firewall pressocché inutilizzato! La cosa mi ha sorpreso dato che, per esempio, OpenSuse ha il suo bel firewall attivo... Roba da Windows 2000... per fortuna almeno non ha gli stessi problemi di sicurezza.

Dimenticavo: l'allegato è possibile scaricarlo da questo link. La piadina che ho mangiato a cena ce l'ho ancora sullo stomaco. Questa è un'altra divagazione.

Tags: Mono

TrueCrypt 6.0

Utilizzo da parecchio tempo questo software open source per proteggere i miei dati personali sul portatile. Portandolo sempre dietro per lavoro e lasciandolo in posti dove potrebbe essere a rischio di furti, non voglio che miei documenti personali, gli account di accesso a email o server e, non per ultimo, dati di altre società, possano finire in mani estranee.

Qualche giorno fa è uscita la nuova versione 6.0 che permette una maggior protezione dei dati. Uno dei punti di forza di TrueCrypt è l'hidden truecrypt volume. Anche se a me non serve un grado di protezione di quel livello, questa opzione permette di creare una partizione nascosta all'interno di un'altra partizione cryptata. In poche parole possiamo fare in modo che ad una stessa partizione criptata vi possiamo accedere con due password differenti, le quali danno accesso a due dischi virtuali differenti con ognuno di essi dati differenti.

Come viene spiegato sul sito di questo software, questa funzione è utile nel caso si venga constretti a fornire la password dietro minaccia o altro. In questo modo è possibile fornire la password per l'accesso al primo disco fittizio mentre il secondo, con i dati veramente importanti, rimane invisibile. Da notare che anche se il disco nascosto all'interno occupa svariati megabytes, questi non vengono detratti dal disco che lo contiene per evitare che la cosa possa essere scoperta. Maggiori info a questa pagina.

In ultimo, una partizione create con TrueCrypt può essere letta da qualsiasi sistema operativo: Windows, Linux, Mac... Comodo.

Tags: Off Topic

Environment.NewLine

Si ignora questa proprietà, si preferisce utilizzare i codice escape '\r' e '\n'; in C# basta scrivere "Testo\r\n" per avere un ritorno a capo, in VB: "Testo" & vbCrLf (oppure "Testo" & chr(13) & chr(10)). Eppure questa property è utile perché imposta il corretto ritorno a capo dipendentemente dal sistema operativo su cui gira consentendo una portabilità del nostro codice.

L'ipotetico codice in C# per scrivere, per esempio, del testo in un file:

string text="Prima riga" + Environment.NewLine + "Seconda riga";

Sarà trasformato, nel nostro abituale Framework su Windows, in:

string text="Prima riga\r\nSeconda riga";

Ma se il codice qui sopra venisse eseguito da Mono su macchine Linux? Ecco il risultato:

string text="Prima riga\nSeconda riga";

Il perché è molto semplice. Fin dal suo primo vagito Ms Dos utilizzava questo doppio codice per il ritorno a capo, mentre altre altri sistemi operativo come Linux, usano il singolo carattere di line feed.

Non si prevede la portabilità di codice fuori Windows? Ognuno fa quello che gli pare.

Tags: .NET Framework, Mono

[OT] Scannerizzare lastre e risonanze magnetiche

Visto che più di una persona(*) mi ha chiesto come ho fatto a scannerizzare una risonanza magnetica, ho deciso di rivelare qui il grande segreto.

Innanzitutto, avevo cercato info su internet su come si potesse trasferire al computer con scanner o altri mezzi questi referti medici, senza mai trovare una tecnica semplice; avevo trovato risposte di persone che consigliavano la richiesta dei risultati direttamente su CD o l'utilizzo di scanner appositi. Siccome io non potevo utilizzare nessuna delle due tecniche, in preda ad astinenza da antidolorifico, mi sono inventato una tecnica molto semplice che porta buoni risultati.

Dopo vari tentativi con gli unici due scanner che ho a casa in varie modalità operativa come "diapositiva", tenendo il coperchio aperto, fornendo luce supplementare sopra alla lastra e così via senza giungere a nulla di buono, sono arrivato alla conclusione che la tenica più semplice era utilizzare una macchina fotografica per fotografare direttamente le lastre controluce. I primi tentativi con lampadine, luce del sole, fanali dell'auto non portavano a buoni risultati visto che non permettevano la diffusione della luce in modo omogeneo per tutto il referto medico. Dovevo trovare un modo per avere quella luce bianca e omogenea che hanno a disposizione i radiologi per esaminare le lastre.

La soluzione è stata più banale del previsto. Ho utilizzato banalmente il monitor lcd del portatile. E' stato sufficiente visualizzare a pieno schermo un'immagine bianca, appoggiandoci sopra la risonanza magnetica, e dalla distanza di ~15 centimetri, fotografarla con una macchina digitale. Consiglio una fotocamera con almeno 4 mega pixel. Sotto a questa risoluzione, come i tipici 1.3 mega pixel del cellulare - con cui ho fatto delle prove - si ottengono risultati scadenti.

Un ultimo quesito che ho fatto a cinque persone e solo una ha saputo darmi la risposta corretta: come si visualizza una schermata completamente bianca che occupa il monitor? La risposta qui sotto (**).

(*) in due me l'hanno chiesto.
(**) con Paint si crea un'immagine bianca con la dimensione della risoluzione del monitor e si visualizza a pieno schermo.

Tags: Off Topic

Servizi in C# su macchine Linux con Mono

Pochi giorni fa ho dovuto rifarmi una macchina su cui girava OpenSuse (la distribuzione che preferisco), ed ho deciso di installare la nuova versione di Ubuntu 8.04 per curiosità visto che l'ultima versione provata di Ubuntu era la 7.04 e volevo provare con mano l'evoluzione avvenuta in questi dodici mesi.

La prima delusione l'ho avuta nel constatare che la versione presente nei repository di Mono è la 1.2.6, mentre l'ultima release è la 1.9.1. Non mi pongo problemi, e visto che dovevo installare un servizio per... ehi, un momento, non sono obbligato a scrivere nel dettaglio i fatti miei! Riprendo: dovendo installare un servizio scritto in C# su questa macchina installo mono e mono-service2 dai repository di Ubuntu. mono-service2 è un tool che permette la gestione dei servizi scritti per Mono sotto Linux.

Per informazione riporto un pubblico esempio di un servizio scritto in C# che può girare sia sotto Windows che Linux. Il codice seguente è possibile compilarlo Visual Studio, da linea di comando sotto Linux con Mono o con MonoDevelop, e può essere testato anche come console application:

// Main.cs created with MonoDevelop // User: az using System; using System.Collections; using System.ComponentModel; using System.Diagnostics; using System.ServiceProcess; using System.IO; using System.Configuration.Install; using System.Threading; namespace service1 { class MainClass { private const string LogFile = "TestService.log"; // The main entry point for the process static void Main() { Write2Log(null, "Main starting"); System.ServiceProcess.ServiceBase[] ServicesToRun; ServicesToRun = new System.ServiceProcess.ServiceBase[] { new TestService("TestService1")}; System.ServiceProcess.ServiceBase.Run(ServicesToRun); Write2Log(null, "Main ended"); } public static void Write2Log(string category, string message) { using (StreamWriter w = new StreamWriter(LogFile, true, System.Text.Encoding.UTF8) ) { if ( category != null ) w.WriteLine(DateTime.Now.ToString() + " " + category + " - " + message); else w.WriteLine(DateTime.Now.ToString() + " " + message); } } } public class TestService : System.ServiceProcess.ServiceBase { private Thread mainThread = null; private bool stopThread = false; public TestService(string name) { this.ServiceName = name; this.CanPauseAndContinue = true; } protected override void Dispose( bool disposing ) { MainClass.Write2Log(ServiceName, "Dispose"); base.Dispose( disposing ); } protected override void OnStart(string[] args) { MainClass.Write2Log(ServiceName, "Starting Service..."); mainThread = new Thread (new ThreadStart (_MainLoop)); stopThread = false; mainThread.Start (); } protected override void OnStop() { MainClass.Write2Log(ServiceName, "Stopping Service..."); if (mainThread != null) { stopThread = true; mainThread.Join (); mainThread = null; } } protected override void OnPause() { MainClass.Write2Log(ServiceName, "Pausing Service..."); } protected override void OnContinue() { MainClass.Write2Log(ServiceName, "Continuing Service..."); } private void _MainLoop () { while (!stopThread) Thread.Sleep (2000); } } ///


 /// This class allows easy installation of this service on Windows.
 ///


 [RunInstaller(true)]
 public class ProjectInstaller : System.Configuration.Install.Installer
 {
  private System.ServiceProcess.ServiceProcessInstaller serviceProcessInstaller1;
  private System.ServiceProcess.ServiceInstaller serviceInstaller1;
  private System.ComponentModel.Container components = null;

  public ProjectInstaller()
  {
   // This call is required by the Designer.
   InitializeComponent();
  }

  /// 
  /// Clean up any resources being used.
  /// 

  protected override void Dispose( bool disposing )
  {
   if( disposing )
   {
    if(components != null)
    {
     components.Dispose();
    }
   }
   base.Dispose( disposing );
  }

  #region Component Designer generated code
  /// 
  /// Required method for Designer support - do not modify
  /// the contents of this method with the code editor.
  /// 

  private void InitializeComponent()
  {
   this.serviceProcessInstaller1 = new System.ServiceProcess.ServiceProcessInstaller();
   this.serviceInstaller1 = new System.ServiceProcess.ServiceInstaller();
   //this.serviceInstaller2 = new System.ServiceProcess.ServiceInstaller();
   // 
   // serviceProcessInstaller1
   // 
   this.serviceProcessInstaller1.Password = null;
   this.serviceProcessInstaller1.Username = null;
   // 
   // serviceInstaller1
   // 
   this.serviceInstaller1.DisplayName = "Test Service 1";
   this.serviceInstaller1.ServiceName = "TestService1";
   // 
   // ProjectInstaller
   // 
   this.Installers.AddRange(new System.Configuration.Install.Installer[] {
       this.serviceProcessInstaller1,
       this.serviceInstaller1
     });
  }
  #endregion
 }
}

Questo servizio è solo un test: scrive in un file di testo quando il servizio viene avviato e quando viene fermato. Una volta testato e confermato il suo funzionamento corretto, provo ad installarlo come servizio sotto Ubuntu con mono-service2. L'help di questo comando è molto chiaro:

az:~$ mono-service2 
You must specify at least the assembly name

Usage is: /usr/bin/mono-service2 [options] service

    -d:         Working directory
    -l:         Lock file (default is /tmp/.lock)
    -m:       Name to show in syslog
    -n:      Name of service to start (default is first defined)
    --debug                Do not send to background nor redirect input/output
    --no-daemon            Do not send to background nor redirect input/output

Controlling the service:

    kill -USR1 `cat `    Pausing service
    kill -USR2 `cat `    Continuing service
    kill `cat `          Ending service

az:~$

Ok, vado nella directory dove è presente il codice compilato del servizio e lancio il comando con l'opzione della working directory:

sudo mono-service2 -d:/home/az/project/service1/service1/bin/Debug/  /home/az/project/service1/service1/bin/Debug/service1.exe

Ma ottengo un non precisato errore: "41: Syntax error: Bad fd number". Una veloce ricerca e trovo che è un bug noto sotto Ubuntu. Sempre a quel link è presente la correzione da fare, anche se un modo migliore per risolvere ogni problema lo spiegherò dopo.

Finalmente tutto funziona. Ora per fare le cose per bene dobbiamo fare in modo che tale servizio sia avviato in automatico all'avvio della macchina, senza nessuna autenticazione dell'utente. Per ottenere questo è necessario creare uno script apposito in "/etc/init.d/". Lo script, che chiamerò "azservice" è il seguente:

#!/bin/sh
# Start/stop the az daemon.
#
### BEGIN INIT INFO
# Provides:          service1
# Short-Description: Test di AZ
# Description:       Service write in C# for mono and linux world
### END INIT INFO

. /lib/lsb/init-functions

case "$1" in
start) log_daemon_msg "Starting test service az" "az-service1"
 mono-service2 -d:/home/az/project/service1/service1/bin/Debug/  /home/az/project/service1/service1/bin/Debug/service1.exe
 ;;
stop) log_daemon_msg "Stopping test service az" "az-service1"
 kill `cat /tmp/service1.exe.lock`
        ;;
restart) log_daemon_msg "Restarting test service az" "az-service1"
 kill `cat /tmp/service1.exe.lock`
 mono-service2 -d:/home/az/project/service1/service1/bin/Debug/  /home/az/project/service1/service1/bin/Debug/service1.exe
        ;;
reload|force-reload) log_daemon_msg "Reloading test service az" "az-service1"
 kill `cat /tmp/service1.exe.lock`
 mono-service2 -d:/home/az/project/service1/service1/bin/Debug/  /home/az/project/service1/service1/bin/Debug/service1.exe
        ;;
*) log_action_msg "Usage: /etc/init.d/azservice {start|stop|restart|reload|force-reload}"
        exit 2
        ;;
esac
exit 0

Dipendentemente dall'opzione passata (start, stop, restart, reload, force-reload), viene invocato in comando mono-service2 con le opzioni necessarie per avviare, fermare o riavviare il servizio:

sudo /etc/init.d/azservice start
sudo /etc/init.d/azservice stop

Per essere richiamato con il precedente modo dobbiamo aggiungere a questo file il flag "avviabile":

sudo chmod +x /etc/init.d/azservice

Trovo interessante il modo utilizzato per fermare un servizio. Prendendo la linea di codice utilizzata si può notare una strana sintassi per chi non è avvezzo a Linux:

kill `cat /tmp/service1.exe.lock`

cat /tmp/service1.exe.lock visualizza normalmente a video il contenuto del file (in questo caso il numero di processo del servizio). Racchiuso tra quegli apici, prende l'output del comando e lo invia a kill che fermerà il processo del servizio.

Per completare il tutto dobbiamo inviare un ultimo comando. Linux ha vari level di avvio. Ognuno di essi si contraddistingue per l'avvio di n servizi. Maggiori informazioni a riguardo si possono trovare qui. Per fare in modo che il nostro servizio sia collegato a questi level, dobbiamo scrivere il comando:

sudo update-rc.d azservice defaults

Dove azservice è il nome del file che abbiamo creato in /etc/init.d/. Il nostro lavoro è finito. Ad ogni avvio il servizio verrà richiamato. Un piccolo avvertimento: questo servizio ha normalmente accesso a tutti i file e un'operazione sbagliata può creare danni irreversibili sulla macchina (ipottizzando che debba cancellare dei file presenti in una directory, un comando come rm -rf * può avere effetti indesiderati se richiamata nella directory root della macchina ;)).

Ubuntu presenta un tool "Servizi" che permette la gestione dei servizi sulla macchina. Si può notare come quello appena creato non sia presente nella lista. Non volendo investigare oltre per scoprire il perché, ho utilizzato di un altro strumento più potente, "BUM" (Boot-up manager) installabile dai repository, in grado di gestire anche quello che ho appena creato, come si vede in figura:

Nel caso di Ubuntu consiglio anche l'upgrade immediato all'ultima versione 1.9.1 di Mono. Per ottenere questo è sufficiente aggiungere il repository di Mono, come è spiegato qui, che risolve anche il bug prima citato di mono-service2.

Tags: .NET Framework, Mono

[OT] Problema serio ai dischi

A febbraio avevo avuto le prime avvisaglie. Da febbraio un lento degrado del disco ha comportato sempre più problemi fino alla rottura dello stesso. Solo un esame approfondito ha evidenziato il problema nel dettaglio:

Dalla seconda settimana di maggio ciò mi ha portato a passare pressocché tutto il tempo a letto per una fortissima sciatalgia, un abuso di antidolorifici e stampelle per camminare. Solo dopo una urgente risonanza magnetica e un urgente operazione chirurgica il problema si è risolto... Per quei pochi che si erano chiesti che fine avessi fatto in tutto questo tempo...

E così questa stagione in bici è andata... L'unica cosa positiva è che non ho perso dati! :-D

Tags: Off Topic

UrlRewriting con trabocchetti vari

Mi sono preso un paio di giorni per sistemare il mio sito. A parte la sporcizia di codice che lo ha sempre contraddistinto (all'interno è codice in VB del 2002) e che ho in parte ripulito, ho implementato un url rewriting per migliorare l'indicizzazione da parte dei motori di ricerca.

Visto che è il mio quel sito, e visto che è sempre stata la mia palestra per l'asp.net, ho provato vari modi per la sua implementazione. Inizialmente avevo posto la mia attenzione all'uso degli handler come avevo spiegato qui nel lontano luglio del 2004, tecnica che trovo descritta anche attualmente in molti blog. Ma mi sono dovuto ricredere dopo i primi rilasci in beta per dei rallentamenti iniziali che non mi spiegavo. Dopo aver studiato per bene il funzionamento di tale tecnica con la mia web application, ho dovuto prendere la decisione di rinunciare, perché sì questa tenica risolve molti problemi, come il cambio di nome per i postback e necessità simili, ma creava un lavoro al server supplementare del tutto inutile.

L'uso di quel tipo di handler prende in consegna al richiesta e la ricompila con il nome della nuova pagina, e questo creava tanti file compilati nella cache di asp.net, quante erano le pagine elaborate con tale tecnica. Riprendendo l'esempio con quello script, io facevo in modo che un link di questo tipo:
www.nomesito.xxx/articolo.aspx?codice=001

Potesse venire invocato con questo url:
www.nomesito.xxx/articolo001.aspx

Il problema è dato dal fatto che ogni singolo articolo così specificato crea nella cache di asp.net una pagina compilata a sé, e per ogni articolo richiesto c'è un periodo di latenza dovuta alla nuova compilazione. Lo scenario diventa apocalittico se, nel mio caso e per il sito, gli articoli fossero stati un milione e fosse molto trafficato e tutti sarebbero richiesti. Nella cache di asp.net si sarebbero creati, per assurdo e solo teoricamente, 1.000.000 di file!

Ho deciso così di risolvere in un altro modo più semplice e prestazionale. In rete sono disponibili gratuitamente due componenti che fanno questo lavoro egregiamente lasciando perdere quello introdotto di asp.net 2.0 che è molto limitato. Io ho preso in considerazione:

Entrambi hanno funzioni complete, come l'uso del codice http 301 per i trasferimenti di pagina e così via. Alla fine la mia decisione è caduta sul primo, ma solo per casualità.

In ogni caso, attenzione all'handler e al PageParser.GetCompiledPageIstance e a come viene utilizzato. Nel mio caso era un danno.

Tra due giorni è Santa Lucia.

Tags: .NET Framework, .NET Framework 2.0, ASP.NET, HttpHandler

[OT] Noi che...

Anche se io faccio raramente OT nel mio blog, mamma mia che bugiardo sono, ecco dei link solo per gente nata negli anni '70 e i primi anni '80:

http://www.youtube.com/watch?v=BITzJGcFA_I
http://www.youtube.com/watch?v=-jHB1ZsM2-Q

Per gli emotivi, preparate i fazzoletti! :')

Tags: Off Topic

Windows Forms - DataGridView e validazione

Sto sistemando una piccola applicazione windows forms che ho scritto in C# per renderla più umana. Ieri sera ho perso più di un'ora - due - per risolvere un problema con la validazione dei dati inseriti in un DataGridView. Tutto sembrava semplice all'inizio visto che è sufficiente agganciare all'evento CellValidating il proprio codice per controllare il contenuto delle celle:

        private void dataGridView1_CellValidating(object sender, DataGridViewCellValidatingEventArgs e)
        {
            ...
            if (e.ColumnIndex == 2)
            {
                int numero;
                if (int.TryParse(e.FormattedValue.ToString(), out numero) == false)
                {
                    dataGridView1.Rows[e.RowIndex].ErrorText = "Inserire un valore numerico!";
                    e.Cancel = true;
                }
                else
                {
                    dataGridView1.Rows[e.RowIndex].ErrorText = null;
                }
            }
        }

Avviato l'esempio è tutto ok, nella cella prescelta posso inserire solo un valore numerico intero, altrimenti compare il bollino rosso e l'errore specificato. Ma da qui inizia il patimento. Se, lasciato il contenuto errato in quella cella, qualsiasi altro webcontrol non risponde, neanche la chiusura della finestra. Penso che sia come per le web application: modifico la proprietà "Validating" dei singolo webcontrol all'infuori del DataGridView, ma nulla. Inizio a fare una ricerca su Internet, e trovo che è un problema comune e scopro qualche trucco per scavalcare il problema, ma non in modo soddisfacente.

Alla fine, testando, mettendo più idee insieme e tirando cazzotti alla tastiera ho trovato una buona soluzione. Innanzitutto è necessario disattivare la generazione di exception in caso di inserimento di un dato errato nella cella. Aggiungiamo questo codice all'avento DataError del DataGridView:

private void dataGridView1_DataError(object sender, DataGridViewDataErrorEventArgs e)
        {
            e.ThrowException = false;
        }

Ora aggiungiamo quest'altro codice all'evento Leave, che ci permette di ripristinare il contenuto della cella che era presente prima della nostra modifica o per inserire un valore di default dato il tipo:

private void dataGridView1_Leave(object sender, EventArgs e)
        {
            for (int i = 0; i < dataGridView1.Rows.Count; i++)
            {
                for (int y = 0; y < dataGridView1.ColumnCount; y++)
                {
                    dataGridView1.Rows[i].Cells[y].Value=
                        dataGridView1.Rows[i].Cells[y].GetEditedFormattedValue(i, DataGridViewDataErrorContexts.Commit);
                }
            }
        }

Infine, per permettere la chiusura della finestra senza comunicazioni alcune, aggiungiamo questo codice all'evento FormClosing della nostra form:

private void Principale_FormClosing(object sender, FormClosingEventArgs e)
        {
            e.Cancel = false;
        }

Fine.

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

Contro il caro pertrolio

In zone extradoganali fare benzina ritorna ad essere un piacere:

Verde a 0.889 e gasolio a 0.750 al litro è un miraggio ormai... Miraggio... incredulità, come si prova sempre, anche se si conosce, poco lontano al passo Bernina a 2.350 m.s.l.m., dopo essere scesi da un ripido sentiero, nel trovarsi dinanzi una stazione:

Va be', è una stazione del famoso trenino rosso.

Tags: Off Topic

Firme nei forum: record!

Un amico di Milano sa il mio astio per i forum che permettono la libera creazione di firme nei post senza limiti. Ricordo che, scherzando con l'amico, gli dissi che mancavano solo i DIVX come firma... ebbene, dopo aver trovato in alcuni forum di community immagini assurde di centinaia di KB - ma a che servono? - finalmente(!?!?) ho trovato un filmato in una firma!

Senza spiegare perché sono finito su quel forum, ecco la pagina incriminata dove è possibile vedere la firma di Sissi66. D'accordo, non è un divx ma è una gif animata, anzi due, che pensano complessivamente 1,9MB!!!

Sono sempre più convinto che un'educazione informatica sarebbe necessaria prima di permettere l'uso di un computer.

Svestitelo e lui saprà guarire,
e se non sa guarire uccidetelo!
È solo un medico, solo un medico!
(Un medico di campagna - Franz Kafka)

Tags: Off Topic

Flashblock - per evitare l'abuso di flash nei siti

Se non fosse che è utile per quei siti che vivono grazie alla tecnologia multimediale di Macromedia, lo avrei disabilitato, disinstallato, o mai installato, il player di Flash visto l'abuso che in questi ultimi mesi/anni si è avuto.
Per Firefox c'è una ottima extension che permette di abilitare solo dove si vuole le applet in flash potendo seleziona quali siti abilitarle di default permanentemente.
L'extension si chiama Flashblock e lo si può installare da questa pagina. Dopo averlo avviato ecco come appare una schermata di youtube:

Per caricarlo è sufficiente cliccare sul simbolo al centro dell'oggetto. Comodissimo, peccato che una simile utility non esiste per IE7 - almeno io non l'ho mai trovata.

Tags: Off Topic

Critiche tecniche del blog di Beppe Grillo

In questo blog non voglio criticare né lui, né le sue idee né i suoi accoliti né le sue iniziative. Ma non si possono avere pagine del blog di 7MB come questa. A parte il caricamento lento, il rendering è pesante persino sui computer veloci per non parlare dell'encoding dei caratteri che su alcuni rss aggregator crea problemi. Una decente paginazione dei commenti o la creazione di un forum apposito, non sarebbe l'ideale per una fruizione più comoda e veloce?

Se il buongiorno si vede dal mattino...

Tags: Off Topic