All’inizio la mia scelta è ricaduta su “Libero API for Fusion Charts”, un prodotto fatto davvero molto bene e che offre la possibilità di implementare diverse tipologie di grafico (tante!). Nonostante le sue caratteristiche ho dovuto mettere da parte questa libreria in quanto legata all’utilizzo del componente Flash (sempre questioni di legacy).

Alla fine ho optato per la soluzione che poi si è rivelata anche la migliore (e ancora mi chiedo perché non ci ho pensato prima?). La scelta è ricaduta su “Microsoft Chart Controls”.

Partiamo dal presupposto che questo prodotto non si presta bene, se non dopo qualche piccolo accorgimento, per essere utilizzato con ASP.NET MVC. Infatti nasce per funzionare principalmente all’interno di applicazioni Web Forms, la cui struttura è nettamente diversa da quella di un progetto MVC. Essendo il chart un controllo Server, necessita di una pagina web di tipo System.Web.UI.Page in cui poter essere posizionato, sappiamo bene che in una pagina MVC non è possibile inserire controlli di questo tipo.

Oggi vorrei spiegarvi come configurare il vostro progetto MVC perché i Microsoft Charts possano funzionare correttamente e senza alcun tipo di problema.

Prima di tutto è necessario estendere le funzionalità dell’oggetto Page perché possa occuparsi anche del disegno dei grafici ms. Lo facciamo realizzando un helper come nell’esempio che segue:

namespace MvcApplication.Helpers
{
	public static class HelperCharts
	{
		public static void RenderChart(this Page page, System.Web.UI.DataVisualization.Charting.Chart chart)
		{
			var writer = new HtmlTextWriter(page.Response.Output);
			chart.RenderControl(writer);
		}
	}
}

Chiaramente le istruzioni che abbiamo scritto sono poche e semplici, ritengo in ogni caso che lavorare in questo modo garantisce una migliore leggibilità e pulizia del codice  e, soprattutto per quanto riguarda MVC, rispetto delle regole imposte dal pattern.

Completato il metodo dobbiamo assicurarci che tale funzionalità sia poi disponibile in tutte le Views e che la gestione dei Charts possa essere correttamente eseguita dal .Net Framework, per tale motivo è necessario il file web.config:

<configuration>
	<appSettings>
		<add key="ChartImageHandler" value="storage=file;timeout=20" />
	</appSettings>
	<system.web>
		<httpHandlers>
		<add path="ChartImg.axd" verb="GET,HEAD,POST"
			type="System.Web.UI.DataVisualization.Charting.ChartHttpHandler,
				System.Web.DataVisualization, Version=4.0.0.0,
				Culture=neutral, PublicKeyToken=31bf3856ad364e35"
	        	validate="false" />
		</httpHandlers>
		<pages>
			<namespaces>
				<add namespace="MvcApplication.Helpers" />
			</namespaces>
		</pages>
	</system.web>
</configuration>

Come da documentazione è necessario aggiungere la chiave ChartImageHandler per definire le modalità di generazione del grafico (considerando che questo alla fine non è altro che un’immagine). Nell’elenco degli HttpHandlers è necessario configurare la risorsa utilizzata per la generazione dei grafici e, per concludere, volendo rendere visibile la funzione precedentemente scritta (RenderChart) in tutte le viste senza dover effettuare una import in ogni pagina del namespace, aggiungiamo all’elenco dei default namespaces anche quello in cui risiede il metodo da noi implementato.

In seguito possiamo realizzare un DTO fatto in questo modo:

namespace MvcApplication.Models.DTO
{
	public sealed class SampleDTO
	{
		public Chart Chart { get; private set; }

		public SampleDTO(Chart chart)
		{
			Chart = chart;
		}
	}
}

Possiamo ora creare un controller di esempio che dispone di un’Action che restituisce il DTO precedentemente realizzato:

namespace MvcApplication.Controllers
{
	using MvcApplication.Models.DTO;
	public class SampleController : Controller
	{
		[HttpGet] public ActionResult GetSampleChart()
		{
			Chart chart = new Chart();
			// Configure Chart...
			SampleDTO sampleDTO = new SampleDTO(chart);
			return View(sampleDTO);
		}
	}
}

E per concludere si passa alla View che si presenta come nell’esempio:

