ansaurus

Question

Compiling an IronPython WPF project to exe

Answer 1

+2 A:

It "boils down to IL", but it isn't compatible with the IL that C# code produces, so it can't be directly compiled to a standalone .exe file. You'll need to use pyc.py to compile your code to a stub EXE with the DLL that CompileModules creates. Then distribute those files with IronPython.dll, IronPython.Modules.dll, Microsoft.Dynamic.dll, Microsoft.Scripting.Debugging.dll, Microsoft.Scripting.dll, and of course the XAML file.

To compile other files, just add them as arguments: ipy.exe pyc.py /main:app.py /target:winexe another.py another2.py additional.py

jcao219 2010-10-22 19:18:41

Very interesting. I'll give pyc.py another try.

Aphex 2010-10-22 20:07:16

`ipy.exe pyc.py /main:app.py /target:winexe` produces a tiny 3kb app.exe that does nothing. Is there something else I need to do here?

Aphex 2010-10-22 20:09:26

It also produces app.dll. Distribute that with those dlls mentioned earlier and your XAML file.

jcao219 2010-10-22 22:29:48

There is indeed a small app.dll produced. Seems like its too small to be actually useful, but in the interest of trying, where can I find those 5 DLLs that I need? I'll try running it with those in the same folder.

Aphex 2010-10-26 19:32:46

The 5 DLLs are either inside of `C:\Windows\Microsoft.NET\assembly\GAC_MSIL` or the IronPython installation directory, but probably the former if you are using the latest version of IronPython.

jcao219 2010-10-26 22:05:03

OK, I copied the DLLs over from the GAC. Still, the exe does nothing. I'm thinking pyc.py simply isn't compiling all of my project's files.

Aphex 2010-10-27 16:55:41

To compile other files, just add them as arguments: `ipy.exe pyc.py /main:app.py /target:winexe another.py another2.py additional.py`

jcao219 2010-10-27 21:44:15

Answer 2

+1 A:

Use pyc.py to produce app.exe and don't forget to include app.dll and IronPython libraries.

As for XAML - I've created project just for .xaml files that I compile in VS and then use them from IronPython. For example:

<ResourceDictionary.MergedDictionaries>
  <ResourceDictionary Source="/CompiledStyle;component/Style.xaml" /> 
</ResourceDictionary.MergedDictionaries>

Lukas Cenovsky 2010-10-23 18:05:23

Okay, I've wrestled with pyc.py and I still dont understand how to make it use all of the files I need. My project consists of 78 files over 5 folders and is launched by running app.py; however as mentioned in my comment to jcao219 running `ipy.exe pyc.py /main:app.py /target:winexe` produces a useless app.exe that does nothing when launched.

Aphex 2010-10-26 19:29:07

I recommend you to start with simple hello world app. Trying to make work 78 files is too much. Start with one file, that add an another one, then subfolder, etc. Also does your app run when you start it by simple: `ipy.exe app.py`?

Lukas Cenovsky 2010-10-27 19:32:23

Yes, `ipy.exe app.py` runs great. By the way, I added a screenshot of my current project structure to the first post... I'm beginning to think I need to give ALL of my files to pyc.py as commandline parameters. Is this **really** the way I'm supposed to build and distribute my IPy apps? Type out `ipy.exe pyc.py app.py <78 .py files here> /main:app.py /target:winexe`?

Aphex 2010-10-27 20:47:28

Yes, that's how. Or you can write some script that does it for you. IronPython's support for building like this is not as great as C#, since C# already fills that niche.

jcao219 2010-10-27 21:45:11

jcao219 is right - you have to give `pyc.py` all files you want to compile. Also note there is a bug in `pyc.py` that forces to create console app when you specify `/main`. Just drop line 97 and it should work.

Lukas Cenovsky 2010-10-28 07:01:05

I was afraid of that. I guess i could write a build script that queries my project folder for every py file and passes them to pyc... I only have two questions. See my edited original post.

Aphex 2010-10-28 15:12:20

Answer 3

+1 A:

To create a set of assemblies for your IronPython application so that you can distribute it you can either use pyc.py or SharpDevelop.

To compile using pyc.py:

ipy.exe pyc.py /main:Program.py Form.py File1.py File2.py ... /target:winexe

Given the amount of files in your project you could try using SharpDevelop instead of maintaining a long command line for pyc.py. You will need to create a new IronPython project in SharpDevelop and import your files into the project. You will probably need to import the files one at a time since SharpDevelop lacks a way to import multiple files unless they are in a subfolder.

You can then use SharpDevelop to compile your application into an executable and a dll. All the other required files, such as IronPython.dll, Microsoft.Scripting.dll, will be in the bin/debug or bin/release folder. SharpDevelop uses clr.CompileModules and a custom MSBuild task behind the scenes to generate the binaries.

Any IronPython packages defined in your project should be usable from your application after compilation.

Packaging up the XAML can be done by embedding the xaml as a resource. Then using code similar to the following:

import clr

clr.AddReference('PresentationFramework')
clr.AddReference('System')

from System.IO import FileMode, FileStream, Path
from System.Reflection import Assembly
from System.Windows import Application
from System.Windows.Markup import XamlReader

executingAssemblyFileName = Assembly.GetEntryAssembly().Location
directory = Path.GetDirectoryName(executingAssemblyFileName)
xamlFileName = Path.Combine(directory, "Window1.xaml")

stream = FileStream(xamlFileName, FileMode.Open)
window = XamlReader.Load(stream)
app = Application()
app.Run(window)

SharpDevelop 3.2 does not embed resource files correctly so you will need to use SharpDevelop 4.

If you are using IronPython 2.7 you can use the new clr.LoadComponent method that takes an object and either a XAML filename or stream and wires up that object to the XAML.

Whilst the C# compiler can compile your XAML into a BAML resource doing the same with IronPython has a few problems. If you do not link the XAML to a class via the x:Class attribute then it is possible to compile the XAML into a BAML resource and have that embedded into your assembly. However you will not get any autogenerated code so you will need to create that code yourself. Another problem is that this will not work out of the box with SharpDevelop. You will need to edit the SharpDevelop.Build.Python.targets file and change the from Python to C#. Trying to use the x:Class attribute will not work since the BAML reader cannot access any associated IronPython class. This is because the generated IL in the compiled IronPython application is very different to that in a C# or VB.NET assembly.

Matt Ward 2010-10-31 20:06:12

ansaurus

tags:

views:

answers:

Compiling an IronPython WPF project to exe

related questions