Friday, November 30, 2007

Pro C# 2008 and the .NET 3.5 Platform, Fourth Edition by Andrew Troelsen

Apress has published their latest C# book: Pro C# 2008 and the .NET 3.5 Platform, Fourth Edition
By Andrew Troelsen
ISBN10: 1-59059-884-9
ISBN13: 978-1-59059-884-9
1370 pp.
Published on Nov 2007

Download a sample chapter here: Ch. 01 - The Philosophy of .NET
Download bonus chapters here

Table of contents:

Part 1 Introducing C# and the .NET Platform

CHAPTER 1 The Philosophy of .NET
Understanding the Previous State of Affairs
The .NET Solution
Introducing the Building Blocks of the .NET Platform (the CLR, CTS,
and CLS)
Additional .NET-Aware Programming Languages
An Overview of .NET Assemblies
Understanding the Common Type System
Understanding the Common Language Specification
Understanding the Common Language Runtime
The Assembly/Namespace/Type Distinction
Exploring an Assembly Using ildasm.exe
Exploring an Assembly Using Lutz Roeder’s Reflector
Deploying the .NET Runtime
The Platform-Independent Nature of .NET

CHAPTER 2 Building C# Applications
The Role of the .NET Framework 3.5 SDK.
Building C# Applications Using csc.exe
Building .NET Applications Using TextPad.
Building .NET Applications Using Notepad++.
Building .NET Applications Using SharpDevelop
Building .NET Applications Using Visual C# 2008 Express..
Building .NET Applications Using Visual Studio 2008.
A Partial Catalog of Additional .NET Development Tools

Part 2 Core C# Programming Constructs

CHAPTER 3 Core C# Programming Constructs, Part I
The Anatomy of a Simple C# Program.
An Interesting Aside: Some Additional Members of the System.Environment Class
The System.Console Class.
System Data Types and C# Shorthand Notation
Understanding the System.String Type
Narrowing and Widening Data Type Conversions
C# Iteration Constructs..
Decision Constructs and the Relational/Equality Operators..

CHAPTER 4 Core C# Programming Constructs, Part II
Methods and Parameter Modifiers..
Understanding Member Overloading
Array Manipulation in C#..
Understanding the Enum Type
Understanding the Structure Type.
Understanding Value Types and Reference Types..
Value and Reference Types: Final Details.
Understanding C# Nullable Types.

CHAPTER 5 Defining Encapsulated Class Types.
Introducing the C# Class Type
Understanding Class Constructors.
The Role of the this Keyword
Understanding the static Keyword.
Defining the Pillars of OOP
C# Access Modifiers
The First Pillar: C#’s Encapsulation Services
Understanding Constant Data
Understanding Read-Only Fields..
Understanding Partial Types
Documenting C# Source Code via XML..
Visualizing the Fruits of Our Labor.

CHAPTER 6 Understanding Inheritance and Polymorphism.
The Basic Mechanics of Inheritance
Revising Visual Studio Class Diagrams
The Second Pillar: The Details of Inheritance
Programming for Containment/Delegation
The Third Pillar: C#’s Polymorphic Support
Understanding Base Class/Derived Class Casting Rules
The Master Parent Class: System.Object.

CHAPTER 7 Understanding Structured Exception Handling
Ode to Errors, Bugs, and Exceptions
The Role of .NET Exception Handling.
The Simplest Possible Example..
Configuring the State of an Exception
System-Level Exceptions (System.SystemException)
Application-Level Exceptions (System.ApplicationException)
Processing Multiple Exceptions..
The Finally Block.
Who Is Throwing What?.
The Result of Unhandled Exceptions
Debugging Unhandled Exceptions Using Visual Studio

CHAPTER 8 Understanding Object Lifetime
Classes, Objects, and References.
The Basics of Object Lifetime
The Role of Application Roots
Understanding Object Generations..
The System.GC Type
Building Finalizable Objects
Building Disposable Objects
Building Finalizable and Disposable Types.