<%@ Page
	Title="Sample"
	Language="C#"
	MasterPageFile="~/Views/Shared/Shell.Master"
	Inherits="System.Web.Mvc.ViewPage<MvcApplication.Models.DTO.SampleDTO>" %>
<h2>Chart Sample</h2>
<div>
<% 	Page.RenderChart(Model.Chart); >
</div>

Con poche righe, abbiamo realizzato quanto necessario per poter sfruttare in modo corretto e pulito i Microsoft Charts nel nostro progetto MVC.

Enjoy!

Nel dover rilasciare l’applicativo si è verificato un particolare problema all’interno del Web Server IIS ospitante. Provando a chiamare l’applicazione da Browser veniva visualizzato il seguente messaggio di errore:

Could not load file or assembly 'Oracle.DataAccess' or one of its dependencies. An attempt was made to load a program with an incorrect format.

Provando a cercare online una possibile soluzione al problema mi sono imbattuto in una serie di Post infiniti in cui vengono proposti particolari workground da applicare direttamente sul file web.config per risolvere un problema di riferimenti che si creano durante l’utilizzo della libreria. C’è da notare che questo problema non si verifica se si lavora con il server web Cassini integrato in Visual Studio.

Poi però ho trovato una soluzione meno invasiva a livello applicativo ma configurabile direttamente sul web server. In pratica per risolvere il problema è necessario apportare una piccola modifica al Pool Applicativo utilizzato per l’esecuzione dell’applicazione quando questa gira su un server a 64bit. Aprendo Internet Information Services Manager è possibile, all’interno della voce “Application Pools” configurare in maniera più dettagliata uno di questi pool selezionando la voce “Advanced Settings…” subito dopo averne selezionato uno.

Per l’applicazione MVC realizzata è stato scelto come pool predefinito “ASP.NET v4.0”, nelle opzioni avanzate ho spuntato la voce “Enable 32-Bit Applications” in modo tale da permettere l’esecuzione di codice a 32 ed a 64 bit insieme.

Rigenerando il pool e riavviando l’applicazione, il problema non si presenta più!

1. è necessario avere molta pazienza perchè questo processo funzioni;
2. il processo è stato testato da me personalmente dopo non pochi tentativi totalmente falliti;

In ogni caso se avete problemi o non vi è chiaro qualche passaggio potete lasciare un commento e provvederò a rispondere non appena possibile. Ora partiamo con la guida!

• Scarichiamo USAIP.pbk dal seguente link e successivamente facciamo doppio-click sul file appena scaricato.
• Nella finestra che ci viene proposta selezioniamo la connessione “EUROIP PPTP Hungary” ed inseriamo le seguenti credenziali di accesso:
  Username: demo
  Password: demo
  Attenzione: questa connessione viene automaticamente chiusa dopo 7 minuti quindi cerchiamo di fare in fretta e con attenzione le operazioni successive (in ogni caso è sempre possibile effettuare una riconnessione).
  Altra nota: se la connessione di rete non viene aperta, è necessario modificare il registro di sistema scaricando una patch (un file reg) dal seguente link, successivamente è necessario riavviare il computer perchè tutto funzioni correttamente (quindi ripetiamo il primo passaggio).
• Ora sul nostro terminale Windows Phone disattiviamo la Connessione WIFI e ci assicuriamo che “Modalità Aereo” sia disattivata e “Rete Dati” sia attiva
• Avviamo Zune e nello stesso tempo lasciamo la configurazione “rete dati” (sul dispositivo) aperta in modo tale da poterci operare velocemente (fare un fast siwtch On|Off).
• Manualmente cerchiamo aggiornamenti da Zune (Settings ->Phone->Update)
• Dopo qualche secondo (il tempo è molto variabile, leggendo i vari commenti su XDA Developers alcune persone hanno aspettato 10-15 secondi, altre dai 33 ai 35 ed altre ancora addirittura oltre i 55 secondi), io con il mio HTC HD7 ho aspettato 15 secondi(dopo aver effettuato ben 3 diversi tentativi con 3 tempi diversi e 3 ripetizioni per ogni range temporale) prima di disattivare la rete dati (rispettivamente le voci “Rete dati” e “Connessione 3G“).
• Aspettiamo un’altro pò ed un popup sul nostro cellulare dovrebbe notificarci che un nuovo aggiornamento è disponibile!
• Questi primi passaggi avranno sicuramente impegnato molto tempo (più o meno 7 minuti, io in totale sono andato oltre i 30 minuti prima di completare l’operazione, tempo in cui è stata effettuata più volte la riconnessione tramite pbk) quindi riattiviamo la connessione alla rete “EUROIP L2TP Hungary” ed ora, con molta calma, Zune procederà al download del primo aggiornamento ufficiale per Windows Phone 7!
• Se non dovesse funzionare ripetiamo questo passaggio facendo attenzione al numero totale di secondi che aspettiamo ogni volta prima di disattivare la rete dati.

