Mi sembra una buona idea definire anticipatamente questi due concetti.
Partiamo dalla serializzazione:

In informatica, la serializzazione è un processo per salvare un oggetto in [...] un file [...] in forma binaria o può utilizzare codifiche testuali (ad esempio il formato XML) direttamente leggibili dagli esseri umani. Lo scopo della serializzazione è di trasmettere l’intero stato dell’oggetto in modo che esso possa essere successivamente ricreato nello stesso identico stato dal processo inverso, chiamato deserializzazione.

Il concetto è semplice quanto efficace se associato al linguaggio di markup XML:

[...] è un metalinguaggio utilizzato per creare nuovi linguaggi, atti a descrivere documenti strutturati.

Quest’altro è invece un po’ più complicato, ma definiamo il nostro obiettivo e procediamo con un esempio.
Supponiamo di avere a disposizione, all’interno dela nostra applicazione, una lista di istanze appartenenti ad un tipo da noi definito come in questo esempio:

   1: //definizione tipo a livello di classe:

   2:  

   3: public struct messaggio {

   4:   public string mittente, destinatario, oggetto, testo;

   5: }

   6:  

   7: //creazione della lista di oggetti del tipo definito

   8:  

   9: List<messaggio> lista = new List<messaggio>();

  10: messaggio m;

  11:  

  12: //le seguenti istruzioni verranno eseguite più volte

  13: //modificando i valori dei campi in modo da riempire

  14: //adeguatamente la lista

  15:  

  16: m.mittente = "Antonio";

  17: m.destinatario = "Bruno";

  18: m.oggetto = "promemoria";

  19: m.testo = "ricordati l'appuntamento per le ore 14:00";

  20: lista.Add(m);

Una volta concluso il lavoro di riempimento della lista, ipotizziamo di voler salvare il risultato composto da struttura e contenuto di essa, in un file XML. Come fare?

Ecco la soluzione:

   1: XmlSerializer s = new XmlSerializer(typeof(List<messaggio>));

   2: TextWriter tw = new StreamWriter("messaggi.xml");

   3: s.Serialize(tw, lista);

   4: tw.Close();

Da notare che costruttore del serializzatore xml va fornito come parametro in ingresso il tipo di dato che dovrà poi serializzare e che è possibile utilizzare un semplice StreamWriter per creare il file in quanto presenta una codifica in tutto simile a quella dei file di testo.

Il nostro file “messaggi.xml”, se aperto con un qualsiasi browser, dovrà risultare simile a questo d’esempio:

Questa volta vi propongo la stessa funzione ma in un altro linguaggio, il Java. Il lavoro sembra, in questa occasione, ancora più semplice:

   1: import java.awt.Dimension;

   2: import java.awt.Rectangle;

   3: import java.awt.Robot;

   4: import java.awt.Toolkit;

   5: import java.awt.image.BufferedImage;

   6: import javax.imageio.ImageIO;

   7: import java.io.File;

   8:  

   9: public void screenshot(String percorso) throws Exception {

  10:   Dimension dimSchermo = Toolkit.getDefaultToolkit().getScreenSize();

  11:   Rectangle rect = new Rectangle(dimSchermo);

  12:   Robot r = new Robot();

  13:   BufferedImage img = r.createScreenCapture(rect);

  14:   ImageIO.write(img, "png", new File(percorso));

  15: }

Come vedete viene utilizzata un’istanza della classe “java.awt.Robot” che si occupa di catturare i singoli pixel di un rettangolo all’interno dello schermo (in pratica il rettangolo ha le stesse dimensioni di quelle totali del monitor) e di restituire una “BufferedImage”.

Notate che lo sceenshot verrà salvato in formato “png” nel percorso specificato come parametro in ingresso. Inoltre sarà importante, al momento di richiamare il metodo, inserire l’istruzione chiamante all’interno di un blocco di gestione delle eccezioni, un try-catch.
Questa operazione è necessaria perchè il metodo è definito come “throw Exception” e, per evitare notifiche di errore durante il debug, bisogna gestire preventivamente eventuali eccezioni.

In pratica voglio soltanto illustrare come effettuare lo swap di due variabili senza utilizzarne una d’appoggio in PHP, essendo l’azione possibile in un modo un po’ differente in questo linguaggio.

