SharpDevelop

Yeah, I'm having some trouble adapting to C++, but Its going. I should have listened to my advisor and did C++ first. It's supposed to be easier that way.

Why everybody hates VB?

OK It's just a single platform (Windows) verbose and not compiled language (by the way also Java is not compiled but no one complains), but you can accomplish many things with it, especially now that is a part of .NET framework.

I once worked in a team which developed the "brain" of a plant to sort mail that was entirely developed in VB5... Well sometimes we miss something but It worked most of the time

Each language has strength and weakness... You can learn easily VB and be very productive... look at Portable Apps, every launcher is made with NSIS.

I think there is not a best-of-all-time language. I like pluralism

sblandin

Does Mono require administrative privileges to be installed?

Let's just assume that .NET or Mono is installed on the client machines, because developing a portable .NET/Mono system would just be too much. Once you assume that, it makes life so much easier. .NET eventually ends up being installed on all of the computers I visit anyway. I've actually talked with some of the internet cafe's around my neighborhood and allowed me to install .NET on their ghost installation.

So once it's installed, what's a viable portable solution for .NET or Mono development? I just came up with two rather unorthadox solutions taking advantage of NAnt, Prebuild and PSPad.

Single C# File

This solution uses Mono and PSPad to allow you to compile single C# files to Mono EXE binaries. It's pretty easy to setup and gives you a nice taste of how Mono works.

Carry around Mono on your USB key. In PSPad, set the compiler settings to DirToMono/bin/mcs.bat, and the Parameter to "%FILE%". Check on "Capture Output" and "Hide Output Window". Set Run After Compilation to DirToMono/bin/mono.exe "%DIR%%NAME%.exe" .

When you click on Compile or hit CTRL F9 in PSPad, it will compile the current C# file you are editing to an EXE file and then run it.

To my knowledge, this solution is completely portable, as you're just running the Mono console programs directly from their location without relying on PATH or any registry settings. I could, of course, be wrong on this though. Anyone try it out?

Multiple C# Files

This solution is a bit more complicated as it uses Prebuild, NAnt, PSPad and an additional batch file. It allows you to compile multiple C# files and projects as well as allows you to compile the projects to either Mono or .NET.

Create a "build.bat" file and put the following code in it:

@ECHO OFF
"../Prebuild/Prebuild.exe" /file %1.xml /target nant
"../NAnt/NAnt.exe" -t:mono-2.0 -buildfile:%1.build clean
"../NAnt/NAnt.exe" -t:mono-2.0 -buildfile:%1.build build-release
"../Prebuild/Prebuild.exe" /file %1.xml /clean nant /y

Create a HelloWorld.xml, this will be our solution file describing all of our projects that will be associated with the solution we'll be editing. Put the following in it:

<?xml version="1.0" encoding="utf-8" ?>
<Prebuild xmlns="http://dnpb.sourceforge.net/schemas/dnpb-1.6.xsd" version="1.6">
  <Solution name="HelloWorld">
    <Project name="HelloWorld"
      path="." language="C#" type="Exe"
      assemblyName="HelloWorld"
      rootNamespace="HelloWorld">
      <Configuration name="Debug">
        <Options>
          <CompilerDefines>DEBUG;TRACE</CompilerDefines>
          <OptimizeCode>false</OptimizeCode>
          <AllowUnsafe>false</AllowUnsafe>
          <OutputPath>bin\Debug</OutputPath>
          <DebugInformation>true</DebugInformation>
          <XmlDocFile></XmlDocFile>
          <WarningLevel>4</WarningLevel>
          <SuppressWarnings></SuppressWarnings>
          <PostBuildEvent></PostBuildEvent>
        </Options>
      </Configuration>
      <Configuration name="Release">
        <Options>
          <CompilerDefines>TRACE</CompilerDefines>
          <OptimizeCode>true</OptimizeCode>
          <AllowUnsafe>false</AllowUnsafe>
          <OutputPath>bin\Release</OutputPath>
          <XmlDocFile></XmlDocFile>
          <DebugInformation>false</DebugInformation>
          
          <WarningLevel>1</WarningLevel>
          <SuppressWarnings></SuppressWarnings>
          <PostBuildEvent></PostBuildEvent>
        </Options>
      </Configuration>
      <Reference name="System" />
      <Files>
        <Match path="." pattern="*.cs" recurse="true"/>
      </Files>
    </Project>
  </Solution>
</Prebuild>

Once you have that, create a new file named "HelloWorld.cs" in the same directory as the XML file:

using System;

namespace HelloWorld
{
	public class HelloWorld
	{
		public static void Main(string[] args)
		{
			Console.WriteLine("Hello World!");
			Console.ReadLine();
		}
	}
}

In the compiler settings of ".xml" files, use "build.bat" for the compiler, %name% for the parameters, and Capture Program Output and Hide Output Window. Then when you click compile in PSPad when you're editing the XML file, it will compile the virtual HelloWorld solution, including the HelloWorld.cs. You'll be left with a HelloWorld.exe in the bin/Release directory.

As you can see, this is a rather strange solution. It uses Prebuild to make a *.build file of all solutions in the XML file. Once it does that, it uses NAnt to build those *.build files. You're then left with built .NET assemblies. The benefit of this solution is that you can have multiple solutions and projects, you can even build your own libraries with it too.

Reflection

After figuring out how to put this all together, I discover that PSPad isn't that good when you're working with external compilers and solutions with multiple files. I'd like to find a better solution around it and hopefully get something even nicer working. Any thoughts?

Rob Loach [Website] [Projects] [Blog]