Lascio ad un altro giorno la mia recensione sull’HTC HD7 o più in generale su Windows Phone ma voglio concludere questo brevissimo post esponendo la mia opinione: quando ho comprato Windows Phone una delle caratteristiche che più mi attraeva (o che forse ho idealizzato io nella mia mente) era la poca frammentazione che questo sistema avrebbe creato (rispetto ad Android per esempio) o più in generale la facilità con cui un utente avrebbe potuto ricevere aggiornamenti sul proprio terminale senza dover aspettare o fare chissà cosa. Il fatto che io abbia scritto questo post è per me una delusione. Il primo update ufficiale è stato rilasciato quasi una settimana fà ed ancora oggi la maggior parte dei possessori di un Windows Phone riscontrano problemi nel reperire facilmente gli aggiornamenti (quindi non sto parlando solo di Italia).

In ogni caso spero che questa guida sia utile a voi tanto quanto lo è stata per me! Enjoy and stay tuned!

Fonte ufficiale: http://forum.xda-developers.com/showthread.php?t=1012189

Web Site

Un progetto “Web Site” non è altro che un insieme di file raggruppati all’interno di cartelle e sotto cartelle il cui tipo varia dalla semplice immagine, al file di testo per finire con i file di codice dell’applicazione. Non esiste un progetto reale associato ma una cartella root in cui tutto è contenuto. Un progetto di questo tipo è compilato dinamicamente mentre l’applicazione è in esecuzione e non contiene al suo interno una cartella bin.

Vantaggi:

• non è necessario avere un file di progetto o una cartella virtuale per la sua esecuzione
• il sito può essere facilmente distribuito facendo un copia incolla dei file da cui è composto

Svantaggi:

• non essendoci il file di progetto non è possibile avere un file di questo tipo con cui, facendo doppio click, è possibile aprire il progetto ottenendo l’elenco completo di tutto il materiale da cui è composto.
• per DEFAULT tutti i file che sono presenti all’interno della cartella del progetto sono da considerare parte stessa di questo, per tale motivo, se alcuni di questi vogliamo escluderli, dobbiamo inserire un suffisso per i file in questione: .exclude

Web Application Project

Questo tipo di progetto è molto più con un semplice “Web Site”. Pensato più in la nel tempo rispetto al suo predecessore, è considerato come un Add On di Visual Studio, aggiunto per la prima volta a partire da VS 2005, viene predisposto anche nei nuovi ambienti (Visual Studio 2008 e 2010).

Vantaggi:

• Tutto il codice viene compilato in un singolo Assembly il cui contenuto viene piazzato all’interno della cartella bin.
• Escludere file che non servono direttamente nel progetto è più semplice, essendoci una soluzione ed un file di progetto che ne identifica la struttura.

Svantaggi:

• Condividere il lavoro con altri colleghi risulta più complesso nel caso si utilizzi Microsoft Visual Source Safe e roba simile.

Chiariti questi macro concetti diventa più facile decidere, in ogni caso la documentazione MSDN mette a disposizione molta più roba in merito, il mio articolo vuole essere un riassunto molto “short” di ambedue le possibilità. A voi la scelta developer!

Oggi voglio mostrarvi come ho realizzato una guida in linea sensibile al contesto (Context Sensitive Help) all’interno di una Client Application realizzata con il .Net Framework.

* Tralasciando la spiegazione di come si realizza una guida in linea (Microsoft Compiled HTML Help), argomento su cui ci sarebbe molto da discutere, questo post vuole spiegare come integrare un file di questo tipo all’interno di un’applicazione Windows Form.

Partiamo dai presupposti, un oggetto di tipo System.Windows.Forms.Form espone una serie di proprietà, tra queste troviamo anche un evento chiamato HelpRequested che lo sviluppatore può eventualmente implementare, a riguardo la documentazione parla chiaro:

L’evento HelpRequested viene solitamente generato quando l’utente preme il tasto F1 o fa clic su un pulsante della Guida sensibile al contesto.

