Bit a bit, si cresce sempre


Blog di un ingeformatico
Statistiche
  • Views Home Page: 489.509
  • Views Posts: 1.566.073
  • Views Gallerie: 738.815
  • n° Posts: 520
  • n° Commenti: 301
Ora e Data
Archivio Posts
Anno 2017

Anno 2016

Anno 2015

Anno 2014

Anno 2013

Anno 2012

Anno 2011

Anno 2010

Anno 2009

Anno 2008

Anno 2007

Anno 2006

Anno 2005

Recensione libro Programming Visual C# 2008: The Language (Microsoft Press)

In Microsoft Press esistono due autori che ad ogni uscita di una nuova versione di C# si presentano puntualmente con le loro guide aggiornate. Fortunatamente si dividono equamente le categorie di lettori. Il primo, John Sharp, si rivolge ai principianti con i suoi libri della serie “Passo per passo” (“Step by Step” nella versione originale). Il secondo, Donis Marshall (autore di questo testo) è invece rivolto a lettori un po’ più esperti, lettori che, idealmente, hanno già letto ed assimilato il primo testo.

Basta leggere iniziare a leggere questo libro per rendersene conto. Nel solo primo capitolo sono introdotti così tanti concetti da essere racchiusi in almeno una decina, se non di più, di capitoli del primo autore.

Questo tomo di oltre 700 pagine è organizzato in questo modo: in tutto sono 18 capitoli racchiusi in 5 parti, ovvero:

 

-          Core Language (3 capitoli)

-          Core Skills (5 capitoli)

-          More C# Language (4 capitoli)

-          Debugging (4 capitoli)

-          Advanced Features (2 capitoli)

 

I primi 8 capitoli, ovvero le prime due parti, sono quelle “obbligatorie”, da leggere e comprendere assolutamente, qualunque sia l’intenzione e lo scopo con cui ci si approccia al testo. Rappresentano anche il passpartout per i successivi capitoli dedicati ad argomenti più avanzati, e che necessitano delle basi esposte in queste prime due parti. Ci si accorge subito di come il lettore di riferimento sia una persona che già conosca perlomeno le basi, meglio se solide, di C#. Nel primo capitolo, infatti, ci sono esempi di codice non banali, che fanno uso di costrutti che in altri testi non fanno mostra di sé se non dalla seconda parte in poi, e soprattutto non vengono spiegati nel dettaglio. Questo a prima vista può creare sconcerto; non capita infatti spesso di trovare un esempio di “Hello, World” che faccia uso dei delegati.

 

Anche nel secondo e terzo capitolo, dove si introduce la programmazione ad oggetti, si percepisce l’originalità dell’approccio all’argomento da parte di questo autore. Magari i principianti assoluti faranno leggermente più fatica nella lettura (sempre rispetto ad altri libri analoghi), ma chi possiede già una discreta infarinatura potrà veramente passare al livello successivo nella padronanza del linguaggio.

Per chi proviene dalla precedente versione 2.0 di C#, l’autore sottolinea i costrutti e le novità della versione 3.0, così ci si può “tarare” nel caso, per motivi di lavoro, ci si trovi “costretti” ad utilizzare Visual Studio 2005 invece della versione 2008.

Ottimo il quarto capitolo dedicato a Visual Studio 2008. L’autore da’ (giustamente) grande importanza a questo ambiente di sviluppo, che verrà ripreso più volte (sia con schermate che spiegazioni) anche nei capitoli successivi, specialmente in quelli sul debugging.

 

Purtroppo tutto il codice segue uno stile di scrittura in cui l’autore pone la prima parentesi graffa aperta sulla stessa linea del costrutto (classe, metodo, ecc.) a cui si riferisce, e che io trovo molto meno leggibile rispetto allo stile di portarla a capo, come si trova in quasi tutti gli altri libri, MSDN compresa. Bisogna farci un po’ l’abitudine, non c’è altro da fare.

In secondo luogo anche i nomi delle classi e delle variabili aiutano poco la comprensione del codice nel suo insieme. Le classi, ad esempio, vengono spesso chiamate “ZClass”, “YClass” e così via, mentre la variabili “fielda”, “fieldb”, “fieldc” e così via, quindi senza far uso di un consigliabile camelCase.