Part 3 Advanced C# Programming Constructs
CHAPTER 9 Working with Interfaces
Understanding Interface Types
Defining Custom Interfaces.
Implementing an Interface
Invoking Interface Members at the Object Level..
Interfaces As Parameters.
Interfaces As Return Values
Arrays of Interface Types.
Implementing Interfaces Using Visual Studio 2008.
Resolving Name Clashes via Explicit Interface Implementation
Designing Interface Hierarchies..
Building Enumerable Types (IEnumerable and IEnumerator)
Building Cloneable Objects (ICloneable)..
Building Comparable Objects (IComparable).
Understanding Callback Interfaces..

CHAPTER 10 Collections and Generics
The Interfaces of the System.Collections Namespace
The Class Types of System.Collections..
System.Collections.Specialized Namespace.
The Boxing, Unboxing, and System.Object Relationship..
The Issue of Type Safety and Strongly Typed Collections..
The System.Collections.Generic Namespace
Creating Custom Generic Methods..
Creating Generic Structures and Classes.
Creating a Custom Generic Collection
Creating Generic Base Classes
Creating Generic Interfaces.

CHAPTER 11 Delegates, Events, and Lambdas
Understanding the .NET Delegate Type..
Defining a Delegate in C#.
The System.MulticastDelegate and System.Delegate Base Classes.
The Simplest Possible Delegate Example.
Retrofitting the Car Type with Delegates..
A More Elaborate Delegate Example
Understanding Delegate Covariance
Creating Generic Delegates
Understanding C# Events.
The Generic EventHandler Delegate..
Understanding C# Anonymous Methods..
Understanding Method Group Conversions.
The C# 2008 Lambda Operator..

CHAPTER 12 Indexers, Operators, and Pointers
Understanding Indexer Methods
Understanding Operator Overloading.
Understanding Custom Type Conversions..
Working with Pointer Types
C# Preprocessor Directives.

CHAPTER 13 C# 2008 Language Features
Understanding Implicitly Typed Local Variables
Understanding Automatic Properties
Understanding Extension Methods..
Understanding Partial Methods..
Understanding Object Initializer Syntax..
Understanding Anonymous Types.

CHAPTER 14 An Introduction to LINQ
Understanding the Role of LINQ..
A First Look at LINQ Query Expressions..
LINQ and Generic Collections
LINQ and Nongeneric Collections..
The Internal Representation of LINQ Query Operators
Investigating the C# LINQ Query Operators.
LINQ Queries: An Island unto Themselves?.

PART 4 Programming with .NET Assemblies
CHAPTER 15 Introducing .NET Assemblies
Defining Custom Namespaces
The Role of .NET Assemblies
Understanding the Format of a .NET Assembly
Building and Consuming a Single-File Assembly..
Building and Consuming a Multifile Assembly
Understanding Private Assemblies..
Understanding Shared Assemblies.
Consuming a Shared Assembly..
Configuring Shared Assemblies..
Investigating the Internal Composition of the GAC
Understanding Publisher Policy Assemblies
Understanding the Element.
The System.Configuration Namespace
The Machine Configuration File

CHAPTER 16 Type Reflection, Late Binding, and Attribute-Based Programming
The Necessity of Type Metadata..
Understanding Reflection.
Building a Custom Metadata Viewer
Dynamically Loading Assemblies..
Reflecting on Shared Assemblies..
Understanding Late Binding
Understanding Attributed Programming
Building Custom Attributes
Assembly-Level (and Module-Level) Attributes
Reflecting on Attributes Using Early Binding.
Reflecting on Attributes Using Late Binding
Putting Reflection, Late Binding, and Custom Attributes in Perspective
Building an Extendable Application.

CHAPTER 17 Processes, AppDomains, and Object Contexts
Reviewing Traditional Win32 Processes..
Interacting with Processes Under the .NET Platform.
Understanding .NET Application Domains.
Understanding Object Context Boundaries.
Summarizing Processes, AppDomains, and Context.

CHAPTER 18 Building Multithreaded Applications
The Process/AppDomain/Context/Thread Relationship
A Brief Review of the .NET Delegate
The Asynchronous Nature of Delegates
Invoking a Method Asynchronously.
The System.Threading Namespace.
The System.Threading.Thread Class
Programmatically Creating Secondary Threads
The Issue of Concurrency.
Programming with Timer Callbacks.
Understanding the CLR ThreadPool.
The Role of the BackgroundWorker Component