L’implementazione risulta molto semplice, nei form in cui vogliamo fornire aiuto possiamo decidere di invocare un metodo che possa, in base al contesto, darci informazioni utili reperite direttamente dal file di guida.

Inoltre è necessario sapere che un file di guida “Microsoft Compiled HTML Help” contiene al suo interno una serie di file html compressi, questi file vengono associati ad un identificatore univoco definito in un file Header (scritto in C) e che riporta il riferimento ad ogni link, questo file viene utilizzato in fase di compilazione della guida e serve propri per indicizzare i contenuti della nostra documentazione per poterla successivamente interrogare utilizzando un TopicId.

Ora, all’interno dei Windows Form sono si presenti delle proprietà per la gestione dell’Help ma non sono quelle di cui noi abbiamo bisogno (in pratica il .Net Framework mette a disposizione una serie di Tooltip che vengono visualizzati per dare aiuto). Supponiamo di aver definito nel nostro file di guida un argomento chiamato “Come effettuare il login”, a questo è stato assegnato l’indice 1000, come fare per ottenere un focus su questo argomento nella guida in linea direttamente dall’applicazione? La soluzione che ho applicato è molto semplice, ogni controllo, all’interno di un applicazione Windows espone una proprietà chiamata Tag che è di tipo Object, lo scopo di questa è proprio memorizzare informazioni aggiuntive nel nostro form come per esempio oggetti, stringhe o quanto ci possa tornare più utile, io ho deciso di inserire in questo campo il TopicId che dovrebbe essere richiamato se l’utente chiede aiuto durante l’esecuzione dell’applicazione, successivamente ho realizzato un oggetto che ho chiamato HelpProvider il cui compito è attivare l’help in linea su un determinato form:

internal sealed class HelpProvider
{
	//Nome del file guida
	private const string ChmFileName = "Docs.chm";
	private Form _form;

	internal Form Form
	{
		get
		{
			return (this._form);
		}
	}

	private HelpProvider()
	{
		this._form = null;
	}

	internal HelpProvider(Form form)
	{

		HelpNamespace = Path.Combine(
			Environment.CurrentDirectory,
			ChmFileName);

		_form = form;
		_form.HelpRequested += new HelpEventHandler(OnHelpRequestedAction);
	}

	internal void TryAsk()
	{
		Control ctrl = null;
		if ((this._form.ActiveControl != null)
			&&
		    (!IsNull(this._form.ActiveControl)))
			ctrl = this._form.ActiveControl;
		else
			ctrl = _form;

		if (ctrl.Tag == null)
		{
			Program.ShowWarning("Unable to retrive help information for this argument.");
			return;
		}

		Help.ShowHelp(ctrl, HelpNamespace, HelpNavigator.TopicId, ctrl.Tag as string);
	}

	/// <summary>
	/// Event Handled when an help request is execute by pressing F1
	/// </summary>
	/// <param name="sender" />
	/// <param name="hlpevent" />
	private void OnHelpRequestedAction(object sender, HelpEventArgs hlpevent)
	{
		this.TryAsk();

		hlpevent.Handled = true;
	}
}

Il funzionamento è molto semplice, questo oggetto riceve in ingresso un Form su cui imposta l’evento  HelpRequested per poter successivamente intercettare le richieste da parte dell’utente, resta in attesa, quando una richiesta viene inoltrata, viene scatenato l’evento OnHelpRequestedAction in cui viene invocato il metodo TryAsk.

Questo metodo effettua diverse operazioni, prima di tutto legge il valore del Tag del controllo che gli viene passato, se questo valore è diverso da NULL,  invoco un metodo, ShowHelp, che fornisce la classe Help del .Net Framework in cui passo:

• ctrl: Controllo che chiede Aiuto (un form o un qualsiasi controllo presente nella maschera corrente)
• HelpNamespace: nome del file di guida da invocare per la documentazione
• HelpNavigator.TopicId: modalità di lettura della documentazione,cioè, quando apro la guida, cosa devo fare esattamente, se cercare per argomento, per indice etc.
• ctrl.Tag: identificativo dell’argomento di cui vogliamo le informazioni.

L’HelpProvider, può essere facilmente utilizzato in questo modo: nel form in cui vogliamo rendere attiva la funzionalità di help, dichiariamo una variabile privata di tipo HelpProvider che andiamo ad inizializzare nel costruttore del nostro Form come nell’esempio che segue:

public class MyWindowsApp : System.Windows.Forms.Form {
	private HelpProvider _helpProvider;

	public MyWindowsApp() {
		_helpProvider = new HelpProvider(this);
	}
}

Con queste poche righe di codice abbiamo attivato un help in linea completo e funzionante!

Ricordate che per funzionare è necessario che i controlli e / o direttamente i form per cui devono essere disponibili informazioni, devono avere la variabile Tag valorizzata con un certo indice equivalente ad un TopicId del nostro file “Windows Compiled HTML Help”, in caso contrario l’help non viene mostrato.

Il problema è questo: supponiamo di voler implementare la chiamata ad una Stored Procedure il cui compito è:

• restituire un elenco di risultati
• restituire dei valori in output

La Stored Procedure accetta in input N parametri e restituisce in output altri M parametri. Per l’esempio che voglio proporvi ne utilizzeremo uno che si chiama @RowCount. Nella maggior parte dei casi viene commesso un errore logico durante la scrittura del codice:

//...
command = DataFactory.GetProcedure(SearchProcedure);
command.Parameters.Add("@RowCount", SqlDbType.Int, 4).Direction = ParameterDirection.Output;
DataFactory.OpenConnection();		

reader = command.ExecuteReader();
// L'errore che commettiamo è qui:
pi.RowCount = (int)command.Parameters["@RowCount"].Value;

//...

Cosa succede? In questa porzione di codice vengono effettuate diverse operazioni:

• Viene inizializzato un comando
• Viene specificato un parametro in output che dovrà essere valorizzato nella stored procedure e restituito nella variabile di output
• Viene eseguita la query ed il risultato viene caricato in un SqlDataReader
• Viene prelevato il valore del parametro in output

Il problema si può verificare a partire dalla descrizione specificata in grassetto (nell’elenco) e si verifica proprio se eseguiamo il passo successivo.

In pratica non è possibile prelevare dei valori in output ad una stored procedure, tramite un SqlCommand, se alla connessione è associato un SqlDataReader aperto, fin quando non invochiamo il metodo Close() dell’oggetto reader, le variabili in output della SqlParameterCollection non vengono caricate, motivo per cui la porzione di codice sopra mostrata genera un eccezione in riferimento al fatto che il .Value è NULL. Se invece proviamo a modificare il codice inserendo un reader.Close() prima di prelevare i valori in output, il tutto funziona correttamente!

Per informazioni più dettagliate sull’argomento potete cliccare qui. Nello specifico la frase che più ci interessa (e che mi salva la vita ogni volta) è questa:

If your Command contains output parameters or return values, they will not be available until the DataReader is closed.

La differenza principale è che il valore di una proprietà è direttamente leggibile da un membro privato della classe o dalla classe stessa che la implementa, mentre il valore di una DependencyProperty viene risolto dinamicamente quando viene chiamato il metodo GetValue che viene ereditato da DependencyObject.

Quando il valore di una DependencyProperty viene settato, questo non viene memorizzato subito nell’oggetto contenitore ma in un dizionario di chiavi e valori che viene fornito da DependencyObject. La chiave corrisponde proprio al nome della proprietà ed il valore corrisponde al contenuto di questa.

I vantaggi che si possono ottenere utilizzando le dependency properties sono molti:

• Si eliminano Memory Footprint: se pensiamo che nella maggior parte dei casi il valore delle proprietà dei nostri oggetti rimane invariato per tutta l’esecuzione del programma aumentando in ogni caso l’utilizzo di memoria per l’applicazione, le dependency properties risolvono questo problema memorizzando solo le proprietà che vengono modificate. I valori di default vengono memorizzati una sola volta all’interno delle proprietà di dipendenza.
• Ereditarietà dei valori: quando si accede ad una proprietà, questa viene letta utilizzando una strategia di risoluzione secondo la quale se si verifica la situazione in cui nessun valore è impostato, la proprietà di dipendenza continua a cercare seguendo uno schema ad albero fin quando non trova un valore. Se per esempio in un controllo imposto la proprietà FontWeight, questa viene impostata anche per tutti gli elementi figlio eccetto quelli per cui non predisponiamo personalmente un comportamento diverso.
• Meccanismo di notifica: le dependency properties hanno un meccanismo automatico di notifica. In pratica è possibile impostare una dependency property in modo tale da poter ricevere una notifica nel caso in cui questa cambi.

