Bit a bit, si cresce sempre


Blog di un ingeformatico
Statistiche
  • Views Home Page: 481.465
  • Views Posts: 1.546.943
  • Views Gallerie: 710.875
  • 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 C# 3.0 Cookbook (O'Reilly)

Su Amazon UK è presente un solo commento a questo libro, in cui un lettore si lamenta di trovare solo ricette (“recipes” in inglese, da cui la collana “Cookbook”, ovvero “libro di cucina”), e di non reputarlo un manuale per l’insegnamento del linguaggio.

Beh, ma non è proprio quello che è riportato in copertina?

Mi domando, qualche volta, come fanno certe persone a raggiungere tali vette di perspicacia e intuizione…

Lo scopo di questo librone (quasi 900 pagine) non è infatti quello di insegnare C# 3.0; si presuppone che il lettore lo conosca già abbastanza bene (o anche limitatamente alla sua versione 2.0 – escludendo, in tal caso, solo qualche capitolo).

È invece una raccolta di ricette, raggruppate per tipologie di argomento.

 

Il metodo di esposizione è questo: si illustra il problema, di complessità man mano crescente all’interno del capitolo di pertinenza, si scrive – leggermente commentando – la soluzione sotto forma di codice, e poi la si analizza in maniera più approfondita, magari riportando interessanti dettagli di teoria. Punto.

Questo è quello che fa questo libro.

Non è comunque poco, tutt’altro. Gli argomenti coperti sono parecchi, le ricette sono abbastanza rappresentative dei problemi cui uno sviluppatore può imbattersi, e il ripasso teorico che viene fatto per ogni ricetta è un modo efficace per fissare i concetti in memoria.  

In tal modo il lettore aumenta per gradi le proprie competenze.

 

Il codice è ben indentato, la carta è un po’ sottile ma di qualità, e la rilegatura felicemente flessibile, il che per un testo destinato a restare a fianco del pc non è un dettaglio da poco.

Stranamente il primo capitolo affronta LINQ, uno degli argomenti più complessi e sicuramente la più recente aggiunta al linguaggio. Ma come detto, in un libro come questo, l’ordine degli argomenti ha un’importanza molto marginale. Il lettore tipico non lo leggerà (quasi) mai consecutivamente, ma si concentrerà su ciò che gli interessa nell’immediato.

 

Questa è la pagina del sito della O’Reilly dedicata al libro.

 

Attualmente è presente una sola lunghissima errata relativa ad un pezzo di codice a pag. 432 (praticamente è da rifarlo tutto). Non ci sono altri errori, segno di una buona cura prima di mandarlo in stampa.

Il file degli esempi di codice è poco più di 3 MB.

Più sotto riporto il sommario dettagliato, con tutte le recipes, così ci si può fare un’idea precisa del contenuto.

 

PRO

Questo libro rappresenta il perfetto complemento alla collezione di libri su C# che ogni sviluppatore possiede.

Una volta che si sono apprese le basi del linguaggio (con altri testi), con questo libro lo si “fissa” tramite esempi, e costituisce il miglior complemento al proprio pc.

 

CONTRO

Tenendo a mente lo scopo e il target dei lettori di questo libro, non ci sono tanti aspetti negativi da imputargli.

 

 

PROS

This book is the perfect complement to the collection of books on C# that each developer owns.

Once you have learned the foundations of the language (with other manuals), with this book it is "fixed" through examples, and is the best complement to your pc.

 

CONS

Bearing in mind the purpose and the target of readers of this book, there are no many negative aspects to ascribe to it.  

 

 

Voto complessivo: 8.5/10

 

Lettore: Intermedio

 

 

Table of Contents

Preface

1. Language Integrated Query (LINQ)

       1.1 Query a Message Queue 

       1.2 Using Set Semantics with Data  

       1.3 Reuse Parameterized Queries with LINQ to SQL 

       1.4 Sort Results in a Culture-Sensitive Manner 

       1.5 Adding Functional Extensions for Use with LINQ 

       1.6 Query and Join Across Data Repositories 

       1.7 Querying Configuration Files with LINQ 

       1.8 Creating XML Straight from a Database 

       1.9 Being Selective About Your Query Results 

       1.10 Using LINQ with Collections That Don't Support IEnumerable 

