Arriva troppo tardi visto che ormai ci sono più programmatori WP7 che telefoni in giro :D

Ma per i ritartadari come me un bel libro gratis http://bit.ly/programwin7phone 

Ho speso qualche ora di lavoro per individuare un problema un po subdolo.

In una chiamata ad un WebService un parametro stringa contiene il carattere ‘\’, tutto bene se il client SilverLight proviene dallo stesso dominio del web service.

Il problema nasce quando si è in uno scenario cross domain in cui il carattere ‘\’ porta all’odiosa eccezione:

InnerException = {System.Exception ---> System.Exception: Exception from HRESULT: 0x80000012
   at System.Net.BrowserHttpWebRequest.InternalEndGetResponse(IAsyncResult asyncResult)
   at System.Net.BrowserHttpWebRequest.<>c__DisplayClass5.<EndGetResponse>b__4(Object send…

La soluzione è semplice, usare

HttpUtility.UrlEncode(theUrlWithWrongChar));

una buona abitudine da seguire sempre!

Supponiamo di voler variare, il colore di fondo delle colonne, per meglio evidenziare l’andamento di un grafico, (cose che si inventano quelli del marketing per capirsi, nulla che abbia un senso nella teoria dei grafici).

Essendo una richiesta pittoresca in tutti i sensi, ci si deve affidare ai template del Chart per sperare di ottenere qualcosa di interessante e con poco sforzo.

Prima di tutto andiamo a creare un Model che ci faciliti la vita a livello di View

   1: public class ColumnDataPoint : INotifyPropertyChanged

   2: {

   3:     private Brush _background;

   4:  

   5:     public Brush Background

   6:     {

   7:         get { return _background; }

   8:         set

   9:         {

  10:             _background = value;

  11:             OnPropertyChanged("Background");

  12:         }

  13:     }

  14:  

  15:     private string _label;

  16:  

  17:     public string Label

  18:     {

  19:         get { return _label; }

  20:         set

  21:         {

  22:             _label = value;

  23:             OnPropertyChanged("Label");

  24:         }

  25:     }

  26:  

  27:     private decimal _amount;

  28:  

  29:     public decimal Amount

  30:     {

  31:         get { return _amount; }

  32:         set

  33:         {

  34:             _amount = value;

  35:             OnPropertyChanged("Amount");

  36:         }

  37:     }

  38:  

  39:     #region INotifyPropertyChanged Members

  40:  

  41:     public event PropertyChangedEventHandler PropertyChanged;

  42:  

  43:     private void OnPropertyChanged(string name)

  44:     {

  45:         if (PropertyChanged != null)

  46:         {

  47:             PropertyChanged(this, new PropertyChangedEventArgs(name));

  48:         }

  49:     }

  50:  

  51:     #endregion

  52: }

la classe ColumnDataPoint contiene una proprietà Background che restituisce il Brush da usare per colorare la colonna, una proprietà Amount che rappresenta l’altezza della colonna ovvero la y, e una proprietà Label per visualizzare qualcosa di leggibile a livello di asse X. Se si vuole evitare che il model debba conoscere il tipo Brush sarà sufficiente usare un Converter, complicando leggermente la sintassi dello xaml che seguirà.

Andiamo ad inserire un Chart con una ColumnSeries e valorizziamo alcune sue proprietà in binding:

   1: <chartingToolkit:Chart Title="Chart Title">

   2:     <chartingToolkit:ColumnSeries ItemsSource="{Binding Points, Mode=OneWay}" 

   3:             IndependentValueBinding="{Binding Mode=OneWay}" 

   4:             DependentValueBinding="{Binding Amount, Mode=OneWay}" 

   5:             DataPointStyle="{StaticResource ColumnColoredDataPointStyle}">

   6:     </chartingToolkit:ColumnSeries>

   7: </chartingToolkit:Chart>

ItemSource è semplicemente in bind con la proprietà Points del VM che altro non è una List<ColumnDataPoint>

IndipendentValueBinding è in bind senza esplicitare il Path, di fatto equivale a legare i punti dell’asse X agli elementi di Points ovvero a istanze di ColumnDataPoint.

DependentValueBinding è legato alla proprietà Amount di ColumnDataPoint.

A questo punto possiamo focalizzarci sul template del DataPoint, per fare questo la via più comoda è farsi generare da Blend una copia del template che possiamo chiamare ColumnColoredDataPointStyle.

   1: <Style x:Key="ColumnColoredDataPointStyle" TargetType="chartingToolkit:ColumnDataPoint">

   2:     <Setter Property="Background" Value="Orange"/>

   3:     <Setter Property="BorderBrush" Value="Black"/>

   4:     <Setter Property="BorderThickness" Value="1"/>

   5:     <Setter Property="IsTabStop" Value="False"/>

   6:     <Setter Property="Template">

   7:         <Setter.Value>

   8:             <ControlTemplate TargetType="chartingToolkit:ColumnDataPoint">

   9:                 <Border x:Name="Root" Opacity="0" BorderBrush="{TemplateBinding BorderBrush}" BorderThickness="{TemplateBinding BorderThickness}">

  10:                     <VisualStateManager.VisualStateGroups>

  11:                         <VisualStateGroup x:Name="CommonStates">

  12:                             <VisualStateGroup.Transitions>

  13:                                 <VisualTransition GeneratedDuration="0:0:0.1"/>

  14:                             </VisualStateGroup.Transitions>

  15:                             <VisualState x:Name="Normal"/>

  16:                             <VisualState x:Name="MouseOver">

  17:                                 <Storyboard>

  18:                                     <DoubleAnimation Duration="0" Storyboard.TargetName="MouseOverHighlight" Storyboard.TargetProperty="Opacity" To="0.6"/>

  19:                                 </Storyboard>

  20:                             </VisualState>

  21:                         </VisualStateGroup>

  22:                         <VisualStateGroup x:Name="SelectionStates">

  23:                             <VisualStateGroup.Transitions>

  24:                                 <VisualTransition GeneratedDuration="0:0:0.1"/>

  25:                             </VisualStateGroup.Transitions>

  26:                             <VisualState x:Name="Unselected"/>

  27:                             <VisualState x:Name="Selected">

  28:                                 <Storyboard>

  29:                                     <DoubleAnimation Duration="0" Storyboard.TargetName="SelectionHighlight" Storyboard.TargetProperty="Opacity" To="0.6"/>

  30:                                 </Storyboard>

  31:                             </VisualState>

  32:                         </VisualStateGroup>

  33:                         <VisualStateGroup x:Name="RevealStates">

  34:                             <VisualStateGroup.Transitions>

  35:                                 <VisualTransition GeneratedDuration="0:0:0.5"/>

  36:                             </VisualStateGroup.Transitions>

  37:                             <VisualState x:Name="Shown">

  38:                                 <Storyboard>

  39:                                     <DoubleAnimation Duration="0" Storyboard.TargetName="Root" Storyboard.TargetProperty="Opacity" To="1"/>

  40:                                 </Storyboard>

  41:                             </VisualState>

  42:                             <VisualState x:Name="Hidden">

  43:                                 <Storyboard>

  44:                                     <DoubleAnimation Duration="0" Storyboard.TargetName="Root" Storyboard.TargetProperty="Opacity" To="0"/>

  45:                                 </Storyboard>

  46:                             </VisualState>

  47:                         </VisualStateGroup>

  48:                     </VisualStateManager.VisualStateGroups>

  49:                     <ToolTipService.ToolTip>

  50:                         <ContentControl Content="{TemplateBinding FormattedDependentValue}"/>

  51:                     </ToolTipService.ToolTip>

  52:                     <Grid Background="{TemplateBinding Background}">

  53:                         <Rectangle>

  54:                             <Rectangle.Fill>

  55:                                 <LinearGradientBrush>

  56:                                     <GradientStop Color="#77ffffff" Offset="0"/>

  57:                                     <GradientStop Color="#00ffffff" Offset="1"/>

  58:                                 </LinearGradientBrush>

  59:                             </Rectangle.Fill>

  60:                         </Rectangle>

  61:                         <Border BorderBrush="#ccffffff" BorderThickness="1">

  62:                             <Border BorderBrush="#77ffffff" BorderThickness="1"/>

  63:                         </Border>

  64:                         <Rectangle x:Name="SelectionHighlight" Fill="Red" Opacity="0"/>

  65:                         <Rectangle x:Name="MouseOverHighlight" Fill="White" Opacity="0"/>

  66:                     </Grid>

  67:                 </Border>

  68:             </ControlTemplate>

  69:         </Setter.Value>

  70:     </Setter>

  71: </Style>

Per il nostro scopo è sufficiente eliminare la riga 2 dal template, e nella riga 52 modificare il binding della proprietà Background dal TemplateBinding al binding classico, legandola alla proprietà Background della classe ColumnDataPoint:

   1: <Grid Background="{Binding Background, Mode=OneWay}">

A questo punto abbiamo legato il colore di ogni colonna all’informazione contenuta nel nostro model.

Ultimo tocco necessario e modificare lo style delle label dell’asse x, e legare anche questa alla proprietà Label del model, modificando la seguente riga 6:

   1: <Style x:Key="XAxisLabelStyle" TargetType="chartingToolkit:AxisLabel">

   2:     <Setter Property="IsTabStop" Value="False"/>

   3:     <Setter Property="Template">

   4:         <Setter.Value>

   5:             <ControlTemplate TargetType="chartingToolkit:AxisLabel">

   6:                 <TextBlock Text="{Binding Label, Mode=OneWay}"/>

   7:             </ControlTemplate>

   8:         </Setter.Value>

   9:     </Setter>

  10: </Style>

la versione finale del chart è quindi la seguente:

   1: <chartingToolkit:Chart Title="Chart Title" LegendStyle="{StaticResource LegendStyle1}" >

   2:     <chartingToolkit:ColumnSeries ItemsSource="{Binding Points, Mode=OneWay}" IndependentValueBinding="{Binding Mode=OneWay}" DependentValueBinding="{Binding Amount, Mode=OneWay}" LegendItemStyle="{x:Null}" DataPointStyle="{StaticResource ColumnColoredDataPointStyle}">

   3:         <chartingToolkit:ColumnSeries.IndependentAxis>

   4:             <chartingToolkit:CategoryAxis Orientation="X" Location="Bottom" AxisLabelStyle="{StaticResource XAxisLabelStyle}" />

   5:         </chartingToolkit:ColumnSeries.IndependentAxis>

   6:     </chartingToolkit:ColumnSeries>

   7: </chartingToolkit:Chart>

L’allinemento del contenuto delle celle della DataGrid, può essere ottenuto andando a modificare il template della DataGridCell. Si può generare una copia utilizzando Blend.

conviene generarla nelle risorse del controllo e dargli un nome ad esempio DataGridCellBaseStyle

nello style generato ci sono due righe interessanti

   1: <Setter Property="HorizontalContentAlignment" Value="Stretch"/>

   2: ...

   3: ...

   4: <ContentPresenter HorizontalAlignment="{TemplateBinding HorizontalContentAlignment}" Margin="{TemplateBinding Padding}" VerticalAlignment="{TemplateBinding VerticalContentAlignment}" Content="{TemplateBinding Content}" ContentTemplate="{TemplateBinding ContentTemplate}"/>

dove si nota come viene assegnato l’allineamento del contenuto della cella della datagrid: il TemplateBinding assegna il valore Stretch all’HorizontalAlignament, sostituendo Stretch con ad esempio Right, nella prima riga si otterrebbe che tutte le celle della datagrid avrebbero un allinemaento a destra

Più interessante è riuscire ad assegnare un comportamento diverso ad ogni colonna, magari riutilizzando il resto delle impostazioni dello stile della cella.

Sfruttando la proprietà BasedOn dello Style andiamo a creare un nuovo stile tipo, dove andiamo ad assegnare solo la proprietà HorizontalContentAlignment

   1: <Style x:Key="DataGridCellAlignRightStyle" BasedOn="{StaticResource DataGridCellBaseStyle}" TargetType="data:DataGridCell">

   2:     <Setter Property="HorizontalContentAlignment" Value="Right"/>

   3: </Style>

adesso usando opportunamente i due stili a disposizione, possiamo mantenere un comportamento di default per l’intera datagrid e modificare il comportamento delle colonne che ci interessa allineare a destra

   1: <data:DataGrid VerticalAlignment="Top" CellStyle="{StaticResource DataGridCellBaseStyle}" ItemsSource="{Binding Movimenti, Mode=OneWay}" AutoGenerateColumns="False" >

   2:     <data:DataGrid.Columns>

   3:         <data:DataGridTextColumn CellStyle="{StaticResource DataGridCellAlignRightStyle}" Binding="{Binding ExecutionDate, Mode=OneWay}" Header="ExecutionDate" />

   4:         <data:DataGridTextColumn CellStyle="{StaticResource DataGridCellAlignRightStyle}" Binding="{Binding Amount, Mode=OneWay}" Header="Amount"/>

   5:         <data:DataGridTextColumn Binding="{Binding Description, Mode=OneWay}" Header="Description"/>

   6:     </data:DataGrid.Columns>

   7: </data:DataGrid>

infatti la colonna Description utilizza lo stile DataGridCellBaseStyle dichirato a livello di datagrid

Questo semplice converter

   1: public class DateConverter : IValueConverter

   2: {

   3:     public object Parameter { get; set; }

   4:  

   5:     #region IValueConverter Members

   6:  

   7:     public object Convert(object value, Type targetType, object parameter, System.Globalization.CultureInfo culture)

   8:     {

   9:         if (value == null)

  10:         {

  11:             return value;

  12:         }

  13:         DateTime dt = (DateTime)value;

  14:         if (parameter != null)

  15:         {

  16:             return dt.ToString(parameter as string);

  17:         }

  18:         return dt.ToString();

  19:     }

  20:     public object ConvertBack(object value, Type targetType, object parameter, System.Globalization.CultureInfo culture)

  21:     {

  22:         return value;

  23:     }

  24:     #endregion

  25: }

lo si può usare per foramattare le date in binding, ad esempio per visualizzare solo l’anno di una data

   1: <TextBlock Text="{Binding Data, Converter={StaticResource dateConverter}, ConverterParameter='yyyy', Mode=OneWay}" />

come MCT ci danno la possibilità di partecipare alla beta degli esami di certificazione, sino al 30 Aprile sono ancora disponibili dei posti per gli esami su Visual Studio 2010 e il Framewrok 4.0 in particolare:

… The following exams are a part of this beta offering.

Exam 71-511, TS: Windows Applications Development with Microsoft .NET Framework 4

Exam 71-515, TS: Web Applications Development with Microsoft .NET Framework 4

Exam 70-513: TS: Windows Communication Foundation Development with Microsoft .NET Framework 4

Exam 70-516: TS: Accessing Data with Microsoft .NET Framework 4

Exam 70-518: Pro: Designing and Developing Windows Applications Using Microsoft .NET Framework 4

Exam 70-519: Pro: Designing and Developing Web Applications Using Microsoft .NET Framework 4

se siete interessati mandatemi una mail e vi giro le istruzioni per iscriversi

Con il collega Daniele ci siamo trovati a ragionare su cosa era meglio utilizzare per implementare un web service che permetta l’accesso ai dati ad un client Silverlight, vagliate le diverse ipotesi con i loro pro e contro, RIA Services, ADO.NET Data Services o semplice Web Service ci sarebbe piaciuto una soluzione un po ibrida.

Il punto a cui si vuole arrivare è poter utilizzare le Data Annotations di validazione direttamente nelle classi del proxy generato dall’Add Service Reference (o slsvcutil.exe).

Prima di tutto creiamo un nuovo progetto Silverlight ad esempio Albums, e nel progetto web creiamo un semplice servizio di login LoginServices con un solo metodo:

   1: [ServiceContract(Namespace = "")]

   2: [AspNetCompatibilityRequirements(RequirementsMode = AspNetCompatibilityRequirementsMode.Allowed)]

   3: public class LoginService

   4: {

   5:     [OperationContract]

   6:     public bool CheckLogin(User user)

   7:     {

   8:         return true;

   9:     }

  10: }

Il punto che ci interessa è il parametro del metodo CheckLogin che è uno User così definito:

   1: public class User

   2: {

   3:     public String Login { get; set; }

   4:     public String Password { get; set; }

   5: }

a questo punto eseguiamo l’Add Service Reference nel progetto Silverlight e individuiamo la classe User auto generata

Aggiungiamo un nuovo progetto alla solution di tipo Silverlight Class Library col nome ServiceReference, aggiungiamo una classe Referece.cs e ci copiamo dentro la classe User. Il progetto Albums avrà un reference alla nuova class library, il tutto dovrebbe avere questo aspetto:

Adesso andiamo ad aggiornare il Service References del progetto Albums modificando leggeremte le impostazioni:

stiamo istruendo il proxy generator a non generare le classi che trova già implementate nella libreria ServiceReferences e in effetti il risultato finale è

un file Reference.cs (quello in alto) che verrà rigenerato ogni volta che aggiorniamo il web service e un file Reference.cs (quello in basso che contiene la sola classe User) che potremo modificare a nostro piacimento, ad esempio aggiungendo nella classe User le Data Annotations di validazione

   1: [System.Runtime.Serialization.DataMemberAttribute()]

   2: [Required (ErrorMessage = "Login is required")]

   3: public string Login

   4: {

   5:     get

   6:     {

   7:         return this.LoginField;

   8:     }

   9:     set

  10:     {

  11:         if ((object.ReferenceEquals(this.LoginField, value) != true))

  12:         {

  13:             this.LoginField = value;

  14:             this.RaisePropertyChanged("Login");

  15:         }

  16:     }

  17: }

  18:  

  19: [System.Runtime.Serialization.DataMemberAttribute()]

  20: [Required(ErrorMessage = "Password is required")]

  21: [StringLength(36, MinimumLength = 8, ErrorMessage = "Password must be between 8 and 36 characters")]

  22: public string Password

  23: {

  24:     get

  25:     {

  26:         return this.PasswordField;

  27:     }

  28:     set

  29:     {

  30:         if ((object.ReferenceEquals(this.PasswordField, value) != true))

  31:         {

  32:             this.PasswordField = value;

  33:             this.RaisePropertyChanged("Password");

  34:         }

  35:     }

  36: }

Il prossimo passo sarà quello di automatizzare anche la generazione della classe User tentando di mantenerla in linea con le mofiche del Web Service.

Il prossimo passo sarà nel prossimo post, spero a breve

il tool è qui C:\Program Files\Microsoft SDKs\Silverlight\v3.0\Tools

esempio di codice per l’aggiunta di un secondary contact nella creazione di una site collection di SharePoint

   1: internal void CreateSite(string serverUrl, string serverRelativeUrl, string title, string description, uint LCID, string templateName)

   2: {

   3:     SPSecurity.RunWithElevatedPrivileges(delegate()

   4:     {

   5:         using (SPSite siteCollectionOuter = new SPSite(serverUrl + serverRelativeUrl))

   6:         {

   7:             SPWebApplication webApp = siteCollectionOuter.WebApplication;

   8:             SPSiteCollection siteCollection = webApp.Sites;

   9:             SPSite site = siteCollection.Add(serverRelativeUrl, title, description, LCID, templateName, "DOMAIN\\\\Administrator", "Administrator", "Administrator@domain.it");

  10:  

  11:             //Add SecondaryContact to the SiteCollection

  12:             SPWeb web = site.OpenWeb();

  13:             web.AllUsers.Add("DOMAIN\\Admin", "Admin@domain.com", "Admin", null);

  14:             SPUser spUser = web.AllUsers["DOMAIN\\AmAdmin"];

  15:             site.SecondaryContact = spUser;

  16:         }

  17:     });

  18: }

5 anni fa sembrava che l’MFC sarebbe diventato un semplice ricordo, o un incubo che ti viene a trovare dopo tanti anni, tipo quelli che dopo anni dalla maturità ti svegli tutto sudato pensando di essere in ritardo all’esame, poi oggi leggo questa frase

For native C++ developers, MFC now supports using a touch-enabled interface. MFC will do much of the heavy lifting: it listens for touch-related messages from Windows and calls out to a number of virtual functions to handle them

e penso che si, era più bello l’MFC di SharePoint :D, ma poi leggo ancora e trovo quello non invidio a chi ancora si diletta col C++

To take advantage of some of these features (such as Jump Lists), you will only need to recompile to get the updated user experience

è tutto in quell’only …

tutte le novità qui

Interessante articolo per la creazione e gestione dei content database di SharePoint

riporto gli script dovesse mai spartire l’articolo

Creating a Content Database

CREATE DATABASE WSS_Content_MSSQLTIPS
ON PRIMARY
( NAME = MSSQLTIPS_01_data,
FILENAME =
    'F:\data\MSSQLTIPS_01_data.mdf',
SIZE = 20,
MAXSIZE = 40,
FILEGROWTH = 5 ),
( NAME = MSSQLTIPS_02_data,
FILENAME =
    'G:\data\MSSQLTIPS_02_data.ndf',
SIZE = 20,
MAXSIZE = 40,
FILEGROWTH = 5 )
LOG ON
( NAME = 'MSSQLTIPS_log',
FILENAME =
    'c:\data\MSSQLTIPS.ldf',
SIZE = 5MB,
MAXSIZE = 25MB,
FILEGROWTH = 5MB );
go

alter database WSS_Content_MSSQLTIPS
set single_user with rollback immediate
go

alter database WSS_Content_MSSQLTIPS
collate Latin1_General_CI_AS_KS_WS
go

alter database WSS_Content_MSSQLTIPS
set multi_user
go

Using the Content Database in a New Web Application

STSADM.EXE 
-o extendvs 
-url http://biwsssql2008:6666 
-donotcreatesite 
-exclusivelyusentlm 
-databaseserver biwsssql2008 
-databasename WSS_Content_MSSQLTIPS 
-apidtype configurableid 
-description MSSQLTIPS 
-apidname MSSQLTIPS 
-apidlogin biwsssql2008\spcontentpool 
-apidpwd pass@word1

Moving Site Collections Between Content Databases

STSADM.EXE -o enumsites -url http://biwsssql2008:6666 > sites.xml

 

STSADM.EXE
-o mergecontentdbs
-url http://biwsssql2008:6666
-sourcedatabase <databasename>
-destinationdatabase <databasename>
-operation 3
-filename sites.xml

E’ uso comune legare la proprietà Visibility di un controllo ad una qualche proprietà di tipo Boolean dei dati, un esempio ben fatto è qui

Ovviamente non è l’unico modo per farlo, e di solito creo una property di tipo Visibility

public System.Windows.Visibility HasPublic { get; set; }

che può essere direttamente collegata, in questo esepmio, ad una CheckBox

<CheckBox IsChecked="{Binding Public, Mode=TwoWay}" Visibility="{Binding HasPublic}" />

tutto questo è molto semplice ed elegante se si è fatto un buon MVVM, e la proprietà HasPublic dove va ? ;-)