Strategie di risoluzione dei valori

Ogni volta che accediamo ad una dependency property, internamente si scatena un meccanismo automatico in grado di risolvere il valore della proprietà, questo meccanismo segue uno schema logico secondo cui prova a cercare un certo tipo di valore fino ad arrivare ad un Default, lo schema di seguito chiarisce meglio il concetto:

Ogni controllo registra un set di DependencyProperty nella classe statica. Ognuna di queste consiste in una chiave che deve essere univoca per tipo oltre ad una serie di metadati che contengono le chiamate di callbacks ed i valori di Default. Tutti i tipi che vogliono utilizzare le DependencyProperties devono derivare da DependencyObject. Questa classe base definisce un dizionario di chiavi – valore che contengono le proprietà della classe che eredita. Una chiave in ingresso è una chiave specificata con una DependencyProperty.

Quando viene effettuata una chiamata ad una DependencyProperty, .Net esegue dietro le quinte una chiamata GetValue(DependencyProperty) per accedere al valore. Questo metodo utilizza una strategia di risoluzione che segue a grandi linee lo schema esposto sopra. Se un valore locale è presente, viene letto questo direttamente dal dizionario, al contrario, se non è impostato, viene effettuata una ricerca ad albero in tutte i controlli ereditati. Se nessun valore viene trovato, viene impostato il valore di Default descritto nei metadati.

Questo schema può chiarire meglio l’idea di ciò che accade:

Come si crea una DependencyProperty

Per creare una DependencyProperty è necessario aggiungere un campo statico di tipo DependencyProperty sul tipo di riferimento e successivamente chiamare DependencyProperty.Register() per creare un istanza dell’oggetto. Il nome della DependencyProperty deve avere come suffisso Property, è una convenzione di WPF. Per renderlo accessibile come una normale proprietà .Net è necessario creare un Property Wrapper. Questo non fa altro che settare e prelevare internamente il valore della proprietà utilizzando rispettivamente GetValue() e SetValue() dal DependencyObject passando la DependencyProperty come chiave.

// Dependency Property
public static readonly DependencyProperty CurrentTimeProperty =
     DependencyProperty.Register( "CurrentTime", typeof(DateTime),
     typeof(MyClockControl), new FrameworkPropertyMetadata(DateTime.Now));

// .NET Property wrapper
public DateTime CurrentTime
{
    get { return (DateTime)GetValue(CurrentTimeProperty); }
    set { SetValue(CurrentTimeProperty, value); }
}

Ogni DependencyProperty permette di impostare un evento di callback per notifiche di cambiamento, validazione etc. Queste chiamate vengono registrate come viene mostrato di seguito:

new FrameworkPropertyMetadata( DateTime.Now,
                       OnCurrentTimePropertyChanged,
                       OnCoerceCurrentTimeProperty ),
                       OnValidateCurrentTimeProperty );

Nella chiamata di callback si verifica se il valore è valido, se questa chiamata restituisce false viene sollevata un eccezione.

private static bool OnValidateTimeProperty(object data)
{
    return data is DateTime;
}

Chiamate di Callback

La chiamata di callback è un metodo statico che viene chiamato ogni qual volta il valore della proprietà cambia. Il nuovo valore viene passato tramite EventArgs, l’oggetto di cui questo valore è cambiato, viene passato come source:

private static void OnCurrentTimePropertyChanged(DependencyObject source,
        DependencyPropertyChangedEventArgs e)
{
    MyClockControl control = source as MyClockControl;
    DateTime time = (DateTime)e.NewValue;
    // Put some update logic here...
}

Readonly DependencyProperties

Alcune dependency property in WPF sono in sola lettura. Sono utilizzate spesso per riportare lo stato di un controllo come IsMouseOver, si può dedurre che in questi casi non ha alcun senso impostare un setter.

Ma la domanda principale, che molte volte, durante lo studio di questo argomento, mi sono posto è: perché utilizzare dependency properties al posto delle normali proprietà che è possibile utilizzare con .Net?

La prima importante ragione è che con .Net non è possibile impostare dei trigger sulle proprietà.

