Table of Contents

This is the table of contents for all the chapters of IronPython in Action that are already available in the Manning Early Access Program. They are possibly still subject to change, but as the book is nearly finished it isn't too likely!

Part 1: Getting Started with IronPython

1. A New Language for .NET

   1.1 An Introduction to IronPython

   1.1.1 What is IronPython?

   1.1.2 A Brief History of IronPython

   1.1.3 IronPython for Python Programmers

   1.1.4 IronPython for .NET Programmers

   1.2 Python on the CLR

   1.2.1 Dynamic Languages on .NET and the DLR

   1.2.2 Silverlight, a New CLR

   1.2.3 The Python Programming Language

   1.2.4 Multiple Programming Paradigms

   1.3 Live Objects on the Console - the Interactive Interpreter

   1.3.1 Using the Interactive Interpreter

   1.3.2 .NET Framework: assemblies, namespaces and classes

   1.3.3 Live objects and the Interactive Interpreter

   1.3.4 Object Introspection with dir and help

   1.4 Summary

2. Introduction to Python

   2.1 An Overview of Python

   2.1.1 Python datatypes

   2.1.2 Names, Objects and References

   2.1.3 Mutable and immutable objects

   2.2 Python: Basic Constructs

   2.2.1 Statements and expressions

   2.2.2 Conditionals and loops

   2.2.3 Functions

   2.2.4 Built in Functions

   2.2.5 Classes

   2.3 Additional Python Features

   2.3.1 Exception Handling

   2.3.2 Closures and scoping rules

   2.3.3 List Comprehensions

   2.3.4 Modules, Packages and Importing

   2.3.5 Docstrings

   2.3.6 The Python Standard Library

   2.4 Summary

3. .NET Objects & IronPython

   3.1 Introducing .NET

   3.1.1 Translating MSDN Documentation into IronPython

   3.1.2 The Form Class

   3.2 Structures, Enumerations and Collections: .NET Types

   3.2.1 Methods and properties inherited from Control

   3.2.2 Adding a Label to the Form: ControlCollection

   3.2.3 Configuring the Label: The Color Structure

   3.2.4 The FormBorderStyle Enumeration

   3.2.5 Hello World with Form and Label

   3.3 Handling Events

   3.3.1 The MouseMove Event

   3.3.2 Event Handlers in IronPython

   3.4 Subclassing .NET Types

   3.5 Summary

Part 2: Core Development Techniques

4. Writing an Application, and Design Patterns with IronPython

   4.1 Data Modelling and Duck Typing

   4.1.1 Python and Protocols

   4.1.2 Duck Typing in Action

   4.2 Model View Controller in IronPython

   4.2.1 Introducing the Running Example

   4.2.2 The View Layer: Creating a User Interface

   4.2.3 A Data Model

   4.2.4 A Controller Class

   4.3 The Command Pattern

   4.3.1 The SaveFileDialog

   4.3.2 Writing Files: the .NET & Python Ways

   4.3.3 Handling exceptions and the system message box

   4.3.4 The Save Command, a Python Class

   4.3.5 The SaveAs Command

   4.4 Integrating Commands with Our Running Example

   4.4.1 Menu Classes and Lambda

   4.4.2 Toolbar and Images, .NET Classes

   4.4.3 Bringing the GUI to Life

   4.5 Summary

5. First Class Functions in Action with XML

   5.1 First Class Functions

   5.1.1 Higher Order Functions

   5.1.2 Python Decorators

   5.1.3 A Null Argument Checking Decorator

   5.2 Representing Documents with XML

   5.2.1 The .NET XmlWriter

   5.2.2 A DocumentWriter Class

   5.2.3 An Alternative with an Inner Function

   5.3 Reading XML

   5.3.1 XmlReader

   5.3.2 An IronPython XML Document Reader

   5.4 Handler Functions for MultiDoc XML

   5.5 The Open Command

   5.6 Summary

6. Properties, Dialogs and Visual Studio

   6.1 Document Observers

   6.1.1 Python properties

   6.1.2 Document Observers on the MainForm

   6.1.3 Adding the OpenCommand

   6.2 More with TabPages: Dialogs and Visual Studio

   6.2.1 Remove Pages: Ok and Cancel Dialog

   6.2.2 Rename Pages: A Modal Dialog

   6.2.3 Visual Studio Express and IronPython

   6.2.4 Adding Pages: Code Reuse in Action

   6.2.5 Wiring the Commands to the View

   6.3 Object Serializing with BinaryFormatter

   6.4 Summary

7. Agile Testing - Where Dynamic Typing Shines

   7.1 The unitest module

   7.1.1 Creating a TestCase

   7.1.2 setup and tearDown

   7.1.3 Test Suites with Multiple Modules

   7.2.Testing with Mocks

   7.2.1 Mock Objects

   7.2.2 Modifying Live Objects: The Art of the Monkey Patch

   7.2.3 Mocks and Dependency Injection

   7.3 Functional Testing

   7.3.1 Interacting with the GUI Thread

   7.3.2 An AsyncExecutor for Asynchronous Interactions

   7.3.3 The Functional Test: Making MultiDoc Dance

   7.4 Summary

8. Getting Deeper into IronPython: Metaprogramming, Protocols and More

   8.1 Protocols instead of Interfaces

   8.1.1 A Myriad of Magic Methods

   8.1.2 Operator Overloading

   8.1.3 Iteration

   8.1.4 Generators

   8.1.5 Equality and Inequality

   8.2 Dynamic Attribute Access

   8.2.1 Attribute Access through Builtin Functions

   8.2.2 Attribute Access through Magic Methods

   8.2.3 Proxying Attribute Access

   8.3 Metaprogramming

   8.3.1 Introduction to Metaclasses

   8.3.2 Uses of Metaclasses

   8.3.3 A Profiling Metaclass

   8.4 IronPython and the CLR

   8.4.1 .NET Arrays

   8.4.2 Overloaded Methods

   8.4.3 'out', 'ref', 'params' and Pointer Parameters

   8.4.4 Value Types

   8.4.5 Interfaces

   8.4.6 Attributes

   8.5.Summary

Part 3: IronPython and Advanced .NET

9. WPF and IronPython

   9.1 Hello World with WPF and IronPython

   9.1.1 WPF from Code

   9.1.2 Hello World from XAML

   9.2 WPF in Action

   9.2.1 Layout with the Grid

   9.2.2 The WPF ComboBox and CheckBox

   9.2.3 The Image Control

   9.2.4 The Expander

   9.2.5 The ScrollViewer

   9.2.6 The TextBlock a Lightweight Document Viewer

   9.2.7 The XamlWriter

   9.3 XPS Documents and Flow Content

   9.3.1 FlowDocument Viewer Classes

   9.3.2 Flow Document Markup

   9.3.3 Document XAML and Object Tree Processing

   9.4 Summary

10. Windows System Administration with IronPython

    10.1 System Administration with IronPython

    10.1.1 Simple Scripts

    10.1.2 Shell Scripting with IronPython

    10.2. WMI and the System.Management Assembly

    10.2.1 System.Management

    10.2.2 Connecting to remote Computers

    10.3 Powershell & IronPython

    10.3.1. Using Powershell from IronPython

    10.3.2. Using IronPython inside Powershell

    10.4 Summary

11. IronPython and ASP.NET

    11.1 Introducing ASP.NET

    11.1.1 Web controls

    11.1.2 Pages and user controls

    11.1.3 Rendering, server code and the page lifecycle

    11.2 Adding IronPython to ASP.NET

    11.2.1 Writing a first application

    11.2.2 Creating a project

    11.3 ASP.NET Infrastructure

    11.3.1 The App_Script Folder

    11.3.2 The Global.py File

    11.3.3 The Web.config File

    11.4 A Web-based MultiDoc Viewer

    11.4.1 Page Structure

    11.4.2 Code-behind

    11.5 Editing MultiDocs

    11.5.1 Swapping Controls

    11.5.2 Handling Viewstate

    11.5.3 Additional Events

    11.6 Converting the Editor into a User Control

    11.6.1 Viewstate Again

    11.6.2 Adding Parameters

    11.7 Summary

The chapters still to be written are:

12. Databases and Web Services
13. Silverlight: IronPython in the Browser
14. Extending IronPython with C# / VB
15. Embedding the IronPython Engine