Latest Posts
Abbiamo quindi diversi Binding:
· Simple bind, è la semplice associazione tra oggetto e percorso
· Element Bind è il bind tra un elemento e l’altro , ad esempio tra uno slider e una label che visualizzerà il valore dello slider
Abbiamo poi diverse modalità di binding che determinano il comportamento:
- OneWay
- TwoWay
- OneTime OneWayToSource
Un’altra componente molto importante sui binding sono i converter:
http://www.winfxitalia.com/script/29/StringFormatConverter-Binding-WPF.aspx
http://blogs.msdn.com/bencon/archive/2006/05/10/594886.aspx
http://dotnetside.org/blogs/vito/archive/2007/07/03/ValueConverter-per-la-formattazione-in-WPF.aspx
Altri elementi molto importanti è l’implementazione e l’utilizzo dell’INotifyPropertyChanged che consente di notificare alla UI il cambio di valore delle property dell’oggetto in datacontext, e ObservableCollection.
http://www.visual-basic.it/articoli/adsWPF_DataBinding.htm
http://www.winfxitalia.com/script/25/Creare-Collezioni-Utilizzabili-Binding-WPF.aspx
Un mio collega mi ha segnalato questo interessante link ad un tool che semplifica la gestione, i caricamenti in parallelo e le dipendenze tra i vari js :
http://labjs.com
Sembra che finalmente i problemi di connessioni abbiano raggiunto una soluzione, dopo che l’anno scorso hanno cambiato il cavo mangiato dai topi, ieri il mio buon amico Marcello ed il suo collega della Telco hanno ricontrollato tutto il cavo dalla centralina a me, e sembra che la presa principale fosse difettosa.
Ora ho capito di essere sfortunato, perchè effettivamente avere i cavi rovinati, su una zona dove l’armadio è pieno ed infine avere anche la presa principale difettosa è un po una cosa da “malocchio”, :).
L’aspetto importante, è che bisogna sempre protestare con educazione. Evitando la tentazione di aggredire l’operatore, che non ha nessuna colpa, ogni volta che una grande azienda, sia essa la Telecom o chiunque altro, evitate la tentazione di dire “inutile protestare, tanto non serve a nulla”. Ve lo dico io… Serve. Oltre a telefonare al 187 numerose volte, ho scritto a vari ministeri, anche al ministero delle attività produttive, denunciando il fatto che senza connessione non lavoro e che ultimamente i problemi erano continui.
La mia lettera è stata protocollata, il ministero ha richiesto un controllo sul cavo, e finalmente la situazione sembra risolta. Inoltre ieri pomeriggio e stamattina mi hanno contattato dalla TElecom e Telco per sapere se è tutto ok, se il problema fosse risolto etc etc e mi hanno invitato a richiamare per ogni eventuale ulteriore problema.
La morale è che, se i problemi persistono, una sana protesta a 360° solitamente smuove qualche cosa.
alk.
Per chi fosse interessato a conoscere le novità presentate al mix2010, il 23 marzo verrà fatta una chat live per discutere di questo argomento. Qui trovate tutti i dettagli.
alk.
Su DotNetCenter è stata pubblicata una mia breve intervista rilasciata in occasione dell’immenente basta italia:
http://dotnetcenter.it/news/10/Intervista-a-Michele-Aponte-speaker-di-BASTA-Italia-2010.html
Mi è stato chiesto anche come è nata la nostra community e che obiettivi si pone… magari chi è curioso di sapere come è nata questa fantastica avventura vedrà soddisfatta la propria curiosità. Ne approfitto per ringraziare ancora una volta tutti gli iscritti e i miei 4 amici cofondatori:
Antonio Liccardi
Alessandro Forte
Carmine Alfano
Marco Savarese
Come direbbe un mio amico (Marcello): siete fottissimi (senza r)…
Michele
Guardando i numeri, diresti che il tuo team pratica realmente il principio K.I.S.S. o diresti che segue la legge di Parkinson ?
- .NET Framework 2.0 il nucleo é composto in tutto da soli 12 Assembly per piú di 12.000 classi (una media di 800 per progetto) e 2.800.000 istruzioni IL (190.000 per progetto)
Fonte: Analyzing the .NET Framework 2.0 with NDepend
- Google ha un singolo source code repository che é completamente accessibile a tutti i 10.000 sviluppatori. Sebbene tutti i sistemi vengono rilasciati indipendentemente l'uno dall'altro (con cicli di rilascio che variano da una settimana a un mese), tutto viene compilato dalla HEAD senza l'uso di binari precompilati, il repository accetta diverse migliaia di modifiche al giorno con picchi di 20+ modifiche per minuto.
Fonte: Mark Striebeck engineering manager a Google, al suo speech al XPDay London 2009 (guarda anche il report da questo post)
- Flickr riceve 40.000 nuove foto per secondo e ha ne archivia piú di 3 miliardi di foto al giorno, vengono eseguiti piú di 10 nuovi rilasci al giorno. Due fattori abilitanti per queste prestazioni tra i molti citati: un unico version control condiviso e no branching.
Fonte: Dev and Ops Cooperation at Flickr
E ora chiediti:
- In quanti Project/Assembly é scomposta la code-base?
- Da quanti code repository distinti (server o trunk) devi fare il get dei sorgenti per compilare la code-base?
- Quante Solution distinte devi compilare per compilare la code-base?
- Oltre al trunk su quanti altri branch sviluppa il team?
La legge di Parkinson applicata alla complessitá della code-base dice che la complessitá della code-base tende ad espandersi sino alla massima capacitá del team e della azienda di gestire la complessitá, invece di limitarsi alla complessitá minima richiesta dai problemi affrontati.
Dal Mix spuntano mirabolanti soprese ma per provarle?
La versione di prova non ha nemmeno la barra degli indirizzi e i menu di navigazione ma si puo’ usare tranquillamente per i propri test attraverso delle scorciatoie da tastiera oppure navigando sui menu del programma.
Ecco gli shorcuts disponibili:
Ctrl + O: Apre una pagina web
F5: Refresh
F10: Home
F12: Developer Toolbar
Alt + 5: Forza in modalità di rendering IE5
Alt + 7: Forza in modalità di rendering IE7
Alt + 8: Forza in modalità di rendering IE8
Alt + 9: Forza in modalità di rendering IE9
Alt + 0: Resetta al default
Ctrl +/-: zoom in e out
Alt + ?: Help
Ctrl + S: Salva la pagina web come…
Alt + /: Informazioni su…
Dai che si va ;)
S.
Riavviata la macchina…bisogna prendere una decisione…
Martedì 23 Marzo, dalle 15 alle 16, Microsoft Italia terrà una sessione di chat dedicata alla novità del Mix 2010 (Silverlight 4 RC, Windows Phone 7 Series, IE9 e HTML 5, jQuery, OData). Per partecipare, è sufficiente collegarsi a questo link il giorno dell’evento.
Per tutti quelli che amano lo Spettacolo lascio il link dei video.
Video Gallery e qui
Senza parole…
nuovo protocollo xml per lo scambio dati via internet.
http://www.odata.org
Da questo link potete accedere a tutte le risorse dell’SDK finalmente in RTM, utile per produrre diettamente dai vostri software Documenti in formato Open XML. Office automation adieu!
Windows 7 permette di creare cartelle denominate Good Mode in cui troveremo organizzati tutte le principali funzionalità di gestione del nostro sistemo operativo.
L’operazione è banale; la sintassi per creare queste cartelle sarà:
NOMECARTELLA.{codice del good mode}
per esempio
Windows 7 reti sicurezza tecniche avanzate.{ED7BA470-8E54-465E-825C-99712043E01C}
Ad operazione completata troveremo all’interno di questa cartella tutta una serie di funzionalità, organizzate per categorie, per la gestione di Windows 7.
Esistono altri parametri per creare cartelle simili aventi funzionalità specifiche,ad esempio:
{0142e4d0-fb7a-11dc-ba4a-000ffe7ab428} – (Dispositivi biometrici) {025A5937-A6BE-4686-A844-36FE4BEC8B6D} – (Impostazioni risparmio energia) {05d7b0f4-2121-4eff-bf6b-ed3f69b894d9} – (Impostazioni icone e notifiche nella barra delle applicazioni) {1206F5F1-0569-412C-8FEC-3204630DFB70} – (Credenziali per l’accesso automatico) {15eae92e-f17a-4431-9f28-805e482dafd4} – (Installa un programma dalla rete) {17cd9488-1228-4b2f-88ce-4298e93e0966} – (Impostazioni dei programmi predefiniti) {1D2680C9-0E2A-469d-B787-065558BC7D43} – (Assembly) {1FA9085F-25A2-489B-85D4-86326EEDCD87} – (Gestione reti wireless) {208D2C60-3AEA-1069-A2D7-08002B30309D} – (Rete) {20D04FE0-3AEA-1069-A2D8-08002B30309D} – (Esplora risorse, cartella “Computer”) {2227A280-3AEA-1069-A2DE-08002B30309D} – (Stampanti e dispositivi) {241D7C96-F8BF-4F85-B01F-E2B043341A4B} – (Connessione a desktop e stampanti in rete) {4026492F-2F69-46B8-B9BF-5654FC07E423} – (Windows Firewall) {78F3955E-3B90-4184-BD14-5397C15F1EFC} – (Prestazioni del computer)
Windows 7 reti sicurezza tecniche avanzate : tutto quello che devi sapere su Windows 7, ogni trucco e configurazioni avanzate. IL LIBRO SU WINDOWS 7
Se avete un monitor ad alta risoluzione 96 DPI o maggiore, se il vostro Pc ha installato una versione di Windows 7 o di Windows Server 2008 R2 e se riscontrate lentezza al boot di Windows; questa Fix risolverà i vostri problemi (… almeno si spera).
Per prima cosa per individuare, se il vostro Monitor ha una risoluzione in cui è necessario applicare questa FIX andiamo in Start\Pannello di controllo\Aspetto e personalizzazione\Schermo come mostra la seguente figura:
Se è selezionata l’opzione 125% o 150% o superiore il nostro Pc è nella cerchia di quelli che potrebbero ottenere benefici da questa patch.
Quindi non ci resta che scaricarla dal link:http://support.microsoft.com/kb/977419/en-us
ed installarla.
Ad installazione completata dovremo poter beneficiare di questa Fix
Windows 7 reti sicurezza tecniche avanzate : tutto quello che devi sapere su Windows 7.Il libro di 784 pagine è edito da FAG Milano e viene veduto anche online sul sito della casa editrice e nelle migliori librerie .
Alcune volte può capitare di dover associare delle informazioni agli export, per esempio specificare cosa ci offre una determinata implementazione di un contratto. Questo permette agli imports di sapere cosa offre un determinato componente/plugin e di utilizzare solo quelli che risolvono le nostre esigenze. MEF supporta due tipi di metadata: typed e non typed. Il post tratterà solo i metadata typed; per vedere un esempio di utilizzo dei non typed potete dare un’occhiata alla MEF Programming Guide.
Ok ora possiamo partire a vedere qualcosa di concreto!
Supponiamo di dover creare un plugin manager che ci permette di accedere ai plugins installati. Elenchiamo un paio di specifiche:
- I plugin implementano l’interfaccia IPlugin
- Un plugin può offrire funzionalità diverse, a seconda della funzionalità implementa una specifica interfaccia
- Il plugin manager deve implementare l’interfaccia IPluginManager
- Tramite il plugin manager possiamo ottenere uno o più plugins che offrono una determinata funzionalità
Iniziamo col definire l’interfaccia IPluginManager
public interface IPluginManager
{
event EventHandler PluginsChanged;
IEnumerable<Lazy<IPlugin, IPluginMetadata>> Plugins { get; set; }
T GetPlugin<T>() where T : class;
IEnumerable<T> GetPlugins<T>() where T : class;
}
Supponiamo di avere due interfacce che specificano due diverse funzionalità:
- IFilter: filtra una collezione di dati (chiamiamolo segnale)
- IFeature: da un segnale estrae una particolare caratteristica
public interface IFilter
{
IList<double> Filter(IList<double> values);
}
public interface IFeature
{
double Extract(IList<double> values);
}
Ora che abbiamo tutto il necessario per costruire il nostro sistema passiamo a giocare con i metadata. Come ho accennato all’inizio i metadata sono delle informazioni aggiuntive che associamo agli export. L’unica informazione di cui noi abbiamo bisogno è il tipo di funzionalità che espone il nostro plugin. Queste informazioni vengono “aggiunte” tramite l’attributo MetadataAttribute, ma visto che stiamo usando i metadata typed le nostre informazioni verranno associate ai vari export tramite l’attributo ExportPluginAttribute
[MetadataAttribute]
[AttributeUsage(AttributeTargets.Class, AllowMultiple = false)]
public class ExportPluginAttribute : ExportAttribute, IPluginMetadata
{
public ExportPluginAttribute()
: base(typeof(IPlugin))
{
}
public Type PluginType { get; set; }
}
Dal codice possiamo notare tre cose fondamentali dell’attributo ExportPluginAttribute
- E’ decorato con l’attributo MetadataAttribute che permette di segnalare al CompositionContainer (a dire il vero la classe che si occupa di recuperare le informazioni aggiuntive è un’altra) che contiene delle informazioni aggiuntive
- Deriva da ExportAttribute così nelle implementazioni di IPlugin evitiamo di specificare ogni volta che il contratto è IPlugin (lo specifichiamo richiamando il costruttore di ExportAttribute)
- Implementa l’interfaccia IPluginMetadata che contiene le informazioni aggiuntive (in questo caso solo il tipo del plugin, cioè il tipo di funzionalità: IFilter o IFeature)
public interface IPluginMetadata
{
Type PluginType { get; }
}
Finalmente possiamo passare alla parte più importante della nostra piccola applicazione, il Plugin Manager!
[Export(typeof(IPluginManager))]
public class PluginManager : IPluginManager
{
private IEnumerable<Lazy<IPlugin, IPluginMetadata>> plugins;
#region IPluginManager Members
public event EventHandler PluginsChanged;
[ImportMany(AllowRecomposition = true)]
public IEnumerable<Lazy<IPlugin, IPluginMetadata>> Plugins
{
get
{
return plugins;
}
set
{
if (plugins == value)
return;
plugins = value;
OnPluginsChanged();
}
}
public T GetPlugin<T>() where T : class
{
return GetPlugins<T>().FirstOrDefault();
}
public IEnumerable<T> GetPlugins<T>() where T : class
{
return (from p in this.Plugins
where p.Metadata.PluginType == typeof(T)
select p.Value).Cast<T>();
}
#endregion
protected virtual void OnPluginsChanged()
{
EventHandler pc = PluginsChanged;
if (pc != null)
PluginsChanged(this, EventArgs.Empty);
}
}
Le parti fondamentali di questo codice sono la proprietà Plugins ed il metodo GetPlugins<T>
La proprietà Plugins è già stata vista nel post precedente e l’unica cosa da notare è l’utilizzo della classe Lazy<T, TMetadata> in maniera tale da poter accedere alle informazioni aggiuntive tramite la proprietà Metadata.
Il compito del metodo GetPlugins<T> è molto semplice: recupera tutti i plugins che hanno la proprietà PluginType uguale al tipo di plugin che vogliamo :)
Continuiamo con il mettere insieme i cocci…
Il PluginManager verrà utilizzato dal ViewModel della MainWindow.xaml
[Export(typeof(MainViewModel))]
public class MainViewModel
{
private IPluginManager pluginManager;
[ImportingConstructor]
public MainViewModel(IPluginManager pluginManager)
{
this.pluginManager = pluginManager;
this.FilterPlugins = new ThreadSafeObservableCollection<IFilter>();
this.FeaturePlugins = new ThreadSafeObservableCollection<IFeature>();
this.pluginManager.PluginsChanged += new EventHandler(pluginManager_PluginsChanged);
this.LoadPlugins();
}
public ObservableCollection<IFilter> FilterPlugins { get; set; }
public ObservableCollection<IFeature> FeaturePlugins { get; set; }
private void pluginManager_PluginsChanged(object sender, EventArgs e)
{
LoadPlugins();
}
private void LoadPlugins()
{
this.FilterPlugins.Clear();
this.FeaturePlugins.Clear();
foreach (IFilter filter in pluginManager.GetPlugins<IFilter>())
this.FilterPlugins.Add(filter);
foreach (IFeature feature in pluginManager.GetPlugins<IFeature>())
this.FeaturePlugins.Add(feature);
}
}
Il PluginManager verrà passato al costruttore del MainViewModel grazie all’attributo ImportingConstructor e per caricare i plugins utilizziamo il metodo GetPlugins spiegato precedentemente.
Cosa da notare è l’utilizzo della classe ThreadSafeObservableCollection<T>, caduta proprio a “faggiuolo” (termine tecnico) se guardate la data dell’articolo, al posto della classica ObservableCollection<T> in quanto se utilizziamo quest’ultima otteniamo un exception dove il Message è
The composition produced a single composition error. The root cause is provided below. Review the CompositionException.Errors property for more detailed information.
1) This type of CollectionView does not support changes to its SourceCollection from a thread different from the Dispatcher thread.
Resulting in: An exception occurred while trying to set the value of property 'PluginManager.PluginManager.Plugins'.
Resulting in: Cannot activate part 'PluginManager.PluginManager'.
Element: PluginManager.PluginManager --> PluginManager.PluginManager --> AssemblyCatalog (Assembly="PluginManager, Version=1.0.0.0, Culture=neutral, PublicKeyToken=null")
Questo perchè il metodo base.Refresh() del DirectoryWatcherCatalog viene chiamato su un thread diverso da quello della UI.
Ora è restata solo la MainWindow, ed è proprio lei che si occupa di creare il CompositionContainer ed i Catalogs
public MainWindow()
{
CompositionContainer compositionContainer;
DirectoryWatcherCatalog directoryCatalog;
AggregateCatalog aggregateCatalog;
InitializeComponent();
if (string.IsNullOrEmpty(Settings.Default.PluginsDirectory))
{
Settings.Default.PluginsDirectory = Path.Combine(Directory.GetCurrentDirectory(), "Plugins");
if (!Directory.Exists(Settings.Default.PluginsDirectory))
Directory.CreateDirectory(Settings.Default.PluginsDirectory);
Settings.Default.Save();
}
directoryCatalog = new DirectoryWatcherCatalog(Settings.Default.PluginsDirectory);
aggregateCatalog = new AggregateCatalog(directoryCatalog, new AssemblyCatalog(Assembly.GetExecutingAssembly()));
compositionContainer = new CompositionContainer(aggregateCatalog);
compositionContainer.ComposeParts(this);
}
[Import(typeof(MainViewModel))]
public MainViewModel ViewModel
{
get
{
return (MainViewModel)this.DataContext;
}
set
{
this.DataContext = value;
}
}
All’interno della solution trovate un progetto chiamato MyPlugins (contiene 3 plugins che non fanno nulla :) ), una volta avviato il progetto PluginManager potete copiare MyPlugins.dll all’interno di ..\PluginManager\bin\Debug\Plugins e dovreste vedere due plugin Feature ed un plugin Filter.
[Download Code]
Buon MEF a tutti :D
Ho scoperto questa mattina, e con un considerevole ritardo che però devo ammettere, in altri “ambiti” sono facilmente tollerati, che è possibile postare articoli su Joomla! tramite Windows Live Writer.
Finalmente non dovrò perdere quarti d’ora preziosi quando devo inserire una news, un articolo o quant’altro per PVI.
Se avete bisogno anche voi di liberarvi del tempo libero, potete seguire queste semplici istruzioni.
Un post del mitico Alessandro Scardova mi ha fatto venire voglia di provare a vedere come se la cava IE9 con i test di compliance W3C, in particolare con Acid3, che è attualmente lo standard de facto in materia.
Internet Explorer è notoriamente il browser più diffuso ma ahimè anche il fanalino di coda nell'aderenza agli standard. Purtroppo, finché non vedremo un valore vicino al 100% nell'esecuzione del test (basterebbe già il 94% ottenuto da Mozilla 3.6 per cominciare), lo sviluppo di applicazioni Web 2.0 (ovvero il solito polpettone di HTML, Javascript, XML & c.) sarà un incubo.
Ecco come si presenta oggi IE9 nella preview pubblica 1.9.7745.6019:
Il 55% ottenuto è ancora lontano dal 100% di Chrome, Safari e Opera e dal 94% di Firefox 3.6. Tuttavia rispetto al misero 20% di IE8 è un notevole passo avanti. Visto che questa è una pre-pre-pre-pre-beta, direi che c'è da sperare bene! :-)
Un'altro aspetto poi sono le performance. I tempi di IE8 sono biblici se confrontati soprattutto con i browser Webkit based (Chrome, Safari), ma di questo parleremo più avanti, non prima di aver visto la beta.
L'utente in genere non considera queste problematiche come rilevanti, "tanto il sito funziona". Anzi, magari non funziona su Chrome proprio perchè è "workaround compliant" invece che W3C compliant. :-)
Il problema è purtroppo nei costi e costi elevati => innovazione tecnologica ridotta.
Sviluppo soluzioni Web da inizio anni '90, ho usato la stragrande maggioranza delle tecnologie che si sono alternate in questi anni (CGI, ASAP, Java Applet, Java Servlet, JSP, JSF, ASP, PHP, ASP.Net, Flash / Flex, Silverlight...) e posso dire che sviluppare su web non è mai stato costoso e problematico come oggi.
Personalmente nel quotare i progetti ormai presento ove possibile sempre due soluzioni: una basata su Silverlight e una basata su ASP.Net Ajax (o MVC 2.0 le rare volte che i controlli di terze parti non servono). Contrariamente a quello che il cliente si aspetta, il preventivo Silverlight è nettamente inferiore alla controparte ASP .Net.
La causa è semplice: la quantità di accrocchi in Javascript, i costi dei test e le generiche problematiche di compatibilità cross browser fanno lievitare i costi in maniera consistente per la seconda.
Ipotizzando un rilascio di un IE9 W3C compliant in un futuro non lontano, bisognerà comunque aspettare come minimo un paio d'anni dal rilascio prima di poter decretare la fine di IE8 e predecessori assortiti. Purtroppo stiamo ancora celebrando il funerale di IE6, che sembra però non essersene del tutto reso conto, visto quanto si vede ancora installato. IE è morto, lunga vita a IE 
Alessandro Pilotti [ MVP / IIS ]
Se si setta la proprietà ReadOnly di un TextBox ASP.NET a True, si avrà lo spiacevole effetto collaterale di perdere il viewstate del TextBox durante i postback.
Questo perchè la proprietà ReadOnly viene valutata lato server e, indicando che il controllo è ReadOnly, implicitamente indica che tutte le modifiche lato client saranno ignorate.
Per ovviare a questo problema si può impostare il readonly nella classica maniera impostando reaonly=”readonly” sul TextBox, oppure da codice utilizzando la proprietà attributes:
1: this.txtTest.Attributes.Add("readonly", "readonly");