La serializzazione è l'operazione di generazione di uno stream (MemoryStream) contenente un clone in bytes della classe serializzata. Lo stream può essere utilizzato successivamente per la scrittura di un file fisico o per la trasmissione in rete. La Deserializzazione è l'operazione contraria, partendo da un backup della classe serializzata si ottiene uno stream contenente il clone della classe e da questo la classe stessa. La classe da serializzare deve essere decorata con l'attributo "Serializable"

Ecco un esempio pratico di serializzazione deserializzazione di una classe in c#:

namespace Ollie10.Serializer
{
    #region

    using System;
    using System.Drawing;
    using System.IO;
    using System.Runtime.Serialization.Formatters.Binary;

    #endregion

    /// <summary>
	/// Esempio di serializzazione 
	/// Definizione una classe "Serializer" 
	/// Si decora la classe l'attributo [Serializable] (obbligatorio per i nostri scopi)
	/// </summary>
	[Serializable]
	public class Serializer
	{
		// definizione membri privati
		private int mIntero;
		private string mTesto;
		private DateTime mDataOra;
		private decimal mDecimale;
		private bool mBooleano;
		private Image mImmagine;

	    #region Proprietà
		public int Intero
		{
			get 
			{
				return mIntero;
			}
			set
			{
				mIntero = value;
			}
		}
		public string Testo
		{
			get
			{
				return mTesto;
			}
			set
			{
				mTesto = value;
			}
		}
		public DateTime DataOra
		{
			get
			{
				return mDataOra;
			}
			set
			{
				mDataOra = value;
			}
		}
		public decimal Decimale
		{
			get
			{
				return mDecimale;
			}
			set
			{
				mDecimale = value;
			}
		}
		public bool Booleano
		{
			get
			{
				return mBooleano;
			}
			set
			{
				mBooleano = value;
			}
		}
		public Image Immagine
		{
			get
			{
				return mImmagine;
			}
			set
			{
				mImmagine = value;
			}
		}
		#endregion
		#region Metodi serializzazione
		/// <summary>
		/// Serialize della classe Serializer
		/// </summary>
		/// <param name="serData">Classe da serializzare</param>
		/// <param name="NomeFile">Nome del file da generare</param>
		/// <returns>Operazione Eseguita/Non eseguita</returns>
		public bool Serialize(Serializer serData,string NomeFile)
		{
			bool RetValue = true;
			MemoryStream ms = new MemoryStream();
			BinaryFormatter br = new BinaryFormatter();
			using (FileStream fs = new FileStream(NomeFile, FileMode.OpenOrCreate))
			{
				try
				{
					// il metodo Serialize di BinaryFormatter
					// restituisce nella variabile ms (MemoryStream) 
					// la classe serializzata
					br.Serialize(ms,serData);
					// scriviamo sul file (FileStream fs) 
					ms.WriteTo(fs);
				}
				catch (Exception ex)
				{
					System.Diagnostics.Debug.WriteLine(ex.Message);
					System.Diagnostics.Debug.WriteLine(ex.StackTrace);
					RetValue = false;
				}
				finally
				{
					fs.Close();
				}
				
			}
			return RetValue;
		}
		/// <summary>
		/// Deserializzazione per la classe Serializer
		/// </summary>
		/// <param name="NomeFile"></param>
		/// <returns></returns>
		public Serializer DeSerialize(string NomeFile)
		{
			using (FileStream fs = new FileStream(NomeFile, FileMode.Open))
			{
				BinaryFormatter bf = new BinaryFormatter();
				try
				{
					fs.Seek(0, SeekOrigin.Begin);
					return (Serializer) bf.Deserialize(fs);
				}
				catch
				{
					return null;
				}
				finally
				{
					fs.Close();
				}
			}
		}
		#endregion
	}
}

Questa versione del database è obsoleta, trovate la più recente (2010) in questo post
Per motivi di lavoro mi è capito di avere a che fare con la creazione di un database contenente la lista di tutti i comuni italiani e visto che a qualcuno potrebbe tornare utile ho pubblicato il materiale. Sono partito dai files originali pubblicati dall'istat (che sono allegati dentro lo zip) per arrivare a diversi formati già pronti ed usabili. I file sono tutti contenuti nello zip che potete scaricare in questo post, il contenuto è così composto:

• Cartella "Access" : il database nei tre formati access attualmente più usati 1997, 2000, 2003
• Cartella "Altri_Formati" : Il database nei formati Html, Xml, Lotus 1-2-3
• Cartella "Comuni_Italiani_2008_Con_Cap" : Altri files meno recenti in Excel e Csv ma comprensivi di CAP
• Cartella "File_Originali_2009" : Tutti i files originali pubblicati dall'istat formati Excel e Csv
• Cartella "Sql_Scripts": Questa cartella contiene i file più utili. 01_Generazione_Tabelle.sql, 02_Insert_Regions.sql, 03_Insert_Districts. sql, 04_Insert_Cities.sql contengono degli script sql che permettono di creare delle tabelle in un database con una struttura relazionale e ne inseriscono i dati all'interno in modo da avere un database già completo ed usabile. Le tabelle saranno collegate in questo modo Regioni -> Provincie -> Citta. Ci sono altri 2 files Tabelle_Complete.sql, Dati_Completi1.sql e Dati_Completi2.sql che creeranno due tabelle generiche con i dati di comuni, provincie e regioni a cui ci si può agganciare con delle viste o delle stored procedure per reperire i dati necessari

Un buon mezzo per evitare richieste al nostro database, è quello di mettere in cache alcune parti del nostro sito. Un esempio può essere una formattazione del testo e dei colori del sito a piacere dell'utente.

In questo caso sarebbe comodo creare un file Xml e metterlo in cache. Quest'ultima poi verrà settata in modo da dipendere dallo stesso file Xml per cui, ogni modifica sul file, farà scadere la cache e quindi il file Xml dovrà essere ricaricato.

Questo breve codice mostra un esempio di utilizzo della Cache:

private void InsertCache()
{ 
//Metto in cache il file Xml 
DataSet myDs = new DataSet(); 
FileStream fileXmlData; 
fileXmlData = new FileStream( Server.MapPath("xml/nomeFile.xml"), FileMode.Open, FileAccess.Read ); 
myDs.ReadXml(fileXmlData); 
Cache.Insert("FileInCache", 
new DataView(myDs.Tables[0]), 
new CacheDependency( Server.MapPath("xml/nomeFile.xml") ) ); 
fileXmlData.Close(); 
}

Questo tutorial video mostra come si può ridurre il rumore di una foto, senza perdere troppa definizione dell’immagine con Lightroom.

È possibile utilizzare filtri particolari per Photoshop, ma se il rumore non è eccessivo si può evitare il passaggio ad un altro programma e mantenere tutto in Lightroom.

Per ridurre il rumore ci sono due controlli che gestiscono luminanza e crominanza con cui bisogna trovare il giusto bilanciamento senza andare ad intaccare troppo i dettagli, che si possono recuperare ricorrendo alla sezione sharpening.

Questo è un video tutorial da 40 minuti in alta definizione sul fotoritocco professionale.

Tocca molti punti e tecniche che si possono utilizzare nei propri fotoritocchi. Tra le modifiche ci sono la correzione del colore, il cambiamento di aspetto di occhio, labbra e la modifica della profondità di campo.

Anche altre aree come il miglioramento di pancia e seno della modella vengono considerate. Dopo il salto è disponibile una versione sommario delle modifiche.

Sterzata decisa di Microsoft che in seguito al successo disarmante ottenuto dalla Beta pubblica di Windows 7 ha deciso di rimuovere il "tetto" di download, precedentemente fissato a 2.5 milioni di sessioni. Ora tutti gli utenti potranno scaricare Windows 7 in versione Beta, server Microsoft permettendo... Permane invece il limite temporale: i download dovranno necessariamente essere effettuati entro il 24 di gennaio. Oltre quella data i link verranno infatti disattivati e gli "esclusi" non potranno far altro che scavare tra i file della rete Torrent... come peraltro accaduto già prima del lancio ufficiale della Beta.