Gianni Giaccaglini

Tricks & mini applics on WPF
posts - 46, comments - 0, trackbacks - 0

Come programmare col nuovo C# 5.0

 

Come programmare col nuovo C# 5.0

Programming C# 5.0
Building Windows 8, Web, and Desktop Applications for the .NET 4.5 Framework
di Ian Griffiths

Editore O'Reilly Media

Octobre 2012

Pagine:886

http://shop.oreilly.com/product/0636920024064.do

Prezzi
Stampa: $54.99
E-book: $43.99
Stampa + Ebook: $60.49

 

Questo best seller, alla quinta edizione, di O’Reilly scritto da Ian Griffiths anche tramite contatti con gli autori Microsoft di Azure, esordisce mettendo subito in evidenza che i potenziamenti dell’edizione 5.0 del linguaggio C# sono in gran parte in linea con la continuità che Microsoft ha esplicato, senza farne il ricettacolo di una miscela di cose incoerenti. Tale filosofia, sostiene l’Autore, si esprime in particolare nella programmazione asincrona, la novità più saliente, che anche in precedenza poteva compiersi, ma mediante codice involuto. C# 5.0 ora permette di redigere codice asincrono che si presenta quasi come quello normale, semplificando la comprensibilità e il lavoro dello sviluppatore.

Questa premessa, se presa alla lettera, a nostro avviso non deve ingannare. Per due motivi.

·         L’impianto stesso del C# (come pure del suo gemello Visual Basic) risulta se non rivoluzionato, modificato abbastanza a fondo, basti pensare all’introduzione della programmazione dichiarativa XAML in precedenza confinata all’ambiente WPF (Windows Presentation Foundation) nonché al supporto del sistema operativo Windows 8 che di XAML ha bisogno, a causa della sua nuova interfaccia “a mattonelle”.

·         Il libro a sua volta non è (come accade con autori più superficiali) una creatura partorita per aggiunte alla precedente versione, ma vanta di essere stato completamente rifatto.

Griffiths comunque mantiene la sua impostazione che consiste nel rivolgersi ai programmatori professionali ma con un’esposizione chiara e graduale che guarda anche ai neofiti del C# e della sua particolare sintassi. Come stiamo per elencare più in dettaglio non manca all’appello nulla di quanto ci si attende da un’opera qualificata. Ma con un’eccezione da segnalare, ovvero la descrizione della nuova interfaccia Surface (e del sistema touch screen in genere?), quasi sicuramente dovuto al fatto che Microsoft ne ha rinviato il varo a gennaio 2013.

Sintesi dei contenuti

Lo spettro dei contenuti appare esauriente, con ampio corredo di esempi che ben illustrano qualità come generics e dynamic typing, nonché, come si è detto, la nuova modalità di programmazione asincrona. Né mancano all’appello XAML, ASP.NET, LINQ e altri strumenti .NET.

Ma ecco l’elenco dei temi trattati.

  • Concetti base: classi, tipi anche personalizzati, collezioni, gestione errori
  • Differenze fra tipi di variabile statici e dinamici
  • Uso di LINQ per trattamento di fonti dati quali oggetti in-memory, database, documenti XML
  • Multithreading e gestione di processi paralleli
  • Il nuovo codice asincrono con esempi tipici e manipolazione di errori
  • Utilizzo di XAML per creare applicazioni in stile Windows 8, per apparecchi mobile, nonché quelle classiche per desktop

Per fornire un’idea concreta su come il libro affronta argomenti particolari ne riprendiamo infine parte del capitolo speciale dedicato alla Reflection e relativi oggetti.

Reflection

The CLR knows a great deal about the types our programs define and use. It requires all assemblies to provide detailed metadata, describing each member of every type, including private implementation details. It relies on this information to perform critical functions, such as JIT compilation and garbage collection. However, it does not keep this knowledge to itself. The reflection API grants access to this detailed type information, so your code can discover everything that the runtime can see. Moreover, you can use reflection to make things happen.

For example, a reflection object representing a method not only describes the method’s name and signature, but it also lets you invoke the method. And in some versions of .NET, you can go further still and generate code at runtime. Reflection is particularly useful in extensible frameworks, because they can use it to adapt their behavior at runtime based on the structure of your code. For example, Visual Studio’s Properties panel uses reflection to discover what public properties a component offers, so if you write a component that can appear on a design surface, such as a user interface element, you do not need to do anything special to make its properties available for editing—Visual Studio will find them automatically.

Reflection Types

The reflection API defines various classes in the System.Reflection namespace. These classes have a structural relationship that mirrors the way that assemblies and the type system work. For example, a type’s containing assembly is part of its identity, so the reflection class that represents a type (TypeInfo) has an Assembly property that returns its containing Assembly object. And you can navigate this relationship in both directions —you can discover all of the types in an assembly from the Assembly class’s Defined Types property. An application that can be extended by loading plug-in DLLs would typically use this to find the types each plug-in provides. Figure 13-1 shows the reflection types that correspond to .NET types, their members, and the components that contain them. The arrows represent containment relationships. (As with assemblies and types, these are all navigable in both directions.)

The inheritance hierarchy for these types (with the exception of TypeInfo, which I’ll get to shortly). This shows a couple of extra abstract types, Member Info and MethodBase, which are shared by various reflection classes that have a certain amount in common. For example, constructors and methods both have parameter lists, and the mechanism for inspecting these is provided by their shared base class, Method Base; all members of types have certain common features, such as accessibility, so any thing that is (or can be) a member of a type is represented in reflection by an object that derives from MemberInfo.

Print | posted on martedì 20 novembre 2012 17:29 |

Feedback

No comments posted yet.

Post Comment

Title  
Name  
Email
Url
Comment   
Please add 4 and 5 and type the answer here:

Powered by:
Powered By Subtext Powered By ASP.NET