All’inizio anche del più piccolo esempio di codice poi, l’autore piazza il suo nome come “namespace” (Donis.CSharpBook), e questo lo trovo una forma di arrogante ed inutile egocentrismo.

Inoltre non viene fatto uso del grassetto, e questo, specie quando ci si riferisce alle parole chiave del linguaggio, può dare adito a fraintendimenti (ad es. “new “ potrebbe essere sia la parola inglese “nuovo”, che la keyword di C#).

 

La 4a parte (More C# Language) si addentra in argomenti più specifici, e tutti e 4 i capitoli che ne fanno parte risultano abbastanza comprensibili e scritti con criterio. Si inizia dal capitolo 9 dedicato all’overloading degli operatori. Non è un capitolo lunghissimo (sole 24 pagine) ma vengono presi in considerazione praticamente tutti i possibili overload custom, con tanto di esempi. Una caratteristica dell’autore, presente non solo in questo capitolo ma anche negli altri, è che antepone la descrizione del codice all’esempio stesso. In parecchi altri libri invece accade il contrario, ovvero prima si mostrano gli esempi di codice (magari descrivendoli sommariamente prima) e poi li si descrive e commenta passo per passo in seguito. Qui accade l’inverso, e bisogna un attimo farci l’abitudine. Personalmente trovo più proficuo l’altro approccio, in quanto quasi sempre in questo libro sono dovuto poi ritornare indietro a rileggermi la descrizione dove aver “visto” il codice.

Si prosegue poi con i delegati e gli eventi nel capitolo 10 (30 pagine) e si ritorna ad occuparsi di LINQ nell’11esimo (22 pagine), soffermandosi in particola su LINQ to XML e to SQL. Per quanto riguarda la trattazione di LINQ, la considererei sufficiente; non approfonditissima (ma qui servirebbe un libro solo per questo argomento), ma superiore a quella presente in altri libri dedicati a C# 2008.

Chiude la parte il necessario capitolo sulle eccezioni (28 pag.), anche questo non vastissimo, ma l’argomento verrà ripreso più avanti in una intera parte ad esse dedicata.

 

Essendo l’autore particolarmente ferrato nel debug delle applicazioni (la sua azienda si chiama proprio “DebugLive”), tutta la quarta parte è dedicata a questo argomento.

Si inizia con il capitolo 13 (45 pagine) dedicato alla “Reflection” e ai metadati presenti negli assembly .NET, su cui appunto la Reflection si basa. Può sembrare strano parlare di questi argomenti in una parte definita di “Debug”, ma lo scopo dell’autore è di portare il lettore ad uno stadio in cui sia in grado di debuggare direttamente del codice MSIL. Il capitolo 14 (38 pagine) è infatti dedicato all’Intermediate Language, il linguaggio di passaggio tra il C# e il codice macchina. Con questi due corposi capitoli l’argomento dovrebbe, in teoria, essere stato coperto per bene. In realtà persiste il linguaggio poco chiaro dell’autore, già rilevato nella prima parte del libro. Mi è capitato più volte di dover rileggere, parola per parola, parecchi paragrafi per capire il senso delle frasi e ciò chi si voleva trasmettere al lettore con esse. 

Nel lungo capitolo 15 (65 pagine) si torna ad utilizzare Visual Studio 2008, mettendo in pratica quanto appreso nei due capitoli precedenti, ovvero il debug efficiente attraverso l’ambiente di sviluppo. Questo capitolo è uno dei migliori del libro, ed è raro trovare un tale approfondimento in libri che non siano specifici su Visual Studio.

Il 16esimo capitolo (48 pagine), forse quello più avanzato e complesso del libro, approfondisce il debugging utilizzando MSIL e una serie di tool (gratuiti) che si affiancano e completano il debugger di Visual Studio.

 

La quinta ed ultima parte (Advanced Features) è composta da soli due capitoli, il 17esimo (47 pagine) dedicato alla gestione della memoria e il 18esimo (25 pagine) riguardante il codice “unsafe”.  

Nel primo viene spiegato approfonditamente come funziona il Garbage Collector di .NET. L’autore da’ prova di conoscere molto bene questa materia, e il discorso entra davvero nei dettagli, pur mantenendo una leggibilità sufficientemente comprensibile anche per chi conosce poco l’argomento. Vengono mostrati anche esempi di codice MSIL, spiegando perciò cosa accade effettivamente dietro le quinte, e messe in evidenza le differenze di comportamento rispetto al C++, dove la gestione della memoria è a carico dello sviluppatore.

Il codice sorgente del capitolo, purtroppo, è molto sparso e confuso, e non si riesce a capire a quali degli esempi riportati nel libro corrispondono i file della cartella; credo però che chi abbia necessità e soprattutto le competenze per leggere questo capitolo possa ricrearsi il (comunque non eccessivo) codice riportato.

Nel più breve 18esimo ed ultimo capitolo si fornisce una sufficiente infarinatura su cosa è il codice “unsafe”, sul perché bisognerebbe evitarlo e sul motivo perché invece in altri casi è necessario.

 

L’inglese, pur non essendo difficile come nei libri di Kent Beck, non brilla per semplicità e comprensibilità. Personalmente, pur essendo ormai abituato a leggere libri di informatica non tradotti, ho dovuto più volte ricorrere al dizionario. 

 

L’aspetto puramente fisico del libro invece è ideale. Le sue dimensioni (18,5 x 22,5 cm), la carta solida ma non lucida e l’ottima rilegatura, flessibile e resistente, sono quanto di meglio si possa richiedere ad un libro di programmazione. Basta andare in una libreria e provare a maneggiarlo un po’ per rendersene subito conto.

 

A questa pagina è presente la scheda del libro e il link per scaricare il codice sorgente (circa 13 MB), nella forma di un file .exe.

Altro link da tenere d’occhio è questo.

 

PRO

La particolarità del libro è di trattare in maniera più che dettagliata argomenti che in altri libri occuperebbero solo un frazione dello spazio che Donis Marshall gli riserva. Mi riferisco in particolar modo al debugging, alla programmazione MSIL e all’utilizzo delle features più avanzate e nascoste di Visual Studio 2008.

Ottima la rilegatura, che mantiene un’invidiabile flessibilità nonostante il libro non sia propriamente un fuscello.

 

CONTRO

Lo stile dell’autore, rappresentato da frasi dichiarative molto corte, non aiuta nella comprensione, men che meno i principianti (ed il libro, come riportato nel retro di copertina,  sarebbe indirizzato anche a loro).

Non è segnalato quando una feature è una novità di C# 3.0, e questo potrebbe essere utile, dato che la stragrande maggioranza di chi leggerà questo libro proviene da almeno una versione precedente del linguaggio.

L’indentazione del codice andrebbe decisamente migliorata, come anche lo stile di formattazione e impaginazione (uso del grassetto, del corsivo, ecc.).

Il file di codice, pur separato per capitoli, è mischiato alla rinfusa, e si fa grande fatica quando si vuole ricercare un esempio riportato nel testo.

 

 

Voto: 7/10

 

Lettore: Intermedio

 

 

Table of Contents

Introduction

Part 1 – Core Language

3 – Cap. 1: Introduction to Microsoft Visual C# Programming

49 – Cap. 2: Types

89 – Cap. 3: Inheritance

Part 2 – Core Skills

143 – Cap. 4: Introduction to Visual Studio 2008

201 – Cap. 5: Arrays and Collections

251 – Cap. 6: Introduction to LINQ

279 – Cap. 7: Generics

313 – Cap. 8: Enumerators

Part 3 – More C# Language

337 – Cap. 9: Operator Overloading

361 – Cap. 10: Delegates and Events

391 – Cap. 11: LINQ Programming

413 – Cap. 12: Exception Handling

Part 4 – Debugging

443 – Cap. 13: Metadata and Reflection

489 – Cap. 14: MSIL Programming

527 – Cap. 15: Debugging with Visual Studio 2008

593 – Cap. 16: Advanced Debugging

Part 5 – Advanced Features

643 – Cap. 17: Memory Management

691 – Cap. 18: Unsafe Code

Index

 

Categoria: Books
giovedì, 22 gen 2009 Ore. 08.53

Messaggi collegati


Meteo
Copyright © 2002-2007 - Blogs 2.0
dotNetHell.it | Home Page Blogs
ASP.NET 2.0 Windows 2003