.Net 3.0
Costanti pubbliche? AHIAHIAHI

Premessa: ciò che scriverò è una banalità, ma secondo me in tanti non ne sono al corrente o non ci pensano. Di cosa parlo? Di cose del genere:

public const int MyConst = 10;

Il danno potenziale che le costanti pubbliche possono creare alla stabilità delle nostre applicazioni è enorme.

Why? Perché le costanti non sono altro che placeholder risolti in fase di compilazione. Questo vuol dire che, finché non si ricompila, il valore non viene aggiornato.

Implicazioni?

  1. Assembly A che definisce una costante MyConst = 10
  2. Assembly B che referenzia Assembly A e ne utilizza MyConst
  3. Assembly A cambia MyConst a 15
  4. Finché non ricompilo Assembly B, questo continua a vedere MyConst = 10

Ogni tanto mi capita di trovare righe di codice simili a quella in alto, con seguenti bug "strani" e dolori per scovarli. Ecco perché cerco sempre di abituare i junior che lavorano con me alla regola:

Le costanti devono essere sempre private o internal. Se serve esporle allora si utilizzino dei field readonly.

Augh!

Technorati tags: ,
WCF, DTO, Fatture e RapportinoMaker (TM)

Volevo lasciare un commento al post di Igor, poi ne è venuto fuori un papiro e allora è meglio scrivere qui.

A mio modo di vedere, c'è un errore di fondo nel concetto di DTO espresso in quel post. Un DTO, infatti, *NON* deve né ereditare, né incapsulare l'oggetto che rappresenta; anzi... dirò di più: un DTO non deve avere alcuna relazione con l'entità (o le entità) di dominio che rappresenta, altrimenti non sarebbe un DTO!!

Cerco di spiegare meglio il concetto. Perché creo ed espongo un DTO? Una delle ragioni può essere che non voglio/posso esporre direttamente una mia entity di dominio. E allora che senso ha creare un DTO che la incapsula? o da cui eredita? Finirei comunque per esporla, no?

In realtà, il DTO ha un significato più ampio: è semplicemente un modo per codificare un particolare messaggio rappresentandolo in forma di oggetto, e non necessariamente è mappato 1-1 con le entità di un domain model (diciamo pure che in generale, ha decisamente poco a che vedere con esse).

Nel caso di Igor, volendo creare un DTO per l'oggetto Fattura, probabilmente realizzerei qualcosa del genere:

1 [DataContract] 2 public class FatturaDTO 3 { 4 [DataMember] 5 public string Numero; 6 [DataMember] 7 public DateTime Data; 8 [DataMember] 9 public string RagioneSocialeCliente 10 ... 11 }

(notare la proprietà RagioneSocialeCliente), magari con un costruttore che accetti un'istanza di "Fattura" e popoli i relativi field. Le stringone XML di questo esempio di Igor sono anch'esse dei DTO, magari in senso lato (ma neanche troppo).

BTW, sicuramente si tratta di un approccio dispendioso, che personalmente adotterei solo se ho vincoli che mi impongono una SOA rigorosa. Mi capita spesso, nel lavoro di tutti i giorni, di dover esporre servizi a client Java o PL/SQL, o magari di esporli e basta, senza sapere chi mai li invocherà, con in mano solo un documento di specifiche di forma da rispettare. E in quel caso allora è necessario specificare un insieme di messaggi che standardizzino il protocollo di comunicazione con i miei servizi e che restino immutabili anche a seguito di eventuali modifiche che un giorno farò al mio domain model. I DTO, per l'appunto.

Molto spesso però - e questo mi sembra proprio il caso di Igor - la reale necessità non è quella di esporre servizi a terze parti, ma semplicemente quella di avere un'applicazione distribuita, pur mantenendo stretto controllo di ciò che è in esecuzione sul client e sul server. Per dirla in parole povere, me ne frego dell'interoperabilità e non espongo nulla a nessuno, voglio solo avere la possibilità di interfacciarmi da remoto con una parte della mia applicazione.

Ottimo. Beh, in questi casi non vedo controindicazioni ad utilizzare direttamente le entity del domain model, se possibile. Dirò di più, magari voglio avere gli stessi tipi di oggetti sia sul client che sul server. Di SOA non ha neanche la più lontana parvenza, ma chi se ne frega? non mi serve avere un'architettura orientata ai servizi.