sintassi di update CAML

XElement updateFields = new XElement("Batch", new XAttribute("OnError", "Continue"),
                            new XElement("Method", new XAttribute("ID", "1"), new XAttribute ("Cmd", "Update"),
                                new XElement("Field", new XAttribute("Name", "ID"), item.Id),
                                new XElement("Field", new XAttribute("Name", "Tipologia"), item.Tipologia)));

Expression Blend usa il namespace d per assegnare comportamenti a design time, ad esempio in uno UserControl SilverLight:

<UserControl ...
    xmlns:vm="clr-namespace:DocumentViewer.ViewModel"
xmlns:d="http://schemas.microsoft.com/expression/blend/2008"
    d:DesignWidth="640" d:DesignHeight="480">
<UserControl.Resources>
   <vm:DocumentVM x:Key="viewmodel" />
</UserControl.Resources>

possiamo sfruttare la proprietà d:DesignInstance insieme a d:DataContext per istruire Blend a creare una istanza della classe indicata:

<Grid x:Name="LayoutRoot" DataContext="{StaticResource viewmodel}" d:DataContext="{d:DesignInstance vm:DocumentVMMock, IsDesignTimeCreatable=True}">

l’aspetto interessante è che a run time il data context è assegnato alla view model DocumentVM, mentre a design time è assegnata a DocumentVMMock, che dai nomi potete immaginare cosa fanno :D, senza necessita di if(IsDesignTime) nel code behind!

