PageRenderTime 100ms CodeModel.GetById 19ms RepoModel.GetById 0ms app.codeStats 0ms

/Languages/IronPython/Public/Tutorial/Tutorial.htm

http://github.com/IronLanguages/main
HTML | 2821 lines | 2795 code | 26 blank | 0 comment | 0 complexity | f3649312a6d6a8ae14c1d3d28296cd5b MD5 | raw file
Possible License(s): CPL-1.0, BSD-3-Clause, ISC, GPL-2.0, MPL-2.0-no-copyleft-exception 
    

  1. <html>
    2. 

  2. 

  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.NoVerify-Background { color : gray; }
    11. 

  11.     p.Code-Highlighted { color : gray; }
    12. 

  12.     p.NoVerify-Highlighted { color : gray; }
    13. 

  13.     p.CodeSample { color:blue; }
    14. 

  14.     p.DOSCommand { color:green; }
    15. 

  15.     p.ExceptionExample { color:green; }
    16. 

  16.     p.ExceptionOutput {display : none; }
    17. 

  17.     p.HiddenCode { display : none; }
    18. 

  18.     p.HiddenOutput {display : none; }
    19. 

  19.     p.LooseVerify { display : none; }
    20. 

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

  21.     p.TypedExample { color : green; }
    22. 

  22.     p.UserExample { color : green; }
    23. 

  23.     p.UserCode { color:green; }
    24. 

  24. </style>
    25. 

  25. 

  26. </head>
    27. 

  27. 

  28. <body lang="EN-US">
    29. 

  29. 

  30. <div class="Section1">
    31. 

  31.     <p class="Title1">IronPython Tutorial</p>
    32. 

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

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

  34.     <hr />
    35. 

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

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

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

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

  39.     copyright laws is the responsibility of the user. Without limiting the rights
    40. 

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

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

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

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

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

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

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

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

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

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

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

  51.     <p class="CopyrightText">© Microsoft Corporation. All rights reserved.</p>
    52. 

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

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

  54.     Directory, BizTalk, SQL Server, SharePoint, Outlook, PowerPoint, FrontPage,
    55. 

  55.     Visual Basic, Visual C++, Visual J++, Visual InterDev, Visual SourceSafe, Visual
    56. 

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

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

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

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

  60.     <hr />
    61. 

  61.     <p class="ContentsHeading">Contents</p>
    62. 

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

  90.     Spelling</a></p>
    91. 

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

  92.     Spelling</a></p>
    93. 

  93.     <p class="Toc1">Tutorial 4: <a href="#T4">Debugging IronPython programs</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 a 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 a custom operator</a></p>
    101. 

  101.     <p class="Toc3">Task 4: <a href="#T5.1.4">Adding a 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 a 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 a custom operator</a></p>
    106. 

  106.     <p class="Toc3">Task 4: <a href="#T5.2.4">Adding a 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 imperative, object-oriented, and functional programming, and also allows
    119. 

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

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

  121.     <p class="Normal">The goal of this tutorial is to quickly familiarize you with the
    122. 

  122.     IronPython console and to show you how to make use of the extensive .NET libraries
    123. 

  123.     available.&nbsp; This tutorial also shows you how to get started in more specialized
    124. 

  124.     areas such as interoperating with <a href="http://www.microsoft.com/com/default.mspx">COM</a>
    125. 

  125.     and extending IronPython with C# and/or Visual Basic.&nbsp; While we do explain some
    126. 

  126.     finer points of Python's syntax, this tutorial is NOT meant to be an introduction to
    127. 

  127.     Python itself, and if you're looking for that, we recommend you start with the tutorial at
    128. 

  128.     <a href="http://docs.python.org/tut/tut.html">www.python.org</a>
    129. 

  129.     or the often recommended book
    130. 

  130.     <a href="http://oreilly.com/catalog/9780596513986/"><i>Learning Python</i></a>
    131. 

  131.     by Mark Lutz and David Ascher. In addition,
    132. 

  132.     <a href="http://www.ironpythoninaction.com/"><i>IronPython in Action</i></a>
    133. 

  133.     by Michael Foord and Christian Muirhead is a definitive guide that includes
    134. 

  134.     a wealth of IronPython-specific information.<br><br>
    135. 

  135.     Some of the exercises in this tutorial require specific software installations.&nbsp;
    136. 

  136.     The prerequisites to successfully complete the whole tutorial are:</p>
    137. 

  137.     <ul type="disc">
    138. 

  138.         <li class="Normal">Microsoft .NET Framework Version 4.0 
    139. 

  139.         <ul type="circle">
    140. 

  140.             <li class="Normal">Required to run IronPython.</li>
    141. 

  141.             <li class="Normal">Download from
    142. 

  142.             <a href="http://www.microsoft.com/downloads/details.aspx?FamilyID=9cfb2d51-5ff4-4491-b0e5-b386f32c0992&amp;displaylang=en">here</a>.</li>
    143. 

  143.         </ul>
    144. 

  144.         </li>
    145. 

  145.     </ul>
    146. 

  146.     <ul>
    147. 

  147.         <li class="Normal">Visual Studio 2010
    148. 

  148. 		<ul type="circle">
    149. 

  149. 			<li class="Normal">Very useful for the C#/VB extending tutorials.</li>
    150. 

  150. 			<li class="Normal">Separate .NET 4.0 installation is not required if 
    151. 

  151. 			Visual Studio 2010 is installed.</li>
    152. 

  152. 			<li class="Normal">Download from
    153. 

  153.             <a href="http://www.microsoft.com/visualstudio">here</a>.</li>
    154. 

  154. 		</ul>
    155. 

  155. 		</li>
    156. 

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

  157.         on the internet)<ul>
    158. 

  158. 			<li>Required for the turorial &quot;<a href="#T1">Basic IronPython</a>&quot;
    159. 

  159.             and exercise &quot;<a href="#T1.3">Loading additional .NET Libraries</a>&quot;.</li>
    160. 

  160. 			<li>Download Mapack from
    161. 

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

  162.             to the Mapack.zip download is
    163. 

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

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

  165.             directory.</li>
    166. 

  166. 		</ul>
    167. 

  167. 		</li>
    168. 

  168.     </ul>
    169. 

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

  170.     <p class="Body">This tutorial assumes that the IronPython distribution was uncompressed
    171. 

  171.     into the directory C:\IronPython.&nbsp; Please note that your individual setup may
    172. 

  172.     vary.</p>
    173. 

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

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

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

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

  177.     and launch the console with the tutorial as your working directory (&gt;..\ipy.exe).</p>
    178. 

  178.     <a name="VS2005Note"></a>
    179. 

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

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

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

  182.     the IronPython interpreter and using the interactive environment to explore
    183. 

  183.     the .NET libraries.</p>
    184. 

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

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

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

  187.     with .NET libraries.</p>
    188. 

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

  189.     <ul>
    190. 

  190.         <li>
    191. 

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

  192.         </li>
    193. 

  193.         <li>
    194. 

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

  195.         from IronPython</a></p>
    196. 

  196.         </li>
    197. 

  197.         <li>
    198. 

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

  199.         </li>
    200. 

  200.     </ul>
    201. 

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

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

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

  204.     environment.</p>
    205. 

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

  206.     the import statement and exploring the Python interactive environment using
    207. 

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

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

  209.     <ol>
    210. 

  210.         <li>
    211. 

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

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

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

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

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

  216.         the tutorial directory&quot;.</p>
    217. 

  217.         </li>
    218. 

  218.     </ol>
    219. 

  219.     <p class="Code-Highlighted">IronPython 2.7 (2.7.10920.0) on .NET 4.0.30319.1<br />
    220. 

  220.     Type &quot;help&quot;, &quot;copyright&quot;, &quot;credits&quot; or &quot;license&quot; for more information.</p>
    221. 

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

  222.     <ol start="2">
    223. 

  223.         <li>
    224. 

  224.         <p class="Step">IronPython's console interfaces with the user in a standard
    225. 

  225.         Read-Eval-Print Loop, or REPL. This means that the console repeatedly reads
    226. 

  226.         user input, evaluates the statement, prints the result (if any), and awaits
    227. 

  227.         more input. Try it out by executing the simple statements listed below.
    228. 

  228.         <b>Note:</b> The input line starting with 'for' requires an extra press of
    229. 

  229.         the enter key afterwards as a signal to the interpreter that there are no
    230. 

  230.         more statements in the 'for' loop.</p>
    231. 

  231.         </li>
    232. 

  232.     </ol>
    233. 

  233.     <p class="TypedExample">2+2</p>
    234. 

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

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

  236.     <p class="TypedExample">x = 10</p>
    237. 

  237.     <p class="TypedExample">print x</p>
    238. 

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

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

  240.     the following text:</p>
    241. 

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

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

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

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

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

  246.     <p class="Code-Highlighted">...</p>
    247. 

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

  248.     1<br />
    249. 

  249.     2</p>
    250. 

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

  251.     &gt;&gt;&gt; print x</p>
    252. 

  252.     <p class="Code-Background"></p>
    253. 

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

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

  255.     <ol start="3">
    256. 

  256.         <li>
    257. 

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

  258.         used in function or class definitions.&nbsp; IronPython prompts for additional lines in a
    259. 

  259.         multi-line statement using:</p>
    260. 

  260.         </li>
    261. 

  261.     </ol>
    262. 

  262.     <p class="Code-Highlighted">...</p>
    263. 

  263.     <p class="Code-Background"></p>
    264. 

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

  265.     <p class="Stepnonumbering">One of the more unique aspects of Python is its sensitivity to whitespace at the
    266. 

  266.         beginning of a line. Unlike C, C# or Java, where blocks of code are grouped by curly brackets "{...}",
    267. 

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

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

  269.         constructs, including function and class definitions, the bodies of loops, 'if'...'elif'...'else' clauses,
    270. 

  270.         and 'try'...'except'...'finally' blocks. </p>
    271. 

  271.     <p class="Stepnonumbering">Define the 'add' function (note, you
    272. 

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

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

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

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

  276.     once more at this point</p>
    277. 

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

  278.     <p class="TypedExample">add('Iron', 'Python')</p>
    279. 

  279.     <p class="Stepnonumbering">&nbsp;</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 function dir(), 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 including 'sys', which is
    316. 

  316.         one of the most frequently used.&nbsp; Load the 'sys' module using the 'import' keyword:</p>
    317. 

  317.         </li>
    318. 

  318.     </ol>
    319. 

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

  320.     <ol start="4">
    321. 

  321.         <li>
    322. 

  322.         <p class="Step">The Python 'import' statement is similar to the 'using' statement
    323. 

  323.         of C# or 'Imports' statement of Visual Basic. The important difference is
    324. 

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

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

  326.         do that automatically, unless it is used in conjunction with the 'from'
    327. 

  327.         keyword (more on this later). To access the names or attributes in an imported
    328. 

  328.         module, prefix them with the module's name:</p>
    329. 

  329.         </li>
    330. 

  330.     </ol>
    331. 

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

  332.     <ol start="5">
    333. 

  333.         <li>
    334. 

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

  335.         </li>
    336. 

  336.     </ol>
    337. 

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

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

  339.     it contains the 'sys' module:</p>
    340. 

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

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

  342.     <ol start="6">
    343. 

  343.         <li>
    344. 

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

  345.         module:</p>
    346. 

  346.         </li>
    347. 

  347.     </ol>
    348. 

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

  349.     <p class="HiddenOutput">['__doc__', '__name__', '__package__', '__stderr__', '__stdin__', '__stdout__', 'api_version', 'argv', 'builtin_module_names', 'byteorder', 'call_tracing', 'callstats', 'copyright', 'displayhook', 'dllhandle', 'dont_write_bytecode', 'exc_clear', 'exc_info', 'exc_traceback', 'exc_type', 'exc_value', 'excepthook', 'exec_prefix', 'executable', 'exit', 'flags', 'float_info', 'getcheckinterval', 'getdefaultencoding', 'getfilesystemencoding', 'getrecursionlimit', 'getsizeof', 'gettrace', 'getwindowsversion', 'hexversion', 'maxint', 'maxsize', 'maxunicode', 'meta_path', 'modules', 'path', 'path_hooks', 'path_importer_cache', 'platform', 'prefix', 'ps1', 'ps2', 'py3kwarning', 'setcheckinterval', 'setdefaultencoding', 'setrecursionlimit', 'settrace', 'stderr', 'stdin', 'stdout', 'subversion', 'version', 'version_info', 'warnoptions', 'winver']</p>
    350. 

  350.     <ol start="7">
    351. 

  351.         <li>
    352. 

  352.         <p class="Step">Print the values of some of the 'sys' module attributes:</p>
    353. 

  353.         </li>
    354. 

  354.     </ol>
    355. 

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

  356.     <p class="LooseVerify">['.', '%DLR_ROOT%\\Test', '%DLR_ROOT%\\Languages\\IronPython\\Public\\Tutorial', '%DLR_ROOT%\\Languages\\IronPython\\Tests', '%DLR_ROOT%\\Test\\IronPythonTutorial', '%DLR_ROOT%\\bin\\Debug\\Lib', '%DLR_ROOT%\\bin\\Debug\\DLLs', '%DLR_ROOT%\\bin\\Debug']</p>
    357. 

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

  358.     <p class="LooseVerify">'%DLR_ROOT%\\bin\\Debug\\ipy.exe'</p>
    359. 

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

  360.     <p class="Normal">This task uses the module 'first.py' located in the Tutorial
    361. 

  361.     folder.</p>
    362. 

  362.     <ol>
    363. 

  363.         <li>
    364. 

  364.         <p class="Step">Import the 'first.py' module located in the Tutorial directory:</p>
    365. 

  365.         </li>
    366. 

  366.     </ol>
    367. 

  367.     <p class="TypedExample">import first</p>
    368. 

  368.     <p class="Code-Background"></p>
    369. 

  369.     <p class="Stepnonumbering">Because you launched ipy.exe from there, the Tutorial directory appears
    370. 

  370.     in sys.path, telling IronPython to look there in its search for 'first.py'.</p>
    371. 

  371.     <ol start="2">
    372. 

  372.         <li>
    373. 

  373.         <p class="Step">Explore the 'first' module using dir():</p>
    374. 

  374.         </li>
    375. 

  375.     </ol>
    376. 

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

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

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

  379.     <ol start="3">
    380. 

  380.         <li>
    381. 

  381.         <p class="Step">Print the documentation for the 'add' and 'factorial' functions,
    382. 

  382.         using __doc__ attribute:</p>
    383. 

  383.         </li>
    384. 

  384.     </ol>
    385. 

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

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

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

  388.     <p class="Stepnonumbering">We will use the __doc__ attribute later to explore .NET
    389. 

  389.     methods and their parameter types.</p>
    390. 

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

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

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

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

  394.     <ol start="4">
    395. 

  395.         <li>
    396. 

  396.         <p class="Step">Call the methods in the 'first' module and print the contents
    397. 

  397.         of the 'hi' attribute</p>
    398. 

  398.         </li>
    399. 

  399.     </ol>
    400. 

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

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

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

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

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

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

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

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

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

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

  410.     <ol start="5">
    411. 

  411.         <li>
    412. 

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

  413.         by Enter)</p>
    414. 

  414.         </li>
    415. 

  415.     </ol>
    416. 

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

  417.     <p class="Body">Much of IronPython's power arises from its ability to seamlessly
    418. 

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

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

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

  421.     IronPython. </p>
    422. 

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

  423.     <ol>
    424. 

  424.         <li>
    425. 

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

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

  427.         </li>
    428. 

  428.         <li>
    429. 

  429.         <p class="Step">Using the 'import' keyword, import the .NET System namespace:</p>
    430. 

  430.         </li>
    431. 

  431.     </ol>
    432. 

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

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

  434.     <ol start="3">
    435. 

  435.         <li>
    436. 

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

  437.         its properties:</p>
    438. 

  438.         </li>
    439. 

  439.     </ol>
    440. 

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

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

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

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

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

  445.     (with 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','Is64BitOperatingSystem','Is64BitProcess','MachineName','MemberwiseClone','NewLine','OSVersion','ProcessorCount','ReferenceEquals','SetEnvironmentVariable','SpecialFolder','SpecialFolderOption','StackTrace','SystemDirectory','SystemPageSize','TickCount','ToString','UserDomainName','UserInteractive','UserName','Version','WorkingSet','__all__','__class__','__delattr__','__doc__','__format__','__getattribute__','__hash__','__init__','__new__','__reduce__','__reduce_ex__','__repr__','__setattr__','__sizeof__','__str__','__subclasshook__']</p>
    448. 

  448.     <p class="NoVerify-Background">['CommandLine', 'CurrentDirectory', ... '__subclasshook__']</p>
    449. 

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

  450.     <p class="NoVerify-Background">&lt;System.OperatingSystem object at 0x000000000000002B [Microsoft Windows NT 6.0.6000.0]</p>
    451. 

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

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

  453.     <p class="NoVerify-Background">'C:\\IronPython\\ipy.exe'</p>
    454. 

  454.     <ol start="4">
    455. 

  455.         <li>
    456. 

  456.         <p class="Step">The import statement can also be used 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 this, then use dir() to explore the contents of the
    459. 

  459.         global namespace.</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. 

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

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

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

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

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

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

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

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

  479.     <p class="NoVerify-Background">
    480. 

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

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

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

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

  484.     <ol>
    485. 

  485.         <li>
    486. 

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

  487.         into the global namespace:</p>
    488. 

  488.         </li>
    489. 

  489.     </ol>
    490. 

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

  491.     <p class="Code-Background"></p>
    492. 

  492.     <ol start="2">
    493. 

  493.         <li>
    494. 

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

  495.         using dir():</p>
    496. 

  496.         </li>
    497. 

  497.     </ol>
    498. 

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

  499.     <p class="Code-Background"></p>
    500. 

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

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

  502. set2 = set(dir(object))
    503. 

  503. list(set1-set2)</p>
    504. 

  504.     <p class="HiddenOutput">
    505. 

  505.     
    506. 

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

  507.     <ol start="3">
    508. 

  508.         <li>
    509. 

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

  510.         </li>
    511. 

  511.     </ol>
    512. 

  512.     <p class="TypedExample">h['a'] = 'IronPython'</p>
    513. 

  513.     <p class="Code-Background"></p>
    514. 

  514.     <p class="TypedExample">h['b'] = 'Tutorial'</p>
    515. 

  515.     <p class="Code-Background"></p>
    516. 

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

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

  518.     the hash table elements.&nbsp; The same syntax applies to any indexable object (Arrays,
    519. 

  519.     Array lists etc):</p>
    520. 

  520.     <p class="TypedExample">h['a']</p>
    521. 

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

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

  523.     step will be:</p>
    524. 

  524.     <p class="NoVerify-Highlighted" style="page-break-after:avoid">&gt;&gt;&gt; h['a'] = 'IronPython'<br />
    525. 

  525.     &gt;&gt;&gt; h['b'] = 'Tutorial'</p>
    526. 

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

  527.     <p class="Code-Background">'IronPython'</p>
    528. 

  528.     <ol start="4">
    529. 

  529.         <li>
    530. 

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

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

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

  533.         </li>
    534. 

  534.     </ol>
    535. 

  535.     <p class="TypedExample">for e in h: print e.Key, ':', e.Value</p>
    536. 

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

  537.     <p class="Stepnonumbering">The expected output in the console is as follows. Note that
    538. 

  538.     the input line starting with 'for' requires an extra return or enter key press because
    539. 

  539.     the interpreter prompts for more statements in the loop's body.</p>
    540. 

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

  541.     ...</p>
    542. 

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

  543.     b : Tutorial</p>
    544. 

  544.     <ol start="5">
    545. 

  545.         <li>
    546. 

  546.         <p class="Step">You can initialize the collection classes using instances
    547. 

  547.         of the built-in list or tuple data types as arguments.&nbsp; You can
    548. 

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

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

  550.         </li>
    551. 

  551.     </ol>
    552. 

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

  553.     <p class="Code-Background"></p>
    554. 

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

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

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

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

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

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

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

  561.     ...</p>
    562. 

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

  563.     2<br />
    564. 

  564.     3</p>
    565. 

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

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

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

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

  569.     2<br />
    570. 

  570.     1</p>
    571. 

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

  572.     <ol>
    573. 

  573.         <li>
    574. 

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

  575.         namespace:</p>
    576. 

  576.         </li>
    577. 

  577.     </ol>
    578. 

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

  579.     <p class="Code-Background"></p>
    580. 

  580.     <ol start="2">
    581. 

  581.         <li>
    582. 

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

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

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

  585.         list of string:</p>
    586. 

  586.         </li>
    587. 

  587.     </ol>
    588. 

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

  589.         <p class="Code-Background"></p>
    590. 

  590.     <ol start="3">
    591. 

  591.         <li>
    592. 

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

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

  594.         </li>
    595. 

  595.     </ol>
    596. 

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

  597.         <p class="Code-Background"></p>
    598. 

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

  599.         <p class="Code-Background"></p>
    600. 

  600.     <ol start="4">
    601. 

  601.         <li>
    602. 

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

  603.         </li>
    604. 

  604.     </ol>
    605. 

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

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

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

  608.     <p class="Code-Background"></p>
    609. 

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

  610.     <p class="Code-Background"></p>
    611. 

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

  612.     <p class="Stepnonumbering">Obviously, adding non-strings will result in a type error:</p>
    613. 

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

  614.     <p class="NoVerify-Background">Traceback (most recent call last):<br />
    615. 

  615. &nbsp;&nbsp;File &quot;&lt;stdin&gt;&quot;, line 1, in &lt;module&gt;<br />
    616. 

  616. TypeError: expected str, got int<br /></p>
    617. 

  617.     <p class="Code-Highlighted">&gt;&gt;&gt; l.Add(2.5)</p>
    618. 

  618.     <p class="NoVerify-Background">Traceback (most recent call last):<br />
    619. 

  619. &nbsp;&nbsp;File &quot;&lt;stdin&gt;&quot;, line 1, in &lt;module&gt;<br />
    620. 

  620. TypeError: expected str, got float<br /></p>
    621. 

  621.     <p class="Code-Highlighted">&gt;&gt;&gt; l.Add([1,2,3])</p>
    622. 

  622.     <p class="NoVerify-Background">Traceback (most recent call last):<br />
    623. 

  623. &nbsp;&nbsp;File &quot;&lt;stdin&gt;&quot;, line 1, in &lt;module&gt;<br />
    624. 

  624. TypeError: expected str, got list<br /></p>
    625. 

  625.     <ol start="5">
    626. 

  626.         <li>
    627. 

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

  628.         </li>
    629. 

  629.     </ol>
    630. 

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

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

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

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

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

  635. Hi</p>
    636. 

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

  637. TypeError: expected str, got float
    638. 

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

  639.     <ol start="6">
    640. 

  640.         <li>
    641. 

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

  642.         by Enter)</p>
    643. 

  643.         </li>
    644. 

  644.     </ol>
    645. 

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

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

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

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

  649.     assemblies (see clr.References in Task 1).&nbsp; To add a reference to a .NET assembly,
    650. 

  650.     use the functions available in the built-in 'clr' module:</p>
    651. 

  651.     <ul>
    652. 

  652.         <li>
    653. 

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

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

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

  656.         for the kind of interactive exploration we see in this Tutorial. We recommend
    657. 

  657.         using the following functions in your code modules, since they provide more control
    658. 

  658.         over which assembly gets loaded.</p>
    659. 

  659.         </li>
    660. 

  660.         <li>
    661. 

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

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

  663.         file regardless of the assembly version. As a result, it doesn't guarantee
    664. 

  664.         that the correct assembly version is being loaded. To guarantee that correct
    665. 

  665.         assembly version is being loaded, use clr.AddReferenceByName. Moreover,
    666. 

  666.         AddReferenceToFile requires that the assembly be located in a
    667. 

  667.         directory listed in sys.path.</p>
    668. 

  668.         </li>
    669. 

  669.         <li>
    670. 

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

  671.         functionality to AddReferenceToFile. The difference is that it accepts
    672. 

  672.         absolute path and before loading the assembly, AddReferenceToFileAndPath
    673. 

  673.         adds the file path into sys.path.</p>
    674. 

  674.         </li>
    675. 

  675.         <li>
    676. 

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

  677.         specified by its full assembly name, for example: &quot;System.Xml, Version=2.0.0.0,
    678. 

  678.         Culture=neutral, PublicKeyToken=b77a5c561934e089&quot;.</p>
    679. 

  679.         </li>
    680. 

  680.         <li>
    681. 

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

  682.         assembly by specifying a partial assembly name. This function cannot guarantee
    683. 

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

  684.         to reference a specific version of the assembly.</p>
    685. 

  685.         </li>
    686. 

  686.     </ul>
    687. 

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

  688.     <ol>
    689. 

  689.         <li>
    690. 

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

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

  692.         </li>
    693. 

  693.         <li>
    694. 

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

  695.         the Xml components must be first added to IronPython.&nbsp; Reference System.Xml
    696. 

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

  697.         and after the call to &quot;clr.AddReference&quot; to see it change if you want):</p>
    698. 

  698.         </li>
    699. 

  699.     </ol>
    700. 

  700.     <p class="TypedExample">import clr</p>
    701. 

  701.     <p class="Code-Background"></p>
    702. 

  702.     <p class="TypedExample">clr.AddReference('System.Xml')</p>
    703. 

  703.     <p class="Code-Background"></p>
    704. 

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

  705.     <p class="Code-Background"></p>
    706. 

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

  707.     <p class="HiddenOutput">['ConformanceLevel','DtdProcessing','EntityHandling','Formatting','IHasXmlNode','IXmlLineInfo','IXmlNamespaceResolver','NameTable','NamespaceHandling','NewLineHandling','ReadState','Resolvers','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>
    708. 

  708.     <ol start="3">
    709. 

  709.         <li>
    710. 

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

  711.         as a parameter. The string parameter can
    712. 

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

  713.         over the assembly references, use the appropriate functions described
    714. 

  714.         above. </p>
    715. 

  715.         <p class="Step">For example, consider the following alternatives for the statement clr.AddReference('System.Xml') above:</p>
    716. 

  716.         </li>
    717. 

  717.     </ol>
    718. 

  718.     <p class="TypedExample">clr.AddReferenceByName('System.Xml, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089')</p>
    719. 

  719.     <p class="Code-Background"></p>
    720. 

  720.     <p class="TypedExample">clr.AddReferenceByPartialName('System.Xml')</p>
    721. 

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

  722.     <ol start="4">
    723. 

  723.         <li>
    724. 

  724.         <p class="Step">Load the XML file 'load.xml' into the XmlDocument. The
    725. 

  725.         xml file contains sample savegame data from the IronPython sample 'Puzzle' .
    726. 

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

  727.         </li>
    728. 

  728.     </ol>
    729. 

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

  730.     <p class="Code-Background"></p>
    731. 

  731.     <p class="TypedExample">d.Load('load.xml')</p>
    732. 

  732.     <p class="Code-Background"></p>
    733. 

  733.     <ol start="5">
    734. 

  734.         <li>
    735. 

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

  736.         </li>
    737. 

  737.     </ol>
    738. 

  738.     <p class="TypedExample">n = d.SelectNodes('//Puzzle/SavedGames/Game/@caption')</p>
    739. 

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

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

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

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

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

  744.     <p class="Code-Background">
    745. 

  745.     Seattle (default game)<br />
    746. 

  746.     New York<br />
    747. 

  747.     World<br />
    748. 

  748.     North America<br />
    749. 

  749.     </p>
    750. 

  750.     <ol start="6">
    751. 

  751.         <li>
    752. 

  752.         <p class="Step">(Optional) Import the 'xmlutil.py' module located in the
    753. 

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

  754.         contents of the Xml document:</p>
    755. 

  755.         </li>
    756. 

  756.     </ol>
    757. 

  757.     <p class="TypedExample">import xmlutil</p>
    758. 

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

  759.     <p class="HiddenOutput">#document None
    760. 

  760. #comment  *************************************************************************
    761. 

  761.  *
    762. 

  762.  * Copyright (c) Microsoft Corporation.&nbsp;
    763. 

  763.  *
    764. 

  764.  * This source code is subject to terms and conditions of the Apache License, Version 2.0. A&nbsp;
    765. 

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

  766.  * you cannot locate the  Apache License, Version 2.0, please send an email to&nbsp;
    767. 

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

  768.  * by the terms of the Apache License, Version 2.0.
    769. 

  769.  *
    770. 

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

  771.  *
    772. 

  772.  *
    773. 

  773.  * ***************************************************************************&nbsp;
    774. 

  774. Puzzle None
    775. 

  775. SavedGames None
    776. 

  776. Game None
    777. 

  777. caption Seattle (default game)
    778. 

  778. type a
    779. 

  779. y 714
    780. 

  780. x 327
    781. 

  781. level 11
    782. 

  782. dimension 3
    783. 

  783. Game None
    784. 

  784. caption New York
    785. 

  785. type r
    786. 

  786. y 1538
    787. 

  787. x 1205
    788. 

  788. level 12
    789. 

  789. dimension 3
    790. 

  790. Game None
    791. 

  791. caption World
    792. 

  792. type h
    793. 

  793. y 0
    794. 

  794. x 0
    795. 

  795. level 2
    796. 

  796. dimension 4
    797. 

  797. Game None
    798. 

  798. caption North America
    799. 

  799. type a
    800. 

  800. x 2
    801. 

  801. y 5
    802. 

  802. level 4
    803. 

  803. dimension 3
    804. 

  804. TopLeftPreviewTile None
    805. 

  805. x -3
    806. 

  806. y -3
    807. 

  807. dimension 3
    808. 

  808. level 5
    809. 

  809. Cache None
    810. 

  810. allow true</p>
    811. 

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

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

  813.     (yields) the XML nodes one by one to the caller, who is iterating over the generator.
    814. 

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

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

  816.     &nbsp;&nbsp;&nbsp; yield xml</br><br>
    817. 

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

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

  819. &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; if attrs:<br />
    820. 

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

  821.     &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;
    822. 

  822.     yield attr</br><br>
    823. 

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

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

  825.     &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;
    826. 

  826.     yield c</p>
    827. 

  827.     <ol start="7">
    828. 

  828.         <li>
    829. 

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

  830.         by Enter)</p>
    831. 

  831.         </li>
    832. 

  832.     </ol>
    833. 

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

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

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

  836.     for download details.</p>
    837. 

  837.     <ol>
    838. 

  838.         <li>
    839. 

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

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

  841.         </li>
    842. 

  842.         <li>
    843. 

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

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

  845.         </li>
    846. 

  846.     </ol>
    847. 

  847.     <p class="TypedExample">import clr</p>
    848. 

  848.     <p class="Code-Background"></p>
    849. 

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

  850.     <p class="Code-Background"></p>
    851. 

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

  852.     <p class="Code-Background"></p>
    853. 

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

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

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

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

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

  858.     &gt;&gt;&gt; dir()</p>
    859. 

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

  860.     <p class="StepNoNumbering"></p>
    861. 

  861.     <p class="StepNoNumbering">If you're having trouble getting this to work, make sure
    862. 

  862.     Mapack.dll is on the search path. One easy way to do this is to copy Mapack.dll into
    863. 

  863.     the Tutorial direcroty (or whichever directory you're running IronPython from).</p>
    864. 

  864.     <ol start="3">
    865. 

  865.         <li>
    866. 

  866.         <p class="Step">Instantiate the Matrix class:</p>
    867. 

  867.         </li>
    868. 

  868.     </ol>
    869. 

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

  870.     <p class="Code-Background"></p>
    871. 

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

  872.     step, you'll learn how to discover which constructors are available.</p>
    873. 

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

  874. &nbsp;&nbsp;File &quot;&lt;stdin&gt;&quot;, line 1, in &lt;module&gt;<br />
    875. 

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

  876.     <ol start="4">
    877. 

  877.         <li>
    878. 

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

  879.         Matrix constructors:</p>
    880. 

  880.         </li>
    881. 

  881.     </ol>
    882. 

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

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

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

  885.     __new__(cls:type, rows: int, columns: int, value: float)<br />
    886. 

  886.     __new__(cls:type, value: Array[Array[float]])
    887. 

  887.     </p>
    888. 

  888.     <ol start="5">
    889. 

  889.         <li>
    890. 

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

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

  892.         on .NET classes. </p>
    893. 

  893.         </li>
    894. 

  894.     </ol>
    895. 

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

  896.     <p class="Code-Background"></p>
    897. 

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

  898.     <p class="Code-Background"></p>
    899. 

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

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

  901.     <p class="TypedExample">print m</p>
    902. 

  902.     <p class="TypedExample">print n</p>
    903. 

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

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

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

  906.     &gt;&gt;&gt; print m</p>
    907. 

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

  908. 0 1.2<br />
    909. 

  909. </p>
    910. 

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

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

  912. 0<br />
    913. 

  913. </p>
    914. 

  914.     <ol start="6">
    915. 

  915.         <li>
    916. 

  916.         <p class="Step">(Optional) IronPython also supports overloaded operators.
    917. 

  917.         Matrix provides implementations of operators +, - (binary and unary), *,
    918. 

  918.         and equality. You can see the Python representation of these operators
    919. 

  919.         (__eq__, __add__, __mul__, __sub__, ...) using dir():</p>
    920. 

  920.         </li>
    921. 

  921.     </ol>
    922. 

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

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

  924. set2 = set(dir(object))
    925. 

  925. list(set1-set2)</p>
    926. 

  926.     <p class="HiddenOutput">
    927. 

  927.     
    928. 

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

  929.     <ol start="7">
    930. 

  930.         <li>
    931. 

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

  932.         </li>
    933. 

  933.     </ol>
    934. 

  934.     <p class="TypedExample">print m * n</p>
    935. 

  935.     <p class="TypedExample">print n.Transpose() * m</p>
    936. 

  936.     <p class="TypedExample">print m * 3</p>
    937. 

  937.     <p class="TypedExample">print n + -n</p>
    938. 

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

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

  940.     <p class="Code-Background">4.8<br />
    941. 

  941. 0<br /><br />
    942. 

  942. </p>
    943. 

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

  944.     <p class="Code-Background">4.8 0
    945. 

  945. <br /><br /></p>
    946. 

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

  947.     <p class="Code-Background">3.6 0<br />
    948. 

  948. 0 3.6<br /><br />
    949. 

  949. </p>
    950. 

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

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

  952. 0<br /><br />
    953. 

  953. </p>
    954. 

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

  955.     <ol start="8">
    956. 

  956.         <li>
    957. 

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

  958.         by Enter)</p>
    959. 

  959.         </li>
    960. 

  960.     </ol>
    961. 

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

  962.     <p class="BodyNote"><b>Note:</b> If you installed IronPython using the MSI installer file, then the Python
    963. 

  963.     standard library is already included, and this exercise does not apply. These steps are only necessary
    964. 

  964.     if you installed IronPython using the ZIP file, which does not include the library. In that case,
    965. 

  965.     this exercise explians how you can obtain Python and direct IronPython to the Python 
    966. 

  966.     standard library.<br /><br />
    967. 

  967.     If you're not sure how IronPython was installed, then attempt <a href="#T1.4.1.3">steps 3-4</a>
    968. 

  968.     below. If your output matches this tutorial's, then you already have access to the Python standard
    969. 

  969.     libraries, and this exercise may be skipped. If you get an ImportError message, then this exercise
    970. 

  970.     is necessary.</p>
    971. 

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

  972.     <ol>
    973. 

  973.         <li>
    974. 

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

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

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

  977.         default installer settings (e.g. installing to c:\python27).</p>
    978. 

  978.         </li>
    979. 

  979.         <li>
    980. 

  980.         <p class="Step">Create a file named 'site.py' and place it in your IronPython 'Lib'
    981. 

  981.         directory.&nbsp; There might be one there already, in which case you can simply edit
    982. 

  982.         it.&nbsp; This 'site.py' file is automatically executed every time you run IronPython,
    983. 

  983.         making it a convenient way to tell IronPython the location of Python's standard library.&nbsp; To
    984. 

  984.         do so, add the following code into IronPython's 'site.py'.&nbsp; (Replace
    985. 

  985.         c:\python27\lib with your actual path to the Python lib directory):</p>
    986. 

  986.         </li>
    987. 

  987.     </ol>
    988. 

  988.     <p class="TypedExample">import sys</p>
    989. 

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

  990.     <p class="SyntaxNote"><b>Syntax Note:</b> Preceding a string literal with 'r' tells
    991. 

  991.     Python to parse the string in "raw" mode, which does not require backslashes (\) to
    992. 

  992.     be escaped. This is helpful for the readability of certain strings, such as Windows
    993. 

  993.     paths.</p>
    994. 

  994.     <ol start="3">
    995. 

  995.         <li>
    996. 

  996.         <a name="T1.4.1.3"><p class="Step">Start the IronPython console from the tutorial directory
    997. 

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

  998.         </li>
    999. 

  999.         <li>
    1000. 

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

  1001.         IronPython, for example to get the current working directory.</p>
    1002. 

  1002.         </li>
    1003. 

  1003.     </ol>
    1004. 

  1004.     <p class="TypedExample">import os</p>
    1005. 

  1005.     <p class="Code-Background"></p>
    1006. 

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

  1007.     <p class="Stepnonumbering">Assuming you're using the standard IronPython installation
    1008. 

  1008.     directory, the output should look like this:</p>
    1009. 

  1009.     <p class="Code-Highlighted">&gt;&gt;&gt; import os<br />
    1010. 

  1010.     &gt;&gt;&gt; os.getcwd()<br /></p>
    1011. 

  1011.     <p class="Code-Background">'C:\\ironpython\\Tutorial'</p>
    1012. 

  1012.     <p class="LooseVerify">
    1013. 

  1013. 

  1014.     '%DLR_ROOT%\\Test\\IronPythonTutorial'</p>
    1015. 

  1015.     <p class="LabSummary">Tutorial Summary</p>
    1016. 

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

  1017.     <ul>
    1018. 

  1018.         <li>
    1019. 

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

  1020.         </li>
    1021. 

  1021.         <li>
    1022. 

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

  1023.         </li>
    1024. 

  1024.         <li>
    1025. 

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

  1026.         </li>
    1027. 

  1027.         <li>
    1028. 

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

  1029.         Library</a></p>
    1030. 

  1030.         </li>
    1031. 

  1031.     </ul>
    1032. 

  1032.     <p class="Body">In this tutorial, you became acquainted with IronPython's interactive
    1033. 

  1033.     console and learned a powerful Python development technique -- the use of dir() and __doc__
    1034. 

  1034.     to dynamically explore the environment.&nbsp; You learned to load and import
    1035. 

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

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

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

  1038.     learned how to access the standard Python libraries.</p>
    1039. 

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

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

  1041.     <p class="Body">A large part of IronPython's beauty lies in its capacity for dynamic-style
    1042. 

  1042.     development -- modifying the live application by adding functioning elements
    1043. 

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

  1044.     (i.e., adding a button to an existing form and adding functionality to handle the user's
    1045. 

  1045.     pressing the button).</p>
    1046. 

  1046.     <p class="Body">This tutorial will focus on creating delegates and handling
    1047. 

  1047.     events in IronPython, as well as creating Windows applications using Windows Forms and
    1048. 

  1048.     the new Windows Presentation Foundation, or WPF (formerly known as Avalon).</p>
    1049. 

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

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

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

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

  1053.     <ul>
    1054. 

  1054.         <li>
    1055. 

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

  1056.         </li>
    1057. 

  1057.         <li>
    1058. 

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

  1059.         </li>
    1060. 

  1060.         <li>
    1061. 

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

  1062.         (Avalon)</a></p>
    1063. 

  1063.         </li>
    1064. 

  1064.     </ul>
    1065. 

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

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

  1067.     learn how to explore event handler use. The event handler we'll use in this
    1068. 

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

  1069.     changes.</p>
    1070. 

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

  1071.     <ol>
    1072. 

  1072.         <li>
    1073. 

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

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

  1075.         </li>
    1076. 

  1076.         <li>
    1077. 

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

  1078.         </li>
    1079. 

  1079.     </ol>
    1080. 

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

  1081.     <p class="Code-Background"></p>
    1082. 

  1082.     <ol start="3">
    1083. 

  1083.         <li>
    1084. 

  1084.         <p class="Step">Create an instance of the FileSystemWatcher class and set its
    1085. 

  1085.         'Path' property to watch over the current directory:</p>
    1086. 

  1086.         </li>
    1087. 

  1087.     </ol>
    1088. 

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

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

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

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

  1092. set2 = set(dir(object))
    1093. 

  1093. list(set1-set2)</p>
    1094. 

  1094.     <p class="HiddenOutput">
    1095. 

  1095. 

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

  1097.     <p class="TypedExample">w.Path = '.'</p>
    1098. 

  1098.     <p class="Code-Background"></p>
    1099. 

  1099.     <ol start="4">
    1100. 

  1100.         <li>
    1101. 

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

  1102.         the events.&nbsp; Because we don't know yet what arguments the delegate will have,
    1103. 

  1103.         let's accept any number of arguments:</p>
    1104. 

  1104.         </li>
    1105. 

  1105.     </ol>
    1106. 

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

  1107.     <p class="Code-Background"></p>
    1108. 

  1108.     <p class="SyntaxNote"><b>Syntax Note:</b> The * operator in front of a function
    1109. 

  1109.     parameter signifies the aggregation of any (remaining) input arguments into a
    1110. 

  1110.     list by that name. As such, * is only acceptable in front of a function's final
    1111. 

  1111.     parameter.</p>
    1112. 

  1112.     <ol start="5">
    1113. 

  1113.         <li>
    1114. 

  1114.         <p class="Step">Register the event handler for the 'Changed', 'Created',
    1115. 

  1115.         and 'Deleted' 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"></p>
    1124. 

  1124.     <ol start="6">
    1125. 

  1125.         <li>
    1126. 

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

  1127.         </li>
    1128. 

  1128.     </ol>
    1129. 

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

  1130.     <ol start="7">
    1131. 

  1131.         <li>
    1132. 

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

  1133.         to create the file is to right-click with the mouse and select 'New\Text
    1134. 

  1134.         Document. The file watcher will raise the 'Created' event.</p>
    1135. 

  1135.         </li>
    1136. 

  1136.     </ol>
    1137. 

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

  1138.     text, and save the file.&nbsp; This raises the 'Changed' event.&nbsp;
    1139. 

  1139.     Then finish by deleting
    1140. 

  1140.     the file to see the 'Deleted' event get raised.</p>
    1141. 

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

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

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

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

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

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

  1147.     <ol start="8">
    1148. 

  1148.         <li>
    1149. 

  1149.         <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>
    1150. 

  1150.         </li>
    1151. 

  1151.     </ol>
    1152. 

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

  1153.     <p class="Code-Background"></p>
    1154. 

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

  1155.     <p class="Code-Background"></p>
    1156. 

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

  1157.     <p class="Code-Background">
    1158. 

  1158.     </p>
    1159. 

  1159.     <ol start="9">
    1160. 

  1160.         <li>
    1161. 

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

  1162.         while they are still being raised, are no longer being handled by our Python
    1163. 

  1163.         'handler' function.</p>
    1164. 

  1164.         </li>
    1165. 

  1165.     </ol>
    1166. 

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

  1167.     <ol>
    1168. 

  1168.         <li>
    1169. 

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

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

  1171.         </li>
    1172. 

  1172.     </ol>
    1173. 

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

  1174.     raised the event</p>
    1175. 

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

  1176.     raised</p>
    1177. 

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

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

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

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

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

  1182.     <p class="Code-Background"></p>
    1183. 

  1183.     <p class="TypedExample">w.Path = '.'</p>
    1184. 

  1184.     <p class="Code-Background"></p>
    1185. 

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

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

  1187. set2 = set(dir(object))
    1188. 

  1188. list(set1-set2)</p>
    1189. 

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

  1190.     console window will be:</p>
    1191. 

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

  1192.     <p class="Code-Background">
    1193. 

  1193. 

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

  1195.     <ol start="2">
    1196. 

  1196.         <li>
    1197. 

  1197.         <p class="Step">Now with more knowledge of the FileSystemEventArgs object's
    1198. 

  1198.         properties, we can create a better event handler that will display its
    1199. 

  1199.         ChangeType and FullPath properties:</p>
    1200. 

  1200.         </li>
    1201. 

  1201.     </ol>
    1202. 

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

  1203.     <ol start="3">
    1204. 

  1204.         <li>
    1205. 

  1205.         <p class="Step">Register the new event handler for the 'Changed', 'Created'
    1206. 

  1206.         and 'Deleted' events:</p>
    1207. 

  1207.         </li>
    1208. 

  1208.     </ol>
    1209. 

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

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

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

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

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

  1214.     <p class="Code-Background">
    1215. 

  1215. 

  1216.     </p>
    1217. 

  1217.     <ol start="4">
    1218. 

  1218.         <li>
    1219. 

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

  1220.         </li>
    1221. 

  1221.     </ol>
    1222. 

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

  1223.     <ol start="5">
    1224. 

  1224.         <li>
    1225. 

  1225.         <p class="Step">Open the Tutorial folder again and create a new file ('Created'
    1226. 

  1226.         event), edit the file in Notepad and save it ('Changed' event) and finish
    1227. 

  1227.         by deleting the file ('Deleted' event).</p>
    1228. 

  1228.         </li>
    1229. 

  1229.     </ol>
    1230. 

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

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

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

  1233.     Changed .\New Text Document.txt<br />
    1234. 

  1234.     Changed .\New Text Document.txt<br />
    1235. 

  1235.     Deleted .\New Text Document.txt</p>
    1236. 

  1236.     <ol start="6">
    1237. 

  1237.         <li>
    1238. 

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

  1239.         </li>
    1240. 

  1240.     </ol>
    1241. 

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

  1242.     <p class="Code-Background"></p>
    1243. 

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

  1244.     <p class="Code-Background"></p>
    1245. 

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

  1246.     <p class="Code-Background"></p>
    1247. 

  1247.     <ol start="7">
    1248. 

  1248.         <li>
    1249. 

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

  1250.         by Enter).</p>
    1251. 

  1251.         </li>
    1252. 

  1252.     </ol>
    1253. 

  1253. 

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

  1255.     <ol>
    1256. 

  1256.         <li>
    1257. 

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

  1258.         </li>
    1259. 

  1259.     </ol>
    1260. 

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

  1261.     <p class="Stepnonumbering">make_event - a function that returns an event tuple containing both
    1262. 

  1262.     the hook (the object which allows connecting and disconnecting of handler delegates) and the
    1263. 

  1263.     callable event-firing object.</p>
    1264. 

  1264.     <br/>
    1265. 

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

  1266.     <br/>
    1267. 

  1267.     <p class="TypedExample">import pyevent</p>
    1268. 

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

  1269.     <br />
    1270. 

  1270.     <p class="SyntaxNote"><b>Syntax Note:</b> Python supports the &quot;unpacking&quot;
    1271. 

  1271.     of iterable objects, which is similar to pattern-matching on F# tuples. This feature
    1272. 

  1272.     is used like normal variable assignment, except the left-hand side of the '=' is a
    1273. 

  1273.     comma-separated list of variables, each of which is assigned the corresponding
    1274. 

  1274.     value in the iterable. Unpacking can only be used when the number of items returned
    1275. 

  1275.     by the right-hand side's iterator is known and exactly matches the length of the
    1276. 

  1276.     comma-separated variable list.</p>
    1277. 

  1277.     <br />
    1278. 

  1278.     <p class="Stepnonumbering">This has returned created for us two objects.  The first object
    1279. 

  1279.     allows a user to hook a function up to the event.  The second object allows the owner of
    1280. 

  1280.     the event to cause the event to be raised.  This allows for the separation of these
    1281. 

  1281.     abilities just like .NET.&nbsp; Now let's take this and put it into a class and see how
    1282. 

  1282.     it gets used.</p>
    1283. 

  1283. 

  1284.     <ol start="2">
    1285. 

  1285.         <li>
    1286. 

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

  1287.         </li>
    1288. 

  1288.     </ol>
    1289. 

  1289. 

  1290.     <p class="TypedExample">class MyClass(object):<br />
    1291. 

  1291.     &nbsp;&nbsp;&nbsp;&nbsp;OnNewInstance,_NewInstance= pyevent.make_event()<br />
    1292. 

  1292.     &nbsp;&nbsp;&nbsp;&nbsp;def __new__(cls):<br />
    1293. 

  1293.     &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;res = object.__new__(object)<br />
    1294. 

  1294.     &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;MyClass._NewInstance(res)<br />
    1295. 

  1295.     </p>
    1296. 

  1296.     <p class="Code-Background"></p>
    1297. 

  1297.     <p class="Code-Background"></p>
    1298. 

  1298.     <p class="Code-Background"></p>
    1299. 

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

  1300.     <p class="Code-Background"></p>
    1301. 

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

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

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

  1304.     <p class="Stepnonumbering">The console output should look like:</p>
    1305. 

  1305.     <p class="Code-Background">new inst:&nbsp; &lt;object object at 0x000000000000002B&gt;</p>
    1306. 

  1306. 

  1307.     <ol start="3">
    1308. 

  1308.         <li>
    1309. 

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

  1310.         </li>
    1311. 

  1311.     </ol>
    1312. 

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

  1313.     <p class="Code-Background"></p>
    1314. 

  1314. 

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

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

  1317.     dynamically from the IronPython interactive console.</p>
    1318. 

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

  1319.     be initialized for that purpose.&nbsp; By default, the Python console executes on one thread 
    1320. 

  1320.     only.&nbsp; While this thread awaits text input in the console window, the Windows application
    1321. 

  1321.     being dynamically created from the console is blocked, or unable to process Windows messages.&nbsp;
    1322. 

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

  1323.     <p class="Body">We provide a .py file to initialize IronPython for properly multithreaded
    1324. 

  1324.     Windows Forms development. See the tasks below.</p>
    1325. 

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

  1326.     <ol>
    1327. 

  1327.         <li>
    1328. 

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

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

  1330.         </li>
    1331. 

  1331.         <li>
    1332. 

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

  1333.         </li>
    1334. 

  1334.     </ol>
    1335. 

  1335.     <p class="TypedExample">import winforms</p>
    1336. 

  1336.     <p class="Code-Background"></p>
    1337. 

  1337.     <p class="SyntaxNote"><b>Syntax Note:</b> Python modules get automatically initialized
    1338. 

  1338.     (executed) when imported, meaning that the Windows Forms initialization code in
    1339. 

  1339.     winforms.py has executed due to the import statement.</p>
    1340. 

  1340.     <ol start="3">
    1341. 

  1341.         <li>
    1342. 

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

  1343.         namespaces into the global namespace: </p>
    1344. 

  1344.         </li>
    1345. 

  1345.     </ol>
    1346. 

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

  1347.     <p class="Code-Background"></p>
    1348. 

  1348.     <p class="TypedExample">from System.Drawing import *</p>
    1349. 

  1349.     <p class="Code-Background"></p>
    1350. 

  1350.     <ol start="4">
    1351. 

  1351.         <li>
    1352. 

  1352.         <p class="Step">Create an instance of the Form class and display it:</p>
    1353. 

  1353.         </li>
    1354. 

  1354.     </ol>
    1355. 

  1355.     <p class="TypedExample">f = Form()</p>
    1356. 

  1356.     <p class="Code-Background"></p>
    1357. 

  1357.     <p class="TypedExample">f.Show()</p>
    1358. 

  1358.     <p class="Code-Background"></p>
    1359. 

  1359.     <p class="Stepnonumbering">You may need to alt-tab or look for the running
    1360. 

  1360.     application since it may not have popped to the top level on your desktop.</p>
    1361. 

  1361.     <ol start="5">
    1362. 

  1362.         <li>
    1363. 

  1363.         <p class="Step">Now set the form's Text property:</p>
    1364. 

  1364.         </li>
    1365. 

  1365.     </ol>
    1366. 

  1366.     <p class="Stepnonumbering">This change should now appear in the form window's title bar.</p>
    1367. 

  1367.     <p class="TypedExample">f.Text = &quot;My First Interactive Application&quot;</p>
    1368. 

  1368.     <p class="Code-Background"></p>
    1369. 

  1369.     <ol start="6">
    1370. 

  1370.         <li>
    1371. 

  1371.         <p class="Step">To bring the application alive, let&#39;s focus on the Click
    1372. 

  1372.         event of the form. Create an event handler for the Click event and click
    1373. 

  1373.         on the form to receive the event. Then remove the event handler</p>
    1374. 

  1374.         </li>
    1375. 

  1375.     </ol>
    1376. 

  1376.     <p class="TypedExample">def click(*args): print args</p>
    1377. 

  1377.     <p class="Code-Background"></p>
    1378. 

  1378.     <p class="TypedExample">f.Click += click</p>
    1379. 

  1379.     <p class="Code-Background"></p>
    1380. 

  1380.     <p class="Stepnonumbering">Click on the form to receive the event..</p>
    1381. 

  1381.     <p class="Stepnonumbering">The output will be a tuple containing a Form
    1382. 

  1382.     object and a MouseEventArgs object, like so:</p>
    1383. 

  1383.     <p class="Noverify-Background">(&lt;System.Windows.Forms.Form object at
    1384. 

  1384.     0x000000000000002B [System.Windows.Forms.Form, Text: My First Interactive Application]&gt;,
    1385. 

  1385.     &lt;System.Windows.Forms.MouseEventArgs object at 0x000000000000002C
    1386. 

  1386.     [System.Windows.Forms.MouseEventArgs]&gt;)</p>
    1387. 

  1387.     <p class="Stepnonumbering">Now remove the click handler because we're going
    1388. 

  1388.     to further develop it.</p>
    1389. 

  1389.     <p class="TypedExample">f.Click -= click</p>
    1390. 

  1390.     <p class="Code-Background"></p>
    1391. 

  1391.     <ol start="7">
    1392. 

  1392.         <li>
    1393. 

  1393.         <p class="Step">Use dir() function to explore MouseEventArgs</p>
    1394. 

  1394.         </li>
    1395. 

  1395.     </ol>
    1396. 

  1396.     <p class="UserCode">dir(MouseEventArgs)</p>
    1397. 

  1397.     <p class="HiddenCode">set1 = set(dir(MouseEventArgs))
    1398. 

  1398. set2 = set(dir(object))
    1399. 

  1399. list(set1-set2)</p>
    1400. 

  1400.     <p class="HiddenOutput">
    1401. 

  1401. 

  1402. ['Button','Delta','Empty','Clicks','X','Y','Location']</p>
    1403. 

  1403.     <ol start="8">
    1404. 

  1404.         <li>
    1405. 

  1405.         <p class="Step" style="page-break-after:avoid">Knowing the contents of the
    1406. 

  1406.         MouseEventArgs, create an improved event handler for the Click event:</p>
    1407. 

  1407.         </li>
    1408. 

  1408.     </ol>
    1409. 

  1409.     <p class="TypedExample" style="page-break-after:avoid">def click(f, a):<br>
    1410. 

  1410. &nbsp;&nbsp;&nbsp; l = Label(Text = &quot;Hello&quot;)<br>
    1411. 

  1411. &nbsp;&nbsp;&nbsp; l.Location = a.Location<br>
    1412. 

  1412. &nbsp;&nbsp;&nbsp; f.Controls.Add(l)</p>
    1413. 

  1413. <p class="SyntaxNote"><b>Syntax Note:</b> Python functions support named parameters
    1414. 

  1414. such as the 'Text' parameter in the above invocation of 'Label'. This allows us to
    1415. 

  1415. specify function arguments by name rather than their ordering, and synergizes nicely
    1416. 

  1416. with Python's capacity for optional parameters.</p>
    1417. 

  1417. <p class="Code-Background"></p>
    1418. 

  1418.     <ol start="9">
    1419. 

  1419.         <li>
    1420. 

  1420.         <p class="Step" style="page-break-after:avoid">Register the event handler:</p>
    1421. 

  1421.         </li>
    1422. 

  1422.     </ol>
    1423. 

  1423.     <p class="TypedExample">f.Click += click</p>
    1424. 

  1424.     <p class="Code-Background"></p>
    1425. 

  1425.     <ol start="10">
    1426. 

  1426.         <li>
    1427. 

  1427.         <p class="Step">Now clicking on the form with the mouse will add &quot;Hello&quot;
    1428. 

  1428.         labels. We can also access the controls we just added via mouse clicks and
    1429. 

  1429.         change them</p>
    1430. 

  1430.         </li>
    1431. 

  1431.     </ol>
    1432. 

  1432.     <p class="TypedExample">for i in f.Controls: i.Font = Font(&quot;Verdana&quot;, 15)</p>
    1433. 

  1433.     <p class="Code-Background"></p>
    1434. 

  1434.     <p class="TypedExample">for i in f.Controls: i.Text = &quot;Hi&quot;</p>
    1435. 

  1435.     <p class="Code-Background"></p>
    1436. 

  1436.     <ol start="11">
    1437. 

  1437.         <li>
    1438. 

  1438.         <p class="Step">After a few moments of clicking, the form will get quite
    1439. 

  1439.         crowded, so we can clear it out:</p>
    1440. 

  1440.         </li>
    1441. 

  1441.     </ol>
    1442. 

  1442.     <p class="TypedExample">f.Controls.Clear()</p>
    1443. 

  1443.     <p class="HiddenCode">f.Close()</p>
    1444. 

  1444.     <p class="Code-Background"></p>
    1445. 

  1445.     <ol start="12">
    1446. 

  1446.         <li>
    1447. 

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

  1448.         by Enter)</p>
    1449. 

  1449.         </li>
    1450. 

  1450.     </ol>
    1451. 

  1451.     <p class="Body">The standalone version of this script is located in wfdemo.py
    1452. 

  1452.     in the Tutorial directory.</p>
    1453. 

  1453.     <h2><a name="T2.3">Exercise 3: Windows Presentation Foundation (Avalon)</a></h2>
    1454. 

  1454.     <p class="Body">In this exercise, you will interactively create a simple interactive
    1455. 

  1455.     Windows Presentation Foundation application.</p>
    1456. 

  1456.     <p class="Body">Just like Windows Forms, the Windows Presentation Foundation
    1457. 

  1457.     also requires initialization to support interactive development. The initialization
    1458. 

  1458.     code is available in &quot;avalon.py&quot; in your Tutorial directory.</p>
    1459. 

  1459.     <h3><a name="T2.3.1">Task 1: Simple Avalon Application</a></h3>
    1460. 

  1460.     <ol>
    1461. 

  1461.         <li>
    1462. 

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

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

  1464.         </li>
    1465. 

  1465.         <li>
    1466. 

  1466.         <p class="Step">Initialize Windows Presentation Foundation:</p>
    1467. 

  1467.         </li>
    1468. 

  1468.     </ol>
    1469. 

  1469.     <p class="TypedExample">from avalon import *</p>
    1470. 

  1470.     <p class="Code-Background"></p>
    1471. 

  1471.     <ol start="3">
    1472. 

  1472.         <li>
    1473. 

  1473.         <p class="Step">Create Avalon window, display it, and set some of its properties:</p>
    1474. 

  1474.         </li>
    1475. 

  1475.     </ol>
    1476. 

  1476.     <p class="TypedExample">w = Window()</p>
    1477. 

  1477.     <p class="Code-Background"></p>
    1478. 

  1478.     <p class="TypedExample">w.Show()</p>
    1479. 

  1479.     <p class="Code-Background"></p>
    1480. 

  1480.     <p class="Stepnonumbering">You may need to alt-tab or look for the running
    1481. 

  1481.     application since it may not have popped to the top level on your desktop.&nbsp;
    1482. 

  1482.     Now, let's do more.</p>
    1483. 

  1483.     <p class="Code-Background"></p>
    1484. 

  1484.     <p class="TypedExample">w.Title = &quot;My Avalon Application&quot;</p>
    1485. 

  1485.     <p class="Code-Background"></p>
    1486. 

  1486.     <p class="TypedExample">w.SizeToContent = SizeToContent.WidthAndHeight</p>
    1487. 

  1487.     <p class="Code-Background"></p>
    1488. 

  1488.     <p class="Stepnonumbering">By setting the window property to
    1489. 

  1489.     &quot;SizeToContent&quot;, the window shrinks.</p>
    1490. 

  1490.     <ol start="4">
    1491. 

  1491.         <li>
    1492. 

  1492.         <p class="Step">Let's add some content now:</p>
    1493. 

  1493.         </li>
    1494. 

  1494.     </ol>
    1495. 

  1495.     <p class="TypedExample">w.Content = TextBlock()</p>
    1496. 

  1496.     <p class="Code-Background"></p>
    1497. 

  1497.     <p class="TypedExample">w.Content.Text = &quot;Hello IronPython!&quot;</p>
    1498. 

  1498.     <p class="Code-Background"></p>
    1499. 

  1499.     <p class="TypedExample">w.Content.FontSize = 50</p>
    1500. 

  1500.     <p class="Code-Background"></p>
    1501. 

  1501.     <ol start="5">
    1502. 

  1502.         <li>
    1503. 

  1503.         <p class="Step">Remove the window content:</p>
    1504. 

  1504.         </li>
    1505. 

  1505.     </ol>
    1506. 

  1506.     <p class="TypedExample">w.Content = None</p>
    1507. 

  1507.     <ol start="6">
    1508. 

  1508.         <li>
    1509. 

  1509.         <p class="Step">You may leave the interpreter open and continue on to Task 2.</p>
    1510. 

  1510.         </li>
    1511. 

  1511.     </ol>
    1512. 

  1512.     <h3><a name="T2.3.2">Task 2: Avalon calculator</a></h3>
    1513. 

  1513.     <ol>
    1514. 

  1514.         <li>
    1515. 

  1515.         <p class="Step">If you are continuing from the Task 1, proceed to step 2.&nbsp;
    1516. 

  1516.         Otherwise, please follow the <a href="#T2.3.1">steps 1-3</a> from Task 1, the
    1517. 

  1517.         relevant portions of which are repeated here:</p>
    1518. 

  1518.         </li>
    1519. 

  1519.     </ol>
    1520. 

  1520.     <p class="TypedExample">from avalon import *</p>
    1521. 

  1521.     <p class="Code-Background"></p>
    1522. 

  1522.     <p class="TypedExample">w = Window()</p>
    1523. 

  1523.     <p class="Code-Background"></p>
    1524. 

  1524.     <p class="TypedExample">w.Show()</p>
    1525. 

  1525.     <p class="Code-Background"></p>
    1526. 

  1526.     <ol start="2">
    1527. 

  1527.         <li>
    1528. 

  1528.         <p class="Step">Windows Presentation Foundation uses the XAML format to describe
    1529. 

  1529.         the graphical layout and basic behaviors of UI. Load the &quot;calc.xaml&quot;
    1530. 

  1530.         and display the resulting content:</p>
    1531. 

  1531.         </li>
    1532. 

  1532.     </ol>
    1533. 

  1533.     <p class="TypedExample">w.Content = LoadXaml(&quot;calc.xaml&quot;)</p>
    1534. 

  1534.     <p class="Code-Background"></p>
    1535. 

  1535.     <p class="Stepnonumbering">Regardless of whether you flowed into this task
    1536. 

  1536.     from Task 1, w.SizeToContent has been reset to manual, so you will need to
    1537. 

  1537.     drag the window's border down and to the right to see the calculator UI.</p>
    1538. 

  1538.     <ol start="3">
    1539. 

  1539.         <li>
    1540. 

  1540.         <p class="Step">Let's walk the calculator's object model tree (function
    1541. 

  1541.         Walk is defined in the avalon.py file)</p>
    1542. 

  1542.         </li>
    1543. 

  1543.     </ol>
    1544. 

  1544.     <p class="TypedExample">for n in Walk(w): print n</p>
    1545. 

  1545.     <p class="HiddenOutput">System.Windows.Window<br />
    1546. 

  1546. &lt;System.Windows.Controls.Canvas object at 0x000000000000002B [System.Windows.Controls.Canvas]&gt;<br />
    1547. 

  1547. &lt;System.Windows.Controls.Canvas object at 0x000000000000002C [System.Windows.Controls.Canvas]&gt;<br />
    1548. 

  1548. &lt;System.Windows.Shapes.Rectangle object at 0x000000000000002D [System.Windows.Shapes.Rectangle]&gt;<br />
    1549. 

  1549. &lt;System.Windows.Controls.Canvas object at 0x000000000000002E [System.Windows.Controls.Canvas]&gt;</p>
    1550. 

  1550. <p class="HiddenOutput">System.Windows.Controls.TextBox
    1551. 

  1551. System.Windows.Controls.RichTextBox
    1552. 

  1552. System.Windows.Controls.Button: 1
    1553. 

  1553. 1
    1554. 

  1554. System.Windows.Controls.Button: 9
    1555. 

  1555. 9
    1556. 

  1556. System.Windows.Controls.Button: 8
    1557. 

  1557. 8
    1558. 

  1558. System.Windows.Controls.Button: 5
    1559. 

  1559. 5
    1560. 

  1560. System.Windows.Controls.Button: 4
    1561. 

  1561. 4
    1562. 

  1562. System.Windows.Controls.Button: 2
    1563. 

  1563. 2
    1564. 

  1564. System.Windows.Controls.Button: 3
    1565. 

  1565. 3
    1566. 

  1566. System.Windows.Controls.Button: 6
    1567. 

  1567. 6
    1568. 

  1568. System.Windows.Controls.Button: *
    1569. 

  1569. *
    1570. 

  1570. System.Windows.Controls.Button: 7
    1571. 

  1571. 7
    1572. 

  1572. System.Windows.Controls.Button: -
    1573. 

  1573. -
    1574. 

  1574. System.Windows.Controls.Button: 0
    1575. 

  1575. 0
    1576. 

  1576. System.Windows.Controls.Button: .
    1577. 

  1577. .
    1578. 

  1578. System.Windows.Controls.Button: =
    1579. 

  1579. =
    1580. 

  1580. System.Windows.Controls.Button: +
    1581. 

  1581. +
    1582. 

  1582. System.Windows.Controls.Button: /
    1583. 

  1583. /
    1584. 

  1584. System.Windows.Controls.Button: C
    1585. 

  1585. C</p>
    1586. 

  1586.     <ol start="4">
    1587. 

  1587.         <li>
    1588. 

  1588.         <p class="Step">Using a generator, we can capture all buttons in the
    1589. 

  1589.         calculator:</p>
    1590. 

  1590.         </li>
    1591. 

  1591.     </ol>
    1592. 

  1592.     <p class="TypedExample">[ n for n in Walk(w) if isinstance(n, Button) ]</p>
    1593. 

  1593.     <p class="LooseVerify">System.Windows.Controls.Button</p>
    1594. 

  1594.     <p class="SyntaxNote"><b>Syntax Note:</b> Python's generator syntax is a
    1595. 

  1595.     concise way of enumerating, filtering (by way of the optional &quot;if
    1596. 

  1596.     ...&quot; portion), and mapping over (by way of the leftmost portion, an
    1597. 

  1597.     identity expression in this example) an iterable.</p>
    1598. 

  1598.     <p class="Stepnonumbering">The console printed the list of all buttons. Let's
    1599. 

  1599.     store this list object in a variable for later use:</p>
    1600. 

  1600.     <p class="TypedExample">buttons = _</p>
    1601. 

  1601.     <p class="Code-Background"></p>
    1602. 

  1602.     <p class="SyntaxNote"><b>Syntax Note:</b> Available only in the interpreter,
    1603. 

  1603.     the &quot;_&quot; variable stores the last non-None result value printed by
    1604. 

  1604.     the console.</p>
    1605. 

  1605.     <ol start="5">
    1606. 

  1606.         <li>
    1607. 

  1607.         <p class="Step">At this point we can make changes to all the buttons. For
    1608. 

  1608.         example, let's change the colors and fonts:</p>
    1609. 

  1609.         </li>
    1610. 

  1610.     </ol>
    1611. 

  1611.     <p class="TypedExample">for b in buttons: b.FontSize *= 2</p>
    1612. 

  1612.     <p class="Code-Background"></p>
    1613. 

  1613.     <p class="TypedExample">for b in buttons: b.Foreground = SolidColorBrush(Colors.Blue)</p>
    1614. 

  1614.     <p class="Code-Background"></p>
    1615. 

  1615.     <ol start="6">
    1616. 

  1616.         <li>
    1617. 

  1617.         <p class="Step" style="page-break-after:avoid">To bring the calculator alive,
    1618. 

  1618.         we need to provide event handlers for each button.&nbsp; These can be imported
    1619. 

  1619.         from the calculator.py file:</p>
    1620. 

  1620.         </li>
    1621. 

  1621.     </ol>
    1622. 

  1622.     <p class="TypedExample">import calculator</p>
    1623. 

  1623.     <p class="Code-Background"></p>
    1624. 

  1624.     <ol start="7">
    1625. 

  1625.         <li>
    1626. 

  1626.         <p class="Step">The calculator module contains the Calculator class that
    1627. 

  1627.         will be responsible for tracking the expression as it is being built by
    1628. 

  1628.         the calculator.&nbsp; To bring the calculator alive (that is, register event
    1629. 

  1629.         handlers for the UI), enter:</p>
    1630. 

  1630.         </li>
    1631. 

  1631.     </ol>
    1632. 

  1632.     <p class="TypedExample">calculator.enliven(w)</p>
    1633. 

  1633.     <p class="HiddenOutput">Registering self.on_One to handle One.Click
    1634. 

  1634. Registering self.on_Nine to handle Nine.Click
    1635. 

  1635. Registering self.on_Eight to handle Eight.Click
    1636. 

  1636. Registering self.on_Five to handle Five.Click
    1637. 

  1637. Registering self.on_Four to handle Four.Click
    1638. 

  1638. Registering self.on_Two to handle Two.Click
    1639. 

  1639. Registering self.on_Three to handle Three.Click
    1640. 

  1640. Registering self.on_Six to handle Six.Click
    1641. 

  1641. Registering self.on_Multiply to handle Multiply.Click
    1642. 

  1642. Registering self.on_Seven to handle Seven.Click
    1643. 

  1643. Registering self.on_Subtract to handle Subtract.Click
    1644. 

  1644. Registering self.on_Zero to handle Zero.Click
    1645. 

  1645. Registering self.on_DecimalPoint to handle DecimalPoint.Click
    1646. 

  1646. Registering self.on_Equals to handle Equals.Click
    1647. 

  1647. Registering self.on_Plus to handle Plus.Click
    1648. 

  1648. Registering self.on_Divide to handle Divide.Click
    1649. 

  1649. Registering self.on_Clear to handle Clear.Click</p>
    1650. 

  1650.     <ol start="8">
    1651. 

  1651.         <li>
    1652. 

  1652.         <p class="Step">At this point, you can click on the calculator buttons and
    1653. 

  1653.         evaluate expressions.</p>
    1654. 

  1654.         </li>
    1655. 

  1655.         <li>
    1656. 

  1656.         <p class="Step">Feel free to explore the calculator.py script file (located
    1657. 

  1657.         in Tutorial directory).&nbsp; The point of interest is the Calculator.__init__
    1658. 

  1658.         constructor method:</p>
    1659. 

  1659.         </li>
    1660. 

  1660.     </ol>
    1661. 

  1661.     <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;
    1662. 

  1662.     (1)<br />
    1663. 

  1663. &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;
    1664. 

  1664.     (2)<br />
    1665. 

  1665. &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;
    1666. 

  1666.     (3)<br />
    1667. 

  1667. &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;
    1668. 

  1668.     (4)<br />
    1669. 

  1669. &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;
    1670. 

  1670.     (5)<br />
    1671. 

  1671. &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; if hasattr(self,
    1672. 

  1672.     &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;
    1673. 

  1673.     (6)<br />
    1674. 

  1674. &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;
    1675. 

  1675.     i.Click += getattr(self, &quot;on_&quot; + i.Name)&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;
    1676. 

  1676.     (7)<br />
    1677. 

  1677. &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;
    1678. 

  1678.     (8)<br />
    1679. 

  1679. &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; if i.Name ==
    1680. 

  1680.     &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;
    1681. 

  1681.     (9)<br />
    1682. 

  1682. &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;
    1683. 

  1683.     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;
    1684. 

  1684.     (10)<br />
    1685. 

  1685. &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;
    1686. 

  1686.     (11)</p>
    1687. 

  1687.     <br />
    1688. 

  1688.     <p class="Stepnonumbering">The &quot;controls&quot; argument for the method is the list of buttons and
    1689. 

  1689.     text boxes, very similar to the list of buttons created in steps 3 and 4 of this task.&nbsp;
    1690. 

  1690.     The initialization code enumerates the list (line 4), identifies buttons (line 5), and uses the name of
    1691. 

  1691.     the button (&quot;One&quot;, &quot;Multiply&quot;, &quot; Equals&quot;, ...) to find the calculator attribute
    1692. 

  1692.     (method) with the corresponding name (for example, &quot;on_One&quot;, &quot;on_Multiply&quot;,
    1693. 

  1693.     and &quot;on_Equals&quot;, respectively).&nbsp; If such an attribute (method) is available,
    1694. 

  1694.     we hook the Click event event, using the name to fetch the attribute (line 7).</p>
    1695. 

  1695.     <ol start="10">
    1696. 

  1696.         <li>
    1697. 

  1697.         <p class="Step">The second point of interest is the on_Equals method, especially
    1698. 

  1698.         the highlighted line.&nbsp; Python has a built-in function, &quot;eval&quot;, which evaluates
    1699. 

  1699.         an expression passed as a string and returns the resulting value.&nbsp; Calculator uses &quot;eval&quot;
    1700. 

  1700.         to evaluate the calculator expressions.&nbsp; The &quot;str&quot; function will then convert the value
    1701. 

  1701.         into a string for display.</p>
    1702. 

  1702.         </li>
    1703. 

  1703.     </ol>
    1704. 

  1704.     <p class="CodeSample">def on_Equals(self, b, e):<br />
    1705. 

  1705. &nbsp;&nbsp;&nbsp; try:<br>
    1706. 

  1706.     &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; result
    1707. 

  1707.     = str(eval(self.expression))<br>
    1708. 

  1708.     &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; self.result.Text
    1709. 

  1709.     = result<br />
    1710. 

  1710. &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; self.expression = result<br />
    1711. 

  1711. &nbsp;&nbsp;&nbsp; except:<br />
    1712. 

  1712. &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; self.result.Text = &quot;&lt;&lt;ERROR&gt;&gt;&quot;<br />
    1713. 

  1713. &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; self.expression = &quot;&quot;</p>
    1714. 

  1714.     <ol start="11">
    1715. 

  1715.         <li>
    1716. 

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

  1717.         by Enter)</p>
    1718. 

  1718.         </li>
    1719. 

  1719.     </ol>
    1720. 

  1720.     <p class="LabSummary">Tutorial Summary</p>
    1721. 

  1721.     <p class="Body">IronPython provides a very easy way to develop live applications
    1722. 

  1722.     in a dynamic and exploratory way. Both Windows Forms and Windows Presentation
    1723. 

  1723.     Foundation (Avalon) applications can be easily developed in this manner with minimal
    1724. 

  1724.     setup. The advantage is that changes are visible immediately, and modifications
    1725. 

  1725.     are happening to a live system without requiring recompilation or even re-execution.</p>
    1726. 

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

  1727.     <ul>
    1728. 

  1728.         <li>
    1729. 

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

  1730.         </li>
    1731. 

  1731.         <li>
    1732. 

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

  1733.         </li>
    1734. 

  1734.         <li>
    1735. 

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

  1736.         (Avalon)</a></p>
    1737. 

  1737.         </li>
    1738. 

  1738.     </ul>
    1739. 

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

  1740.     <p class="Body">In this tutorial, you became familiar with using delegates and
    1741. 

  1741.     handling events in IronPython -- an essential part of interactive development
    1742. 

  1742.     of Windows applications using WinForms or Avalon. Then you dynamically created
    1743. 

  1743.     a simple interactive application in Windows Forms and two applications using
    1744. 

  1744.     Windows Presentation Foundation. </p>
    1745. 

  1745.     <h1><a name="T3">Tutorial 3: IronPython and COM interoperability</a></h1>
    1746. 

  1746.     <p class="Body">COM interoperability is an important part of .NET Framework.
    1747. 

  1747.     To use COM objects from the .NET application, an interop assembly that contains
    1748. 

  1748.     the .NET metadata for the COM objects is required. This tutorial will outline
    1749. 

  1749.     how the interop assemblies can be created (in the case they are not provided
    1750. 

  1750.     by the creators of the COM object) and will demonstrate the ease with which
    1751. 

  1751.     COM objects can be used from IronPython.</p>
    1752. 

  1752.     <p class="Body">Estimated time to complete this tutorial: <b>15 minutes</b></p>
    1753. 

  1753.     <p class="Body">The objective of this tutorial is to explore COM interoperability
    1754. 

  1754.     from IronPython.</p>
    1755. 

  1755.     <ul>
    1756. 

  1756.         <li>
    1757. 

  1757.         <p class="ExerciseList"><a href="#T3.1">Word Spell Checking</a></p>
    1758. 

  1758.         </li>
    1759. 

  1759.     </ul>
    1760. 

  1760.     <h2><a name="T3.1">Exercise 1: Use Word for Spell Checking</a></h2>
    1761. 

  1761.     <p class="Body">In this exercise you will create an instance of Microsoft
    1762. 

  1762.     Word and use it to check word spellings.</p>
    1763. 

  1763.     <h3><a name="T3.1.1">Task 1: Accessing Word and Checking Spelling</a></h3>
    1764. 

  1764.     <ol>
    1765. 

  1765.         <li>
    1766. 

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

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

  1768.         </li>
    1769. 

  1769.         <li>
    1770. 

  1770.         <p class="Step">Import clr module and add a reference to the Word COM
    1771. 

  1771.         interop assembly.</p>
    1772. 

  1772.         </li>
    1773. 

  1773.     </ol>
    1774. 

  1774.     <p class="TypedExample">import clr</p>
    1775. 

  1775.     <p class="Code-Background"></p>
    1776. 

  1776.     <p class="TypedExample">clr.AddReferenceByPartialName(&quot;Microsoft.Office.Interop.Word&quot;)</p>
    1777. 

  1777.     <p class="Code-Background"></p>
    1778. 

  1778.     <p class="TypedExample">from Microsoft.Office.Interop.Word import ApplicationClass</p>
    1779. 

  1779.     <p class="Code-Background"></p>
    1780. 

  1780.     </p>
    1781. 

  1781.     <ol start="3">
    1782. 

  1782.         <li>
    1783. 

  1783.         <p class="Step">Start an instance of Word as a COM server running.&nbsp;
    1784. 

  1784.         You won't see it show up since it is hidden, but you can see it in the
    1785. 

  1785.         Windows Task Manager by typing ctrl-shift-escape and looking for the
    1786. 

  1786.         WINWORD.EXE process.</p></li>
    1787. 

  1787.     </ol>
    1788. 

  1788.     <p class="TypedExample">w = ApplicationClass()</p>
    1789. 

  1789.     <p class="Code-Background"></p>
    1790. 

  1790.     <ol start="4">
    1791. 

  1791.         <li>
    1792. 

  1792.         <p class="Step">Define the following function to check the spelling.&nbsp;
    1793. 

  1793.         Remember to indent the lines of the function's body extra spaces, and you
    1794. 

  1794.         have to hit an extra return or enter to complete the function's definition.</p></li>
    1795. 

  1795.     </ol>
    1796. 

  1796.     <p class="TypedExample">def check_word (word):<br>
    1797. 

  1797. &nbsp;&nbsp; return w.CheckSpelling(word)</p>
    1798. 

  1798. <p class="Code-Background"></p>
    1799. 

  1799.     <p class="TypedExample">check_word(&quot;foo&quot;)</p>
    1800. 

  1800.     <p class="HiddenOutput">False</p>
    1801. 

  1801.     <p class="TypedExample">check_word(&quot;food&quot;)</p>
    1802. 

  1802.     <p class="HiddenOutput">True</p>
    1803. 

  1803.     <ol start="5">
    1804. 

  1804.         <li>
    1805. 

  1805.         <p class="Step">You can try that out on a couple of words, but now lets
    1806. 

  1806.         define a function that will suggest corrections for us.&nbsp; First, we
    1807. 

  1807.         need to add a document so that we can call GetSpellingSuggestions(),
    1808. 

  1808.         which gives a nice error message if you try to call it with no documents
    1809. 

  1809.         opened.</p></li>
    1810. 

  1810.     </ol>
    1811. 

  1811.     <p class="TypedExample">w.Documents.Add()</p>
    1812. 

  1812.     <p class="LooseVerify">Microsoft.Office.Interop.Word.DocumentClass</p>
    1813. 

  1813.     <ol start="6">
    1814. 

  1814.         <li>
    1815. 

  1815.         <p class="Step">The first result of
    1816. 

  1816.         several return values from GetSpellingSuggestions() is a collection of
    1817. 

  1817.         items, each of which is a correction suggestion.&nbsp; We use a Python
    1818. 

  1818.         list comprehension to iterate through the COM collection object and call
    1819. 

  1819.         the Name property on each item object in the collection.&nbsp; Each
    1820. 

  1820.         item's Name property is a string that Word is suggesting as a correct
    1821. 

  1821.         spelling.</p></li>
    1822. 

  1822.     </ol>
    1823. 

  1823.     <p class="TypedExample">def suggestions(word):<br>
    1824. 

  1824. &nbsp;&nbsp; res_objects = w.GetSpellingSuggestions(word)<br>
    1825. 

  1825. &nbsp;&nbsp; return [x.Name for x in res_objects]</p>
    1826. 

  1826. <p class="Code-Background"></p>
    1827. 

  1827.     <ol start="7">
    1828. 

  1828.         <li>
    1829. 

  1829.         <p class="Step">Now, let's shut down Word and exit the IronPython
    1830. 

  1830.         console.&nbsp; When you enter the next line and hit return, if you are
    1831. 

  1831.         watching the Windows Task Manager, you will see the WINWORD.EXE process
    1832. 

  1832.         go away.</p></li>
    1833. 

  1833.     </ol>
    1834. 

  1834.     <p class="TypedExample">w.Quit()</p>
    1835. 

  1835.     <p class="Code-Background"></p>
    1836. 

  1836.     <h3><a name="T3.1.2">Task 2: Use Windows Form Dialog to Correct Spelling</a></h3>
    1837. 

  1837.     <p class="Body">In this task you will use an example already written that is
    1838. 

  1838.     very similar to what you did in Task 1, but it demonstrates two additional
    1839. 

  1839.     features.&nbsp; It uses a Python standard module to register a clean up
    1840. 

  1840.     function so that when the IronPython console terminates, the Word process is
    1841. 

  1841.     closed.&nbsp; The example also has a function, correct_word, that uses a
    1842. 

  1842.     Windows Form as a dialog to let users select a correct word to return.</p>
    1843. 

  1843.     <ol>
    1844. 

  1844.         <li>
    1845. 

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

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

  1847.         </li>
    1848. 

  1848.         <li>
    1849. 

  1849.         <p class="Step">Import spellcheck.</p>
    1850. 

  1850.         </li>
    1851. 

  1851.         <li>
    1852. 

  1852.         <p class="Step">Call spellcheck.correct_word on a correctly spelled
    1853. 

  1853.         word, and you'll see the function returns the word.</p>
    1854. 

  1854.         </li>
    1855. 

  1855.         <li>
    1856. 

  1856.         <p class="Step">Call spellcheck.correct_word on a misspelled word, and a
    1857. 

  1857.         Windows Form similar to Word's spelling correction dialog appears.&nbsp;
    1858. 

  1858.         You can pick from the list and click the Replace button, double click a
    1859. 

  1859.         word in the suggestions list, enter custom text and click the Use Custom
    1860. 

  1860.         button, click an Ignore button to return the misspelled word, and so on. </p>
    1861. 

  1861.         </li>
    1862. 

  1862.         <li>
    1863. 

  1863.         <p class="Step">Open the spellcheck.py file to see the code for the the
    1864. 

  1864.         Windows Form as well as the functions.</li>
    1865. 

  1865.     </ol>
    1866. 

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

  1867.     <p class="LabSummary">Tutorial Summary</p>
    1868. 

  1868.     <p class="Body">This tutorial was focused on using COM interop to control COM objects from the IronPython environment.</p>
    1869. 

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

  1870.     <ul>
    1871. 

  1871.         <li>
    1872. 

  1872.         <p class="ExerciseList"><a href="#T3.1">Word Spell Checking</a></p>
    1873. 

  1873.         </li>
    1874. 

  1874.     </ul>
    1875. 

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

  1876.     <p class="Body">You used Word to check the spelling of words, learned
    1877. 

  1877.     how to supply missing optional arguments, and inspected code that builds a
    1878. 

  1878.     Windows Form and uses it as a dialog.</p>
    1879. 

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

  1880.     <h1><a name="T4">Tutorial 4: Debugging IronPython programs</a></h1>
    1881. 

  1881.     <p class="Body">This tutorial will walk you through a very simple debug session,
    1882. 

  1882.     debugging a Python script using the Microsoft CLR Debugger.&nbsp; If you have a
    1883. 

  1883.     Visual Studio SKU, see <a href="#T7">using Visual Studio</a>, and consider skipping
    1884. 

  1884.     this exercise.</p>
    1885. 

  1885.     <p class="Body">Estimated time to complete this tutorial: <b>10 minutes</b></p>
    1886. 

  1886.     <p class="Body">The objective of this tutorial is debugging simple Python script
    1887. 

  1887.     using Microsoft CLR Debugger.</p>
    1888. 

  1888.     <ul>
    1889. 

  1889.         <li>
    1890. 

  1890.         <p class="Body"><a href="#T4.1">Debugging IronPython programs</a></p>
    1891. 

  1891.         </li>
    1892. 

  1892.     </ul>
    1893. 

  1893.     <h2><a name="T4.1">Exercise 1: Debugging IronPython programs</a></h2>
    1894. 

  1894.     <p class="Body">In this exercise, you will step through a simple Python script
    1895. 

  1895.     in the Microsoft CLR Debugger.</p>
    1896. 

  1896.     <h3><a name="T4.1.1">Task 1: Debugging IronPython programs using Microsoft CLR
    1897. 

  1897.     Debugger</a></h3>
    1898. 

  1898.     <ol>
    1899. 

  1899.         <li>
    1900. 

  1900.         <p class="Step">Launch Microsoft CLR Debugger.</p>
    1901. 

  1901.         </li>
    1902. 

  1902.         <li>
    1903. 

  1903.         <p class="Step">From the debugger Menu, select Debug / Program to Debug
    1904. 

  1904.         ...</p>
    1905. 

  1905.         </li>
    1906. 

  1906.         <li>
    1907. 

  1907.         <p class="Step">For Program, browse to the ipy.exe (located
    1908. 

  1908.         in the installaton directory)</p>
    1909. 

  1909.         </li>
    1910. 

  1910.         <li>
    1911. 

  1911.         <p class="Step">For Arguments, type in &quot;-D debugging.py&quot;</p>
    1912. 

  1912.         </li>
    1913. 

  1913.         <li>
    1914. 

  1914.         <p class="Step">Change Working directory to the Tutorial directory</p>
    1915. 

  1915.         </li>
    1916. 

  1916.         <li>
    1917. 

  1917.         <p class="Step">Click OK</p>
    1918. 

  1918.         </li>
    1919. 

  1919.         <li>
    1920. 

  1920.         <p class="Step">From the Menu, select File / Open / File. Browse to the
    1921. 

  1921.         Tutorial directory and select two files to open:</p>
    1922. 

  1922.         </li>
    1923. 

  1923.     </ol>
    1924. 

  1924.     <p class="Body">debugging.py</p>
    1925. 

  1925.     <p class="Body">first.py</p>
    1926. 

  1926.     <ol start="8">
    1927. 

  1927.         <li>
    1928. 

  1928.         <p class="Step">Place breakpoint at the following line of the debugging.py
    1929. 

  1929.         file (Place cursor on the line and pres F9):</p>
    1930. 

  1930.         </li>
    1931. 

  1931.     </ol>
    1932. 

  1932.     <p class="Body">print first.add(1, 2)</p>
    1933. 

  1933.     <ol start="9">
    1934. 

  1934.         <li>
    1935. 

  1935.         <p class="Step">Press F5 - Start Debugging.</p>
    1936. 

  1936.         </li>
    1937. 

  1937.     </ol>
    1938. 

  1938.     <p class="Stepnonumbering">IronPython will compile the debugging.py file and
    1939. 

  1939.     start executing it. You will hit the breakpoint you inserted at line 3.</p>
    1940. 

  1940.     <p class="StepNote">Note: If you get poor performance starting the debugging
    1941. 

  1941.     session, exit the debugger, open the Windows Explorer and delete the following
    1942. 

  1942.     directory:</p>
    1943. 

  1943.     <p class="StepNote">%USERPROFILE%\Application Data\Microsoft\DbgClr</p>
    1944. 

  1944.     <ol start="10">
    1945. 

  1945.         <li>
    1946. 

  1946.         <p class="Step">Pressing F11, step through the execution of the program,
    1947. 

  1947.         explore variables (even change the values of the variables in the watch
    1948. 

  1948.         window) and explore the call stack. </p>
    1949. 

  1949.         </li>
    1950. 

  1950.         <li>
    1951. 

  1951.         <p class="Step">End the debugging session and exit the debugger.</p>
    1952. 

  1952.         </li>
    1953. 

  1953.     </ol>
    1954. 

  1954.     <p class="LabSummary">Tutorial Summary</p>
    1955. 

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

  1956.     <ul>
    1957. 

  1957.         <li>
    1958. 

  1958.         <p class="Body"><a href="#T4.1">Debugging IronPython programs</a></p>
    1959. 

  1959.         </li>
    1960. 

  1960.     </ul>
    1961. 

  1961.     <p class="Body">In this tutorial, you walked through the simple debug session
    1962. 

  1962.     of IronPython program. You used Microsoft CLR Debugger, placed breakpoints and
    1963. 

  1963.     stepped through the Python program execution.</p>
    1964. 

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

  1965.     <h1><a name="T5">Tutorial 5: Extending IronPython</a></h1>
    1966. 

  1966.     <p class="Body">Estimated time to complete this tutorial: <b>25- 60 minutes</b></p>
    1967. 

  1967.     <p class="Body">The objective of this tutorial is to implement the class which
    1968. 

  1968.     will seamlessly fit into the IronPython environment. You can choose to follow
    1969. 

  1969.     Exercise 1 - C# implementation, Exercise 2 - Visual Basic, or both. Both tracks
    1970. 

  1970.     will result in the same functionality.</p>
    1971. 

  1971.     <ul>
    1972. 

  1972.         <li>
    1973. 

  1973.         <p class="Body"><a href="#T5.1">Extending using C#</a></p>
    1974. 

  1974.         </li>
    1975. 

  1975.         <li>
    1976. 

  1976.         <p class="Body"><a href="#T5.2">Extending using Visual Basic.NET</a></p>
    1977. 

  1977.         </li>
    1978. 

  1978.     </ul>
    1979. 

  1979.     <h2><a name="T5.1">Exercise 1: Extending using C#</a></h2>
    1980. 

  1980.     <p class="Body">In this exercise you will use C# language to build a class that
    1981. 

  1981.     supports enumeration, custom operators and delegates, and you will use that class
    1982. 

  1982.     from IronPython.  It’s worth noting that as Python does not contain protected class members,
    1983. 

  1983.     such members get promoted to public class members when imported into IronPython.  Private
    1984. 

  1984.     class members, however, will be invisible in IronPython when imported.</p>
    1985. 

  1985.     <h3><a name="T5.1.1">Task 1: Implementing a simple class - constructor and ToString</a></h3>
    1986. 

  1986.     <ol>
    1987. 

  1987.         <li>
    1988. 

  1988.         <p class="Step">Open the &quot;SDK Command Prompt&quot; or &quot;Visual Studio 2010 
    1989. 

  1989. 		Command Prompt&quot; from the start menu. A more recent Visual Studio command 
    1990. 

  1990. 		prompt should also work.</p>
    1991. 

  1991.         </li>
    1992. 

  1992.         <li>
    1993. 

  1993.         <p class="Step">Open the &quot;csextend.cs&quot; file in Notepad or your favorite text
    1994. 

  1994.         editor. The file is initially empty.</p>
    1995. 

  1995.         </li>
    1996. 

  1996.     </ol>
    1997. 

  1997.     <p class="DosExample">notepad csextend.cs</p>
    1998. 

  1998.     <ol start="3">
    1999. 

  1999.         <li>
    2000. 

  2000.         <p class="Step">Add using clauses at the beginning of the file:</p>
    2001. 

  2001.         </li>
    2002. 

  2002.     </ol>
    2003. 

  2003.     <p class="CodeSample">using System;<br />
    2004. 

  2004.     using System.Collections;</p>
    2005. 

  2005.     <ol start="4">
    2006. 

  2006.         <li>
    2007. 

  2007.         <p class="Step">Define a simple class:</p>
    2008. 

  2008.         </li>
    2009. 

  2009.     </ol>
    2010. 

  2010.     <p class="CodeSample">public class Simple {<br />
    2011. 

  2011. &nbsp;&nbsp;&nbsp; private int data;<br>
    2012. 

  2012.     <br />
    2013. 

  2013. &nbsp;&nbsp;&nbsp; public Simple(int data) {<br />
    2014. 

  2014. &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; this.data = data;<br />
    2015. 

  2015. &nbsp;&nbsp;&nbsp; }<br>
    2016. 

  2016.     <br />
    2017. 

  2017. &nbsp;&nbsp;&nbsp; public override string ToString() {<br />
    2018. 

  2018. &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; return String.Format(&quot;Simple&lt;{0}&gt;&quot;, data);<br />
    2019. 

  2019. &nbsp;&nbsp;&nbsp; }<br />
    2020. 

  2020.     }</p>
    2021. 

  2021.     <ol start="5">
    2022. 

  2022.         <li>
    2023. 

  2023.         <p class="Step">Switch back to the Command Prompt window and build the
    2024. 

  2024.         code using available csx.bat (C# extension):</p>
    2025. 

  2025.         </li>
    2026. 

  2026.     </ol>
    2027. 

  2027.     <p class="DosExample">csx</p>
    2028. 

  2028.     <ol start="6">
    2029. 

  2029.         <li>
    2030. 

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

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

  2032.         </li>
    2033. 

  2033.     </ol>
    2034. 

  2034.     <ol start="7">
    2035. 

  2035.         <li>
    2036. 

  2036.         <p class="Step">Load the dll that you just built (csextend.dll) into IronPython.
    2037. 

  2037.         Then explore the Simple class using built-in dir() function:</p>
    2038. 

  2038.         </li>
    2039. 

  2039.     </ol>
    2040. 

  2040.     <p class="TypedExample">import clr</p>
    2041. 

  2041.     <p class="Code-Background"></p>
    2042. 

  2042.     <p class="UserCode">clr.AddReferenceToFile(&quot;csextend.dll&quot;)</p>
    2043. 

  2043.     <p class="HiddenCode">clr.AddReferenceToFile(&quot;csextend_5.1.1.dll&quot;)</p>
    2044. 

  2044.     <p class="Code-Background"></p>
    2045. 

  2045.     <p class="TypedExample">import Simple</p>
    2046. 

  2046.     <p class="Code-Background"></p>
    2047. 

  2047.     <p class="UserCode">dir(Simple)</p>
    2048. 

  2048.     <p class="HiddenCode">set1 = set(dir(Simple))
    2049. 

  2049. set2 = set(dir(object))
    2050. 

  2050. list(set1-set2)</p>
    2051. 

  2051.     <p class="HiddenOutput">
    2052. 

  2052. 

  2053. []</p>
    2054. 

  2054.     <p class="Stepnonumbering">You will see following output:</p>
    2055. 

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

  2056.     &gt;&gt;&gt; clr.AddReferenceToFile(&quot;csextend.dll&quot;)<br />
    2057. 

  2057.     &gt;&gt;&gt; import Simple<br />
    2058. 

  2058.     &gt;&gt;&gt; dir(Simple)<br /></p>
    2059. 

  2059.     <p class="Code-Highlighted">['Equals', 'GetHashCode', 'GetType', 'MemberwiseClone', 'ReferenceEquals', 'ToString', '__class__', '__delattr__', '__doc__', '__format__', '__getattribute__', '__hash__', '__init__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__']</p>
    2060. 

  2060.     <ol start="8">
    2061. 

  2061.         <li>
    2062. 

  2062.         <p class="Step">Instantiate the Simple class:</p>
    2063. 

  2063.         </li>
    2064. 

  2064.     </ol>
    2065. 

  2065.     <p class="TypedExample">s = Simple(10)</p>
    2066. 

  2066.     <p class="Code-Background"></p>
    2067. 

  2067.     <p class="TypedExample">print s</p>
    2068. 

  2068.     <p class="Stepnonumbering">IronPython will output:</p>
    2069. 

  2069.     <p class="Code-Highlighted">&gt;&gt;&gt; s = Simple(10)<br />
    2070. 

  2070.     &gt;&gt;&gt; print s</p>
    2071. 

  2071.     <p class="Code-Background">Simple&lt;10&gt;</p>
    2072. 

  2072.     <ol start="9">
    2073. 

  2073.         <li>
    2074. 

  2074.         <p class="Step">You have just explored all the functionality currently available
    2075. 

  2075.         in the Simple class. Exit IronPython and return to the C# code to add more.</p>
    2076. 

  2076.         </li>
    2077. 

  2077.     </ol>
    2078. 

  2078.     <h3><a name="T5.1.2">Task 2: Making the object enumerable</a></h3>
    2079. 

  2079.     <ol>
    2080. 

  2080.         <li>
    2081. 

  2081.         <p class="Step">Back in Notepad, open &quot;csextend.cs&quot; to add more functionality
    2082. 

  2082.         to the Simple class.</p>
    2083. 

  2083.         </li>
    2084. 

  2084.         <li>
    2085. 

  2085.         <p class="Step">First, inherit the Simple class from IEnumerable and implement the
    2086. 

  2086.         GetEnumerator() method. Use the C#'s new &quot;yield return&quot; statement:</p>
    2087. 

  2087.         </li>
    2088. 

  2088.     </ol>
    2089. 

  2089.     <p class="CodeSample">public class Simple : IEnumerable {<br>
    2090. 

  2090.     <br />
    2091. 

  2091. &nbsp;&nbsp;&nbsp; private int data;<br /><br />
    2092. 

  2092. &nbsp;&nbsp;&nbsp; public Simple(int data) {<br />
    2093. 

  2093. &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; this.data = data;<br />
    2094. 

  2094. &nbsp;&nbsp;&nbsp; }<br /><br />
    2095. 

  2095. &nbsp;&nbsp;&nbsp; public override string ToString() {<br />
    2096. 

  2096. &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; return String.Format(&quot;Simple&lt;{0}&gt;&quot;, data);<br />
    2097. 

  2097. &nbsp;&nbsp;&nbsp; }<br />
    2098. 

  2098. &nbsp;<br />
    2099. 

  2099.     &nbsp;&nbsp;&nbsp; public IEnumerator GetEnumerator()
    2100. 

  2100.     {<br />
    2101. 

  2101. &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; for (int i = 0; i &lt; data; i++) {<br />
    2102. 

  2102. &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; yield return
    2103. 

  2103.     new Simple(i);<br />
    2104. 

  2104. &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; }<br />
    2105. 

  2105. &nbsp;&nbsp;&nbsp; }</p>
    2106. 

  2106.     <p class="CodeSample">}</p>
    2107. 

  2107.     <ol start="3">
    2108. 

  2108.         <li>
    2109. 

  2109.         <p class="Step">Save the changes, compile the code (csx), launch IronPython
    2110. 

  2110.         Console (ip) and test the code:</p>
    2111. 

  2111.         </li>
    2112. 

  2112.     </ol>
    2113. 

  2113.     <p class="TypedExample">import clr</p>
    2114. 

  2114.     <p class="Code-Background"></p>
    2115. 

  2115.     <p class="UserCode">clr.AddReferenceToFile(&quot;csextend.dll&quot;)</p>
    2116. 

  2116.     <p class="HiddenCode">clr.AddReferenceToFile(&quot;csextend_5.1.2.dll&quot;)</p>
    2117. 

  2117.     <p class="Code-Background"></p>
    2118. 

  2118.     <p class="TypedExample">import Simple</p>
    2119. 

  2119.     <p class="Code-Background"></p>
    2120. 

  2120.     <p class="UserCode">dir(Simple)</p>
    2121. 

  2121.     <p class="HiddenCode">set1 = set(dir(Simple))
    2122. 

  2122. set2 = set(dir(object))
    2123. 

  2123. list(set1-set2)</p>
    2124. 

  2124.     <p class="HiddenOutput">
    2125. 

  2125. 

  2126. ['GetEnumerator','__iter__']</p>
    2127. 

  2127.     <p class="TypedExample">s = Simple(10)</p>
    2128. 

  2128.     <p class="Code-Background"></p>
    2129. 

  2129.     <p class="TypedExample">for i in s: print i</p>
    2130. 

  2130.     <p class="Stepnonumbering">You will get the following output in the IronPython
    2131. 

  2131.     console window:</p>
    2132. 

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

  2133.     &gt;&gt;&gt; clr.AddReferenceToFile(&quot;csextend.dll&quot;)<br />
    2134. 

  2134.     &gt;&gt;&gt; import Simple<br />
    2135. 

  2135.     &gt;&gt;&gt; dir(Simple)<br />
    2136. 

  2136.     <p class="Code-Highlighted">['Equals', 'GetEnumerator', 'GetHashCode', 'GetType', 'MemberwiseClone', 'ReferenceEquals', 'ToString', '__class__', '__delattr__', '__doc__', '__format__', '__getattribute__', '__hash__', '__init__', '__iter__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__']</p>
    2137. 

  2137.     <p class="Code-Highlighted">&gt;&gt;&gt; s = Simple(10)<br />
    2138. 

  2138.     &gt;&gt;&gt; for i in s: print i</p>
    2139. 

  2139.     <p class="Code-Background">Simple&lt;0&gt;<br />
    2140. 

  2140.     Simple&lt;1&gt;<br />
    2141. 

  2141.     Simple&lt;2&gt;<br />
    2142. 

  2142.     Simple&lt;3&gt;<br />
    2143. 

  2143.     Simple&lt;4&gt;<br />
    2144. 

  2144.     Simple&lt;5&gt;<br />
    2145. 

  2145.     Simple&lt;6&gt;<br />
    2146. 

  2146.     Simple&lt;7&gt;<br />
    2147. 

  2147.     Simple&lt;8&gt;<br />
    2148. 

  2148.     Simple&lt;9&gt;</p>
    2149. 

  2149.     <p class="StepNote">Notice that the dir() function now shows the GetEnumerator
    2150. 

  2150.     method.</p>
    2151. 

  2151.     <ol start="4">
    2152. 

  2152.         <li>
    2153. 

  2153.         <p class="Step">Exit IronPython and return to the C# code to add more
    2154. 

  2154.         functionality.</p>
    2155. 

  2155.         </li>
    2156. 

  2156.     </ol>
    2157. 

  2157.     <h3><a name="T5.1.3">Task 3: Adding a custom operator</a></h3>
    2158. 

  2158.     <ol>
    2159. 

  2159.         <li>
    2160. 

  2160.         <p class="Step">Add the operator + method:</p>
    2161. 

  2161.         </li>
    2162. 

  2162.     </ol>
    2163. 

  2163.     <p class="CodeSample">using System;<br />
    2164. 

  2164.     using System.Collections;</br>
    2165. 

  2165.     <br />
    2166. 

  2166.     public class Simple : IEnumerable {<br />
    2167. 

  2167. &nbsp;&nbsp;&nbsp; private int data;<br />
    2168. 

  2168. &nbsp;&nbsp;&nbsp; public Simple(int data) {<br />
    2169. 

  2169. &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; this.data = data;<br />
    2170. 

  2170. &nbsp;&nbsp;&nbsp; }<br />
    2171. 

  2171. &nbsp;&nbsp;&nbsp; public override string ToString() {<br />
    2172. 

  2172. &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; return String.Format(&quot;Simple&lt;{0}&gt;&quot;, data);<br />
    2173. 

  2173. &nbsp;&nbsp;&nbsp; }<br />
    2174. 

  2174. &nbsp;&nbsp;&nbsp; public IEnumerator GetEnumerator() {<br />
    2175. 

  2175. &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; for (int i = 0; i &lt; data; i ++) {<br />
    2176. 

  2176. &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; yield return
    2177. 

  2177.     new Simple(i);<br />
    2178. 

  2178. &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; }<br />
    2179. 

  2179. &nbsp;&nbsp;&nbsp; }<br />
    2180. 

  2180. &nbsp;</br>
    2181. 

  2181.     &nbsp;&nbsp;&nbsp; public static Simple operator +(Simple a, Simple b) {<br />
    2182. 

  2182. &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; return new Simple(a.data + b.data);<br />
    2183. 

  2183. &nbsp;&nbsp;&nbsp; }</br>
    2184. 

  2184.     }</p>
    2185. 

  2185.     <ol start="2">
    2186. 

  2186.         <li>
    2187. 

  2187.         <p class="Step">Return to the command prompt, compile the code (csx), launch
    2188. 

  2188.         IronPython Console (ip) and test the code:</p>
    2189. 

  2189.         </li>
    2190. 

  2190.     </ol>
    2191. 

  2191.     <p class="TypedExample">import clr</p>
    2192. 

  2192.     <p class="Code-Background"></p>
    2193. 

  2193.     <p class="UserCode">clr.AddReferenceToFile(&quot;csextend.dll&quot;)</p>
    2194. 

  2194.     <p class="HiddenCode">clr.AddReferenceToFile(&quot;csextend_5.1.3.dll&quot;)</p>
    2195. 

  2195.         <p class="Code-Background"></p>
    2196. 

  2196.     <p class="TypedExample">import Simple</p>
    2197. 

  2197.         <p class="Code-Background"></p>
    2198. 

  2198.     <p class="UserCode">dir(Simple)</p>
    2199. 

  2199.     <p class="HiddenCode">set1 = set(dir(Simple))
    2200. 

  2200. set2 = set(dir(object))
    2201. 

  2201. list(set1-set2)</p>
    2202. 

  2202.     <p class="HiddenOutput">
    2203. 

  2203. 

  2204.     ['__radd__','__add__','GetEnumerator','__iter__']</p>
    2205. 

  2205.     <p class="TypedExample">a = Simple(10)</p>
    2206. 

  2206.         <p class="Code-Background"></p>
    2207. 

  2207.     <p class="TypedExample">b = Simple(20)</p>
    2208. 

  2208.         <p class="Code-Background"></p>
    2209. 

  2209.     <p class="TypedExample">a + b</p>
    2210. 

  2210.     <p class="LooseVerify">Simple&lt;30&gt;</p>
    2211. 

  2211.     <p class="Stepnonumbering">Notice in the output of dir() that you will now see
    2212. 

  2212.     the additional methods __add__ and __radd__, Python's notion of custom operator
    2213. 

  2213.     implementation:</p>
    2214. 

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

  2215.     &gt;&gt;&gt; clr.AddReferenceToFile(&quot;csextend.dll&quot;)<br />
    2216. 

  2216.     &gt;&gt;&gt; import Simple<br />
    2217. 

  2217.     &gt;&gt;&gt; dir(Simple)</p>
    2218. 

  2218.     <p class="Code-Highlighted">['Equals', 'GetEnumerator', 'GetHashCode', 'GetType', 'MemberwiseClone', 'ReferenceEquals', 'ToString', '__add__', '__class__', '__delattr__', '__doc__', '__format__', '__getattribute__', '__hash__', '__init__', '__iter__', '__new__', '__radd__', '__reduce__', '__reduce_ex__', '__repr__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__']</p>
    2219. 

  2219.     <p class="Code-Highlighted">&gt;&gt;&gt; a = Simple(10)<br />
    2220. 

  2220.     &gt;&gt;&gt; b = Simple(20)</p>
    2221. 

  2221.     <p class="Code-Highlighted">&gt;&gt;&gt; a + b</p>
    2222. 

  2222.     <p class="Code-Background">&lt;Simple object at 0x000000000000002B [Simple&lt;30&gt;]&gt;</p>
    2223. 

  2223.     <ol start="3">
    2224. 

  2224.         <li>
    2225. 

  2225.         <p class="Step">Exit IronPython and return to the C# code to add more
    2226. 

  2226.         functionality.</p>
    2227. 

  2227.         </li>
    2228. 

  2228.     </ol>
    2229. 

  2229.     <h3><a name="T5.1.4">Task 4: Adding a delegate</a></h3>
    2230. 

  2230.     <ol>
    2231. 

  2231.         <li>
    2232. 

  2232.         <p class="Step">Add the declaration of the delegate to the top of the C#
    2233. 

  2233.         source file:</p>
    2234. 

  2234.         </li>
    2235. 

  2235.     </ol>
    2236. 

  2236.     <p class="CodeSample">using System;<br />
    2237. 

  2237.     using System.Collections;<br />
    2238. 

  2238. &nbsp;<br>
    2239. 

  2239.    public delegate int Transformer(int input);</p>
    2240. 

  2240.     <ol start="2">
    2241. 

  2241.         <li>
    2242. 

  2242.         <p class="Step">Add the &quot;Transform&quot; method to the Simple class,
    2243. 

  2243.         which takes the delegate as a parameter and invokes the it:</p>
    2244. 

  2244.         </li>
    2245. 

  2245.     </ol>
    2246. 

  2246.     <p class="CodeSample">using System;<br />
    2247. 

  2247.     using System.Collections;<br />
    2248. 

  2248. &nbsp;<br>
    2249. 

  2249.     public delegate int Transformer(int input);<br>
    2250. 

  2250.     <br />
    2251. 

  2251.     public class Simple : IEnumerable {<br />
    2252. 

  2252. &nbsp;&nbsp;&nbsp; private int data;<br />
    2253. 

  2253. &nbsp;&nbsp;&nbsp; public Simple(int data) {<br />
    2254. 

  2254. &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; this.data = data;<br />
    2255. 

  2255. &nbsp;&nbsp;&nbsp; }<br>
    2256. 

  2256.     <br />
    2257. 

  2257. &nbsp;&nbsp;&nbsp; public override string ToString() {<br />
    2258. 

  2258. &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; return String.Format(&quot;Simple&lt;{0}&gt;&quot;, data);<br />
    2259. 

  2259. &nbsp;&nbsp;&nbsp; }<br>
    2260. 

  2260.     <br />
    2261. 

  2261. &nbsp;&nbsp;&nbsp; public IEnumerator GetEnumerator() {<br />
    2262. 

  2262. &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; for (int i = 0; i &lt; data; i ++) {<br />
    2263. 

  2263. &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; yield return
    2264. 

  2264.     new Simple(i);<br />
    2265. 

  2265. &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; }<br />
    2266. 

  2266. &nbsp;&nbsp;&nbsp; }<br />
    2267. 

  2267. &nbsp;<br>
    2268. 

  2268.     &nbsp;&nbsp;&nbsp; public int Transform(Transformer
    2269. 

  2269.     t) {<br />
    2270. 

  2270. &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; return t(data);<br />
    2271. 

  2271. &nbsp;&nbsp;&nbsp; }<br>
    2272. 

  2272.     <br />
    2273. 

  2273. &nbsp;&nbsp;&nbsp; public static Simple operator +(Simple a, Simple b) {<br />
    2274. 

  2274. &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; return new Simple(a.data + b.data);<br />
    2275. 

  2275. &nbsp;&nbsp;&nbsp; }<br />
    2276. 

  2276.     }</p>
    2277. 

  2277.     <ol start="3">
    2278. 

  2278.         <li>
    2279. 

  2279.         <p class="Step">Return to the command prompt, compile the code
    2280. 

  2280.         (csx), launch IronPython Console (ip) and test the code:</p>
    2281. 

  2281.         </li>
    2282. 

  2282.     </ol>
    2283. 

  2283.     <p class="TypedExample">import clr</p>
    2284. 

  2284.     <p class="Code-Background"></p>
    2285. 

  2285.     <p class="UserCode">clr.AddReferenceToFile(&quot;csextend.dll&quot;)</p>
    2286. 

  2286.     <p class="HiddenCode">clr.AddReferenceToFile(&quot;csextend_5.1.4.dll&quot;)</p>
    2287. 

  2287.     <p class="Code-Background"></p>
    2288. 

  2288.     <p class="TypedExample">import Simple</p>
    2289. 

  2289.     <p class="Code-Background"></p>
    2290. 

  2290.     <p class="TypedExample">a = Simple(10)</p>
    2291. 

  2291.     <p class="Code-Background"></p>
    2292. 

  2292.     <p class="TypedExample">def X(i):<br>
    2293. 

  2293. &nbsp;&nbsp;&nbsp; return i + 100</p>
    2294. 

  2294.     <p class="Code-Background"></p>
    2295. 

  2295.     <p class="TypedExample">a.Transform(X)</p>
    2296. 

  2296.     <p class="Stepnonumbering">The function X is getting passed as the delegate
    2297. 

  2297.     to the Simple&#39;s Transform method. You will get following output:</p>
    2298. 

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

  2299.     &gt;&gt;&gt; clr.AddReferenceToFile(&quot;csextend.dll&quot;)<br />
    2300. 

  2300.     &gt;&gt;&gt; import Simple<br />
    2301. 

  2301.     &gt;&gt;&gt; a = Simple(10)</p>
    2302. 

  2302.     <p class="Code-Highlighted">&gt;&gt;&gt; def X(i):<br />
    2303. 

  2303.     ...&nbsp;&nbsp;&nbsp;&nbsp; return i + 100<br />
    2304. 

  2304.     ...<br />
    2305. 

  2305.     &gt;&gt;&gt; a.Transform(X)</p>
    2306. 

  2306.     <p class="Code-Background">110</p>
    2307. 

  2307.     <ol start="4">
    2308. 

  2308.         <li>
    2309. 

  2309.         <p class="Step">This concludes the C# extending example. An interesting optional
    2310. 

  2310.         exercise is to combine the debugging example with this one. If you are so inclined,
    2311. 

  2311.         try debugging the script that you just typed in. To do so, open the
    2312. 

  2312.         &quot;debugcsx.py&quot; script located in Tutorial directory and place a breakpoint
    2313. 

  2313.         on the function 'X'. You will see a mixed call stack between C# and IronPython.</p>
    2314. 

  2314.         </li>
    2315. 

  2315.     </ol>
    2316. 

  2316.     <h2><a name="T5.2">Exercise 2: Extending using Visual Basic.NET</a></h2>
    2317. 

  2317.     <p class="Body">In this exercise you will use the Visual Basic .NET language to
    2318. 

  2318.     build a class that supports enumeration, custom operators and delegates, and
    2319. 

  2319.     you will use that class from IronPython.  It’s worth noting that as Python does
    2320. 

  2320.     not contain protected class members, these members become public when imported into
    2321. 

  2321.     IronPython. Private class members, however, will be invisible from IronPython.</p>
    2322. 

  2322.     <h3><a name="T5.2.1">Task 1: Implementing a simple class - constructor and ToString</a></h3>
    2323. 

  2323.     <ol>
    2324. 

  2324.         <li>
    2325. 

  2325.         <p class="Step">Open the &quot;SDK Command Prompt&quot; or &quot;Visual Studio 
    2326. 

  2326. 		2010 Command Prompt&quot; from the start menu. A more recent Visual Studio 
    2327. 

  2327. 		Command Prompt should also work.</p>
    2328. 

  2328.         </li>
    2329. 

  2329.         <li>
    2330. 

  2330.         <p class="Step">Open &quot;vbextend.vb&quot; in notepad or your favorite text editor. The
    2331. 

  2331.         file is initially empty.</p>
    2332. 

  2332.         </li>
    2333. 

  2333.     </ol>
    2334. 

  2334.     <p class="DosExample">notepad vbextend.vb</p>
    2335. 

  2335.     <ol start="3">
    2336. 

  2336.         <li>
    2337. 

  2337.         <p class="Step">Add Imports clauses at the beginning of the file:</p>
    2338. 

  2338.         </li>
    2339. 

  2339.     </ol>
    2340. 

  2340.     <p class="CodeSample">Imports System<br />
    2341. 

  2341.     Imports System.Collections</p>
    2342. 

  2342.     <ol start="4">
    2343. 

  2343.         <li>
    2344. 

  2344.         <p class="Step">Define a simple class:</p>
    2345. 

  2345.         </li>
    2346. 

  2346.     </ol>
    2347. 

  2347.     <p class="CodeSample">Public Class Simple<br />
    2348. 

  2348. &nbsp;&nbsp;&nbsp; Private data As Integer<br />
    2349. 

  2349.     <br />
    2350. 

  2350. &nbsp;&nbsp;&nbsp; Public Sub New(ByVal data As Integer)<br />
    2351. 

  2351. &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; Me.data = data<br />
    2352. 

  2352. &nbsp;&nbsp;&nbsp; End Sub<br />
    2353. 

  2353.     <br />
    2354. 

  2354. &nbsp;&nbsp;&nbsp; Overrides Function ToString() As String<br />
    2355. 

  2355. &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; Return String.Format(&quot;Simple&lt;{0}&gt;&quot;, data)<br />
    2356. 

  2356. &nbsp;&nbsp;&nbsp; End Function<br />
    2357. 

  2357. &nbsp;</p>
    2358. 

  2358.     <p class="CodeSample">End Class</p>
    2359. 

  2359.     <ol start="5">
    2360. 

  2360.         <li>
    2361. 

  2361.         <p class="Step">Switch back to the Command Prompt window and build the
    2362. 

  2362.         code using the available vbx.bat (Visual Basic extension):</p>
    2363. 

  2363.         </li>
    2364. 

  2364.     </ol>
    2365. 

  2365.     <p class="DosExample">vbx</p>
    2366. 

  2366.     <ol start="6">
    2367. 

  2367.         <li>
    2368. 

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

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

  2370.         </li>
    2371. 

  2371.     </ol>
    2372. 

  2372.     <ol start="7">
    2373. 

  2373.         <li>
    2374. 

  2374.         <p class="Step">Load the dll that you just built (vbextend.dll) into IronPython.
    2375. 

  2375.         Then explore the Simple class using built-in dir() function:</p>
    2376. 

  2376.         </li>
    2377. 

  2377.     </ol>
    2378. 

  2378.     <p class="TypedExample">import clr</p>
    2379. 

  2379.     <p class="Code-Background"></p>
    2380. 

  2380.     <p class="UserCode">clr.AddReferenceToFile(&quot;vbextend.dll&quot;)</p>
    2381. 

  2381.     <p class="HiddenCode">clr.AddReferenceToFile(&quot;vbextend_5.2.1.dll&quot;)</p>
    2382. 

  2382.     <p class="Code-Background"></p>
    2383. 

  2383.     <p class="TypedExample">import Simple</p>
    2384. 

  2384.     <p class="Code-Background"></p>
    2385. 

  2385.     <p class="UserCode">dir(Simple)</p>
    2386. 

  2386.     <p class="HiddenCode">set1 = set(dir(Simple))
    2387. 

  2387. set2 = set(dir(object))
    2388. 

  2388. list(set1-set2)</p>
    2389. 

  2389.     <p class="HiddenOutput">
    2390. 

  2390. 

  2391. []</p>
    2392. 

  2392.     <p class="Stepnonumbering">You will see following output:</p>
    2393. 

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

  2394.     &gt;&gt;&gt; clr.AddReferenceToFile(&quot;vbextend.dll&quot;)<br />
    2395. 

  2395.     &gt;&gt;&gt; import Simple<br />
    2396. 

  2396.     &gt;&gt;&gt; dir(Simple)</p>
    2397. 

  2397.     <p class="Code-Highlighted">['Equals', 'GetHashCode', 'GetType', 'MemberwiseClone', 'ReferenceEquals', 'ToString', '__class__', '__delattr__', '__doc__', '__format__', '__getattribute__', '__hash__', '__init__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__']</p>
    2398. 

  2398.     <ol start="8">
    2399. 

  2399.         <li>
    2400. 

  2400.         <p class="Step">Instantiate and print a Simple object:</p>
    2401. 

  2401.         </li>
    2402. 

  2402.     </ol>
    2403. 

  2403.     <p class="TypedExample">s = Simple(10)</p>
    2404. 

  2404.     <p class="Code-Background"></p>
    2405. 

  2405.     <p class="TypedExample">print s</p>
    2406. 

  2406.     <p class="Stepnonumbering">IronPython will output:</p>
    2407. 

  2407.     <p class="Code-Highlighted">&gt;&gt;&gt; s = Simple(10)<br />
    2408. 

  2408.     &gt;&gt;&gt; print s</p>
    2409. 

  2409.     <p class="Code-Background">Simple&lt;10&gt;</p>
    2410. 

  2410.     <ol start="9">
    2411. 

  2411.         <li>
    2412. 

  2412.         <p class="Step">You just have explored all the functionality available in
    2413. 

  2413.         the Simple class. Exit IronPython and return to the Visual Basic code
    2414. 

  2414.         to add more functionality.</p>
    2415. 

  2415.         </li>
    2416. 

  2416.     </ol>
    2417. 

  2417.     <h3><a name="T5.2.2">Task 2: Making the object enumerable</a></h3>
    2418. 

  2418.     <ol>
    2419. 

  2419.         <li>
    2420. 

  2420.         <p class="Step">Back in Notepad, open &quot;vbextend.vb&quot; to add more functionality
    2421. 

  2421.         to the Simple class.</p>
    2422. 

  2422.         </li>
    2423. 

  2423.         <li>
    2424. 

  2424.         <p class="Step">First, inherit the Simple class from IEnumerable and implement
    2425. 

  2425.         the GetEnumerator() method. Unlike C#, Visual Basic does not offer the yield
    2426. 

  2426.         keyword, so implementing IEnumerable interface requires adding a helper class
    2427. 

  2427.         SimpleEnum:</p>
    2428. 

  2428.         </li>
    2429. 

  2429.     </ol>
    2430. 

  2430.     <p class="CodeSample">Imports System<br />
    2431. 

  2431.     Imports System.Collections<br />
    2432. 

  2432. &nbsp;</p>
    2433. 

  2433.     <p class="CodeSample">Public Class SimpleEnum<br />
    2434. 

  2434. &nbsp;&nbsp;&nbsp; Implements IEnumerator<br />
    2435. 

  2435.     <br />
    2436. 

  2436. &nbsp;&nbsp;&nbsp; Private data As Integer<br />
    2437. 

  2437. &nbsp;&nbsp;&nbsp; Private curr As Integer<br />
    2438. 

  2438.     <br />
    2439. 

  2439. &nbsp;&nbsp;&nbsp; Public Sub New(ByVal data As Integer)<br />
    2440. 

  2440. &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; Me.data = data<br />
    2441. 

  2441. &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; Me.curr = -1<br />
    2442. 

  2442. &nbsp;&nbsp;&nbsp; End Sub<br />
    2443. 

  2443.     <br />
    2444. 

  2444. &nbsp;&nbsp;&nbsp; Public ReadOnly Property Current() As Object _<br />
    2445. 

  2445. &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; Implements IEnumerator.Current<br />
    2446. 

  2446. &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; Get<br />
    2447. 

  2447. &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; Return New Simple(curr)<br />
    2448. 

  2448. &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; End Get<br />
    2449. 

  2449. &nbsp;&nbsp;&nbsp; End Property<br />
    2450. 

  2450.     <br />
    2451. 

  2451. &nbsp;&nbsp;&nbsp; Public Function MoveNext() As Boolean _<br />
    2452. 

  2452. &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; Implements IEnumerator.MoveNext<br />
    2453. 

  2453. &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; curr += 1<br />
    2454. 

  2454. &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; Return curr &lt; data<br />
    2455. 

  2455. &nbsp;&nbsp;&nbsp; End Function<br />
    2456. 

  2456.     <br />
    2457. 

  2457. &nbsp;&nbsp;&nbsp; Public Sub Reset() Implements IEnumerator.Reset<br />
    2458. 

  2458. &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; curr = -1<br />
    2459. 

  2459. &nbsp;&nbsp;&nbsp; End Sub<br />
    2460. 

  2460.     End Class</p>
    2461. 

  2461.     <p class="CodeSample"><br />
    2462. 

  2462.     Public Class Simple</p>
    2463. 

  2463.     <p class="CodeSample">&nbsp;&nbsp;&nbsp; Implements IEnumerable<br />
    2464. 

  2464.     <br />
    2465. 

  2465.     <p class="CodeSample">&nbsp;&nbsp;&nbsp; Private data As Integer<br />
    2466. 

  2466.     <br />
    2467. 

  2467. &nbsp;&nbsp;&nbsp; Public Sub New(ByVal data As Integer)<br />
    2468. 

  2468. &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; Me.data = data<br />
    2469. 

  2469. &nbsp;&nbsp;&nbsp; End Sub<br />
    2470. 

  2470.     <br />
    2471. 

  2471. &nbsp;&nbsp;&nbsp; Overrides Function ToString() As String<br />
    2472. 

  2472. &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; Return String.Format(&quot;Simple&lt;{0}&gt;&quot;, data)<br />
    2473. 

  2473. &nbsp;&nbsp;&nbsp; End Function<br />
    2474. 

  2474. &nbsp;</p>
    2475. 

  2475.     <p class="CodeSample">&nbsp;&nbsp;&nbsp; Function GetEnumerator() As IEnumerator
    2476. 

  2476.     _<br />
    2477. 

  2477. &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; Implements IEnumerable.GetEnumerator<br />
    2478. 

  2478. &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; Return New SimpleEnum(data)<br />
    2479. 

  2479. &nbsp;&nbsp;&nbsp; End Function</p>
    2480. 

  2480.     <p class="CodeSample"><br />
    2481. 

  2481.     End Class</p>
    2482. 

  2482.     <ol start="3">
    2483. 

  2483.         <li>
    2484. 

  2484.         <p class="Step">Compile the code (vbx), launch IronPython Console (ip) and
    2485. 

  2485.         test the code:</p>
    2486. 

  2486.         </li>
    2487. 

  2487.     </ol>
    2488. 

  2488.     <p class="TypedExample">import clr</p>
    2489. 

  2489.     <p class="Code-Background"></p>
    2490. 

  2490.     <p class="UserCode">clr.AddReferenceToFile(&quot;vbextend.dll&quot;)</p>
    2491. 

  2491.     <p class="HiddenCode">clr.AddReferenceToFile(&quot;vbextend_5.2.2.dll&quot;)</p>
    2492. 

  2492.     <p class="Code-Background"></p>
    2493. 

  2493.     <p class="TypedExample">import Simple</p>
    2494. 

  2494.     <p class="Code-Background"></p>
    2495. 

  2495.     <p class="UserCode">dir(Simple)</p>
    2496. 

  2496.     <p class="HiddenCode">set1 = set(dir(Simple))
    2497. 

  2497. set2 = set(dir(object))
    2498. 

  2498. list(set1-set2)</p>
    2499. 

  2499.     <p class="HiddenOutput">
    2500. 

  2500. 

  2501. ['GetEnumerator','__iter__']</p>
    2502. 

  2502.     <p class="TypedExample">s = Simple(10)</p>
    2503. 

  2503.     <p class="Code-Background"></p>
    2504. 

  2504.     <p class="TypedExample">for i in s: print i</p>
    2505. 

  2505.     <p class="Stepnonumbering">You will get the following output in the IronPython
    2506. 

  2506.     console window:</p>
    2507. 

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

  2508.     &gt;&gt;&gt; clr.AddReferenceToFile(&quot;vbextend.dll&quot;)<br />
    2509. 

  2509.     &gt;&gt;&gt; import Simple<br />
    2510. 

  2510.     &gt;&gt;&gt; dir(Simple)</p>
    2511. 

  2511.     <p class="Code-Highlighted">['Equals', 'GetEnumerator', 'GetHashCode', 'GetType', 'MemberwiseClone', 'ReferenceEquals', 'ToString', '__class__', '__delattr__', '__doc__', '__format__', '__getattribute__', '__hash__', '__init__', '__iter__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__']</p>
    2512. 

  2512.     <p class="Code-Highlighted">&gt;&gt;&gt; s = Simple(10)<br />
    2513. 

  2513.     &gt;&gt;&gt; for i in s: print i</p>
    2514. 

  2514.     <p class="Code-Background">Simple&lt;0&gt;<br />
    2515. 

  2515.     Simple&lt;1&gt;<br />
    2516. 

  2516.     Simple&lt;2&gt;<br />
    2517. 

  2517.     Simple&lt;3&gt;<br />
    2518. 

  2518.     Simple&lt;4&gt;<br />
    2519. 

  2519.     Simple&lt;5&gt;<br />
    2520. 

  2520.     Simple&lt;6&gt;<br />
    2521. 

  2521.     Simple&lt;7&gt;<br />
    2522. 

  2522.     Simple&lt;8&gt;<br />
    2523. 

  2523.     Simple&lt;9&gt;</p>
    2524. 

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

  2525.     <p class="StepNote">Notice that the dir() function now shows the GetEnumerator
    2526. 

  2526.     method.</p>
    2527. 

  2527.     <ol start="4">
    2528. 

  2528.         <li>
    2529. 

  2529.         <p class="Step">Exit IronPython and return to the Visual Basic code
    2530. 

  2530.         to add more functionality.</p>
    2531. 

  2531.         </li>
    2532. 

  2532.     </ol>
    2533. 

  2533.     <h3><a name="T5.2.3">Task 3: Adding a custom operator</a></h3>
    2534. 

  2534.     <ol>
    2535. 

  2535.         <li>
    2536. 

  2536.         <p class="Step">Add the operator + method to the Simple class:</p>
    2537. 

  2537.         </li>
    2538. 

  2538.     </ol>
    2539. 

  2539.     <p class="CodeSample">Public Class Simple<br />
    2540. 

  2540. &nbsp;&nbsp;&nbsp; Implements IEnumerable<br />
    2541. 

  2541. &nbsp;&nbsp;&nbsp; Private data As Integer<br />
    2542. 

  2542.     <br />
    2543. 

  2543. &nbsp;&nbsp;&nbsp; Public Sub New(ByVal data As Integer)<br />
    2544. 

  2544. &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; Me.data = data<br />
    2545. 

  2545. &nbsp;&nbsp;&nbsp; End Sub<br />
    2546. 

  2546.     <br />
    2547. 

  2547. &nbsp;&nbsp;&nbsp; Overrides Function ToString() As String<br />
    2548. 

  2548. &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; Return String.Format(&quot;Simple&lt;{0}&gt;&quot;, data)<br />
    2549. 

  2549. &nbsp;&nbsp;&nbsp; End Function<br />
    2550. 

  2550.     <br />
    2551. 

  2551. &nbsp;&nbsp;&nbsp; Function GetEnumerator() As IEnumerator _<br />
    2552. 

  2552. &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;
    2553. 

  2553.     Implements IEnumerable.GetEnumerator<br />
    2554. 

  2554. &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; Return New SimpleEnum(data)<br />
    2555. 

  2555. &nbsp;&nbsp;&nbsp; End Function<br />
    2556. 

  2556. &nbsp;</p>
    2557. 

  2557.     <p class="CodeSample">&nbsp;&nbsp;&nbsp; Shared Operator +(ByVal a As
    2558. 

  2558.     Simple, ByVal b As Simple) As Simple<br />
    2559. 

  2559. &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; Return New Simple(a.data + b.data)<br />
    2560. 

  2560. &nbsp;&nbsp;&nbsp; End Operator</p>
    2561. 

  2561.     <p class="CodeSample"><br />
    2562. 

  2562.     End Class</p>
    2563. 

  2563.     <ol start="2">
    2564. 

  2564.         <li>
    2565. 

  2565.         <p class="Step">Compile the code (vbx), launch IronPython Console (ip) and
    2566. 

  2566.         test the code:</p>
    2567. 

  2567.         </li>
    2568. 

  2568.     </ol>
    2569. 

  2569.     <p class="TypedExample">import clr</p>
    2570. 

  2570.     <p class="Code-Background"></p>
    2571. 

  2571.     <p class="UserCode">clr.AddReferenceToFile(&quot;vbextend.dll&quot;)</p>
    2572. 

  2572.     <p class="HiddenCode">clr.AddReferenceToFile(&quot;vbextend_5.2.3.dll&quot;)</p>
    2573. 

  2573.     <p class="Code-Background"></p>
    2574. 

  2574.     <p class="TypedExample">import Simple</p>
    2575. 

  2575.     <p class="Code-Background"></p>
    2576. 

  2576.     <p class="UserCode">dir(Simple)</p>
    2577. 

  2577.     <p class="HiddenCode">set1 = set(dir(Simple))
    2578. 

  2578. set2 = set(dir(object))
    2579. 

  2579. list(set1-set2)</p>
    2580. 

  2580.     <p class="HiddenOutput">
    2581. 

  2581. 

  2582.     ['__radd__','__add__','GetEnumerator','__iter__']</p>
    2583. 

  2583.     <p class="TypedExample">a = Simple(10)</p>
    2584. 

  2584.     <p class="Code-Background"></p>
    2585. 

  2585.     <p class="TypedExample">b = Simple(20)</p>
    2586. 

  2586.     <p class="Code-Background"></p>
    2587. 

  2587.     <p class="TypedExample">a + b</p>
    2588. 

  2588.     <p class="LooseVerify">Simple&lt;30</p>
    2589. 

  2589.     <p class="Stepnonumbering">Notice in the output of dir() that you now see the
    2590. 

  2590.     additional methods __add__ and __radd__, Python's notion of custom operator
    2591. 

  2591.     implementation:</p>
    2592. 

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

  2593.     &gt;&gt;&gt; clr.AddReferenceToFile(&quot;vbextend.dll&quot;)<br />
    2594. 

  2594.     &gt;&gt;&gt; import Simple<br />
    2595. 

  2595.     &gt;&gt;&gt; dir(Simple)</p>
    2596. 

  2596.     <p class="Code-Background">['Equals', 'GetEnumerator', 'GetHashCode', 'GetType', 'MemberwiseClone', 'ReferenceEquals', 'ToString', '__add__', '__class__', '__delattr__', '__doc__', '__format__', '__getattribute__', '__hash__', '__init__', '__iter__', '__new__', '__radd__', '__reduce__', '__reduce_ex__', '__repr__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__']</p>
    2597. 

  2597.     <p class="Code-Highlighted">&gt;&gt;&gt; a = Simple(10)<br />
    2598. 

  2598.     &gt;&gt;&gt; b = Simple(20)</p>
    2599. 

  2599.     <p class="Code-Highlighted">&gt;&gt;&gt; a + b</p>
    2600. 

  2600.     <p class="Code-Background">&lt;Simple object at 0x000000000000002B [Simple&lt;30&gt;]&gt;</p>
    2601. 

  2601.     <ol start="3">
    2602. 

  2602.         <li>
    2603. 

  2603.         <p class="Step">Exit IronPython and return to the Visual Basic .NET
    2604. 

  2604.         code to add more functionality.</p>
    2605. 

  2605.         </li>
    2606. 

  2606.     </ol>
    2607. 

  2607.     <h3><a name="T5.2.4">Task 4: Adding a delegate</a></h3>
    2608. 

  2608.     <ol>
    2609. 

  2609.         <li>
    2610. 

  2610.         <p class="Step">Add the declaration of the delegate to the top of the Visual
    2611. 

  2611.         Basic source file:</p>
    2612. 

  2612.         </li>
    2613. 

  2613.     </ol>
    2614. 

  2614.     <p class="CodeSample">Imports System<br />
    2615. 

  2615.     Imports System.Collections<br />
    2616. 

  2616. &nbsp;</p>
    2617. 

  2617.     <p class="CodeSample">Public Delegate Function Transformer(ByVal input
    2618. 

  2618.     As Integer) As Integer</p>
    2619. 

  2619.     <ol start="2">
    2620. 

  2620.         <li>
    2621. 

  2621.         <p class="Step">Add the &quot;Transform&quot; method to the Simple class,
    2622. 

  2622.         which takes the delegate as a parameter and invokes it:</p>
    2623. 

  2623.         </li>
    2624. 

  2624.     </ol>
    2625. 

  2625.     <p class="CodeSample">Public Class Simple<br />
    2626. 

  2626. &nbsp;&nbsp;&nbsp; Implements IEnumerable<br />
    2627. 

  2627. &nbsp;&nbsp;&nbsp; Private data As Integer<br />
    2628. 

  2628.     <br />
    2629. 

  2629. &nbsp;&nbsp;&nbsp; Public Sub New(ByVal data As Integer)<br />
    2630. 

  2630. &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; Me.data = data<br />
    2631. 

  2631. &nbsp;&nbsp;&nbsp; End Sub<br />
    2632. 

  2632.     <br />
    2633. 

  2633. &nbsp;&nbsp;&nbsp; Overrides Function ToString() As String<br />
    2634. 

  2634. &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; Return String.Format(&quot;Simple&lt;{0}&gt;&quot;, data)<br />
    2635. 

  2635. &nbsp;&nbsp;&nbsp; End Function<br />
    2636. 

  2636.     <br />
    2637. 

  2637. &nbsp;&nbsp;&nbsp; Function GetEnumerator() As IEnumerator _<br />
    2638. 

  2638. &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;
    2639. 

  2639.     Implements IEnumerable.GetEnumerator<br />
    2640. 

  2640. &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; Return New SimpleEnum(data)<br />
    2641. 

  2641. &nbsp;&nbsp;&nbsp; End Function<br />
    2642. 

  2642. &nbsp;</p>
    2643. 

  2643.     <p class="CodeSample">&nbsp;&nbsp;&nbsp; Function Transform(ByVal t As
    2644. 

  2644.     Transformer) As Integer<br />
    2645. 

  2645. &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; Return t(data)<br />
    2646. 

  2646. &nbsp;&nbsp;&nbsp; End Function</p>
    2647. 

  2647.     <p class="CodeSample"><br />
    2648. 

  2648. &nbsp;&nbsp;&nbsp; Shared Operator +(ByVal a As Simple, ByVal b As Simple) As Simple<br />
    2649. 

  2649. &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; Return New Simple(a.data + b.data)<br />
    2650. 

  2650. &nbsp;&nbsp;&nbsp; End Operator<br />
    2651. 

  2651.     <br />
    2652. 

  2652.     End Class</p>
    2653. 

  2653.     <ol start="3">
    2654. 

  2654.         <li>
    2655. 

  2655.         <p class="Step">Return to the command prompt, compile the code
    2656. 

  2656.         (vbx), launch IronPython Console (ip) and test the code:</p>
    2657. 

  2657.         </li>
    2658. 

  2658.     </ol>
    2659. 

  2659.     <p class="TypedExample">import clr</p>
    2660. 

  2660.     <p class="Code-Background"></p>
    2661. 

  2661.     <p class="UserCode">clr.AddReferenceToFile(&quot;vbextend.dll&quot;)</p>
    2662. 

  2662.     <p class="HiddenCode">clr.AddReferenceToFile(&quot;vbextend_5.2.4.dll&quot;)</p>
    2663. 

  2663.     <p class="Code-Background"></p>
    2664. 

  2664.     <p class="TypedExample">import Simple</p>
    2665. 

  2665.     <p class="Code-Background"></p>
    2666. 

  2666.     <p class="TypedExample">a = Simple(10)</p>
    2667. 

  2667.     <p class="TypedExample">def X(i):<br>
    2668. 

  2668. &nbsp;&nbsp;&nbsp; return i + 100</p>
    2669. 

  2669.     <p class="Code-Background"></p>
    2670. 

  2670.     <p class="TypedExample">&nbsp;</p>
    2671. 

  2671.     <p class="TypedExample">a.Transform(X)</p>
    2672. 

  2672.     <p class="Code-Background"></p>
    2673. 

  2673.     <p class="Stepnonumbering">The function X is getting passed as the delegate
    2674. 

  2674.     to the Simple&#39;s Transform method. You will get following output:</p>
    2675. 

  2675.     <p class="Code-Highlighted">&nbsp;</p>
    2676. 

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

  2677.     &gt;&gt;&gt; clr.AddReferenceToFile(&quot;vbextend.dll&quot;)<br />
    2678. 

  2678.     &gt;&gt;&gt; import Simple<br />
    2679. 

  2679.     &gt;&gt;&gt; a = Simple(10)<br />
    2680. 

  2680.     &gt;&gt;&gt; def X(i):</p>
    2681. 

  2681.     <p class="Code-Highlighted">...&nbsp;&nbsp;&nbsp;&nbsp; return i + 100<br />
    2682. 

  2682.     ...<br />
    2683. 

  2683.     &gt;&gt;&gt; a.Transform(X)</p>
    2684. 

  2684.     <p class="Code-Background">110</p>
    2685. 

  2685.     <p class="Normal"></p>
    2686. 

  2686.     <ol start="4">
    2687. 

  2687.         <li>
    2688. 

  2688.         <p class="Step">This concludes the Visual Basic extending example. An interesting
    2689. 

  2689.         optional exercise is to combine the debugging example with this one. If you are so
    2690. 

  2690.         inclined, try debugging the script that you just typed in. To do so, open the
    2691. 

  2691.         &quot;debugvbx.py&quot; script located in the Tutorial directory and place a
    2692. 

  2692.         breakpoint on the function 'X'. You will see mixed call stack between Visual
    2693. 

  2693.         Basic and Python.</p>
    2694. 

  2694.         </li>
    2695. 

  2695.     </ol>
    2696. 

  2696.     <p class="LabSummary">Tutorial Summary</p>
    2697. 

  2697.     <p class="Body">The complete version of the csextend.cs and vbextend.vb files
    2698. 

  2698.     are located in the Tutorial\Extend directory along with files csxtest.py and
    2699. 

  2699.     vbxtest.py which contain the test code for the C# and Visual Basic .NET extensions
    2700. 

  2700.     respectively.</p>
    2701. 

  2701.     <p class="Body">The code to experiment with debugging Python and C# or Visual
    2702. 

  2702.     Basic code is located in the Python scripts debugcsx.py and debugvbx.py respectively.</p>
    2703. 

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

  2704.     <ul>
    2705. 

  2705.         <li>
    2706. 

  2706.         <p class="Body"><a href="#T5.1">Extending IronPython using C# code</a></p>
    2707. 

  2707.         </li>
    2708. 

  2708.         <li>
    2709. 

  2709.         <p class="Body"><a href="#T5.2">Extending IronPython using Visual Basic
    2710. 

  2710.         .NET</a></p>
    2711. 

  2711.         </li>
    2712. 

  2712.     </ul>
    2713. 

  2713.     <p class="Body">In this tutorial, you implemented a simple class to be used
    2714. 

  2714.     from IronPython. You added the ability for IronPython to enumerate the class,
    2715. 

  2715.     added a custon addition operator to it, and included support for a delegate.
    2716. 

  2716.     The implementation was in either C#, Visual Basic, or both.</p>
    2717. 

  2717. <h1><a name="T7">Tutorial 6: Using Visual Studio to Edit .py Files and Debug Them</a></h1>
    2718. 

  2718.     <p class="BodyNote">There is a community technology preview add-in for 
    2719. 

  2719. 	Visual Studio 2010, IronPython Tools, which supports development of Python 
    2720. 

  2720. 	code.&nbsp; Not only does this include Python syntax highlighting, it also 
    2721. 

  2721. 	adds Python expression completion support to Visual Studio among other 
    2722. 

  2722. 	things!&nbsp; You can download IronPython Tools from
    2723. 

  2723. 	<a href="http://www.ironpython.net/tools/">http://www.ironpython.net/tools/</a>.</p>
    2724. 

  2724. 	<p class="BodyNote">If you would like to see more features added to this 
    2725. 

  2725. 	tool, we would love
    2726. 

  2726.     your feedback! Please vote and/or leave a comment
    2727. 

  2727.     <a href="https://connect.microsoft.com/VisualStudio/feedback/ViewFeedback.aspx?FeedbackID=475830">here</a>.</p>
    2728. 

  2728.     <p class="Body">This tutorial shows you how to quickly set up Visual Studio to
    2729. 

  2729.     work on Python scripts in a directory.</p>
    2730. 

  2730.     <p class="Body">Estimated time to complete this tutorial: <b>5 minutes</b></p>
    2731. 

  2731.     <p class="Body">The objective of this tutorial is to set up Visual Studio
    2732. 

  2732.     for some basic tool support for debugging.</p>
    2733. 

  2733.     <ul>
    2734. 

  2734.         <li>
    2735. 

  2735.         <p class="Body"><a href="#T6.1">Setting up Visual Studio for IronPython
    2736. 

  2736.         Debugging</a></p>
    2737. 

  2737.         </li>
    2738. 

  2738.     </ul>
    2739. 

  2739.     <h2><a name="T6.1">Exercise 1: Setting up Visual Studio for IronPython
    2740. 

  2740.     Debugging</a></h2>
    2741. 

  2741.     <p class="Body">In this exercise you will set up a Visual Studio solution
    2742. 

  2742.     that you can use to edit .py files in a directory and debug them using the
    2743. 

  2743.     Visual Studio .NET debugger.&nbsp; We will use the Tutorial directory as an
    2744. 

  2744.     example, but you could save your solution anywhere.</p>
    2745. 

  2745.     <h3><a name="T6.1.1">Task 1: Setting up Visual Studio for IronPython
    2746. 

  2746.     Debugging</a></h3>
    2747. 

  2747.     <ol>
    2748. 

  2748.         <li>
    2749. 

  2749.         <p class="Step">Open Visual Studio and close any solution or projects
    2750. 

  2750.         you might have open.</p>
    2751. 

  2751.         </li>
    2752. 

  2752.         <li>
    2753. 

  2753.         <p class="Step">Use the File-&gt;Open-&gt;Project/Solution ... command and
    2754. 

  2754.         browse to the ipy.exe application in your IronPython installation
    2755. 

  2755.         (c:\IronPython\ipy.exe is where the tutorial assumes you have it).</p>
    2756. 

  2756.         </li>
    2757. 

  2757.         <li>
    2758. 

  2758.         <p class="Step">We will use the Tutorial directory as an example, and
    2759. 

  2759.         we'll want to set it up as the working directory for loading .py
    2760. 

  2760.         scripts.&nbsp; Right click on the ipy.exe project node in the Visual
    2761. 

  2761.         Studio's solution
    2762. 

  2762.         explorer and choose the Properties command.</p>
    2763. 

  2763.         </li>
    2764. 

  2764.         <li>
    2765. 

  2765.         <p class="Step">In the properties dialog, you will fill in two
    2766. 

  2766.         fields, the Command Arguments and Working Directory.&nbsp; For the
    2767. 

  2767.         Command Arguments, enter &quot;-D first.py&quot;.&nbsp; For the Working Directory,
    2768. 

  2768.         enter the path to the Tutorial directory (c:\IronPython\Tutorial\ is
    2769. 

  2769.         where we assume you have it).&nbsp; Click Apply and OK to confirm your
    2770. 

  2770.         changes.</p>
    2771. 

  2771.         </li>
    2772. 

  2772.         <li>
    2773. 

  2773.         <p class="Step">Now let's save the solution with the File-&gt;Save All ...
    2774. 

  2774.         command.&nbsp; Save it to the Tutorial directory.</p>
    2775. 

  2775.         </li>
    2776. 

  2776.         <li>
    2777. 

  2777.         <p class="Step">To test out our set up, use Ctrl+O to open a file.&nbsp;
    2778. 

  2778.         Browse to the &quot;first.py&quot; file in the Tutorial directory.&nbsp; Place the
    2779. 

  2779.         caret on the line that reads &quot;def add(a, b):&quot;, and press F9 to set a
    2780. 

  2780.         breakpoint.</p>
    2781. 

  2781.         </li>
    2782. 

  2782.         <li>
    2783. 

  2783.         <p class="Step">Press F5 to run the script, and you will hit the
    2784. 

  2784.         breakpoint.&nbsp; If you Press F10, you will step through the file, but
    2785. 

  2785.         all it does is load the definitions and set some variables before
    2786. 

  2786.         terminating.</p>
    2787. 

  2787.         </li>
    2788. 

  2788.         <li>
    2789. 

  2789.         <p class="Step">To see more stepping, we'll add a line to the file and
    2790. 

  2790.         set another breakpoint.&nbsp; Add a line to the end of the file to
    2791. 

  2791.         invoke the factorial function (&quot;factorial(5)&quot;).&nbsp; Add a breakpoint to the line that reads
    2792. 

  2792.         &quot;if n &lt;= 1: return 1&quot;.&nbsp; Now Press F5 to run the script.&nbsp;
    2793. 

  2793.         Press F10 repeatedly and notice the locals window where
    2794. 

  2794.         the parameter &quot;n&quot; decrements to 0 and then goes back up to 5 as the
    2795. 

  2795.         recursion unwinds.&nbsp; You can also hover the mouse over the &quot;n&quot;
    2796. 

  2796.         in the editor window to get a data tip of its value each time you stop at the
    2797. 

  2797.         breakpoint.</p>
    2798. 

  2798.         </li>
    2799. 

  2799.     </ol>
    2800. 

  2800. <p class="Body">To work on other scripts, just change the Command Arguments
    2801. 

  2801. property for the ipy.exe project as we did above to name another script you want
    2802. 

  2802. to load on F5.&nbsp; You might also find it useful to go to the
    2803. 

  2803. Tools-&gt;Options... dialog and change a property on the Environment-&gt;Documents
    2804. 

  2804. page to show the open script files.&nbsp; If you check the property &quot;Show Miscellaneous Files in the Solution
    2805. 

  2805. Explorer&quot;, then you will get a list of the .py files you are editing.&nbsp; Each
    2806. 

  2806. time you open this solution again at a later time, you will see all the .py
    2807. 

  2807. files you developed while using this solution file.</p>
    2808. 

  2808.     <p class="LabSummary">Tutorial Summary</p>
    2809. 

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

  2810.     <ul>
    2811. 

  2811.         <li>
    2812. 

  2812.         <p class="Body"><a href="#T6.1">Setting up Visual Studio for IronPython
    2813. 

  2813.         Debugging</a></p>
    2814. 

  2814.         </li>
    2815. 

  2815.     </ul>
    2816. 

  2816.     <p class="Normal">In this tutorial you set up Visual Studio to work on
    2817. 

  2817.     Python scripts in a directory and debug them.</p>
    2818. 

  2818. 

  2819. </body>
    2820. 

  2820. 

  2821. </html>
    2822. 

  2822.