2. Strings and Characters

       2.1 Determining the Kind of Character a Char Contains 

       2.2 Controlling Case Sensitivity When Comparing Two Characters 

       2.3Within Another String 

       2.4 Controlling Case Sensitivity When Comparing Two Strings 

       2.5 Comparing a String to the Beginning or End of a Second String 

       2.6 Inserting Text into a String 

       2.7 Removing or Replacing Characters Within a String 

       2.8 Encoding Binary Data As Base64 

       2.9 Decoding a Base64-Encoded Binary 

       2.10 Converting a String Returned As a Byte[ ] Back into a String 

       2.11 Passing a String to a Method That Accepts Only a Byte[ ] 

       2.12 Converting Strings to Other Types 

       2.13 Creating a Delimited String 

       2.14 Extracting Items from a Delimited String 

       2.15 Iterating over Each Character in a String 

       2.16 Pruning Characters from the Head and/or Tail of a String 

       2.17 Testing a String for Null or Empty 

       2.18 Appending a Line 

3. Classes and Structures

       3.1 Creating Union-Type Structures 

       3.2 Making a Type Sortable 

       3.3 Making a Type Searchable 

       3.4 Indirectly Overloading the +=, -=, /=, and *= Operators 

       3.5 Indirectly Overloading the &&, ||, and ?: Operators 

       3.6 Making Error-Free Expressions 

       3.7 Reducing Your Boolean Logic 

       3.8 Language-Agnostic Manner 

       3.9 or the is Operator 

       3.10 Casting with the as Operator 

       3.11 Determining a Variable's Type with the is Operator 

       3.12 Returning Multiple Items from a Method 

       3.13 Parsing Command-Line Parameters 

       3.14 Initializing a Constant Field at Runtime 

       3.15 Building Cloneable Classes 

       3.16 Assuring an Object's Disposal 

       3.17 Disposing of Unmanaged Resources 

       3.18 Determining Where Boxing and Unboxing Occur 

4. Generics

       4.1 Deciding When and Where to Use Generics 

       4.2 Understanding Generic Types 

       4.3 Replacing the ArrayList with Its Generic Counterpart 

       4.4 Replacing the Stack and Queue with Their Generic Counterparts 

       4.5 Using a Linked List 

       4.6 Creating a Value Type That Can Be Initialized to Null 

       4.7 Reversing the Contents of a Sorted List 

       4.8 Making Read-Only Collections the Generic Way 

       4.9 Replacing the Hashtable with Its Generic Counterpart 

       4.10 Using foreach with Generic Dictionary Types 

       4.11 Constraining Type Arguments 

       4.12 Initializing Generic Variables to Their Default Values 

5. Collections

       5.1 Swapping Two Elements in an Array 

       5.2 Reversing an Array Quickly 

       5.3 Writing a More Flexible StackTrace Class 

       5.4 Determining the Number of Times an Item Appears in a List 

       5.5 Retrieving All Instances of a Specific Item in a List 

       5.6 Inserting and Removing Items from an Array 

       5.7 Keeping Your List Sorted 

       5.8 Sorting a Dictionary's Keys and/or Values 

       5.9 Creating a Dictionary with Max and Min Value Boundaries 

       5.10 Storing Snapshots of Lists in an Array 

       5.11 Persisting a Collection Between Application Sessions 

       5.12 Testing Every Element in an Array or List 

       5.13 Performing an Action on Each Element in an Array or List 

       5.14 Creating a Read-Only Array or List 

6. Iterators, Partial Types, and Partial Methods

       6.1 Creating an Iterator on a Generic Type 

       6.2 Creating an Iterator on a Nongeneric Type 

       6.3 Creating Custom Enumerators 

       6.4 Implementing Iterator Logic 

       6.5 Forcing an Iterator to Stop Iterating 

       6.6 Dealing with Finally Blocks and Iterators 

       6.7 Implementing Nested foreach Functionality in a Class 

       6.8 Organizing Your Interface Implementations 

       6.9 Generating Code That Is No Longer in Your Main Code Paths 

       6.10 Adding Hooks to Generated Entities 

7. Exception Handling

       7.1 Knowing When to Catch and Rethrow Exceptions 

       7.2 Assuring Exceptions Are Not Lost When Using Finally Blocks 

       7.3 Handling Exceptions Thrown from Methods Invoked via Reflection 

       7.4 Preventing Unhandled Exceptions 

       7.5 Getting Exception Information 

       7.6 Getting to the Root of a Problem Quickly 

       7.7 Creating a New Exception Type 

       7.8 Obtaining a Stack Trace 

       7.9 Breaking on a First-Chance Exception 

       7.10 Handling Exceptions Thrown from an Asynchronous Delegate 

       7.11 Giving Exceptions the Extra Info They Need with Exception.Data 

       7.12 Dealing with Unhandled Exceptions in WinForms Applications 

       7.13 Foundation (WPF) Applications 

       7.14 Analyzing Exceptions for Common Errors 

