book

Professional IronPython™

Name: Professional IronPython™
Author: John Paul Mueller
ISBN: 9780470548592

by John Paul Mueller

April 2010

Intermediate to advanced

479 pages

12h 44m

English

Wrox

Read now

Unlock full access

Copyright
CREDITS
ABOUT THE AUTHOR
ABOUT THE TECHNICAL EDITOR
ACKNOWLEDGMENTS
INTRODUCTION
WHO THIS BOOK IS FORWHAT THIS BOOK COVERSHOW THIS BOOK IS STRUCTUREDWHAT YOU NEED TO USE THIS BOOKCONVENTIONSSOURCE CODEERRATAP2P.WROX.COM
I. Introducing IronPython
1. Discovering IronPython
1.1. AN OVERVIEW OF IRONPYTHON1.2. GETTING IRONPYTHON1.2.1. Understanding the IronPython Requirements1.2.2. Getting the Software1.2.3. Performing the Installation1.2.4. Building the Binaries from Scratch1.2.5. Using Third-Party Libraries1.3. UNDERSTANDING THE DYNAMIC LANGUAGE RUNTIME1.4. USING THE IRONPYTHON CONSOLE1.4.1. Opening and Using the Default Console1.4.2. Getting Help with Any Function1.4.3. Understanding the IPY.EXE Command Line Syntax1.4.3.1. Adding IPY.EXE to the Windows Environment1.4.3.2. Executing an Application from the Command Prompt1.4.3.3. Understanding the IPY.EXE Standard Command Line Switches1.4.3.4. Working with the –X: Command Line Switches1.4.3.5. Modifying the IPY.EXE Environment Variables1.4.4. Exiting the IronPython Interpreter1.5. USING THE IRONPYTHON WINDOWED ENVIRONMENT1.6. CREATING YOUR FIRST APPLICATION1.7. USING IRONPYTHON CONSTRUCTIVELY
2. Understanding the IronPython Basics
2.1. USING VISUAL STUDIO TO CREATE IRONPYTHON APPLICATIONS2.1.1. Creating the Project2.1.2. Adding Existing Files to the Project2.1.3. Adding New Files to the Project2.1.4. IronPython Project Limitations2.1.5. Debugging the Project2.2. UNDERSTANDING THE USE OF INDENTATION AND CAPITALIZATION IN IRONPYTHON2.3. CONSIDERING DATA TYPES IN IRONPYTHON2.4. EXPLORING THE IRONPYTHON MODULES2.4.1. Considering Built-in and External Modules2.4.2. Working with the Built-in Modules2.4.2.1. Considering the Immediately Available Modules2.4.2.2. Using sys.builtin_module_names2.4.3. Using External Modules with IronPython2.5. INTERACTING WITH THE IRONPYTHON ENVIRONMENT2.5.1. Obtaining Version Information2.5.2. Changing sys.path Values2.5.3. Obtaining Command Line Arguments2.6. USING IRONPYTHON CONSTRUCTIVELY
II. Using the IronPython Language