Create una proprietà in sola lettura è molto simile a creare una proprietà in .Net. All’interno della chiamata DepedencyProperty.Register() si può chiamare DependencyProperty.RegisterReadonly(). Viene restituita una DependencyPropertyKey, questa dovrebbe essere memorizzata in una variabile privata o protetta (Statica) ed in sola lettura. La chiave ti permette di avere accesso al valore e settarlo come normalmente si farebbe con una Property. La seconda cosa da fare è impostare una DependencyProperty pubblica assegnata a DependencyPropertyKey.DependencyProperty. Questa proprietà è in sola lettura e può essere richiamata dall’esterno.

// Register the private key to set the value
private static readonly DependencyPropertyKey IsMouseOverPropertyKey =
      DependencyProperty.RegisterReadOnly("IsMouseOver",
      typeof(bool), typeof(MyClass),
      new FrameworkPropertyMetadata(false));

// Register the public property to get the value
public static readonly DependencyProperty IsMouseoverProperty =
      IsMouseOverPropertyKey.DependencyProperty;    

// .NET Property wrapper
public int IsMouseOver
{
   get { return (bool)GetValue(IsMouseoverProperty); }
   private set { SetValue(IsMouseOverPropertyKey, value); }
}

Per concludere, l’argomento può sembrare di difficile comprensione nei primi momenti (tristissimi momenti) ma subito dopo, se si ha modo di poter vedere in azione queste funzionalità la comprensione risulta molto più facile. Spero che questa guida possa essere di aiuto a qualcuno che come me, alle prime esperienze con nuove tecnologie, si trovi spiazzato e disorientato!

Per qualsiasi domanda ci sono i commenti!

Un anno fatto di tanti momenti in cui il nervosismo prende il sopravvento, in cui tanta gente, maleducata e scortese pensa di potersi prendere gioco di te, un anno in cui hai la possibilità di capire che il cliente ha ragione quando paga, non se hai la fortuna di poter scegliere con chi avere a che fare e di selezionare i tuoi lavori. Allo stesso tempo ho avuto modo di lavorare con persone che ti apprezzano e valorizzano, clienti che sono in grado di trasmetterti quella soddisfazione che solo tu, dopo tutto il lavoro che hai fatto, sei in grado di poter percepire.

Un anno fatto di sorprese, una ragazza che ogni giorno continua a sopportarmi nonostante le mie passioni e la mia ostinazione nel volerle sempre parlare dei miei progetti, delle mie ambizioni e dei miei piani futuri, mai stanca del mio continuo parlare; dei genitori ed una sorella fantastica sempre vicini ed in prima linea per questo ragazzo che ha sempre la testa da un’altra parte!

Un anno fatto di idee e progetti, scaturiti dalla voglia di spingersi sempre più verso qualcosa di grande e soddisfacente. Un periodo in cui ho avuto la fortuna di poter collaborare con persone straordinarie accomunati da un obiettivo. Forza di volontà, ottimismo e voglia di conoscenza sono alla base di questo 2010.

Un anno all’insegna della “non-completezza”, quando hai tanto in testa e poco tempo per fare tutto, in alcuni momenti hai la sensazione di non farcela, poi, grazie sempre a quelle persone che ti sostengono e ti sono vicine, una spinta ad essere più forte ed attivo di prima arriva ed è proprio in quei momenti che ritrovi lo spirto giusto per rimetterti a fare quello che hai lasciato a metà.

Un amico, tempo fa, mi ha “regalato” un consiglio, un suo modo di fare che si è rivelato per me grandioso: un foglio, una penna e tanta attenzione nel catturare ogni idea che la testa tira fuori, annotarle e tenerle sempre d’occhio, capire quando è il momento di di mettersi all’opera. Nella mia stanza c’è un foglio, appeso al muro, cosi visibile che nemmeno mia madre può fare a meno di notarlo, tanti punti da completare, tante cose da fare, tante X sopra ad ogni frase per indicare ciò che sono riuscito a fare e ciò che ancora è in attesa di essere fatto. Mi basta guardarlo per sentirmi soddisfatto di quello che sono oggi pensando che domani quella lista sarà ancora più lunga e con più X ad indicare ogni mio nuovo traguardo.

Da quando ho imparato a camminare mi piace correre. (Friedrich Nietzsche)