Ecco il codice:

   1: <?php

   2: $a = 10;

   3: $b = 20;

   4: list($a, $b) = array($b, $a);

   5: ?>

Come potete vedere viene utilizzata la funzione “list()” che serve per assegnare il valore a più variabili in un’unica istruzione ed il metodo “array()” che svolge un compito chiaramente intuibile.

Un post semplice semplice, soltanto per completare il discorso…alla prossima!

Per primo presento il metodo più diretto e conosciuto che sfrutta una variabile cosiddetta d’appoggio per effettuare lo scambio:

   1: void swap1(int a, int b) {

   2:   int tmp = a;

   3:   a = b;

   4:   b = tmp;

   5: }

In questo caso non vi è nulla da commentare.

Sfruttando però le potenzialità dei linguaggi “C-like” (C e derivati…) che supportano l’uso degli operatori bitwise si può inoltre implementare la funzione in questo modo:

   1: void swap2(int a, int b) {

   2:   a ^= b;

   3:   b ^= a;

   4:   a ^= b;

   5: }

Bisogna sottolineare che questo secondo algoritmo non supporta lo swap di 2 variabili uguali. Si riceverebbe quindi un risultato errato richiamandolo nel modo seguente:

   1: swap2(a,a);

che va quindi evitato.
La logica che sta dietro a questo metodo si basa completamente sull’utilizzo dell’”OR esclusivo” che solitamente si indica con il nome abbreviato “XOR”. Nei linguaggi di programmazione si utilizza indicandolo con il carattere “^” e, facendola breve, applicato a 2 variabili restituisce la proposizione “true” (vero) quando esse sono uguali. Il concetto espresso, applicato al codice binario, si occupa quindi di restituire il valore “1″ quando gli i-esimi bit delle variabili sono equivalenti.

Ecco un esempio:

   1: int a = 7; //in binario: 0111

   2: int b = 9; //in binario: 1001

   3: int c = a^b; //c = 1 perché:

   4:  

   5: /*

   6: a   b   c = a^b

   7: 0   1     0

   8: 1   0     0

   9: 1   0     0

  10: 1   1     1

  11: */

Passiamo all’ultimo metodo che a differenza dei precedenti non utilizza né una variabile d’appoggio, né l’OR esclusivo: soltanto somme e differenze. Non necessità di spiegazioni, potete capirne il funzionamento anche da soli pensandoci su un’attimo:

   1: void swap3(int a, int b) {

   2:   a += b;

   3:   b = a - b;

   4:   a -= b;      

   5: }

Che dire…let’s try!

   1: private string ricavaSorgente(string url) {

   2:   string s;

   3:   HttpWebRequest r1 = (HttpWebRequest)HttpWebRequest.Create(url);

   4:   HttpWebResponse r2 = (HttpWebResponse)r1.GetResponse();

   5:   StreamReader sr = new StreamReader(r2.GetResponseStream());

   6:   s = sr.ReadToEnd();

   7:   sr.Close();

   8:   r2.Close();

   9:   return s;

  10: }

Come vedete basta realizzare una richiesta allo specifico url ed incanalare la risposta dal server all’interno di uno stream. A questo punto basterà comportarsi allo stesso modo di come faremmo in locale andando a leggere tutto lo stream (grazie all’istruzione “ReadToEnd()”) utilizzando un semplice StreamReader. Il metodo si occupa quindi di liberare le risorse utilizzate e restituire in output il sorgente desiderato in formato stringa.

Esistono, però, anche metodi “preconfezionati” inseriti nel Framework che assolvono il medesimo compito. Potreste infatti preferire questa codifica:

   1: private string ricavaSorgente(string url) {

   2:   WebClient wc = new WebClient();

   3:   return wc.DownloadString(url);

   4: }

Per utilizzare i metodi finora descritti sara necessario includere due direttive using:
-”System.IO”
-”System.Net”

Qualche tempo fa avevo realizzato un browser e ricordo di aver utilizzato l’istruzione che segue per ricavare il sorgente della pagina corrente:

   1: string s = webBrowser1.DocumentText;

Solo un piccolo tip in più!