la figu da Expresion Blend:

l’esempio l’ho preso qui che parla di SilverLight 4.0, ma questo funziona anche col 3.0

Una volta in un bel libro su ASP.NET avevo letto (cito a memoria):

Lo sviluppatore è avvisato a configurare l’ambiente di sviluppo, ad utilizzare il sessionState su Sql Server, in modo che qualunque sia poi la configurazione in produzione, non avrà brutte sorprese

Appena la lessi pensai, ottimo consiglio, poi per la pigrizia di tutti i giorni non ho mai seguito il consiglio.

Oggi ho perso 3 ore per capire perchè non serializzasse una banalissima classe, peccato che la classe avesse un riferimento ad uno UserControl (di cui ovviamente non ricordavo più l’esistenza) e la serializzazione falliva.

Noto che in giro si fa largo uso della AddWithValue(), a me non è mai piaciuta sarà per il mio naturale snobbismo delle cose semplici. Dopo un po di anni che ci pensavo su ho deciso che era giunto il tempo di capirci meglio, mi sono armato di F11 e ho guardato un po dentro la libreria System.Data.

Quello che sospettavo mi viene confermato alla riga 1271 del file SqlParameter.cs, ovviamente esegue un _value.GetType() per poter preparare i parametri da passare a SQL Server. Se siete dei fissati dell’ottimizzazione tenetelo da buon conto.

