PageRenderTime 72ms CodeModel.GetById 19ms RepoModel.GetById 1ms app.codeStats 0ms

/IronPython_2_0/Tutorial/Tutorial.htm

#
HTML | 2996 lines | 2969 code | 26 blank | 1 comment | 0 complexity | 1623e1b5d96dc0645c03a305c88dde4e MD5 | raw file
Possible License(s): GPL-2.0, MPL-2.0-no-copyleft-exception, CPL-1.0, CC-BY-SA-3.0, BSD-3-Clause, ISC, AGPL-3.0, LGPL-2.1, Apache-2.0 
    

  1. <html xmlns="http://www.w3.org/1999/xhtml">

    2. 

  2. 

    3. 

  3. <head>

    4. 

  4. <meta http-equiv="Content-Type" content="text/html; charset=windows-1252" />

    5. 

  5. <title>IronPython Tutorial</title>

    6. 

  6. <!--link rel="stylesheet" type="text/css" href="../Doc/IronPython.css"-->

    7. 

  7. <style type="text/css">

    8. 

  8. 	p.AntiVerify { display : none; }

    9. 

  9. 	p.Code-Background { color : gray; }

    10. 

  10. 	p.Code-Highlighted { color : gray; }

    11. 

  11. 	p.CodeSample { color:blue; }

    12. 

  12. 	p.DOSCommand { color:green; }

    13. 

  13. 	p.ExceptionExample { color:green; }

    14. 

  14. 	p.ExceptionOutput {display : none; }

    15. 

  15. 	p.HiddenCode { display : none; }

    16. 

  16. 	p.HiddenOutput {display : none; }

    17. 

  17. 	p.LooseVerify { display : none; }

    18. 

  18. 	p.Stepnonumbering { text-indent: 2em; }

    19. 

  19. 	p.TypedExample { color : green; }

    20. 

  20. 	p.UserCode { color:green; }

    21. 

  21. </style>

    22. 

  22. 

    23. 

  23. </head>

    24. 

  24. 

    25. 

  25. <body lang="EN-US">

    26. 

  26. 

    27. 

  27. <div class="Section1">

    28. 

  28. 	<p class="Title1">IronPython Tutorial</p>

    29. 

  29. 	<p class="Title2">A tour of Python on .NET</p>

    30. 

  30. 	<p class="Title2">&nbsp;</p>

    31. 

  31. 	<hr />

    32. 

  32. 	<p class="CopyrightText">Information in this document is subject to change without

    33. 

  33. 	notice. The example companies, organizations, products, people, and events depicted

    34. 

  34. 	herein are fictitious. No association with any real company, organization, product,

    35. 

  35. 	person or event is intended or should be inferred. Complying with all applicable

    36. 

  36. 	copyright laws is the responsibility of the user. Without limiting the rights

    37. 

  37. 	under copyright, no part of this document may be reproduced, stored in or introduced

    38. 

  38. 	into a retrieval system, or transmitted in any form or by any means (electronic,

    39. 

  39. 	mechanical, photocopying, recording, or otherwise), or for any purpose, without

    40. 

  40. 	the express written permission of Microsoft Corporation.</p>

    41. 

  41. 	<p class="CopyrightText">&nbsp;</p>

    42. 

  42. 	<p class="CopyrightText">Microsoft may have patents, patent applications, trademarked,

    43. 

  43. 	copyrights, or other intellectual property rights covering subject matter in

    44. 

  44. 	this document. Except as expressly provided in any written license agreement

    45. 

  45. 	from Microsoft, the furnishing of this document does not give you any license

    46. 

  46. 	to these patents, trademarks, copyrights, or other intellectual property.</p>

    47. 

  47. 	<p class="CopyrightText">&nbsp;</p>

    48. 

  48. 	<p class="CopyrightText">Š Microsoft Corporation. All rights reserved.</p>

    49. 

  49. 	<p class="CopyrightText">&nbsp;</p>

    50. 

  50. 	<p class="CopyrightText">Microsoft, MS-DOS, MS, Windows, Windows NT, MSDN, Active

    51. 

  51. 	Directory, BizTalk, SQL Server, SharePoint, Outlook, PowerPoint, FrontPage,

    52. 

  52. 	Visual Basic, Visual C++, Visual J++, Visual InterDev, Visual SourceSafe, Visual

    53. 

  53. 	C#, Visual J#,&nbsp; and Visual Studio are either registered trademarks or trademarks

    54. 

  54. 	of Microsoft Corporation in the U.S.A. and/or other countries.</p>

    55. 

  55. 	<p class="CopyrightText">&nbsp;</p>

    56. 

  56. 	<p class="CopyrightText">Other product and company names herein may be the trademarks of their respective owners.</p>

    57. 

  57. 	<hr />

    58. 

  58. 	<p class="ContentsHeading">Contents</p>

    59. 

  59. 	<p class="Toc1"><a href="#Intro">Introduction</a></p>

    60. 

  60. 	<p class="Toc1">Tutorial 1: <a href="#T1">Basic IronPython</a></p>

    61. 

  61. 	<p class="Toc2">Exercise 1: <a href="#T1.1">The IronPython interactive console</a></p>

    62. 

  62. 	<p class="Toc3">Task 1: <a href="#T1.1.1">IronPython console</a></p>

    63. 

  63. 	<p class="Toc3">Task 2: <a href="#T1.1.2">Built-in modules and interactive exploration</a></p>

    64. 

  64. 	<p class="Toc3">Task 3: <a href="#T1.1.3">External Python modules</a></p>

    65. 

  65. 	<p class="Toc2">Exercise 2: <a href="#T1.2">Using the standard .NET libraries from IronPython</a></p>

    66. 

  66. 	<p class="Toc3">Task 1: <a href="#T1.2.1">Basic .NET library use</a></p>

    67. 

  67. 	<p class="Toc3">Task 2: <a href="#T1.2.2">Working with .NET classes</a></p>

    68. 

  68. 	<p class="Toc3">Task 3: <a href="#T1.2.3">Generics</a></p>

    69. 

  69. 	<p class="Toc2">Exercise 3: <a href="#T1.3">Loading .NET libraries</a></p>

    70. 

  70. 	<p class="Toc3">Task 1: <a href="#T1.3.1">Using System.Xml - AddReference</a></p>

    71. 

  71. 	<p class="Toc3">Task 2: <a href="#T1.3.2">Mapack - Loading the .NET libraries - AddReferenceToFile</a></p>

    72. 

  72. 	<p class="Toc2">Exercise 4: <a href="#T1.4">Obtaining and Using Python Standard Library</a></p>

    73. 

  73. 	<p class="Toc3">Task 1: <a href="#T1.4.1">Configuring IronPython to use the Python standard library</a></p>

    74. 

  74. 	<p class="Toc1">Tutorial 2: <a href="#T2">Advanced IronPython</a></p>

    75. 

  75. 	<p class="Toc2">Exercise 1: <a href="#T2.1">Events and Delegates</a></p>

    76. 

  76. 	<p class="Toc3">Task 1: <a href="#T2.1.1">File System Watcher</a></p>

    77. 

  77. 	<p class="Toc3">Task 2: <a href="#T2.1.2">Improving the event handler</a></p>

    78. 

  78. 	<p class="Toc3">Task 3: <a href="#T2.1.3">Defining events in Python</a></p>

    79. 

  79. 	<p class="Toc2">Exercise 2: <a href="#T2.2">Windows Forms</a></p>

    80. 

  80. 	<p class="Toc3">Task 1: <a href="#T2.2.1">Simple Windows Forms application</a></p>

    81. 

  81. 	<p class="Toc2">Exercise 3: <a href="#T2.3">Windows Presentation Foundation (Avalon)</a></p>

    82. 

  82. 	<p class="Toc3">Task 1: <a href="#T2.3.1">Simple Avalon Application</a></p>

    83. 

  83. 	<p class="Toc3">Task 2: <a href="#T2.3.2">Avalon calculator</a></p>

    84. 

  84. 	<p class="Toc1">Tutorial 3: <a href="#T3">IronPython and COM interoperability</a></p>

    85. 

  85. 	<p class="Toc2">Exercise 1: <a href="#T3.1">Merlin the Wizard</a></p>

    86. 

  86. 	<p class="Toc3">Task 1: <a href="#T3.1.1">Creating COM interop assemblies</a></p>

    87. 

  87. 	<p class="Toc3">Task 2: <a href="#T3.1.2">Using COM objects from IronPython</a></p>

    88. 

  88. 	<p class="Toc2">Exercise 2: <a href="#T3.2">Use Word for Spell Checking</a></p>

    89. 

  89. 	<p class="Toc3">Task 1: <a href="#T3.2.1">Accessing Word and Checking

    90. 

  90. 	Spelling</a></p>

    91. 

  91. 	<p class="Toc3">Task 2: <a href="#T3.2.2">Use Windows Form Dialog to Correct

    92. 

  92. 	Spelling</a></p>

    93. 

  93. 	<p class="Toc1">Tutorial 4: <a href="#T4">Debugging IronPython program</a></p>

    94. 

  94. 	<p class="Toc2">Exercise 1: <a href="#T4.1">Debugging IronPython programs</a></p>

    95. 

  95. 	<p class="Toc3">Task 1: <a href="#T4.1.1">Debugging IronPython programs using Microsoft CLR Debugger</a></p>

    96. 

  96. 	<p class="Toc1">Tutorial 5: <a href="#T5">Extending IronPython</a></p>

    97. 

  97. 	<p class="Toc2">Exercise 1: <a href="#T5.1">Extending using C#</a></p>

    98. 

  98. 	<p class="Toc3">Task 1: <a href="#T5.1.1">Implementing simple class - constructor and ToString</a></p>

    99. 

  99. 	<p class="Toc3">Task 2: <a href="#T5.1.2">Making the object enumerable</a></p>

    100. 

  100. 	<p class="Toc3">Task 3: <a href="#T5.1.3">Adding custom operator</a></p>

    101. 

  101. 	<p class="Toc3">Task 4: <a href="#T5.1.4">Adding delegate</a></p>

    102. 

  102. 	<p class="Toc2">Exercise 2: <a href="#T5.2">Extending using Visual Basic.NET</a></p>

    103. 

  103. 	<p class="Toc3">Task 1: <a href="#T5.2.1">Implementing simple class - constructor and ToString</a></p>

    104. 

  104. 	<p class="Toc3">Task 2: <a href="#T5.2.2">Making the object enumerable</a></p>

    105. 

  105. 	<p class="Toc3">Task 3: <a href="#T5.2.3">Adding custom operator</a></p>

    106. 

  106. 	<p class="Toc3">Task 4: <a href="#T5.2.4">Adding delegate</a></p>

    107. 

  107.     <p class="Toc1">Tutorial 6: <a href="#T7">Using Visual Studio to Edit .py

    108. 

  108. 	Files and Debug Them</a></p>

    109. 

  109. 	<p class="Toc2">Exercise 1: <a href="#T6.1">Setting up Visual Studio for

    110. 

  110. 	IronPython Debugging</a></p>

    111. 

  111. 	<p class="Toc3">Task 1: <a href="#T6.1.1">Setting up Visual Studio for

    112. 

  112. 	IronPython Debugging</a></p>

    113. 

  113. </div>

    114. 

  114. <div class="Section2">

    115. 

  115. 	<h1><a name="Intro">Introduction</a></h1>

    116. 

  116. 	<p class="Normal">IronPython is the .NET implementation of the Python programming language

    117. 

  117.         (<a href="http://www.python.org">www.python.org</a>).&nbsp; It's a dynamically typed language with support

    118. 

  118.         for many programming paradigms such as object-oriented programming, and also allows

    119. 

  119. 	you to seamlessly use .NET code.</p>

    120. 

  120. 	<p class="Normal">&nbsp;</p>

    121. 

  121. 	<p class="Normal">The goal of this tutorial is to quickly

    122. 

  122. 	familiarize you with the IronPython console, and to show you how to make use of the extensive .NET libraries available.&nbsp;

    123. 

  123. 	This tutorial also shows you how to get started in more specialized areas

    124. 

  124. 	such as interoperating with COM, extending IronPython with C#, and embedding

    125. 

  125. 	IronPython.&nbsp; This tutorial is NOT meant to be an introduction to Python

    126. 

  126. 	itself, and if you're looking for that, we recommend you start with the

    127. 

  127. 	tutorial at <a href="http://docs.python.org/tut/tut.html">www.python.org</a>

    128. 

  128. 	or the often recommended book <i>Learning Python</i> by Mark Lutz and David

    129. 

  129. 	Ascher. For an introduction to both the Python language as well as the unique

    130. 

  130. 	capabilities of IronPython, we recommend <i>IronPython in Action</i> by 

    131. 

  131. 	Michael Foord<br><br>

    132. 

  132.         Some of the exercises in this tutorial require prerequisites.&nbsp; The prerequisites to successfully complete the whole tutorial are:</p>

    133. 

  133. 	<ul type="disc">

    134. 

  134. 		<li class="Normal">Microsoft .NET Framework Version 3.5

    135. 

  135. 		<ul type="circle">

    136. 

  136. 			<li class="Normal">Required to run IronPython on Windows Vista.</li>

    137. 

  137. 			<li class="Normal">Microsoft .NET Framework Version 3.0 SP1 or higher needed for Windows operating systems released prior to Windows Vista</li>

    138. 

  138. 			<li class="Normal">Download from

    139. 

  139. 			<a href="http://www.microsoft.com/downloads/details.aspx?familyid=333325FD-AE52-4E35-B531-508D977D32A6&displaylang=en   ">

    140. 

  140. 			here</a>.</li>

    141. 

  141. 		</ul>

    142. 

  142. 		</li>

    143. 

  143. 	</ul>

    144. 

  144. 	<ul>

    145. 

  145. 		<li class="Normal">Visual Studio 2005 or 2008<ul type="circle">

    146. 

  146. 			<li class="Normal">Required for &quot;Setting up Visual Studio for IronPython Debugging&quot; tutorials.</li>

    147. 

  147. 		</ul>

    148. 

  148. 		</li>

    149. 

  149. 	</ul>

    150. 

  150. 	<ul>

    151. 

  151. 		<li class="Normal">Microsoft Word<ul type="circle">

    152. 

  152. 			<li class="Normal">Required for &quot;Use Word for Spell Checking&quot; and &quot;Merlin the Wizard&quot; tutorials.</li>

    153. 

  153. 		</ul>

    154. 

  154. 		</li>

    155. 

  155. 	</ul>

    156. 

  156. 	<ul>

    157. 

  157. 		<li class="Normal"><a name="Mapack">Mapack</a> (example assembly found

    158. 

  158. 		on the internet)<ul>

    159. 

  159. 			<li>Required for the &quot;Basic IronPython&quot; tutorial, exercise &quot;Loading .NET

    160. 

  160. 			Libraries&quot;.</li>

    161. 

  161. 			<li>Download Mapack from

    162. 

  162. 			<a href="http://www.lutzroeder.com/dotnet/">here</a> (direct link

    163. 

  163. 			to the Mapack.zip download is

    164. 

  164. 			<a href="http://www.lutzroeder.com/dotnet/Download.aspx?File=Mapack">

    165. 

  165. 			here</a>).</li>

    166. 

  166. 			<li>Extract Mapack.dll from the zip file directly into the Tutorial

    167. 

  167. 			directory.</li>

    168. 

  168. 		</ul>

    169. 

  169. 		</li>

    170. 

  170. 	</ul>

    171. 

  171. 	<p class="Normal">&nbsp;</p>

    172. 

  172. 	<p class="Body">Visual Studio 2005 or 2008 can be used in place of the Microsoft .NET

    173. 

  173. 	Framework Version 2.0 and the .NET Framework 2.0 Software Development Kit (SDK).

    174. 

  174. 	Since Visual Studio installs both the .NET Framework 2.0 and the .NET Framework

    175. 

  175. 	SDK, there is no need to install those explicitly if you have Visual Studio

    176. 

  176. 	2005 available. Visual Studio 2008 also installs .NET Framework 3.5. </p>

    177. 

  177. 	<p class="Body">This tutorial also assumes that you will launch the

    178. 

  178. 	IronPython console (c:\ironpython\ipy.exe) from the tutorial directory.&nbsp;

    179. 

  179. 	When the tutorials direct you to start the IronPython console from the tutorial directory,

    180. 

  180. 	you should change to the tutorial directory (&gt;cd c:\ironpython\tutorial)

    181. 

  181. 	and launch the console with the tutorial as your working directory (&gt;..\ipy.exe). If you

    182. 

  182. 	install IronPython via the MSI installer, it will install to c:\Program Files\IronPython 2.0 

    183. 

  183. 	by default. In this scenario, you can still run the tutorial, but several tutorials require 

    184. 

  184. 	write access to the tutorial directory, which will require administrator access if IronPython

    185. 

  185. 	is installed under Program Files.</p>

    186. 

  186. 	<p class="Body">&nbsp;</p>

    187. 

  187. 	<h1><a name="T1">Tutorial 1: Basic IronPython</a></h1>

    188. 

  188. 	<p class="Body">The emphasis of this tutorial is on the basic interaction with

    189. 

  189. 	the IronPython interpreter and using the interactive environment to explore

    190. 

  190. 	the .NET libraries.</p>

    191. 

  191. 	<p class="Body">Estimated time to complete this tutorial: <b>30 minutes</b></p>

    192. 

  192. 	<p class="Body">The objective of this tutorial is to launch the IronPython interpreter,

    193. 

  193. 	explore the environment of the interactive console and use IronPython to interact

    194. 

  194. 	with .NET libraries.</p>

    195. 

  195. 	<p class="Body">The exercises in this tutorial are:</p>

    196. 

  196. 	<ul>

    197. 

  197. 		<li>

    198. 

  198. 		<p class="ExerciseList"><a href="#T1.1">The IronPython interactive console</a></p>

    199. 

  199. 		</li>

    200. 

  200. 		<li>

    201. 

  201. 		<p class="ExerciseList"><a href="#T1.2">Using the standard .NET libraries

    202. 

  202. 		from IronPython</a></p>

    203. 

  203. 		</li>

    204. 

  204. 		<li>

    205. 

  205. 		<p class="ExerciseList"><a href="#T1.3">Loading additional .NET libraries</a></p>

    206. 

  206. 		</li>

    207. 

  207. 	</ul>

    208. 

  208. 	<h2><a name="T1.1">Exercise 1: The IronPython interactive console</a></h2>

    209. 

  209. 	<p class="Body">In this exercise, you will start the IronPython interactive

    210. 

  210. 	interpreter and perform simple tasks to become acquainted with the IronPython

    211. 

  211. 	environment.</p>

    212. 

  212. 	<p class="Normal">If you are familiar with using the Python interactive console,

    213. 

  213. 	the import statement and exploring the Python interactive environment using

    214. 

  214. 	dir() function and __doc__ attribute, you can <a href="#T1.2">skip this exercise</a>.</p>

    215. 

  215. 	<h3><a name="T1.1.1">Task 1: IronPython console</a></h3>

    216. 

  216. 	<ol>

    217. 

  217. 		<li>

    218. 

  218. 		<p class="Step">Start the IronPython console from the tutorial directory

    219. 

  219. 		by changing to the tutorial directory (&gt;cd c:\ironpython\tutorial) and

    220. 

  220. 		launching the console c:\ironpython\ipy.exe executable (&gt;..\ipy.exe).&nbsp;

    221. 

  221. 		This is how you should always launch the console for the tutorials, but

    222. 

  222. 		from now on, we'll just direct you to &quot;start the IronPython console from

    223. 

  223. 		the tutorial directory&quot;.</p>

    224. 

  224. 		</li>

    225. 

  225. 	</ol>

    226. 

  226. 	<p class="Code-Highlighted">IronPython 2.0 (2.0.0.0) on .NET 2.0.50727.3053<br />

    227. 

  227. 	Copyright (c) Microsoft Corporation. All rights reserved.</p>

    228. 

  228. 	<p class="Code-Highlighted">&gt;&gt;&gt; _</p>

    229. 

  229. 	<ol start="2">

    230. 

  230. 		<li>

    231. 

  231. 		<p class="Step">Execute simple statements listed below.&nbsp; After each statement IronPython prints the result, if any, and awaits more input.&nbsp;

    232. 

  232. 		(The input line starting with &quot;for&quot; requires an extra return or enter

    233. 

  233. 		key press because the interpreter prompts for more statements in the

    234. 

  234. 		'for' loop.)</p>

    235. 

  235. 		</li>

    236. 

  236. 	</ol>

    237. 

  237. 	<p class="TypedExample">2+2</p>

    238. 

  238. 	<p class="TypedExample">print &quot;Hello World!&quot;</p>

    239. 

  239. 	<p class="TypedExample">for i in range(3): print i</p>

    240. 

  240. 	<p class="TypedExample">x = 10</p>

    241. 

  241. 	<p class="TypedExample">print x</p>

    242. 

  242. 	<p class="Stepnonumbering">&nbsp;</p>

    243. 

  243. 	<p class="Stepnonumbering">After this step, the console window will contain

    244. 

  244. 	the following text:</p>

    245. 

  245. 	<p class="Code-Highlighted">&gt;&gt;&gt; 2+2</p>

    246. 

  246. 	<p class="Code-Background">4</p>

    247. 

  247. 	<p class="Code-Highlighted">&gt;&gt;&gt; print &quot;Hello World!&quot;</p>

    248. 

  248. 	<p class="Code-Background">Hello World!</p>

    249. 

  249. 	<p class="Code-Highlighted">&gt;&gt;&gt; for i in range(3): print i</p>

    250. 

  250. 	<p class="Code-Highlighted">...</p>

    251. 

  251. 	<p class="Code-Background">0<br />

    252. 

  252. 	1<br />

    253. 

  253. 	2</p>

    254. 

  254. 	<p class="Code-Highlighted">&gt;&gt;&gt; x = 10<br />

    255. 

  255. 	&gt;&gt;&gt; print x</p>

    256. 

  256. 	<p class="Code-Background"></p>

    257. 

  257. 	<p class="Code-Background">10</p>

    258. 

  258. 	<p class="Code-Highlighted">&gt;&gt;&gt; </p>

    259. 

  259. 	<ol start="3">

    260. 

  260. 		<li>

    261. 

  261. 		<p class="Step">IronPython console supports multi-line statements, often

    262. 

  262. 		used by function definitions.&nbsp; IronPython prompts for additional lines of

    263. 

  263. 		multi-line statements using:</p>

    264. 

  264. 		</li>

    265. 

  265. 	</ol>

    266. 

  266. 	<p class="Code-Highlighted">...</p>

    267. 

  267. 	<p class="Code-Background"></p>

    268. 

  268. 	<p class="Stepnonumbering">Unlike C# or Java, where blocks of code are grouped by curly brackets "{...}",

    269. 

  269.         blocks of code in Python are grouped based on their level of indentation.&nbsp; Every new block of code

    270. 

  270.         must be indented one more level than the previous block of code.&nbsp; Blocks of code are used for

    271. 

  271.         function and class definitions as well as 'if' statements and loops. </p>

    272. 

  272. 	<p class="Stepnonumbering">Define the &quot;add&quot; function (note, you

    273. 

  273. 	need to enter spaces before the 'return' statement):</p>

    274. 

  274. 	<p class="TypedExample">def add(a, b):<br>

    275. 

  275. &nbsp;&nbsp;&nbsp; return a + b</p>

    276. 

  276. 	<p class="Stepnonumbering">To complete the function definition, press Enter

    277. 

  277. 	once more at this point</p>

    278. 

  278. 	<p class="TypedExample">add(3, 2)</p>

    279. 

  279. 	<p class="TypedExample">add(&quot;Iron&quot;, &quot;Python&quot;)</p>

    280. 

  280. 	<p class="Stepnonumbering">After this step, the console contents will be:</p>

    281. 

  281. 	<p class="Code-Highlighted">&gt;&gt;&gt; def add(a, b):<br />

    282. 

  282. 	...&nbsp;&nbsp;&nbsp;&nbsp; return a + b<br />

    283. 

  283. 	...<br />

    284. 

  284. 	&gt;&gt;&gt; add(3, 2)</p>

    285. 

  285. 	<p class="Code-Background">5</p>

    286. 

  286. 	<p class="Code-Highlighted">&gt;&gt;&gt; add(&quot;Iron&quot;, &quot;Python&quot;)</p>

    287. 

  287. 	<p class="Code-Background">&#39;IronPython&#39;</p>

    288. 

  288. 	<p class="Code-Highlighted">&gt;&gt;&gt; </p>

    289. 

  289. 	<p class="Step">&nbsp;</p>

    290. 

  290. 	<ol start="4">

    291. 

  291. 		<li>

    292. 

  292. 		<p class="Step">To exit the IronPython interactive console, type Ctrl+Z and Enter (alternatively,

    293. 

  293. 		press F6 followed by Enter).</p>

    294. 

  294. 		</li>

    295. 

  295. 	</ol>

    296. 

  296. 	<p class="TypedExample">^Z</p>

    297. 

  297. 	<h3><a name="T1.1.2">Task 2: Built-in modules and interactive exploration</a></h3>

    298. 

  298. 	<ol>

    299. 

  299. 		<li>

    300. 

  300. 		<p class="Step">Start the IronPython console from the tutorial directory

    301. 

  301. 		(see <a href="#Intro">Introduction</a> for details).</p>

    302. 

  302. 		</li>

    303. 

  303. 		<li>

    304. 

  304. 		<p class="Step">Using the built-in dir() function, list the contents of

    305. 

  305. 		the IronPython environment:</p>

    306. 

  306. 		</li>

    307. 

  307. 	</ol>

    308. 

  308. 	<p class="TypedExample">dir()</p>

    309. 

  309. 	<p class="Stepnonumbering">The output in the console window will be:</p>

    310. 

  310. 	<p class="Code-Highlighted">&gt;&gt;&gt; dir()</p>

    311. 

  311. 	<p class="Code-Background">['__builtins__', '__doc__', '__name__']<br />

    312. 

  312. </p>

    313. 

  313. 	<ol start="3">

    314. 

  314. 		<li>

    315. 

  315. 		<p class="Step">IronPython comes with several built-in modules, the most

    316. 

  316. 		frequently used one being &quot;sys&quot;.&nbsp; Import &quot;sys&quot; module using the &quot;import&quot;

    317. 

  317. 		statement:</p>

    318. 

  318. 		</li>

    319. 

  319. 	</ol>

    320. 

  320. 	<p class="TypedExample">import sys</p>

    321. 

  321. 	<ol start="4">

    322. 

  322. 		<li>

    323. 

  323. 		<p class="Step">The Python import statement is similar to the &quot;using&quot; statement

    324. 

  324. 		of C# or &quot;Imports&quot; statement of Visual Basic. The important difference is

    325. 

  325. 		that the C# and VB statements bring the names from the imported namespace

    326. 

  326. 		into the global namespace to be accessed directly. Python’s import doesn’t

    327. 

  327. 		do that. To access the names or attributes in an imported module, prefix

    328. 

  328. 		the

    329. 

  329. 		names with the module's name:</p>

    330. 

  330. 		</li>

    331. 

  331. 	</ol>

    332. 

  332. 	<p class="UserExample">sys.version</p>

    333. 

  333. 	<ol start="5">

    334. 

  334. 		<li>

    335. 

  335. 		<p class="Step">Use the dir() function to explore the environment:</p>

    336. 

  336. 		</li>

    337. 

  337. 	</ol>

    338. 

  338. 	<p class="TypedExample">dir()</p>

    339. 

  339. 	<p class="Stepnonumbering" style="margin-left: 0.5in">The environment (global namespace) has changed, now

    340. 

  340. 	it contains the &quot;sys&quot; module:</p>

    341. 

  341. 	<p class="Code-Highlighted">&gt;&gt;&gt; dir()</p>

    342. 

  342. 	<p class="Code-Background">['__builtins__', '__doc__', '__name__', 'sys']</p>

    343. 

  343. 	<ol start="6">

    344. 

  344. 		<li>

    345. 

  345. 		<p class="Step">Use the dir() function to explore the contents of the &quot;sys&quot;

    346. 

  346. 		module:</p>

    347. 

  347. 		</li>

    348. 

  348. 	</ol>

    349. 

  349. 	<p class="TypedExample">dir(sys)</p>

    350. 

  350. 	<p class="HiddenOutput">['__name__', '__stderr__', '__stdin__', '__stdout__', '_getframe', 'api_version', 'argv', 'builtin_module_names', 'byteorder', 'copyright', 'displayhook', 'exc_clear', 'exc_info', 'exc_traceback', 'exc_type', 'exc_value', 'excepthook', 'exec_prefix', 'executable', 'exit', 'getcheckinterval', 'getdefaultencoding', 'getfilesystemencoding', 'getrecursionlimit', 'hexversion', 'maxint', 'maxunicode', 'meta_path', 'modules', 'path', 'path_hooks', 'path_importer_cache', 'platform', 'prefix', 'ps1', 'ps2', 'setcheckinterval', 'setdefaultencoding', 'setrecursionlimit', 'settrace', 'stderr', 'stdin', 'stdout', 'version', 'version_info', 'warnoptions', 'winver']</p>

    351. 

  351. 	<ol start="7">

    352. 

  352. 		<li>

    353. 

  353. 		<p class="Step">Print the values of some of the &quot;sys&quot; module attributes:</p>

    354. 

  354. 		</li>

    355. 

  355. 	</ol>

    356. 

  356. 	<p class="TypedExample">sys.path</p>

    357. 

  357. 	<p class="LooseVerify">['.', '%MERLIN_ROOT%\\Test\\IronPythonTutorial', '%MERLIN_ROOT%\\Test', '%MERLIN_ROOT%\\Languages\\IronPython\\Tutorial', '%MERLIN_ROOT%\\Languages\\IronPython\\Tests', '%MERLIN_ROOT%\\Bin\\Debug\\Lib']</p>

    358. 

  358. 	<p class="TypedExample">sys.executable</p>

    359. 

  359. 	<p class="LooseVerify">'%MERLIN_ROOT%\\Bin\\Debug\\ipy.exe'</p>

    360. 

  360. 	<h3><a name="T1.1.3">Task 3: External Python modules</a></h3>

    361. 

  361. 	<p class="Normal">This task uses the module &quot;first.py&quot; located in the Tutorial

    362. 

  362. 	folder.</p>

    363. 

  363. 	<ol>

    364. 

  364. 		<li>

    365. 

  365. 		<p class="Step">Import the &quot;first.py&quot; module located in the Tutorial

    366. 

  366. 		(because you launched ipy.exe from the Tutorial directory, &quot;first&quot; will

    367. 

  367. 		be found on your sys.path):</p>

    368. 

  368. 		</li>

    369. 

  369. 	</ol>

    370. 

  370. 	<p class="TypedExample">import first</p>

    371. 

  371. 	<p class="Code-Background"></p>

    372. 

  372. 	<ol start="2">

    373. 

  373. 		<li>

    374. 

  374. 		<p class="Step">Explore the module &quot;first&quot; using dir() function:</p>

    375. 

  375. 		</li>

    376. 

  376. 	</ol>

    377. 

  377. 	<p class="TypedExample">dir(first)</p>

    378. 

  378. 	<p class="Code-Highlighted">&gt;&gt;&gt; dir(first)</p>

    379. 

  379. 	<p class="Code-Background">['__builtins__', '__file__', '__name__', 'add', 'factorial', 'hi']</p>

    380. 

  380. 	<ol start="3">

    381. 

  381. 		<li>

    382. 

  382. 		<p class="Step">Print the documentation for the &quot;add&quot; and &quot;factorial&quot; functions,

    383. 

  383. 		using __doc__ attribute:</p>

    384. 

  384. 		</li>

    385. 

  385. 	</ol>

    386. 

  386. 	<p class="TypedExample">first.add.__doc__</p>

    387. 

  387. 	<p class="TypedExample">first.factorial.__doc__</p>

    388. 

  388. 	<p class="Stepnonumbering">&nbsp;</p>

    389. 

  389. 	<p class="Stepnonumbering">The __doc__ attribute will be later used also for

    390. 

  390. 	exploring .NET methods and their parameter types.</p>

    391. 

  391. 	<p class="Code-Highlighted">&gt;&gt;&gt; first.add.__doc__</p>

    392. 

  392. 	<p class="Code-Background">&#39;add(a, b) -&gt; returns a + b&#39;</p>

    393. 

  393. 	<p class="Code-Highlighted">&gt;&gt;&gt; first.factorial.__doc__</p>

    394. 

  394. 	<p class="Code-Background">&#39;factorial(n) -&gt; returns factorial of n&#39;</p>

    395. 

  395. 	<ol start="4">

    396. 

  396. 		<li>

    397. 

  397. 		<p class="Step">Call the methods in the &quot;first&quot; module and print the contents

    398. 

  398. 		of the &quot;hi&quot; attribute</p>

    399. 

  399. 		</li>

    400. 

  400. 	</ol>

    401. 

  401. 	<p class="TypedExample">first.add(1,2)</p>

    402. 

  402. 	<p class="TypedExample">first.factorial(5)</p>

    403. 

  403. 	<p class="TypedExample">first.hi</p>

    404. 

  404. 	<p class="Stepnonumbering">The expected output is:</p>

    405. 

  405. 	<p class="Code-Highlighted">&gt;&gt;&gt; first.add(1,2)</p>

    406. 

  406. 	<p class="Code-Background">3</p>

    407. 

  407. 	<p class="Code-Highlighted">&gt;&gt;&gt; first.factorial(5)</p>

    408. 

  408. 	<p class="Code-Background">120</p>

    409. 

  409. 	<p class="Code-Highlighted">&gt;&gt;&gt; first.hi</p>

    410. 

  410. 	<p class="Code-Background">&#39;Hello from IronPython!&#39;</p>

    411. 

  411. 	<ol start="5">

    412. 

  412. 		<li>

    413. 

  413. 		<p class="Step">Exit the IronPython Interactive console (Ctrl+Z or F6 followed

    414. 

  414. 		by Enter)</p>

    415. 

  415. 		</li>

    416. 

  416. 	</ol>

    417. 

  417. 	<h2><a name="T1.2">Exercise 2: Using the standard .NET libraries from IronPython</a></h2>

    418. 

  418. 	<p class="Body">The power of IronPython lies within the ability to seamlessly

    419. 

  419. 	access the wealth of .NET libraries. This exercise will demonstrate how the

    420. 

  420. 	.NET libraries can be used from IronPython.</p>

    421. 

  421. 	<p class="Body">In this exercise, you will use the standard .NET libraries from

    422. 

  422. 	IronPython. </p>

    423. 

  423. 	<h3><a name="T1.2.1">Task 1: Basic .NET library use</a></h3>

    424. 

  424. 	<ol>

    425. 

  425. 		<li>

    426. 

  426. 		<p class="Step">Start the IronPython console from the tutorial directory

    427. 

  427. 		(see <a href="#Intro">Introduction</a> for details).</p>

    428. 

  428. 		</li>

    429. 

  429. 		<li>

    430. 

  430. 		<p class="Step">Using the &quot;import&quot; statement, import the .NET System namespace:</p>

    431. 

  431. 		</li>

    432. 

  432. 	</ol>

    433. 

  433. 	<p class="TypedExample">import System</p>

    434. 

  434. 	<p class="Code-Background"></p>

    435. 

  435. 	<ol start="3">

    436. 

  436. 		<li>

    437. 

  437. 		<p class="Step">Explore the System.Environment class and access some of

    438. 

  438. 		its properties:</p>

    439. 

  439. 		</li>

    440. 

  440. 	</ol>

    441. 

  441. 	<p class="TypedExample">dir(System.Environment)</p>

    442. 

  442. 	<p class="UserCode">System.Environment.OSVersion</p>

    443. 

  443. 	<p class="TypedExample">System.Environment.CommandLine</p>

    444. 

  444. 	<p class="Stepnonumbering">The expected output of these commands is as follows

    445. 

  445. 	(with some ellipsis for convenience):</p>

    446. 

  446. 	<p class="Code-Highlighted">&gt;&gt;&gt; dir(System.Environment)</p>

    447. 

  447. 	<p class="HiddenOutput">['CommandLine', 'CurrentDirectory', 'Equals', 'Exit', 'ExitCode', 'ExpandEnvironmentVariables', 'FailFast', 'GetCommandLineArgs', 'GetEnvironmentVariable', 'GetEnvironmentVariables', 'GetFolderPath', 'GetHashCode', 'GetLogicalDrives', 'GetType', 'HasShutdownStarted', 'MachineName', 'MemberwiseClone', 'NewLine', 'OSVersion', 'ProcessorCount', 'ReferenceEquals', 'SetEnvironmentVariable', 'SpecialFolder', 'StackTrace', 'SystemDirectory', 'TickCount', 'ToString', 'UserDomainName', 'UserInteractive', 'UserName', 'Version', 'WorkingSet', '__all__', '__class__', '__delattr__', '__doc__', '__getattribute__', '__hash__', '__init__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__setattr__', '__str__']</p>

    448. 

  448. 	<p class="Code-Highlighted">&gt;&gt;&gt; System.Environment.OSVersion</p>

    449. 

  449. 	<p class="Code-Highlighted">&lt;System.OperatingSystem object at 0x000000000000002B [Microsoft Windows NT 6.0.6000.0]</p>

    450. 

  450. 	<p class="Code-Highlighted">&gt;&gt;&gt; System.Environment.CommandLine</p>

    451. 

  451. 	<p class="Code-Highlighted">&#39;C:\\IronPython\\ipy.exe&#39;

    452. 

  452. 	<p class="LooseVerify">'"%MERLIN_ROOT%\\Bin\\Debug\\ipy.exe"'

    453. 

  453. 	</p>

    454. 

  454. 	<ol start="4">

    455. 

  455. 		<li>

    456. 

  456. 		<p class="Step">The import statement can be used also to import contents of

    457. 

  457. 		a class or module into the global namespace.&nbsp; Use the &quot;from ... import ...&quot;

    458. 

  458. 		flavor of the import statement to do that and explore the contents of the

    459. 

  459. 		global namespace using dir().</p>

    460. 

  460. 		</li>

    461. 

  461. 	</ol>

    462. 

  462. 	<p class="TypedExample">from System.Math import *</p>

    463. 

  463. 	<p class="UserCode">dir()</p>

    464. 

  464. 	<p class="HiddenCode">set1 = set(dir())

    465. 

  465. set2 = set(dir(object))

    466. 

  466. list(set1-set2)

    467. 

  467. 	</p>

    468. 

  468. 	<p class="HiddenOutput">

    469. 

  469. 

    470. 

  470. 	['Tan','Sqrt','Acos','Sin','Abs','Round','Pow','Floor','Exp','Log','Atan2','IEEERemainder','Atan','__builtins__','Asin','System','E','Cosh','__name__', 'Ceiling','DivRem','BigMul','Cos','Truncate','Min','Tanh','Log10','Sign','Max','Sinh','PI']</p>

    471. 

  471. 	<p class="Stepnonumbering">Now you can call Math methods without having to specify

    472. 

  472. 	the namespace and class name prefix:</p>

    473. 

  473. 	<p class="TypedExample">Sin(PI/2)</p>

    474. 

  474. 	<p class="Stepnonumbering">The expected output is:</p>

    475. 

  475. 	<p class="Code-Highlighted">&gt;&gt;&gt; from System.Math import *</p>

    476. 

  476. 	<p class="Code-Highlighted">&gt;&gt;&gt; dir()</p>

    477. 

  477. 	<p class="Code-Highlighted">[&#39;Abs&#39;, &#39;Acos&#39;, &#39;Asin&#39;, &#39;Atan&#39;, &#39;Atan2&#39;, &#39;BigMul&#39;, &#39;Ceiling&#39;, &#39;Cos&#39;, &#39;Cosh&#39;, &#39;DivRem&#39;, &#39;E&#39;, &#39;Equals&#39;, &#39;Exp&#39;, &#39;Floor&#39;, &#39;GetHashCode&#39;, &#39;GetType&#39;, &#39;IEEERemainder&#39;, &#39;Log&#39;, &#39;Log10&#39;, &#39;Max&#39;, &#39;Min&#39;, &#39;PI&#39;, &#39;Pow&#39;, &#39;Round&#39;, &#39;Sign&#39;, &#39;Sin&#39;, &#39;Sinh&#39;, &#39;Sqrt&#39;, &#39;System&#39;, &#39;Tan&#39;, &#39;Tanh&#39;, &#39;ToString&#39;, &#39;Truncate&#39;, &#39;__builtins__&#39;, &#39;__doc__&#39;, &#39;__name__&#39;]</p>

    478. 

  478. 	<p class="Code-Highlighted">&gt;&gt;&gt; Sin(PI/2)</p>

    479. 

  479. 	<p class="Code-Background">1.0</p>

    480. 

  480. 	<h3><a name="T1.2.2">Task 2: Working with .NET classes</a></h3>

    481. 

  481. 	<ol>

    482. 

  482. 		<li>

    483. 

  483. 		<p class="Step">Import the contents of the &quot;System.Collections&quot; namespace

    484. 

  484. 		into the global namespace:</p>

    485. 

  485. 		</li>

    486. 

  486. 	</ol>

    487. 

  487. 	<p class="TypedExample">from System.Collections import *</p>

    488. 

  488. 	<p class="Code-Background"></p>

    489. 

  489. 	<ol start="2">

    490. 

  490. 		<li>

    491. 

  491. 		<p class="Step">Create instance of the Hashtable class and explore the instance

    492. 

  492. 		using dir():</p>

    493. 

  493. 		</li>

    494. 

  494. 	</ol>

    495. 

  495. 	<p class="TypedExample">h = Hashtable()</p>

    496. 

  496. 	<p class="Code-Background"></p>

    497. 

  497. 	<p class="UserCode">dir(h)</p>

    498. 

  498. 	<p class="HiddenCode">set1 = set(dir(h))

    499. 

  499. set2 = set(dir(object))

    500. 

  500. list(set1-set2)</p>

    501. 

  501. 	<p class="HiddenOutput">

    502. 

  502.         

    503. 

  503.         ['Clone','ContainsValue','SyncRoot','hcp','__setitem__','__contains__','KeyEquals','IsSynchronized','GetEnumerator','GetHash','Contains','Item','Values','ContainsKey','Remove','OnDeserialization','__iter__','Add','Synchronized','EqualityComparer','__len__','comparer','Keys','Clear','IsReadOnly','CopyTo','IsFixedSize','__add__','GetObjectData','Count','__getitem__']</p>

    504. 

  504. 	<ol start="3">

    505. 

  505. 		<li>

    506. 

  506. 		<p class="Step">Insert&nbsp;a few elements into the hash table:</p>

    507. 

  507. 		</li>

    508. 

  508. 	</ol>

    509. 

  509. 	<p class="TypedExample">h[&quot;a&quot;] = &quot;IronPython&quot;</p>

    510. 

  510. 	<p class="Code-Background"></p>

    511. 

  511. 	<p class="TypedExample">h[&quot;b&quot;] = &quot;Tutorial&quot;</p>

    512. 

  512. 	<p class="Code-Background"></p>

    513. 

  513. 	<p class="Stepnonumbering">&nbsp;</p>

    514. 

  514. 	<p class="Stepnonumbering">IronPython supports the C# - style syntax for accessing

    515. 

  515. 	the hash table elements.&nbsp; The same syntax applies to any index-able object (Arrays,

    516. 

  516. 	Array lists etc):</p>

    517. 

  517. 	<p class="TypedExample">h[&quot;a&quot;]</p>

    518. 

  518. 	<p class="Stepnonumbering" style="page-break-after:avoid">&nbsp;</p>

    519. 

  519. 	<p class="Stepnonumbering" style="page-break-after:avoid">The output of this

    520. 

  520. 	step will be:</p>

    521. 

  521. 	<p class="Code-Background" style="page-break-after:avoid">&gt;&gt;&gt; h[&quot;a&quot;] = &quot;IronPython&quot;<br />

    522. 

  522. 	&gt;&gt;&gt; h[&quot;b&quot;] = &quot;Tutorial&quot;</p>

    523. 

  523. 	<p class="Code-Highlighted" style="page-break-after:avoid">&gt;&gt;&gt; h[&quot;a&quot;]</p>

    524. 

  524. 	<p class="Code-Background">&#39;IronPython&#39;</p>

    525. 

  525. 	<ol start="4">

    526. 

  526. 		<li>

    527. 

  527. 		<p class="Step">Enumerate the contents of the hash table using the &quot;for

    528. 

  528. 		... in ...&quot; statement. The hash table elements are instances of &quot;DictionaryEntry&quot;

    529. 

  529. 		class. Print the &quot;Key&quot; and &quot;Value&quot; properties of each entry:</p>

    530. 

  530. 		</li>

    531. 

  531. 	</ol>

    532. 

  532. 	<p class="TypedExample">for e in h: print e.Key, &quot;:&quot;, e.Value</p>

    533. 

  533. 	<p class="Stepnonumbering">&nbsp;</p>

    534. 

  534. 	<p class="Stepnonumbering">The expected output in the console is (the input

    535. 

  535. 	line starting with &quot;for&quot; requires an extra return or enter key press because

    536. 

  536. 	the interpreter prompts for more statements in the 'for' loop.):</p>

    537. 

  537. 	<p class="Code-Highlighted">&gt;&gt;&gt; for e in h: print e.Key, &quot;:&quot;, e.Value<br>

    538. 

  538. 	...</p>

    539. 

  539. 	<p class="Code-Background">a : IronPython<br />

    540. 

  540. 	b : Tutorial</p>

    541. 

  541. 	<ol start="5">

    542. 

  542. 		<li>

    543. 

  543. 		<p class="Step">You can initialize the collection classes by passing in

    544. 

  544. 		the Python built-in list or tuple data types as arguments.&nbsp; You can

    545. 

  545. 		create a Python list by specifying the list of elements in square brackets: [1,2,3].&nbsp;

    546. 

  546. 		You create tuples by specifying elements in the parentheses: (1,2,3).</p>

    547. 

  547. 		</li>

    548. 

  548. 	</ol>

    549. 

  549. 	<p class="TypedExample">l = ArrayList([1,2,3])</p>

    550. 

  550. 	<p class="Code-Background"></p>

    551. 

  551. 	<p class="TypedExample">for i in l: print i</p>

    552. 

  552. 	<p class="TypedExample">s = Stack((1,2,3))</p>

    553. 

  553. 	<p class="TypedExample">while s.Count: s.Pop()</p>

    554. 

  554. 	<p class="Stepnonumbering">&nbsp;</p>

    555. 

  555. 	<p class="Stepnonumbering">The expected output is:</p>

    556. 

  556. 	<p class="Code-Highlighted">&gt;&gt;&gt; l = ArrayList([1,2,3])<br />

    557. 

  557. 	&gt;&gt;&gt; for i in l: print i<br>

    558. 

  558. 	...</p>

    559. 

  559. 	<p class="Code-Background">1<br />

    560. 

  560. 	2<br />

    561. 

  561. 	3</p>

    562. 

  562. 	<p class="Code-Background"></p>

    563. 

  563. 	<p class="Code-Highlighted">&gt;&gt;&gt; s = Stack((1,2,3))<br />

    564. 

  564. 	&gt;&gt;&gt; while s.Count: s.Pop()<br>...</p>

    565. 

  565. 	<p class="Code-Background">3<br />

    566. 

  566. 	2<br />

    567. 

  567. 	1</p>

    568. 

  568. 	<h3><a name="T1.2.3">Task 3: Generics</a></h3>

    569. 

  569. 	<ol>

    570. 

  570. 		<li>

    571. 

  571. 		<p class="Step">Import the Generic collections from the System.Collections.Generic

    572. 

  572. 		namespace:</p>

    573. 

  573. 		</li>

    574. 

  574. 	</ol>

    575. 

  575. 	<p class="TypedExample">from System.Collections.Generic import *</p>

    576. 

  576. 	<p class="Code-Background"></p>

    577. 

  577. 	<ol start="2">

    578. 

  578. 		<li>

    579. 

  579. 		<p class="Step">To instantiate a generic class, the generic type arguments

    580. 

  580. 		must be specified.&nbsp; IronPython uses the following syntax to specify the type

    581. 

  581. 		arguments: generic_type[type_argument, ...].&nbsp; Create an instance of generic

    582. 

  582.         list of string:</p>

    583. 

  583. 		</li>

    584. 

  584. 	</ol>

    585. 

  585. 	<p class="TypedExample">l = List[str]()</p>

    586. 

  586. 		<p class="Code-Background"></p>

    587. 

  587. 	<ol start="3">

    588. 

  588. 		<li>

    589. 

  589. 		<p class="Step">Add string values into the list. Since we created a list of

    590. 

  590. 		string, adding strings is possible:</p>

    591. 

  591. 		</li>

    592. 

  592. 	</ol>

    593. 

  593. 	<p class="TypedExample">l.Add(&quot;Hello&quot;)</p>

    594. 

  594. 		<p class="Code-Background"></p>

    595. 

  595. 	<p class="TypedExample">l.Add(&quot;Hi&quot;)</p>

    596. 

  596. 		<p class="Code-Background"></p>

    597. 

  597. 	<ol start="4">

    598. 

  598. 		<li>

    599. 

  599. 		<p class="Step">Try adding objects of types other than string:</p>

    600. 

  600. 		</li>

    601. 

  601. 	</ol>

    602. 

  602. 	<p class="ExceptionExample">l.Add(3)</p>

    603. 

  603. 	<p class="Code-Background"></p>

    604. 

  604. 	<p class="ExceptionExample">l.Add(2.5)</p>

    605. 

  605. 	<p class="Code-Background"></p>

    606. 

  606. 	<p class="ExceptionExample">l.Add([1,2,3])</p>

    607. 

  607. 	<p class="Code-Background"></p>

    608. 

  608. 	<p class="Stepnonumbering">&nbsp;</p>

    609. 

  609. 	<p class="Stepnonumbering">Obviously, adding non-strings will fail with type

    610. 

  610. 	error:</p>

    611. 

  611. 	<p class="Code-Highlighted">&gt;&gt;&gt; l.Add(3)</p>

    612. 

  612. 	<p class="Code-Highlighted">Traceback (most recent call last):<br>

    613. 

  613. 

    614. 

  614.   File , line unknown, in Initialize##40

    615. 

  615. 	<br>

    616. 

  616. TypeError: expected str, got int

    617. 

  617. 	<br></p>

    618. 

  618. 	<ol start="5">

    619. 

  619. 		<li>

    620. 

  620. 		<p class="Step">Enumerate the generic collection:</p>

    621. 

  621. 		</li>

    622. 

  622. 	</ol>

    623. 

  623. 	<p class="TypedExample">for i in l: print i</p>

    624. 

  624. 	<p class="Stepnonumbering">The output will be:</p>

    625. 

  625. 	<p class="Code-Highlighted">&gt;&gt;&gt; for i in l: print i<br>...</p>

    626. 

  626. 	<p class="Code-Background">Hello<br />

    627. 

  627. 	Hi</p>

    628. 

  628. 	<p class="ExceptionOutput">TypeError: expected str, got int

    629. 

  629. TypeError: expected str, got float

    630. 

  630. TypeError: expected str, got list</p>

    631. 

  631. 	<ol start="6">

    632. 

  632. 		<li>

    633. 

  633. 		<p class="Step">Exit the IronPython Interactive console (Ctrl+Z or F6 followed

    634. 

  634. 		by Enter)</p>

    635. 

  635. 		</li>

    636. 

  636. 	</ol>

    637. 

  637. 	<h2><a name="T1.3">Exercise 3: Loading .NET libraries</a></h2>

    638. 

  638. 	<p class="Body">IronPython can directly import only some of the .NET libraries

    639. 

  639. 	- the most commonly used ones.&nbsp; To use additional .NET libraries, they must be

    640. 

  640. 	explicitly referenced.&nbsp; IronPython maintains a list of all referenced

    641. 

  641. 	assemblies (see clr.References in Task 1).&nbsp; To add a reference to a .NET assembly, use the functions

    642. 

  642. 	available in the built-in &quot;clr&quot; module:</p>

    643. 

  643. 	<ul>

    644. 

  644. 		<li>

    645. 

  645. 		<p class="Body"><b>clr.AddReference</b> adds a reference to the .NET assembly

    646. 

  646. 		either by passing the .NET assembly object directly, or specifying the file

    647. 

  647. 		name or the assembly name (full or partial). This function is provided primarily

    648. 

  648. 		for the interactive exploration. We recommend using the following functions

    649. 

  649. 		in the code modules, since they provide more control over which assembly

    650. 

  650. 		is being loaded.</p>

    651. 

  651. 		</li>

    652. 

  652. 		<li>

    653. 

  653. 		<p class="Body"><b>clr.AddReferenceToFile</b> adds reference to the assembly

    654. 

  654. 		specified by its file name. This function will load the assembly from the

    655. 

  655. 		file regardless of the assembly version. As a result, it doesn&#39;t guarantee

    656. 

  656. 		that the correct assembly version is being loaded. To guarantee that correct

    657. 

  657. 		assembly version is being loaded, use clr.AddReferenceByName. Moreover,

    658. 

  658. 		AddReferenceToFile requires that the assembly be located in a

    659. 

  659. 		directory listed in sys.path.</p>

    660. 

  660. 		</li>

    661. 

  661. 		<li>

    662. 

  662. 		<p class="Body"><b>clr.AddReferenceToFileAndPath</b> provides similar

    663. 

  663. 		functionality to AddReferenceToFile. The difference is that it accepts

    664. 

  664. 		absolute path and before loading the assembly, AddReferenceToFileAndPath

    665. 

  665. 		adds the file path into sys.path.</p>

    666. 

  666. 		</li>

    667. 

  667. 		<li>

    668. 

  668. 		<p class="Body"><b>clr.AddReferenceByName</b> adds reference to the assembly

    669. 

  669. 		specified by its full assembly name, for example: &#39;System.Xml, Version=2.0.0.0,

    670. 

  670. 		Culture=neutral, PublicKeyToken=b77a5c561934e089&#39;.</p>

    671. 

  671. 		</li>

    672. 

  672. 		<li>

    673. 

  673. 		<p class="Body"><b>clr.AddReferenceByPartialName</b> adds reference to the

    674. 

  674. 		assembly by specifying a partial assembly name. This function cannot guarantee

    675. 

  675. 		that the correct version of the assembly is being loaded. Use clr.AddReferenceByName

    676. 

  676. 		to add reference to specific version of the assembly.</p>

    677. 

  677. 		</li>

    678. 

  678. 	</ul>

    679. 

  679. 	<h3><a name="T1.3.1">Task 1: Using System.Xml - AddReference</a></h3>

    680. 

  680. 	<ol>

    681. 

  681. 		<li>

    682. 

  682. 		<p class="Step">Start the IronPython console from the tutorial directory

    683. 

  683. 		(see <a href="#Intro">Introduction</a> for details).</p>

    684. 

  684. 		</li>

    685. 

  685. 		<li>

    686. 

  686. 		<p class="Step">To import System.Xml, the reference to the assembly containing

    687. 

  687. 		the Xml components must be first added to IronPython.&nbsp; Add reference to System.Xml

    688. 

  688. 		using the following code&nbsp; (you can enter &quot;clr.References&quot; before

    689. 

  689. 		and after the call to clr.AddReference to see it change if you want):</p>

    690. 

  690. 		</li>

    691. 

  691. 	</ol>

    692. 

  692. 	<p class="TypedExample">import clr</p>

    693. 

  693. 	<p class="Code-Background"></p>

    694. 

  694. 	<p class="TypedExample">clr.AddReference(&quot;System.Xml&quot;)</p>

    695. 

  695. 	<p class="Code-Background"></p>

    696. 

  696. 	<p class="TypedExample">from System.Xml import *</p>

    697. 

  697. 	<p class="Code-Background"></p>

    698. 

  698. 	<p class="TypedExample">dir()</p>

    699. 

  699. 	<p class="HiddenOutput">['ConformanceLevel', 'EntityHandling', 'Formatting', 'IHasXmlNode', 'IXmlLineInfo', 'IXmlNamespaceResolver', 'NameTable', 'NewLineHandling', 'ReadState', 'Schema', 'Serialization', 'ValidationType', 'WhitespaceHandling', 'WriteState', 'XPath', 'XmlAttribute', 'XmlAttributeCollection', 'XmlCDataSection', 'XmlCharacterData', 'XmlComment', 'XmlConvert', 'XmlDateTimeSerializationMode', 'XmlDeclaration', 'XmlDocument', 'XmlDocumentFragment', 'XmlDocumentType', 'XmlElement', 'XmlEntity', 'XmlEntityReference', 'XmlException', 'XmlImplementation', 'XmlLinkedNode', 'XmlNameTable', 'XmlNamedNodeMap', 'XmlNamespaceManager', 'XmlNamespaceScope', 'XmlNode', 'XmlNodeChangedAction', 'XmlNodeChangedEventArgs', 'XmlNodeChangedEventHandler', 'XmlNodeList', 'XmlNodeOrder', 'XmlNodeReader', 'XmlNodeType', 'XmlNotation', 'XmlOutputMethod', 'XmlParserContext', 'XmlProcessingInstruction', 'XmlQualifiedName', 'XmlReader', 'XmlReaderSettings', 'XmlResolver', 'XmlSecureResolver', 'XmlSignificantWhitespace', 'XmlSpace', 'XmlText', 'XmlTextReader', 'XmlTextWriter', 'XmlTokenizedType', 'XmlUrlResolver', 'XmlValidatingReader', 'XmlWhitespace', 'XmlWriter', 'XmlWriterSettings', 'Xsl', '__builtins__', '__doc__', '__name__', 'clr']</p>

    700. 

  700. 	<ol start="3">

    701. 

  701. 		<li>

    702. 

  702. 		<p class="Step">Note that the clr.AddReference function accepts either System.Reflection.Assembly object or string

    703. 

  703. 		as a parameter. The string parameter can

    704. 

  704. 		be a full assembly name, a partial assembly name, or a file name. For more control

    705. 

  705. 		over the assembly references, use the appropriate functions described

    706. 

  706. 		above. </p>

    707. 

  707. 		<p class="Step">For example, consider the following alternatives for the statement clr.AddReference(&quot;System.Xml&quot;) above:</p>

    708. 

  708. 		</li>

    709. 

  709. 	</ol>

    710. 

  710. 	<p class="TypedExample">clr.AddReferenceByName(&#39;System.Xml, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089&#39;)</p>

    711. 

  711. 	<p class="Code-Background"></p>

    712. 

  712. 	<p class="TypedExample">clr.AddReferenceByPartialName(&quot;System.Xml&quot;)</p>

    713. 

  713. 	<p class="Code-Background"></p>

    714. 

  714. 	<ol start="4">

    715. 

  715. 		<li>

    716. 

  716. 		<p class="Step">Load the XML file &quot;load.xml&quot; into the XmlDocument. The

    717. 

  717. 		xml file contains sample savegame data from the IronPython sample &quot;Puzzle&quot; .

    718. 

  718. 		For direct viewing, the load.xml file is located in the Tutorial folder</p>

    719. 

  719. 		</li>

    720. 

  720. 	</ol>

    721. 

  721. 	<p class="TypedExample">d = XmlDocument()</p>

    722. 

  722. 	<p class="Code-Background"></p>

    723. 

  723. 	<p class="TypedExample">d.Load(&quot;load.xml&quot;)</p>

    724. 

  724. 	<p class="Code-Background"></p>

    725. 

  725. 	<ol start="5">

    726. 

  726. 		<li>

    727. 

  727. 		<p class="Step">We can now query the document. Query for all the saved games using the query below:</p>

    728. 

  728. 		</li>

    729. 

  729. 	</ol>

    730. 

  730. 	<p class="TypedExample">n = d.SelectNodes(&quot;//Puzzle/SavedGames/Game/@caption&quot;)</p>

    731. 

  731. 	<p class="TypedExample">for e in n: print e.Value</p>

    732. 

  732. 	<p class="Stepnonumbering">&nbsp;</p>

    733. 

  733. 	<p class="Stepnonumbering">The output in the console window will be:</p>

    734. 

  734. 	<p class="Code-Highlighted">&gt;&gt;&gt; n = d.SelectNodes(&quot;//Puzzle/SavedGames/Game/@caption&quot;)<br />

    735. 

  735. 	&gt;&gt;&gt; for e in n: print e.Value<br>...</p>

    736. 

  736. 	<p class="Code-Background">

    737. 

  737. 	Seattle (default game)<br />

    738. 

  738. 	New York<br />

    739. 

  739. 	World<br />

    740. 

  740. 	North America<br />

    741. 

  741. 	</p>

    742. 

  742. 	<ol start="6">

    743. 

  743. 		<li>

    744. 

  744. 		<p class="Step">(Optional) Import the &quot;xmlutil.py&quot; module located in the

    745. 

  745. 		Tutorial directory and use the function provided in the module to walk the

    746. 

  746. 		contents of the Xml document:</p>

    747. 

  747. 		</li>

    748. 

  748. 	</ol>

    749. 

  749. 	<p class="TypedExample">import xmlutil</p>

    750. 

  750. 	<p class="TypedExample">for e in xmlutil.Walk(d): print e.Name, e.Value</p>

    751. 

  751. 	<p class="HiddenOutput">#document None

    752. 

  752. #comment  *************************************************************************

    753. 

  753.  *

    754. 

  754.  * Copyright (c) Microsoft Corporation.&nbsp;

    755. 

  755.  *

    756. 

  756.  * This source code is subject to terms and conditions of the Microsoft Public License. A&nbsp;

    757. 

  757.  * copy of the license can be found in the License.html file at the root of this distribution. If&nbsp;

    758. 

  758.  * you cannot locate the  Microsoft Public License, please send an email to&nbsp;

    759. 

  759.  * ironpy@microsoft.com. By using this source code in any fashion, you are agreeing to be bound&nbsp;

    760. 

  760.  * by the terms of the Microsoft Public License.

    761. 

  761.  *

    762. 

  762.  * You must not remove this notice, or any other, from this software.

    763. 

  763.  *

    764. 

  764.  *

    765. 

  765.  * ***************************************************************************&nbsp;

    766. 

  766. Puzzle None

    767. 

  767. SavedGames None

    768. 

  768. Game None

    769. 

  769. caption Seattle (default game)

    770. 

  770. type a

    771. 

  771. y 714

    772. 

  772. x 327

    773. 

  773. level 11

    774. 

  774. dimension 3

    775. 

  775. Game None

    776. 

  776. caption New York

    777. 

  777. type r

    778. 

  778. y 1538

    779. 

  779. x 1205

    780. 

  780. level 12

    781. 

  781. dimension 3

    782. 

  782. Game None

    783. 

  783. caption World

    784. 

  784. type h

    785. 

  785. y 0

    786. 

  786. x 0

    787. 

  787. level 2

    788. 

  788. dimension 4

    789. 

  789. Game None

    790. 

  790. caption North America

    791. 

  791. type a

    792. 

  792. x 2

    793. 

  793. y 5

    794. 

  794. level 4

    795. 

  795. dimension 3

    796. 

  796. TopLeftPreviewTile None

    797. 

  797. x -3

    798. 

  798. y -3

    799. 

  799. dimension 3

    800. 

  800. level 5

    801. 

  801. Cache None

    802. 

  802. allow true</p>

    803. 

  803. 	<p class="Stepnonumbering">The Walk function is a generator (a Python function

    804. 

  804. 	that contains a &quot;yield&quot; statement). As the Walk function executes, it returns

    805. 

  805. 	(yields) the XML nodes one by one to the caller who iterates over the generator.

    806. 

  806. 	The source for the Walk function is:</p>

    807. 

  807. 	<p class="CodeSample">def Walk(xml):</br>

    808. 

  808. 	&nbsp;&nbsp;&nbsp; yield xml</br><br>

    809. 

  809. 	&nbsp;&nbsp;&nbsp; if hasattr(xml, &quot;Attributes&quot;):<br />

    810. 

  810. &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; attrs = xml.Attributes<br />

    811. 

  811. &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; if attrs:<br />

    812. 

  812. &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; for attr in attrs:</br>

    813. 

  813. 	&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;

    814. 

  814. 	yield attr</br><br>

    815. 

  815. 	&nbsp;&nbsp;&nbsp; for child in xml:<br />

    816. 

  816. &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; for c in Walk(child):</br>

    817. 

  817. 	&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;

    818. 

  818. 	yield c</p>

    819. 

  819. 	<ol start="7">

    820. 

  820. 		<li>

    821. 

  821. 		<p class="Step">Exit the IronPython Interactive console (Ctrl+Z or F6 followed

    822. 

  822. 		by Enter)</p>

    823. 

  823. 		</li>

    824. 

  824. 	</ol>

    825. 

  825. 	<h3><a name="T1.3.2">Task 2: Mapack - Loading the .NET libraries - AddReferenceToFile</a></h3>

    826. 

  826. 	<p class="Normal">This task requires the Mapack.dll library for linear algebra computations.&nbsp;

    827. 

  827. 	The library is not part of the IronPython distribution. See <a href="#Mapack">prerequisites</a>

    828. 

  828. 	for download details.</p>

    829. 

  829. 	<ol>

    830. 

  830. 		<li>

    831. 

  831. 		<p class="Step">Start the IronPython console from the tutorial directory

    832. 

  832. 		(see <a href="#Intro">Introduction</a> for details).</p>

    833. 

  833. 		</li>

    834. 

  834. 		<li>

    835. 

  835. 		<p class="Step">Use the clr.AddReferenceToFile function to load the Matrix

    836. 

  836. 		library &quot;Mapack.dll&quot;:</p>

    837. 

  837. 		</li>

    838. 

  838. 	</ol>

    839. 

  839. 	<p class="TypedExample">import clr</p>

    840. 

  840. 	<p class="Code-Background"></p>

    841. 

  841. 	<p class="TypedExample">clr.AddReferenceToFile(&quot;Mapack.dll&quot;)</p>

    842. 

  842. 	<p class="Code-Background"></p>

    843. 

  843. 	<p class="TypedExample">from Mapack import *</p>

    844. 

  844. 	<p class="Code-Background"></p>

    845. 

  845. 	<p class="TypedExample">dir()</p>

    846. 

  846. 	<p class="Stepnonumbering">The expected output will be:</p>

    847. 

  847. 	<p class="Code-Highlighted">&gt;&gt;&gt; import clr<br />

    848. 

  848. 	&gt;&gt;&gt; clr.AddReferenceToFile(&quot;Mapack.dll&quot;)<br />

    849. 

  849. 	&gt;&gt;&gt; from Mapack import *<br />

    850. 

  850. 	&gt;&gt;&gt; dir()</p>

    851. 

  851. 	<p class="Code-Background">['CholeskyDecomposition', 'EigenvalueDecomposition', 'LuDecomposition', 'Matrix', 'QrDecomposition', 'SingularValueDecomposition', '__builtins__', '__doc__', '__name__', 'clr']</p>

    852. 

  852. 	<ol start="3">

    853. 

  853. 		<li>

    854. 

  854. 		<p class="Step">Create instance of Matrix class:</p>

    855. 

  855. 		</li>

    856. 

  856. 	</ol>

    857. 

  857. 	<p class="ExceptionExample">m = Matrix()</p>

    858. 

  858. 	<p class="Code-Background"></p>

    859. 

  859. 	<p class="Stepnonumbering">Oops, bad arguments for the constructor.&nbsp; In the next

    860. 

  860. 	step you&#39;ll learn the way to discover the constructors available.</p>

    861. 

  861. 	<p class="Code-Highlighted">Traceback (most recent call last):

    862. 

  862. 		<br>

    863. 

  863. 	  File , line unknown, in Initialize##30

    864. 

  864. 		<br>

    865. 

  865. 	TypeError: Matrix() takes at least 1 argument (0 given)</p>

    866. 

  866. 	<ol start="4">

    867. 

  867. 		<li>

    868. 

  868. 		<p class="Step">Using the __doc__ attribute, find out information about

    869. 

  869. 		Matrix constructors:</p>

    870. 

  870. 		</li>

    871. 

  871. 	</ol>

    872. 

  872. 	<p class="TypedExample">print Matrix.__new__.__doc__</p>

    873. 

  873. 	<p class="Code-Highlighted">&gt;&gt;&gt; print Matrix.__new__.__doc__</p>

    874. 

  874. 	<p class="Code-Background">__new__(cls, int rows, int columns)<br />

    875. 

  875. 	__new__(cls, int rows, int columns, float value)<br />

    876. 

  876. 	__new__(cls, Array[Array[float]] value)

    877. 

  877. 	</p>

    878. 

  878. 	<ol start="5">

    879. 

  879. 		<li>

    880. 

  880. 		<p class="Step">Create instances of the Matrix class using the correct constructors

    881. 

  881. 		and set some matrix elements manually.&nbsp; IronPython supports custom indexing

    882. 

  882. 		on .NET classes. </p>

    883. 

  883. 		</li>

    884. 

  884. 	</ol>

    885. 

  885. 	<p class="TypedExample">m = Matrix(2, 2, 1.2)</p>

    886. 

  886. 	<p class="Code-Background"></p>

    887. 

  887. 	<p class="TypedExample">n = Matrix(2,1)</p>

    888. 

  888. 	<p class="Code-Background"></p>

    889. 

  889. 	<p class="TypedExample">n[0,0] = 4</p>

    890. 

  890. 	<p class="Code-Background"></p>

    891. 

  891. 	<p class="TypedExample">print m</p>

    892. 

  892. 	<p class="TypedExample">print n</p>

    893. 

  893. 	<p class="Code-Highlighted">&gt;&gt;&gt; m = Matrix(2, 2, 1.2)<br />

    894. 

  894. 	&gt;&gt;&gt; n = Matrix(2,1)<br />

    895. 

  895. 	&gt;&gt;&gt; n[0,0] = 4<br />

    896. 

  896. 	&gt;&gt;&gt; print m</p>

    897. 

  897. 	<p class="Code-Background">1.2 0 <br />

    898. 

  898. 	0 1.2&nbsp;

    899. 

  899. 	</p>

    900. 

  900. 	<p class="Code-Highlighted">&gt;&gt;&gt; print n</p>

    901. 

  901. 	<p class="Code-Background">4 <br />

    902. 

  902. 	0&nbsp;

    903. 

  903. 	</p>

    904. 

  904. 	<ol start="6">

    905. 

  905. 		<li>

    906. 

  906. 		<p class="Step">(Optional) IronPython also supports overloaded operators.&nbsp; Matrix does overload operators +, - (binary and unary) and *.&nbsp; You can see

    907. 

  907. 		Python representation of the operators (__add__, __mul__, __sub__, ...)

    908. 

  908. 		using dir():</p>

    909. 

  909. 		</li>

    910. 

  910. 	</ol>

    911. 

  911. 	<p class="UserCode">dir(m)</p>

    912. 

  912. 	<p class="HiddenCode">set1 = set(dir(m))

    913. 

  913. set2 = set(dir(object))

    914. 

  914. list(set1-set2)</p>

    915. 

  915. 	<p class="HiddenOutput">

    916. 

  916. 

    917. 

  917.         ['Submatrix','Symmetric','Clone','__sub__','Columns','Trace','__ne__','InfinityNorm','Rows','__setitem__','Multiply','__neg__','Diagonal','Random','Subtract','Item','Square','FrobeniusNorm','Solve','__rmul__','Negate','Add','Inverse','__radd__','__rsub__','__mul__','Determinant','__add__','__eq__','__getitem__','Norm1','Transpose']</p>

    918. 

  918. 	<ol start="7">

    919. 

  919. 		<li>

    920. 

  920. 		<p class="Step">Make simple calculations with the matrices:</p>

    921. 

  921. 		</li>

    922. 

  922. 	</ol>

    923. 

  923. 	<p class="TypedExample">m * n</p>

    924. 

  924. 	<p class="TypedExample">n.Transpose() * m</p>

    925. 

  925. 	<p class="TypedExample">m * 3</p>

    926. 

  926. 	<p class="TypedExample">n + -n</p>

    927. 

  927. 	<p class="Stepnonumbering">The expected output of this step is:</p>

    928. 

  928. 	<p class="Code-Highlighted">&gt;&gt;&gt; m * n</p>

    929. 

  929. 	<p class="LooseVerify">Mapack.Matrix</p>

    930. 

  930. 	<p class="Code-Highlighted">&gt;&gt;&gt; n.Transpose() * m</p>

    931. 

  931. 	<p class="LooseVerify">Mapack.Matrix</p>

    932. 

  932. 	<p class="Code-Highlighted">&gt;&gt;&gt; m * 3</p>

    933. 

  933. 	<p class="LooseVerify">Mapack.Matrix</p>

    934. 

  934. 	<p class="Code-Highlighted">&gt;&gt;&gt; n + -n</p>

    935. 

  935. 	<p class="LooseVerify">Mapack.Matrix</p>

    936. 

  936. 	<p class="ExceptionOutput">TypeError: Matrix() takes at least 1 argument (0 given)</p>

    937. 

  937. 	<ol start="8">

    938. 

  938. 		<li>

    939. 

  939. 		<p class="Step">Exit the IronPython Interactive console (Ctrl+Z or F6 followed

    940. 

  940. 		by Enter)</p>

    941. 

  941. 		</li>

    942. 

  942. 	</ol>

    943. 

  943. 	<h2><a name="T1.4">Exercise 4: Obtaining and Using Python Standard Library</a></h2>

    944. 

  944. 	<p class="Body">In this exercise, you will obtain Python and point

    945. 

  945. 	IronPython at the Python standard library. If you installed IronPython from the MSI installer, 

    946. 

  946. 	the Python standard library is installed by default and you can skip this exercise.</p>

    947. 

  947. 	<h3><a name="T1.4.1">Task 1: Configuring IronPython to use the Python standard library</a></h3>

    948. 

  948. 	<ol>

    949. 

  949. 		<li>

    950. 

  950. 		<p class="Step">Download the latest Python installer from

    951. 

  951. 		<a href="http://www.python.org/download/">http://www.python.org/download/</a>

    952. 

  952. 		and install Python.&nbsp; The rest of this exercise will assume you used

    953. 

  953. 		defaults (and installed to c:\python25, for example).</p>

    954. 

  954. 		</li>

    955. 

  955. 		<li>

    956. 

  956. 		<p class="Step">Create a file named &quot;site.py&quot; and place it into your

    957. 

  957. 		IronPython &quot;Lib&quot; directory.&nbsp; There might be one there

    958. 

  958. 		already, so you can just edit it.&nbsp; The &quot;site.py&quot; file is executed every time

    959. 

  959. 		you run IronPython.&nbsp; To tell IronPython where the Python standard library

    960. 

  960. 		is, you can add the &quot;lib&quot; directory of Python to IronPython's path.&nbsp; To

    961. 

  961. 		do so, put the following code into IronPython's &quot;site.py&quot; file (replace

    962. 

  962. 		c:\python25\lib with your actual path to the Python lib directory):</p>

    963. 

  963. 		</li>

    964. 

  964. 	</ol>

    965. 

  965. 	<p class="TypedExample">import sys</p>

    966. 

  966.     <p class="TypedExample">sys.path.append(r&quot;c:\python25\lib&quot;)</p>

    967. 

  967. 	<ol start="3">

    968. 

  968. 		<li>

    969. 

  969. 		<p class="Step">Start the IronPython console from the tutorial directory

    970. 

  970. 		(see <a href="#Intro">Introduction</a> for details).</p>

    971. 

  971. 		</li>

    972. 

  972. 		<li>

    973. 

  973. 		<p class="Step">Now you can use the Python standard library from

    974. 

  974. 		IronPython, for example to get the current working directory (output

    975. 

  975. 		uses assumed location of your IronPython installation):</p>

    976. 

  976. 		</li>

    977. 

  977. 	</ol>

    978. 

  978. 	<p class="TypedExample">import os</p>

    979. 

  979. 	<p class="Code-Background"></p>

    980. 

  980. 	<p class="TypedExample">os.getcwd()</p>

    981. 

  981. 	<p class="Code-Highlighted">'C:\\ironpython\\Tutorial'</p>

    982. 

  982. 	<p class="LooseVerify">

    983. 

  983. 

    984. 

  984. 	'%MERLIN_ROOT%\\Test\\IronPythonTutorial'</p>

    985. 

  985. 	<p class="LabSummary">Tutorial Summary</p>

    986. 

  986. 	<p class="Body">In this tutorial you performed the following exercises.</p>

    987. 

  987. 	<ul>

    988. 

  988. 		<li>

    989. 

  989. 		<p class="Body"><a href="#T1.1">The IronPython interactive console</a></p>

    990. 

  990. 		</li>

    991. 

  991. 		<li>

    992. 

  992. 		<p class="Body"><a href="#T1.2">Using the standard .NET libraries from IronPython</a></p>

    993. 

  993. 		</li>

    994. 

  994. 		<li>

    995. 

  995. 		<p class="Body"><a href="#T1.3">Loading .NET libraries</a></p>

    996. 

  996. 		</li>

    997. 

  997. 		<li>

    998. 

  998. 		<p class="Body"><a href="#T1.4">Obtaining and Using Python Standard

    999. 

  999. 		Library</a></p>

    1000. 

  1000. 		</li>

    1001. 

  1001. 	</ul>

    1002. 

  1002. 	<p class="Body">In this tutorial, you became acquainted with IronPython interactive

    1003. 

  1003. 	console, including the dynamic exploratory way of development using the dir() function

    1004. 

  1004. 	and __doc__ attribute to explore the environment.&nbsp; You learned to load and import

    1005. 

  1005. 	.NET libraries from IronPython (using the import statement), create instances

    1006. 

  1006. 	of .NET classes (including generic classes), call methods, enumerate .NET collections,

    1007. 

  1007. 	and even use overloaded operators on .NET objects.&nbsp; Finally, you

    1008. 

  1008. 	learned how to access standard Python libraries.</p>

    1009. 

  1009. 	<p class="Body">&nbsp;</p>

    1010. 

  1010. 	<h1><a name="T2">Tutorial 2: Advanced IronPython</a></h1>

    1011. 

  1011. 	<p class="Body">The large part of the beauty of IronPython lies within the dynamic-style

    1012. 

  1012. 	development -- modifying the live application by adding functioning elements

    1013. 

  1013. 	to it.&nbsp; With Windows applications, this often requires delegates and event handling

    1014. 

  1014. 	(i.e., adding a button to an existing form and adding functionality to the button

    1015. 

  1015. 	to handle the user pressing the button).</p>

    1016. 

  1016. 	<p class="Body">This tutorial will focus on creating delegates, handling

    1017. 

  1017. 	events in IronPython, and creating Windows applications using Windows Forms and

    1018. 

  1018. 	the new Windows Presentation Foundation (formerly known as Avalon).</p>

    1019. 

  1019. 	<p class="Body">Estimated time to complete this tutorial: <b>25 minutes</b></p>

    1020. 

  1020. 	<p class="Body">The objective of this tutorial is to learn how to create delegates

    1021. 

  1021. 	and handle events using IronPython, and to use that knowledge to build working Windows

    1022. 

  1022. 	applications using Windows Forms and Windows Presentation Foundation.</p>

    1023. 

  1023. 	<ul>

    1024. 

  1024. 		<li>

    1025. 

  1025. 		<p class="ExerciseList"><a href="#T2.1">Events and Delegates</a></p>

    1026. 

  1026. 		</li>

    1027. 

  1027. 		<li>

    1028. 

  1028. 		<p class="ExerciseList"><a href="#T2.2">Windows Forms</a></p>

    1029. 

  1029. 		</li>

    1030. 

  1030. 		<li>

    1031. 

  1031. 		<p class="ExerciseList"><a href="#T2.3">Windows Presentation Foundation

    1032. 

  1032. 		(Avalon)</a></p>

    1033. 

  1033. 		</li>

    1034. 

  1034. 	</ul>

    1035. 

  1035. 	<h2><a name="T2.1">Exercise 1: Events and Delegates</a></h2>

    1036. 

  1036. 	<p class="Body">In this exercise, you will create a simple event handler and

    1037. 

  1037. 	learn how to explore event handler use. The event handler we&#39;ll use in this

    1038. 

  1038. 	exercise is the FileSystemWatcher - a component that raises events on file system

    1039. 

  1039. 	changes.</p>

    1040. 

  1040. 	<h3><a name="T2.1.1">Task 1: File System Watcher</a></h3>

    1041. 

  1041. 	<ol>

    1042. 

  1042. 		<li>

    1043. 

  1043. 		<p class="Step">Start the IronPython console from the tutorial directory

    1044. 

  1044. 		(see <a href="#Intro">Introduction</a> for details).</p>

    1045. 

  1045. 		</li>

    1046. 

  1046. 		<li>

    1047. 

  1047. 		<p class="Step">Import the contents of System.IO into the global namespace:</p>

    1048. 

  1048. 		</li>

    1049. 

  1049. 	</ol>

    1050. 

  1050. 	<p class="TypedExample">from System.IO import *</p>

    1051. 

  1051. 	<p class="Code-Background"></p>

    1052. 

  1052. 	<ol start="3">

    1053. 

  1053. 		<li>

    1054. 

  1054. 		<p class="Step">Create instance of the FileSystemWatcher class and set Path

    1055. 

  1055. 		property to watch over the current directory:</p>

    1056. 

  1056. 		</li>

    1057. 

  1057. 	</ol>

    1058. 

  1058. 	<p class="TypedExample">w = FileSystemWatcher()</p>

    1059. 

  1059. 	<p class="Code-Background"></p>

    1060. 

  1060. 	<p class="UserCode">dir(w)</p>

    1061. 

  1061. 	<p class="HiddenCode">set1 = set(dir(w))

    1062. 

  1062. set2 = set(dir(object))

    1063. 

  1063. list(set1-set2)</p>

    1064. 

  1064. 	<p class="HiddenOutput">

    1065. 

  1065. 

    1066. 

  1066.     ['GetLifetimeService', 'EndInit', 'IncludeSubdirectories', 'Filter', 'WaitForChanged', 'Disposed', 'OnChanged', 'DesignMode', 'InitializeLifetimeService', 'NotifyFilter', 'GetService', 'Path', 'Created', 'EnableRaisingEvents', 'InternalBufferSize', 'SynchronizingObject', 'OnError', 'Site', 'BeginInit', 'Deleted', 'Error', 'Dispose', '__enter__', 'CanRaiseEvents', 'Events', 'Changed', '__exit__', 'Container', 'OnRenamed', 'Renamed', 'CreateObjRef', 'OnCreated', 'OnDeleted']</p>

    1067. 

  1067. 	<p class="TypedExample">w.Path = &quot;.&quot;</p>

    1068. 

  1068. 	<p class="Code-Background"></p>

    1069. 

  1069. 	<ol start="4">

    1070. 

  1070. 		<li>

    1071. 

  1071. 		<p class="Step" style="page-break-after:avoid">Create the function to handle

    1072. 

  1072. 		the events.&nbsp; Because we don&#39;t know yet what arguments the delegate will have,

    1073. 

  1073. 		let&#39;s accept any number of arguments (the *arg notation):</p>

    1074. 

  1074. 		</li>

    1075. 

  1075. 	</ol>

    1076. 

  1076. 	<p class="TypedExample">def handle(*args): print args</p>

    1077. 

  1077. 	<p class="Code-Background"></p>

    1078. 

  1078. 	<ol start="5">

    1079. 

  1079. 		<li>

    1080. 

  1080. 		<p class="Step">Register the event handler for the &#39;Changed&#39;, &#39;Created&#39;,

    1081. 

  1081. 		and &#39;Deleted&#39; events:</p>

    1082. 

  1082. 		</li>

    1083. 

  1083. 	</ol>

    1084. 

  1084. 	<p class="TypedExample">w.Changed += handle</p>

    1085. 

  1085. 	<p class="Code-Background"></p>

    1086. 

  1086. 	<p class="TypedExample">w.Created += handle</p>

    1087. 

  1087. 	<p class="Code-Background"></p>

    1088. 

  1088. 	<p class="TypedExample">w.Deleted += handle</p>

    1089. 

  1089. 	<p class="Code-Background"></p>

    1090. 

  1090. 	<ol start="6">

    1091. 

  1091. 		<li>

    1092. 

  1092. 		<p class="Step">Enable the watcher to raise events:</p>

    1093. 

  1093. 		</li>

    1094. 

  1094. 	</ol>

    1095. 

  1095. 	<p class="TypedExample">w.EnableRaisingEvents = True</p>

    1096. 

  1096. 	<ol start="7">

    1097. 

  1097. 		<li>

    1098. 

  1098. 		<p class="Step">Open the Tutorial folder and create a file.&nbsp; An easy way

    1099. 

  1099. 		to create the file is to right-click with the mouse and select &quot;New\Text

    1100. 

  1100. 		Document&quot;. The file watcher will raise the &quot;Created&quot; event.</p>

    1101. 

  1101. 		</li>

    1102. 

  1102. 	</ol>

    1103. 

  1103. 	<p class="Stepnonumbering">You can then open the file in Notepad, type in any

    1104. 

  1104. 	text, and save the file.&nbsp; This raises the &quot;Changed&quot; event.&nbsp;

    1105. 

  1105. 	Then finish by deleting

    1106. 

  1106. 	the file to see the &quot;Deleted&quot; event get raised.</p>

    1107. 

  1107. 	<p class="Stepnonumbering">At the end of this step, the output in the command

    1108. 

  1108. 	window will be similar to the following:</p>

    1109. 

  1109. 	<p class="Code-Highlighted">(System.IO.FileSystemWatcher, &lt;System.IO.FileSystemEventArgs object at 0x03CE0BB8&gt;)<br />

    1110. 

  1110. 	(System.IO.FileSystemWatcher, &lt;System.IO.FileSystemEventArgs object at 0x039B3B4D&gt;)<br />

    1111. 

  1111. 	(System.IO.FileSystemWatcher, &lt;System.IO.FileSystemEventArgs object at 0x039B3B4D&gt;)<br />

    1112. 

  1112. 	(System.IO.FileSystemWatcher, &lt;System.IO.FileSystemEventArgs object at 0x014EF022&gt;)</p>

    1113. 

  1113. 	<ol start="8">

    1114. 

  1114. 		<li>

    1115. 

  1115. 		<p class="Step">In the next task, we will create an improved event handler.&nbsp; For now, remove the current event handler from the file watcher events:</p>

    1116. 

  1116. 		</li>

    1117. 

  1117. 	</ol>

    1118. 

  1118. 	<p class="TypedExample">w.Changed -= handle</p>

    1119. 

  1119. 	<p class="Code-Background"></p>

    1120. 

  1120. 	<p class="TypedExample">w.Created -= handle</p>

    1121. 

  1121. 	<p class="Code-Background"></p>

    1122. 

  1122. 	<p class="TypedExample">w.Deleted -= handle</p>

    1123. 

  1123. 	<p class="Code-Background">

    1124. 

  1124. 	</p>

    1125. 

  1125. 	<ol start="9">

    1126. 

  1126. 		<li>

    1127. 

  1127. 		<p class="Step">(Optional) You can try step 7 again to see that the events,

    1128. 

  1128. 		while they are still being raised, are not being handled by the Python &quot;handler&quot;

    1129. 

  1129. 		function.</p>

    1130. 

  1130. 		</li>

    1131. 

  1131. 	</ol>

    1132. 

  1132. 	<h3><a name="T2.1.2">Task 2: Improving the event handler</a></h3>

    1133. 

  1133. 	<ol>

    1134. 

  1134. 		<li>

    1135. 

  1135. 		<p class="Step">In the previous task, step 7 we can see that the types of

    1136. 

  1136. 		the parameters passed to all three events were the same:</p>

    1137. 

  1137. 		</li>

    1138. 

  1138. 	</ol>

    1139. 

  1139. 	<p class="Stepnonumbering">FileSystemWatcher - the instance of the object that

    1140. 

  1140. 	raised the event</p>

    1141. 

  1141. 	<p class="Stepnonumbering">FileSystemEventArgs - the information about the event

    1142. 

  1142. 	raised</p>

    1143. 

  1143. 	<p class="Stepnonumbering">Use dir() to explore the event arguments class to

    1144. 

  1144. 	find what information the event contains:</p>

    1145. 

  1145. 	<p class="TypedExample">from System.IO import *</p>

    1146. 

  1146. 	<p class="Code-Background"></p>

    1147. 

  1147. 	<p class="TypedExample">w = FileSystemWatcher()</p>

    1148. 

  1148. 	<p class="Code-Background"></p>

    1149. 

  1149. 	<p class="TypedExample">w.Path = &quot;.&quot;</p>

    1150. 

  1150. 	<p class="Code-Background"></p>

    1151. 

  1151. 	<p class="UserCode">dir(FileSystemEventArgs)</p>

    1152. 

  1152. 	<p class="HiddenCode">set1 = set(dir(FileSystemEventArgs))

    1153. 

  1153. set2 = set(dir(object))

    1154. 

  1154. list(set1-set2)</p>

    1155. 

  1155. 	<p class="Stepnonumbering" style="page-break-after:avoid">The output in the

    1156. 

  1156. 	console window will be:</p>

    1157. 

  1157. 	<p class="Code-Highlighted" style="page-break-after:avoid">&gt;&gt;&gt; dir(FileSystemEventArgs)</p>

    1158. 

  1158. 	<p class="Code-Highlighted">['ChangeType', 'Empty', 'Equals', 'FullPath', 'GetHashCode', 'GetType', 'MemberwiseClone', 'Name', 'ReferenceEquals', 'ToString', '__class__', '__delattr__', '__doc__', '__getattribute__', '__hash__', '__init__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__setattr__', '__str__']</p>

    1159. 

  1159. 	<p class="HiddenOutput">

    1160. 

  1160. 

    1161. 

  1161. 	['FullPath', 'Name', 'Empty', 'ChangeType']</p>

    1162. 

  1162. 	<ol start="2">

    1163. 

  1163. 		<li>

    1164. 

  1164. 		<p class="Step">Now with more knowledge of the event argument properties,

    1165. 

  1165. 		we can create a better event handler that will print ChangeType and FullPath

    1166. 

  1166. 		properties of the event argument object:</p>

    1167. 

  1167. 		</li>

    1168. 

  1168. 	</ol>

    1169. 

  1169. 	<p class="TypedExample">def handle(w, a): print a.ChangeType, a.FullPath</p>

    1170. 

  1170. 	<ol start="3">

    1171. 

  1171. 		<li>

    1172. 

  1172. 		<p class="Step">Register the new event handler for the &#39;Changed&#39;, &#39;Created&#39;

    1173. 

  1173. 		and &#39;Deleted&#39; events:</p>

    1174. 

  1174. 		</li>

    1175. 

  1175. 	</ol>

    1176. 

  1176. 	<p class="TypedExample">w.Changed += handle</p>

    1177. 

  1177. 	<p class="Code-Background"></p>

    1178. 

  1178. 	<p class="TypedExample">w.Created += handle</p>

    1179. 

  1179. 	<p class="Code-Background"></p>

    1180. 

  1180. 	<p class="TypedExample">w.Deleted += handle</p>

    1181. 

  1181. 	<p class="Code-Background">

    1182. 

  1182. 

    1183. 

  1183. 	</p>

    1184. 

  1184. 	<ol start="4">

    1185. 

  1185. 		<li>

    1186. 

  1186. 		<p class="Step">Make sure the raising of the events is enabled:</p>

    1187. 

  1187. 		</li>

    1188. 

  1188. 	</ol>

    1189. 

  1189. 	<p class="TypedExample">w.EnableRaisingEvents = True</p>

    1190. 

  1190. 	<ol start="5">

    1191. 

  1191. 		<li>

    1192. 

  1192. 		<p class="Step">Open the Tutorial folder again and create a new file (&quot;Created&quot;

    1193. 

  1193. 		event), edit the file in Notepad and save it (&quot;Changed&quot; event) and finish

    1194. 

  1194. 		by deleting the file (&quot;Deleted&quot; event).</p>

    1195. 

  1195. 		</li>

    1196. 

  1196. 	</ol>

    1197. 

  1197. 	<p class="Stepnonumbering">At the end of this step, the output in the command

    1198. 

  1198. 	window will be similar to the following:</p>

    1199. 

  1199. 	<p class="Code-Highlighted">Created .\New Text Document.txt<br />

    1200. 

  1200. 	Changed .\New Text Document.txt<br />

    1201. 

  1201. 	Changed .\New Text Document.txt<br />

    1202. 

  1202. 	Deleted .\New Text Document.txt</p>

    1203. 

  1203. 	<ol start="6">

    1204. 

  1204. 		<li>

    1205. 

  1205. 		<p class="Step">Remove the event handler from the file watcher events:</p>

    1206. 

  1206. 		</li>

    1207. 

  1207. 	</ol>

    1208. 

  1208. 	<p class="TypedExample">w.Changed -= handle</p>

    1209. 

  1209. 	<p class="Code-Background"></p>

    1210. 

  1210. 	<p class="TypedExample">w.Created -= handle</p>

    1211. 

  1211. 	<p class="Code-Background"></p>

    1212. 

  1212. 	<p class="TypedExample">w.Deleted -= handle</p>

    1213. 

  1213. 	<p class="Code-Background"></p>

    1214. 

  1214. 	<ol start="7">

    1215. 

  1215. 		<li>

    1216. 

  1216. 		<p class="Step">Exit the IronPython Interactive console (Ctrl+Z or F6, followed

    1217. 

  1217. 		by Enter).</p>

    1218. 

  1218. 		</li>

    1219. 

  1219. 	</ol>

    1220. 

  1220. 

    1221. 

  1221. 		<h3><a name="T2.1.3">Task 3: Defining events in Python</a></h3>

    1222. 

  1222. 	<ol>

    1223. 

  1223. 		<li>

    1224. 

  1224. 		<p class="Step">Finally let's look at how we can get event handler syntax from Python code:</p>

    1225. 

  1225. 		</li>

    1226. 

  1226. 	</ol>

    1227. 

  1227. 	<p class="Stepnonumbering">pyevent - a module providing Python event support</p>

    1228. 

  1228. 	<p class="Stepnonumbering">make_event - a function that returns an event tuple containing both the callable object and the object

    1229. 

  1229. 	that allows connecting and unconnecting to the event.</p>

    1230. 

  1230. 	<br/>

    1231. 

  1231. 	<p class="Stepnonumbering" style="page-break-after:avoid">To create an event:</p>

    1232. 

  1232. 	<br/>

    1233. 

  1233. 	<p class="TypedExample">import pyevent</p>

    1234. 

  1234. 	<p class="TypedExample">hook,caller = pyevent.make_event()</p>

    1235. 

  1235. 	<br/>

    1236. 

  1236. 	<p class="Stepnonumbering">This has returned back to us two objects.  The first object allows a user to hook a

    1237. 

  1237. 		function up to the event.  The second object allows the owner of the event to cause the event to be raised.

    1238. 

  1238. 		This allows for the separation of these abilities just like .NET.&nbsp; Now let's take this and put it into a class and

    1239. 

  1239. 		see how it gets used.</p>

    1240. 

  1240. 

    1241. 

  1241. 	<ol start="2">

    1242. 

  1242. 		<li>

    1243. 

  1243. 		<p class="Step">We'll define a class that has an event for</p>

    1244. 

  1244. 		</li>

    1245. 

  1245. 	</ol>

    1246. 

  1246. 

    1247. 

  1247. 	<p class="TypedExample">class MyClass(object):<br>

    1248. 

  1248. 	&nbsp;&nbsp;&nbsp;&nbsp;OnNewInstance,_NewInstance= pyevent.make_event()<br>

    1249. 

  1249. 	&nbsp;&nbsp;&nbsp;&nbsp;def __new__(cls):<br>

    1250. 

  1250. 	&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;res = object.__new__(object)<br>

    1251. 

  1251. 	&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;MyClass._NewInstance(res)<br>

    1252. 

  1252. 	</p>

    1253. 

  1253. 	<p class="Code-Background"></p>

    1254. 

  1254. 	<p class="Code-Background"></p>

    1255. 

  1255. 	<p class="Code-Background"></p>

    1256. 

  1256. 	<p class="TypedExample">def NewInst(x): print 'new inst: ', x </p>

    1257. 

  1257. 	<p class="Code-Background"></p>

    1258. 

  1258. 	<p class="TypedExample">MyClass.OnNewInstance += NewInst</p>

    1259. 

  1259. 	<p class="Code-Background"></p>

    1260. 

  1260. 	<p class="TypedExample">a = MyClass()</p>

    1261. 

  1261. 	<p class="LooseVerify">new inst</p>

    1262. 

  1262. 

    1263. 

  1263. 	<ol start="3">

    1264. 

  1264. 		<li>

    1265. 

  1265. 		<p class="Step">Just like with CLR events you can also remove event handlers:</p>

    1266. 

  1266. 		</li>

    1267. 

  1267. 	</ol>

    1268. 

  1268. 	<p class="TypedExample">MyClass.OnNewInstance -= NewInst</p>

    1269. 

  1269. 	<p class="Code-Background"></p>

    1270. 

  1270. 

    1271. 

  1271. 	<h2><a name="T2.2">Exercise 2: Windows Forms</a></h2>

    1272. 

  1272. 	<p class="Body">To interactively develop Windows applications, IronPython must

    1273. 

  1273. 	be initialized for that purpose.&nbsp; By default, the Python console executes on one thread only.&nbsp; While this thread awaits text input in the console window, the Windows application

    1274. 

  1274. 	being dynamically created from the console is not able to process Windows messages.&nbsp;

    1275. 

  1275. 	Therefore, the application does not repaint itself or handle input to the UI.</p>

    1276. 

  1276. 	<p class="Body">We provide a .py file to initialize IronPython for Windows Forms

    1277. 

  1277. 	development, see tasks below.</p>

    1278. 

  1278. 	<p class="Body">In this exercise, you will create simple Windows Forms applications

    1279. 

  1279. 	dynamically from the IronPython interactive console.</p>

    1280. 

  1280. 	<h3><a name="T2.2.1">Task 1: Simple Windows Forms application</a></h3>

    1281. 

  1281. 	<ol>

    1282. 

  1282. 		<li>

    1283. 

  1283. 		<p class="Step">Start the IronPython console from the tutorial directory

    1284. 

  1284. 		(see <a href="#Intro">Introduction</a> for details).</p>

    1285. 

  1285. 		</li>

    1286. 

  1286. 		<li>

    1287. 

  1287. 		<p class="Step">Initialize Windows Forms by loading the winforms module/script:</p>

    1288. 

  1288. 		</li>

    1289. 

  1289. 	</ol>

    1290. 

  1290. 	<p class="TypedExample">import winforms</p>

    1291. 

  1291. 	<p class="Code-Background"></p>

    1292. 

  1292. 	<p class="Stepnonumbering">Python modules get automatically initialized

    1293. 

  1293. 	(executed) upon import so the Windows Forms initialization code has executed

    1294. 

  1294. 	as part of the import statement.</p>

    1295. 

  1295. 	<ol start="3">

    1296. 

  1296. 		<li>

    1297. 

  1297. 		<p class="Step">Import the contents of the System.Windows.Forms and System.Drawing

    1298. 

  1298. 		namespaces into the global namespace: </p>

    1299. 

  1299. 		</li>

    1300. 

  1300. 	</ol>

    1301. 

  1301. 	<p class="TypedExample">from System.Windows.Forms import *</p>

    1302. 

  1302. 	<p class="Code-Background"></p>

    1303. 

  1303. 	<p class="TypedExample">from System.Drawing import *</p>

    1304. 

  1304. 	<p class="Code-Background"></p>

    1305. 

  1305. 	<ol start="4">

    1306. 

  1306. 		<li>

    1307. 

  1307. 		<p class="Step">Create an instance of the Form class and display it:</p>

    1308. 

  1308. 		</li>

    1309. 

  1309. 	</ol>

    1310. 

  1310. 	<p class="TypedExample">f = Form()</p>

    1311. 

  1311. 	<p class="Code-Background"></p>

    1312. 

  1312. 	<p class="TypedExample">f.Show()</p>

    1313. 

  1313. 	<p class="Code-Background"></p>

    1314. 

  1314. 	<p class="Stepnonumbering">You may need to alt-tab or look for the running

    1315. 

  1315. 	application since it may not have popped to the top level on your desktop.</p>

    1316. 

  1316. 	<ol start="5">

    1317. 

  1317. 		<li>

    1318. 

  1318. 		<p class="Step">Now set the form Text property:</p>

    1319. 

  1319. 		</li>

    1320. 

  1320. 	</ol>

    1321. 

  1321. 	<p class="TypedExample">f.Text = &quot;My First Interactive Application&quot;</p>

    1322. 

  1322. 	<p class="Code-Background"></p>

    1323. 

  1323. 	<ol start="6">

    1324. 

  1324. 		<li>

    1325. 

  1325. 		<p class="Step">To bring the application alive, let&#39;s focus on the Click

    1326. 

  1326. 		event of the form. Create an event handler for the Click event and click

    1327. 

  1327. 		on the form to receive the event. Then remove the event handler</p>

    1328. 

  1328. 		</li>

    1329. 

  1329. 	</ol>

    1330. 

  1330. 	<p class="TypedExample">def click(*args): print args</p>

    1331. 

  1331. 	<p class="Code-Background"></p>

    1332. 

  1332. 	<p class="TypedExample">f.Click += click</p>

    1333. 

  1333. 	<p class="Code-Background"></p>

    1334. 

  1334. 	<p class="Stepnonumbering">Click on the form to receive the event..</p>

    1335. 

  1335. 	<p class="Stepnonumbering">The output will be similar to:</p>

    1336. 

  1336. 	<p class="Code-Highlighted">&gt;&gt;&gt; (System.Windows.Forms.Form, Text: My First Interactive

    1337. 

  1337. 	Application, &lt;System.Windows.Forms.MouseEventArgs object at 0x02324551&gt;)</p>

    1338. 

  1338. 	<p class="Stepnonumbering">Now remove the click handler because we're going

    1339. 

  1339. 	to further develop it.</p>

    1340. 

  1340. 	<p class="TypedExample">f.Click -= click</p>

    1341. 

  1341. 	<p class="Code-Background"></p>

    1342. 

  1342. 	<ol start="7">

    1343. 

  1343. 		<li>

    1344. 

  1344. 		<p class="Step">Use dir() function to explore the MouseEventArgs</p>

    1345. 

  1345. 		</li>

    1346. 

  1346. 	</ol>

    1347. 

  1347. 	<p class="UserCode">dir(MouseEventArgs)</p>

    1348. 

  1348. 	<p class="HiddenCode">set1 = set(dir(MouseEventArgs))

    1349. 

  1349. set2 = set(dir(object))

    1350. 

  1350. list(set1-set2)</p>

    1351. 

  1351. 	<p class="HiddenOutput">

    1352. 

  1352. 

    1353. 

  1353. 	['Location', 'Y', 'X', 'Button', 'Clicks', 'Empty', 'Delta']</p>

    1354. 

  1354. 	<ol start="8">

    1355. 

  1355. 		<li>

    1356. 

  1356. 		<p class="Step" style="page-break-after:avoid">Knowing the contents of the

    1357. 

  1357. 		MouseEventArgs, create an improved event handler for the Click event:</p>

    1358. 

  1358. 		</li>

    1359. 

  1359. 	</ol>

    1360. 

  1360. 	<p class="TypedExample" style="page-break-after:avoid">def click(f, a):<br>

    1361. 

  1361. &nbsp;&nbsp;&nbsp; l = Label(Text = &quot;Hello&quot;)<br>

    1362. 

  1362. &nbsp;&nbsp;&nbsp; l.Location = a.Location<br>

    1363. 

  1363. &nbsp;&nbsp;&nbsp; f.Controls.Add(l)</p>

    1364. 

  1364. <p class="Code-Background"></p>

    1365. 

  1365. 	<ol start="9">

    1366. 

  1366. 		<li>

    1367. 

  1367. 		<p class="Step" style="page-break-after:avoid">Register the event handler:</p>

    1368. 

  1368. 		</li>

    1369. 

  1369. 	</ol>

    1370. 

  1370. 	<p class="TypedExample">f.Click += click</p>

    1371. 

  1371. 	<p class="Code-Background"></p>

    1372. 

  1372. 	<ol start="10">

    1373. 

  1373. 		<li>

    1374. 

  1374. 		<p class="Step">Now clicking on the form with the mouse will add &quot;Hello&quot;

    1375. 

  1375. 		labels. We can also access the controls we just added via mouse clicks and

    1376. 

  1376. 		change them</p>

    1377. 

  1377. 		</li>

    1378. 

  1378. 	</ol>

    1379. 

  1379. 	<p class="TypedExample">for i in f.Controls: i.Font = Font(&quot;Verdana&quot;, 15)</p>

    1380. 

  1380. 	<p class="Code-Background"></p>

    1381. 

  1381. 	<p class="TypedExample">for i in f.Controls: i.Text = &quot;Hi&quot;</p>

    1382. 

  1382. 	<p class="Code-Background"></p>

    1383. 

  1383. 	<ol start="11">

    1384. 

  1384. 		<li>

    1385. 

  1385. 		<p class="Step">After a few moments of clicking, the form will get quite

    1386. 

  1386. 		crowded, so we can clear it out:</p>

    1387. 

  1387. 		</li>

    1388. 

  1388. 	</ol>

    1389. 

  1389. 	<p class="TypedExample">f.Controls.Clear()</p>

    1390. 

  1390. 	<p class="HiddenCode">f.Close()</p>

    1391. 

  1391. 	<p class="Code-Background"></p>

    1392. 

  1392. 	<ol start="12">

    1393. 

  1393. 		<li>

    1394. 

  1394. 		<p class="Step">Exit the IronPython Interactive console (Ctrl+Z or F6 followed

    1395. 

  1395. 		by Enter)</p>

    1396. 

  1396. 		</li>

    1397. 

  1397. 	</ol>

    1398. 

  1398. 	<p class="Body">The standalone version of this script is located in wfdemo.py

    1399. 

  1399. 	in the Tutorial directory.</p>

    1400. 

  1400. 	<h2><a name="T2.3">Exercise 3: Windows Presentation Foundation (Avalon)</a></h2>

    1401. 

  1401. 	<p class="Body">This exercise requires Windows Presentation Foundation installed.&nbsp; Please see <a href="#Avalon">prerequisites</a> for more information.</p>

    1402. 

  1402. 	<p class="Body">Just like Windows Forms, the Windows Presentation Foundation

    1403. 

  1403. 	also requires initialization to support interactive development. The initialization

    1404. 

  1404. 	code is available in the &quot;Tutorial\avalon.py&quot; file.</p>

    1405. 

  1405. 	<p class="Body">In this exercise, you will interactively create simple interactive

    1406. 

  1406. 	Windows Presentation Foundation application.</p>

    1407. 

  1407. 	<h3><a name="T2.3.1">Task 1: Simple Avalon Application</a></h3>

    1408. 

  1408. 	<ol>

    1409. 

  1409. 		<li>

    1410. 

  1410. 		<p class="Step">Start the IronPython console from the tutorial directory

    1411. 

  1411. 		(see <a href="#Intro">Introduction</a> for details).</p>

    1412. 

  1412. 		</li>

    1413. 

  1413. 		<li>

    1414. 

  1414. 		<p class="Step">Initialize Windows Presentation Foundation:</p>

    1415. 

  1415. 		</li>

    1416. 

  1416. 	</ol>

    1417. 

  1417. 	<p class="TypedExample">from avalon import *</p>

    1418. 

  1418. 	<p class="Code-Background"></p>

    1419. 

  1419. 	<ol start="3">

    1420. 

  1420. 		<li>

    1421. 

  1421. 		<p class="Step">Create Avalon window, display it, and set some of its properties:</p>

    1422. 

  1422. 		</li>

    1423. 

  1423. 	</ol>

    1424. 

  1424. 	<p class="TypedExample">w = Window()</p>

    1425. 

  1425. 	<p class="Code-Background"></p>

    1426. 

  1426. 	<p class="TypedExample">w.Show()</p>

    1427. 

  1427. 	<p class="Code-Background"></p>

    1428. 

  1428. 	<p class="Stepnonumbering">You may need to alt-tab or look for the running

    1429. 

  1429. 	application since it may not have popped to the top level on your desktop.&nbsp;

    1430. 

  1430. 	Now, let's do more.</p>

    1431. 

  1431. 	<p class="Code-Background"></p>

    1432. 

  1432. 	<p class="TypedExample">w.Title = &quot;My Avalon Application&quot;</p>

    1433. 

  1433. 	<p class="Code-Background"></p>

    1434. 

  1434. 	<p class="TypedExample">w.SizeToContent = SizeToContent.WidthAndHeight</p>

    1435. 

  1435. 	<p class="Code-Background"></p>

    1436. 

  1436. 	<p class="Stepnonumbering">By setting the window property to &quot;size to

    1437. 

  1437. 	content&quot;, the window shrinks.</p>

    1438. 

  1438. 	<ol start="4">

    1439. 

  1439. 		<li>

    1440. 

  1440. 		<p class="Step">Let&#39;s add the content now:</p>

    1441. 

  1441. 		</li>

    1442. 

  1442. 	</ol>

    1443. 

  1443. 	<p class="TypedExample">w.Content = TextBlock()</p>

    1444. 

  1444. 	<p class="Code-Background"></p>

    1445. 

  1445. 	<p class="TypedExample">w.Content.Text = &quot;Hello IronPython!&quot;</p>

    1446. 

  1446. 	<p class="Code-Background"></p>

    1447. 

  1447. 	<p class="TypedExample">w.Content.FontSize = 50</p>

    1448. 

  1448. 	<p class="Code-Background"></p>

    1449. 

  1449. 	<ol start="5">

    1450. 

  1450. 		<li>

    1451. 

  1451. 		<p class="Step">Remove the window content:</p>

    1452. 

  1452. 		</li>

    1453. 

  1453. 	</ol>

    1454. 

  1454. 	<p class="TypedExample">w.Content = None</p>

    1455. 

  1455. 	<h3><a name="T2.3.2">Task 2: Avalon calculator</a></h3>

    1456. 

  1456. 	<ol>

    1457. 

  1457. 		<li>

    1458. 

  1458. 		<p class="Step">If you are continuing from the Task 1, proceed to step 2.&nbsp; Otherwise, please follow the <a href="#T2.3.1">steps 1-3</a> from the Task

    1459. 

  1459. 		1. </p>

    1460. 

  1460. 		</li>

    1461. 

  1461. 		<li>

    1462. 

  1462. 		<p class="Step">Windows Presentation Foundation uses the XAML format to describe

    1463. 

  1463. 		the graphical layout and basic behaviors of UI. Load the &quot;calc.xaml&quot; and display the resulting content:</p>

    1464. 

  1464. 		</li>

    1465. 

  1465. 	</ol>

    1466. 

  1466. 		<p class="TypedExample">from avalon import *</p>

    1467. 

  1467. 		<p class="Code-Background"></p>

    1468. 

  1468. 		<p class="TypedExample">w = Window()</p>

    1469. 

  1469. 		<p class="Code-Background"></p>

    1470. 

  1470. 	<p class="TypedExample">w.Show()</p>

    1471. 

  1471. 	<p class="Code-Background"></p>

    1472. 

  1472. 	<p class="TypedExample">w.Content = LoadXaml(&quot;calc.xaml&quot;)</p>

    1473. 

  1473. 	<p class="Code-Background"></p>

    1474. 

  1474. 	<p class="Stepnonumbering">If you flowed into this task from Task 1, then

    1475. 

  1475. 	w.SizeToContent may have been reset to manual, but in either case, you may

    1476. 

  1476. 	need to manually drag the window's border down and to the right to see the

    1477. 

  1477. 	calculator UI.</p>

    1478. 

  1478. 	<ol start="3">

    1479. 

  1479. 		<li>

    1480. 

  1480. 		<p class="Step">Let's walk the calculator&#39;s object model (function

    1481. 

  1481. 		Walk is defined in the avalon.py file)</p>

    1482. 

  1482. 		</li>

    1483. 

  1483. 	</ol>

    1484. 

  1484. 	<p class="TypedExample">for n in Walk(w): print n</p>

    1485. 

  1485. 	<p class="HiddenOutput">System.Windows.Window</p>

    1486. 

  1486. <p class="LooseVerify">Canvas

    1487. 

  1487. Canvas

    1488. 

  1488. Rectangle

    1489. 

  1489. Canvas</p>

    1490. 

  1490. <p class="HiddenOutput">System.Windows.Controls.TextBox

    1491. 

  1491. System.Windows.Controls.RichTextBox

    1492. 

  1492. System.Windows.Controls.Button: 1

    1493. 

  1493. 1

    1494. 

  1494. System.Windows.Controls.Button: 9

    1495. 

  1495. 9

    1496. 

  1496. System.Windows.Controls.Button: 8

    1497. 

  1497. 8

    1498. 

  1498. System.Windows.Controls.Button: 5

    1499. 

  1499. 5

    1500. 

  1500. System.Windows.Controls.Button: 4

    1501. 

  1501. 4

    1502. 

  1502. System.Windows.Controls.Button: 2

    1503. 

  1503. 2

    1504. 

  1504. System.Windows.Controls.Button: 3

    1505. 

  1505. 3

    1506. 

  1506. System.Windows.Controls.Button: 6

    1507. 

  1507. 6

    1508. 

  1508. System.Windows.Controls.Button: *

    1509. 

  1509. *

    1510. 

  1510. System.Windows.Controls.Button: 7

    1511. 

  1511. 7

    1512. 

  1512. System.Windows.Controls.Button: -

    1513. 

  1513. -

    1514. 

  1514. System.Windows.Controls.Button: 0

    1515. 

  1515. 0

    1516. 

  1516. System.Windows.Controls.Button: .

    1517. 

  1517. .

    1518. 

  1518. System.Windows.Controls.Button: =

    1519. 

  1519. =

    1520. 

  1520. System.Windows.Controls.Button: +

    1521. 

  1521. +

    1522. 

  1522. System.Windows.Controls.Button: /

    1523. 

  1523. /

    1524. 

  1524. System.Windows.Controls.Button: C

    1525. 

  1525. C</p>

    1526. 

  1526. 	<ol start="4">

    1527. 

  1527. 		<li>

    1528. 

  1528. 		<p class="Step">Using Python&#39;s list comprehension syntax we can capture

    1529. 

  1529. 		all buttons in the calculator:</p>

    1530. 

  1530. 		</li>

    1531. 

  1531. 	</ol>

    1532. 

  1532. 	<p class="TypedExample">[ n for n in Walk(w) if isinstance(n, Button) ]</p>

    1533. 

  1533. 	<p class="LooseVerify">System.Windows.Controls.Button</p>

    1534. 

  1534. 	<p class="Stepnonumbering">The console printed the list of all buttons.&nbsp; To

    1535. 

  1535. 	save the button list object in a variable, use the interpreter's &quot;_&quot;

    1536. 

  1536. 	variable, which always holds the last non-None value result printed by the

    1537. 

  1537. 	console:</p>

    1538. 

  1538. 	<p class="TypedExample">buttons = _</p>

    1539. 

  1539. 	<p class="Code-Background"></p>

    1540. 

  1540. 	<ol start="5">

    1541. 

  1541. 		<li>

    1542. 

  1542. 		<p class="Step">At this point we can make changes to all the buttons, for

    1543. 

  1543. 		example, change the colors and fonts:</p>

    1544. 

  1544. 		</li>

    1545. 

  1545. 	</ol>

    1546. 

  1546. 	<p class="TypedExample">for b in buttons: b.FontSize *= 2</p>

    1547. 

  1547. 	<p class="Code-Background"></p>

    1548. 

  1548. 	<p class="TypedExample">for b in buttons: b.Foreground = SolidColorBrush(Colors.Blue)</p>

    1549. 

  1549. 	<p class="Code-Background"></p>

    1550. 

  1550. 	<ol start="6">

    1551. 

  1551. 		<li>

    1552. 

  1552. 		<p class="Step" style="page-break-after:avoid">To bring the calculator alive,

    1553. 

  1553. 		we need to provide event handlers for each button.&nbsp; These can be imported

    1554. 

  1554. 		from the calculator.py file:</p>

    1555. 

  1555. 		</li>

    1556. 

  1556. 	</ol>

    1557. 

  1557. 	<p class="TypedExample">import calculator</p>

    1558. 

  1558. 	<p class="Code-Background"></p>

    1559. 

  1559. 	<ol start="7">

    1560. 

  1560. 		<li>

    1561. 

  1561. 		<p class="Step">The calculator module contains the Calculator class that

    1562. 

  1562. 		will be responsible for tracking the expression as it is being built by

    1563. 

  1563. 		the calculator.&nbsp; To bring the calculator alive (that is, register event

    1564. 

  1564. 		handlers for the UI), enter:</p>

    1565. 

  1565. 		</li>

    1566. 

  1566. 	</ol>

    1567. 

  1567. 	<p class="TypedExample">calculator.enliven(w)</p>

    1568. 

  1568. 	<p class="HiddenOutput">Registering self.on_One to handle One.Click

    1569. 

  1569. Registering self.on_Nine to handle Nine.Click

    1570. 

  1570. Registering self.on_Eight to handle Eight.Click

    1571. 

  1571. Registering self.on_Five to handle Five.Click

    1572. 

  1572. Registering self.on_Four to handle Four.Click

    1573. 

  1573. Registering self.on_Two to handle Two.Click

    1574. 

  1574. Registering self.on_Three to handle Three.Click

    1575. 

  1575. Registering self.on_Six to handle Six.Click

    1576. 

  1576. Registering self.on_Multiply to handle Multiply.Click

    1577. 

  1577. Registering self.on_Seven to handle Seven.Click

    1578. 

  1578. Registering self.on_Subtract to handle Subtract.Click

    1579. 

  1579. Registering self.on_Zero to handle Zero.Click

    1580. 

  1580. Registering self.on_DecimalPoint to handle DecimalPoint.Click

    1581. 

  1581. Registering self.on_Equals to handle Equals.Click

    1582. 

  1582. Registering self.on_Plus to handle Plus.Click

    1583. 

  1583. Registering self.on_Divide to handle Divide.Click

    1584. 

  1584. Registering self.on_Clear to handle Clear.Click</p>

    1585. 

  1585. 	<ol start="8">

    1586. 

  1586. 		<li>

    1587. 

  1587. 		<p class="Step">At this point you can click on the calculator buttons and

    1588. 

  1588. 		evaluate expressions.</p>

    1589. 

  1589. 		</li>

    1590. 

  1590. 		<li>

    1591. 

  1591. 		<p class="Step">Feel free to explore the calculator.py script file (located

    1592. 

  1592. 		in Tutorial directory).&nbsp; The point of interest is the Calculator.__init__

    1593. 

  1593. 		method:</p>

    1594. 

  1594. 		</li>

    1595. 

  1595. 	</ol>

    1596. 

  1596. 	<p class="CodeSample">def __init__(self, controls):&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;

    1597. 

  1597. 	(1)<br />

    1598. 

  1598. &nbsp;&nbsp;&nbsp; self.expression = &quot;&quot;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;

    1599. 

  1599. 	(2)<br />

    1600. 

  1600. &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;

    1601. 

  1601. 	(3)<br />

    1602. 

  1602. &nbsp;&nbsp;&nbsp; for i in controls:&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;

    1603. 

  1603. 	(4)<br />

    1604. 

  1604. &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; if isinstance(i, Button):&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;

    1605. 

  1605. 	(5)<br />

    1606. 

  1606. &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; if hasattr(self,

    1607. 

  1607. 	&quot;on_&quot; + i.Name):&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;

    1608. 

  1608. 	(6)<br />

    1609. 

  1609. &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;

    1610. 

  1610. 	i.Click += getattr(self, &quot;on_&quot; + i.Name)&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;

    1611. 

  1611. 	(7)<br />

    1612. 

  1612. &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; elif isinstance(i, TextBox):&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;

    1613. 

  1613. 	(8)<br />

    1614. 

  1614. &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; if i.Name ==

    1615. 

  1615. 	&quot;Result&quot;:&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;

    1616. 

  1616. 	(9)<br />

    1617. 

  1617. &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;

    1618. 

  1618. 	self.result = i&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;

    1619. 

  1619. 	(10)<br />

    1620. 

  1620. &nbsp;&nbsp;&nbsp; self.result.Text = self.expression&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;

    1621. 

  1621. 	(11)</p>

    1622. 

  1622. 	<p class="Stepnonumbering">The &quot;controls&quot; argument for the method is the list of buttons and

    1623. 

  1623. 	text boxes, very similar to the list of buttons created in steps 3 and 4 of this task.&nbsp;

    1624. 

  1624. 	The initialization code enumerates the list (line 4), identifies buttons (line 5), and uses the name of

    1625. 

  1625. 	the button (&quot;One&quot;, &quot;Multiply&quot;, &quot; Equals&quot;, ...) to find the calculator attribute

    1626. 

  1626. 	(method) with the corresponding name (for example, &quot;on_One&quot;, &quot;on_Multiply&quot;,

    1627. 

  1627. 	and &quot;on_Equals&quot;, respectively).&nbsp; If such an attribute (method) is available,

    1628. 

  1628. 	we hook the Click event event, using the name to fetch the attribute (line 7).</p>

    1629. 

  1629. 	<ol start="10">

    1630. 

  1630. 		<li>

    1631. 

  1631. 		<p class="Step">The second point of interest is the on_Equals method, especially

    1632. 

  1632. 		the highlighted line.&nbsp; Python has a built-in function, &quot;eval&quot;, which evaluates

    1633. 

  1633. 		an expression passed as a string and returns the resulting value.&nbsp; Calculator uses &quot;eval&quot;

    1634. 

  1634. 		to evaluate the calculator expressions.&nbsp; The &quot;str&quot; function will then convert the value

    1635. 

  1635. 		into a string for display.</p>

    1636. 

  1636. 		</li>

    1637. 

  1637. 	</ol>

    1638. 

  1638. 	<p class="CodeSample">def on_Equals(self, b, e):<br />

    1639. 

  1639. &nbsp;&nbsp;&nbsp; try:<br>

    1640. 

  1640. 	&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; result

    1641. 

  1641. 	= str(eval(self.expression))<br>

    1642. 

  1642. 	&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; self.result.Text

    1643. 

  1643. 	= result<br />

    1644. 

  1644. &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; self.expression = result<br />

    1645. 

  1645. &nbsp;&nbsp;&nbsp; except:<br />

    1646. 

  1646. &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; self.result.Text = &quot;&lt;&lt;ERROR&gt;&gt;&quot;<br />

    1647. 

  1647. &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; self.expression = &quot;&quot;</p>

    1648. 

  1648. 	<ol start="11">

    1649. 

  1649. 		<li>

    1650. 

  1650. 		<p class="Step">Exit the IronPython Interactive console (Ctrl+Z or F6 followed

    1651. 

  1651. 		by Enter)</p>

    1652. 

  1652. 		</li>

    1653. 

  1653. 	</ol>

    1654. 

  1654. 	<p class="LabSummary">Tutorial Summary</p>

    1655. 

  1655. 	<p class="Body">IronPython provides a very easy way to develop live applications

    1656. 

  1656. 	in a dynamic and exploratory way. Both Windows Forms and Windows Presentation

    1657. 

  1657. 	Foundation (Avalon) applications can be easily developed this way with minimal

    1658. 

  1658. 	setup. The advantage is that changes are visible immediately and modifications

    1659. 

  1659. 	are happening to a live system and don&#39;t require recompilation.</p>

    1660. 

  1660. 	<p class="Body">In this tutorial you performed the following exercises:</p>

    1661. 

  1661. 	<ul>

    1662. 

  1662. 		<li>

    1663. 

  1663. 		<p class="ExerciseList"><a href="#T2.1">Events and Delegates</a></p>

    1664. 

  1664. 		</li>

    1665. 

  1665. 		<li>

    1666. 

  1666. 		<p class="ExerciseList"><a href="#T2.2">Windows Forms</a></p>

    1667. 

  1667. 		</li>

    1668. 

  1668. 		<li>

    1669. 

  1669. 		<p class="ExerciseList"><a href="#T2.3">Windows Presentation Foundation

    1670. 

  1670. 		(Avalon)</a></p>

    1671. 

  1671. 		</li>

    1672. 

  1672. 	</ul>

    1673. 

  1673. 	<p class="Body">&nbsp;</p>

    1674. 

  1674. 	<p class="Body">In this tutorial, you became familiar with using delegates and

    1675. 

  1675. 	handling events in IronPython - an essential part of interactive development

    1676. 

  1676. 	of Windows applications using WinForms or Avalon. Then you dynamically created

    1677. 

  1677. 	simple interactive application in Windows Forms and created two applications

    1678. 

  1678. 	using Windows Presentation Foundation. </p>

    1679. 

  1679. 	<h1><a name="T3">Tutorial 3: IronPython and COM interoperability</a></h1>

    1680. 

  1680. 	<p class="Body">COM interoperability is an important part of .NET Framework.

    1681. 

  1681. 	To use COM objects from the .NET application, an interop assembly that contains

    1682. 

  1682. 	the .NET metadata for the COM objects is required. This tutorial will outline

    1683. 

  1683. 	how the interop assemblies can be created (in the case they are not provided

    1684. 

  1684. 	by the creators of the COM object) and will demonstrate the ease with which

    1685. 

  1685. 	COM objects can be used from IronPython.</p>

    1686. 

  1686. 	<p class="Body">Estimated time to complete this tutorial: <b>20 minutes</b></p>

    1687. 

  1687. 	<p class="Body">The objective of this tutorial is to explore COM interoperability

    1688. 

  1688. 	from IronPython.</p>

    1689. 

  1689. 	<ul>

    1690. 

  1690. 		<li>

    1691. 

  1691. 		<p class="ExerciseList"><a href="#T3.1">Merlin the Wizard</a></p>

    1692. 

  1692. 		</li>

    1693. 

  1693. 		<li>

    1694. 

  1694. 		<p class="ExerciseList"><a href="#T3.2">Word Spell Checking</a></p>

    1695. 

  1695. 		</li>

    1696. 

  1696. 	</ul>

    1697. 

  1697. 	<h2><a name="T3.1">Exercise 1: Merlin the Wizard</a></h2>

    1698. 

  1698. 	<p class="Body">This exercise consists of two tasks.&nbsp; In the first one we will

    1699. 

  1699. 	create an interop assembly for a COM object library and explore it using the

    1700. 

  1700. 	.NET reflection tools.&nbsp; In the second task we will use the COM object library

    1701. 

  1701. 	from IronPython.</p>

    1702. 

  1702. 	<p class="Body">In this exercise, you will create a COM interop assembly and

    1703. 

  1703. 	use it to drive the COM object from IronPython.</p>

    1704. 

  1704. 	<h3><a name="T3.1.1">Task 1: Creating COM interop assemblies</a></h3>

    1705. 

  1705. 	<ol>

    1706. 

  1706. 		<li>

    1707. 

  1707. 		<p class="Step">Open the &quot;SDK Command Prompt&quot; or &quot;Visual Studio 2005 Command

    1708. 

  1708. 		Prompt&quot; from the start menu. Note, if you installed IronPython under Program 

    1709. 

  1709.             Files via the MSI installer, you'll need to run the command prompt as an 

    1710. 

  1710.             administrator.</p>

    1711. 

  1711. 		</li>

    1712. 

  1712. 		<li>

    1713. 

  1713. 		<p class="Step">The .NET Frameworks SDK comes with the &quot;tlbimp&quot; tool which converts

    1714. 

  1714. 		a COM type library into .NET metadata information -- the interop assembly.&nbsp; The COM object library we want to use from IronPython

    1715. 

  1715. 		is msagent, located

    1716. 

  1716. 		in %SystemRoot%\msagent\agentsvr.exe.&nbsp; Use the tlbimp tool to generate the

    1717. 

  1717. 		interop assembly for msagent (tlbimp writes to the current directory):</p>

    1718. 

  1718. 		</li>

    1719. 

  1719. 	</ol>

    1720. 

  1720. 	<p class="DOSCommand">tlbimp %SystemRoot%\msagent\agentsvr.exe</p>

    1721. 

  1721. 	<p class="Code-Highlighted">C:\IronPython\Tutorial&gt;tlbimp %SystemRoot%\msagent\agentsvr.exe<br />

    1722. 

  1722. 	Microsoft (R) .NET Framework Type Library to Assembly Converter 2.0.50727.42<br />

    1723. 

  1723. 	Copyright (C) Microsoft Corporation.&nbsp; All rights reserved.<br />

    1724. 

  1724. 	<br>

    1725. 

  1725. 	Type library imported to AgentServerObjects.dll</p>

    1726. 

  1726. 	<ol start="3">

    1727. 

  1727. 		<li>

    1728. 

  1728. 		<p class="Step">The .NET metadata information was saved in AgentServerObjects.dll.&nbsp; Use the ildasm tool to explore the generated DLL:</p>

    1729. 

  1729. 		</li>

    1730. 

  1730. 	</ol>

    1731. 

  1731. 	<p class="DOSCommand">ildasm AgentServerObjects.dll</p>

    1732. 

  1732. 	<ol start="4">

    1733. 

  1733. 		<li>

    1734. 

  1734. 		<p class="Step">As you browse the metadata tree, notice that at the root

    1735. 

  1735. 		of the hierarchy there is the &quot;AgentServerObjects&quot; namespace.&nbsp; The namespace

    1736. 

  1736. 		contains many interfaces and a single class - AgentServerClass.&nbsp; Explore

    1737. 

  1737. 		the methods on the class.&nbsp; Calling some of its methods will be the subject

    1738. 

  1738. 		of the next task.</p>

    1739. 

  1739. 		</li>

    1740. 

  1740. 		<li>

    1741. 

  1741. 		<p class="Step">When you are done exploring the AgentServerObjects.dll,

    1742. 

  1742. 		close the ildasm tool.&nbsp; Copy AgentServerObjects.dll to the tutorial

    1743. 

  1743. 		directory, and then close the Windows command prompt.</p>

    1744. 

  1744. 		</li>

    1745. 

  1745. 	</ol>

    1746. 

  1746. 	<h3><a name="T3.1.2">Task 2: Using COM objects from IronPython</a></h3>

    1747. 

  1747. 	<ol>

    1748. 

  1748. 		<li>

    1749. 

  1749. 		<p class="Step">Start the IronPython console from the tutorial directory

    1750. 

  1750. 		(see <a href="#Intro">Introduction</a> for details).</p>

    1751. 

  1751. 		</li>

    1752. 

  1752. 		<li>

    1753. 

  1753. 		<p class="Step">Using the &quot;AddReferenceToFile&quot; function in the

    1754. 

  1754. 		clr module,

    1755. 

  1755. 		add a reference to the AgentServerObjects.dll:</p>

    1756. 

  1756. 		</li>

    1757. 

  1757. 	</ol>

    1758. 

  1758. 	<p class="TypedExample">import clr</p>

    1759. 

  1759. 	<p class="Code-Background"></p>

    1760. 

  1760. 	<p class="TypedExample">clr.AddReferenceToFile(&quot;AgentServerObjects.dll&quot;)</p>

    1761. 

  1761. 	<p class="Code-Background"></p>

    1762. 

  1762. 	<ol start="3">

    1763. 

  1763. 		<li>

    1764. 

  1764. 		<p class="Step">Import the contents of the AgentServerObjects namespace

    1765. 

  1765. 		and explore the contents using dir():</p>

    1766. 

  1766. 		</li>

    1767. 

  1767. 	</ol>

    1768. 

  1768. 	<p class="TypedExample">from AgentServerObjects import *</p>

    1769. 

  1769. 	<p class="Code-Background"></p>

    1770. 

  1770. 	<p class="TypedExample">dir()</p>

    1771. 

  1771. 	<p class="HiddenOutput">['AgentServer', 'AgentServerClass', 'IAgent', 'IAgentAudioOutputProperties', 'IAgentAudioOutputPropertiesEx', 'IAgentBalloon', 'IAgentBalloonEx', 'IAgentCharacter', 'IAgentCharacterEx', 'IAgentCommand', 'IAgentCommandEx', 'IAgentCommandWindow', 'IAgentCommands', 'IAgentCommandsEx', 'IAgentEx', 'IAgentNotifySink', 'IAgentNotifySinkEx', 'IAgentPropertySheet', 'IAgentSpeechInputProperties', 'IAgentUserInput', '__builtins__', '__doc__', '__name__', 'clr']

    1772. 

  1772. 	</p>

    1773. 

  1773. 	<ol start="4">

    1774. 

  1774. 		<li>

    1775. 

  1775. 		<p class="Step">Create instance of the AgentServerClass and explore its

    1776. 

  1776. 		contents:</p>

    1777. 

  1777. 		</li>

    1778. 

  1778. 	</ol>

    1779. 

  1779. 	<p class="TypedExample">a = AgentServerClass()</p>

    1780. 

  1780. 	<p class="TypedExample">dir(a)</p>

    1781. 

  1781. 	<p class="Stepnonumbering">The output in the console window will be:</p>

    1782. 

  1782. 	<p class="Code-Highlighted">&gt;&gt;&gt; a = AgentServerClass()<br />

    1783. 

  1783. 	&gt;&gt;&gt; dir(a)</p>

    1784. 

  1784. 	<p class="Code-Background">['CreateObjRef','Equals','GetCharacter','GetCharacterEx','GetHashCode','GetLifetimeService','GetSuspended','GetType','GetVersion','InitializeLifetimeService','Load','MemberwiseClone','ReferenceEquals','Register','ShowDefaultCharacterProperties','ToString','Unload','Unregister','__class__','__delattr__','__doc__','__getattribute__','__hash__','__init__','__new__','__reduce__','__reduce_ex__','__repr__','__setattr__','__str__']</p>

    1785. 

  1785. 	<ol start="5">

    1786. 

  1786. 		<li>

    1787. 

  1787. 		<p class="Step">Load &quot;Merlin the Wizard&quot; character. (The character data

    1788. 

  1788. 		is stored in c:\WINDOWS\msagent\chars). The Load method returns multiple

    1789. 

  1789. 		values packed into a tuple - the

    1790. 

  1790. 	first value is the actual character ID. Capture the character id in the variable:</p>

    1791. 

  1791. 		</li>

    1792. 

  1792. 	</ol>

    1793. 

  1793. 	<p class="TypedExample">cid = clr.Reference[int]()</p>

    1794. 

  1794. 	<p class="Code-Background"></p>

    1795. 

  1795. 	<p class="TypedExample">reqid = clr.Reference[int]()</p>

    1796. 

  1796. 	<p class="Code-Background"></p>

    1797. 

  1797. 	<p class="TypedExample">a.Load(&quot;Merlin.acs&quot;, cid, reqid)</p>

    1798. 

  1798. 	<p class="Code-Background"></p>

    1799. 

  1799. 	<ol start="6">

    1800. 

  1800. 		<li>

    1801. 

  1801. 		<p class="Step">Call GetCharacter method on the AgentServerClass instance

    1802. 

  1802. 		to get the actual character, display the character and have him think about

    1803. 

  1803. 		IronPython Tutorial:</p>

    1804. 

  1804. 		</li>

    1805. 

  1805. 	</ol>

    1806. 

  1806. 	<p class="TypedExample">from System.Runtime.InteropServices import DispatchWrapper, UnknownWrapper</p>

    1807. 

  1807. 	<p class="TypedExample">c = clr.StrongBox[object](DispatchWrapper(None))</p>

    1808. 

  1808. 	<p class="HiddenOutput"></p>

    1809. 

  1809. 	<p class="TypedExample">a.GetCharacter(cid.Value, c)</p>

    1810. 

  1810. 	<p class="HiddenOutput"></p>

    1811. 

  1811. 	<p class="Code-Background"></p>

    1812. 

  1812. 	<p class="TypedExample">character = c.Value</p>

    1813. 

  1813. 	<p class="HiddenOutput"></p>

    1814. 

  1814. 	<p class="TypedExample">character.Show(0, reqid)</p>

    1815. 

  1815. 	<p class="HiddenOutput"></p>

    1816. 

  1816. 	<p class="TypedExample">character.Think(&quot;IronPython Tutorial&quot;, reqid)</p>

    1817. 

  1817. 	<p class="HiddenOutput"></p>

    1818. 

  1818. 	<ol start="7">

    1819. 

  1819. 		<li>

    1820. 

  1820. 		<p class="Step">Merlin has a lot of animations he can play.&nbsp; Get list of

    1821. 

  1821. 		all the animations by calling the GetAnimationNames method. Play one of the animations,

    1822. 

  1822. 		&quot;Read&quot;, by calling the Play method:</p>

    1823. 

  1823. 		</li>

    1824. 

  1824. 	</ol>

    1825. 

  1825. 	<p class="TypedExample">enum = clr.StrongBox[object](UnknownWrapper(None))</p>

    1826. 

  1826. 	<p class="HiddenOutput"></p>

    1827. 

  1827. 	<p class="TypedExample">character.GetAnimationNames(enum)</p>

    1828. 

  1828. 	<p class="HiddenOutput"></p>

    1829. 

  1829. 	<p class="TypedExample">animations = enum.Value</p>

    1830. 

  1830. 	<p class="HiddenOutput"></p>

    1831. 

  1831. 	<p class="TypedExample">for n in animations: print n</p>

    1832. 

  1832. 	<p class="HiddenOutput">RestPose<br>

    1833. 

  1833. Blink<br>

    1834. 

  1834. Idle2_2<br>

    1835. 

  1835. Idle2_1<br>

    1836. 

  1836. Idle1_1<br>

    1837. 

  1837. Idle1_3<br>

    1838. 

  1838. Idle1_2<br>

    1839. 

  1839. Idle1_4<br>

    1840. 

  1840. Greet<br>

    1841. 

  1841. Idle3_1<br>

    1842. 

  1842. GestureUp<br>

    1843. 

  1843. GestureDown<br>

    1844. 

  1844. GestureLeft<br>

    1845. 

  1845. GestureRight<br>

    1846. 

  1846. Show<br>

    1847. 

  1847. Hide<br>

    1848. 

  1848. Hearing_4<br>

    1849. 

  1849. Hearing_1<br>

    1850. 

  1850. Hearing_2<br>

    1851. 

  1851. Hearing_3<br>

    1852. 

  1852. Alert<br>

    1853. 

  1853. Explain<br>

    1854. 

  1854. Processing<br>

    1855. 

  1855. Thinking<br>

    1856. 

  1856. Searching<br>

    1857. 

  1857. Acknowledge<br>

    1858. 

  1858. Wave<br>

    1859. 

  1859. DontRecognize<br>

    1860. 

  1860. Uncertain<br>

    1861. 

  1861. Decline<br>

    1862. 

  1862. Sad<br>

    1863. 

  1863. StopListening<br>

    1864. 

  1864. GetAttention<br>

    1865. 

  1865. GetAttentionReturn<br>

    1866. 

  1866. Idle3_2<br>

    1867. 

  1867. Surprised<br>

    1868. 

  1868. Congratulate_2<br>

    1869. 

  1869. Reading<br>

    1870. 

  1870. Announce<br>

    1871. 

  1871. Read<br>

    1872. 

  1872. ReadReturn<br>

    1873. 

  1873. Writing<br>

    1874. 

  1874. Write<br>

    1875. 

  1875. WriteReturn<br>

    1876. 

  1876. Congratulate<br>

    1877. 

  1877. Confused<br>

    1878. 

  1878. Suggest<br>

    1879. 

  1879. MoveRight<br>

    1880. 

  1880. MoveLeft<br>

    1881. 

  1881. MoveUp<br>

    1882. 

  1882. MoveDown<br>

    1883. 

  1883. StartListening<br>

    1884. 

  1884. WriteContinued<br>

    1885. 

  1885. DoMagic1<br>

    1886. 

  1886. DoMagic2<br>

    1887. 

  1887. LookDown<br>

    1888. 

  1888. LookDownBlink<br>

    1889. 

  1889. LookDownReturn<br>

    1890. 

  1890. LookLeft<br>

    1891. 

  1891. LookLeftBlink<br>

    1892. 

  1892. LookLeftReturn<br>

    1893. 

  1893. LookRight<br>

    1894. 

  1894. LookRightBlink<br>

    1895. 

  1895. LookRightReturn<br>

    1896. 

  1896. LookUp<br>

    1897. 

  1897. LookUpBlink<br>

    1898. 

  1898. LookUpReturn<br>

    1899. 

  1899. ReadContinued<br>

    1900. 

  1900. Pleased<br>

    1901. 

  1901. GetAttentionContinued<br>

    1902. 

  1902. Process<br>

    1903. 

  1903. Search<br>

    1904. 

  1904. Think<br></p>

    1905. 

  1905. 	<p class="TypedExample">character.Play(&quot;Read&quot;, reqid)</p>

    1906. 

  1906. 	<p class="HiddenOutput"></p>

    1907. 

  1907. 	<ol start="8">

    1908. 

  1908. 		<li>

    1909. 

  1909. 		<p class="Step">(Optional) To call a series of animations, we could call character.Play(animation_name, reqid)

    1910. 

  1910. 		for each animation.&nbsp; Python&#39;s lamda functions can simplify this process.&nbsp; We can create global functions and assign them names based on the animation

    1911. 

  1911. 		name:</p>

    1912. 

  1912. 		</li>

    1913. 

  1913. 	</ol>

    1914. 

  1914. 	<p class="TypedExample">character.GetAnimationNames(enum)</p>

    1915. 

  1915. 	<p class="HiddenOutput"></p>

    1916. 

  1916. 	<p class="TypedExample">animations = enum.Value</p>

    1917. 

  1917. 	<p class="HiddenOutput"></p>

    1918. 

  1918. 	<p class="TypedExample">for n in animations: globals()[n] = lambda name=n: character.Play(name, reqid)</p>

    1919. 

  1919. 	<p class="HiddenOutput"></p>

    1920. 

  1920. 	<p class="Stepnonumbering">At this point we can have Merlin play animations

    1921. 

  1921. 	simply by calling a function from global namespace:</p>

    1922. 

  1922. 	<p class="TypedExample">Congratulate()</p>

    1923. 

  1923. 	<p class="HiddenOutput"></p>

    1924. 

  1924. 	<p class="Code-Background"></p>

    1925. 

  1925. 	<ol start="9">

    1926. 

  1926. 		<li>

    1927. 

  1927. 		<p class="Step">Stop Merlin&#39;s animations, hide him, and exit IronPython console</p>

    1928. 

  1928. 		</li>

    1929. 

  1929. 	</ol>

    1930. 

  1930. 	<p class="TypedExample">character.StopAll(0)</p>

    1931. 

  1931. 	<p class="HiddenOutput"></p>

    1932. 

  1932. 	<p class="TypedExample">character.Hide(0, reqid)</p>

    1933. 

  1933. 	<p class="HiddenOutput"></p>

    1934. 

  1934. 	<h2><a name="T3.2">Exercise 2: Use Word for Spell Checking</a></h2>

    1935. 

  1935. 	<p class="Body">In this exercise you will create an instance of Microsoft

    1936. 

  1936. 	Word and use it to check word spellings.</p>

    1937. 

  1937. 	<h3><a name="T3.2.1">Task 1: Accessing Word and Checking Spelling</a></h3>

    1938. 

  1938. 	<ol>

    1939. 

  1939. 		<li>

    1940. 

  1940. 		<p class="Step">Start the IronPython console from the tutorial directory

    1941. 

  1941. 		(see <a href="#Intro">Introduction</a> for details).</p>

    1942. 

  1942. 		</li>

    1943. 

  1943. 		<li>

    1944. 

  1944. 		<p class="Step">Import clr module and add a reference to the Word COM

    1945. 

  1945. 		interop assembly.</p>

    1946. 

  1946. 		</li>

    1947. 

  1947. 	</ol>

    1948. 

  1948. 	<p class="TypedExample">import clr</p>

    1949. 

  1949. 	<p class="Code-Background"></p>

    1950. 

  1950. 	<p class="TypedExample">clr.AddReferenceByPartialName(&quot;Microsoft.Office.Interop.Word&quot;)</p>

    1951. 

  1951. 	<p class="Code-Background"></p>

    1952. 

  1952. 	<p class="TypedExample">from Microsoft.Office.Interop.Word import ApplicationClass</p>

    1953. 

  1953. 	<p class="Code-Background"></p>

    1954. 

  1954. 	</p>

    1955. 

  1955. 	<ol start="3">

    1956. 

  1956. 		<li>

    1957. 

  1957. 		<p class="Step">Start an instance of Word as a COM server running.&nbsp;

    1958. 

  1958. 		You won't see it show up since it is hidden, but you can see it in the

    1959. 

  1959. 		Windows Task Manager by typing ctrl-shift-escape and looking for the

    1960. 

  1960. 		WINWORD.EXE process.</p></li>

    1961. 

  1961. 	</ol>

    1962. 

  1962. 	<p class="TypedExample">w = ApplicationClass()</p>

    1963. 

  1963. 	<p class="Code-Background"></p>

    1964. 

  1964. 	<ol start="4">

    1965. 

  1965. 		<li>

    1966. 

  1966. 		<p class="Step">Define the following function to check the spelling.&nbsp;

    1967. 

  1967. 		Remember to indent the lines of the function's body extra spaces, and you

    1968. 

  1968. 		have to hit an extra return or enter to complete the function's definition.</p></li>

    1969. 

  1969. 	</ol>

    1970. 

  1970. 	<p class="TypedExample">def check_word (word):<br>

    1971. 

  1971. &nbsp;&nbsp; return w.CheckSpelling(word)</p>

    1972. 

  1972. <p class="Code-Background"></p>

    1973. 

  1973. 	<p class="TypedExample">check_word(&quot;foo&quot;)</p>

    1974. 

  1974. 	<p class="HiddenOutput">False</p>

    1975. 

  1975. 	<p class="TypedExample">check_word(&quot;food&quot;)</p>

    1976. 

  1976. 	<p class="HiddenOutput">True</p>

    1977. 

  1977. 	<ol start="5">

    1978. 

  1978. 		<li>

    1979. 

  1979. 		<p class="Step">You can try that out on a couple of words, but now lets

    1980. 

  1980. 		define a function that will suggest corrections for us.&nbsp; First, we

    1981. 

  1981. 		need to add a document so that we can call GetSpellingSuggestions(),

    1982. 

  1982. 		which gives a nice error message if you try to call it with no documents

    1983. 

  1983. 		opened.</p></li>

    1984. 

  1984. 	</ol>

    1985. 

  1985. 	<p class="TypedExample">w.Documents.Add()</p>

    1986. 

  1986. 	<p class="LooseVerify">Microsoft.Office.Interop.Word.DocumentClass</p>

    1987. 

  1987. 	<ol start="6">

    1988. 

  1988. 		<li>

    1989. 

  1989. 		<p class="Step">The first result of

    1990. 

  1990. 		several return values from GetSpellingSuggestions() is a collection of

    1991. 

  1991. 		items, each of which is a correction suggestion.&nbsp; We use a Python

    1992. 

  1992. 		list comprehension to iterate through the COM collection object and call

    1993. 

  1993. 		the Name property on each item object in the collection.&nbsp; Each

    1994. 

  1994. 		item's Name property is a string that Word is suggesting as a correct

    1995. 

  1995. 		spelling.</p></li>

    1996. 

  1996. 	</ol>

    1997. 

  1997. 	<p class="TypedExample">def suggestions(word):<br>

    1998. 

  1998. &nbsp;&nbsp; res_objects = w.GetSpellingSuggestions(word)<br>

    1999. 

  1999. &nbsp;&nbsp; return [x.Name for x in res_objects]</p>

    2000. 

  2000. <p class="Code-Background"></p>

    2001. 

  2001. 	<ol start="7">

    2002. 

  2002. 		<li>

    2003. 

  2003. 		<p class="Step">Now, let's shut down Word and exit the IronPython

    2004. 

  2004. 		console.&nbsp; When you enter the next line and hit return, if you are

    2005. 

  2005. 		watching the Windows Task Manager, you will see the WINWORD.EXE process

    2006. 

  2006. 		go away.</p></li>

    2007. 

  2007. 	</ol>

    2008. 

  2008. 	<p class="TypedExample">w.Quit()</p>

    2009. 

  2009. 	<p class="Code-Background"></p>

    2010. 

  2010. 	<h3><a name="T3.2.2">Task 2: Use Windows Form Dialog to Correct Spelling</a></h3>

    2011. 

  2011. 	<p class="Body">In this task you will use an example already written that is

    2012. 

  2012. 	very similar to what you did in Task 1, but it demonstrates two additional

    2013. 

  2013. 	features.&nbsp; It uses a Python standard module to register a clean up

    2014. 

  2014. 	function so that when the IronPython console terminates, the Word process is

    2015. 

  2015. 	closed.&nbsp; The example also has a function, correct_word, that uses a

    2016. 

  2016. 	Windows Form as a dialog to let users select a correct word to return.</p>

    2017. 

  2017. 	<ol>

    2018. 

  2018. 		<li>

    2019. 

  2019. 		<p class="Step">Start the IronPython console from the tutorial directory

    2020. 

  2020. 		(see <a href="#Intro">Introduction</a> for details).</p>

    2021. 

  2021. 		</li>

    2022. 

  2022. 		<li>

    2023. 

  2023. 		<p class="Step">Import spellcheck.</p>

    2024. 

  2024. 		</li>

    2025. 

  2025. 		<li>

    2026. 

  2026. 		<p class="Step">Call spellcheck.correct_word on a correctly spelled

    2027. 

  2027. 		word, and you'll see the function returns the word.</p>

    2028. 

  2028. 		</li>

    2029. 

  2029. 		<li>

    2030. 

  2030. 		<p class="Step">Call spellcheck.correct_word on a misspelled word, and a

    2031. 

  2031. 		Windows Form similar to Word's spelling correction dialog appears.&nbsp;

    2032. 

  2032. 		You can pick from the list and click the Replace button, double click a

    2033. 

  2033. 		word in the suggestions list, enter custom text and click the Use Custom

    2034. 

  2034. 		button, click an Ignore button to return the misspelled word, and so on. </p>

    2035. 

  2035. 		</li>

    2036. 

  2036. 		<li>

    2037. 

  2037. 		<p class="Step">Open the spellcheck.py file to see the code for the the

    2038. 

  2038. 		Windows Form as well as the functions.</li>

    2039. 

  2039. 	</ol>

    2040. 

  2040. 	<p class="Body">&nbsp;</p>

    2041. 

  2041. 	<p class="LabSummary">Tutorial Summary</p>

    2042. 

  2042. 	<p class="Body">This tutorial was focused on using COM interop assemblies generated

    2043. 

  2043. 	via tlbimp tool (in the .NET Framework SDK) to control COM objects from the IronPython environment.</p>

    2044. 

  2044. 	<p class="Body">In this tutorial you performed the following exercises.</p>

    2045. 

  2045. 	<ul>

    2046. 

  2046. 		<li>

    2047. 

  2047. 		<p class="ExerciseList"><a href="#T3.1">Merlin the Wizard</a></p>

    2048. 

  2048. 		</li>

    2049. 

  2049. 		<li>

    2050. 

  2050. 		<p class="ExerciseList"><a href="#T3.2">Word Spell Checking</a></p>

    2051. 

  2051. 		</li>

    2052. 

  2052. 	</ul>

    2053. 

  2053. 	<p class="Body">&nbsp;</p>

    2054. 

  2054. 	<p class="Body">In this tutorial, you created a COM interop assembly for the

    2055. 

  2055. 	msagent COM object.&nbsp; You used the tlbimp tool which is part of the .NET Framework

    2056. 

  2056. 	SDK.&nbsp; Using the ildasm tool, you explored contents of the interop assembly.</p>

    2057. 

  2057. 	<p class="Body">Then, from IronPython you loaded the interop assembly, created

    2058. 

  2058. 	an instance of the COM object, and instructed Merlin to play different animations.</p>

    2059. 

  2059. 	<p class="Body">You also used Word to check the spelling of words, learned

    2060. 

  2060. 	how to supply missing optional arguments, and inspected code that builds a

    2061. 

  2061. 	Windows Form and uses it as a dialog.</p>

    2062. 

  2062. 	<p class="Normal">&nbsp;</p>

    2063. 

  2063. 	<h1><a name="T4">Tutorial 4: Debugging IronPython program</a></h1>

    2064. 

  2064. 	<p class="Body">This tutorial will walk you through very simple debug session,

    2065. 

  2065. 	debugging a Python script using Microsoft CLR Debugger.&nbsp; See

    2066. 

  2066. 	<a href="#T7">using Visual Studio</a> if you have a Visual Studio SKU and

    2067. 

  2067. 	consider skipping this exercise.</p>

    2068. 

  2068. 	<p class="Body">Estimated time to complete this tutorial: <b>10 minutes</b></p>

    2069. 

  2069. 	<p class="Body">The objective of this tutorial is debugging simple Python script

    2070. 

  2070. 	using Microsoft CLR Debugger.</p>

    2071. 

  2071. 	<ul>

    2072. 

  2072. 		<li>

    2073. 

  2073. 		<p class="Body"><a href="#T4.1">Debugging IronPython program</a></p>

    2074. 

  2074. 		</li>

    2075. 

  2075. 	</ul>

    2076. 

  2076. 	<h2><a name="T4.1">Exercise 1: Debugging IronPython program</a></h2>

    2077. 

  2077. 	<p class="Body">In this exercise, you will step through a simple Python script

    2078. 

  2078. 	in the Microsoft CLR Debugger.</p>

    2079. 

  2079. 	<h3><a name="T4.1.1">Task 1: Debugging IronPython program using Microsoft CLR

    2080. 

  2080. 	Debugger</a></h3>

    2081. 

  2081. 	<ol>

    2082. 

  2082. 		<li>

    2083. 

  2083. 		<p class="Step">Launch Microsoft CLR Debugger. </p>

    2084. 

  2084. 		</li>

    2085. 

  2085. 		<li>

    2086. 

  2086. 		<p class="Step">From the debugger Menu, select Debug / Program to Debug

    2087. 

  2087. 		...</p>

    2088. 

  2088. 		</li>

    2089. 

  2089. 		<li>

    2090. 

  2090. 		<p class="Step">For Program, browse to the ipy.exe (located

    2091. 

  2091. 		in the installaton directory)</p>

    2092. 

  2092. 		</li>

    2093. 

  2093. 		<li>

    2094. 

  2094. 		<p class="Step">For Arguments, type in debugging.py</p>

    2095. 

  2095. 		</li>

    2096. 

  2096. 		<li>

    2097. 

  2097. 		<p class="Step">Change Working directory to the Tutorial directory</p>

    2098. 

  2098. 		</li>

    2099. 

  2099. 		<li>

    2100. 

  2100. 		<p class="Step">Click OK</p>

    2101. 

  2101. 		</li>

    2102. 

  2102. 		<li>

    2103. 

  2103. 		<p class="Step">From Menu, select File / Open / File. Browse to the Tutorial

    2104. 

  2104. 		directory and select two files to open:</p>

    2105. 

  2105. 		</li>

    2106. 

  2106. 	</ol>

    2107. 

  2107. 	<p class="Body">debugging.py</p>

    2108. 

  2108. 	<p class="Body">first.py</p>

    2109. 

  2109. 	<ol start="8">

    2110. 

  2110. 		<li>

    2111. 

  2111. 		<p class="Step">Place breakpoint at the following line of the debugging.py

    2112. 

  2112. 		file (Place cursor on the line and pres F9):</p>

    2113. 

  2113. 		</li>

    2114. 

  2114. 	</ol>

    2115. 

  2115. 	<p class="Body">print first.add(1, 2)</p>

    2116. 

  2116. 	<ol start="9">

    2117. 

  2117. 		<li>

    2118. 

  2118. 		<p class="Step">Press F5 - Start Debugging.</p>

    2119. 

  2119. 		</li>

    2120. 

  2120. 	</ol>

    2121. 

  2121. 	<p class="Stepnonumbering">IronPython will compile the debugging.py file and

    2122. 

  2122. 	start executing it. You will hit the breakpoint at the line 3.</p>

    2123. 

  2123. 	<p class="StepNote">Note: If you get poor performance starting the debugging

    2124. 

  2124. 	session, exit the debugger, open the Windows Explorer and delete the following

    2125. 

  2125. 	directory:</p>

    2126. 

  2126. 	<p class="StepNote">%USERPROFILE%\Application Data\Microsoft\DbgClr</p>

    2127. 

  2127. 	<ol start="10">

    2128. 

  2128. 		<li>

    2129. 

  2129. 		<p class="Step">Pressing F11, step through the execution of the program,

    2130. 

  2130. 		explore variables (even change the values of the variables in the watch

    2131. 

  2131. 		window) and explore the call stack. </p>

    2132. 

  2132. 		</li>

    2133. 

  2133. 		<li>

    2134. 

  2134. 		<p class="Step">End the debugging session and exit the debugger.</p>

    2135. 

  2135. 		</li>

    2136. 

  2136. 	</ol>

    2137. 

  2137. 	<p class="LabSummary">Tutorial Summary</p>

    2138. 

  2138. 	<p class="Body">In this tutorial you performed the following exercises.</p>

    2139. 

  2139. 	<ul>

    2140. 

  2140. 		<li>

    2141. 

  2141. 		<p class="Body"><a href="#T4.1">Debugging IronPython program</a></p>

    2142. 

  2142. 		</li>

    2143. 

  2143. 	</ul>

    2144. 

  2144. 	<p class="Body">In this tutorial, you walked through the simple debug session

    2145. 

  2145. 	of IronPython program. You used Microsoft CLR Debugger, placed breakpoints and

    2146. 

  2146. 	stepped through the Python program execution.</p>

    2147. 

  2147. 	<p class="Body">&nbsp;</p>

    2148. 

  2148. 	<h1><a name="T5">Tutorial 5: Extending IronPython</a></h1>

    2149. 

  2149. 	<p class="Body">Estimated time to complete this tutorial: <b>25- 60 minutes</b></p>

    2150. 

  2150. 	<p class="Body">The objective of this tutorial is to implement the class which

    2151. 

  2151. 	will seamlessly fit into the IronPython environment. You can choose to follow

    2152. 

  2152. 	Exercise 1 - C# implementation, Exercise 2 - Visual Basic, or both. Both tracks

    2153. 

  2153. 	will result in the same functionality.</p>

    2154. 

  2154. 	<ul>

    2155. 

  2155. 		<li>

    2156. 

  2156. 		<p class="Body"><a href="#T5.1">Extending using C#</a></p>

    2157. 

  2157. 		</li>

    2158. 

  2158. 		<li>

    2159. 

  2159. 		<p class="Body"><a href="#T5.2">Extending using Visual Basic.NET</a></p>

    2160. 

  2160. 		</li>

    2161. 

  2161. 	</ul>

    2162. 

  2162. 	<h2><a name="T5.1">Exercise 1: Extending using C#</a></h2>

    2163. 

  2163. 	<p class="Body">In this exercise you will use C# language to build a class that

    2164. 

  2164. 	supports enumeration, custom operators and delegates and you will use that class

    2165. 

  2165. 	from IronPython.  It’s worth noting that as Python does not contain protected class members,

    2166. 

  2166.         these members get promoted to public class members when imported into Python.  Private

    2167. 

  2167.         class members, however, will be invisible to Python when imported.</p>

    2168. 

  2168. 	<h3><a name="T5.1.1">Task 1: Implementing simple class - constructor and ToString</a></h3>

    2169. 

  2169. 	<ol>

    2170. 

  2170. 		<li>

    2171. 

  2171. 		<p class="Step">Open the &quot;SDK Command Prompt&quot; or &quot;Visual Studio 2005 Command

    2172. 

  2172. 		Prompt&quot; from the start menu.</p>

    2173. 

  2173. 		</li>

    2174. 

  2174. 		<li>

    2175. 

  2175. 		<p class="Step">Open the &quot;csextend.cs&quot; file in notepad. The file is initially

    2176. 

  2176. 		empty</p>

    2177. 

  2177. 		</li>

    2178. 

  2178. 	</ol>

    2179. 

  2179. 	<p class="DOSExample">notepad csextend.cs</p>

    2180. 

  2180. 	<ol start="3">

    2181. 

  2181. 		<li>

    2182. 

  2182. 		<p class="Step">Add using clauses at the beginning of the file:</p>

    2183. 

  2183. 		</li>

    2184. 

  2184. 	</ol>

    2185. 

  2185. 	<p class="CodeSample">using System;<br />

    2186. 

  2186. 	using System.Collections;</p>

    2187. 

  2187. 	<ol start="4">

    2188. 

  2188. 		<li>

    2189. 

  2189. 		<p class="Step">Define a simple class:</p>

    2190. 

  2190. 		</li>

    2191. 

  2191. 	</ol>

    2192. 

  2192. 	<p class="CodeSample">public class Simple {<br />

    2193. 

  2193. &nbsp;&nbsp;&nbsp; private int data;<br>

    2194. 

  2194. 	<br />

    2195. 

  2195. &nbsp;&nbsp;&nbsp; public Simple(int data) {<br />

    2196. 

  2196. &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; this.data = data;<br />

    2197. 

  2197. &nbsp;&nbsp;&nbsp; }<br>

    2198. 

  2198. 	<br />

    2199. 

  2199. &nbsp;&nbsp;&nbsp; public override string ToString() {<br />

    2200. 

  2200. &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; return String.Format(&quot;Simple&lt;{0}&gt;&quot;, data);<br />

    2201. 

  2201. &nbsp;&nbsp;&nbsp; }<br />

    2202. 

  2202. 	}</p>

    2203. 

  2203. 	<ol start="5">

    2204. 

  2204. 		<li>

    2205. 

  2205. 		<p class="Step">Switch back to the SDK Command Prompt window and build the

    2206. 

  2206. 		code using available csx.bat (C# extension):</p>

    2207. 

  2207. 		</li>

    2208. 

  2208. 	</ol>

    2209. 

  2209. 	<p class="DOSExample">csx</p>

    2210. 

  2210. 	<ol start="6">

    2211. 

  2211. 		<li>

    2212. 

  2212. 		<p class="Step">Start the IronPython console from the tutorial directory

    2213. 

  2213. 		(see <a href="#Intro">Introduction</a> for details).</p>

    2214. 

  2214. 		</li>

    2215. 

  2215. 	</ol>

    2216. 

  2216. 	<ol start="7">

    2217. 

  2217. 		<li>

    2218. 

  2218. 		<p class="Step">Load the dll that you just built (csextend.dll) into IronPython.

    2219. 

  2219. 		Then explore the Simple class using built-in dir() function:</p>

    2220. 

  2220. 		</li>

    2221. 

  2221. 	</ol>

    2222. 

  2222. 	<p class="TypedExample">import clr</p>

    2223. 

  2223. 	<p class="Code-Background"></p>

    2224. 

  2224. 	<p class="UserCode">clr.AddReferenceToFile(&quot;csextend.dll&quot;)</p>

    2225. 

  2225. 	<p class="HiddenCode">clr.AddReferenceToFile(&quot;csextend_5.1.1.dll&quot;)</p>

    2226. 

  2226. 	<p class="Code-Background"></p>

    2227. 

  2227. 	<p class="TypedExample">import Simple</p>

    2228. 

  2228. 	<p class="Code-Background"></p>

    2229. 

  2229. 	<p class="UserCode">dir(Simple)</p>

    2230. 

  2230. 	<p class="HiddenCode">set1 = set(dir(Simple))

    2231. 

  2231. set2 = set(dir(object))

    2232. 

  2232. list(set1-set2)</p>

    2233. 

  2233. 	<p class="HiddenOutput">

    2234. 

  2234. 

    2235. 

  2235. 	[]</p>

    2236. 

  2236. 	<p class="Stepnonumbering">You will see following output:</p>

    2237. 

  2237. 	<p class="Code-Highlighted">&gt;&gt;&gt; import clr<br />

    2238. 

  2238. 	&gt;&gt;&gt; clr.AddReferenceToFile(&quot;csextend.dll&quot;)<br />

    2239. 

  2239. 	&gt;&gt;&gt; import Simple<br />

    2240. 

  2240. 	&gt;&gt;&gt; dir(Simple)</p>

    2241. 

  2241. 	<p class="Code-Highlighted">['Equals', 'GetHashCode', 'GetType', 'MemberwiseClone', 'ReferenceEquals', 'ToString', '__class__', '__delattr__', '__doc__', '__getattribute__', '__hash__', '__init__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__setattr__', '__str__']</p>

    2242. 

  2242. 	<ol start="8">

    2243. 

  2243. 		<li>

    2244. 

  2244. 		<p class="Step">Create instance of the Simple class:</p>

    2245. 

  2245. 		</li>

    2246. 

  2246. 	</ol>

    2247. 

  2247. 	<p class="TypedExample">s = Simple(10)</p>

    2248. 

  2248. 	<p class="Code-Background"></p>

    2249. 

  2249. 	<p class="TypedExample">print s</p>

    2250. 

  2250. 	<p class="Stepnonumbering">IronPython will output:</p>

    2251. 

  2251. 	<p class="Code-Highlighted">&gt;&gt;&gt; s = Simple(10)<br />

    2252. 

  2252. 	&gt;&gt;&gt; print s</p>

    2253. 

  2253. 	<p class="Code-Background">Simple&lt;10&gt;</p>

    2254. 

  2254. 	<ol start="9">

    2255. 

  2255. 		<li>

    2256. 

  2256. 		<p class="Step">You have just explored all the functionality currently available

    2257. 

  2257. 		in the Simple class. Exit IronPython and return back to the C# code to add

    2258. 

  2258. 		more functionality.</p>

    2259. 

  2259. 		</li>

    2260. 

  2260. 	</ol>

    2261. 

  2261. 	<h3><a name="T5.1.2">Task 2: Making the object enumerable</a></h3>

    2262. 

  2262. 	<ol>

    2263. 

  2263. 		<li>

    2264. 

  2264. 		<p class="Step">In Notepad, add more functionality to the Simple class.</p>

    2265. 

  2265. 		</li>

    2266. 

  2266. 		<li>

    2267. 

  2267. 		<p class="Step">First, inherit the Simple class from IEnumerable and implement

    2268. 

  2268. 		GetEnumerator() method. Use the C#&#39;s new &quot;yield return&quot; statement:</p>

    2269. 

  2269. 		</li>

    2270. 

  2270. 	</ol>

    2271. 

  2271. 	<p class="CodeSample">public class Simple : IEnumerable {<br>

    2272. 

  2272. 	<br />

    2273. 

  2273. &nbsp;&nbsp;&nbsp; private int data;<br />

    2274. 

  2274. &nbsp;&nbsp;&nbsp; public Simple(int data) {<br />

    2275. 

  2275. &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; this.data = data;<br />

    2276. 

  2276. &nbsp;&nbsp;&nbsp; }<br />

    2277. 

  2277. &nbsp;&nbsp;&nbsp; public override string ToString() {<br />

    2278. 

  2278. &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; return String.Format(&quot;Simple&lt;{0}&gt;&quot;, data);<br />

    2279. 

  2279. &nbsp;&nbsp;&nbsp; }<br />

    2280. 

  2280. &nbsp;<br>

    2281. 

  2281. 	&nbsp;&nbsp;&nbsp; public IEnumerator GetEnumerator()

    2282. 

  2282. 	{<br />

    2283. 

  2283. &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; for (int i = 0; i &lt; data; i ++) {<br />

    2284. 

  2284. &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; yield return

    2285. 

  2285. 	new Simple(i);<br />

    2286. 

  2286. &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; }<br />

    2287. 

  2287. &nbsp;&nbsp;&nbsp; }</p>

    2288. 

  2288. 	<p class="CodeSample">}</p>

    2289. 

  2289. 	<ol start="3">

    2290. 

  2290. 		<li>

    2291. 

  2291. 		<p class="Step">Save the changes, compile the code (csx), launch IronPython

    2292. 

  2292. 		Console (ip) and test the code:</p>

    2293. 

  2293. 		</li>

    2294. 

  2294. 	</ol>

    2295. 

  2295. 	<p class="TypedExample">import clr</p>

    2296. 

  2296. 	<p class="Code-Background"></p>

    2297. 

  2297. 	<p class="UserCode">clr.AddReferenceToFile(&quot;csextend.dll&quot;)</p>

    2298. 

  2298. 	<p class="HiddenCode">clr.AddReferenceToFile(&quot;csextend_5.1.2.dll&quot;)</p>

    2299. 

  2299. 	<p class="Code-Background"></p>

    2300. 

  2300. 	<p class="TypedExample">import Simple</p>

    2301. 

  2301. 	<p class="Code-Background"></p>

    2302. 

  2302. 	<p class="UserCode">dir(Simple)</p>

    2303. 

  2303. 	<p class="HiddenCode">set1 = set(dir(Simple))

    2304. 

  2304. set2 = set(dir(object))

    2305. 

  2305. list(set1-set2)</p>

    2306. 

  2306. 	<p class="HiddenOutput">

    2307. 

  2307. 

    2308. 

  2308. 	['GetEnumerator', '__iter__']</p>

    2309. 

  2309. 	<p class="Code-Highlighted">['Equals', 'GetEnumerator', 'GetHashCode', 'GetType', 'MemberwiseClone', 'ReferenceEquals', 'ToString', '__class__', '__delattr__', '__doc__', '__getattribute__', '__hash__', '__init__', '__iter__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__setattr__', '__str__']</p>

    2310. 

  2310. 	<p class="TypedExample">s = Simple(10)</p>

    2311. 

  2311. 	<p class="Code-Background"></p>

    2312. 

  2312. 	<p class="TypedExample">for i in s: print i</p>

    2313. 

  2313. 	<p class="Stepnonumbering">You will get the following output in the IronPython

    2314. 

  2314. 	console window:</p>

    2315. 

  2315. 	<p class="Code-Highlighted">&gt;&gt;&gt; import clr<br />

    2316. 

  2316. 	&gt;&gt;&gt; clr.AddReferenceToFile(&quot;csextend.dll&quot;)<br />

    2317. 

  2317. 	&gt;&gt;&gt; import Simple<br />

    2318. 

  2318. 	&gt;&gt;&gt; dir(Simple)<br />

    2319. 

  2319. 	&gt;&gt;&gt; s = Simple(10)</p>

    2320. 

  2320. 	<p class="Code-Highlighted">&gt;&gt;&gt; for i in s: print i</p>

    2321. 

  2321. 	<p class="Code-Background">Simple&lt;0&gt;<br />

    2322. 

  2322. 	Simple&lt;1&gt;<br />

    2323. 

  2323. 	Simple&lt;2&gt;<br />

    2324. 

  2324. 	Simple&lt;3&gt;<br />

    2325. 

  2325. 	Simple&lt;4&gt;<br />

    2326. 

  2326. 	Simple&lt;5&gt;<br />

    2327. 

  2327. 	Simple&lt;6&gt;<br />

    2328. 

  2328. 	Simple&lt;7&gt;<br />

    2329. 

  2329. 	Simple&lt;8&gt;<br />

    2330. 

  2330. 	Simple&lt;9&gt;</p>

    2331. 

  2331. 	<p class="StepNote">Notice that the dir() function now returned the GetEnumerator

    2332. 

  2332. 	method.</p>

    2333. 

  2333. 	<ol start="4">

    2334. 

  2334. 		<li>

    2335. 

  2335. 		<p class="Step">Exit IronPython and return back to the C# code to add more

    2336. 

  2336. 		functionality.</p>

    2337. 

  2337. 		</li>

    2338. 

  2338. 	</ol>

    2339. 

  2339. 	<h3><a name="T5.1.3">Task 3: Adding custom operator</a></h3>

    2340. 

  2340. 	<ol>

    2341. 

  2341. 		<li>

    2342. 

  2342. 		<p class="Step">Add the operator + method:</p>

    2343. 

  2343. 		</li>

    2344. 

  2344. 	</ol>

    2345. 

  2345. 	<p class="CodeSample">using System;<br />

    2346. 

  2346. 	using System.Collections;</br>

    2347. 

  2347. 	<br />

    2348. 

  2348. 	public class Simple : IEnumerable {<br />

    2349. 

  2349. &nbsp;&nbsp;&nbsp; private int data;<br />

    2350. 

  2350. &nbsp;&nbsp;&nbsp; public Simple(int data) {<br />

    2351. 

  2351. &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; this.data = data;<br />

    2352. 

  2352. &nbsp;&nbsp;&nbsp; }<br />

    2353. 

  2353. &nbsp;&nbsp;&nbsp; public override string ToString() {<br />

    2354. 

  2354. &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; return String.Format(&quot;Simple&lt;{0}&gt;&quot;, data);<br />

    2355. 

  2355. &nbsp;&nbsp;&nbsp; }<br />

    2356. 

  2356. &nbsp;&nbsp;&nbsp; public IEnumerator GetEnumerator() {<br />

    2357. 

  2357. &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; for (int i = 0; i &lt; data; i ++) {<br />

    2358. 

  2358. &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; yield return

    2359. 

  2359. 	new Simple(i);<br />

    2360. 

  2360. &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; }<br />

    2361. 

  2361. &nbsp;&nbsp;&nbsp; }<br />

    2362. 

  2362. &nbsp;</br>

    2363. 

  2363. 	&nbsp;&nbsp;&nbsp; public static Simple operator

    2364. 

  2364. 	+(Simple a, Simple b) {<br />

    2365. 

  2365. &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; return new Simple(a.data + b.data);<br />

    2366. 

  2366. &nbsp;&nbsp;&nbsp; }</br>

    2367. 

  2367. 	}</p>

    2368. 

  2368. 	<ol start="2">

    2369. 

  2369. 		<li>

    2370. 

  2370. 		<p class="Step">Return to the command prompt, compile the code (csx), launch

    2371. 

  2371. 		IronPython Console (ip) and test the code:</p>

    2372. 

  2372. 		</li>

    2373. 

  2373. 	</ol>

    2374. 

  2374. 	<p class="TypedExample">import clr</p>

    2375. 

  2375. 	<p class="Code-Background"></p>

    2376. 

  2376. 	<p class="UserCode">clr.AddReferenceToFile(&quot;csextend.dll&quot;)</p>

    2377. 

  2377. 	<p class="HiddenCode">clr.AddReferenceToFile(&quot;csextend_5.1.3.dll&quot;)</p>

    2378. 

  2378. 		<p class="Code-Background"></p>

    2379. 

  2379. 	<p class="TypedExample">import Simple</p>

    2380. 

  2380. 		<p class="Code-Background"></p>

    2381. 

  2381. 	<p class="UserCode">dir(Simple)</p>

    2382. 

  2382. 	<p class="HiddenCode">set1 = set(dir(Simple))

    2383. 

  2383. set2 = set(dir(object))

    2384. 

  2384. list(set1-set2)</p>

    2385. 

  2385. 	<p class="HiddenOutput">

    2386. 

  2386. 

    2387. 

  2387. 	['GetEnumerator', '__iter__', '__radd__', '__add__']</p>

    2388. 

  2388. 	<p class="TypedExample">a = Simple(10)</p>

    2389. 

  2389. 		<p class="Code-Background"></p>

    2390. 

  2390. 	<p class="TypedExample">b = Simple(20)</p>

    2391. 

  2391. 		<p class="Code-Background"></p>

    2392. 

  2392. 	<p class="TypedExample">a + b</p>

    2393. 

  2393. 	<p class="LooseVerify">Simple&lt;30</p>

    2394. 

  2394. 	<p class="Stepnonumbering">Notice that in the output of dir() call you will

    2395. 

  2395. 	now get additional methods __add__ and __radd__, Python&#39;s notion of custom operator

    2396. 

  2396. 	implementation:</p>

    2397. 

  2397. 	<p class="Code-Highlighted">&gt;&gt;&gt; import clr<br />

    2398. 

  2398. 	&gt;&gt;&gt; clr.AddReferenceToFile(&quot;csextend.dll&quot;)<br />

    2399. 

  2399. 	&gt;&gt;&gt; import Simple<br />

    2400. 

  2400. 	&gt;&gt;&gt; dir(Simple)<br />

    2401. 

  2401. 	&gt;&gt;&gt; a = Simple(10)<br />

    2402. 

  2402. 	&gt;&gt;&gt; b = Simple(20)</p>

    2403. 

  2403. 	<p class="Code-Highlighted">&gt;&gt;&gt; a + b<br />

    2404. 

  2404. 	&lt;Simple object at 0x000000000000002B [Simple&lt;30]</p>

    2405. 

  2405. 	<ol start="3">

    2406. 

  2406. 		<li>

    2407. 

  2407. 		<p class="Step">Exit IronPython and return back to the C# code to add more

    2408. 

  2408. 		functionality.</p>

    2409. 

  2409. 		</li>

    2410. 

  2410. 	</ol>

    2411. 

  2411. 	<h3><a name="T5.1.4">Task 4: Adding delegate</a></h3>

    2412. 

  2412. 	<ol>

    2413. 

  2413. 		<li>

    2414. 

  2414. 		<p class="Step">Add the definition of the delegate to the top of the C#

    2415. 

  2415. 		source file:</p>

    2416. 

  2416. 		</li>

    2417. 

  2417. 	</ol>

    2418. 

  2418. 	<p class="CodeSample">using System;<br />

    2419. 

  2419. 	using System.Collections;<br />

    2420. 

  2420. &nbsp;<br>

    2421. 

  2421.    public delegate int Transformer(int input);</p>

    2422. 

  2422. 	<ol start="2">

    2423. 

  2423. 		<li>

    2424. 

  2424. 		<p class="Step">Add &quot;Transform&quot; method to the Simple class that takes the

    2425. 

  2425. 		delegate as a parameter and invokes the delegate:</p>

    2426. 

  2426. 		</li>

    2427. 

  2427. 	</ol>

    2428. 

  2428. 	<p class="CodeSample">using System;<br />

    2429. 

  2429. 	using System.Collections;<br />

    2430. 

  2430. &nbsp;<br>

    2431. 

  2431. 	public delegate int Transformer(int input);<br>

    2432. 

  2432. 	<br />

    2433. 

  2433. 	public class Simple : IEnumerable {<br />

    2434. 

  2434. &nbsp;&nbsp;&nbsp; private int data;<br />

    2435. 

  2435. &nbsp;&nbsp;&nbsp; public Simple(int data) {<br />

    2436. 

  2436. &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; this.data = data;<br />

    2437. 

  2437. &nbsp;&nbsp;&nbsp; }<br>

    2438. 

  2438. 	<br />

    2439. 

  2439. &nbsp;&nbsp;&nbsp; public override string ToString() {<br />

    2440. 

  2440. &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; return String.Format(&quot;Simple&lt;{0}&gt;&quot;, data);<br />

    2441. 

  2441. &nbsp;&nbsp;&nbsp; }<br>

    2442. 

  2442. 	<br />

    2443. 

  2443. &nbsp;&nbsp;&nbsp; public IEnumerator GetEnumerator() {<br />

    2444. 

  2444. &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; for (int i = 0; i &lt; data; i ++) {<br />

    2445. 

  2445. &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; yield return

    2446. 

  2446. 	new Simple(i);<br />

    2447. 

  2447. &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; }<br />

    2448. 

  2448. &nbsp;&nbsp;&nbsp; }<br />

    2449. 

  2449. &nbsp;<br>

    2450. 

  2450. 	&nbsp;&nbsp;&nbsp; public int Transform(Transformer

    2451. 

  2451. 	t) {<br />

    2452. 

  2452. &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; return t(data);<br />

    2453. 

  2453. &nbsp;&nbsp;&nbsp; }<br>

    2454. 

  2454. 	<br />

    2455. 

  2455. &nbsp;&nbsp;&nbsp; public static Simple operator +(Simple a, Simple b) {<br />

    2456. 

  2456. &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; return new Simple(a.data + b.data);<br />

    2457. 

  2457. &nbsp;&nbsp;&nbsp; }<br />

    2458. 

  2458. 	}</p>

    2459. 

  2459. 	<ol start="3">

    2460. 

  2460. 		<li>

    2461. 

  2461. 		<p class="Step">Return back to the SDK command prompt, compile the code

    2462. 

  2462. 		(csx), launch IronPython Console (ip) and test the code:</p>

    2463. 

  2463. 		</li>

    2464. 

  2464. 	</ol>

    2465. 

  2465. 	<p class="TypedExample">import clr</p>

    2466. 

  2466. 	<p class="Code-Background"></p>

    2467. 

  2467. 	<p class="UserCode">clr.AddReferenceToFile(&quot;csextend.dll&quot;)</p>

    2468. 

  2468. 	<p class="HiddenCode">clr.AddReferenceToFile(&quot;csextend_5.1.4.dll&quot;)</p>

    2469. 

  2469. 	<p class="Code-Background"></p>

    2470. 

  2470. 	<p class="TypedExample">import Simple</p>

    2471. 

  2471. 	<p class="Code-Background"></p>

    2472. 

  2472. 	<p class="TypedExample">a = Simple(10)</p>

    2473. 

  2473. 	<p class="Code-Background"></p>

    2474. 

  2474. 	<p class="TypedExample">def X(i):<br>

    2475. 

  2475. &nbsp;&nbsp;&nbsp; return i + 100</p>

    2476. 

  2476. 	<p class="Code-Background"></p>

    2477. 

  2477. 	<p class="TypedExample">a.Transform(X)</p>

    2478. 

  2478. 	<p class="Stepnonumbering">The function X is getting passed as the delegate

    2479. 

  2479. 	to the Simple&#39;s Transform method. You will get following output:</p>

    2480. 

  2480. 	<p class="Code-Highlighted">&gt;&gt;&gt; import clr<br />

    2481. 

  2481. 	&gt;&gt;&gt; clr.AddReferenceToFile(&quot;csextend.dll&quot;)<br />

    2482. 

  2482. 	&gt;&gt;&gt; import Simple<br />

    2483. 

  2483. 	&gt;&gt;&gt; a = Simple(10)</p>

    2484. 

  2484. 	<p class="Code-Highlighted">&gt;&gt;&gt; def X(i):<br />

    2485. 

  2485. 	...&nbsp;&nbsp;&nbsp;&nbsp; return i + 100<br />

    2486. 

  2486. 	...<br />

    2487. 

  2487. 	&gt;&gt;&gt; a.Transform(X)</p>

    2488. 

  2488. 	<p class="Code-Background">110</p>

    2489. 

  2489. 	<ol start="4">

    2490. 

  2490. 		<li>

    2491. 

  2491. 		<p class="Step">This concludes the C# extending example. If you are interested,

    2492. 

  2492. 		an interesting exercise is combining the debugging example and the extending

    2493. 

  2493. 		one. If you are inspired to do so, try debugging the script that you just

    2494. 

  2494. 		typed in. Debug the &quot;debugcsx.py&quot; script located in Tutorial directory and

    2495. 

  2495. 		place a breakpoint on the X function - you will see mixed call stack between

    2496. 

  2496. 		C# and Python.</p>

    2497. 

  2497. 		</li>

    2498. 

  2498. 	</ol>

    2499. 

  2499. 	<h2><a name="T5.2">Exercise 2: Extending using Visual Basic.NET</a></h2>

    2500. 

  2500. 	<p class="Body">In this exercise you will use Visual Basic .NET language to

    2501. 

  2501. 	build a class that supports enumeration, custom operators and delegates and

    2502. 

  2502. 	you will use that class from IronPython.  It’s worth noting that as Python does not contain protected

    2503. 

  2503.         class members, that these members get promoted to public class members when imported into Python.

    2504. 

  2504.         Private class members, however, will be invisible to Python when imported.</p>

    2505. 

  2505. 	<h3><a name="T5.2.1">Task 1: Implementing simple class - constructor and ToString</a></h3>

    2506. 

  2506. 	<ol>

    2507. 

  2507. 		<li>

    2508. 

  2508. 		<p class="Step">Open the &quot;SDK Command Prompt&quot; or &quot;Visual Studio 2005 Command

    2509. 

  2509. 		Prompt&quot; from the start menu.</p>

    2510. 

  2510. 		</li>

    2511. 

  2511. 		<li>

    2512. 

  2512. 		<p class="Step">Open the &quot;vbextend.vb&quot; file in notepad. The file is initially

    2513. 

  2513. 		empty</p>

    2514. 

  2514. 		</li>

    2515. 

  2515. 	</ol>

    2516. 

  2516. 	<p class="DOSExample">notepad vbextend.vb</p>

    2517. 

  2517. 	<ol start="3">

    2518. 

  2518. 		<li>

    2519. 

  2519. 		<p class="Step">Add Imports clauses at the beginning of the file:</p>

    2520. 

  2520. 		</li>

    2521. 

  2521. 	</ol>

    2522. 

  2522. 	<p class="CodeSample">Imports System<br />

    2523. 

  2523. 	Imports System.Collections</p>

    2524. 

  2524. 	<ol start="4">

    2525. 

  2525. 		<li>

    2526. 

  2526. 		<p class="Step">Define a simple class:</p>

    2527. 

  2527. 		</li>

    2528. 

  2528. 	</ol>

    2529. 

  2529. 	<p class="CodeSample">Public Class Simple<br />

    2530. 

  2530. &nbsp;&nbsp;&nbsp; Private data As Integer<br />

    2531. 

  2531. 	<br />

    2532. 

  2532. &nbsp;&nbsp;&nbsp; Public Sub New(ByVal data As Integer)<br />

    2533. 

  2533. &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; Me.data = data<br />

    2534. 

  2534. &nbsp;&nbsp;&nbsp; End Sub<br />

    2535. 

  2535. 	<br />

    2536. 

  2536. &nbsp;&nbsp;&nbsp; Overrides Function ToString() As String<br />

    2537. 

  2537. &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; Return String.Format(&quot;Simple&lt;{0}&gt;&quot;, data)<br />

    2538. 

  2538. &nbsp;&nbsp;&nbsp; End Function<br />

    2539. 

  2539. &nbsp;</p>

    2540. 

  2540. 	<p class="CodeSample">End Class</p>

    2541. 

  2541. 	<ol start="5">

    2542. 

  2542. 		<li>

    2543. 

  2543. 		<p class="Step">Switch back to the SDK Command Prompt window and build the

    2544. 

  2544. 		code using the available vbx.bat (Visual Basic extension):</p>

    2545. 

  2545. 		</li>

    2546. 

  2546. 	</ol>

    2547. 

  2547. 	<p class="DOSExample">vbx</p>

    2548. 

  2548. 	<ol start="6">

    2549. 

  2549. 		<li>

    2550. 

  2550. 		<p class="Step">Start the IronPython console from the tutorial directory

    2551. 

  2551. 		(see <a href="#Intro">Introduction</a> for details).</p>

    2552. 

  2552. 		</li>

    2553. 

  2553. 	</ol>

    2554. 

  2554. 	<ol start="7">

    2555. 

  2555. 		<li>

    2556. 

  2556. 		<p class="Step">Load the dll that you just built (vbextend.dll) into IronPython.

    2557. 

  2557. 		Then explore the Simple class using built-in dir() function:</p>

    2558. 

  2558. 		</li>

    2559. 

  2559. 	</ol>

    2560. 

  2560. 	<p class="TypedExample">import clr</p>

    2561. 

  2561. 	<p class="Code-Background"></p>

    2562. 

  2562. 	<p class="UserCode">clr.AddReferenceToFile(&quot;vbextend.dll&quot;)</p>

    2563. 

  2563. 	<p class="HiddenCode">clr.AddReferenceToFile(&quot;vbextend_5.2.1.dll&quot;)</p>

    2564. 

  2564. 	<p class="Code-Background"></p>

    2565. 

  2565. 	<p class="TypedExample">import Simple</p>

    2566. 

  2566. 	<p class="Code-Background"></p>

    2567. 

  2567. 	<p class="UserCode">dir(Simple)</p>

    2568. 

  2568. 	<p class="HiddenCode">set1 = set(dir(Simple))

    2569. 

  2569. set2 = set(dir(object))

    2570. 

  2570. list(set1-set2)</p>

    2571. 

  2571. 	<p class="HiddenOutput">

    2572. 

  2572. 

    2573. 

  2573. 	[]</p>

    2574. 

  2574. 	<p class="Stepnonumbering">You will see following output:</p>

    2575. 

  2575. 	<p class="Code-Highlighted">&gt;&gt;&gt; import clr<br />

    2576. 

  2576. 	&gt;&gt;&gt; clr.AddReferenceToFile(&quot;vbextend.dll&quot;)<br />

    2577. 

  2577. 	&gt;&gt;&gt; import Simple<br />

    2578. 

  2578. 	&gt;&gt;&gt; dir(Simple)</p>

    2579. 

  2579. 	<p class="Code-Highlighted">['Equals', 'GetHashCode', 'GetType', 'MemberwiseClone', 'ReferenceEquals', 'ToString', '__class__', '__delattr__', '__doc__', '__getattribute__', '__hash__', '__init__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__setattr__', '__str__']</p>

    2580. 

  2580. 	<ol start="8">

    2581. 

  2581. 		<li>

    2582. 

  2582. 		<p class="Step">Create instance of the Simple class:</p>

    2583. 

  2583. 		</li>

    2584. 

  2584. 	</ol>

    2585. 

  2585. 	<p class="TypedExample">s = Simple(10)</p>

    2586. 

  2586. 	<p class="Code-Background"></p>

    2587. 

  2587. 	<p class="TypedExample">print s</p>

    2588. 

  2588. 	<p class="Stepnonumbering">IronPython will output:</p>

    2589. 

  2589. 	<p class="Code-Highlighted">&gt;&gt;&gt; s = Simple(10)<br />

    2590. 

  2590. 	&gt;&gt;&gt; print s</p>

    2591. 

  2591. 	<p class="Code-Background">Simple&lt;10&gt;</p>

    2592. 

  2592. 	<ol start="9">

    2593. 

  2593. 		<li>

    2594. 

  2594. 		<p class="Step">You just have explored all the functionality available in

    2595. 

  2595. 		the Simple class. Exit IronPython and return back to the Visual Basic code

    2596. 

  2596. 		to add more functionality.</p>

    2597. 

  2597. 		</li>

    2598. 

  2598. 	</ol>

    2599. 

  2599. 	<h3><a name="T5.2.2">Task 2: Making the object enumerable</a></h3>

    2600. 

  2600. 	<ol>

    2601. 

  2601. 		<li>

    2602. 

  2602. 		<p class="Step">Back in Notepad, add more functionality to the vbextend.vb,

    2603. 

  2603. 		Simple class</p>

    2604. 

  2604. 		</li>

    2605. 

  2605. 		<li>

    2606. 

  2606. 		<p class="Step">First, inherit the Simple class from IEnumerable and implement

    2607. 

  2607. 		GetEnumerator() method. Unlike C#, Visual Basic does not offer the yield

    2608. 

  2608. 		keyword so implementing IEnumerable interface requires adding a helper class

    2609. 

  2609. 		SimpleEnum:</p>

    2610. 

  2610. 		</li>

    2611. 

  2611. 	</ol>

    2612. 

  2612. 	<p class="CodeSample">Imports System<br />

    2613. 

  2613. 	Imports System.Collections<br />

    2614. 

  2614. &nbsp;</p>

    2615. 

  2615. 	<p class="CodeSample">Public Class SimpleEnum<br />

    2616. 

  2616. &nbsp;&nbsp;&nbsp; Implements IEnumerator<br />

    2617. 

  2617. 	<br />

    2618. 

  2618. &nbsp;&nbsp;&nbsp; Private data As Integer<br />

    2619. 

  2619. &nbsp;&nbsp;&nbsp; Private curr As Integer<br />

    2620. 

  2620. 	<br />

    2621. 

  2621. &nbsp;&nbsp;&nbsp; Public Sub New(ByVal data As Integer)<br />

    2622. 

  2622. &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; Me.data = data<br />

    2623. 

  2623. &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; Me.curr = -1<br />

    2624. 

  2624. &nbsp;&nbsp;&nbsp; End Sub<br />

    2625. 

  2625. 	<br />

    2626. 

  2626. &nbsp;&nbsp;&nbsp; Public ReadOnly Property Current() As Object _<br />

    2627. 

  2627. &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; Implements IEnumerator.Current<br />

    2628. 

  2628. &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; Get<br />

    2629. 

  2629. &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; Return New Simple(curr)<br />

    2630. 

  2630. &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; End Get<br />

    2631. 

  2631. &nbsp;&nbsp;&nbsp; End Property<br />

    2632. 

  2632. 	<br />

    2633. 

  2633. &nbsp;&nbsp;&nbsp; Public Function MoveNext() As Boolean _<br />

    2634. 

  2634. &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;

    2635. 

  2635. 	Implements IEnumerator.MoveNext<br />

    2636. 

  2636. &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; curr += 1<br />

    2637. 

  2637. &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; Return curr &lt; data<br />

    2638. 

  2638. &nbsp;&nbsp;&nbsp; End Function<br />

    2639. 

  2639. 	<br />

    2640. 

  2640. &nbsp;&nbsp;&nbsp; Public Sub Reset() Implements IEnumerator.Reset<br />

    2641. 

  2641. &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; curr = -1<br />

    2642. 

  2642. &nbsp;&nbsp;&nbsp; End Sub<br />

    2643. 

  2643. 	End Class</p>

    2644. 

  2644. 	<p class="CodeSample"><br />

    2645. 

  2645. 	Public Class Simple</p>

    2646. 

  2646. 	<p class="CodeSample">&nbsp;&nbsp;&nbsp; Implements IEnumerable</p>

    2647. 

  2647. 	<p class="CodeSample">&nbsp;&nbsp;&nbsp; Private data As Integer<br />

    2648. 

  2648. 	<br />

    2649. 

  2649. &nbsp;&nbsp;&nbsp; Public Sub New(ByVal data As Integer)<br />

    2650. 

  2650. &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; Me.data = data<br />

    2651. 

  2651. &nbsp;&nbsp;&nbsp; End Sub<br />

    2652. 

  2652. 	<br />

    2653. 

  2653. &nbsp;&nbsp;&nbsp; Overrides Function ToString() As String<br />

    2654. 

  2654. &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; Return String.Format(&quot;Simple&lt;{0}&gt;&quot;, data)<br />

    2655. 

  2655. &nbsp;&nbsp;&nbsp; End Function<br />

    2656. 

  2656. &nbsp;</p>

    2657. 

  2657. 	<p class="CodeSample">&nbsp;&nbsp;&nbsp; Function GetEnumerator() As IEnumerator

    2658. 

  2658. 	_<br />

    2659. 

  2659. &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;

    2660. 

  2660. 	Implements IEnumerable.GetEnumerator<br />

    2661. 

  2661. &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; Return New SimpleEnum(data)<br />

    2662. 

  2662. &nbsp;&nbsp;&nbsp; End Function</p>

    2663. 

  2663. 	<p class="CodeSample"><br />

    2664. 

  2664. 	End Class</p>

    2665. 

  2665. 	<ol start="3">

    2666. 

  2666. 		<li>

    2667. 

  2667. 		<p class="Step">Compile the code (vbx), launch IronPython Console (ip) and

    2668. 

  2668. 		test the code:</p>

    2669. 

  2669. 		</li>

    2670. 

  2670. 	</ol>

    2671. 

  2671. 	<p class="TypedExample">import clr</p>

    2672. 

  2672. 	<p class="Code-Background"></p>

    2673. 

  2673. 	<p class="UserCode">clr.AddReferenceToFile(&quot;vbextend.dll&quot;)</p>

    2674. 

  2674. 	<p class="HiddenCode">clr.AddReferenceToFile(&quot;vbextend_5.2.2.dll&quot;)</p>

    2675. 

  2675. 	<p class="Code-Background"></p>

    2676. 

  2676. 	<p class="TypedExample">import Simple</p>

    2677. 

  2677. 	<p class="Code-Background"></p>

    2678. 

  2678. 	<p class="UserCode">dir(Simple)</p>

    2679. 

  2679. 	<p class="HiddenCode">set1 = set(dir(Simple))

    2680. 

  2680. set2 = set(dir(object))

    2681. 

  2681. list(set1-set2)</p>

    2682. 

  2682. 	<p class="HiddenOutput">

    2683. 

  2683. 

    2684. 

  2684. 	['GetEnumerator', '__iter__']</p>

    2685. 

  2685. 	<p class="TypedExample">s = Simple(10)</p>

    2686. 

  2686. 	<p class="Code-Background"></p>

    2687. 

  2687. 	<p class="TypedExample">for i in s: print i</p>

    2688. 

  2688. 	<p class="Stepnonumbering">You will get the following output in the IronPython

    2689. 

  2689. 	console window:</p>

    2690. 

  2690. 	<p class="Code-Highlighted">&gt;&gt;&gt; import clr<br />

    2691. 

  2691. 	&gt;&gt;&gt; clr.AddReferenceToFile(&quot;vbextend.dll&quot;)<br />

    2692. 

  2692. 	&gt;&gt;&gt; import Simple<br />

    2693. 

  2693. 	&gt;&gt;&gt; dir(Simple)<br />

    2694. 

  2694. 	&gt;&gt;&gt; s = Simple(10)</p>

    2695. 

  2695. 	<p class="Code-Highlighted">&gt;&gt;&gt; for i in s: print i</p>

    2696. 

  2696. 	<p class="Code-Background">Simple&lt;0&gt;<br />

    2697. 

  2697. 	Simple&lt;1&gt;<br />

    2698. 

  2698. 	Simple&lt;2&gt;<br />

    2699. 

  2699. 	Simple&lt;3&gt;<br />

    2700. 

  2700. 	Simple&lt;4&gt;<br />

    2701. 

  2701. 	Simple&lt;5&gt;<br />

    2702. 

  2702. 	Simple&lt;6&gt;<br />

    2703. 

  2703. 	Simple&lt;7&gt;<br />

    2704. 

  2704. 	Simple&lt;8&gt;<br />

    2705. 

  2705. 	Simple&lt;9&gt;</p>

    2706. 

  2706. 	<p class="Normal">&nbsp;</p>

    2707. 

  2707. 	<p class="StepNote">Notice that the dir() function now returned the GetEnumerator

    2708. 

  2708. 	method.</p>

    2709. 

  2709. 	<ol start="4">

    2710. 

  2710. 		<li>

    2711. 

  2711. 		<p class="Step">Exit IronPython and return back to the Visual Basic code

    2712. 

  2712. 		to add more functionality.</p>

    2713. 

  2713. 		</li>

    2714. 

  2714. 	</ol>

    2715. 

  2715. 	<h3><a name="T5.2.3">Task 3: Adding custom operator</a></h3>

    2716. 

  2716. 	<ol>

    2717. 

  2717. 		<li>

    2718. 

  2718. 		<p class="Step">Add the operator + method to the Simple class:</p>

    2719. 

  2719. 		</li>

    2720. 

  2720. 	</ol>

    2721. 

  2721. 	<p class="CodeSample">Public Class Simple<br />

    2722. 

  2722. &nbsp;&nbsp;&nbsp; Implements IEnumerable<br />

    2723. 

  2723. &nbsp;&nbsp;&nbsp; Private data As Integer<br />

    2724. 

  2724. 	<br />

    2725. 

  2725. &nbsp;&nbsp;&nbsp; Public Sub New(ByVal data As Integer)<br />

    2726. 

  2726. &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; Me.data = data<br />

    2727. 

  2727. &nbsp;&nbsp;&nbsp; End Sub<br />

    2728. 

  2728. 	<br />

    2729. 

  2729. &nbsp;&nbsp;&nbsp; Overrides Function ToString() As String<br />

    2730. 

  2730. &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; Return String.Format(&quot;Simple&lt;{0}&gt;&quot;, data)<br />

    2731. 

  2731. &nbsp;&nbsp;&nbsp; End Function<br />

    2732. 

  2732. 	<br />

    2733. 

  2733. &nbsp;&nbsp;&nbsp; Function GetEnumerator() As IEnumerator _<br />

    2734. 

  2734. &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;

    2735. 

  2735. 	Implements IEnumerable.GetEnumerator<br />

    2736. 

  2736. &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; Return New SimpleEnum(data)<br />

    2737. 

  2737. &nbsp;&nbsp;&nbsp; End Function<br />

    2738. 

  2738. &nbsp;</p>

    2739. 

  2739. 	<p class="CodeSample">&nbsp;&nbsp;&nbsp; Shared Operator +(ByVal a As

    2740. 

  2740. 	Simple, ByVal b As Simple) As Simple<br />

    2741. 

  2741. &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; Return New Simple(a.data + b.data)<br />

    2742. 

  2742. &nbsp;&nbsp;&nbsp; End Operator</p>

    2743. 

  2743. 	<p class="CodeSample"><br />

    2744. 

  2744. 	End Class</p>

    2745. 

  2745. 	<ol start="2">

    2746. 

  2746. 		<li>

    2747. 

  2747. 		<p class="Step">Compile the code (vbx), launch IronPython Console (ip) and

    2748. 

  2748. 		test the code:</p>

    2749. 

  2749. 		</li>

    2750. 

  2750. 	</ol>

    2751. 

  2751. 	<p class="TypedExample">import clr</p>

    2752. 

  2752. 	<p class="Code-Background"></p>

    2753. 

  2753. 	<p class="UserCode">clr.AddReferenceToFile(&quot;vbextend.dll&quot;)</p>

    2754. 

  2754. 	<p class="HiddenCode">clr.AddReferenceToFile(&quot;vbextend_5.2.3.dll&quot;)</p>

    2755. 

  2755. 	<p class="Code-Background"></p>

    2756. 

  2756. 	<p class="TypedExample">import Simple</p>

    2757. 

  2757. 	<p class="Code-Background"></p>

    2758. 

  2758. 	<p class="UserCode">dir(Simple)</p>

    2759. 

  2759. 	<p class="HiddenCode">set1 = set(dir(Simple))

    2760. 

  2760. set2 = set(dir(object))

    2761. 

  2761. list(set1-set2)</p>

    2762. 

  2762. 	<p class="HiddenOutput">

    2763. 

  2763. 

    2764. 

  2764. 	['GetEnumerator', '__iter__', '__radd__', '__add__']</p>

    2765. 

  2765. 	<p class="TypedExample">a = Simple(10)</p>

    2766. 

  2766. 	<p class="Code-Background"></p>

    2767. 

  2767. 	<p class="TypedExample">b = Simple(20)</p>

    2768. 

  2768. 	<p class="Code-Background"></p>

    2769. 

  2769. 	<p class="TypedExample">a + b</p>

    2770. 

  2770. 	<p class="LooseVerify">Simple&lt;30</p>

    2771. 

  2771. 	<p class="Stepnonumbering">Notice that in the output of dir() call you will

    2772. 

  2772. 	now get additional methods __add__ and __radd__, Python&#39;s notion of custom operator

    2773. 

  2773. 	implementation:</p>

    2774. 

  2774. 	<p class="Code-Highlighted">&gt;&gt;&gt; import clr<br />

    2775. 

  2775. 	&gt;&gt;&gt; clr.AddReferenceToFile(&quot;vbextend.dll&quot;)<br />

    2776. 

  2776. 	&gt;&gt;&gt; import Simple<br />

    2777. 

  2777. 	&gt;&gt;&gt; dir(Simple)<br />

    2778. 

  2778. 	&gt;&gt;&gt; a = Simple(10)<br />

    2779. 

  2779. 	&gt;&gt;&gt; b = Simple(20)</p>

    2780. 

  2780. 	<p class="Code-Highlighted">&gt;&gt;&gt; a + b<br>

    2781. 

  2781. 	&lt;Simple object at 0x000000000000002B [Simple&lt;30]</p>

    2782. 

  2782. 	<ol start="3">

    2783. 

  2783. 		<li>

    2784. 

  2784. 		<p class="Step">Exit IronPython and return back to the Visual Basic .NET

    2785. 

  2785. 		code to add more functionality.</p>

    2786. 

  2786. 		</li>

    2787. 

  2787. 	</ol>

    2788. 

  2788. 	<h3><a name="T5.2.4">Task 4: Adding delegate</a></h3>

    2789. 

  2789. 	<ol>

    2790. 

  2790. 		<li>

    2791. 

  2791. 		<p class="Step">Add the definition of the delegate to the top of the Visual

    2792. 

  2792. 		Basic source file:</p>

    2793. 

  2793. 		</li>

    2794. 

  2794. 	</ol>

    2795. 

  2795. 	<p class="CodeSample">Imports System<br />

    2796. 

  2796. 	Imports System.Collections<br />

    2797. 

  2797. &nbsp;</p>

    2798. 

  2798. 	<p class="CodeSample">Public Delegate Function Transformer(ByVal input

    2799. 

  2799. 	As Integer) As Integer</p>

    2800. 

  2800. 	<ol start="2">

    2801. 

  2801. 		<li>

    2802. 

  2802. 		<p class="Step">Add &quot;Transform&quot; method to the Simple class that takes the

    2803. 

  2803. 		delegate as a parameter and invokes the delegate:</p>

    2804. 

  2804. 		</li>

    2805. 

  2805. 	</ol>

    2806. 

  2806. 	<p class="CodeSample">Public Class Simple<br />

    2807. 

  2807. &nbsp;&nbsp;&nbsp; Implements IEnumerable<br />

    2808. 

  2808. &nbsp;&nbsp;&nbsp; Private data As Integer<br />

    2809. 

  2809. 	<br />

    2810. 

  2810. &nbsp;&nbsp;&nbsp; Public Sub New(ByVal data As Integer)<br />

    2811. 

  2811. &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; Me.data = data<br />

    2812. 

  2812. &nbsp;&nbsp;&nbsp; End Sub<br />

    2813. 

  2813. 	<br />

    2814. 

  2814. &nbsp;&nbsp;&nbsp; Overrides Function ToString() As String<br />

    2815. 

  2815. &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; Return String.Format(&quot;Simple&lt;{0}&gt;&quot;, data)<br />

    2816. 

  2816. &nbsp;&nbsp;&nbsp; End Function<br />

    2817. 

  2817. 	<br />

    2818. 

  2818. &nbsp;&nbsp;&nbsp; Function GetEnumerator() As IEnumerator _<br />

    2819. 

  2819. &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;

    2820. 

  2820. 	Implements IEnumerable.GetEnumerator<br />

    2821. 

  2821. &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; Return New SimpleEnum(data)<br />

    2822. 

  2822. &nbsp;&nbsp;&nbsp; End Function<br />

    2823. 

  2823. &nbsp;</p>

    2824. 

  2824. 	<p class="CodeSample">&nbsp;&nbsp;&nbsp; Function Transform(ByVal t As

    2825. 

  2825. 	Transformer) As Integer<br />

    2826. 

  2826. &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; Return t(data)<br />

    2827. 

  2827. &nbsp;&nbsp;&nbsp; End Function</p>

    2828. 

  2828. 	<p class="CodeSample"><br />

    2829. 

  2829. &nbsp;&nbsp;&nbsp; Shared Operator +(ByVal a As Simple, ByVal b As Simple) As Simple<br />

    2830. 

  2830. &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; Return New Simple(a.data + b.data)<br />

    2831. 

  2831. &nbsp;&nbsp;&nbsp; End Operator<br />

    2832. 

  2832. 	<br />

    2833. 

  2833. 	End Class</p>

    2834. 

  2834. 	<ol start="3">

    2835. 

  2835. 		<li>

    2836. 

  2836. 		<p class="Step">Return back to the SDK command prompt, compile the code

    2837. 

  2837. 		(vbx), launch IronPython Console (ip) and test the code:</p>

    2838. 

  2838. 		</li>

    2839. 

  2839. 	</ol>

    2840. 

  2840. 	<p class="TypedExample">import clr</p>

    2841. 

  2841. 	<p class="Code-Background"></p>

    2842. 

  2842. 	<p class="UserCode">clr.AddReferenceToFile(&quot;vbextend.dll&quot;)</p>

    2843. 

  2843. 	<p class="HiddenCode">clr.AddReferenceToFile(&quot;vbextend_5.2.4.dll&quot;)</p>

    2844. 

  2844. 	<p class="Code-Background"></p>

    2845. 

  2845. 	<p class="TypedExample">import Simple</p>

    2846. 

  2846. 	<p class="Code-Background"></p>

    2847. 

  2847. 	<p class="TypedExample">a = Simple(10)</p>

    2848. 

  2848. 	<p class="TypedExample">def X(i):<br>

    2849. 

  2849. &nbsp;&nbsp;&nbsp; return i + 100</p>

    2850. 

  2850. 	<p class="Code-Background"></p>

    2851. 

  2851. 	<p class="TypedExample">&nbsp;</p>

    2852. 

  2852. 	<p class="TypedExample">a.Transform(X)</p>

    2853. 

  2853. 	<p class="Code-Background"></p>

    2854. 

  2854. 	<p class="Stepnonumbering">The function X is getting passed as the delegate

    2855. 

  2855. 	to the Simple&#39;s Transform method. You will get following output:</p>

    2856. 

  2856. 	<p class="Code-Highlighted">&nbsp;</p>

    2857. 

  2857. 	<p class="Code-Highlighted">&gt;&gt;&gt; import clr<br />

    2858. 

  2858. 	&gt;&gt;&gt; clr.AddReferenceToFile(&quot;vbextend.dll&quot;)<br />

    2859. 

  2859. 	&gt;&gt;&gt; import Simple<br />

    2860. 

  2860. 	&gt;&gt;&gt; a = Simple(10)<br />

    2861. 

  2861. 	&gt;&gt;&gt; def X(i):</p>

    2862. 

  2862. 	<p class="Code-Highlighted">...&nbsp;&nbsp;&nbsp;&nbsp; return i + 100<br />

    2863. 

  2863. 	...<br />

    2864. 

  2864. 	&gt;&gt;&gt; a.Transform(X)</p>

    2865. 

  2865. 	<p class="Code-Background">110</p>

    2866. 

  2866. 	<p class="Normal"></p>

    2867. 

  2867. 	<ol start="4">

    2868. 

  2868. 		<li>

    2869. 

  2869. 		<p class="Step">This concludes the Visual Basic extending example. If you

    2870. 

  2870. 		are interested, an interesting exercise is combining the debugging example

    2871. 

  2871. 		and the extending one. If you are inspired to do so, try debugging the script

    2872. 

  2872. 		that you just typed in. Debug the &quot;debugvbx.py&quot; script located in the Tutorial

    2873. 

  2873. 		directory. Place a breakpoint on the X function - you will see mixed call

    2874. 

  2874. 		stack between Visual Basic and Python.</p>

    2875. 

  2875. 		</li>

    2876. 

  2876. 	</ol>

    2877. 

  2877. 	<p class="LabSummary">Tutorial Summary</p>

    2878. 

  2878. 	<p class="Body">The complete version of the csextend.cs and vbextend.vb files

    2879. 

  2879. 	are located in the Tutorial\Extend directory along with files csxtest.py and

    2880. 

  2880. 	vbxtest.py which contain the test code for the C# and Visual Basic .NET extensions

    2881. 

  2881. 	respectively.</p>

    2882. 

  2882. 	<p class="Body">The code to experiment with debugging of Python and C# or Visual

    2883. 

  2883. 	Basic code, use Python scripts debugcsx.py and debugvbx.py respectively.</p>

    2884. 

  2884. 	<p class="Body">In this tutorial you performed the following exercises.</p>

    2885. 

  2885. 	<ul>

    2886. 

  2886. 		<li>

    2887. 

  2887. 		<p class="Body"><a href="#T5.1">Extending IronPython using C# code</a></p>

    2888. 

  2888. 		</li>

    2889. 

  2889. 		<li>

    2890. 

  2890. 		<p class="Body"><a href="#T5.2">Extending IronPython using Visual Basic

    2891. 

  2891. 		.NET</a></p>

    2892. 

  2892. 		</li>

    2893. 

  2893. 	</ul>

    2894. 

  2894. 	<p class="Body">In this tutorial, you implemented a simple class to be used

    2895. 

  2895. 	from IronPython. You added the ability for IronPython to enumerate the class,

    2896. 

  2896. 	added an operator to it and support for delegate. The implementation was in

    2897. 

  2897. 	either C# or Visual Basic, or both.</p>

    2898. 

  2898. <h1><a name="T7">Tutorial 6: Using Visual Studio to Edit .py Files and Debug

    2899. 

  2899. Them</a></h1>

    2900. 

  2900. 	<p class="Body">There's very basic support for editing .py files in Visual

    2901. 

  2901. 	Studio (no coloring or expression completion), but you get .NET debugging support.&nbsp; This tutorial shows

    2902. 

  2902. 	you how to quickly set up Visual Studio to work on Python scripts in a

    2903. 

  2903. 	directory.</p>

    2904. 

  2904. 	<p class="Body">Estimated time to complete this tutorial: <b>5 minutes</b></p>

    2905. 

  2905. 	<p class="Body">The objective of this tutorial is to set up Visual Studio

    2906. 

  2906. 	for some basic tool support for debugging.</p>

    2907. 

  2907. 	<ul>

    2908. 

  2908. 		<li>

    2909. 

  2909. 		<p class="Body"><a href="#T6.1">Setting up Visual Studio for IronPython

    2910. 

  2910. 		Debugging</a></p>

    2911. 

  2911. 		</li>

    2912. 

  2912. 	</ul>

    2913. 

  2913. 	<h2><a name="T6.1">Exercise 1: Setting up Visual Studio for IronPython

    2914. 

  2914. 	Debugging</a></h2>

    2915. 

  2915. 	<p class="Body">In this exercise you will set up a Visual Studio solution

    2916. 

  2916. 	that you can use to edit .py files in a directory and debug them using the

    2917. 

  2917. 	Visual Studio .NET debugger.&nbsp; We will use the Tutorial directory as an

    2918. 

  2918. 	example, but you could save your solution anywhere.</p>

    2919. 

  2919. 	<h3><a name="T6.1.1">Task 1: Setting up Visual Studio for IronPython

    2920. 

  2920. 	Debugging</a></h3>

    2921. 

  2921. 	<ol>

    2922. 

  2922. 		<li>

    2923. 

  2923. 		<p class="Step">Open Visual Studio and close any solution or projects

    2924. 

  2924. 		you might have open.</p>

    2925. 

  2925. 		</li>

    2926. 

  2926. 		<li>

    2927. 

  2927. 		<p class="Step">Use the File-&gt;Open-&gt;Project/Solution ... command and

    2928. 

  2928. 		browse to the ipy.exe application in your IronPython installation

    2929. 

  2929. 		(c:\IronPython\ipy.exe is where the tutorial assumes you have it).</p>

    2930. 

  2930. 		</li>

    2931. 

  2931. 		<li>

    2932. 

  2932. 		<p class="Step">We will use the Tutorial directory as an example, and

    2933. 

  2933. 		we'll want to set it up as the working directory for loading .py

    2934. 

  2934. 		scripts.&nbsp; Right click on the ipy.exe project node in the Visual

    2935. 

  2935. 		Studio's solution

    2936. 

  2936. 		explorer and choose the Properties command.</p>

    2937. 

  2937. 		</li>

    2938. 

  2938. 		<li>

    2939. 

  2939. 		<p class="Step">In the properties dialog, you will fill in two

    2940. 

  2940. 		fields, the Command Arguments and Working Directory.&nbsp; For the

    2941. 

  2941. 		Command Arguments, enter &quot;-D first.py&quot;.&nbsp; The -D argument enables 

    2942. 

  2942.             application debugging. For the Working Directory,

    2943. 

  2943. 		enter the path to the Tutorial directory (c:\IronPython\Tutorial\ is

    2944. 

  2944. 		where we assume you have it).&nbsp; Click Apply and OK to confirm your

    2945. 

  2945. 		changes.</p>

    2946. 

  2946. 		</li>

    2947. 

  2947. 		<li>

    2948. 

  2948. 		<p class="Step">Now let's save the solution with the File-&gt;Save All ...

    2949. 

  2949. 		command.&nbsp; Save it to the Tutorial directory.</p>

    2950. 

  2950. 		</li>

    2951. 

  2951. 		<li>

    2952. 

  2952. 		<p class="Step">To test out our set up, use Ctrl+O to open a file.&nbsp;

    2953. 

  2953. 		Browse to the &quot;first.py&quot; file in the Tutorial directory.&nbsp; Place the

    2954. 

  2954. 		caret on the line that reads &quot;def add(a, b):&quot;, and press F9 to set a

    2955. 

  2955. 		breakpoint.</p>

    2956. 

  2956. 		</li>

    2957. 

  2957. 		<li>

    2958. 

  2958. 		<p class="Step">Press F5 to run the script, and you will hit the

    2959. 

  2959. 		breakpoint.&nbsp; If you Press F10, you will step through the file, but

    2960. 

  2960. 		all it does is load the definitions and set some variables before

    2961. 

  2961. 		terminating.</p>

    2962. 

  2962. 		</li>

    2963. 

  2963. 		<li>

    2964. 

  2964. 		<p class="Step">To see more stepping, we'll add a line to the file and

    2965. 

  2965. 		set another breakpoint.&nbsp; Add a line to the end of the file to

    2966. 

  2966. 		invoke the factorial function (&quot;factorial(5)&quot;).&nbsp; Add a breakpoint to the line that reads

    2967. 

  2967. 		&quot;if n &lt; 1: return 1&quot;.&nbsp; Now Press F5 to run the script.&nbsp;

    2968. 

  2968. 		Press F10 repeatedly and notice the locals window where

    2969. 

  2969. 		the parameter &quot;n&quot; decrements to 0 and then goes back up to 5 as the

    2970. 

  2970. 		recursion unwinds.&nbsp; You can also hover the mouse over the &quot;n&quot;

    2971. 

  2971. 		in the editor window to get a data tip of its value each time you stop at the

    2972. 

  2972. 		breakpoint.</p>

    2973. 

  2973. 		</li>

    2974. 

  2974. 	</ol>

    2975. 

  2975. <p class="Body">To work on other scripts, just change the Command Arguments

    2976. 

  2976. property for the ipy.exe project as we did above to name another script you want

    2977. 

  2977. to load on F5.&nbsp; You might also find it useful to go to the

    2978. 

  2978. Tools-&gt;Options... dialog and change a property on the Environment-&gt;Documents

    2979. 

  2979. page to show the open script files.&nbsp; If you check the property &quot;Show Miscellaneous Files in the Solution

    2980. 

  2980. Explorer&quot;, then you will get a list of the .py files you are editing.&nbsp; Each

    2981. 

  2981. time you open this solution again at a later time, you will see all the .py

    2982. 

  2982. files you developed while using this solution file.</p>

    2983. 

  2983. 	<p class="LabSummary">Tutorial Summary</p>

    2984. 

  2984. 	<p class="Body">In this tutorial you performed the following exercises.</p>

    2985. 

  2985. 	<ul>

    2986. 

  2986. 		<li>

    2987. 

  2987. 		<p class="Body"><a href="#T6.1">Setting up Visual Studio for IronPython

    2988. 

  2988. 		Debugging</a></p>

    2989. 

  2989. 		</li>

    2990. 

  2990. 	</ul>

    2991. 

  2991. 	<p class="Normal">In this tutorial you set up Visual Studio to work on

    2992. 

  2992. 	Python scripts in a directory and debug them.</p>

    2993. 

  2993. 

    2994. 

  2994. </body>

    2995. 

  2995. 

    2996. 

  2996. </html>

    2997. 

  2997.