IronPython Tutorial
A tour of Python on .NET
Information in this document is subject to change without notice. The example companies, organizations, products, people, and events depicted herein are fictitious. No association with any real company, organization, product, person or event is intended or should be inferred. Complying with all applicable copyright laws is the responsibility of the user. Without limiting the rights under copyright, no part of this document may be reproduced, stored in or introduced into a retrieval system, or transmitted in any form or by any means (electronic, mechanical, photocopying, recording, or otherwise), or for any purpose, without the express written permission of Microsoft Corporation.
Microsoft may have patents, patent applications, trademarked, copyrights, or other intellectual property rights covering subject matter in this document. Except as expressly provided in any written license agreement from Microsoft, the furnishing of this document does not give you any license to these patents, trademarks, copyrights, or other intellectual property.
© Microsoft Corporation. All rights reserved.
Microsoft, MS-DOS, MS, Windows, Windows NT, MSDN, Active Directory, BizTalk, SQL Server, SharePoint, Outlook, PowerPoint, FrontPage, Visual Basic, Visual C++, Visual J++, Visual InterDev, Visual SourceSafe, Visual C#, Visual J#, and Visual Studio are either registered trademarks or trademarks of Microsoft Corporation in the U.S.A. and/or other countries.
Other product and company names herein may be the trademarks of their respective owners.
Contents
Tutorial 1: Basic IronPython
Exercise 1: The IronPython interactive console
Task 1: IronPython console
Task 2: Built-in modules and interactive exploration
Task 3: External Python modules
Exercise 2: Using the standard .NET libraries from IronPython
Task 1: Basic .NET library use
Task 2: Working with .NET classes
Task 3: Generics
Exercise 3: Loading .NET libraries
Task 1: Using System.Xml - AddReference
Task 2: Mapack - Loading the .NET libraries - AddReferenceToFile
Exercise 4: Obtaining and Using Python Standard Library
Task 1: Configuring IronPython to use the Python standard library
Tutorial 2: Advanced IronPython
Exercise 1: Events and Delegates
Task 1: File System Watcher
Task 2: Improving the event handler
Task 3: Defining events in Python
Exercise 2: Windows Forms
Task 1: Simple Windows Forms application
Exercise 3: Windows Presentation Foundation (Avalon)
Task 1: Simple Avalon Application
Task 2: Avalon calculator
Tutorial 3: IronPython and COM interoperability
Exercise 1: Merlin the Wizard
Task 1: Creating COM interop assemblies
Task 2: Using COM objects from IronPython
Exercise 2: Use Word for Spell Checking
Task 1: Accessing Word and Checking Spelling
Task 2: Use Windows Form Dialog to Correct Spelling
Tutorial 4: Debugging IronPython program
Exercise 1: Debugging IronPython programs
Task 1: Debugging IronPython programs using Microsoft CLR Debugger
Tutorial 5: Extending IronPython
Exercise 1: Extending using C#
Task 1: Implementing simple class - constructor and ToString
Task 2: Making the object enumerable
Task 3: Adding custom operator
Task 4: Adding delegate
Exercise 2: Extending using Visual Basic.NET
Task 1: Implementing simple class - constructor and ToString
Task 2: Making the object enumerable
Task 3: Adding custom operator
Task 4: Adding delegate
Tutorial 6: Embedding IronPython
Exercise 1: IronPython as an expression evaluator
Task 1: IronPython as an expression evaluator
Exercise 2: IronPython as application's scripting engine
Task 1: Embedding IronPython in an application
Task 2: Handling IronPython exceptions gracefully
Task 3: Redirecting the engine's output streams
Tutorial 7: Using Visual Studio to Edit .py Files and Debug Them
Exercise 1: Setting up Visual Studio for IronPython Debugging
IronPython is the .NET implementation of the Python programming language (www.python.org). It's a dynamically typed language with support for many programming paradigms such as object-oriented programming, and also allows you to seamlessly use .NET code.
The goal of this tutorial is to quickly
familiarize you with the IronPython console, and to show you how to make use of the extensive .NET libraries available.
This tutorial also shows you how to get started in more specialized areas
such as interoperating with COM, extending IronPython with C#, and embedding
IronPython. This tutorial is NOT meant to be an introduction to Python
itself, and if you're looking for that, we recommend you start with the
tutorial at www.python.org
or the often recommend book Learning Python by Mark Lutz and David
Ascher.
Some of the exercises in this tutorial require prerequisites. The prerequisites to successfully complete the whole tutorial are:
Visual Studio 2005 can be used in place of the Microsoft .NET Framework Version 2.0 and the .NET Framework 2.0 Software Development Kit (SDK). Since Visual Studio 2005 installs both the .NET Framework 2.0 and the .NET Framework SDK, there is no need to install those explicitly if you have Visual Studio 2005 available.
This tutorial assumes that the IronPython distribution was uncompressed into the directory C:\IronPython. Please note that your individual setup may vary.
This tutorial also assumes that you will launch the IronPython console (c:\ironpython\ipy.exe) from the tutorial directory. When the tutorials direct you to start the IronPython console from the tutorial directory, you should change to the tutorial directory (>cd c:\ironpython\tutorial) and launch the console with the tutorial as your working directory (>..\ipy.exe).
The emphasis of this tutorial is on the basic interaction with the IronPython interpreter and using the interactive environment to explore the .NET libraries.
Estimated time to complete this tutorial: 30 minutes
The objective of this tutorial is to launch the IronPython interpreter, explore the environment of the interactive console and use IronPython to interact with .NET libraries.
The exercises in this tutorial are:
In this exercise, you will start the IronPython interactive interpreter and perform simple tasks to become acquainted with the IronPython environment.
If you are familiar with using the Python interactive console, the import statement and exploring the Python interactive environment using dir() function and __doc__ attribute, you can skip this exercise.
Start the IronPython console from the tutorial directory by changing to the tutorial directory (>cd c:\ironpython\tutorial) and launching the console c:\ironpython\ipy.exe executable (>..\ipy.exe). This is how you should always launch the console for the tutorials, but from now on, we'll just direct you to "start the IronPython console from the tutorial directory".
IronPython 1.0 on .NET 2.0.50727.42
Copyright (c) Microsoft Corporation. All rights reserved.
>>> _
Execute simple statements listed below. After each statement IronPython prints the result, if any, and awaits more input. (The input line starting with "for" requires an extra return or enter key press because the interpreter prompts for more statements in the 'for' loop.)
2+2
print "Hello World!"
for i in range(3): print i
x = 10
print x
After this step, the console window will contain the following text:
>>> 2+2
4
>>> print "Hello World!"
Hello World!
>>> for i in range(3): print i
...
0
1
2
>>> x = 10
>>> print x
10
>>>
IronPython console supports multi-line statements, often used by function definitions. IronPython prompts for additional lines of multi-line statements using:
...
Unlike C# or Java, where blocks of code are grouped by curly brackets "{...}", blocks of code in Python are grouped based on their level of indentation. Every new block of code must be indented one more level than the previous block of code. Blocks of code are used for function and class definitions as well as 'if' statements and loops.
Define the "add" function (note, you need to enter spaces before the 'return' statement):
def add(a, b):
return a + b
To complete the function definition, press Enter once more at this point
add(3, 2)
add("Iron", "Python")
After this step, the console contents will be:
>>> def add(a, b):
... return a + b
...
>>> add(3, 2)
5
>>> add("Iron", "Python")
'IronPython'
>>>
To exit the IronPython interactive console, type Ctrl+Z and Enter (alternatively, press F6 followed by Enter).
^Z
Start the IronPython console from the tutorial directory (see Introduction for details).
Using the built-in dir() function, list the contents of the IronPython environment:
dir()
The output in the console window will be:
>>> dir()
['__builtins__', '__doc__', '__name__']
>>>
IronPython comes with several built-in modules, the most frequently used one being "sys". Import "sys" module using the "import" statement:
import sys
The Python import statement is similar to the "using" statement of C# or "Imports" statement of Visual Basic. The important difference is that the C# and VB statements bring the names from the imported namespace into to the global namespace to be accessed directly. Python’s import doesn’t do that. To access the names or attributes in an imported module, prefix the names with the module's name:
sys.version
Use the dir() function to explore the environment:
dir()
The environment (global namespace) has changed, now it contains the "sys" module:
>>> dir()
['__builtins__', '__doc__',
'__name__', 'sys']
>>>
Use the dir() function to explore the contents of the "sys" module:
dir(sys)
Print the values of some of the "sys" module attributes:
sys.path
sys.executable
This task uses the module "first.py" located in the Tutorial folder.
Import the "first.py" module located in the Tutorial (because you launched ipy.exe from the Tutorial directory, "first" will be found on your sys.path):
import first
Explore the module "first" using dir() function:
dir(first)
>>> dir(first)
['__builtins__', '__doc__', '__file__', '__name__', 'add', 'factorial', 'hi']
Print the documentation for the "add" and "factorial" functions, using __doc__ attribute:
first.add.__doc__
first.factorial.__doc__
The __doc__ attribute will be later used also for exploring .NET methods and their parameter types.
>>> first.add.__doc__
'add(a, b) -> returns a + b'
>>> first.factorial.__doc__
'factorial(n) -> returns factorial of n'
>>>
Call the methods in the "first" module and print the contents of the "hi" attribute
first.add(1,2)
first.factorial(5)
first.hi
The expected output is:
>>> first.add(1,2)
3
>>> first.factorial(5)
120
>>> first.hi
'Hello from IronPython!'
Exit the IronPython Interactive console (Ctrl+Z or F6 followed by Enter)
The power of IronPython lies within the ability to seamlessly access the wealth of .NET libraries. This exercise will demonstrate how the .NET libraries can be used from IronPython.
In this exercise, you will use the standard .NET libraries from IronPython.
Start the IronPython console from the tutorial directory (see Introduction for details).
Using the "import" statement, import the .NET System namespace:
import System
Explore the System.Environment class and access some of its properties:
dir(System.Environment)
System.Environment.OSVersion
System.Environment.CommandLine
The expected output of these commands is as follows (with some ellipsis for convenience):
>>> dir(System.Environment)
['CommandLine', ..., 'OSVersion', ... ]
>>> System.Environment.OSVersion
Microsoft Windows NT 5.2.3790 Service Pack 1
>>> System.Environment.CommandLine
'C:\\IronPython\\ipy.exe'
>>>
The import statement can be used also to import contents of a class or module into the global namespace. Use the "from ... import ..." flavor of the import statement to do that and explore the contents of the global namespace using dir().
from System.Math import *
dir()
Now you can call Math methods without having to specify the namespace and class name prefix:
Sin(PI/2)
The expected output is:
>>> from System.Math import *
>>> dir()
['Abs', 'Acos', 'Asin', 'Atan', 'Atan2', 'BigMul', 'Ceiling', 'Cos', 'Cosh', 'DivRem', 'E', 'Equals', 'Exp', 'Floor', 'GetHashCode', 'GetType', 'IEEERemainder', 'Log', 'Log10', 'Max', 'Min', 'PI', 'Pow', 'Round', 'Sign', 'Sin', 'Sinh', 'Sqrt', 'System', 'Tan', 'Tanh', 'ToString', 'Truncate', '__builtins__', '__doc__', '__name__']
>>> Sin(PI/2)
1.0
Import the contents of the "System.Collections" namespace into the global namespace:
from System.Collections import *
Create instance of the Hashtable class and explore the instance using dir():
h = Hashtable()
dir(h)
Insert a few elements into the hash table:
h["a"] = "IronPython"
h["b"] = "Tutorial"
IronPython supports the C# - style syntax for accessing the hash table elements. The same syntax applies to any index-able object (Arrays, Array lists etc):
h["a"]
The output of this step will be:
>>> h["a"] = "IronPython"
>>> h["b"] = "Tutorial"
>>> h["a"]
'IronPython'
Enumerate the contents of the hash table using the "for ... in ..." statement. The hash table elements are instances of "DictionaryEntry" class. Print the "Key" and "Value" properties of each entry:
for e in h: print e.Key, ":", e.Value
The expected output in the console is (the input line starting with "for" requires an extra return or enter key press because the interpreter prompts for more statements in the 'for' loop.):
>>> for e in h: print e.Key, ":", e.Value
...
a : IronPython
b : Tutorial
You can initialize the collection classes by passing in the Python built-in list or tuple data types as arguments. You can create a Python list by specifying the list of elements in square brackets: [1,2,3]. You create tuples by specifying elements in the parentheses: (1,2,3).
l = ArrayList([1,2,3])
for i in l: print i
s = Stack((1,2,3))
while s.Count: s.Pop()
The expected output is:
>>> l = ArrayList([1,2,3])
>>> for i in l: print i
...
1
2
3
>>> s = Stack((1,2,3))
>>> while s.Count: s.Pop()
...
3
2
1
Import the Generic collections from the System.Collections.Generic namespace
from System.Collections.Generic import *
To instantiate a generic class, the generic type arguments must be specified. IronPython uses the following syntax to specify the type arguments: generic_type[type_argument, ...]. Create instance of generic list of string:
l = List[str]()
Add string values into the list. Since we created list of string, adding string is possible:
l.Add("Hello")
l.Add("Hi")
Try adding objects of types other than string:
l.Add(3)
l.Add(2.5)
l.Add([1,2,3])
Obviously, adding non-strings will fail with type error:
>>> l.Add(3)
Traceback (most recent call last):
...
ValueError: The value "3" is not of type "System.String" and cannot be used in this generic collection.
Parameter name: value
Enumerate the generic collection:
for i in l: print i
The output will be:
>>> for i in l: print i
...
Hello
Hi
Exit the IronPython Interactive console (Ctrl+Z or F6 followed by Enter)
IronPython can directly import only some of the .NET libraries - the most commonly used ones. To use additional .NET libraries, they must be explicitly referenced. IronPython maintains a list of all referenced assemblies (see clr.References in Task 1). To add a reference to a .NET assembly, use the functions available in the built-in "clr" module:
clr.AddReference adds a reference to the .NET assembly either by passing the .NET assembly object directly, or specifying the file name or the assembly name (full or partial). This function is provided primarily for the interactive exploration. We recommend using the following functions in the code modules, since they provide more control over which assembly is being loaded.
clr.AddReferenceToFile adds reference to the assembly specified by its file name. This function will load the assembly from the file regardless of the assembly version. As a result, it doesn't guarantee that the correct assembly version is being loaded. To guarantee that correct assembly version is being loaded, use clr.AddReferenceByName. Moreover, AddReferenceToFile requires that the assembly be located in a directory listed in sys.path.
clr.AddReferenceToFileAndPath provides similar functionality to AddReferenceToFile. The difference is that it accepts absolute path and before loading the assembly, AddReferenceToFileAndPath adds the file path into sys.path.
clr.AddReferenceByName adds reference to the assembly specified by its full assembly name, for example: 'System.Xml, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089'.
clr.AddReferenceByPartialName adds reference to the assembly by specifying a partial assembly name. This function cannot guarantee that the correct version of the assembly is being loaded. Use clr.AddReferenceByName to add reference to specific version of the assembly.
Start the IronPython console from the tutorial directory (see Introduction for details).
To import System.Xml, the reference to the assembly containing the Xml components must be first added to IronPython. Add reference to System.Xml using the following code (you can enter "clr.References" before and after the call to clr.AddReference to see it change if you want):
import clr
clr.AddReference("System.Xml")
from System.Xml import *
dir()
Note that the clr.AddReference function accepts either System.Reflection.Assembly object or string as a parameter. The string parameter can be a full assembly name, a partial assembly name, or a file name. For more control over the assembly references, use the appropriate functions described above.
For example, consider the following alternatives for the statement clr.AddReference("System.Xml") above:
clr.AddReferenceByName('System.Xml, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089')
clr.AddReferenceByPartialName("System.Xml")
Load the XML file "Releases.xml" into the XmlDocument. The xml file contains the release dates of all versions of IronPython between 0.7 and 0.9.4. For direct viewing, the Releases.xml file is located in "Releases.xml"
d = XmlDocument()
d.Load("Releases.xml")
We can now query the document. Query for all released versions of IronPython using the query below:
n = d.SelectNodes("//@Version")
for e in n: print e.Value
The output in the console window will be:
>>> n = d.SelectNodes("//@Version")
>>> for e in n: print e.Value
...
0.7
0.7.1
0.7.2
0.7.3
0.7.4
0.7.5
0.7.6
0.9
0.9.1
0.9.2
0.9.3
0.9.4
(Optional) Import the "xmlutil.py" module located in the Tutorial directory and use the function provided in the module to walk the contents of the Xml document:
import xmlutil
for e in xmlutil.Walk(d): print e.Name, e.Value
The Walk function is a generator (a Python function that contains a "yield" statement). As the Walk function executes, it returns (yields) the XML nodes one by one to the caller who iterates over the generator. The source for the Walk function is:
def Walk(xml):
yield xml
if hasattr(xml, "Attributes"):
attrs = xml.Attributes
if attrs:
for attr in attrs:
yield attr
for child in xml:
for c in Walk(child):
yield c
Exit the IronPython Interactive console (Ctrl+Z or F6 followed by Enter)
This task requires the Mapack.dll library for linear algebra computations. The library is not part of the IronPython distribution. See prerequisites for download details.
Start the IronPython console from the tutorial directory (see Introduction for details).
Use the clr.AddReferenceToFile function to load the Matrix library "Mapack.dll":
import clr
clr.AddReferenceToFile("Mapack.dll")
from Mapack import *
dir()
The expected output will be:
>>> import clr
>>> clr.AddReferenceToFile("Mapack.dll")
>>> from Mapack import *
>>> dir()
['CholeskyDecomposition', 'EigenvalueDecomposition', 'LuDecomposition', 'Matrix', 'QrDecomposition', 'SingularValueDecomposition', '__builtins__', '__doc__', '__name__', 'clr', 'sys']
Create instance of Matrix class:
m = Matrix()
Oops, bad arguments for the constructor. In the next step you'll learn the way to discover the constructors available.
>>> m = Matrix()
Traceback (most recent call last):
at <shell>
TypeError: Matrix() takes at least 1 argument (0 given)
Using the __doc__ attribute, find out information about Matrix constructors:
print Matrix.__new__.__doc__
>>> print Matrix.__new__.__doc__
__new__(int, int)
__new__(int, int, float)
__new__(System.Double[][])
Create instances of the Matrix class using the correct constructors and set some matrix elements manually. IronPython supports custom indexing on .NET classes.
m = Matrix(2, 2, 1.2)
n = Matrix(2,1)
n[0,0] = 4
print m
print n
>>> m = Matrix(2, 2, 1.2)
>>> n = Matrix(2,1)
>>> n[0,0] = 4
>>> print m
1.2 0
0 1.2
>>> print n
4
0
(Optional) IronPython also supports overloaded operators. Matrix does overload operators +, - (binary and unary) and *. You can see Python representation of the operators (__add__, __mul__, __sub__, ...) using dir():
dir(m)
Make simple calculations with the matrices:
m * n
n.Transpose() * m
m * 3
n + -n
The expected output of this step is:
>>> m * n
4.8
0
>>> n.Transpose() * m
4.8 0
>>> m * 3
3.6 0
0 3.6
>>> n + -n
0
0
Exit the IronPython Interactive console (Ctrl+Z or F6 followed by Enter)
In this exercise, you will obtain Python and point IronPython at the Python standard library.
Download the latest Python installer from http://www.python.org/download/ and install Python. The rest of this exercise will assume you used defaults (and installed to c:\python24, for example).
Create a file named "site.py" and place it into your IronPython "Lib" directory. There might be one there already, so you can just edit it. The "site.py" file is executed every time you run IronPython. To tell IronPython where the Python standard library is, you can add the "lib" directory of Python to IronPython's path. To do so, put the following code into IronPython's "site.py" file (replace c:\python24\lib with your actual path to the Python lib directory):
import sys
sys.path.append(r"c:\python24\lib")
Start the IronPython console from the tutorial directory (see Introduction for details).
Now you can use the Python standard library from IronPython, for example to get the current working directory (output uses assumed location of your IronPython installation):
import os
os.getcwd()
'C:\\ironpython\\Tutorial'
Tutorial Summary
In this tutorial you performed the following exercises.
In this tutorial, you became acquainted with IronPython interactive console, including the dynamic exploratory way of development using the dir() function and __doc__ attribute to explore the environment. You learned to load and import .NET libraries from IronPython (using the import statement), create instances of .NET classes (including generic classes), call methods, enumerate .NET collections, and even use overloaded operators on .NET objects. Finally, you learned how to access standard Python libraries.
The large part of the beauty of IronPython lies within the dynamic-style development -- modifying the live application by adding functioning elements to it. With Windows applications, this often requires delegates and event handling (i.e., adding a button to an existing form and adding functionality to the button to handle the user pressing the button).
This tutorial will focus on creating delegates, handling events in IronPython, and creating Windows applications using Windows Forms and the new Windows Presentation Foundation (formerly known as Avalon).
Estimated time to complete this tutorial: 25 minutes
The objective of this tutorial is to learn how to create delegates and handle events using IronPython, and to use that knowledge to build working Windows applications using Windows Forms and Windows Presentation Foundation.
In this exercise, you will create a simple event handler and learn how to explore event handler use. The event handler we'll use in this exercise is the FileSystemWatcher - a component that raises events on file system changes.
Start the IronPython console from the tutorial directory (see Introduction for details).
Import the contents of System.IO into the global namespace:
from System.IO import *
Create instance of the FileSystemWatcher class and set Path property to watch over the current directory:
w = FileSystemWatcher()
dir(w)
w.Path = "."
Create the function to handle the events. Because we don't know yet what arguments the delegate will have, let's accept any number of arguments (the *arg notation):
def handle(*args): print args
Register the event handler for the 'Changed', 'Created', and 'Deleted' events:
w.Changed += handle
w.Created += handle
w.Deleted += handle
Enable the watcher to raise events:
w.EnableRaisingEvents = True
Open the Tutorial folder and create a file. An easy way to create the file is to right-click with the mouse and select "New\Text Document". The file watcher will raise the "Created" event.
You can then open the file in Notepad, type in any text, and save the file. This raises the "Changed" event. Then finish by deleting the file to see the "Deleted" event get raised.
At the end of this step, the output in the command window will be similar to the following:
(System.IO.FileSystemWatcher, <System.IO.FileSystemEventArgs
object at 0x03CE0BB8>)
(System.IO.FileSystemWatcher, <System.IO.FileSystemEventArgs object at 0x039B3B4D>)
(System.IO.FileSystemWatcher, <System.IO.FileSystemEventArgs object at 0x039B3B4D>)
(System.IO.FileSystemWatcher, <System.IO.FileSystemEventArgs object at 0x014EF022>)
In the next task, we will create an improved event handler. For now, remove the current event handler from the file watcher events:
w.Changed -= handle
w.Created -= handle
w.Deleted -= handle
(Optional) You can try step 7 again to see that the events, while they are still being raised, are not being handled by the Python "handler" function.
In the previous task, step 7 we can see that the types of the parameters passed to all three events were the same:
FileSystemWatcher - the instance of the object that raised the event
FileSystemEventArgs - the information about the event raised
Use dir() to explore the event arguments class to find what information the event contains:
dir(FileSystemEventArgs)
The output in the console window will be:
>>> dir(FileSystemEventArgs)
['ChangeType', 'Empty', 'Equals', 'Finalize', 'FullPath', 'GetHashCode', 'GetType', 'MakeDynamicType', 'MemberwiseClone', 'Name', 'Reduce', 'ReferenceEquals', 'ToString', '__class__', '__doc__', '__init__', '__module__', '__new__', '__reduce__', '__reduce_ex__', '__repr__']
Now with more knowledge of the event argument properties, we can create a better event handler that will print ChangeType and FullPath properties of the event argument object:
def handle(w, a): print a.ChangeType, a.FullPath
Register the new event handler for the 'Changed', 'Created' and 'Deleted' events:
w.Changed += handle
w.Created += handle
w.Deleted += handle
Make sure the raising of the events is enabled:
w.EnableRaisingEvents = True
Open the Tutorial folder again and create a new file ("Created" event), edit the file in Notepad and save it ("Changed" event) and finish by deleting the file ("Deleted" event).
At the end of this step, the output in the command window will be similar to the following:
Created .\New Text Document.txt
Changed .\New Text Document.txt
Changed .\New Text Document.txt
Deleted .\New Text Document.txt
Remove the event handler from the file watcher events:
w.Changed -= handle
w.Created -= handle
w.Deleted -= handle
Exit the IronPython Interactive console (Ctrl+Z or F6, followed by Enter).
Finally let's look at how we can get event handler syntax from Python code:
pyevent - a module providing Python event support
make_event - a function that returns an event tuple containing both the callable object and the object that allows connecting and unconnecting to the event.
To create an event:
import pyevent
hook,caller = pyevent.make_event()
This has returned back to us two objects. The first object allows a user to hook a function up to the event. The second object allows the owner of the event to cause the event to be raised. This allows for the separation of these abilities just like .NET. Now let's take this and put it into a class and see how it gets used.
We'll define a class that has an event for
class MyClass(object):
OnNewInstance,_NewInstance= pyevent.make_event()
def __new__(cls):
res = object.__new__(object)
MyClass._NewInstance(res)
def NewInst(x): print 'new inst: ', x
MyClass.OnNewInstance += NewInst
a = MyClass()
Just like with CLR events you can also remove event handlers:
MyClass.OnNewInstance -= NewInst
To interactively develop Windows applications, IronPython must be initialized for that purpose. By default, the Python console executes on one thread only. While this thread awaits text input in the console window, the Windows application being dynamically created from the console is not able to process Windows messages. Therefore, the application does not repaint itself or handle input to the UI.
We provide a .py file to initialize IronPython for Windows Forms development, see tasks below.
In this exercise, you will create simple Windows Forms applications dynamically from the IronPython interactive console.
Start the IronPython console from the tutorial directory (see Introduction for details).
Initialize Windows Forms by loading the winforms module/script:
import winforms
Python modules get automatically initialized (executed) upon import so the Windows Forms initialization code has executed as part of the import statement.
Import the contents of the System.Windows.Forms and System.Drawing namespaces into the global namespace:
from System.Windows.Forms import *
from System.Drawing import *
Create an instance of the Form class and display it:
f = Form()
f.Show()
You may need to alt-tab or look for the running application since it may not have popped to the top level on your desktop.
Now set the form Text property:
f.Text = "My First Interactive Application"
To bring the application alive, let's focus on the Click event of the form. Create an event handler for the Click event and click on the form to receive the event. Then remove the event handler
def click(*args): print args
f.Click += click
Click on the form to receive the event..
The output will be similar to:
>>> (System.Windows.Forms.Form, Text: My First Interactive Application, <System.Windows.Forms.MouseEventArgs object at 0x02324551>)
Now remove the click handler because we're going to further develop it.
f.Click -= click
Use dir() function to explore the MouseEventArgs
dir(MouseEventArgs)
Knowing the contents of the MouseEventArgs, create an improved event handler for the Click event:
def click(f, a):
l = Label(Text = "Hello")
l.Location = a.Location
f.Controls.Add(l)
Register the event handler:
f.Click += click
Now clicking on the form with the mouse will add "Hello" labels. We can also access the controls we just added via mouse clicks and change them
for i in f.Controls: i.Font = Font("Verdana", 15)
for i in f.Controls: i.Text = "Hi"
After a few moments of clicking, the form will get quite crowded, so we can clear it out:
f.Controls.Clear()
Exit the IronPython Interactive console (Ctrl+Z or F6 followed by Enter)
The standalone version of this script is located in wfdemo.py in the Tutorial directory.
This exercise requires Windows Presentation Foundation installed. Please see prerequisites for more information.
Just like Windows Forms, the Windows Presentation Foundation also requires initialization to support interactive development. The initialization code is available in the "Tutorial\avalon.py" file.
In this exercise, you will interactively create simple interactive Windows Presentation Foundation application.
Start the IronPython console from the tutorial directory (see Introduction for details).
Initialize Windows Presentation Foundation:
from avalon import *
Create Avalon window, display it, and set some of its properties:
w = Window()
w.Show()
You may need to alt-tab or look for the running application since it may not have popped to the top level on your desktop. Now, let's do more.
w.Title = "My Avalon Application"
w.SizeToContent = SizeToContent.WidthAndHeight
By setting the window property to "size to content", the window shrinks.
Let's add the content now:
w.Content = TextBlock()
w.Content.Text = "Hello IronPython!"
w.Content.FontSize = 50
Remove the window content:
w.Content = None
If you are continuing from the Task 1, proceed to step 2. Otherwise, please follow the steps 1-3 from the Task 1.
Windows Presentation Foundation uses the XAML format to describe the graphical layout and basic behaviors of UI. Load the "calc.xaml" and display the resulting content:
w.Content = LoadXaml("calc.xaml")
If you flowed into this task from Task 1, then w.SizeToContent may have been reset to manual, but in either case, you may need to manually drag the window's border down and to the right to see the calculator UI.
Let's walk the calculator's object model (function Walk is defined in the avalon.py file)
for n in Walk(w): print n
Using Python's list comprehension syntax we can capture all buttons in the calculator:
[ n for n in Walk(w) if isinstance(n, Button) ]
The console printed the list of all buttons. To save the button list object in a variable, use the interpreter's "_" variable, which always holds the last non-None value result printed by the console:
buttons = _
At this point we can make changes to all the buttons, for example, change the colors and fonts:
for b in buttons: b.FontSize *= 2
for b in buttons: b.Foreground = SolidColorBrush(Colors.Blue)
To bring the calculator alive, we need to provide event handlers for each button. These can be imported from the calculator.py file:
import calculator
The calculator module contains the Calculator class that will be responsible for tracking the expression as it is being built by the calculator. To bring the calculator alive (that is, register event handlers for the UI), enter:
calculator.enliven(w)
At this point you can click on the calculator buttons and evaluate expressions.
Feel free to explore the calculator.py script file (located in Tutorial directory). The point of interest is the Calculator.__init__ method:
def __init__(self, controls):
(1)
self.expression = ""
(2)
(3)
for i in controls:
(4)
if isinstance(i, Button):
(5)
if hasattr(self,
"on_" + i.Name):
(6)
i.Click += getattr(self, "on_" + i.Name)
(7)
elif isinstance(i, TextBox):
(8)
if i.Name ==
"Result":
(9)
self.result = i
(10)
self.result.Text = self.expression
(11)
The "controls" argument for the method is the list of buttons and text boxes, very
similar to the list of buttons created in steps 3 and 4 of this task. The initialization
code enumerates the list (line 4), identifies buttons (line 5), and uses the
name of the button ("One", "Multiply", " Equals", ...) to find the
calculator attribute
(method) with the corresponding name (for example, "on_One", "on_Multiply",
and "on_Equals", respectively). If such an attribute (method) is available,
we hook the Click event event, using the name to fetch the attribute (line 7).
The second point of interest is the on_Equals method, especially the highlighted line. Python has a built-in function, "eval", which evaluates an expression passed as a string and returns the resulting value. Calculator uses "eval" to evaluate the calculator expressions. The "str" function will then convert the value into a string for display.
def on_Equals(self, b, e):
try:
result = str(eval(self.expression))
self.result.Text
= result
self.expression = result
except:
self.result.Text = "<<ERROR>>"
self.expression = ""
Exit the IronPython Interactive console (Ctrl+Z or F6 followed by Enter)
Tutorial Summary
IronPython provides very easy way to develop live applications in a dynamic and exploratory way. Both Windows Forms and Windows Presentation Foundation (Avalon) applications can be easily developed this way with minimal setup. The advantage is that changes are visible immediately and modifications are happening to live system and don't require recompilation.
In this tutorial you performed the following exercises:
In this tutorial, you became familiar with using delegates and handling events in IronPython - an essential part of interactive development of Windows applications using WinForms or Avalon. Then you dynamically created simple interactive application in Windows Forms and created two applications using Windows Presentation Foundation.
COM interoperability is an important part of .NET Framework. To use COM objects from the .NET application, an interop assembly that contains the .NET metadata for the COM objects is required. This tutorial will outline how the interop assemblies can be created (in the case they are not provided by the creators of the COM object) and will demonstrate the ease with which COM objects can be used from IronPython.
Estimated time to complete this tutorial: 20 minutes
The objective of this tutorial is to explore COM interoperability from IronPython.
This exercise consists of two tasks. In the first one we will create an interop assembly for a COM object library and explore it using the .NET reflection tools. In the second task we will use the COM object library from IronPython.
In this exercise, you will create a COM interop assembly and use it to drive the COM object from IronPython.
Open the "SDK Command Prompt" or "Visual Studio 2005 Command Prompt" from the start menu.
The .NET Frameworks SDK comes with the "tlbimp" tool which converts a COM type library into .NET metadata information -- the interop assembly. The COM object library we want to use from IronPython is msagent, located in %SystemRoot%\msagent\agentsvr.exe. Use the tlbimp tool to generate the interop assembly for msagent (tlbimp writes to the current directory):
tlbimp %SystemRoot%\msagent\agentsvr.exe
C:\IronPython\Tutorial>tlbimp %SystemRoot%\msagent\agentsvr.exe
Microsoft (R) .NET Framework Type Library to Assembly Converter 2.0.50727.42
Copyright (C) Microsoft Corporation. All rights reserved.
Type library imported to AgentServerObjects.dll
The .NET metadata information was saved in AgentServerObjects.dll. Use the ildasm tool to explore the generated DLL:
ildasm AgentServerObjects.dll
As you browse the metadata tree, notice that at the root of the hierarchy there is the "AgentServerObjects" namespace. The namespace contains many interfaces and a single class - AgentServerClass. Explore the methods on the class. Calling some of its methods will be the subject of the next task.
When you are done exploring the AgentServerObjects.dll, close the ildasm tool. Copy AgentServerObjects.dll to the tutorial directory, and then close the Windows command prompt.
Start the IronPython console from the tutorial directory (see Introduction for details).
Using the "AddReferenceToFile" function in the clr module, add a reference to the AgentServerObjects.dll:
import clr
clr.AddReferenceToFile("AgentServerObjects.dll")
Import the contents of the AgentServerObjects namespace and explore the contents using dir():
from AgentServerObjects import *
dir()
Create instance of the AgentServerClass and explore its contents:
a = AgentServerClass()
dir(a)
The output in the console window will be:
>>> a = AgentServerClass()
>>> dir(a)
['CreateObjRef', 'Equals', 'GetCharacter', 'GetHashCode', 'GetLifetimeService', 'GetSuspended', 'GetType', 'InitializeLifetimeService', 'Load', 'MemberwiseClone', 'Register', 'ToString', 'Unload', 'Unregister', '__class__', '__init__', '__module__', '__new__']
Explore the parameters of the Load method on AgentServerClass:
a.Load.__doc__
>>> a.Load.__doc__
'(int, int) Load(object, vLoadKey)\r\n'
The Load methods have an input parameter (name of the character to load) and two output parameters. When calling this method, IronPython will turn the two output parameters into multiple return values.
Load "Merlin the Wizard" character. (The character data is stored in c:\WINDOWS\msagent\chars). The Load method returns multiple values packed into a tuple - the first value is the actual character ID. Capture the character id in the variable:
cid = a.Load("Merlin.acs")[0]
Call GetCharacter method on the AgentServerClass instance to get the actual character, display the character and have him think about IronPython Tutorial:
c = a.GetCharacter(cid)
c.Show(0)
c.Think("IronPython Tutorial")
Merlin has a lot of animations he can play. Get list of all the animations by calling the GetAnimationNames method. Play one of the animations, "Read", by calling the Play method:
for n in c.GetAnimationNames(): print n
c.Play("Read")
(Optional) To call a series of animations, we could call c.Play(animation_name) for each animation. Python's lamda functions can simplify this process. We can create global functions and assign them names based on the animation name:
for n in c.GetAnimationNames(): globals()[n] = lambda name=n: c.Play(name)
At this point we can have Merlin play animations
simply by
calling a function from global namespace:
Congratulate()
Stop Merlin's animations, hide him, and exit IronPython console
c.StopAll(0)
c.Hide(0)
In this exercise you will create an instance of Microsoft Word and use it to check word spellings.
Start the IronPython console from the tutorial directory (see Introduction for details).
Import clr module and add a reference to the Word COM interop assembly. Also, import System so that we can use a special value from it later.
import clr
clr.AddReferenceByPartialName("Microsoft.Office.Interop.Word")
from Microsoft.Office.Interop.Word import ApplicationClass
import System
Start an instance of Word as a COM server running. You won't see it show up since it is hidden, but you can see it in the Windows Task Manager by typing ctrl-shift-escape and looking for the WINWORD.EXE process.
w = ApplicationClass()
Define the following function to check the spelling. We have to build up an argument list so that we can supply the 12 optional arguments we do not care about (System.Type.Missing). We get the answer by taking the first (at index zero) of a few return values (out parameters in COM interop). Remember to indent the lines of the function's body extra spaces, and you have to hit an extra return or enter to complete the function's definition.
def check_word (word):
args = [word] + [System.Type.Missing]*12
return w.CheckSpelling(*args)[0]
check_word("foo")
check_word("food")
You can try that out on a couple of words, but now lets define a function that will suggest corrections for us. First, we need to add a document so that we can call GetSpellingSuggestions(), which gives a nice error message if you try to call it with no documents opened.
w.Documents.Add(*[System.Type.Missing]*4)
The function we'll define builds an argument list just like check_word() did to supply several unneeded optional arguments. The first result of several return values from GetSpellingSuggestions() is a collection of items, each of which is a correction suggestion. We use a Python list comprehension to iterate through the COM collection object and call the Name property on each item object in the collection. Each item's Name property is a string that Word is suggesting as a correct spelling.
def suggestions (word):
args = [word] + [System.Type.Missing]*13
res_objects = w.GetSpellingSuggestions(*args)[0]
return [x.Name for x in res_objects]
Now, let's shut down Word and exit the IronPython console. When you enter the next line and hit return, if you are watching the Windows Task Manager, you will see the WINWORD.EXE process go away.
w.Quit(*[System.Type.Missing]*3)
In this task you will use an example already written that is very similar to what you did in Task 1, but it demonstrates two additional features. It uses a Python standard module to register a clean up function so that when the IronPython console terminates, the Word process is closed. The example also has a function, correct_word, that uses a Windows Form as a dialog to let users select a correct word to return.
Start the IronPython console from the tutorial directory (see Introduction for details).
Import spellcheck.
Call spellcheck.correct_word on a correctly spelled word, and you'll see the function returns the word.
Call spellcheck.correct_word on a misspelled word, and a Windows Form similar to Word's spelling correction dialog appears. You can pick from the list and click the Replace button, double click a word in the suggestions list, enter custom text and click the Use Custom button, click an Ignore button to return the misspelled word, and so on.
Open the spellcheck.py file to see the code for the the Windows Form as well as the functions.
Tutorial Summary
This tutorial was focused on using COM interop assemblies generated via tlbimp tool (in the .NET Framework SDK) to control COM objects from the IronPython environment.
In this tutorial you performed the following exercises.
In this tutorial, you created a COM interop assembly for the msagent COM object. You used the tlbimp tool which is part of the .NET Framework SDK. Using the ildasm tool, you explored contents of the interop assembly.
Then, from IronPython you loaded the interop assembly, created an instance of the COM object, and instructed Merlin to play different animations.
You also used Word to check the spelling of words, learned how to supply missing optional arguments, and inspected code that builds a Windows Form and uses it as a dialog.
This tutorial will walk you through very simple debug session, debugging a Python script using Microsoft CLR Debugger. See using Visual Studio if you have a Visual Studio SKU and consider skipping this exercise.
Estimated time to complete this tutorial: 10 minutes
The objective of this tutorial is debugging simple Python script using Microsoft CLR Debugger.
In this exercise, you will step through a simple Python script in the Microsoft CLR Debugger.
Launch Microsoft CLR Debugger.
From the debugger Menu, select Debug / Program to Debug ...
For Program, browse to the ipy.exe (located in the installaton directory)
For Arguments, type in debugging.py
Change Working directory to the Tutorial directory
Click OK
From Menu, select File / Open / File. Browse to the Tutorial directory and select two files to open:
debugging.py
first.py
Place breakpoint at the following line of the debugging.py file (Place cursor on the line and pres F9):
print first.add(1, 2)
Press F5 - Start Debugging.
IronPython will compile the debugging.py file and start executing it. You will hit the breakpoint at the line 3.
Note: If you get poor performance starting the debugging session, exit the debugger, open the Windows Explorer and delete the following directory:
%USERPROFILE%\Application Data\Microsoft\DbgClr
Pressing F11, step through the execution of the program, explore variables (even change the values of the variables in the watch window) and explore the call stack.
End the debugging session and exit the debugger.
Tutorial Summary
In this tutorial you performed the following exercises.
In this tutorial, you walked through the simple debug session of IronPython program. You used Microsoft CLR Debugger, placed breakpoints and stepped through the Python program execution.
Estimated time to complete this tutorial: 25- 60 minutes
The objective of this tutorial is to implement the class which will seamlessly fit into the IronPython environment. You can choose to follow Exercise 1 - C# implementation, Exercise 2 - Visual Basic, or both. Both tracks will result in the same functionality.
In this exercise you will use C# language to build a class that supports enumeration, custom operators and delegates and you will use that class from IronPython. It’s worth noting that as Python does not contain protected class members, that these members get promoted to public class members when imported into Python. Private class members, however, will be invisible to Python when imported.
Open the "SDK Command Prompt" or "Visual Studio 2005 Command Prompt" from the start menu.
Open the "csextend.cs" file in notepad. The file is initially empty
notepad csextend.cs
Add using clauses at the beginning of the file:
using System;
using System.Collections;
Define a simple class:
public class Simple {
private int data;
public Simple(int data) {
this.data = data;
}
public override string ToString() {
return String.Format("Simple<{0}>", data);
}
}
Switch back to the SDK Command Prompt window and build the code using available csx.bat (C# extension):
csx
Start the IronPython console from the tutorial directory (see Introduction for details).
Load the dll that you just built (csextend.dll) into IronPython. Then explore the Simple class using built-in dir() function:
import clr
clr.AddReferenceToFile("csextend.dll")
import Simple
dir(Simple)
You will see following output:
>>> import clr
>>> clr.AddReferenceToFile("csextend.dll")
>>> import Simple
>>> dir(Simple)
['Equals', 'GetHashCode', 'GetType', 'ToString', '__new__', '__repr__']
Create instance of the Simple class:
s = Simple(10)
print s
IronPython will output:
>>> s = Simple(10)
>>> print s
Simple<10>
You have just explored all the functionality currently available in the Simple class. Exit IronPython and return back to the C# code to add more functionality.
In Notepad, add more functionality to the Simple class.
First, inherit the Simple class from IEnumerable and implement GetEnumerator() method. Use the C#'s new "yield return" statement:
public class Simple : IEnumerable {
private int data;
public Simple(int data) {
this.data = data;
}
public override string ToString() {
return String.Format("Simple<{0}>", data);
}
public IEnumerator GetEnumerator()
{
for (int i = 0; i < data; i ++) {
yield return
new Simple(i);
}
}
}
Save the changes, ccompile the code (csx), launch IronPython Console (ip) and test the code:
import sys
clr.AddReferenceToFile("csextend.dll")
import Simple
dir(Simple)
s = Simple(10)
for i in s: print i
You will get the following output in the IronPython console window:
>>> import clr
>>> clr.AddReferenceToFile("csextend.dll")
>>> import Simple
>>> dir(Simple)
['Equals', 'GetEnumerator', 'GetHashCode', 'GetType', 'ToString', '__new__',
'__repr__']
>>> s = Simple(10)
>>> for i in s: print i
Simple<0>
Simple<1>
Simple<2>
Simple<3>
Simple<4>
Simple<5>
Simple<6>
Simple<7>
Simple<8>
Simple<9>
Notice that the dir() function now returned the GetEnumerator method.
Exit IronPython and return back to the C# code to add more functionality.
Add the operator + method:
using System;
using System.Collections;
public class Simple : IEnumerable {
private int data;
public Simple(int data) {
this.data = data;
}
public override string ToString() {
return String.Format("Simple<{0}>", data);
}
public IEnumerator GetEnumerator() {
for (int i = 0; i < data; i ++) {
yield return
new Simple(i);
}
}
public static Simple operator
+(Simple a, Simple b) {
return new Simple(a.data + b.data);
}
}
Return to the command prompt, compile the code (csx), launch IronPython Console (ip) and test the code:
import clr
clr.AddReferenceToFile("csextend.dll")
import Simple
dir(Simple)
a = Simple(10)
b = Simple(20)
a + b
Notice that in the output of dir() call you will now get additional methods __add__ and __radd__, Python's notion of custom operator implementation:
>>> import clr
>>> clr.AddReferenceToFile("csextend.dll")
>>> import Simple
>>> dir(Simple)
['Equals', 'GetEnumerator', 'GetHashCode', 'GetType', 'ToString', '__add__',
'__new__', '__radd__', '__repr__']
>>> a = Simple(10)
>>> b = Simple(20)
>>> a + b
Simple<30>
Exit IronPython and return back to the C# code to add more functionality.
Add the definition of the delegate to the top of the C# source file:
using System;
using System.Collections;
public delegate int Transformer(int input);
Add "Transform" method to the Simple class that takes the delegate as a parameter and invokes the delegate:
using System;
using System.Collections;
public delegate int Transformer(int input);
public class Simple : IEnumerable {
private int data;
public Simple(int data) {
this.data = data;
}
public override string ToString() {
return String.Format("Simple<{0}>", data);
}
public IEnumerator GetEnumerator() {
for (int i = 0; i < data; i ++) {
yield return
new Simple(i);
}
}
public int Transform(Transformer
t) {
return t(data);
}
public static Simple operator +(Simple a, Simple b) {
return new Simple(a.data + b.data);
}
}
Return back to the SDK command prompt, compile the code (csx), launch IronPython Console (ip) and test the code:
import clr
clr.AddReferenceToFile("csextend.dll")
import Simple
a = Simple(10)
def X(i):
return i + 100
a.Transform(X)
The function X is getting passed as the delegate to the Simple's Transform method. You will get following output:
>>> import clr
>>> clr.AddReferenceToFile("csextend.dll")
>>> import Simple
>>> a = Simple(10)
>>> def X(i):
... return i + 100
...
>>> a.Transform(X)
110
This concludes the C# extending example. If you are interested, an interesting exercise is combining the debugging example and the extending one. If you are inspired to do so, try debugging the script that you just typed in. Debug the "debugcsx.py" script located in Tutorial directory and place breakpoint into the X function - you will see mixed call stack between Visual Basic and Python.
In this exercise you will use Visual Basic .NET language to build a class that supports enumeration, custom operators and delegates and you will use that class from IronPython. It’s worth noting that as Python does not contain protected class members, that these members get promoted to public class members when imported into Python. Private class members, however, will be invisible to Python when imported.
Open the "SDK Command Prompt" or "Visual Studio 2005 Command Prompt" from the start menu.
Open the "vbextend.cs" file in notepad. The file is initially empty
notepad vbextend.cs
Add Imports clauses at the beginning of the file:
Imports System
Imports System.Collections
Define a simple class:
Public Class Simple
Private data As Integer
Public Sub New(ByVal data As Integer)
Me.data = data
End Sub
Overrides Function ToString() As String
Return String.Format("Simple<{0}>", data)
End Function
End Class
Switch back to the SDK Command Prompt window and build the code using the available vbx.bat (Visual Basic extension):
vbx
Start the IronPython console from the tutorial directory (see Introduction for details).
Load the dll that you just built (vbextend.dll) into IronPython. Then explore the Simple class using built-in dir() function:
import clr
clr.AddReferenceToFile("vbextend.dll")
import Simple
dir(Simple)
You will see following output:
>>> import clr
>>> clr.AddReferenceToFile("vbextend.dll")
>>> import Simple
>>> dir(Simple)
['Equals', 'GetHashCode', 'GetType', 'ToString', '__new__', '__repr__']
Create instance of the Simple class:
s = Simple(10)
print s
IronPython will output:
>>> s = Simple(10)
>>> print s
Simple<10>
You just have explored all the functionality available in the Simple class. Exit IronPython and return back to the Visual Basic code to add more functionality.
Back in Notepad, add more functionality to the vbextend.vb, Simple class
First, inherit the Simple class from IEnumerable and implement GetEnumerator() method. Unlike C#, Visual Basic does not offer the yield keyword so implementing IEnumerable interface requires adding a helper class SimpleEnum:
Imports System
Imports System.Collections
Public Class SimpleEnum
Implements IEnumerator
Private data As Integer
Private curr As Integer
Public Sub New(ByVal data As Integer)
Me.data = data
Me.curr = -1
End Sub
Public ReadOnly Property Current() As Object _
Implements IEnumerator.Current
Get
Return New Simple(curr)
End Get
End Property
Public Function MoveNext() As Boolean _
Implements IEnumerator.MoveNext
curr += 1
Return curr < data
End Function
Public Sub Reset() Implements IEnumerator.Reset
curr = -1
End Sub
End Class
Public Class Simple
Implements IEnumerable
Private data As Integer
Public Sub New(ByVal data As Integer)
Me.data = data
End Sub
Overrides Function ToString() As String
Return String.Format("Simple<{0}>", data)
End Function
Function GetEnumerator() As IEnumerator
_
Implements IEnumerable.GetEnumerator
Return New SimpleEnum(data)
End Function
End Class
Compile the code (vbx), launch IronPython Console (ip) and test the code:
import clr
clr.AddReferenceToFile("vbextend.dll")
import Simple
dir(Simple)
s = Simple(10)
for i in s: print i
You will get the following output in the IronPython console window:
>>> import clr
>>> clr.AddReferenceToFile("vbextend.dll")
>>> import Simple
>>> dir(Simple)
['Equals', 'GetEnumerator', 'GetHashCode', 'GetType', 'ToString', '__new__',
'__repr__']
>>> s = Simple(10)
>>> for i in s: print i
Simple<0>
Simple<1>
Simple<2>
Simple<3>
Simple<4>
Simple<5>
Simple<6>
Simple<7>
Simple<8>
Simple<9>
Notice that the dir() function now returned the GetEnumerator method.
Exit IronPython and return back to the Visual Basic code to add more functionality.
Add the operator + method to the Simple class:
Public Class Simple
Implements IEnumerable
Private data As Integer
Public Sub New(ByVal data As Integer)
Me.data = data
End Sub
Overrides Function ToString() As String
Return String.Format("Simple<{0}>", data)
End Function
Function GetEnumerator() As IEnumerator _
Implements IEnumerable.GetEnumerator
Return New SimpleEnum(data)
End Function
Shared Operator +(ByVal a As
Simple, ByVal b As Simple) As Simple
Return New Simple(a.data + b.data)
End Operator
End Class
Compile the code (vbx), launch IronPython Console (ip) and test the code:
import clr
clr.AddReferenceToFile("vbextend.dll")
import Simple
dir(Simple)
a = Simple(10)
b = Simple(20)
a + b
Notice that in the output of dir() call you will now get additional methods __add__ and __radd__, Python's notion of custom operator implementation:
>>> import clr
>>> clr.AddReferenceToFile("vbextend.dll")
>>> import Simple
>>> dir(Simple)
['Equals', 'GetEnumerator', 'GetHashCode', 'GetType', 'ToString', '__add__',
'__new__', '__radd__', '__repr__']
>>> a = Simple(10)
>>> b = Simple(20)
>>> a + b
Simple<30>
Exit IronPython and return back to the Visual Basic .NET code to add more functionality.
Add the definition of the delegate to the top of the Visual Basic source file:
Imports System
Imports System.Collections
Public Delegate Function Transformer(ByVal input As Integer) As Integer
Add "Transform" method to the Simple class that takes the delegate as a parameter and invokes the delegate:
Public Class Simple
Implements IEnumerable
Private data As Integer
Public Sub New(ByVal data As Integer)
Me.data = data
End Sub
Overrides Function ToString() As String
Return String.Format("Simple<{0}>", data)
End Function
Function GetEnumerator() As IEnumerator _
Implements IEnumerable.GetEnumerator
Return New SimpleEnum(data)
End Function
Function Transform(ByVal t As
Transformer) As Integer
Return t(data)
End Function
Shared Operator +(ByVal a As Simple, ByVal b As Simple) As Simple
Return New Simple(a.data + b.data)
End Operator
End Class
Return back to the SDK command prompt, compile the code (vbx), launch IronPython Console (ip) and test the code:
import clr
clr.AddReferenceToFile("vbextend.dll")
import Simple
a = Simple(10)
def X(i):
return i + 100
a.Transform(X)
The function X is getting passed as the delegate to the Simple's Transform method. You will get following output:
>>> import clr
>>> clr.AddReferenceToFile("vbextend.dll")
>>> import Simple
>>> a = Simple(10)
>>> def X(i):
... return i + 100
...
>>> a.Transform(X)
110
This concludes the Visual Basic extending example. If you are interested, an interesting exercise is combining the debugging example and the extending one. If you are inspired to do so, try debugging the script that you just typed in. Debug the "debugvbx.py" script located in the Tutorial directory. Place breakpoint into the X function - you will see mixed call stack between Visual Basic and Python.
Tutorial Summary
The complete version of the csextend.cs and vbextend.vb files are located in the Tutorial\Extend directory along with files csxtest.py and vbxtest.py which contain the test code for the C# and Visual Basic .NET extensions respectively.
The code to experiment with debugging of Python and C# or Visual Basic code, use Python scripts debugcsx.py and debugvbx.py respectively.
In this tutorial you performed the following exercises.
In this tutorial, you implemented a simple class to be used from IronPython. You added the ability for IronPython to enumerate the class, added an operator to it and support for delegate. The implementation was in either C# or Visual Basic, or both.
IronPython can be very easily embedded in the .NET application - either as a simple engine to evaluate Python expressions, but much more powerfully to script the .NET application. This tutorial will explore both means of using IronPython.
Estimated time to complete this tutorial: 25 minutes
The objective of this tutorial is to use IronPython as part of .NET application to evaluate Python expressions and to script the .NET application.
In this exercise, you will implement simple C# application that will embed IronPython and use it to evaluate expressions.
Open the "SDK Command Prompt" or "Visual Studio 2005 Command Prompt" from the start menu.
Open the "eval.cs" file in notepad. The file is initially empty
notepad eval.cs
Insert the using statements at the beginning of the file. The PythonEngine, a class that provides the functionality we will leverage in this exercise, is located in the IronPython.Hosting namespace:
using System;
using IronPython.Hosting;
Implement the simple evaluator. The evaluator will create instance of PythonEngine class and call the Evaluate method, passing the command line argument as the expression string:
public class Eval {
public static void Main(string[] args) {
PythonEngine pe = new PythonEngine();
Console.WriteLine(pe.Evaluate(args[0]));
}
}
Save the changes and return to the SDK Command Prompt. Build the eval.cs using the provided batch file "cseval.bat". The batch script also copies the IronPython binaries to the current directory (they are not installed in Global Assembly Cache) so that the runtime can find them as the eval program executes:
cseval
Execute the eval program and pass simple expressions on the command line to be evaluated by the PythonEngine:
eval 2+2
eval 2**3
eval 5%3
The sample output:
C:\IronPython\Tutorial>eval 2+2
4
C:\IronPython\Tutorial>eval 2**3
8
C:\IronPython\Tutorial>eval 5%3
2
The complete code for the eval.cs is available in "Tutorial\Embed\eval.cs"
The previous exercise demonstrated one-way interaction between IronPython and an application: the eval program used IronPython as a worker, and IronPython had no need to know anything about eval. From the IronPython engine’s perspective, there was no difference between commands sent from eval and those that someone sitting directly at the console might type.
However, IronPython can be embedded much more fully as a scripting engine for an application. The hosting application can make its own objects available to the IronPython engine, allowing users to write scripts in IronPython that manipulate these objects. Thus, the flexibility of IronPython can be used to automate complicated or frequently-performed tasks, and to provide an open-ended, extensible application.
In this exercise, you will:
Embed IronPython in an application as the scripting engine
Handle IronPython exceptions gracefully
Redirect the engine’s output streams
Open the file HostingApp\MonthAtAGlance.cs. (This is the only file in the project containing application logic; everything else is used by Forms only.) At the top of the file, add references to IronPython.Hosting and IronPython.Compiler:
using IronPython.Hosting;
using IronPython.Compiler;
Add a PythonEngine instance as a private member of the class MonthAtAGlance:
// Application variables
private Dictionary<System.DateTime, string> dateEntries;
private System.DateTime lastDate;
private PythonEngine engine;
Add a method to initialize the PythonEngine, import the site module, and make the dateEntries variable available to it under the name dateentries.
void InitializePythonEngine()
{
engine = new PythonEngine();
engine.Import("Site");
engine.Globals["dateentries"] = dateEntries;
}
Place a call to InitializePythonEngine() in the constructor for the App’s main form:
public MonthAtAGlance() {
InitializeComponent();
InitializeApp();
InitializePythonEngine();
}
In the monthCalendar_DateChanged method, add code to call the engine. Note that we now have two ways to invoke the IronPython engine: Evaluate, as we saw in Exercise 1; and Execute, which changes the state of the engine but doesn’t return any result. Also, if we know the type that an expression evaluates to, we can use the generic form Evaluate
engine.Execute("n = dateentries.Count");
int nEntries = engine.EvaluateAs<int>("n");
label.Text = "There are now " + nEntries.ToString() + " entries in the
dictionary.";
Compile the application using the script makeha.bat. Run it inside the HostingApp directory, where it is found. The executable will be App.exe. The source file for this step is also available as HostingApp\MonthAtAGlance.1.cs
If an application’s users have IronPython available as a scripting engine, it’s a given that syntax and logic errors will sometimes occur, raising IronPython exceptions. To show how this can degrade usability, let’s first see what happens when an application doesn’t have any way of handling exceptions from IronPython scripts gracefully:
At the end of InitializePythonEngine, we'll add some Python code that generates an exception by attempting to reference an undefined variable, so:
engine.Execute("print y");
Compile and run App.exe; again, the prepared source-file for this step is available, as MonthAtAGlance.2.1.cs. At once, you will see an exception dialog:
This dialogue appears because the default UncaughtExceptionHandler for the current AppDomain is invoked. By adding a new UncaughtExceptionHandler, you can perform various clean-up and reporting tasks before this dialogue appears. However, ideally you would like to handle the situation a little better than that. At the very least, your application can catch exceptions raised inside the PythonEngine and display the stack-trace to the user.
Wrap the call to Execute that you added in step 1 in a try/catch block:
try {
engine.Execute("print y");
} catch (Exception exc) {
MessageBox.Show(exc.ToString());
}
Compile and run to see the stack-trace displayed in the message-box; after dismissing it, you can interact with the application normally.
Since we know the type of exception that will be raised – and that every Python exception maps to a .NET exception – we can add more precise handling. Modify the try/catch block as follows:
try {
engine.Execute("print y");
} catch (IronPython.Runtime.PythonNameError exc) {
MessageBox.Show("IronPython engine complained: "+exc.Message);
} catch (Exception exc) {
MessageBox.Show("Unexpected exception: "+exc.ToString()+"\nShutting down!");
System.Environment.Exit(-1);
}
Compile and run again; note the different message-box that appears:
In Task 2, we directed the PythonEnginer to execute a print statement. Although this direction failed, because we asked it to print an undefined variable, nonetheless it raises an important question: if we execute a print, or any other statement which has console output as a side-effect, where does this output go when we host the engine in a GUI application? Let’s see what happens…
Modify the print statement added in Task 2 so that it executes without an error:
engine.Execute("print 'Hello, world!'");
Now compile and run the program again. Look at the command window you launched the program from. You'll see 'Hello world!' printed there. By default, the IronPython engine writes to the standard output; but it's straightforward to redirect to a file so that all interactions with the engine are logged.
Modify InitializePythonEngine as follows:
engine = new PythonEngine();
System.IO.FileStream fs = new System.IO.FileStream("scripting-log.txt",
System.IO.FileMode.Create);
engine.SetStdout(fs);
engine.SetStderr(fs);
engine.Globals["dateentries"] = dateEntries;
Now compile and run.Look in the home directory of the executable for scripting-log.txt; it should contain the text ‘Hello, world!'.
Now let's use the IronPython engine to view information on the application objects. Add the following lines to the empty body of defaultEvtHandler:
engine.Execute("print '---------'");
engine.Execute("for i in dateentries.Keys: print 'Day %s: %s' % (i, dateentries[i])");
Now try compiling and running. Add a few entries to the calendar. You’ll see that, after you shut down, scripting-log.txt contains a text list of your calendar entries. (Any standard error output will be directed there as well.) Actually, it contains a complete record of the updates you have made to the calendar, since this Python code will be invoked whenever a date's entry is altered.
Tutorial Summary
In this tutorial you performed the following exercises.
In this tutorial you used IronPython as an embedded expression evaluator and as a scripting engine for an existing .NET application.
There's very basic support for editing .py files in Visual Studio (no coloring or expression completion), but you get .NET debugging support. This tutorial shows you how to quickly set up Visual Studio to work on Python scripts in a directory.
Estimated time to complete this tutorial: 5 minutes
The objective of this tutorial is to set up Visual Studio for some basic tool support for debugging.
In this exercise you will set up a Visual Studio solution that you can use to edit .py files in a directory and debug them using the Visual Studio .NET debugger. We will use the Tutorial directory as an example, but you could save your solution anywhere.
Open Visual Studio and close any solution or projects you might have open.
Use the File->Open->Project/Solution ... command and browse to the ipy.exe application in your IronPython installation (c:\IronPython\ipy.exe is where the tutorial assumes you have it).
We will use the Tutorial directory as an example, and we'll want to set it up as the working directory for loading .py scripts. Right click on the ipy.exe project node in the Visual Studio's solution explorer and choose the Properties command.
In the properties dialog, you will fill in two fields, the Command Arguments and Working Directory. For the Command Arguments, enter "first.py". For the Working Directory, enter the path to the Tutorial directory (c:\IronPython\Tutorial\ is where we assume you have it). Click Apply and OK to confirm your changes.
Now let's save the solution with the File->Save All ... command. Save it to the Tutorial directory.
To test out our set up, use Ctrl+O to open a file. Browse to the "first.py" file in the Tutorial directory. Place the caret on the line that reads "def add(a, b):", and press F9 to set a breakpoint.
Press F5 to run the script, and you will hit the breakpoint. If you Press F10, you will step through the file, but all it does is load the definitions and set some variables before terminating.
To see more stepping, we'll add a line to the file and set another breakpoint. Add a line to the end of the file to invoke the factorial function ("factorial(5)"). Add a breakpoint to the line that reads "if n < 1: return 1". Now Press F5 to run the script. Press F10 repeatedly and notice the locals window where the parameter "n" decrements to 0 and then goes back up to 5 as the recursion unwinds. You can also hover the mouse over the "n" in the editor window to get a data tip of its value each time you stop at the breakpoint.
To work on other scripts, just change the Command Arguments property for the ipy.exe project as we did above to name another script you want to load on F5. You might also find it useful to go to the Tools->Options... dialog and change a property on the Environment->Documents page to show the open script files. If you check the property "Show Miscellaneous Files in the Solution Explorer", then you will get a list of the .py files you are editing. Each time you open this solution again at a later time, you will see all the .py files you developed while using this solution file.
Tutorial Summary
In this tutorial you performed the following exercises.
In this tutorial you set up Visual Studio to work on Python scripts in a directory and debug them.