Software Mason
Una delle cose “scomode” di passare un parametro ad una funziona per reference è che la funzione a questo punto può liberamente modificare il parametro in ingresso con il rischio di produrre side-effect indesiderati. Una cosa del tipo: struct Person { … } static void DoSomething( ref this Person ) { … ...
In C# 7 questo non era possibile: public static class Extensions { public static void Something( ref this ExtendedStruct es) { } } Non era cioè possibile passare ad esempio una struct ad un extension method per reference, pagando quindi pegno se volevamo usare extension method su strutture. Con C# 7.2 adesso è possibile, ci sono altre novità che riguardano “ref”, forse più interessanti ancora. Novità tutte orientate...
Una delle cose “noiose“ quando si scrive un’applicazione, ad esempio, Console è quando nel metodo Main si deve avere a che fare con codice asincrono, si finisce per scrivere una cosa del tipo: public void Main(string[] args) { MainAsync(args).GetAwaiter().GetResult(); } public Task MainAsync(string[] args) { return Task.CompletedTask; }...
Una* delle macchine che uso quotidianamente per lavoro è nel programma insider, slow ring, e da un po’ è stata aggiornata a Creators Update. Una delle feature che aspettavo era il “Controlled Folder Access”. Quello che potete fare è definire una o più cartelle (e di conseguenza le relative sotto-cartelle) come “controllate”. Questo fa si che fondamentalmente solo i programmi autorizzati possono apportare modifiche a quelle cartelle. Ovviamente la cosa che salta subito all’occhio è che un ransomware non risulta tra i programmi autorizzati e quindi problema risolto. Occhio perché al momento non è tutto oro...
Con grande piacere sono stato invitato, dai ragazzi di Brain-Sys e da Overnet, al Focus Day che si terrà a Milano il 27 maggio. Il focus della giornata sono i “developer tools” quindi tutti gli strumenti che un team di sviluppo si trova ad usare quotidianamente, parleremo quindi di Visual Studio, dando anche una sbirciata a cosa ci riserva il nuovo Visual Studio “15”, di NPM, Bower, Grunt e Gulp senza dimenticarci di UWP e Xamarin per lo sviluppo cross-platform. Io personalmente mi dedicherò a qualcosa di un po’ inusuale: GitFlow & GitHubFlow: gestire...
Idempotenza questa sconosciuta… Il “buon” Subtext è evidente che non sa cosa sia… post, duplicati, visibili da front-end ma non da back-end, dove ce ne sono altri duplicati: Lasciamo perdere poi la gestione della paginazione: Evito poi di addentrarmi nei meandri dello scheduler…è come sparare sulla Croce Rossa.
Il primo degli strumenti di cui ho parlato è Slack che sostanzialmente si configura come il centro del nostro mondo in particolare come accentratore di, quasi, tutta la comunicazione interna. La comunicazione però, purtroppo, non è solo quella interna e questo fa si che sia quasi impossibile, almeno per figure come la mia, eliminare completamente l’uso della mail. Ho colleghi che, dato il tipo di lavoro che fanno principalmente, guardano la posta una volta alla settimana o meno. Inbox Zero Tutta la posta aziendale gira su Google Apps il che comporta che il client di posta sia...
Workshop 1 Anno 2016 - Introduzione a DotNetCore, Microservice e ServiceFabric, una gran soddisfazione non c’è che dire. Slide: http://www.slideshare.net/mauroservienti/soa-ddd-e-microservices Esempi: https://github.com/mauroservienti/NServiceBus.Samples/tree/master/v5 L’esempio che abbiamo visto girare durante la mia sessione è il 14esimo: Il sistema più semplice per averlo up & running è installare i tool della Particular Platform, l’esempio usa dietro le quinte NServiceBus, scegliendo di configurare come minimo NServiceBus e ServiceControl: Questo fa si che tutte le code necessarie al funzionamento degli esempi siano create a correttamente configurate. Il file markdown relativo...
Questo post era originariamente su Medium a fini di sperimentazione della piattaforma, ed era anche l’unico, ma ho deciso di chiudere l’account. Riporto quindi il contenuto qui. Ieri sera è stata una piacevolissima sorpresa, sinceramente, non mi aspettavo così tanta gente e così tanto interesse. Quando, qualche mese fa, abbiamo deciso di parlare di “pub/sub” applicato al mondo di front-end avevo ben chiaro in testa come avrebbe dovuto funzionare la demo, ma in tutta sincerità non avevo la più pallida idea di come gestire la parte introduttiva. Alla fine mi sono preso il...
Un bel post di Martino introduce Topshelf, libreria che in passato ho usato parecchio. Si, ho usato e non uso più, nessun problema, semplicemente ritengo sia totalmente inutile. Riporto di seguito il codice che ha mostrato Martino, nulla di trascendentale, un servizio e la sua fase di bootstrap. Vediamo lo stesso codice implementato senza Topshelf using System; using System.ServiceProcess; class Program : ServiceBase { static void Main( string[] args...
Agli ultimi Community Days, 2015 per i posteri, una delle mie slide era la seguente: Nel contesto di quella presentazione, sempre per i posteri si parlava di NoSql, l’obiettivo era far notare come non ci fosse il giusto o lo sbagliato, in termini assoluti, quando si parla di database documentali, o in generale di lotta tra Sql e NoSql. Allo stesso modo è sbagliato affermare che: basso accoppiamento è bene, alto accoppiamento è male; microservices è bene, monolite è male; funzionale è bene, procedurale è male;...
Questa è facile! Aleggia questa strana convinzione che un mondo sincrono sia anche consistente, ecco… a meno che le vostre query in lettura non usino lock pessimistici e transazioni con un altissimo livello di serializzazione allora mi spiace dirvi che le vostre query sono stale by design… Mi spiace anche farvi notare che il sincrono non fa altro che ridurre la finestra temporale e dare una falsa sensazione di sicurezza; sensazione che altro non fa che abbassare il livello di guardia “aiutandoci” a produrre codice che troppo spesso parte dal presupposto che le cose vadano come ci aspettiamo....
Qualche tempo fa con un amico si stava discutendo di `Repository Pattern` e di tutto quello che gli gira intorno, tutta la disquisizione ruotava intorno a quale fosse il ruolo di un `repository` in un mondo orientato a CQRS. Siamo dopo un po’ di scambi di opinioni giunti alle seguenti questa conclusioni. Un repository deve consentire di caricare un aggregato data la sua chiave primaria; consentire di aggiungere una nuova istanza di un aggregato; persistere le modifiche apportate ad un aggregato; rappresentare una...
La serie di post su CQRS si arricchisce sempre più, ne mancano un paio per chiudere il cerchio e avere una overview abbastanza completa su “cosa”, “come” e “quando”. L’ultima volta che ne abbiamo parlato abbiamo introdotto il concetto di de-normalizzazione asincrona, elencando più o meno una lista di possibili passi simile a quella che segue: Invio del comando in POST; Ricezione del comando e dispatch dello stesso su una coda; Invio della risposta HTTP-202; Ricezione del comando e...
Nelle nostre divagazioni su CQRS di qualche tempo fa abbiamo parlato di eventualmente consistente ma non ci siamo addentrati nelle implicazioni tecniche che eventualmente consistente porta con se. Qualche, più di qualche, divagazione tecnica la approfondisco sul mio blog in inglese parlando di Jason che è un toolkit che ho scritto per eliminare dai pensieri dello sviluppatore tutta la parte infrastrutturale. In uno scenario come il seguente però abbiamo un piccolo problema nel momento in cui la parte di de-normalizzazione è asincrona: Supponendo una Single Page Application in cui i comandi arrivano via HTTP avete il...
Settimana scorsa mentre andavo a Londra per lavoro ho avuto il piacere di leggere “ASP.NET Web API Succinctly” di Emanuele DelBono, il libro fa parte della catena di libri tecnici di Syncfusion e devo dire che nella sua brevità, si legge in non più di due ore, è semplicemente esaustivo. Emanuele parte facendo una breve introduzione alla filosofia che “regola” REST per poi addentrarsi nei tecnicismi di ASP.NET Web API e di come REST si coniughi con gli aspetti tecnologici di Web API. La parte tecnica è il giusto mix tra semplicità e approfondimento, vista la natura delle...
Ai Community Days di quest’anno abbiamo sproloquiato di scalabilità, una delle cose su cui ho cercato di insistere è che per poter parlare di scalabilità è necessario in primis essere in grado di misurare e definire quali sono i requisiti che devono essere rispettati. Questo per un semplicissimo motivo: la scalabilità infinita è un mito, fine, è il requisito che ci deve far scegliere come scalare e non la semplice necessità di scalare. Facciamo un esempio banale e un po’ astratto per capire: Abbiamo un bel sito web di e-commerce, piccolo piccolo che fa...
Abbiamo già parlato del lavoro legato alla performance di Radical, i punti toccati non sono stati poi molti, il voro nocciolo della questione giro intorno ad un signore che si chiama “Ensure” e che vi permette di scrivere qualcosa del tipo: class MyClass
{
public void Foo( String arg )
{
Ensure.That( arg ).Named( () => arg ).IsNotNullNorEmpty();
}
}
A runtime quello che succede è che se “arg” è null o empty vi beccate una simpatica eccezione con tutti i dettagli del caso, compreso:
...
Aurelio è uno dei tanti fruitori di Radical (che vi ricordo ha cambiato casa) e mi ha segnalato un fastidioso problema di performance nel momento in cui viene messa in binding una list di entità, basate sulla classe base “AbstractViewModel” di Radical, la cui numerosità sia corposa: Nell’esempio, che Aurelio ha prodotto per riprodurre il problema, a sinistra vengono create 2.000 istanze di un banalissimo ViewModel che implementa direttamente INotifyPropertyChanged, mentre a destra viene fatta la stessa cosa con un ViewModel che eredita da “AbstractViewModel”. Come si nota i tempi sono abissalmente superiori e anche inaccettabili...
Attualmente sono veramente rognosi da usare, ma potrebbero diventare: public class Foo
{
public static void MyMethod( out Int32 x )
{
x = 12;
}
}
Foo.MyMethod( out var bar );
bar...
Forse potremo dichiarare inline al metodo i tipi in out, sfruttando type inference e avendoli a disposizione nello scope, forse…
.m
Non tutte le feature che vediamo saranno sicuramente implementate, questi post sono basati sui draft pubblicamente disponibili al momento della scrittura
Anche questa è una figata: public class Foo
{
public DateTime BornDate{ get; set; }
public Int32 Age => DateTime.Now.Year - this.BornDate.Year;
}
Lasciamo perdere l’implementazione stupida, ma notiamo piuttosto che Age è una proprietà a tutti gli effetti, è una proprietà in solo get, il cui body invece di essere inutilmente verboso si limita ad una lambda.
Cosa è che la distingue da uno dei tanti tipi di delegato?
il tipo di ritorno;
il dettaglio, poco visibile al primo sguardo, che non ci sono parametri in ingresso alla...
Finalmente :-) class Sample<T>
{
public Sample( T data )
{
}
}
var instance = new Sample( "this type is infered" );
Non saremo più obbligati a dichiarare i tipi generici sui costruttori, rendendo di fatto utili le Tuple :-P
.m
Non tutte le feature che vediamo saranno sicuramente implementate, questi post sono basati sui draft pubblicamente disponibili al momento della scrittura
Questa invece mi piace un sacco, nonostante purtroppo non sia un’implementazione delle Monad in C#: public class Foo
{
public void Evaluate( Person person )
{
var number = person?.Addresses?.FirstOrDefault()?.StreetNumber;
}
}
Se diciamo che, dato che StreetNumber è Int32, il tipo di “number” è Nullable<Int32> il resto direi che è abbastanza ovvio. Ci evita una valanga di noiose e rumorose “if”.
.m
Non tutte le feature che vediamo saranno sicuramente implementate, questi post sono basati sui draft pubblicamente disponibili al momento della...
Questa non mi piace, nel senso che non mi piace la keyword params in generale, sono più le volte che alla lunga mi ha dato problemi piuttosto che vantaggi, comunque: public ckass Foo
{
public void Evaluate( params IEnumerable<Whatever> data )
{
}
}
.m
Non tutte le feature che vediamo saranno sicuramente implementate, questi post sono basati sui draft pubblicamente disponibili al momento della scrittura
Questa è una figata: public class Foo
{
public Int32 Evaluate( SomeInput data ) => …;
}
Lasciamo perdere la non-implementazione , ma notiamo piuttosto che Evaluate è un metodo a tutti gli effetti, il cui body invece di essere inutilmente verboso si limita ad una lambda, in realtà è una espressione, non viene generato un expression tree, usa solo una sintassi simile a quella delle lambda.
.m
Non tutte le feature che vediamo saranno sicuramente implementate, questi post sono basati sui draft pubblicamente disponibili al momento della scrittura
Ultimamente mi sto dedicando molto allo sviluppo client con JavaScript e HTML, mi diverto, odio JavaScript, amo JavaScript e comunque mi diverto :-) Una delle cose interessanti dello stack client side è che è totalmente indipendente da Windows come sistema operativo, quindi perché non sfruttare il dettaglio che il mio Mac, quando non uso la macchina virtuale, sta acceso almeno 12 ore a batteria, come ambiente di sviluppo per la parte client? Un web server… …purtroppo vi serve perché se da una pagina caricata dal browser con lo schema “file://” fate una richiesta http con lo stesso...
Sulla falsariga della inizializzazione delle proprietà automatica sarà possibile inizializzare le proprietà automatiche in solo “get”: public class Foo
{
public String Bar { get; } = "hi, there!";
}
.m
Non tutte le feature che vediamo saranno sicuramente implementate, questi post sono basati sui draft pubblicamente disponibili al momento della scrittura
Interessante poter scrivere: public class Person( string firstName, string lastName )
{
public String FirstName{ get; set; } = firstName;
public String LastName{ get; set; } = lastName;
}
Lo scopo è aumentare drasticamente la compattezza del codice in quei casi in cui praticamente scriveremmo solo plumbing, come nell’esempio di cui sopra. Possiamo quindi:
dichiarare 1 costruttore in-line con la dichiarazione della classe stessa;
assegnare dei valori di default alle proprietà auto-generate, in questo caso utilizzando i parametri del costruttore di cui sopra, che sono in scope;
Ovviamente...
Anche quest’anno i Community Days sono finiti, è stata per l’ennesima volta l’esperienza community migliore che si possa avere, il che non è ne scontato ne facile. Andare in crescendo, ogni singolo anno di più, garantendo un evento di qualità, di elevatissima qualità diciamocela tutta, con: 75 speaker; 89 sessioni divise su 11 track; per 3 giorni; è tutto tranne che un’operazione semplice e chiunque pensi il contrario è caldamente invitato a farsi avanti a dare una mano. Quindi complimenti ad Andrea e Daniele per la fatica...
Partendo con la nostra carrellata sulle funzionalità che verranno aggiunte al linguaggio la prima interessante (che sinceramente a me fa un po’ storcere il naso) è la possibilità di usare la keyword “using” negli statement per l’aggiunta dei namespace anche per aggiungere interi riferimenti a classi: using System;
using System.Math;
namespace UsingSample
{
public class Sample
{
static void Calculate()
{
var result = Sqrt( /* ...
La nuova versione di C# conterrà molte nuove piccole gemme, alcune confermate altre in fase di studio: using statics; primary constructors; auto-property initializers; getter-only auto-properties; expression bodied functions; params on IEnumerable; null operator; ctor type inference; declaration expression; out parameters inference; Un veloce post per ognuna è in arrivo nei prossimi giorni ;-) .m
Qualche giorno fa sono stato da un cliente per una giornata di consulenza, giornata che in partenza sembrava prospettarsi come la solita, senza nessuna connotazione negativa sia chiaro, giornata in cui si discute di tecnologia, ma mai aspettativa fu più sbagliata. La giornata partiva con l'obiettivo di capire come migrare un'architettura tradizionale, quindi basata su layer, verso un'architettura esagonale corredata da CQRS e Event Sourcing, partendo dal presupposto che il team si era già fatto tutta una serie di domande, sacrosante, che aprivano a molti dubbi sulla scelta che si stava per fare. n.d.r.: il...
Come già annunciato da Lorenzo su questi schermi nei giorni passati dopo un corposo lavoro di setup con Ynnova abbiamo lanciato il primo giro del calendario di formazione.
Obiettivo di questa tornata di corsi sono da un lato gli aseptti architetturali, con due giorni di formazione su CQRS e Event Sourcing, e dall'altro le tecnologie di presentazione dei dati, nello specifico le Single Page Application con AngularJS, con anche in questo caso due intere giornate di formazione.
A calendario ci sono 8 date geograficamente distribuite e siamo molto felici di aver avuto il supporto di Michele Aponte e Fabio Cozzolino, rispettivamente DotNetCampania...
...e le conseguenti pessime decisioni di design. Sto lavorando con le API di amministrazione dell’ACS di Windows Azure, API che sono esposte oltre che dal portale di Azure con una bella e comoda interfaccia anche come servizi in modo da poter programmaticamente gestire la configurazione. I servizi che l’ACS di Azure espone sono basati su OData (almeno in apparenza) ed espongono un modello apparentemente molto comodo, sempre in apparenza :-) Osservate il seguente stralcio di codice: var client = CreateManagementServiceClient();
var parties = client.RelyingParties;
foreach ( var party in parties )
{
Console.WriteLine(...
…fare un mesetto da manager ogni 6 mesi, si renderebbero conto al volo che il codice è un dettaglio infrastrutturale che incide sul successo di un progetto per una parte a volte veramente poco significativa. Al crescere del team, o della complessità del progetto, l’organizzazione del lavoro, la distribuzione dei compiti, le competenze delle risorse, le scelte architetturali, le scelte tecniche le guideline operative, tutto il tempo dedicato alla parte di UX hanno un’incidenza tale che è abbastanza facile comprendere perché in certe organizzazioni la catena manageriale diventa lunghissima. Portando ad un ovvio problema sia chiaro. Su un...
Ultimamente mi ritrovo spesso ad osservare mia moglie mentre ha a che fare, dovrei dire combatte, con del software, dovrei dire con del software pietoso. L'unica vera conclusione che posso trarre è che complessivamente scriviamo del software che definire anche solo accettabile è quantomeno stupido e senza senso. Nella stragrande maggioranza dei casi, usando anche software (web o meno che sia) blasonato fa molta fatica a raggiungere gli obiettivi che si è prefissata, siano essi un acquisto online o la semplice stampa di un documento PDF. Cercando di essere il più obiettivi possibili e partendo dal presupposto...
Nonostante il disastro totale che è la mia agenda in questo periodo ce la possiamo fare :-) La data in cui riesco a pianificare e rendere sostenibile la preparazione del quarto appuntamento con Radical è Lunedì 25/11 alle 21.30 (magari anche un po’ prima, ma quello lo decidiamo insieme). L’agenda, o meglio una possibile idea di agenda, è: Introduzione del polimorfismo nel modello dati al fine di capire come gestire visualizzazioni condivise e editing diverso; Approfondimento dei concetti di “UI Composition” per capire come strutturare un’applicazione a moduli/plugin; ...
Lorenzo ha fatto un lavoro notevole con l’organizzazione delle due giornate su RavenDB che si terranno a Padova il 28 e 29 ottobre, ha anche preso accordi con Manning per la sponsorizzazione, quindi credo che avremo qualche libro che “gironzolerà” durante le due giornate. Se non ho capito male c’è ancora un posto disponibile, nel caso quindi vi interessare approfondire, o anche solo approcciare, il mondo dei database documentali direi che l’occasione non è di quello che dovete lasciarvi scappare.
Qualche settimana fa questo: Poi Davide questo: Andate a leggere il post linkato da Davide (http://gaiustech.wordpress.com/2013/04/13/mongodb-days/), poi fate un esercizio e togliete la parola MongoDB da tutto il post e sostituitela con qualsiasi tecnologia, meglio se di grido e nuova, vi venga in mente, il discorso (mediamente) fila lo stesso. Ha senso anche spezzare una lancia a favore della conferenza che del resto si chiama “MongoDB Days” e quindi è sensato aspettarsi che si parli solo di quanto sia bello quello e che ci siano anche un sacco di invasati, del post infatti...
Il primo “giro” di Radical mi sembra di poter dire sia andato bene, ci sono un po’ di cose da affinare ma direi che non mi posso lamentare troppo, ovviamente grazie a tutti i partecipanti. La registrazione e il materiale del primo incontro è disponibile per il download. Come da richiesta stiamo organizzando il secondo round il cui scopo è affrontare una “semplice applicazione per editare delle anagrafiche”, gli argomenti che tratteremo sono: CRUD usando RavenDB Embedded allo scopo di tener bassissima la complessità, pensate a RavenDB (in questo caso) come un mero meccanismo...
Qualche giorno fa abbiamo accennato alla possibilità di fare una sessione introduttiva a Model View ViewModel con Radical: le adesioni sono per gestite con un doodle. Sembra che la maggioranza abbia votato per domani (15/05) alle 21.30, e così sia la prima sessione la terremo domani, a breve posterò anche il link e lo modalità di erogazione. Se riusciamo la registro e magari la ripetiamo anche, o la evolviamo con una seconda puntata, se la cosa “ci” piace. .m
Forse non tutti sanno che… OAuth non è un protocollo di autenticazione, ma bensì un protocollo di autorizzazione il cui scopo, nello specifico, è quello di delegare un terzo attore ad accedere ad una risorsa verso cui il delegante è autenticato e autorizzato. Diciamo che questo, OAuth non è un protocollo di autenticazione, è uno dei buoni motivi per cui Twitter non è uno degli IdentityProvider supportati dell’ACS di Windows Azure. Diciamo anche che avete questo scenario: State lavorando ad un progetto che tra le tante cose espone un’API che sarà pubblica; ...
Qualche giorno fa in “C come CQRS” abbiamo analizzato, senza scendere troppo nel dettaglio, una possibile implementazione della parte di comandi di CQRS. Ora, quello che abbiamo ricade a tutti gli effetti sotto il cappello dei tecnicismi, che, sono si importanti, ma senza avere una visione generale del problema trovano il tempo che trovano. Se ci spostiamo un pelo più in alto e diamo uno sguardo al tutto quello che vediamo, generalizzando molto e prendendo la letteratura alla lettera, è questo: Ci sono tante implementazioni possibili, anche molto più semplici di quella identificata nel diagramma,...
CQRS che…? per una esaustiva introduzione a CQRS potete leggere questo articolo di Martin Fowler. Andrea nella sua sessione su CQRS al .NETCAMPUS presentando il pattern, e una possibile implementazione, ha detto una cosa importantissima, particolarmente vera quando si parla in generale di Domain Driven Design: CQRS, Event Sourcing e DDD sono una metodologia di sviluppo che aggrega vari pattern architetturali, ognuno dei quali, in fase di implementazione, può essere declinato in modi diversi tutte egualmente giusti, in dipendenza del contesto in cui ci troviamo. (non sono le esatte parole, ma rendono...
…che in quanto tale forse andava fatta prima… :-) Approfitto dell commento di Nicolò per farla adesso, nonostante ne abbia già parlato anche se mi rendo conto solo ora che probabilmente annegata in un discorso ampio e complesso la cosa possa passare inosservata. Attenzione… :-) Osservate il post di Corrado sulla localizzazione: Se provate, in un qualsiasi punto del ViewModel, a scrivere “this.LocalizedText.” scoprite che l’intellisense non vi fa vedere un bel nulla…eppure questo funziona che è un piacere: Come è possibile? Il giochetto è abbastanza semplice ed...
throw new ServiceException( "Error sending e-mail, but e-mail sent successfully" );
e pure affascinante :-)
.m
…è praticamente impossibile, mettevi l’anima in pace :-) ma non tutto è perso, altrimenti che scriverei a fare? Il problema di fondo è che per sviluppare in maniera decente per Windows Mobile avete 2 requisiti: che l’emulatore sia in grado di connettersi alla rete e qui sorgono i primi problemi perchè l’emulatore usa il driver di rete di Virtual PC 2007 che purtroppo non convive felicemente con Windows Virtual PC su Wiundows 7; che il Cellular Emulator faccia il suo fantastico sporco lavoro e qui proprio non c’è mezzo perchè il...
Ne abbiamo parlato non poco sia io che Corrado e l’argomento è stato ripreso durante il corso su Wpf che abbiamo tenuto questa settimana, a proposito: trovo che sia decisamente produttivo, in particolare per la platea, partecipare ad un corso dove la docenza è in pair, con 2 docenti, con un background tecnico paragonabile, ma con un background lavorativo diverso perchè porta un arricchimento non da poco. …torniamo “in topic” che è meglio :-) L’obiettivo è poter avere, in Blend, questo: Quindi semplicemente una design time experience degna del...
Tra le tante novità di Wpf 4.0, questa è proprio interessante: http://blogs.msdn.com/llobo/archive/2009/11/20/xaml-2009-features-factorymethod-arguments.aspx .m
Stavo leggendo una interessante serie di post sull’integrazione tra Castle e WCF, illuminante e istruttiva per molti versi ma sinceramente faccio molta fatica a digerire questo mascheramento. Credo che in generale ci sia un problema di fondo nella teminologia usata: quando si parla di IoC si usa indifferentemente componente o servizio. L’errore secondo me sta nell’utilizzare poi indifferentemente servizio quando questo viene inteso come componente e quando questo invece viene inteso come servizio nel senso SOA del temine, portando alla convinzione che siano concettualmente utilizzabili allo stesso modo. Secondo me non c’è nulla di più sbagliato, ho la...
Parliamo un po’ di produttività… ma non tanto in termini di linee di codice scritte in una unità di tempo quanto piuttosto di come e quanto cali la nostra, la mia sicuramente, resa a causa della noia che scrivere codice sempre uguale produce… Se usate Wpf (o in generale sviluppo di applicazione rich client) questo è un esempio di noia mortale: private String _myValue = null;
public String MyValue
{
get { return this._myValue; }
set
{
if( value != this.MyValue...
Nell’ottica di addomesticare lo strumento e non di piegare noi stessi ai limiti, o presunti tali, dello strumento stesso, ci sono una quantità notevole di piccole cose che possiamo fare per semplificarci la vita. Faccio Unit Test e TDD, credo nella giusta misura, e uso con soddisfazione MSTest per tutta una serie di buone ragioni, ma se c’è una cosa che mi da veramente fastidio è questa: Che cosa notate? mi sono limitato ad aggiungere ad un progetto di test un nuovo test, nulla di più, eppure: Il codice del template...
Sono un paio di settimane che sto seguendo la “ricetta” e ho notato che il fatto di averne parlato ha stuzzicato l’interesse. Quoto Andrea Dottor: …Per quanto mi riguarda, non la conoscevo e ne sono rimasto da un lato affascinato, nel senso che, porsi degli obiettivi da 25 minuti non è affatto complesso, e rimanere concentrati per 25 minuti è una cosa fattibile… L’esperienza di queste 2 settimane mi fa dire che: 25 minuti sono lunghissimi :-) Stare concentrati per 25 minuti su un obiettivo è...
Iniziamo con una piccola nota polemica, concedetemelo :-)
un dev è un professionista come tanti altri, medici o idraulici ad esempio, e quello che mi aspetto da un medico o da un idraulico è che abbia una buona conoscenza, ma soprattutto confidenza, dei suoi strumenti… quindi come è normale che un idraulico sappia cosa è un sifone mi aspetto che un dev sappia cosa è metticiunpoquellochevuoi di Visual Studio; non mi aspetto che lo sappia usare ma mi aspetto che la curiosità l’abbia spinto almeno a dargli un’occhiata.
Purtroppo sempre più spesso consto che questo è molto lontano dalla realtà di...
Avete mai provato a tenere abilitato lo script debugger di Internet Explorer? e poi a navigare un po’ e un po’ la…? che esperienza teribbile :-), tre quarti delle pagine contengone quintalate di errori JavaScript: producendo una experience che definire pessima è un complimento :-) L’unica fortuna, per chi produce ste cose, è che quelle opzioni devono essere esplicitamente configurate e quindi in pressochè tutti i browser le cose vanno bene, ma la domanda a questo punto è: ma il dev che ha scritto quello roba l’ha...
Poco tempo fa ho parlato di strategie di generazione del document identifier con NHibernate, quello che vogliamo ottenere è rendere trasparente all’utilizzatore il fatto che un “id”, ad esempio il numero fattura, debba essere generato e dipenda da fattori esterni all’entità. In soldoni vogliamo limitarci ad una cosa del genere: using( var dc = this.dataContextFactory.Create() )
{
using( var tx = dc.BegingTransaction( IsolationLevel.Serializable ) )
{
dc.Insert( myEntity );
tx.Commit();
}
}
nel post di...
Questa è abbastanza “scomoda” se usate gli event listener di NHibernate da codice dovete stare molto attenti a non rimuovere quelli di default:
var fc = container.GetService<FluentConfiguration>();
fc.ExposeConfiguration( cfg =>
{
cfg.EventListeners.PreInsertEventListeners = new[] { new MySaveEventListener() };
} );
Quello che succede infatti, e pure giustamente, è che se nella lista degli eventi c’è già qualcuno lo state semplicemente sovrascrivendo e questo è poco bello :-)
Una soluzione semplice ed elegante è questo Extension Method che vi permette di scrivere in maniera molto naturale questo:
var fc = container.GetService<FluentConfiguration>();
fc.ExposeConfiguration( cfg =>
{
cfg.AddListener( e => e.PreInsertEventListeners, new MySaveEventListener() );
});
ne riparliamo prossimamente
.m
Questo è un’altro dei passaggi cruciali, abbastanza manutenibile anche a posteriori a patto che non siate sotto source control che rende le cose un po’ più ostiche. Per prima cosa ricordiamoci che i sistemi di source control non digeriscono molto bene il rename di un progetto, e TFS non fa difetto ;-); per essere precisi il problema è che se siete (e io lo sono alla noia) pignoli quando rinominate un progetto volete anche rinominare la folder.. e questo spacca la solution… e che ----- :-), quindi si può fare ma è abbastanza tedioso, meglio cercare...
Durante la preparazione del materiale per il corso del mese prossimo salta fuori questa piccola rogna che mi segno per i posteri ma che devo indagare un po’ meglio: se avete un elemento Wpf che supporta l’infrastruttura di commanding, quindi un ICommandSource, in binding con un ICommand e nel momento in cui lo stato del commando cambia (evento CanExcecuteChanged) l’elemento Wpf è disabilitato (IsEnabled == false) la variazione di stato del comando viene ignorata e non viene rivaluata (CanExecute) quando l’elemento Wpf torna ad essere abilitato. Qualcuno ha avuto esperienze simili? .m
Non sono propriamente uno sviluppatore web, o almeno non lo sono più in modo assiduo da qualche anno, quindi sono rimasto un po’ indietro :-) Da un anno, abbondante, a questa parte in bottega stiamo seguento un cliente, di dimensioni ragguardevoli, nello sviluppo di una soluzione di content publishing; sono entrato nel team da poco e siccome una parte corposa del progetto è basta su Asp.Net MVC avevo bisogno di recuperare il tempo perso e nel frattempo prendere confidenza con il framework MVC, naturalmente non potevo farlo pesando sulle spalle del team, almeno non per la parte prettamente infrastrutturale....
La nuova Team Build di TFS 2010 è semplicemente fantasmagorica, hanno rivoluzionato il mondo e adesso il driver della Team Build non è più il già eccelso motore di MSBuild ma ci siamo evoluti verso Workflow Foundation 4.0: Questa è una piccola parte, notare la scrollbar sulla destra, del workflow del build template di default. Se andiamo a spulciare nei meandri troviamo questo: che esegue la vera e propria build del progetto o dei progetti compresi nella solution, tutto il resto, i “fronzoli”… si fa per dire…, è completamente gestito da WF4.0...
Se, e ripeto se, questa cosa vede la luce, faccio santo qualcuno :-) Leggendo questa serie di post mi vengono i brividi al pensiero di quello che potrei mettere in piedi con un TFS “locale” sincronizzato con un TFS “aziendale” (stiamo lavorando per voi :-)). Team Build “locale” con la mostruosità di vataggi che questo comporta; possibilità di lavorare offline con una experience da paura perchè sarebbe esattamente come essere online; Una bolletta 3G un po’ meno salata, che non guasta mai ;-) .. chi più...
Questa è una di quelle cose che non si drovrebbero fare… ma se avete un db che non potete toccare non è che ci siano molte scappatoie :-) Il bello è che il tool risponde alla grande, anche se in questo caso deve essere un po’ addomesticato. Lo scenario è questo: Mappato su un db con, più o meno, questa struttura: Nel dominio avete il concetto di Preventivo (Estimate) e di Contratto (Agreement) e le 2 entità sono relazionate tra loro: ad un preventivo potrebbe corrispondere uno ed un solo contratto...
è un problema :-) [TestMethod]
public void ExceptionTestWrapper_Try_using_non_buggy_code_should_not_fail()
{
Tester.Expecting<ArgumentNullException>( "expectedParamName" ).Try( () =>
{
new ClassUnderTest( null );
} );
}
[TestMethod]
[ExpectedException( typeof( AssertFailedException ) )]
public void ExceptionTestWrapper_Try_using_non_buggy_code_but_with_wrong_expected_paramName_should_fail()
{
Tester.Expecting<ArgumentNullException>( "invalidParamName" ).Try( () =>
{
new ClassUnderTest( null );
} );
}
[TestMethod]
[ExpectedException( typeof( AssertFailedException ) )]
public void ExceptionTestWrapper_Try_using_buggy_code_should_fail()
{
Tester.Expecting<ArgumentNullException>( "expectedParamName" ).Try( () =>
{
new ClassUnderTest(...
Supponendo di aver bisogno di mappare un’entità che espone delle proprietà calcolate con FluentNHibernate avete qualche problema… L’inghippo di fondo è questo: quando mappate una entity, in fase di inizializzazione dei proxy (e qui vado a intuito) il proxy builder cerca tutte le proprietà e si lamenta, con una sonora exception, se una delle proprietà non è virtual o se manca del set accessor. Il messaggio di errore poi è quantomeno fuorviante :-) Girovagando su internet si trovano tante colorite soluzioni (pezze direi io) tra cui la più bella è quella di disabilitare in toto il proxy validator:...
Lo scenario più semplice è quello della generazione del “numero fattura” in fase di insert del nuovo documento, tralasciamo per ora le più svariate possibilità legate al concetto di bozza, ad un certo punto avete la necessità di generare questo benedetto numero che deve sottostare a determinate regole. La stessa cosa può succedere in altri casi, come ad esempio la generazione di un codice cliente, e questo ci permette di generalizzare dicendo che: Abbiamo la necessità di generare un codice univoco; Questo codice univoco deve essere umanamente leggibile e avere un significato nel...
Scenario: un dominio molto banale mappato su una singola tabella con una colonna che fa da discriminante, è così, è legacy e me lo devo tenere :-). Adesso il nostro simpatico utente vuole fare una ricerca per tutti i Subject, a prescindere dal fatto che siano Company o Person, che contengono in Subject.Name qualcosa tipo (Like) ‘%mauro%’: una sorta di full-text. Banale direte voi: var criteria = querySpec.Keywords
.AsSqlServerKeywords()
.Aggregate( session.CreateCriteria<Subject>(), ( a, kw ) =>
a.Add( Restrictions.Like(...
Tempo fa ho introdotto PostSharp, dal primo approccio è passato ormai un anno e da qualche mese lo uso con soddisfazione, in produzione, per la gestione della parte noiosa del tracing. In questi giorni ho ripreso in mano la parte di AOP per la validazione dei parametri di input di un metodo, tipicamente quello che si fa è questo: void StandardValidation( String v )
{
if( v == null )
{
throw new ArgumentNullException( "v" );
}
}
oppure, evolvendosi...
La necessità è quella di intercettare il plug/unplug di un qualsiasi device USB. Il problema è che il sistema operativo sparapacchia la notifica nella massage pump e il subclassing in Wpf è concetto inesistente… Quindi? E’ un po’ contorto ma alla fine con una manciata di righe di codice ci si arriva: Public Interface IHardwareMonitor
Event DeviceAttached As EventHandler
Event DeviceRemoved As EventHandler
End Interface
definiamo quello che vogliamo ottenere: un semplice observer.
The Trick
A questo punto lo possiamo implementare, ad esempio, in questo modo:
Public NotInheritable...
Pian piano il tutto sta prendendo forma, i nodi vengono al pettine e le soluzioni (almeno per ora, è il bello del nostro lavoro, panta rei) sembrano finalmente essere soluzioni e non semplici pezze, non puzzano insomma :-) Tutto parte da qui, cioè fondamentalmente dalla necessità di snellire la realizzazione di un’applicazione fortemente basata su M-V-VM e dalla necessità, evidenziata qui e qui, di fornire una UX che sia decisamente consistente. In questa direzione, e al crescere dell’applicazione, risulta rapidamente evidente che vi è la necessità di snellire e automatizzare il maggior numero possibile di task: quindi, come scegliamo...
… o era un diamante… scherzi a parte, da un punto di vista tecnologico abbiamo già visto che non è vero che la scelta di un O/RM ci lega per la vita con questo però è essenziale che la scelta di un O/RM sia comunque oculata e ben ponderata rimpiazzarlo non è operazione da un pomeriggio. Nel mio piccolo ho avuto il piacere/dispiacere di avere a che fare con (in ordine alfabetico): Entity Framework (v1); Linq to Sql; NHibernate; Se devo scegliere un “vincitore”, di che cosa poi...
Secondo me ci stanno abituando un gran bene: ci sono alcune notifiche all’utente che hanno bisogno di “essere invasive senza essere invasive” :-), probabilmente fine a qualche anno fa una situazione del genere sarebbe stata gestita con un fastidiosissimo MessageBox. Il sistema adottato da IE, e anche da molti altri software, è comodissimo perchè è decisamente ben visibile e fastidioso (quindi attira l’attenzione) ma per nulla invasivo, un MessageBox sarebbe bloccante. Queste buoni abitudini però possono ritorcersi contro di noi perchè il nostro caro utente fa dei confronti tra il nostro software e quello degli altri...
Okkio a questo scenario: var subjects = new EntityCollection<Subject>();
var dataView = subjects.DefaultView;
subjects.Add( new Person() );
Adesso immaginate che dataView sia in binding con una ListView, dataView è IBindingListView e questo fa si che la ListView sia in grado di reagire alle variazioni che subisce dataView, ecco che il codice di cui sopra fa “magicamente apparire” nella ListView un nuovo item.
Adesso fate questa cosa:
var subjects = new EntityCollection<Subject>();
var dataView = subjects.DefaultView;
for( var i = 0; i < 1000; i++ )
{
subjects.Add( new Person() );
}
La stessa cosa, ma un po’...
Ayende ne ha parlato proprio in questi giorni, ed io è qualche settimana che giro intorno… anche se lo scenario è diverso. Unoa dei problemi delle differenze tra Wpf e Windows Forms è che per il mondo Wpf i concetti di IDisposable e di IComponent sono del tutto irrilevanti, del resto non ci sono risorse, aka handle ad esempio, da rilasciare. In Windows Forms sfruttavo il fatto di poter realizzare un IComponent e avere gratis la chiamata a Dispose nel momento in cui veniva fatta la Dispose del componente contenitore, ad esempio la Form. In molti casi deviavo...
Questo manuale proprio non mi va giù :-) Pochissimi giorni fa ho introdotto nel mio toolkit un behavior per generalizzare la gestione del Drag & Drop, a breve il tutto probabilmente finirà su CodePlex, ma non è questo l’argomento odierno. Houston abbiamo un problema <cit.> Nel post di cui sopra, per agganciare il behavior ad una ListView facevamo: <ListView Margin="5" HorizontalAlignment="Stretch"
behaviors:DragDropManager.DataObject="{Binding Path=ItemsToDrag}"
behaviors:DragDropManager.DataObjectType="myType"
ItemsSource="{Binding...
Non si può. Il motivo è abbastanza semplice, esiste uno ed un solo “Region Service”, per ciclo di vita dell’applicazione, che è il main entry point per accedere al mondo delle region, dato un Region Service e una View è possibile ottenere un Region Manager che è colui che gestisce le region per una data View; come minimo quindi esiste un Region Manager per ogni View che ospita delle region. La procedura di registrazione delle region è abbastanza semplice e viene fatta dalla MarkupExtension che lo sviluppatore utilizza nello xaml: <StackPanel rg:RegionService.Region="{rg:PanelRegion Names=”MyRegion”}}" />
...
Se soffrite da dipendenza acuta da M-V-VM questa è una discreta rottura perchè il drag & drop è “roba” totalmente da Presentation (aka View) ma la logica è totalmente da Business (aka ViewModel). La gestione del drag & drop è quindi un ottimo candidato per divertirci con gli attached behavior, nome figoso per le ormai legacy attached properties. Quello che vogliamo ottenere è questo: <ListView HorizontalAlignment="Stretch"
SelectedItem="{Binding Path=Selection}"
behaviors:DragDropManager.DataObject="{Binding Path=Selection}"
...
Discreta rottura di mar*ni: var wrapper = new Wrapper<Person>();
var a = TypeDescriptor.GetProperties( wrapper );
var b = TypeDescriptor.GetProperties( typeof( Wrapper<Person>) );
producono 2 risultati decisamente diversi… Gestibile, sia chiaro, ma decisamente una rottura che per ora rende inutilizzabile in molti scenari questa fantastica idea, autocelebration-mode-off :-)
peccatissimo, peccato…
.m
Questa cosa è rimasta in sospeso da tempo immemore ed è ora di dare un senso, perchè altrimenti un senso non ce l’ha… <semi-cit> :-) La nostra applicazione funziona! ma effettivamente è poco più di un “Hello World”, però funziona. Prometto che diventerà qualcosa di più di un semplicissimo “proof of concept”. Adesso però abbiamo un problema non da poco, ne abbiamo già parlato, e adesso cerchiamo di approfondire e nel limite del possibile dare una soluzione. A volte si dice che un’immagine vale più di mille parole ma in questo caso non è...
L’allergia continua ed evidentemente peggiora… :-) Qualche tempo fa ho parlato di NHibernate e degli IUserType, fortunatamente non ho fatto vedere l’implementazione :-) perchè c’è un leggero bug, moltgo subdolo, ma sempre bug! Un doveroso grazie a Marco De Sanctis che mi ha supportato nella ricerca/soluzione del problema. Un minimo di storia, concedetemelo, immaginiamo un modello del tipo: dove avete una classe e delle associazioni, nell’esempio volutamente monodirezionali, non delle collection-association, che hanno la caratteristica di poter essere null. Avete quindi un Prodotto che può avere una Serie...
Separation Of Concern e Single Point of Responsibility (non ho trovato in link che mi piacesse) visti dalla parte sbagliata: Quel coso fa troppe cose :-) .m
Nonostante il titolo questo post è uno strascico di quello sulla conversazione di qualche tempo fa. Te l’avevo detto io, te l’avevo detto io, ehehehe ehehehe :-) Facciamo un po’ di storia. C’erano una volta i cursori e i lock pessimistici: poi, forse fortunatamente, il mondo si è evoluto e siamo passati agli scenari disconnessi: In uno scenario disconnesso semplicemente si carica/crea una rappresentazione in memoria dei dati e si lavora su quella rappresentazione invece che direttamente sullo storage. Questo secondo approccio risolve molti problemi, permette scenari di gran lunga...
Trovo che la sintassi di C# accoppiata ad un po’ di sane Fluent Interfaces porti a qualcosa di semplicemente bello, l’eleganza del risultato è una delle cose che mi piacciono sempre molto. var command = DelegateCommand.Create()
.OnCanExecute( o => true )
.OnExecute( o => { } )
.TriggerUsing( PropertyChangedObserver
.Monitor( this )
...
una piacevole chiaccherata via messenger con Marco di Sanctis mi porta verso questo post che probabilmente sarà il primo di una serie, probabilmente. Vediamo di dare un paio di definizioni giusto per inquadrare lo scenario: Database Transaction: è una transazione specificamente sui dati il cui scope è limitato al database/storage, per sua natura deve essere il più “stretta” possibile, dove per stretta intendiamo iniziare il più tardi possibile e terminare il prima possibile; il perchè è evidente: durante una transazione a livello di storage abbiamo, in base al livello di isolamento, fondamentalmente un lock pessimistico sui dati ergo...
Disclaimer(s) :-) Sto studiando quindi prendete tutto molto con le pinze; Sono decisamente allergico al manuale delle istruzioni quindi usate delle pinze belle grosse :-); Detto questo, immaginate di avere il vostro bel dominio siffatto: Il resto per ora è poco importante, il capo dice che in DDD non è buona cosa esporre la Primary Key perchè non è cosa pertinente al dominio ma è un problema dello storage, sono pienamente d’accordo ma è altrettanto vero che è pur sempre un gran comodo averla li...
…sembra una parolaccia, e per molti versi ritengo che lo sia, ma andiamo con ordine: diciamo che avete il vostro “bel” dominio mappato con il fido Linq to Sql e siete decisamente felici di come funzionano le cose, nonostante gli evidenti limiti di L2S, ma ad un certo punto succede che i requisiti vi impongono di integrare all’interno della vostra applicazione dati che arrivano da una sorgente dati diversa, nello specifico un preistorico database dbase (v.2), che ha il piccolo difetto di non supportare in alcun modo la multiutenza ergo il primo che arriva “locca”...
Alla UGI.Alt Conf ho “vinto” per aver fatto una Open Session una licenza di NH Proof. Complice una necessità mi stasera mi sono messo di buona lena e: Ho approcciato per la prima volta in vita mia NHibernate: Utilizzando Fluent Configuration; Linq 2 NHibernate; In pochi minuti ho prodotto la prima fetch un po’ complessa, almeno per me neofita di NHibernate: ...
Partiamo da questo semplice test: [TestMethod]
public void entity_set_property_normal_should_raise_propertyChanged_event()
{
var expected = 1;
var actual = 0;
var target = new MockEntity();
target.PropertyChanged += ( s, e ) => actual++;
target.FirstName = "Mauro";
actual.ShouldBeEqualTo( expected );
}
Proprio triviale, una semplice entità che implementa INotifyPropertyChanged, tipicamente l’implementazione della proprietà FirstName potrebbe essere una cosa del tipo:
public class Person : INotifyPropertyChanged
{
public event PropertyChangedEventHandler PropertyChanged;
protected virtual void OnPropertyChanged( String...
Una delle cose che gli utenti chiedono è di poter selezionare in blocco un set di dati e stamparli, un esempio banale è questa window per la ricerca di contratti in cui l’utente seleziona uno o più contratti e poi può pigiare il bottone stampa presente nella Quick Access Toolbar del Ribbon: Un po’ di pubblicità occulta a colui che mi fornisce i controlli: Divelements. il problema è che se il “report” che nasce da quella richiesta è di più di una pagina avete l’inghippo che la numerazione delle pagine viene sballata perchè il secondo item che...
Poco tempo fa ho parlato della funzionalità di Blend 3 che permette di avere dei dati di esempio a design time al fine di ottimizare proprio la design experience, subito dopo Corrado ha parlato di qualcosa di ancora più figoso. Purtroppo siamo alle solite: non è tutto oro quel che luccica. Se avete un ViewModel, o più in generale un DataContext, un po’ complesso la soluzione di Corrado purtroppo non funziona. Per un po’ complesso intendo che basta banalmente esporre dalla classe, che verrà utilizzata come DataContext, un tipo generico e siete “fritti” perchè lo xaml non ha...
Nel post di ieri ho detto che mi piace molto utilizzare le enumerazioni (System.Enum) nei miei ViewModel, le enumerazioni sono un gran comode in quanto fortemente tipizzate, giustamente Matteo però nei commenti chiede: Domanda: se tutte le proprietà ed i dati devono essere localizzabili gli enum sono ancora cosi necessari? In generale la risposta è si, vediamo nel dettaglio cosa faccio. Ecco come definisco una enumerazione: public enum AdvertisementInvoiceCadence
{
None = 0,
[EnumItemDescription( "Immediata", "La fattura verrà emessa immediatamente...
Quando prendete confidenza con Wpf scoprite che, tra le tante cose, i template, gli stili e i trigger sono la manna dal cielo. Quando però approcciate lo sviluppo di un’applicazione complessa, che magari vuole anche usare M-V-VM, anche mettendoci tutta la buona volontà scoprite che il design della UI diventa una delle attività più onerose e time consuming nel ciclo di sviluppo. Il motivo è presto detto: Se usate come designer Visual Studio (aka Cider) avete l’inghippo che: Definirlo stabile è difficile ;-) ...
Un bel po’ di carne al fuoco già nel titolo, quindi preparatevi ;-) Scenario Diciamo che il vostro cliente è un giornale, e che su quel giornale ci finiscano casualmente delle pubblicità, e che sempre casualmente voi stiate realizzando per quel giornale un gestionale ad uso interno :-). Tralasciando tutto il processo diciamo che avete in mano una cosa che potremmo chiamare “Impegnato” che è una lista di potenziali pubblicità che dovrebbero finire su una certa uscita, potenziali e dovrebbero perchè per tutta una serie di buoni motivi la redazione/direzione/grafica potrebbero dedicere di apportare modifiche dell’ultima ora che...
Non sono mai stato un “test addicted” nel senso che non scrivo i test per tutto, scrivo i test per molte cose (ed in alcuni casi tendo maniacalmente ad un 100% di Code Coverage), alcune le faccio in TDD, e per altre ritengo semplicemente inutile scrivere test, se non a fronte di un bug dove allora prima scrivo il test, e se assenti, un set di test che mi parino da eventuali regressioni, che lo riproduce poi procedo con la fix. Credo di avere una minima esperienza da garantirmi un buon deisgn anche se non è emergente, ne è...
Qualche giorno fa ho parlato di db4o dal punto di vista dello sviluppatore, devo dire che nell’insieme ho trovato molto interessante il tutto e sto seguendo il feed del team di sviluppo. Ci sono interessanti novità per quel che riguarda il supporto a linq/IQueryable<T> il che non è niente male, inoltre con la versione 7.10, ancora in beta, viene distribuito gratuitamente anche il db4o ObjectManager (una sorta di Enterprise Manager per db4o) la cosa interessante è che questa versione: ha funzionato al primo colpo, a differenza del predecessore; è un add-in che...
I vari flavour del DataContext offrono la possibilità di agganciare un “logger” per vedere ad esempio le query prodotte, ad esempio con Linq2Sql avete una cosa del tipo: using( var dc = new MyDataContext() )
{
dc.Log = Console.Out;}
Questo, se avete un debugger attaccato, o siete in un’applicazione Console, scrive sulla Console (Output Window per il debugger) i messaggi di Log del DataContext, tra cui tutte le query T-Sql con i parametri etc etc…
Adesso supponiamo che vogliate scrivere quel log su un vostro sistema di Log, sia esso log4net, come nel mio caso, o...
Workflow 4.0 –> Flowchart –> Hosting nelle nostre applicazioni –> Spettacolo :-) .m
Ieri ho parlato di Log4PostSharp come ottimo compagno di viaggio per la scrittura del tracing. Un paio di note per districarsi meglio nella giungla. Magagna… Se scaricate Log4PostSharp e cercate di usarlo non va, vi beccate un simpatico errore di compilazione… per qualche strano motivo l’autore ha compilato i suoi assembly utilizzando una reference ad una versione specifica di PostSharp, la 1.0, mentre tipicamente voi potreste avere la 1.0sp1. Nulla di grave: Scaricatevi i sorgenti dal repository svn di Google (io uso RapidSVN) Aprite la solution; ...
Un paio di assiomi ;-): Il Tracing è necessario; Il Tracing è di una noia mortale; Però… ci sono due macro categorie di Tracing in realtà, io divido tra: Tracing: quello che fa il codice: il metodo tal dei tali è stato invocato con la lista di parametrei xyz; Logging: quello che fa l’utente: l’utente ‘mauro’ alla tal ora del tal giorno ha salvato la tal anagrafica cliente; Quello che più mi pesa è la prima categoria, facendo...
Io sinceramente ogni tanto mi pento di essere così “goloso” di conoscenza… perchè già il nostro lavoro è, se vogliamo, una fonte infinita di possibilità se poi ci mettiamo ad ascoltare le pulci nell’orecchio allora siamo proprio rovinati. In viaggio verso Predappio per il workshop UGIdotNet il capo butta li una frase del tipo: Mi chiedo come mai i database ad oggetti non prendano piede. (citazione molto vaga ma la memoria alla mia età ormai fa acqua…). Quindi… è domenica mattina presto, l’ufficio è aperto, c’è una giornata meravigliosa e la dolce metà è ancora a pelle d’orso...
Una “mailing list” spontanea tra svariati partecipanti mi porta verso questo post. Il problema è la validazione dell’input dell’utente, vediamo da dove sono partito: La situazione è decisamente banale, classicissima Window (Wpf) per l’editing di una Entity (Person), il tutto basato strettamente su M-V-VM, quindi è un “requisito” che nel code-behind della Window non ci finisca nulla, o xaml o ViewModel. Il problema è la vadilazione dell’input, diamo un paio di regole di business che “incriccano” la cosa: Rule A: Person.FirstName non deve essere vuoto; Rule B: Person.LastName non deve...
Nulla di tecnico stavolta solo un esempio di quello che si può fare, non tanto graficamente perchè sono una mezza-ciofeca, quanto in termini di UX; abbiamo parlato di Loading Adorner, con lo scopo di migliorare l’esperienza dell’utente durante l’uso della nostra applicazione. Naturalmente non basta, uffa…, l’utente si aspetta anche altre cose (sempre in termini di operazioni asincrone): La possibilità di annullare l’operazione in corso; Feedback sullo stato d’esecuzione/avanzamento dell’operazione; Entrambe le cose non è detto che siano di facile soluzione, analizziamole una alla volta: Annullamento dell’operazione...
… e ci complichiamo la vita reinventando la ruota. La gestione dei settings di un’applicazione VisualStudio ci mette a disposizione un’infrastruttura eccelsa per la gestione dei settings, che va mostruosamente oltre il mero file “ini”, non foss’altro perchè, ad esempio: è fortemente tipizzata; è “a gratis” user o application scoped; offre un designer integrato nell’ambiete di sviluppo, con tutto quello che questo comporta, come ad esempio il pieno supporto per il refactoring… che è tutto tranne che poco ;-) Quello che succede però è che appena...
Che bel mix… sta di fatto che Wpf non ha, tra le tante cose di cui si sente la mancanza, una ForlderBrowserDialog, niente panico! Si può tranquillamente usare quella presente nell’assembly System.Windows.Forms.dll, o, con un po’ più di lavoro, quella nativa Win32; ma non è questo l’oggetto del post. Dopo avere referenziato l’assembly System.Windows.Forms.dll potete scrivere una cosa del tipo: String SelectFolderPath( String initialFolder )
{
using( var dialog = new System.Windows.Forms.FolderBrowserDialog() )
{
dialog.ShowNewFolderButton = true;
dialog.RootFolder =...
Il nuovo e fiammante Visual Studio 2010 Beta 1 ha partorito il primo progettino… e non poteva che essere un behavior per WPF. Ci sono ancora 2 cose, e probabilmente molte altre ;-), che l’utente è abituato ad avere in campi diversi ma per certi versi complementari: Interazione con l’(eco)sistema attraverso la tastiera: l’utente quando ad esempio esegue una ricerca è decisamente abituato a: inserire i criteri di ricerca, come ad esempio un elenco di keyword, all’interno di una TextBox; premere invio; e non a prendere il...
…è troppo nemica del compilatore e se in una giornata scrivete montagne di codice il rischio di scrivere minch*ate è alto, e in questo caso neanche gli Unit Test sono d’aiuto: namespace Topics.Runtime.ViewModel
{
using ...;
[Component( typeof( IEstimateWizardViewModel ), Lifestyle = Lifestyle.Transient )]
sealed class EstimateWizardViewModel : ViewModelBase<IEstimateWizardView>, IEstimateWizardViewModel
{
public static readonly DependencyProperty IsBusyProperty = DependencyProperty.Register(
"IsBusy",
...
Costruendo il mio CueBanner per WPF mi ero imbattuto in uno strano comportamento, mi auto quoto: Un adorner per poter essere visibile ha bisogno di un AdornerLayer in cui essere “ospitato”, ogni Window (non proprio…, ho un caso che sto cercando di debuggare in cui questo non succede…) ha implicitamente un AdornerLayer anche se non lo inseriamo noi nello xaml. Quel “caso” è la classica sindrome da “allergia al manuale delle istruzioni”, lo scenario era questo, era perchè adesso funziona: Controllo Ribbon, figosissimo, con in una Ribbontab la casella di...
Sempre in tema di UX ritengo fondamentale che un’applicazione Windows sia fortemente basata su multithreading perchè se c’è una cosa che mi da veramente fastidio è vedere l’applicazione freezata, con quel laconico (Not responding) nella barra del titolo, solo perchè l’operazione “lunga” viene eseguita nello stesso thread della UI. In effetti se dato uno sguardo al task manager scoprite cose interessanti: Un mondo multithreaded è sicuramente più difficile da dominare ma è anche vero che una segretaria incazz*ta è forse peggio di una suocera logorroica, inoltre se cerchiamo scopriamo che il framework .net ci mette...
Abbiamo parlato della possibilità di mettere in binding i SelectedItems della ListView di WPF con una nostra collection, altra cosa a cui abbiamo accennato è la mancanza, sulla ListView, di un ICommand per gestire il doppio click su un elemento della lista. Siccome abbiamo scoperto, almeno io ;-), la potenza delle attached properties facciamocelo. ItemDoubleClickCommand Partiamo come al solito dal risultato che vogliamo ottenere: <ListView local:ListViewManager.ItemDoubleClickCommand="{Binding Path=Select}" />
Molto semplice: poter dichiarare un nuovo Command e metterlo in binding con qualcosa che implementi l’interfaccia ICommand; per arrivare li, nell’ormai vecchio e familiare ListViewManager, cominciamo...
Questa cosa è una figata!, Raff ha la sua e io mi sono fatto, come Raff da tempo immemore (dal fx 1.1, poi con rimaneggiamenti vari nel tempo per adattarla alle nuove feature), la mia implementazione che a breve upgraderò a INotifyCollectionChanged e ICollectionView per stare al passo con i tempi. Ma torniamo alle cose importanti, uno dei dettami di M-V-VM è, o meglio sarebbe, quello di non esporre mai direttamente il Model alla View; ad esempio esporre una IList<Address> direttamente dal VM non è proprio il massimo, funziona ma ha qualche magagna fastidiosa. Sempre meglio avere uno strato...
per ora è solo un’idea che mi frulla per la testa ma… una cosa che si fa con M-V-VM è la necessità di triggerare la rivalutazione dell’eseguibilità di un ICommand a fronte del fatto che una certa cosa è successa, tipicamente un’altra proprietà del VM è cambiata; un esempio: Il comando “Browse” non è attivo se la casella di testo “Criteri di Ricerca” (in binding con la proprietà QueryText del VM) è vuota, quando la proprietà QueryText cambia dobbiamo triggerare la rivalutazione dell’eseguibilità dell’ICommand. Questo in termini di codice spesso si traduce in qualcose...
Una delle cose che “pretendo” è che la UX offerta sia consistente con quella dell’ecosistema che ospita l’applicazione, questo per un’applicazione Windows si traduce in moltissime cose, e moltissimo lavoro, tra cui ad esempio: Supporto per la navigazione/gestione comandi con la tastiera; Supporto per la gestione dei comandi tramite shortcut; Comunicazione con l’utente; Async, Async, Async (more to come…); Disposizione, aspetto e layout dei controlli consistente con quello del sistema; etc.. Tra queste...
Credo che alla lunga tutti ci siamo scontrati con la noisitàcomplessitàindigeribilità della gestione della configurazione del container per IoC. In una soluzione corposa, okkio non necessariamente complessa, basta e avanza corposa, è una vera menata. Si ci sono le fluent interfaces che ci fanno risparmare un sacco di “giornate di inferno”, che altrimenti ci guadagneremmo gestendo la configurazione su file xml, permettendoci di scrivere cose del tipo: container.Register( Component.For<IWindsorContainer, IServiceProvider>()
.Instance( container ) );
container.Register( Component.For<ModulesConfigurationSectionHandler>()
.FactoryMethod( this.container.Kernel, () =>
{
...
Un altro intermezzo, si lo so che ho promesso un’ultima puntata ma: Non ho tempo, ogni tanto lavoro :-); La soluzione che per ora ho adottato per la gestione della navigazione, oggetto dell’ultima puntata, non mi piace, funziona, funziona bene, ma non mi piace… è rumorosa. Facciamo invece un passo indierto: tempo fa abbiamo parlato di “message broker” per sopperire all’impossibilità di usare, in un’applicazione composita, i tradizionali eventi del mondo .net. Una cosa che tipicamente si fa in un’applicazione composita è iniettare contenuti visuali, e lo si...
Noto uno strano comportamento nel metodo Sort() della lista generica List<T>. Preambolo. Avete una classe del tipo: class Tupla
{
public Int32 Value { get; set; }
public String Description { get; set; }
}
ne avete n istanze in una lista e volete ordinare la lista in base al valore della proprietà Value, per farlo è necessario utilizzare un IComparer<T> custom, una cosa del tipo:
class TuplaComparer : IComparer<Tupla>
{
public int Compare( Tupla x, Tupla y )
{
...
In questi giorni sto facendo largo uso di TDD per implementare un sistema discretamente complesso di parsing/trasformazione di informazioni da un formato ad un altro: db –> Object Model –> DTO –> Flat text File. Un po’ di considerazioni live durante l’esperienza: Produttività Dobbiamo prima definire cosa intendiamo per produttività, se pensiamo a meri tempi di scrittura del codice, la sentenza è “bassa produttività”, se invece, come doveroso, ci mettiamo anche qualità del prodotto finito, le cose cambiano un filino, decisamente alta. Design Emergente Decisamente si, non è che sia molto da fare, devo ammettere...
ahahahrgh :-D L’astrazione ha tanti vantaggi ma porta anche tanti potenziali problemi soprattutto se la stiamo gestendo male o se stiamo astraendo troppo o addirittura dove proprio non serve. L’uso di un container per IoC tende a portare ad un uso esasperato dell’astrazione perchè si tende, all’inizio, ad astrarre anche il container stesso. L’inghippo è che probabilmente non abbiamo ben presente la differenza tra Dependency Injection e Inversion of Control, perchè se ne parla sempre insieme ma sono due mondo molto diversi tra loro dove il primo può vivere di vita propria mentre il secondo nasce anche per...
Mi chiedono: “…Se volessi creare una shell con il ribbon in alto e la possibilità di aggiungere schede al ribbon da parte dei singoli moduli, devo referenziare l'assembly del ribbon da ogni modulo? o c'è un modo più corretto e ordinato per fare le cose? Perchè sarebbe carino se potessi referenziare l'assembly del ribbon da un modulo Infrastruttura e poi da tutti i moduli poter caricare la parte di ribbon dedicata al modulo passando per l'infrastruttura…” Se ho ben capito, e qui liberi di smentirmi, la domanda potrebbe essere generalizzata in: ...
Prima di passare all’argomento centrale di questa lunga trattazione dobbiamo fare un piccolo escursus sul sistema di comunicazione interno all’applicazione. Messaging Il mondo .net ci ha abituato molto bene, gli eventi sono una vera manna dal cielo, ma purtroppo nel nostro caso servono veramente a poco. Facciamo un esempio chiarificatore: Avete 2 oggetti che devono comunicare tra loro, e per l’esattezza, l’oggetto A deve sapere quando succede qualcosa all’oggetto B. Tradizionalmente fareste: Esporre a B un evento; Aggiungere un handler a B.Event da A;...
Scoperto come scoprire quali sono i moduli installati non ci resta che caricarli… fosse semplice ;-) La prima cosa che dobbiamo fare è trovare un sistema per collegare un IModuleDescriptor ad un modulo, dato che le informazioni presenti in un ModuleDescriptor arrivano da un file di configurazione non abbiamo gratis nessun “ponte” tra i 2 mondi: la descrizione di un modulo e il modulo stesso. Quello che possiamo banalmente fare, e che faremo, è aggiungere alcune informazioni al sistema di configurazione, in realtà scopriamo che ci basta aggiungere al file di configurazione un valore che ci dica quale...
La nostra applicazione non fa ancora nulla ma almeno si avvia. Il prossimo passo è quello di realizzare un’infrastruttura per gestire i moduli, in particolare in questa fase ci concentreremo sul processo di discovery. Quali sono i problemi che dobbiamo risolvere: Discovery: il processo di discovery è quello che consente all’IApplicationBootstrapper di capire quali siano i moduli che possono essere caricati, quello che ci dobbiamo limitare a fare è quindi fornire allo strato superiore l’elencodeii moduli disponibili, non è onere nostro fare nessun ragionamento; A questo punto possiamo avere 3 potenziali...
Here we are, lets go deeper! Concentriamo in questo post i primi 2 argomenti: L’organizzazione della solution in Visual Studio, e i problemi che ci dobbiamo portare a casa; La Shell: lo scheletro della nostra infrastruttura; Visual Studio: how to… L’organizzazione della solution in VS è fondamentale per non impazzire durante lo sviluppo e per supportare sia i vostri requisiti sia l’infrastruttura di IoC; quest’ultima è quella che rende particolarmente critica la struttura della solution: Dogma: un framework non deve dipendere da un IoC container; ...
Continuiamo… Siamo ancora ad un livello introduttivo, cerchiamo di capire quali sono le problematiche tecniche che dovremo affrontare e perchè. Dogma: Diamoci delle regole e rispettiamole. Nello sviluppo di applicazioni complesse, e comunque in generale nell’applicazione di un pattern, non abbiamo nessun supporto dall’ambiente di sviluppo, questo significa, ad esempio, che il compilatore (san csc.exe :-D) non ci aiuta in nessun modo segnalandoci che stiamo facendo una certa cosa nel modo sbagliato. Abbiamo quindi bisogno di capire quali sono i problemi, trovare una soluzione che ci permetta di rispettare i requisiti e poi non...
Immaginiamo uno scenario in cui sia necessario soddisfare i seguenti requisiti: Deve essere possibile scomporre l’applicazione in moduli funzionali: I moduli funzionali devono essere independenti l’uno dall’altro; I mdouli funzionali possono avere delle dipendenze logiche tra loro ma l’assenza di una dipendenza non deve precludere il funzionamento dell’applicazione o del modulo stesso; I moduli funzionali devono poter essere rimpiazzati/aggiunti a caldo; ...
All’ultimo agile day ho sentito più volte l’affermazione che il Code Coverage, che è la percentuale di codice coperta dagli Unit Test, non è necessariamente un’indicazione che i test siano dei buoni test. In linea di massima questa affermazione mi trova complessivamente d’accordo. Essendo il Code Coverage il risultato di un’analisi statica non ha necessariamente significato qualitativo.
Ritengo però che il Code Coverage dia comunque informazioni utilissime, non è tanto la percentuale di copertura che ritengo importante, annche se mi piace tendere al 100%, quanto il fatto che ad esempio a volte il Code Coverage di Visual Studio si comporta in...
Detto fatto :-D
Pochissimo tempo fa ho fatto una lunga digressione su Model-View-ViewModel calato in applicazione complessa dove la complessità risiede principalmente lato presentation.
Una delle necessità è quella di mantenere la separazione tra i vari ViewModel al fine di consentire agili refactoring dell’interfaccia utente e volendo anche molto altro. L’inghippo purtroppo è che i ViewModel in qualche modo devono comunicare tra di loro, l’esempio potrebbe essere:
finestra principale, la Shell (terminologia presa in prestito da PRISM), che ospita 2 “region”:
Region 1: user control per la ricerca/visualizzazione...
Era un po’ di tempo che non mi divertivo così tanto a fare questo lavoro! Da un mesetto a questa parte sto lavorando ad un nuovo progetto che è nato quasi per caso. In dicembre IL mio cliente storico si presenta e mi dice che avrebbero bisogno di una semplice applicazione per fare l’inventario di una delle loro attività al pubblico. L’obiettivo è quello di avere uno strumento snello e semplice che permetta ad n operatori di lavorare insieme e funzioni senza fronzoli e soprattutto senza problemi dato che il tempo stimato per l’inventario è di 72h...
ClickOnce, per certe cose, è una tecnologia fantastica, se però siete in un ambiente un po’ complesso e avete i classici ambienti di Sviluppo, Test, Produzione e chi più ne ha più ne metta scoprite che Visual Studio non digerisce questa cosa neanche a spingere… Ci sono un po’ di soluzioni con pregi e difetti, partiamo da Visual Studio e poi vediamo come affronta la cosa ClickOnce. La situazione classica è la necessità di avere file di configurazione diversi per ambiente diverso, classicamente ad esempio cambia la connection string al db, quello che possiamo fare è: ...
Oggi sono incappato in uno stranissimo comportamento che non mi spiegavo… stavo scrivendo degli unit test di una collection custom scroccando la classe GenericParameterHelper che è li apposta per quello… e ho scritto una cosa del tipo: [TestMethod] public void entityCollection_remove_a_reference_not_in_the_collection_should_return_false() { var target = this.CreateMock<GenericParameterHelper>(); target.Add( new GenericParameterHelper() ); target.Add( new GenericParameterHelper() ); target.Add( new GenericParameterHelper() ); var actual = target.Remove( new GenericParameterHelper() ); actual.ShouldBeFalse();...
Ok… predo spunto dal commento di Davide per approfondire la questione IQueryProvider e cercare di capire quali sono le difficoltà vere, o almeno quelle che ho scoperto io fino ad ora, nella realizzazione di un query provider per Linq.
Innanzitutto sottolineo che non mi sto cimentando nell’impresa, non per ora…, sto “semplicemente” cercando di capire come funziona. Come Roby sono curioso(issimo) per natura, devo smontare e rimontere tutto quello che mi passa per le mani e se non capisco mi intestardisco fino ad arrivare alla soluzione.
Vediamo innanzitutto da dove si parte. Questo snippet, preso dagli unit test, espone lo scenario:
String...
Prendo spunto da un post di Mario per allargare la discussione e dire la mia in un contesto più comodo, i commenti purtroppo non sono comodi e non abbiamo più un forum, speriamo che torni presto perchè sarebbe stato il posto ideale. Disclaimer: Quando parliamo di architettura ci possiamo mettere su due livelli: Architettura fine a se stessa: inteso come la soluzione ideale in un mondo ideale; Architettura calata nel contesto: la soluzione ideale con tutti i constraint del caso derivanti dal mondo che sto vivendo in quel momento,...
…ho iniziato a dare il primo sguardo serio a WPF e coadiuvato da un paio di mail scambiate con Corrado sto realizzando un piccolo, veramente piccolo, concept. Per ora ho scalfito la superficie del motore di binding e dei template, ci sono rimasto male. Sto facendo cose che se penso di fare con Windows Forms… meglio che non lo dica :-D .m
Il framework 4.0 “is on the way”, c’è ancora molta strada da fare ma se non altro la via è stata imboccata; cominciano a girare un po’ di documenti sulle novità che verranno introdotte con il nuovo runtime e i cominciano anche a sprecarsi i post su “dynamic”, sui valori di default per i parametri etc… evito che è meglio ;-) E’ ovvio che rivoluzioni come Linq si vedono una volta nella vita quindi secondo me non ha senso lamentarsi dell’apparente veste poco rivoluzionaria del nuovo framework, se però scaviamo a fondo, sotto sotto ci sono tante belle cose…...
Si sa sono un fun di Castle Windsor e in generale del mondo IoC, una cosa però veramente tediosa, prona ad errori, scomoda e decisamente ingombrante dei framework di Inversion of Control è la gestione del file di configurazione, soprattutto se usate massicciamente i generics. Questo perchè per gestire una situazione, decisamente triviale, come la seguente: public interface IMyComponent<T>
where T : IDispatcher
{
}
public interface IDispatcher
{
void Say( String msg );
}
class MyComponent : IMyComponent<IDispatcher>
{
public MyComponent( IDispatcher dispatcher )
{
dispatcher.Say(...
Se vado avanti così potrei diventare PostSharp addicted… già sono compiler addicted conclamato, sono sulla buona strada per diventare Unit Testing addicted e dopo aver provato la compile time validation di PostSharp posso asserire che si sta chiudendo il cerchio. Un paio di giorni fa abbiamo visto come usare PostSharp per validare a runtime i parametri di un metodo (per inciso funziona anche con i costruttori) facendo semplicemente una cosa del genere: class MyTestClass
{
public void Foo( [NotNull]String arg )
{
Console.WriteLine( "Foo( String ):...
Mi riallaccio al post di ieri per fare una precisazione, faccio un nuovo post perchè fare un update dell’altro è pressochè impossibile… sopportatemi ;-) Ieri ho detto che: “…quello che però non ha fatto è stato rimettere sul parametro del metodo privato l’attributo, e questo credo sia un bug, vedremo…;” Riferendomi a questa situazione: [ArgumentValidatorAspect()]
class MyTestClass
{
public void Foo( [NotNull]String arg )
{
Console.WriteLine( "Foo:" + arg );
}
}
e compilando il risultato che otteniamo, visto con il fido Reflector, è questo:
...
è da un po’ di tempo che mi riprometto di fare delle prove e capire come funziona il gioiellino. Diciamo che sono partito con una necessità decisamente triviale ma che illustra bene le potenzialità della cosa. Lo scopo è far funzionare questo codice: class MyTestClass
{
public void Foo( [NotNull]String arg )
{
Console.WriteLine( "Foo:" + arg );
}
}
e fare in modo di ottenere una ArgumentNullException( ‘arg’ ) se il metodo Foo() viene invocato così:
MyTestClass obj = new MyTestClass();
obj.Foo( null );
Nello specifico NotNullAttribute...
Forse non tutti sanno che… :-D, bello iniziare così. Sappiamo tutti cosa sono gli eventi e come utilizzarli/gestirli, abbiamo il sistema tradizionale (quasi legacy oserei dire ;-)): WithEvent we = new WithEvent();
we.SomethingOccurred += new EventHandler( OnSomethingOccurred );
In cui agganciamo esplicitamente un delegate, che punta ad un nostro metodo, all’evento esposto da una classe.
Abbiamo poi altri due sistemi, il secondo evoluzione del primo, che sono decisamente più smart:
WithEvent we = new WithEvent();
we.SomethingOccurred += delegate( object sender, EventArgs e )
{
//Do something...
};
possiamo infatti utilizzare gli anonymous methods per agganciare direttamente un...
Qualche giorno fa ho avuto modo di (s)parlare di come poter implementare IEnlistmentNotification in una propria classe di business al fine di realizzare un resource manager che sia utilizzabile all’interno di un TransactionScope. Quello che però ho dato per scontato è che si sappia come funziona il giochino. Ho già avuto modo di parlarne ampiamente in un articolo per MSDN ma alcuni dettagli forse mancano ed è giusto riprenderli qui, partiamo da questo snippet: using( TransactionScope scope = new TransactionScope() ) { ...
al fine di fare un po’ di esperimenti sto usando il “nuovo” (si fa per dire) SqlCe 3.5 SP1 (o come diavolo si chiama… ;-)) ma sono incappato in un fastidioso comportamento che non è semplice da aggirare. Se cercate di racchiudere una serie di “SqlCeCommand” in un blocco “TransactionScope” vi beccate una sonora Exception che vi informa che “The Connection object cannot be enlisted in the Transaction”… il motivo è molto semplice SqlCe non supporta le transazioni distribuite (nella versione precedente 3.1 non c’era neppure nessun supporto per System.Transactions, quindi non lamentiamoci troppo) quindi...
Dunque, supponiamo di avere il seguente stralcio di codice:
IChangeTrackingServiceContainer container = ChangeTrackingServiceContainer.GetProvider();
IChangeTrackingService tracking = container.CreateTrackingService();
DataContextProcess dataContext = new DataContextProcess();
IEntityCollection<IPerson> allPersons = dataContext.GetAll<IPerson>();
IPerson first = allPersons.Where( p => p.LastName == "Servienti" ).First();
first.FirstName = "Mauro";
if( tracking.IsChanged )
{
IEnumerable<IAdvisedAction> advisory = tracking.GetAdvisory();
dataContext.Commit( advisory );
tracking.AcceptChanges();
}
Nulla di trascendentale… ma come molti di voi sapranno, se avete mai dato un occhio a NSK o vi siete mai cimentati nella realizzazione di una Unit of Work, quello che ci si aspetta è che il lavoro fatto dal metodo Commit() del data context sia come...
Avete mai pensato di sfruttare Visual Studio come piattaforma di sviluppo oltre che come fantastico ambiente RAD e non? A caldo la prima cosa che mi verrebbe da rispondere se qualcuno me lo chiedesse è: “lascia perdere…è un delirio ;-)”. Se però siete come me e vi intestardite sulle cose che non capite fino in fondo allora forse potremmo darci man forte analizzando insieme pro e contro di un task che non è certo semplice: Sviluppo di un VSPackage. Cercheremo di sviscerare i passi da seguire per arrivare a costruire un proprio Project System...
Mi collego ad un post di ieri di Luka perchè uno dei punti elencati mi ha fatto pensare e vorrei riportare la mia esperienza di questo periodo. “…L'unico modo di provare cose nuove è farlo di nascosto dal cliente, dai colleghi e dalla azienda per cui lavoro. Poi se ne risponde ... gioie e dolori…” Il cliente che sto seguendo in questo periodo direi che può essere classificato, per tutta una serie di motivi che non mi interessa elencare, tra i clienti difficili, in cui il rapporto è complesso e a volte fatto di...
In un'altro post di qualche giorno fa mi è stato chiesto di approfondire alcuni concetti. Partiamo dal primo: IServiceContainer. Come forse avrete capito sono leggermente ossessionato dal problema delle dipendenze e siccome in moltissimi casi liberarsene costa veramente poco faccio sempre il possibile per farlo. Nello specifico in questo periodo stiamo facendo uso massiccio di Castle Windsor come motore di Inversion of Control ma la mia ossessione mi dice che non è bello dipendere da Castle perchè domani mattina potremmo volerci mettere Sping.NET o Unity... quindi?!?! Molto semplicemente astraimo l'uso che facciamo di Castle mascherandolo. In questo...
Oggi sono blogorroico :-D, e quindi ci metto anche il terzo... se poi "il quattro vien da se" be allora siamo proprio alla frutta... In questo caso parliamo di qualcosa che è ancora in una versione più che embrionale... è quasi tutto ancora nella mia testa... o meglio ben dettagliato sul fido OneNote. Il problema è questo: IMyEntity entity = whatEverDataProvider.GetMyEntity(); IMyCollection list = entity.Children; Int32 count = list.Count; if( count > 100 ) { ...
...lungi da me ;-), ma... ebbene si secondo me c'è sempre un ma. In questo periodo, decisamente massacrante, stiamo lavorando ad una soluzione potenzialmente abbastanza complessa e potenzialmente molto distribuita ;-) quindi uno dei problemi è che abbiamo n tier che vengono coinvolti dal ciclo di vita di una entity o da una operazione di business; e questo mi fa sempre dire che ogni tier/layer è storia a se, non sa nulla di chi sta prima e sa molto poco di chi sta dopo... e se assieme a questo assioma ci mettiamo che il dato è sacro (meglio un...
... e non viceversa. Con questo intendo dire che il modello ad oggetti che utilizziamo non dovrebbe essere mai modellato, in nessuna delle sue parti, pensando al fatto che quello specifico modello ad oggetti dovrà essere mappato su di un modello relazionale. Perchè dico questo? perchè spesso vedo, o semplicemente sento, che questo concetto viene in alcuni casi "dimenticato" a favore della semplicità (ma è poi vera questa semplicità o è solo apparente?) di implementazione della relazione tra i due mondi. Ma andiamo con ordine, ieri "chiaccherando" di architettura con il collega Marco, sono stato simpaticamente tacciato di...