Viene definito il Robin Hood dei nostri tempi, ruba ai ricchi per dare ai poveri, una volta erano cibo, vestiti e monete d’oro, ora la ricchezza è informazione, libera e trasparente. Alle sue spalle un curriculum davvero notevole che ha portato la sua società no-profit Wikileaks ad essere premiata in diverse manifestazioni internazionali. Oggi questo uomo è vittima di un complotto internazionale in cui gli USA fanno da padroni, catturato su “appuntamento”, è bene chiarirlo, Julian Assange non è stato colto di sorpresa da nessuno, si è costituito alle forze dell’ordine per essere processato, si trova ora in carcere ed aspetta di essere processato per un reato che non ha commesso, se poi avere rapporti sessuali consenzienti è paragonabile a violenza allora siamo su un altro pianeta (infatti).

Di fatto, attualmente, quella che viene definita la “Infowar” è una guerra in cui le truppe di Wikileaks hanno la meglio. Se una volta l’arresto di Assange sarebbe bastato per porre fine alla pubblicazione di queste informazioni, ora non è più cosi. La sua assicurazione circola su internet da ormai molto tempo, un file di diversi Gigabyte crittografato contenente l’archivio completo delle informazioni (anche quelle non ancora pubblicate).

Se dovesse accadermi qualcosa verrà pubblicata la chiave con cui poter aprire l’archivio completo

In parallelo un gruppo di hacker informatici hanno avviata quella che viene chiamata “Operation Payback”, molte sono le compagnie online che hanno voltato le spalle a Wikileaks senza fornire una giusta causa, siti web per il pagamento online e servizi di web hosting che all’improvviso hanno sospeso i servizi di pubblicazione e pagamento per Assange e la sua associazione.

La situazione che si prospetta è da film, una potenza mondiale che vuole mettere fine ad un buco nella propria sicurezza, alla fuori uscita di informazioni cosi riservate da poter diventare un vero problema se pubblicate. Questo momento storico non è altro che il resoconto di un lungo periodo in cui Governi di tutto il mondo si sono fatti autori di azioni imperdonabili, gesti privi di umanità, è un momento molto cupo per la storia dell’uomo, uno evento che mette in evidenza quanto l’avidità ed il potere siano oggi ambiti tanto quanto lo erano in passato.

Tempo fa’ Opera ha chiesto che Microsoft inserisse all’interno del proprio sistema operativo la famosa “Ballot Screen” per dare all’utente la possibilità di scegliere quale browser installare sul proprio sistema operativo. Tralasciando le mie idee a riguardo (non sono per niente con la richiesta di Opera), il risultato finale?

Opera e alleati (Firefox, Chrome etc.) entrati in campo in un secondo momento attirati dalla gustosa soluzione di poter distribuire il proprio Browser su larga scala tramite MS, hanno ottenuto miglioramenti quantificabili in piccolissime percentuali di utenti in più che hanno scelto tramite questa finestra quale browser utilizzare, percentuali europee che se paragonate al resto del mondo rendono la situazione praticamente impercettibile.

Un interessante articolo a riguardo lo trovate qui (un po’ vecchio, letto tempo fa’, ma rende bene l’idea della situazione venutasi a creare).

E’ interessante notare come, nonostante questo completo fiasco, altri Competitor in altri campi abbiano deciso di provare a sfruttare la stessa mossa. Trend Micro e Panda hanno fatto richiesta per una medesima finestra per la scelta dell’antivirus da utilizzare sul proprio computer definendo Windows Security Essentials un ostacolo ed una mossa scorretta da parte di Microsoft che da parte sua definisce il suo prodotto come GRATUITO ed una soluzione di base da avere sul PC.

E’ preferibile avere Security Essentials rispetto a non avere alcuna protezione (MS)

Trend Micro e Panda ritengono le modalità di distribuzione di questo software non valide, in quanto MSE viene distribuito tramite Windows Update, però è importante ricordare che MS non obbliga ad installare il software.

Personalmente penso che questa situazioni si vengono a creare in un contesto in cui la stessa MS viene vista come Monopolista di qualsiasi mercato in cui i prodotti sono strettamente legati al sistema operativo. L’utente è libero di scegliere, MSE è un buon prodotto, gratuito, quindi ha le sue limitazione e non può essere paragonato ad una soluzione a pagamento ma la sua distribuzione viene proposta in un ottica di “protezione per gli utenti che acquistano un sistema operativo MS”. Ovviamente ritengo questa mossa da parte delle due sopracitate compagnia scorretta, favorita soprattutto dagli episodi passati che quasi incentivano azioni di ostruzionismo! In definitiva spero che almeno per questa volta, se l’antitrust dovesse essere chiamato a decidere, faccia scelte diverse rispetto al passato.