8. Diagnostics

       8.1 Providing Fine-Grained Control over Debugging/Tracing Output 

       8.2 Determining Whether a Process Has Stopped Responding 

       8.3 Using Event Logs in Your Application 

       8.4 Searching Event Log Entries 

       8.5 Watching the Event Log for a Specific Entry 

       8.6 Implementing a Simple Performance Counter 

       8.7 Enabling and Disabling Complex Tracing Code 

       8.8 Capturing Standard Output for a Process 

       8.9 Creating Custom Debugging Displays for Your Classes 

9. Delegates, Events, and Lambda Expressions

       9.1 Multicast Delegate 

       9.2 Multicast Delegate 

       9.3 Multicast Delegate 

       9.4 Asynchronous 

       9.5 An Advanced Interface Search Mechanism 

       9.6 Observing Additions and Modifications to Dictionaries 

       9.7 Using Lambda Expressions 

       9.8 Set Up Event Handlers Without the Mess 

       9.9 Using Different Parameter Modifiers in Lambda Expressions 

       9.10 Using Closures in C# 

       9.11 Performing Multiple Operations on a List Using Functors 

10. Regular Expressions

       10.1 Enumerating Matches 

       10.2 Extracting Groups from a MatchCollection 

       10.3 Verifying the Syntax of a Regular Expression 

       10.4 Quickly Finding Only the Last Match in a String 

       10.5 Augmenting the Basic String Replacement Function 

       10.6 Implementing a Better Tokenizer 

       10.7 Counting Lines of Text 

       10.8 Returning the Entire Line in Which a Match Is Found 

       10.9 Finding a Particular Occurrence of a Match 

       10.10 Using Common Patterns 

11. Data Structures and Algorithms

       11.1 Creating a Hash Code for a Data Type 

       11.2 Creating a Priority Queue 

       11.3 Creating a One-to-Many Map (MultiMap) 

       11.4 Creating a Binary Search Tree 

       11.5 Creating an n-ary Tree 

       11.6 Using a HashSet Object 

12. Filesystem I/O

       12.1 Manipulating File Attributes 

       12.2 Renaming a File 

       12.3 Outputting a Platform-Independent EOL Character 

       12.4 Manipulating Directory Attributes 

       12.5 Renaming a Directory 

       12.6 Searching for Directories or Files Using Wildcards 

       12.7 Obtaining the Directory Tree 

       12.8 Parsing a Path 

       12.9 Parsing Paths in Environment Variables 

       12.10 Launching and Interacting with Console Utilities 

       12.11 Locking Subsections of a File 

       12.12 Waiting for an Action to Occur in the Filesystem 

       12.13 Comparing Version Information of Two Executable Modules 

       12.14 Querying Information for All Drives on a System 

       12.15 Compressing and Decompressing Your Files 

13. Reflection

       13.1 Listing Referenced Assemblies 

       13.2 Listing Exported Types 

       13.3 Finding Overridden Methods 

       13.4 Finding Members in an Assembly 

       13.5 Determining and Obtaining Nested Types Within an Assembly 

       13.6 Displaying the Inheritance Hierarchy for a Type 

       13.7 Finding the Subclasses of a Type 

       13.8 Finding All Serializable Types Within an Assembly 

       13.9 Dynamically Invoking Members 

       13.10 Determining If a Type or Method  Is Generic 

       13.11 Accessing Local Variable Information 

       13.12 Creating a Generic Type 

14. Web

       14.1 Converting an IP Address to a Hostname 

       14.2 Converting a Hostname to an IP Address 

       14.3 Parsing a URI 

       14.4 Handling Web Server Errors 

       14.5 Communicating with a Web Server 

       14.6 Going Through a Proxy 

       14.7 Obtaining the HTML from a URL 

       14.8 Using the Web Browser Control 

       14.9 Tying Database Tables to the Cache 

       14.10 Prebuilding an ASP.NET Web Site Programmatically 

       14.11 Escaping and Unescaping Data for the Web 

       14.12 Using the UriBuilder Class 

       14.13 Inspect and Change Your Web Application Configuration 

       14.14 Faster Performance 

       14.15 Checking Out a Web Server's Custom Error Pages 

