lunedì 24 maggio 2010

Serializzare oggetti in stile ViewState ASP.NET

Il ViewState è una delle componenti che caratterizzano le pagine ASP.NET rispetto al resto del panorama per lo sviluppo web.

Il view state è un modo per poter mantenere lo stato dei controlli (e non solo) di una pagina tra un post-back ed il successivo.

Se apriamo l’HTML generato da una pagina ASP.NET possiamo vedere che il ViewState viene salvato in un apposito campo nascosto (chiamato __VIEWSTATE):

Esempio del viewstate in una pagina ASP.NET Il valore del viewstate (ovvero la stringa con tutti i caratteri “strani”) è ottenuta comprimendo e serializzando tutte le proprietà dei controlli (per i quali è attivo il view state).

Possiamo utilizzare questo tipo di serializzazione anche nelle nostre applicazioni (non ASP.NET) utilizzando la classe ObjectStateFormatter (contenuta nel namespace System.Web.UI all’interno dell’assembly System.Web.dll).

Per serializzare un nostro oggetto in una stringa possiamo utilizzare la sintassi seguente:

   1: Dim customer = New Customer With {.FirstName = "Massimo", _



   2:                                   .LastName = "Bonanni"}



   3: Dim stateForm = New ObjectStateFormatter()



   4: Dim formattedCustomer = stateForm.Serialize(customer)




L’istanza della classe viene serializzata in una stringa stile ViewState come mostrato nella seguente figura:



image La nostra classe deve essere, ovviamente, serializzabile, ad esempio:





   1: <Serializable()> _



   2: Public Class Customer



   3:  



   4:     Private _FirstName As String



   5:  



   6:     Public Property FirstName() As String



   7:         Get



   8:             Return Me._FirstName



   9:         End Get



  10:         Set(ByVal value As String)



  11:             Me._FirstName = value



  12:         End Set



  13:     End Property



  14:  



  15:  



  16:     Private _LastName As String



  17:  



  18:     Public Property LastName() As String



  19:         Get



  20:             Return Me._LastName



  21:         End Get



  22:         Set(ByVal value As String)



  23:             Me._LastName = value



  24:         End Set



  25:     End Property



  26:  



  27:     Public Overrides Function ToString() As String



  28:         Return String.Format("{0} {1}", Me.FirstName, Me.LastName)



  29:     End Function



  30: End Class




Possiamo, ovviamente, eseguire anche la deserializzazione utilizzando il metodo Deserialize():





   1: Dim deserializeObj = CType(stateForm.Deserialize(formattedCustomer), Customer)




Questo tipo di serializzazione non è, ovviamente, standard come l’XML o il JSON ed ha senso usarla solo in quei casi in cui stiamo creando una serializzazione a nostro uso e consumo ma non abbiamo intenzione di fornire interoperabilità verso terze parti.



lunedì 17 maggio 2010

I-Memo finalmente un interessante prodotto tutto italiano

Mi hanno fatto conoscere un prodotto creato e realizzato da una giovane azienda lucana che permette di memorizzare username e password proteggendole con l’impronta digitale.

Il prodotto si chiama I-Memo e maggiori info sono disponibili sul sito http://www.menstecnica.com/index.html.

Una volta tanto l’ingegno italiano ha prodotto un qualcosa che potrebbe essere utile.

Technorati Tag: ,

On-line la nuova community romana DomusDotNet

E’ finalmente on-line la nuova community romana (e laziale) sulle tecnologie basate sul framework .NET di Microsoft.

Logo DomusDotNet su fondo chiaro (800 x 183)

Il portale della community è raggiungibile all’indirizzo http://www.domusdotnet.org. Troverete articoli, tips & tricks, recensioni su tools e servizi, notizie e molto altro.

venerdì 14 maggio 2010

Nascondere proprietà e campi nella maschera di controllo del debug

In questo post vorrei segnalarvi l’attributo DebuggerBrowsable per nascondere proprietà e attributi di una nostra classe nella finestra di controllo del debug.

L’attributo DebuggerBrowsable può essere applicato ad una proprietà o ad un campo e permette di nascondere la proprietà o il campo nella finestra di debug.

Ad esempio, prendiamo la classe:

  1. Public Class Class1
  2.  
  3.     Public Property VisibleProperty As String
  4.  
  5.     <Diagnostics.DebuggerBrowsable(DebuggerBrowsableState.Never)>
  6.     Public Property InvisibleProperty As String
  7.  
  8. End Class

La proprietà InvisibleProperty, pur essendo pubblica, non sarà visualizzata nella finestra di debug:

clip_image001

martedì 11 maggio 2010

Evitare il debug all’interno di metodi o proprietà: DebuggerHiddenAttribute e DebuggerStepThroughAttribute

Gli attributi che analizzeremo in questo post servono per evitare che si possa eseguire debug all’interno di metodi o proprietà delle nostre classi. Appartengono entrambi al namespace System.Diagnostics.

DebuggerHiddenAttribute

L’attributo DebuggerHidden permette di “nascondere” un costruttore, un metodo o una proprietà. Decorando un membro dei precedenti con questo attributo facciamo si che quando si esegue il debug non si possa eseguire uno step-into all’interno del metodo o fermarsi in un breakpoint interno al metodo stesso.

Un esempio di utilizzo dell’attributo è il seguente:

  1. Public Class Class1
  2.  
  3.     Public Function NotHiddenMethod() As Boolean
  4.         Return True
  5.     End Function
  6.  
  7.     <Diagnostics.DebuggerHidden()> _
  8.     Public Function HiddenMethod() As Boolean
  9.         Return True
  10.     End Function
  11.  
  12. End Class

Di fatto, il metodo HiddenMethod non può essere debuggato né utilizzando lo step-into né inserendo un breakpoint all’interno (per la cronaca l’ambiente di sviluppo permette di inserire il breakpoint ma questo non è attivo).

DebuggerStepThroughAttribute

DebuggerStepThrough funziona in maniera analoga al precedente attributo ma si limita solo a non permettere l’esecuzione dello Step-Into nel metodo e non a disabilitare i breakpoint interni. In più rispetto al precedente attributo, questo può essere applicato anche a livello di classe o struttura in modo da inibire tutti i membri della classe o struttura stessa.

In realtà l’attributo funziona in due differenti modalità in base all’opzione “Enable Just My Code” impostata nelle proprietà di debug del progetto:

clip_image002

Se è abilitata l’opzione Just My Code, l’attributo si comporta esattamente come l’attributo precedente non permettendo neanche i breakpoint interni ai membri decorati.

Se non è abilitata l’opzione Just My Code, invece, il flusso di esecuzione in debug si fermerà su eventuali breakpoint interni ai membri pur non permettendo lo step-into.

venerdì 7 maggio 2010

Personalizzare il tooltip di debug di Visual Studio

Quando eseguiamo il debug di una applicazione utilizzando Visual Studio, nel momento in cui con il mouse passiamo al di sopra di una variabile, ci appare un tooltip che permette di analizzare il contenuto della variabile stessa.

L’attributo DebuggerDisplay ci permette di personalizzare come apparirà questo tooltip. Supponiamo di avere la classe Employee:

  1. Public Class Employee
  2.  
  3.     Public Property LastName As String
  4.  
  5.     Public Property FirstName As String
  6.  
  7. End Class

E di voler eseguire il debug di una semplice applicazione console:

clip_image001

Il tooltip che ci permette di vedere i valori assunti dalla variabile employee ci dice che la variabile è di tipo Employee e ci obbliga ad aprire l’albero delle proprietà per vedere il contenuto della stessa.

Un modo per ovviare a questo e visualizzare una stringa che indichi il contenuto della variabile è implementare l’override del metodo ToString(). Questo fatto ci obbliga, però, ad utilizzare un metodo che è, di solito, utilizzato per scopi applicativi (ad esempio per mostrare i dati in una listbox) per eseguire il debug. Non è detto che le informazioni che dobbiamo mostrare in debug siano le stesse da mostrare con il ToString(). Per risolvere questo problema ci viene in aiuto l’attributo DebuggerDisplayAttribute il cui scopo è definire come deve essere visualizzato il nostro oggetto quando viene aperto il tooltip di debug:

  1. <Diagnostics.DebuggerDisplay("Employee = {LastName} {FirstName}")>
  2. Public Class Employee
  3.  
  4.     Public Property LastName As String
  5.  
  6.     Public Property FirstName As String
  7.  
  8. End Class

In questo modo otteniamo:

clip_image002

L’attributo può essere applicato ad assembly, classi, strutture, campi, proprietà o delegate.

 

martedì 4 maggio 2010

Cambio sede per l'evento del 14 maggio a Roma

Se ancora non l’avete letto, vi linko il post di Alessandro Del Sole riguardo lo spostamento della sede dell’evento Community Tour che si terrà a Roma il 14 Maggio 2010:

Cambio sede per l'evento del 14 maggio a Roma

L’utilizzo della classe ConditionalAttribute per evitare l’esecuzione di metodi

L’attributo ConditionaAttribute (contenuto nel namespace System.Diagnostics, assembly mscorlib.dll) ci consente di includere (o escludere) metodi dal flusso di esecuzione in base alla presenza o meno di una costante di compilazione.

Ad esempio, supponiamo di avere la seguente applicazione console:

  1. Module Module1
  2.  
  3.     Sub Main()
  4.         Console.WriteLine("Console start")
  5.         WriteLog()
  6.  
  7.         Console.WriteLine("Console end")
  8.     End Sub
  9.  
  10.     <Diagnostics.Conditional("LOG")>
  11.     Private Sub WriteLog()
  12.         Console.WriteLine("WriteLog")
  13.     End Sub
  14.  
  15. End Module

Se non definiamo la costante di compilazione LOG, il codice che viene compilato è il seguente:

clip_image002[1]

Come si può osservare, il corpo del metodo decorato con l’attributo ConditionalAttribute è stato compilato ma non è stata inserita la chiamata allo stesso che si sarebbe dovuta trovare tra le due istruzioni Console.WriteLine del Main. Questo significa che, quando eseguiamo, ad esempio, il debug della nostra applicazione, vedremo il punto di esecuzione saltare la chiamata al metodo WriteLog().

Definiamo, ora, la costante di compilazione LOG e per fare questo apriamo la finestra delle proprietà dell’applicazione console:

clip_image004[1]

Se compiliamo dopo aver salvato i cambiamenti alle proprietà dell’applicazione, otteniamo:

clip_image006[1]

Il metodo, questa volta, viene effettivamente richiamato.

La costante di compilazione è definibile anche con la direttiva #Const nel seguente modo:

  1. #Const LOG = False

L’utilizzo dell’attributo ConditionalAttribute è una valida alternativa ai costrutti #If...#End If anche se non è applicabile a quei metodi che ritornano dei valori (function). In questo caso, per poter applicare l’attributo è necessario convertire la function in una sub e restituire il valore come argomento byref.