Bootstrap prototyping


Un interessante tool per disegnare velocemente prototipi e test veloci di siti in Bootstrap https://www.easel.io/demo

author: Davide Cuppone | posted @ mercoledì 7 agosto 2013 7.56

Un post in quattro parti per una SPA che non sia il solito Hello World


Costruito sul template HotTowel un buon esempio di utilizzo di Breeze e SignalR in una SPA

author: Davide Cuppone | posted @ martedì 21 maggio 2013 18.13 | Feedback (0)

Free e-book


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 

Technorati Tags: ,

author: Davide Cuppone | posted @ venerdì 12 novembre 2010 9.46 | Feedback (4)

Silverlight ed un’eccezione solo in cross domain


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!
 
Technorati Tags:

author: Davide Cuppone | posted @ lunedì 8 novembre 2010 23.54 | Feedback (2)

Modificare l’aspetto di una ColumnsSeries del Silverlight Toolkit Chart


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).

image

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>

 

author: Davide Cuppone | posted @ mercoledì 5 maggio 2010 10.17 | Feedback (0)

Allineamento delle celle di una DataGrid in Silverlight


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.

image

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

 

image

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

image

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

image

 

author: Davide Cuppone | posted @ venerdì 30 aprile 2010 13.28 | Feedback (0)

Format String in xaml con un converter (Silverlight)


 

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}" />

Technorati Tags:

Update : Precisazione dopo il commento, in Silverlight 4.0 o WPF conviene usare direttamente la StringFormat.

author: Davide Cuppone | posted @ lunedì 19 aprile 2010 16.31 | Feedback (2)

Visual Studio 2010 beta exams


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

author: Davide Cuppone | posted @ martedì 6 aprile 2010 17.53 | Feedback (2)

Inserire le Data Annotations nelle classi generate con Add Service Reference


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

start reference.cs

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:

Solution

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

How to Configure Service Reference Configure Service Reference

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

Splitted reference.cs

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

 

author: Davide Cuppone | posted @ venerdì 2 aprile 2010 11.34 | Feedback (1)

Generare service reference da riga di comando con SLsvcutil


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

 

Technorati Tags:

author: Davide Cuppone | posted @ giovedì 1 aprile 2010 17.34 | Feedback (0)

Aggiungere il Secondary Contact ad una site collection SharePoint


 

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: }

 

Technorati Tags: ,

author: Davide Cuppone | posted @ lunedì 8 marzo 2010 18.11 | Feedback (1)

Mai dare per spacciata un tecnologia


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

author: Davide Cuppone | posted @ venerdì 5 marzo 2010 12.58 | Feedback (0)

Content DataBase per SharePoint


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

 

Technorati Tags:

author: Davide Cuppone | posted @ giovedì 25 febbraio 2010 11.47

Binding della proprietà Visibility senza l’uso di un Converter


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 ? ;-)

 

Technorati Tags: ,,

author: Davide Cuppone | posted @ mercoledì 17 febbraio 2010 17.03 | Feedback (1)

XLINQ


 

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)));

author: Davide Cuppone | posted @ mercoledì 10 febbraio 2010 9.21

Silverlight MVVM e Preview Data a Design Time in Expression Blend


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:

 image

 

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

author: Davide Cuppone | posted @ martedì 9 febbraio 2010 15.48 | Feedback (3)

Uomo avvisato mezzo salvato


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.

author: Davide Cuppone | posted @ giovedì 10 dicembre 2009 16.25 | Feedback (1)

Parameters.AddWithValue() e Parameters.Add() cosa conviene usare?


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;

author: Davide Cuppone | posted @ martedì 24 novembre 2009 17.54 | Feedback (4)

Pensieri liberi


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

author: Davide Cuppone | posted @ martedì 3 novembre 2009 12.54 | Feedback (1)

Tempi virtuali


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.

author: Davide Cuppone | posted @ venerdì 30 ottobre 2009 14.45 | Feedback (6)