CHAPTER 19 Understanding CIL and the Role of Dynamic Assemblies
Reflecting on the Nature of CIL Programming
Examining CIL Directives, Attributes, and Opcodes.
Pushing and Popping: The Stack-Based Nature of CIL
Understanding Round-Trip Engineering
Understanding CIL Directives and Attributes.
.NET Base Class Library, C#, and CIL Data Type Mappings.
Defining Type Members in CIL
Examining CIL Opcodes..
Building a .NET Assembly with CIL.
Understanding Dynamic Assemblies

Part 5 Introducing the .NET Base Class Libraries
CHAPTER 20 File I/O and Isolated Storage
Exploring the System.IO Namespace
The Directory(Info) and File(Info) Types..
Working with the DirectoryInfo Type
Working with the Directory Type..
Working with the DriveInfo Class Type..
Working with the FileInfo Class..
Working with the File Type
The Abstract Stream Class
Working with StreamWriters and StreamReaders..
Working with StringWriters and StringReaders
Working with BinaryWriters and BinaryReaders
Programmatically “Watching” Files.
Performing Asynchronous File I/O.
Understanding the Role of Isolated Storage
A Primer on Code Access Security..
An Overview of Isolated Storage
Obtaining a Store Using IsolatedStorageFile
Isolated Storage in Action: ClickOnce Deployment..

CHAPTER 21 Introducing Object Serialization
Understanding Object Serialization.
Configuring Objects for Serialization
Choosing a Serialization Formatter.
Serializing Objects Using the BinaryFormatter
Serializing Objects Using the SoapFormatter
Serializing Objects Using the XmlSerializer.
Serializing Collections of Objects..
Customizing the Serialization Process

CHAPTER 22 ADO.NET Part I: The Connected Layer
A High-Level Definition of ADO.NET.
Understanding ADO.NET Data Providers..
Additional ADO.NET Namespaces.
The Types of the System.Data Namespace
Abstracting Data Providers Using Interfaces.
Creating the AutoLot Database
The ADO.NET Data Provider Factory Model.
Understanding the Connected Layer of ADO.NET
Working with Data Readers
Building a Reusable Data Access Library.
Creating a Console UI–Based Front End..
Asynchronous Data Access Using SqlCommand..
Understanding Database Transactions..

CHAPTER 23 ADO.NET Part II: The Disconnected Layer
Understanding the Disconnected Layer of ADO.NET.
Understanding the Role of the DataSet..
Working with DataColumns.
Working with DataRows.
Working with DataTables.
Binding DataTable Objects to User Interfaces
Filling DataSet/DataTable Objects Using Data Adapters..
Revisiting AutoLotDAL.dll.
Navigating Multitabled DataSet Objects..
The Data Access Tools of Visual Studio 2008
Decoupling Autogenerated Code from the UI Layer.

CHAPTER 24 Programming with the LINQ APIs
The Role of LINQ to ADO.NET
Programming with LINQ to DataSet.
Programming with LINQ to SQL..
Generating Entity Classes Using SqlMetal.exe
Building Entity Classes Using Visual Studio 2008
Manipulating XML Documents Using LINQ to XML..
Navigating an In-Memory Document

CHAPTER 25 Introducing Windows Communication Foundation
A Potpourri of Distributed Computing APIs.
The Role of WCF..
Investigating the Core WCF Assemblies..
The Visual Studio WCF Project Templates..
The Basic Composition of a WCF Application
The ABCs of WCF.
Building a WCF Service..
Hosting the WCF Service..
Building the WCF Client Application.
Using the WCF Service Library Project Template..
Hosting the WCF Service As a Windows Service..
Invoking a Service Asynchronously.
Designing WCF Data Contracts

CHAPTER 26 Introducing Windows Workflow Foundation
Defining a Business Process
The Building Blocks of WF
WF Assemblies, Namespaces, and Projects
Building a Simple Workflow-Enabled Application
Examining the WF Engine Hosting Code..
Invoking Web Services Within Workflows.
Building a Reusable WF Code Library
A Brief Word Regarding Custom Activities.

Part 6 Desktop User Interfaces
CHAPTER 27 Programming with Windows Forms
The Windows Forms Namespaces..
Building a Simple Windows Forms Application (IDE-Free)..
The Visual Studio Windows Forms Project Template.
The Anatomy of a Form..
Responding to Mouse Activity
Responding to Keyboard Activity..
Designing Dialog Boxes..
Rendering Graphical Data Using GDI+
Building a Complete Windows Forms Application..