Allora, in uno scenario simile può essere utile anche questo tip.
http://blogs.ugidotnet.org/Crad/archive/2007/04/02/74468.aspx

Ah... last but not least: invece che con DataContract, i servizi WCF funzionano benone anche con entity marcate semplicemente come Serializable. smile_wink

 

Technorati tags: , ,
5 Comments Filed Under [ Architettura .Net 3.0 ]
[WCF] Condividere la medesima class library tra server e client

Windows Communication Foundation permette, in maniera estremamente semplice, di utilizzare tipi complessi sia come parametri di un servizio che come valori di ritorno: basta che essi siano marcati o con l'attributo DataContract o Serializable:

[DataContract] public class MyClass { // codice.... } [ServiceContract] public interface IMyService { [OperationContract] string MyMethod(MyClass parameter); }

Il comportamento di default di svcutil.exe, in fase di generazione del proxy per l'accesso al servizio da parte del client, è quello di creare una classe omonima di MyClass e con i medesimi membri pubblici. Nel caso in cui MyClass sia definita in un assembly referenziato sia dal service che dal client, è tuttavia possibile fare in modo che entrambi questi attori condividano lo stesso tipo, utilizzando il parametro /reference (o la sua versione breve /r) di svcutil.exe. Supponendo che il nome dell'assembly in questione sia CommonTypes, ad esempio, possiamo scrivere:

svcutil.exe /out:"MyServiceClient.cs" /language:csharp "http://serviceUrl/service.svc" /r:"CommonTypes.dll"

Technorati tags: ,
One Comment Filed Under [ .Net 3.0 ]
[WCF] Attenzione alle Using

In Windows Communication Foundation, il proxy creato da svcutil eredita dalla classe ClientBase<T>, che a sua volta implementa l'interfaccia IDisposable. Conseguenza di questo fatto è che viene naturale invocare il nostro bel servizio scrivendo:

using (MyServiceClient client = new MyServiceClient()) { // more code goes here... }

Ma se l'invocazione genera un errore, cosa accade? L'utilizzo del blocco using ci garantisce che venga chiamato il metodo Dispose() di MyServiceClient, che, Reflector alla mano, non fa altro che invocarne il metodo Close().

Attenzione però all'eccezione rilanciata se lo stato del client è Faulted (accade ogni volta che si verifica un errore non recuperabile, ad es. il server ha chiuso la connessione): in questo caso, infatti, al posto di Close andrebbe invocato il metodo Abort. L'uso di Close determina il sollevarsi di una CommunicationObjectFaultedException che oscura completamente l'errore verificatosi all'interno del blocco using.

Per ovviare a questo problema, ho costruito una classe helper che chiude il client in maniera un po' più furba:

public class SafeClose: IDisposable { private ICommunicationObject communicationObject; public SafeClose(ICommunicationObject co) { communicationObject = co; } public void Dispose() { try { if (communicationObject.State != CommunicationState.Faulted) communicationObject.Close(); } catch { communicationObject.Abort(); } } }

La sintassi di utilizzo è solo di poco più prolissa:

MyServiceClient client; using (new SafeClose(client = new MyServiceClient())) { Console.WriteLine(client.MyMethod()); }

HTH.

Ciao smile_wink

Add Comment Filed Under [ .Net 3.0 ]
[WCF] Problemi con l'hosting su IIS

Altro tip su WCF (giuro, è in buona fede, non partecipo a Community Credit, ehhehe!!)

Una volta effettuato il deploy di un servizio WCF su IIS, ho purtroppo constatato che il file .svc veniva fornito in output come semplice plain text. Occhiata al metabase di IIS e, sorpresa... non era presente alcun binding tra questa estensione e ASP.NET.

La causa è da ricercarsi in un bug dei primi installer di .NET 3.0 che creavano dei problemi alla configurazione di IIS. Per risolverli è sufficiente digitare, da prompt dei comandi,

"%windir%\Microsoft.NET\Framework\v3.0\Windows Communication Foundation\ServiceModelReg.exe" /s:W3SVC

Maggiori dettagli in questo post.

HTH.

Add Comment Filed Under [ .Net 3.0 ]
[WCF] Non vi funziona l'intellisense nell'app.config?

Anche con le VS2005 Extension for WCF e WPF installate, può capitare che Visual Studio non mostri correttamente l'intellisense degli elementi di configurazione relativi a Windows Communication Foundation.

Come risolvere? Se avete un luminare come Fabio Cozzolino tra i contact di MSN è un gioco da ragazzi, basta chiedere a lui! :D

Altrimenti, eseguite nuovamente l'installazione delle estensioni, ma digitando

msiexec /i vsextwfx.msi WRC_INSTALLED_OVERRIDE=1

da riga di comando!

Add Comment Filed Under [ .Net 3.0 ]
Un aspetto che non mi piace di WCF

In questi giorni in azienda ho iniziato ad utilizzare Windows Communication Foundation piuttosto intensamente e mi sono fatto un'idea di massima (ancora MOOOLTO grossolana) su questa parte del .Net FX 3.0.

Mi piace parecchio il nuovo DataContractSerializer (AKA XmlFormatter), grazie al quale riusciamo ad avere oggetti lato client molto più simili alle controparti server side. Mi piace (ovviamente) la tanto decantata possibilità di creare servizi indipendenti dalla tecnologia utilizzata, anche se tutta da verificare nella pratica, mi piace il fatto che si possa personalizzare il formato dei messaggi scambiati tra client e server e che si possano creare metodi che lavorino direttamente su di essi, piuttosto che su oggetti a più alto livello.

Per il momento, c'è un solo aspetto che proprio non riesco a digerire, ossia il fatto che per usare WCF sia costretto a decorare le mie interfacce, metodi e classi con custom attributes, il che implica ricompilazione di codice e reference a System.ServiceModel un po' ovunque...

Nelle applicazioni che sviluppo qui in azienda, i servizi sono disaccoppiati dalla tecnologia utilizzata ed esposti tramite interfacce, il che mi consente di swappare tra WebService ASP.NET, WSE 3.0 o Remoting (in alcuni casi e con alcune ovvie limitazioni) agendo semplicemente sulla configurazione.

WCF, in questo contesto, mi crea qualche grana in più e credo che sarebbe stato molto più elegante specificare queste informazioni in un file esterno, in maniera quindi molto meno "invasima".

2 Comments Filed Under [ .Net 3.0 ]
Nuovo Yahoo Messenger in WPF!!

In questo post dicevo che, per ciò che ho avuto modo di vedere, non immagino la tipica applicazione gestionale realizzata in WPF. Questa nuova tecnologia, secondo me, ha ben altri scopi, dato che "non di soli gestionali vive il programmatore", no?

Ecco perché, a mio modo di vedere, forse il famoso Healthcare Prototype, che comunque ha lasciato tante bocche spalancate, è un esempio un po' fuorviante.

Chi invece credo beneficerà alla grande delle peculiarità di WPF e ci farà toccare con mano cosa vuol dire avere a disposizione una tale potenza e flessibilità per la UI sono i software di messaggistica, utilizzati dai 15enni e dai 50enni e che, per loro natura, traggono pieno profitto da un look più accattivante.

Tutto questo preambolo, per dire cosa? Beh, che Yahoo per prima, con il suo Messenger, ha voluto tastare il terreno e si avvia al rilascio di una versione interamente .NET 3.0 e WPF powered, con tanto di supporto alla Sidebar di Vista.

Se fate un giro sul sito ufficiale avrete la possibilità di guardare anche un filmato dimostrativo.

fonte: http://weblogs.asp.net/scottgu/archive/2007/01/07/next-generation-yahoo-messenger-built-with-wpf-and-net.aspx

One Comment Filed Under [ Misc .Net 3.0 ]
Prime impressioni su WPF

Durante le festività natalizie, ho avuto modo di papparmi un paio di centinaia di pagine del libro di Charles Petzold su WPF; per il momento, ho toccato pochissimo (quasi nulla) XAML, dato che la prima metà del libro non lo tratta. Questa scelta, che inizialmente mi aveva lasciato piuttosto perplesso, è in realtà completamente giustificata: XAML altri non è che un modo per serializzare una gerarchia di oggetti e quindi, alla fine dei conti, in WPF riveste comunque il ruolo di "accessorio ", per quanto di fondamentale importanza; morale della favola: per studiare l'architettura di WPF se ne può fare benissimo a meno, in compenso ho scritto tanto codice C# e ho iniziato ad esplorare un po' il modello a oggetti del nuovo framework.

L'impressione è quella di trovarsi davanti a qualcosa di mastodontico, sia per quanto riguarda potenzialità e flessibilità, che a livello di complessità: nonostante il mio background professionale si basi per un buon 80% sul mondo delle applicazioni windows, i primi test mi hanno lasciato piuttosto spaesato. Le gerarchie degli oggetti sono estremamente più profonde rispetto a quelle delle WinForms 2.0, ma quest'approccio, che denota uno sforzo architetturale non da poco, ha permesso di implementare nativamente funzionalità evolute delle quali chiunque si sia occupato in passato di applicazioni windows ha sentito la necessità almeno una volta.

DependencyProperties, AttachedProperties (trattate da Corrado rispettivamente qui e qui ) e soprattutto il nuovo modello di routing degli eventi sono un'autentica manna dal cielo e vi assicuro che, nonostante magari possano sembrare un qualcosa di "inedito" rispetto a ciò che era la programmazione windows in passato, dopo un po' non se ne riesce veramente a fare a meno e tornare a Winforms dà una sensazione un po' di "vecchio".

Da appassionato, insomma, sono veramente entusiasta, ma resto ancora perplesso circa la diffusione che questo framework potrà avere presso il grande pubblico. Secondo me le Windows Forms avranno ancora vita lunghissima, WPF è decisamente complesso e soprattutto differente da tutto ciò che si è visto in passato, con il risultato che il passaggio a questa tecnologia potrebbe risultare molto ma molto costoso. E' ancora un po' presto per tirare le somme, mancano ancora tool di sviluppo concreti e anche la libreria di controlli è un po' lacunosa (il DateTimePicker dov'è?), ma allo stato attuale non riesco proprio ad immaginare la piccola/media software house che decida di sviluppare il proprio gestionale in WPF, ne ritengo molto più plausibile un utilizzo, ad es., per la produzione di una presentazione multimediale o per un software semplice ma che necessiti di essere graficamente accattivante.

powered by IMHO 1.3

One Comment Filed Under [ .Net 3.0 ]
[Libro] Applications = Code + Markup

Dopo neanche una settimana dall'ordine (Amazon.co.uk tutta la vita, altro che shopping negli states), la mia simpatica postina ha lasciato nella cassetta delle lettere Applications = Code + Markup e questa sera ho dato una sbirciatina veloce al contenuto.

Ora, premetto che è assolutamente presto per dare un giudizio, dato che ho guardato l'indice, sfogliato il libro qua e là e letto un paio di pagine, ma...

  1. La copertina rigida rullezza, e ci troviamo davanti un gran bel tomo da un migliaio di pagine circa
  2. Mi sembra scritto in maniera piuttosto semplice e chiara, almeno da quel poco (facciamo pure quasi nulla) che ho letto
  3. L'han detto in tanti, lo ripeto anch'io: mi sembra assurdo che un libro su WPF sia praticamente privo di immagini
  4. L'impostazione non mi convince

Spiego meglio il punto 4: le circa 1000 pagine sono divise in due grosse sezioni, Code e Markup, come dice il titolo. In pratica, quindi, per tutta la prima metà del libro, scordatevi pure ogni forma di XAML, non se ne trova ombra. Ci sono, invece, centinaia di snippet di codice (ben spiegati, a quanto mi è sembrato) in cui l'applicazione è "disegnata" istanziando a mano ogni componente.

Viceversa, la seconda parte, pur essendo basata prevalentemente sul markup, presenta comunque un po' di esempi di code-behind (diciamo che siamo 75% XAML e 25% C#).

Che dire, ora come ora sono un po' perplesso, perché snippet chilometrici che costruiscono menu, button e textbox secondo me lasciano un il tempo che trovano: certo, è importante conoscere l'object model, ma alla fine non credo che nessuno disegnerà mai Form (pardon, Window smile_wink) in questo modo. Di buono c'è che il libro sembra coprire parecchi aspetti di WPF, dal data binding alla gestione degli eventi, passando per resources, brushes, ecc.ecc.ecc...

Staremo a vedere, tra qualche giorno inizio a papparmelo.

4 Comments Filed Under [ Libri .Net 3.0 ]