3. Implementing Structured Language Elements
3.1. STRINGING STATEMENTS TOGETHER3.2. SELECTING BETWEEN OPTIONS3.2.1. Performing a Simple Decision Using if3.2.2. Choosing between Two Options Using if . . . else3.2.3. Creating a Decision Tree Using if . . . elif . . . else3.3. CREATING LOOPS3.3.1. Using for ... in3.3.2. Using while3.4. PERFORMING ENUMERATIONS3.5. USING IRONPYTHON CONSTRUCTIVELY
4. Using Arrays and Collections
4.1. WORKING WITH TUPLES, LISTS, AND ARRAYS4.1.1. Understanding Tuples, Lists, and Arrays4.1.2. Creating and Accessing Single-Dimension Arrays4.1.3. Manipulating Single-Dimension Arrays4.1.4. Working with Multi-Dimension Arrays4.1.5. Using the range() Function4.1.6. Processing Arrays Using the break and else Clauses4.1.7. Processing Arrays Using the continue Clause4.1.8. Using the enumerate() Function4.2. WORKING WITH THE COLLECTIONS MODULE4.3. USING DICTIONARIES4.4. USING IRONPYTHON CONSTRUCTIVELY
5. Interacting with Structures and Objects
5.1. WORKING WITH EXISTING OBJECTS5.1.1. Discovering IronPython Objects5.1.2. Working with String Objects5.1.2.1. Performing Standard Tasks with Strings5.1.2.2. Formatting String Output5.1.3. Working with Numeric Objects5.1.3.1. Considering Numeric Type Differences5.1.3.2. Performing Standard Tasks with Numbers5.1.4. Working with Boolean Objects5.2. CREATING NEW OBJECTS5.2.1. Defining the IronPython Class5.2.2. Using Custom Objects in IronPython5.2.3. Adding Documentation5.3. USING IRONPYTHON CONSTRUCTIVELY
III. Working with IronPython
6. Using the Python Standard Library
6.1. CONSIDERING THE STANDARD LIBRARY FEATURES6.2. OBTAINING AND INSTALLING THE PYTHON STANDARD LIBRARY6.3. ACCESSING THE STANDARD LIBRARY FROM IRONPYTHON6.3.1. Manually Adding the Import Search Path6.3.2. Modifying the Site.py File6.4. USING THE STANDARD LIBRARY FEATURES6.4.1. Using the Module Documentation6.4.2. Using the Python Manuals6.4.3. Working with IDLE6.4.3.1. Configuring IDLE6.4.3.2. Performing an Interactive Edit6.4.3.3. Using the Path Browser6.4.3.4. Using the Class Browser6.4.3.5. Using the Debugger6.4.4. Looking for Standard Library Issues6.5. USING IRONPYTHON CONSTRUCTIVELY
7. Accessing the .NET Framework
7.1. IMPORTING THE .NET FRAMEWORK ASSEMBLIES7.1.1. Performing a Standard Import7.1.2. Importing an Assembly into the Global Namespace7.1.3. Configuring the Console for .NET Help7.1.4. Creating a Reference to .NET Assemblies7.2. USING .NET DATA TYPES7.3. INTERACTING WITH .NET FRAMEWORK ELEMENTS7.3.1. Obtaining Assembly Information7.3.2. Making Static Method Calls7.3.3. Creating .NET Objects7.3.4. Creating the Directory Example7.4. WORKING WITH GENERICS7.5. USING IRONPYTHON CONSTRUCTIVELY
8. Creating Windows Forms Applications
8.1. WORKING WITHOUT A VISUAL DESIGNER8.1.1. Understanding How the Visual Designer Works8.1.2. Understanding the Elements of a Window8.1.3. Emulating the Visual Designer Results8.2. DEFINING WINDOWS FORMS8.2.1. Creating the Window Code8.2.1.1. Creating the Basic Control Structure8.2.1.2. Making the Application Easier to Use8.2.1.3. Performing Quick Form Tests8.2.2. Initializing the Application8.2.3. Providing Handlers for the Control Events8.2.4. Performing Some Useful Work as the Result of User Input8.2.5. Running the Application8.3. INTERACTING WITH PREDEFINED AND CUSTOM EVENTS8.3.1. Handling Events Using Existing Classes8.3.2. Developing Your Own Events8.3.2.1. Creating the Event Class8.3.2.2. Devising an Event Class Test Form8.3.2.3. Running the Code8.4. USING IRONPYTHON CONSTRUCTIVELY
9. Interacting with COM Objects
9.1. AN OVERVIEW OF COM ACCESS DIFFERENCES WITH PYTHON9.2. CHOOSING A BINDING TECHNIQUE9.2.1. Understanding Early and Late Binding9.2.2. Using Early Binding9.2.3. Using Late Binding9.3. DEFINING AN INTEROP DLL9.3.1. Accessing the Visual Studio .NET Utilities9.3.2. Understanding the Type Library Import Utility9.3.3. Understanding the ActiveX Import Utility9.3.4. Creating the Windows Media Player Interop DLL9.3.5. Exploring the Windows Media Player Interop DLL9.3.5.1. Using the ILDasm Command Line9.3.5.2. Working with ILDasm Symbols9.3.5.3. Exploring ILDasm entries9.3.6. Using the Windows Media Player Interop DLL9.3.6.1. Working with ResGen9.3.6.2. Creating the Media Player Form Code9.3.6.3. Creating the Media Player Application Code9.4. PERFORMING LATE BINDING USING ACTIVATOR.CREATEINSTANCE()9.5. PERFORMING LATE BINDING USING MARSHAL.GETACTIVEOBJECT()9.6. USING IRONPYTHON CONSTRUCTIVELY
10. Using IronPython for Administration Tasks
10.1. UNDERSTANDING THE COMMAND LINE10.1.1. Understanding the Need for Command Line Applications10.1.2. Reading Data from the Command Line10.1.2.1. Using the Python Method10.1.2.2. Using the .NET Method10.1.3. Providing Command Line Help10.1.3.1. Creating an Application Description10.1.3.2. Describing the Application Calling Syntax10.1.3.3. Documenting the Command Line Switches10.1.3.4. Showing Usage Examples10.1.3.5. Putting Everything Together10.1.3.6. Including Other Elements10.2. INTERACTING WITH THE ENVIRONMENT10.2.1. Understanding Environment Variables10.2.2. Using the Python Method10.2.2.1. Reading the Environment Variables Using Python10.2.2.2. Setting the Environment Variables Using Python10.2.3. Using the .NET Method10.2.3.1. Reading the Environment Variables Using .NET10.2.3.2. Setting the Environment Variables Using .NET10.2.4. Environment Variable Considerations10.3. STARTING OTHER COMMAND LINE APPLICATIONS10.4. PROVIDING STATUS INFORMATION10.4.1. Reporting Directly to the User10.4.2. Creating Log Files10.4.3. Using the Event Log10.5. USING IRONPYTHON CONSTRUCTIVELY
11. Developing ASP.NET Applications
11.1. CONSIDERING IRONPYTHON WEB APPLICATION COMPATIBILITY11.2. OBTAINING ASP.NET DYNAMIC LANGUAGE SUPPORT11.2.1. DLR Limitations11.2.2. Getting DLR11.2.3. Using the Sample Applications11.3. CREATING A WEB SITE11.4. BUILDING A BASIC ASP.NET SITE USING IRONPYTHON11.4.1. Creating the Project11.4.2. Defining the User Interface11.4.3. Creating the Code Behind11.4.4. Starting the Visual Studio Built-In Web Server11.4.4.1. Understanding the WebDev.WebServer Command Line Syntax11.4.4.2. Using the Built-In Web Server with a Batch File11.4.4.3. Interacting with the Built-In Web Server11.4.4.4. Considering the Built-In Web Server Limitations11.4.5. Performing Basic Testing11.4.6. Considering Debugging11.5. USING IRONPYTHON CONSTRUCTIVELY
12. Debugging IronPython Applications
12.1. UNDERSTANDING IRONPYTHON WARNINGS12.1.1. Working with Actions12.1.2. Working with Messages12.1.3. Working with Categories12.2. OBTAINING ERROR INFORMATION12.2.1. Using the sys Module12.2.2. Using the traceback Module12.3. DEBUGGING WITH THE PYTHON DEBUGGER12.4. DEBUGGING WITH THE CLR DEBUGGER12.5. USING VISUAL STUDIO FOR IRONPYTHON DEBUGGING12.6. DEFINING AND USING EXCEPTIONS12.6.1. Implementing Python Exceptions12.6.2. Implementing .NET Exceptions12.7. USING IRONPYTHON CONSTRUCTIVELY
IV. Advanced IronPython Topics
13. Working with XML Data
13.1. USING THE .NET XML FUNCTIONALITY13.1.1. Considering the System.Xml Namespace13.1.2. Developing a Basic .NET XML Application13.2. USING XMLUTIL13.2.1. Loading and Viewing the XMLUtil Module13.2.2. Using the XMLUtil Module to View XML Data13.3. USING THE PYTHON MODULES13.3.1. Working with xml.dom.minidom13.3.2. Working with xml.sax13.4. USING IRONPYTHON CONSTRUCTIVELY
14. Interacting with the DLR
14.1. OBTAINING DLR14.1.1. Using the Direct Method14.1.2. Downloading the Full DLR14.1.3. Building the Full DLR14.1.3.1. Performing a Command Line Build14.1.3.2. Performing a Visual Studio 2008 Build14.1.3.3. Performing a Visual Studio 2010 Build14.1.4. Downloading the Documentation14.1.5. Reporting Bugs and Other Issues14.2. WORKING WITH HOSTING APIS14.2.1. Using the Hosting APIs14.2.2. Understanding the Hosting APIs Usage Levels14.2.3. Considering the Host Application14.2.4. Embedding IronPython as a Scripting Language14.3. UNDERSTANDING THE EXTENSIONS TO LINQ EXPRESSION TREE14.4. CONSIDERING DYNAMICSITE14.5. WORKING WITH IDYNAMICOBJECT14.6. UNDERSTANDING THE ACTIONBINDER14.7. UNDERSTANDING THE OTHER DLR FEATURES14.8. USING IRONPYTHON CONSTRUCTIVELY
15. Using IronPython from Other .NET Languages
15.1. UNDERSTANDING THE RELATIONSHIP BETWEEN DYNAMIC AND STATIC LANGUAGES15.2. CREATING AN EXTERNALLY ACCESSIBLE IRONPYTHON MODULE15.2.1. Considering Requirements for Externally Accessible Modules15.2.2. Creating the IronPython Script15.3. ACCESSING THE MODULE FROM C#15.3.1. Adding the Required C# References15.3.2. Adding the Required References to the Host Language15.3.3. Understanding the Use of ScriptEngine15.3.4. Using the dynamic Keyword15.3.5. Working with the App.CONFIG File15.4. ACCESSING THE MODULE FROM VISUAL BASIC.NET15.4.1. Adding the Required Visual Basic.NET References15.4.2. Creating the Visual Basic.NET Code15.5. DEVELOPING TEST PROCEDURES FOR EXTERNAL MODULES15.6. DEBUGGING THE EXTERNAL MODULE15.7. USING IRONPYTHON CONSTRUCTIVELY
16. Extending IronPython Using C#
16.1. UNDERSTANDING THE REQUIREMENTS FOR AN EXTENSION16.2. CONSIDERING IRONPYTHON AND STATIC LANGUAGE DIFFERENCES16.2.1. Defining Why You Use a Static Language with IronPython16.2.2. Understanding Line Noise16.2.3. Considering Scoping Issues16.3. CREATING THE SIMPLE C# EXTENSION16.3.1. Creating the Project16.3.2. Developing the C# Extension16.3.3. Adding the IronPython Project16.3.4. Creating the IronPython Application16.4. USING C# FOR USER INTERFACE SUPPORT16.4.1. Defining a Library of Dialog Boxes16.4.2. Creating the Dialog Box Library in C#16.4.2.1. Defining Simple Message Boxes16.4.2.2. Using Enumerations with IronPython16.4.2.3. Considering Developer Help16.4.2.4. Defining Complex Forms16.4.3. Accessing the Dialog Box Library from IronPython16.4.3.1. An Alternative Method for Adding the IronPython Project16.4.3.2. Performing the Message Box and Form Tests16.5. USING C# FOR WIN32 SUPPORT16.5.1. Creating the P/Invoke Code16.5.2. Developing the IronPython Callable Methods16.5.2.1. Defining Common Variables and the Constructor16.5.2.2. Defining the GetCurrentDisplayMode() Method16.5.2.3. Defining the GetConsoleWindowSize() Method16.5.2.4. Defining the GetConsoleInfo() Method16.5.3. Writing an IronPython Application to Use P/Invoke16.6. USING IRONPYTHON CONSTRUCTIVELY
17. Extending IronPython Using Visual Basic.NET
17.1. CONSIDERING C# AND VISUAL BASIC.NET EXTENSION SIMILARITIES17.2. CREATING THE SIMPLE VISUAL BASIC.NET EXTENSION17.2.1. Creating the Project17.2.2. Developing the Visual Basic.NET Extension17.2.3. Adding the IronPython Project17.2.4. Creating the IronPython Application17.3. USING VISUAL BASIC.NET FOR USER INTERFACE SUPPORT17.3.1. Creating the User Interface Library Module17.3.1.1. Defining Simple Message Boxes17.3.1.2. Defining Complex Forms17.3.2. Accessing the User Interface Library Module from IronPython17.3.2.1. An Alternative Method for Adding the IronPython Project17.3.2.2. Performing the Message Box and Form Tests17.4. USING VISUAL BASIC.NET FOR DATABASE SUPPORT17.4.1. Obtaining and Configuring the Database17.4.2. Creating the Database Support Module17.4.2.1. Creating a Connection to the Database17.4.2.2. Adding Database Manipulation Code17.4.3. Accessing the Database Module through IronPython17.5. USING IRONPYTHON CONSTRUCTIVELY
18. Using IronPython for Application Testing
18.1. UNDERSTANDING WHY YOU WANT TO USE IRONPYTHON FOR TESTING18.2. CONSIDERING THE TEST ENVIRONMENT18.2.1. Defining Access18.2.2. Considering a Few Things IronPython Can't Test18.2.3. Creating the Test Harness18.3. TESTING DLLS18.3.1. Creating the Test DLL18.3.2. Creating the DLL Test Script18.3.3. Performing the DLL Test18.4. TESTING APPLICATIONS18.4.1. Creating the Test Application18.4.1.1. Defining the Form18.4.1.2. Building the Code18.4.2. Creating the Application Test Script18.4.3. Performing the Application Test18.5. PERFORMING COMMAND LINE TESTS18.6. USING IRONPYTHON CONSTRUCTIVELY
19. Using IronPython with Mono
19.1. WHAT IS MONO?19.1.1. An Overview of the Mono Family19.1.2. Considering the Reasons for Using Mono19.1.3. Understanding Mono Limitations19.1.4. Using Mono on Windows Server 2008 Server Core19.2. OBTAINING AND INSTALLING MONO19.3. CREATING AN IRONPYTHON APPLICATION WITH MONO19.3.1. Working at the Command Line19.3.2. Defining the Project19.3.3. Creating the Code19.3.4. Running the Application from the IDE19.3.5. Running the Application from the Command Line19.4. INTERACTING WITH OTHER .NET LANGUAGES UNDER MONO19.5. USING IRONPYTHON CONSTRUCTIVELY
A. IronPython Differences with CPython
A.1. IMPLEMENTING STANDARD TYPES, FUNCTIONS, AND BEHAVIORSA.2. MISSING CPYTHON LIBRARIESA.3. MISSING OR CHANGED EXTENSION MODULESA.4. USING CUSTOM CPYTHON EXTENSIONSA.5. INTERACTING WITH THE INTERPRETER AND ENVIRONMENTA.6. USING GARBAGE COLLECTION
B. CPython Extensions for IronPython
B.1. OBTAINING THE EXTENSIONSB.2. OVERCOMING POTENTIAL EXTENSION PROBLEMSB.3. OBTAINING THIRD-PARTY SOLUTIONSB.3.1. Considering Some of the Better SolutionsB.3.2. Working with IronClad