Un altro aspetto è invece un po più subdolo, è legato ai tipi di dato che potrebbero essere rappresentati in SQL Server in differenti modi, ad esempio nel caso di String la SqlParameter imposta come tipo sql l’nvarchar, se sfortunatamente state lavorando con un DB che usa varchar, avverrà una seconda conversione da parte di SQL Server.

Se poi spaventa il dover impostare il valore in due righe di codice:

com.Parameters.Add("@parametro", SqlDbType.NVarChar);
com.Parameters["@parametro"].Value = _value;

E’ meglio usare questa scrittura molto più elegante:

com.Parameters.Add("@parametro", SqlDbType.NVarChar).Value= _value;

Venerdì scorso mi si è palesato, dietro il monitor, il cliente mentre ero su FaceBook, in tutta tranquillità, acquisita in anni di consulenza, ho finito quello che stavo facendo e poi ho dato retta al cliente.

Questa mattina, in riunione per pianificare delle nuove funzionalità all’applicazione web dello stesso cliente, si parlava di un mini sistema di messaggistica, allora me ne sono uscito con l’esempio di come una cosa simile è fatta in facebook a livello di user experience e dopo due minuti erano tutti convinti.

Son sicuro che se raccontavo la stessa cosa senza l’esempio di facebook eravamo ancora li a discutere e addio pranzo!!