CHAPTER 28 Introducing Windows Presentation Foundation and XAML
The Motivation Behind WPF
The Various Flavors of WPF Applications..
Investigating the WPF Assemblies.
Building a (XAML-Free) WPF Application..
Additional Details of the Application Type.
Additional Details of the Window Type..
Building a (XAML-Centric) WPF Application
Transforming Markup into a .NET Assembly
Separation of Concerns Using Code-Behind Files.
The Syntax of XAML
Building WPF Applications Using Visual Studio 2008.
Processing XAML at Runtime: SimpleXamlPad.exe.
The Role of Microsoft Expression Blend.

CHAPTER 29 Programming with WPF Controls
A Survey of the WPF Control Library
Declaring Controls in XAML
Understanding the Role of Dependency Properties.
Understanding Routed Events
Working with Button Types
Working with CheckBoxes and RadioButtons
Working with the ListBox and ComboBox Types..
Working with Text Areas.
Controlling Content Layout Using Panels..
Building a Window’s Frame Using Nested Panels.
Understanding WPF Control Commands.
Understanding the WPF Data-Binding Model
Data Conversion Using IValueConverter.
Binding to Custom Objects
Binding UI Elements to XML Documents.

CHAPTER 30 WPF 2D Graphical Rendering, Resources, and Themes
The Philosophy of WPF Graphical Rendering Services
Exploring the Shape-Derived Types
Working with WPF Brushes
Working with WPF Pens.
Exploring the Drawing-Derived Types..
The Role of UI Transformations..
Understanding WPF’s Animation Services.
Understanding the WPF Resource System
Defining and Applying Styles for WPF Controls..
Altering a Control’s UI Using Templates.

Part 7 Building Web Applications with ASP.NET
CHAPTER 31 Building ASP.NET Web Pages
The Role of HTTP.
Understanding Web Applications and Web Servers.
The Role of HTML.
The Role of Client-Side Scripting.
Submitting the Form Data (GET and POST)
Building a Classic ASP Page
Problems with Classic ASP
The ASP.NET Namespaces
The ASP.NET Web Page Code Model
Details of an ASP.NET Website Directory Structure.
The ASP.NET Page Compilation Cycle..
The Inheritance Chain of the Page Type.
Interacting with the Incoming HTTP Request
Interacting with the Outgoing HTTP Response
The Life Cycle of an ASP.NET Web Page.
The Role of the Web.config File..

CHAPTER 32 ASP.NET Web Controls, Themes, and Master Pages
Understanding the Nature of Web Controls
The System.Web.UI.Control Type.
The System.Web.UI.WebControls.WebControl Type.
Major Categories of ASP.NET Web Controls
Building a Feature-Rich ASP.NET Website
The Role of the Validation Controls
Working with Themes..
Positioning Controls Using HTML Tables.

CHAPTER 33 ASP.NET State Management Techniques
The Issue of State
ASP.NET State Management Techniques.
Understanding the Role of ASP.NET View State.
The Role of the Global.asax File.
Understanding the Application/Session Distinction.
Working with the Application Cache
Maintaining Session Data
Understanding Cookies.
The Role of the Element.
Understanding the ASP.NET Profile API.

Part 8 Appendixes
APPENDIX A COM and .NET Interoperability
The Scope of .NET Interoperability.
A Simple Example of .NET to COM Interop
Investigating a .NET Interop Assembly.
Understanding the Runtime Callable Wrapper
The Role of COM IDL.
Using a Type Library to Build an Interop Assembly.
Building a More Elaborate COM Server.
Examining the Interop Assembly.
Understanding COM to .NET Interoperability
The Role of the CCW.
The Role of the .NET Class Interface
Building Your .NET Types
Generating the Type Library and Registering the .NET Types
Examining the Exported Type Information.
Building a Visual Basic 6.0 Test Client

APPENDIX B Platform-Independent .NET Development with Mono
The Platform-Independent Nature of .NET
Obtaining and Installing Mono.
The Mono Development Tools.
Building .NET Applications with Mono.
Suggestions for Further Study.


Amazon Link: Pro C# 2008 and the .NET 3.5 Platform, Fourth Edition

No comments: