book

IronPython in Action

Name: IronPython in Action
ISBN: 9781933988337

by Michael Foord, Christian J. Muirhead

March 2009

Intermediate to advanced

496 pages

13h 10m

English

Manning Publications

Read now

Unlock full access

Copyright
Dedication
Foreword
Preface
Acknowledgments
About this Book
Who should read this book?RoadmapCode conventions and downloadsAuthor OnlineAbout the authorsAbout the titleAbout the cover illustration
1. Getting started with IronPython
1. A new language for .NET
1.1. An introduction to IronPython1.1.1. What is IronPython?1.1.2. A brief history of IronPython1.1.3. IronPython for Python programmers1.1.4. IronPython for .NET programmers1.2. Python on the CLR1.2.1. Dynamic languages on .NET and the DLR1.2.2. Silverlight: a new CLR1.2.3. The Python programming language1.2.4. Multiple programming paradigms1.3. Live objects on the console: the interactive interpreter1.3.1. Using the interactive interpreter1.3.2. The .NET framework: assemblies, namespaces, and references1.3.3. Live objects and the interactive interpreter1.3.4. Object introspection with dir and help1.4. Summary
2. Introduction to Python
2.1. An overview of Python2.1.1. Python datatypesStringsThe CLR Module and IronPython TypesNumbersListsTuplesDictionariesSetsNone and the Booleans2.1.2. Names, objects, and references2.1.3. Mutable and immutable objects2.2. Python: basic constructs2.2.1. Statements and expressions2.2.2. Conditionals and loops2.2.3. Functions2.2.4. Built-in functions2.2.5. Classes2.3. Additional Python features2.3.1. Exception handling2.3.2. Closures and scoping rules2.3.3. List comprehensions2.3.4. Modules, packages, and importing2.3.5. Docstrings2.3.6. The Python standard library2.4. Summary
3. .NET objects and IronPython
3.1. Introducing .NET3.1.1. Translating MSDN documentation into IronPython3.1.2. The Form class3.2. Structures, enumerations, and collections: .NET types3.2.1. Methods and properties inherited from Control3.2.2. Adding a Label to the Form: ControlCollection3.2.3. Configuring the Label: the Color structure3.2.4. The FormBorderStyle enumeration3.2.5. Hello World with Form and Label3.3. Handling events3.3.1. Delegates and the MouseMove event3.3.2. Event handlers in IronPython3.4. Subclassing .NET types3.5. Summary
2. Core development techniques

4. Writing an application and design patterns with IronPython
4.1. Data modeling and duck typing4.1.1. Python and protocols4.1.2. Duck typing in action4.2. Model-View-Controller in IronPython4.2.1. Introducing the running example4.2.2. The view layer: creating a user interface4.2.3. A data model4.2.4. A controller class4.3. The command pattern4.3.1. The SaveFileDialog4.3.2. Writing files: the .NET and Python ways4.3.3. Handling exceptions and the system message box4.3.4. The SaveCommand4.3.5. The SaveAsCommand4.4. Integrating commands with our running example4.4.1. Menu classes and lambda4.4.2. .NET classes: ToolBar and images4.4.3. Bringing the GUI to life4.5. Summary
5. First-class functions in action with XML
5.1. First-class functions5.1.1. Higher order functions5.1.2. Python decorators5.1.3. A null-argument-checking decorator5.2. Representing documents with XML5.2.1. The .NET XmlWriter5.2.2. A DocumentWriter Class5.2.3. An alternative with an inner function5.3. Reading XML5.3.1. XMLReader5.3.2. An IronPython XmlDocumentReader5.4. Handler functions for MultiDoc XML5.5. The Open command5.6. Summary
6. Properties, dialogs, and Visual Studio
6.1. Document observers6.1.1. Python propertiesDocument Observers on the MainformMaking Document a PropertyRefactoring the TabController6.1.2. Adding the OpenCommand6.2. More with TabPages: dialogs and Visual Studio6.2.1. Remove pages: OK and Cancel dialog boxThe Code Behind6.2.2. Rename pages: a modal dialogFilling in the DialogThe RenameCommand6.2.3. Visual Studio Express and IronPython6.2.4. Adding pages: code reuse in action6.2.5. Wiring the commands to the view6.3. Object serializing with BinaryFormatter6.4. Summary
7. Agile testing: where dynamic typing shines
7.1. The unittest module7.1.1. Creating a TestCase7.1.2. setUp and tearDown7.1.3. Test suites with multiple modules7.2. Testing with mocks7.2.1. Mock objects7.2.2. Modifying live objects: the art of the monkey patchAttribute Lookup RulesThe Listener Class7.2.3. Mocks and dependency injection7.3. Functional testing7.3.1. Interacting with the GUI thread7.3.2. An AsyncExecutor for asynchronous interactions7.3.3. The functional test: making MultiDoc dance7.4. Summary
8. Metaprogramming, protocols, and more
8.1. Protocols instead of interfaces8.1.1. A myriad of magic methodsThe Length of ContainersRepresenting objects as stringsTruth testing of objects8.1.2. Operator overloading8.1.3. Iteration8.1.4. Generators8.1.5. Equality and inequality8.2. Dynamic attribute access8.2.1. Attribute access with built-in functions8.2.2. Attribute access through magic methods8.2.3. Proxying attribute access8.3. Metaprogramming8.3.1. Introduction to metaclasses8.3.2. Uses of metaclasses8.3.3. A profiling metaclass8.4. IronPython and the CLR8.4.1. .NET arraysCreateInstance and multidimensional arrays8.4.2. Overloaded methods8.4.3. out, ref, params, and pointer parameters8.4.4. Value types8.4.5. Interfaces8.4.6. Attributes8.4.7. Static compilation of IronPython code8.5. Summary
3. IronPython and advanced .NET
9. WPF and IronPython
9.1. Hello World with WPF and IronPython9.1.1. WPF from code9.1.2. Hello World from XAML9.2. WPF in action9.2.1. Layout with the Grid9.2.2. The WPF ComboBox and CheckBox9.2.3. The Image control9.2.4. The Expander9.2.5. The ScrollViewer9.2.6. The TextBlock: a lightweight document control9.2.7. The XamlWriter9.3. XPS documents and flow content9.3.1. FlowDocument viewer classesThe FlowDocumentReaderThe FlowDocumentPageViewer and FlowDocumentScrollViewer9.3.2. Flow document markupBasic Markup9.3.3. Document XAML and object tree processingHandling ImagesHandling Links9.4. Summary
10. Windows system administration with IronPython
10.1. System administration with Python10.1.1. Simple scripts10.1.2. Shell scripting with IronPythonParsing Command-line ArgumentsReading Onfiguration FilesWalking DirectoriesFiltering Filenames10.2. WMI and the System.Management assembly10.2.1. System.ManagementSimple WQL QueriesMonitoring EventsWQL, WMI Classes, and Events10.2.2. Connecting to remote computersConnection Authentication and ImpersonationQuerying Remote Computers10.3. PowerShell and IronPython10.3.1. Using PowerShell from IronPythonThe PowerShell RunspaceMultiple Commands and the Pipeline10.3.2. Using IronPython from PowerShellEmbedding IronPython in PowerShellCreating STA ThreadsAsynchronous Events without BlockingCalling Python Code and Returning Results10.4. Summary
11. IronPython and ASP.NET
11.1. Introducing ASP.NET11.1.1. Web controls11.1.2. Pages and user controls11.1.3. Rendering, server code, and the page lifecycle11.2. Adding IronPython to ASP.NET11.2.1. Writing a first application11.2.2. Handling an event11.3. ASP.NET infrastructure11.3.1. The App_Script folder11.3.2. The Global.py file11.3.3. The Web.config file11.4. A web-based MultiDoc Viewer11.4.1. Page structureData Binding11.4.2. Code-behindPage Lifecycle11.5. Editing MultiDocs11.5.1. Swapping controls11.5.2. Handling view state11.5.3. Additional events11.6. Converting the Editor into a user control11.6.1. View state again11.6.2. Adding parameters11.7. Summary
12. Databases and web services
12.1. Relational databases and ADO.NET12.1.1. Trying it out using PostgreSQLInstalling the Pieces12.1.2. Connecting to the database12.1.3. Executing commands12.1.4. Setting parameters12.1.5. Querying the database12.1.6. Reading multirow results12.1.7. Using transactions12.1.8. DataAdapters and DataSets12.2. Web services12.2.1. Using a simple web service12.2.2. Using SOAP services from IronPython12.2.3. REST services in IronPythonThe Notes Service Client ModuleThe Notes Service12.3. Summary
13. Silverlight: IronPython in the browser
13.1. Introduction to Silverlight13.1.1. Dynamic SilverlightEmbedding the Silverlight ControlThe xap File13.1.2. Your Python application13.1.3. Silverlight controlsUsing ControlsUsing the Extended ControlsExtended Controls from XAML13.1.4. Packaging a Silverlight application13.2. A Silverlight Twitter client13.2.1. Cross-domain policies13.2.2. Debugging Silverlight applications13.2.3. The user interfaceThe Grid, the ScrollViewer, and the HyperlinkButton13.2.4. Accessing network resourcesThe WebClientParsing the XML from TwitterPosting With WebClient13.2.5. Threads and dispatching onto the UI thread13.2.6. IsolatedStorage in the browser13.3. Videos and the browser DOM13.3.1. The MediaElement video player13.3.2. Accessing the browser DOM13.4. Summary
4. Reaching out with IronPython
14. Extending IronPython with C#/VB.NET
14.1. Writing a class library for IronPython14.1.1. Working with Visual Studio or MonoDevelop14.1.2. Python objects from class libraries14.1.3. Calling unmanaged code with the P/Invoke attribute14.1.4. Methods with attributes through subclassingCompiling Assemblies Without Visual Studio14.2. Creating dynamic (and Pythonic) objects from C#/VB.NET14.2.1. Providing dynamic attribute access14.2.2. Python magic methods14.2.3. APIs with keyword and multiple arguments14.3. Compiling and using assemblies at runtime14.4. Summary
15. Embedding the IronPython engine
15.1. Creating a custom executable15.1.1. The IronPython engine15.1.2. Executing a Python fileSetting the Command-line ArgumentsSetting the Search PathHandling Python Exceptions15.2. IronPython as a scripting engine15.2.1. Setting and fetching variables from a scope15.2.2. Providing modules and assemblies for the engine15.2.3. Python code as an embedded resource15.3. Python plugins for .NET applications15.3.1. A plugin class and registry15.3.2. Autodiscovery of user plugins15.3.3. Diverting standard output15.3.4. Calling the user plugins15.4. Using DLR objects from other .NET languages15.4.1. Expressions, functions, and Python types15.4.2. Dynamic operations with ObjectOperations15.4.3. The built-in Python functions and modules15.4.4. The future of interacting with dynamic objects15.5. Summary
A. A whirlwind tour of C#
A.1. NamespacesA.2. Using directiveA.3. ClassesA.4. AttributesA.5. InterfacesA.6. EnumsA.7. StructsA.8. MethodsA.8.1. Virtual and override methodsA.8.2. Other method modifiersA.8.3. Parameter passingA.8.4. Method overloadingA.9. DelegatesA.10. EventsA.11. Operator overloadingA.12. Properties and indexersA.13. LoopsA.13.1. while loopA.13.2. do loopA.13.3. for loopA.13.4. foreach loopA.14. CastsA.15. ifA.16. switchA.17. try/catch/finally and throwA.18. lockA.19. newA.20. nullA.21. using statementA.22. OperatorsA.23. Generics
B. Python magic methods
B.1. Object creationB.2. ComparisonB.3. MiscellaneousB.4. Containers and iterationB.4.1. Mapping and sequence protocol methodsB.4.2. Generator expressions and conditional expressionsB.5. Conversion to stringB.6. Attribute accessB.7. Numeric typesB.7.1. Arithmetic operationsB.7.2. Conversion between numeric typesB.8. Context managers and the with statementB.9. The descriptor protocolB.10. Magic attributesB.11. Functions and modules
C. For more information
C.1. IronPython and Python language sitesC.2. Mailing lists and newsgroupsC.3. Python and IronPython code examplesC.4. Learning PythonC.5. BlogsC.6. IronPython teamC.7. SilverlightC.8. .NET and MonoC.9. Dynamic languages on .NETC.10. IDEs and tools

Content preview from IronPython in Action

Chapter 8. Metaprogramming, protocols, and more

This chapter covers
Python protocols Dynamic attribute access Metaprogramming with metaclasses Advanced .NET interoperation

In this chapter, we’re going to look under the hood of the Python programming language. We’ve covered all the basic syntax and how to use classes from the .NET framework with IronPython. To make full use of Python, you need to know how to hook Python classes into the infrastructure that the language provides. As you write classes and libraries in Python, you’ll need to define how your objects take part in normal operations and interact with other objects. Much of this interaction is done through protocols, the magic methods that we’ve already briefly discussed.

We focus here on the ...

Become an O’Reilly member and get unlimited access to this title plus top books and audiobooks from O’Reilly and nearly 200 top publishers, thousands of courses curated by job role, 150+ live events each month,
and much more.

Read now

Unlock full access

More than 5,000 organizations count on O’Reilly

O’Reilly covers everything we've got, with content to help us build a world-class technology community, upgrade the capabilities and competencies of our teams, and improve overall team performance as well as their engagement.

Julian F.

Head of Cybersecurity

I wanted to learn C and C++, but it didn't click for me until I picked up an O'Reilly book. When I went on the O’Reilly platform, I was astonished to find all the books there, plus live events and sandboxes so you could play around with the technology.

Addison B.

Field Engineer

I’ve been on the O’Reilly platform for more than eight years. I use a couple of learning platforms, but I'm on O'Reilly more than anybody else. When you're there, you start learning. I'm never disappointed.

Amir M.

Data Platform Tech Lead

I'm always learning. So when I got on to O'Reilly, I was like a kid in a candy store. There are playlists. There are answers. There's on-demand training. It's worth its weight in gold, in terms of what it allows me to do.

Mark W.

Embedded Software Engineer

Publisher Resources

ISBN: 9781933988337Publisher Support Publisher Website

Cloud Computing

Data Engineering

Data Science

AI & ML

Programming Languages

Software Architecture

IT/Ops

Security

Design

Business

Soft Skills

IronPython in Action

by Michael Foord, Christian J. Muirhead

Chapter 8. Metaprogramming, protocols, and more

Become an O’Reilly member and get unlimited access to this title plus top books and audiobooks from O’Reilly and nearly 200 top publishers, thousands of courses curated by job role, 150+ live events each month,
and much more.