Domanda: Venerdì scorso stavo perdendo tempo del cliente? o stavo lavorando per il cliente??

Risposta: mi fanno pena le aziende che chiudono gli accessi ad alcuni siti internet!!!

PS: Adesso mi devo inventare un esempio per giustificare il tempo perso a scrivere questo post :D

Ho ormai abbandonato Microsoft Virtual PC 2007 per Windows Virtual PC, dopo più di una settimana d’uso devo dire che le performance sono molto migliori sia per la macchina host che per la macchina guest, però un po di problemi li ho avuti.

Da Windows Virtual PC è sparito il tasto Host (che di solito era Alt Gr), e non commento!!!

Windows Virtual PC è molto più lento a salvare lo stato della macchina virtuale (Hibernate) e veramente lunghissimo a farla ripartire, ho dovuto puntare la sveglia mezz’ora prima.

Sul PC di casa con host Windows 7 e guest windows 7 non si riesce a installare le Integration Features, non ho avuto tempo di cercare se è un problema conosciuto o no.

Sulla macchina virtuale con Windows Server 2003 R2 Standard invece ho installato le Integration Feature (anche se ufficialmente non supportano Windows Server 2003) fa un po le bizze quando parte, a volte rimane nero per un po di tempo ma poi si lavora che è uno spetacolo.

Su suggerimento dell’amico Salvo ho poi provato la Sun Virtual Box, bhe fantastica, intanto su macchina con host a 32 bit supporta sistemi operativi guest a 64 bit, per cui son partito subito con l’installazione di W7 a 64 bit e VS 2010 a 64 bit, non l’ho usato tanto da potermi esprimere sulle prestazioni ma la prima impressione è più che positiva.