Content preview from Professional IronPython™

Chapter 8. Creating Windows Forms Applications

WHAT'S IN THIS CHAPTER?

Creating a form design without using the Visual Designer
Building a Windows Forms application
Using events and delegates in IronPython

Most of the applications you've worked with in the book so far rely on a character-mode interface. Of course, character-mode is just fine when you're dealing with utilities or example applications, but most users want a GUI. The idea of typing commands at the command prompt is so foreign to most of today's users that you'd never get them all trained to use your application.

Fortunately, you can create a number of graphical application types using IronPython. Unfortunately, many of the graphical programming tools available to Python developers won't work with IronPython because IronPython lacks support for C-style libraries. This is a situation where you really do need Windows Forms support to provide what the user needs in the way of an application.

The problem for the IronPython developer is that IronPython isn't integrated into Visual Studio. Consequently, you won't have Visual Designer support in a pure IronPython environment. (Chapters 16 and 17 show how to overcome this problem by using either C# or Visual Basic.NET to produce the user interface.) This chapter discusses some ways in which you can produce a great interface without using the Visual Designer.

A graphical interface naturally implies writing code that responds to events (handlers) and providing the code required to produce ...

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

What Successful Brick-and-Mortar Retailers Get Right

Publisher Resources

ISBN: 9780470548592Purchase book

Cloud Computing

Data Engineering

Data Science

AI & ML

Programming Languages

Software Architecture

IT/Ops

Security

Design

Business

Soft Skills

Professional IronPython™

by John Paul Mueller

Chapter 8. Creating Windows Forms Applications

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.