15. XML

       15.1 Reading and Accessing XML Data in Document Order 

       15.2 Reading XML on the Web 

       15.3 Querying the Contents of an XML Document 

       15.4 Validating XML 

       15.5 Creating an XML Document Programmatically 

       15.6 Detecting Changes to an XML Document 

       15.7 Handling Invalid Characters in an XML String 

       15.8 Transforming XML 

       15.9 Tearing Apart an XML Document 

       15.10 Putting Together an XML Document 

       15.11 Validating Modified XML Documents Without Reloading 

       15.12 Extending Transformations 

       15.13 Getting Your Schemas in Bulk from Existing XML Files 

       15.14 Passing Parameters to Transformations 

16. Networking

       16.1 Writing a TCP Server 

       16.2 Writing a TCP Client 

       16.3 Simulating Form Execution 

       16.4 Transferring Data via HTTP 

       16.5 Using Named Pipes to Communicate 

       16.6 Pinging Programmatically 

       16.7 Send SMTP Mail Using the SMTP Service 

       16.8 Use Sockets to Scan the Ports on a Machine 

       16.9 Use the Current Internet Connection Settings 

       16.10 Transferring Files Using FTP 

17. Security

       17.1 Controlling Access to Types in a Local Assembly 

       17.2 Encrypting/Decrypting a String 

       17.3 Encrypting and Decrypting a File 

       17.4 Cleaning Up Cryptography Information 

       17.5 Following Transmission 

       17.6 Storing Data Securely 

       17.7 Making a Security Assert Safe 

       17.8 Verifying That an Assembly Has Been Granted Specific Permissions 

       17.9 Minimizing the Attack Surface of an Assembly 

       17.10 Obtaining Security/Audit Information 

       17.11 Granting/Revoking Access to a File or Registry Key 

       17.12 Protecting String Data with Secure Strings 

       17.13 Securing Stream Data 

       17.14 Encrypting web.config Information 

       17.15 Obtaining the Full Reason a SecurityException Was Thrown 

       17.16 Achieving Secure Unicode Encoding 

       17.17 Obtaining a Safer File Handle 

18. Threading and Synchronization

       18.1 Creating Per-Thread Static Fields 

       18.2 Providing Thread-Safe Access to Class Members 

       18.3 Preventing Silent Thread Termination 

       18.4 Being Notified of the Completion of an Asynchronous Delegate 

       18.5 Storing Thread-Specific Data Privately 

       18.6 Granting Multiple Access to Resources with a Semaphore 

       18.7 Synchronizing Multiple Processes with the Mutex 

       18.8 Using Events to Make Threads Cooperate 

       18.9 Get the Naming Rights for Your Events 

       18.10 Performing Atomic Operations Among Threads 

       18.11 Optimizing Read-Mostly Access 

19. Toolbox

       19.1or User Session Changes 

       19.2 Controlling a Service 

       19.3 List What Processes an Assembly Is Loaded In 

       19.4 Using Message Queues on a Local Workstation 

       19.5 Finding the Path to the Current Framework Version 

       19.6 Registered in the Global Assembly Cache (GAC) 

       19.7 Capturing Output from the Standard Output Stream 

       19.8 Running Code in Its Own AppDomain 

       19.9 Version of the Current Operating System 

20. Numbers and Enumerations

       20.1 Converting Between Degrees and Radians 

       20.2 Using the Bitwise Complement Operator with Various Data Types 

       20.3 Converting a Number in Another Base to Base10  

       20.4 Determining Whether a String Is a Valid Number 

       20.5 Rounding a Floating-Point Value 

       20.6 Choosing a Rounding Algorithm 

       20.7 Converting Between Temperature Scales 

       20.8 Safely Performing a Narrowing Numeric Cast 

       20.9 Displaying an Enumeration Value As a String 

       20.10 Converting Plain Text to an Equivalent Enumeration Value 

       20.11 Testing for a Valid Enumeration Value 

       20.12 Testing for a Valid Enumeration of Flags 

       20.13 Using Enumerated Members in a Bit Mask 

       20.14 Determining Whether One or More Enumeration Flags Are Set 

       20.15 Determining the Integral Part of a Decimal or Double 

Index

 

Titolo: C# 3.0 Cookbook
Autori: Jay Hilyard, Stephen Teilhet
Editore: O’Reilly
ISBN: 9780596516109
Pagine: 886
Prezzo: 54.99 $ (prezzo di copertina)
Data di uscita: Gen. 2008

Categoria: Books
lunedì, 04 mag 2009 Ore. 12.00

Messaggi collegati


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