358 lines
16 KiB
HTML
358 lines
16 KiB
HTML
|
<!--startcut ==============================================-->
|
||
|
<!-- *** BEGIN HTML header *** -->
|
||
|
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 3.2//EN">
|
||
|
<HTML><HEAD>
|
||
|
<title>Programming Bits: Meeting C# and Mono LG #84</title>
|
||
|
</HEAD>
|
||
|
<BODY BGCOLOR="#FFFFFF" TEXT="#000000" LINK="#0000FF" VLINK="#0000AF"
|
||
|
ALINK="#FF0000">
|
||
|
<!-- *** END HTML header *** -->
|
||
|
|
||
|
<!-- *** BEGIN navbar *** -->
|
||
|
<IMG ALT="" SRC="../gx/navbar/left.jpg" WIDTH="14" HEIGHT="45" BORDER="0" ALIGN="bottom"><A HREF="orr.html"><IMG ALT="[ Prev ]" SRC="../gx/navbar/prev.jpg" WIDTH="16" HEIGHT="45" BORDER="0" ALIGN="bottom"></A><A HREF="index.html"><IMG ALT="[ Table of Contents ]" SRC="../gx/navbar/toc.jpg" WIDTH="220" HEIGHT="45" BORDER="0" ALIGN="bottom" ></A><A HREF="../index.html"><IMG ALT="[ Front Page ]" SRC="../gx/navbar/frontpage.jpg" WIDTH="137" HEIGHT="45" BORDER="0" ALIGN="bottom"></A><A HREF="http://www.linuxgazette.com/cgi-bin/talkback/all.py?site=LG&article=http://www.linuxgazette.com/issue84/ortiz.html"><IMG ALT="[ Talkback ]" SRC="../gx/navbar/talkback.jpg" WIDTH="121" HEIGHT="45" BORDER="0" ALIGN="bottom" ></A><A HREF="../lg_faq.html"><IMG ALT="[ FAQ ]" SRC="./../gx/navbar/faq.jpg"WIDTH="62" HEIGHT="45" BORDER="0" ALIGN="bottom"></A><A HREF="qubism.html"><IMG ALT="[ Next ]" SRC="../gx/navbar/next.jpg" WIDTH="15" HEIGHT="45" BORDER="0" ALIGN="bottom" ></A><IMG ALT="" SRC="../gx/navbar/right.jpg" WIDTH="15" HEIGHT="45" ALIGN="bottom">
|
||
|
<!-- *** END navbar *** -->
|
||
|
|
||
|
<!--endcut ============================================================-->
|
||
|
|
||
|
<TABLE BORDER><TR><TD WIDTH="200">
|
||
|
<A HREF="http://www.linuxgazette.com/">
|
||
|
<IMG ALT="LINUX GAZETTE" SRC="../gx/2002/lglogo_200x41.png"
|
||
|
WIDTH="200" HEIGHT="41" border="0"></A>
|
||
|
<BR CLEAR="all">
|
||
|
<SMALL>...<I>making Linux just a little more fun!</I></SMALL>
|
||
|
</TD><TD WIDTH="380">
|
||
|
|
||
|
|
||
|
<CENTER>
|
||
|
<BIG><BIG><STRONG><FONT COLOR="maroon">Programming Bits: Meeting C# and Mono</FONT></STRONG></BIG></BIG>
|
||
|
<BR>
|
||
|
<STRONG>By <A HREF="../authors/ortiz.html">Ariel Ortiz Ramirez</A></STRONG>
|
||
|
</CENTER>
|
||
|
|
||
|
</TD></TR>
|
||
|
</TABLE>
|
||
|
<P>
|
||
|
|
||
|
<!-- END header -->
|
||
|
|
||
|
|
||
|
|
||
|
<p>C# (pronounced C-sharp) is a new object-oriented programming language
|
||
|
designed to take advantage of Microsoft's .NET development framework.
|
||
|
It has many similarities with other popular object-oriented languages such as
|
||
|
C++ and Java, yet it offers some new goodies.</p>
|
||
|
|
||
|
<p>Linux offers the opportunity to develop C# applications thanks to a project
|
||
|
called Mono. Mono is an open source implementation of the .NET platform. In the
|
||
|
following sections, I will describe the main elements of the current
|
||
|
implementation of the Mono system.</p>
|
||
|
|
||
|
<h2>The Mono Project</h2>
|
||
|
|
||
|
<p>At this time, Mono implements two standards: the C# programming language
|
||
|
(Standard ECMA-334) and the Common Language Infrastructure (Standard ECMA-335).
|
||
|
Both of these specifications were developed by Microsoft and submitted to ECMA
|
||
|
(a vendor consortium formerly known as the European Computer Manufacturers
|
||
|
Association) on October 2000. They were formally approved on December 2001, and
|
||
|
they will probably become ISO standards (thanks to a "fast-track"
|
||
|
agreement that ISO has with ECMA) some time before the end of next year.</p>
|
||
|
|
||
|
<p>The Mono project is sponsored by Ximian, the same company that brought us the
|
||
|
GNOME graphical desktop environment. Mexican hacker and Ximian CTO Miguel de
|
||
|
Icaza currently leads the development of this project. In my opinion, the people
|
||
|
involved with the development of Mono have done a remarkable job in quite a
|
||
|
short amount of time. By the way, the word "Mono" means monkey in
|
||
|
Spanish. These guys at Ximian really like monkeys.</p>
|
||
|
|
||
|
<h2>Hello Mono World!</h2>
|
||
|
|
||
|
<p>Lets follow a simple programming example in order to understand how C# and the
|
||
|
different Mono components fit together. To see this in action, make sure you
|
||
|
have a working Mono installation (see the <a href="#resources"> resources</a> section for information on
|
||
|
downloading and installing Mono). </p>
|
||
|
|
||
|
<p>The following figure summarizes the process we will follow in order to
|
||
|
compile and run our C# program:</p>
|
||
|
|
||
|
<img border="0" src="misc/ortiz/using_mono.png" alt="Compiling and running C# programs." width="390" height="351">
|
||
|
|
||
|
<p> First, we will create a simple C# source
|
||
|
program (the classical "Hello World!" couldn't be missing). Type the
|
||
|
following program using your favorite text editor and save the file as <b>hello.cs</b>:</p>
|
||
|
|
||
|
<blockquote>
|
||
|
<pre>
|
||
|
class Hello {
|
||
|
public static void Main() {
|
||
|
System.Console.WriteLine("Hello Mono World!");
|
||
|
}
|
||
|
}
|
||
|
</pre>
|
||
|
</blockquote>
|
||
|
|
||
|
<p>This program is composed of a class named <code>Hello</code> which contains
|
||
|
a method called <code>Main</code>. This method establishes the program entry
|
||
|
point, in the same way that the <code>main</code> function is the start of a
|
||
|
C/C++ program. In this example, the <code>Main</code> method prints to the
|
||
|
standard output the message "Hello Mono World".</p> <p>We can now
|
||
|
compile the program using the Mono C# compiler, called <code>mcs</code>. At the
|
||
|
shell prompt type:</p>
|
||
|
|
||
|
<blockquote>
|
||
|
<pre>
|
||
|
mcs hello.cs
|
||
|
</pre>
|
||
|
</blockquote>
|
||
|
|
||
|
<p>We now should have a file called <b>hello.exe</b> in the current directory.
|
||
|
But don't get baffled about the .exe file name extension. It is not a Windows
|
||
|
executable file, at least not in the way we're used to. Contrary to what happens
|
||
|
when we compile a program written in languages like C or C++, the C# compiler
|
||
|
does not generate a machine-specific object file (for example a Linux ELF x86
|
||
|
object file), but instead generates a special binary file called an <b>assembly</b>,
|
||
|
which is made up of <b>metadata</b> and <b>intermediate language</b> (IL)
|
||
|
instructions. These two together represent a platform-agnostic translation of
|
||
|
the program source code. This means, of course, that when we actually run the
|
||
|
program contained in the assembly, its intermediate language code has to be translated
|
||
|
to the native code of the computer where the program is being run. This last
|
||
|
translation phase is carried out by a <b>virtual machine</b>, whose behavior is
|
||
|
defined by the <b>Common Language Infrastructure</b> (CLI) specification. The
|
||
|
CLI defines an object oriented runtime environment that supports a base class
|
||
|
library, dynamic class loading and linking, multiple thread execution,
|
||
|
just-in-time compilation, and automatic memory management. The
|
||
|
Microsoft implementation of the CLI specification is usually referred as the <b>Common
|
||
|
Language Runtime</b> (CLR). We say that the CLR is a superset of the CLI because
|
||
|
the CLR contains some extensions that are not part of the CLI.</p>
|
||
|
|
||
|
<p>To execute our assembly, we must invoke the program called <code>mono</code>,
|
||
|
which is the Mono virtual machine. Type at the shell prompt the following:</p>
|
||
|
|
||
|
<blockquote>
|
||
|
<pre>
|
||
|
mono hello.exe
|
||
|
</pre>
|
||
|
</blockquote>
|
||
|
|
||
|
<p>The output should be:</p>
|
||
|
|
||
|
<blockquote>
|
||
|
<pre>
|
||
|
Hello Mono World!
|
||
|
</pre>
|
||
|
</blockquote>
|
||
|
|
||
|
<h2>Behind the Scenes</h2>
|
||
|
|
||
|
<p>Lets see how to examine the contents of our assembly. The program <code>monodis</code>
|
||
|
(Mono disassembler) reads the binary information of an assembly and
|
||
|
produces a textual representation of its contents. Type at the shell prompt:</p>
|
||
|
|
||
|
<blockquote>
|
||
|
<pre>
|
||
|
monodis hello.exe
|
||
|
</pre>
|
||
|
</blockquote>
|
||
|
|
||
|
<p>The disassembler output should be something like the following:</p>
|
||
|
|
||
|
<blockquote>
|
||
|
<pre>
|
||
|
.assembly extern mscorlib
|
||
|
{
|
||
|
.ver 0:0:0:0
|
||
|
}
|
||
|
.assembly 'hello'
|
||
|
{
|
||
|
.hash algorithm 0x00008004
|
||
|
.ver 0:0:0:0
|
||
|
}
|
||
|
.class private auto ansi beforefieldinit Hello
|
||
|
extends [mscorlib]System.Object
|
||
|
{
|
||
|
|
||
|
// method line 1
|
||
|
.method public hidebysig specialname rtspecialname
|
||
|
instance default void .ctor() cil managed
|
||
|
{
|
||
|
// Method begins at RVA 0x20ec
|
||
|
// Code size 7 (0x7)
|
||
|
.maxstack 8
|
||
|
IL_0000: ldarg.0
|
||
|
IL_0001: call instance void valuetype [corlib]System.Object::.ctor()
|
||
|
IL_0006: ret
|
||
|
} // end of method instance default void .ctor()
|
||
|
|
||
|
// method line 2
|
||
|
.method public static
|
||
|
default void Main() cil managed
|
||
|
{
|
||
|
// Method begins at RVA 0x20f4
|
||
|
.entrypoint
|
||
|
// Code size 11 (0xb)
|
||
|
.maxstack 8
|
||
|
IL_0000: ldstr "Hello Mono World!"
|
||
|
IL_0005: call void class [corlib]System.Console::WriteLine(string)
|
||
|
IL_000a: ret
|
||
|
} // end of method default void Main()
|
||
|
|
||
|
} // end of type Hello
|
||
|
</pre>
|
||
|
</blockquote>
|
||
|
|
||
|
<p>The first part of this output corresponds to the metadata. It contains
|
||
|
information about the current version of the assembly, any optional security constraints,
|
||
|
locale information, and a list of all externally referenced assemblies that are
|
||
|
required for proper execution. The rest of the output represents the IL code. We
|
||
|
can spot two methods in this code: the default class constructor called <code>.ctor</code>,
|
||
|
provided automatically by the compiler, and our <code>Main</code> method. As
|
||
|
described before, when the virtual machine is asked to run this code, it uses a
|
||
|
just-in-time (JIT) compiler to translate the IL into the native machine code of the
|
||
|
hosting environment. The native code is not generated until it is actually
|
||
|
needed (thus the name just-in-time). For our example, the following is the native x86
|
||
|
machine code (in AT&T assembly language syntax) that gets generated for the <code>Main</code>
|
||
|
method:</p>
|
||
|
|
||
|
<blockquote>
|
||
|
<pre>
|
||
|
push %ebp
|
||
|
mov %esp,%ebp
|
||
|
sub $0x30,%esp
|
||
|
push $0x80c9eb0
|
||
|
mov 0x805462c,%eax
|
||
|
push %eax
|
||
|
cmpl $0x0,(%eax)
|
||
|
mov (%eax),%eax
|
||
|
call *0x94(%eax)
|
||
|
add $0x8,%esp
|
||
|
mov 0x805462c,%eax
|
||
|
push %eax
|
||
|
cmpl $0x0,(%eax)
|
||
|
mov (%eax),%eax
|
||
|
call *0xb4(%eax)
|
||
|
add $0x4,%esp
|
||
|
leave
|
||
|
ret
|
||
|
</pre>
|
||
|
</blockquote>
|
||
|
|
||
|
<p>Mono also comes with an interpreter called <code>mint</code>. If you use this
|
||
|
program, the IL instructions are interpreted instead of being compiled to native
|
||
|
code by the JIT. Actually, our simple program might be a little bit faster when
|
||
|
run under <code>mint</code> because the JIT compiler will take some time to
|
||
|
compile the code of our program and store it some where in memory. Of course,
|
||
|
subsequent execution of the native code already in memory is definitely faster
|
||
|
than interpretation. Currently the Mono JIT compiler is only available for x86
|
||
|
machines. The Mono interpreter must be used in any non-x86 machine. To see the
|
||
|
interpreter running, type at the shell prompt:</p>
|
||
|
|
||
|
<blockquote>
|
||
|
<pre>
|
||
|
mint hello.exe
|
||
|
</pre>
|
||
|
</blockquote>
|
||
|
|
||
|
<p>If you're familiar with Java, you might be thinking that all this technology
|
||
|
sounds pretty much like the way that the Java platform works. And this is indeed
|
||
|
so. The CLI virtual machine is the key factor for platform independence. This
|
||
|
means that I can write and compile a program in Linux using Mono, and then run
|
||
|
it in a Windows computer with the .NET framework. There is no need to rewrite or
|
||
|
recompile the source code. But in contrast to the Java Virtual Machine, which is
|
||
|
tightly coupled to the Java programming language, the CLI specification not only
|
||
|
allows platform independence, it also allows language independence. Windows has
|
||
|
compilers that target the CLR from a number of languages. The most
|
||
|
important ones are part of Microsoft's Visual Studio .NET development
|
||
|
environment: Visual Basic .NET, JScript .NET, Managed C++ and C#. Other
|
||
|
languages supported, from third party vendors, include APL, COBOL, Eiffel,
|
||
|
Forth, Fortran, Haskell, Mercury, Mondrian, Oberon, Pascal, Perl, Python, RPG,
|
||
|
Scheme and SmallScript. The Mono project only has a C# compiler at this time, but we will probably
|
||
|
see in the near future other languages being supported.</p>
|
||
|
|
||
|
<p>Another important element of the CLI is the <b>Common Type System </b>(CTS).
|
||
|
The CTS fully describes all the data types supported by the virtual machine,
|
||
|
including how these data types interact with each other and how they are
|
||
|
represented as metadata inside the assemblies. It is important to note that not
|
||
|
all languages available for the CLI support all data types in the CTS. So there
|
||
|
is a <b>Common Language Specification</b> (CLS), that defines a subset of common
|
||
|
types that ensure that binary assemblies can be used across all languages that
|
||
|
target the CLI. This means that if we build a CLI class that only exposes CLS
|
||
|
compliant features, any CLI compatible language can use it. You could create a class in
|
||
|
Eiffel, subclass it in C# and instantiate it in a Visual Basic.NET program. Now
|
||
|
this is real language interoperability.</p>
|
||
|
|
||
|
<h2>Some Advantages</h2>
|
||
|
|
||
|
<p>Using a CLI compliant platform, such as Mono or the .NET framework, has some
|
||
|
important advantages:</p>
|
||
|
|
||
|
<ul>
|
||
|
<li>Programs can be run without recompiling on any operating system and
|
||
|
processor that supports the platform.</li>
|
||
|
<li>There is complete multiple language integration.</li>
|
||
|
<li>The system supports important security measures.</li>
|
||
|
<li>A common runtime engine is shared by all CLI aware languages.</li>
|
||
|
<li>A consistent object model is used by all CLI aware languages, including a standard
|
||
|
API offered by a single base class library. Once you learn this API, you can
|
||
|
use it in any language supported by the platform.</li>
|
||
|
<li>There is a simplified deployment model. There is no need to register a
|
||
|
binary unit into the system registry. </li>
|
||
|
<li>Multiple versions of the same binary library (DLL) can coexist in harmony
|
||
|
on the same computer. </li>
|
||
|
</ul>
|
||
|
|
||
|
<p> C#, as a programming language, has also some important features:</p>
|
||
|
|
||
|
<ul>
|
||
|
<li>It includes constructs such as properties, events and attributes that ease
|
||
|
the construction of software components. </li>
|
||
|
<li>It does not require the use separate header of interface definition
|
||
|
language (IDL) files.</li>
|
||
|
<li>It has a simplified versioning mechanism.</li>
|
||
|
<li>It's type safe and has a unified type system. All data types (including
|
||
|
primitive types) derive from a single base class.</li>
|
||
|
<li>It has automatic memory management, through the use of garbage collection.</li>
|
||
|
<li>It's closely integrated to the CLI.</li>
|
||
|
</ul>
|
||
|
|
||
|
<p>I will discuss these and other C# issues more thoroughly in later
|
||
|
articles. </p>
|
||
|
|
||
|
<h2><a name="resources">Resources</a></h2>
|
||
|
|
||
|
<dl>
|
||
|
<dt> <a href="http://www.go-mono.com/">http://www.go-mono.com/</a></dt>
|
||
|
<dd>The official Mono home page. The download and install instructions
|
||
|
can be found here.</dd>
|
||
|
<dt><a href="http://msdn.microsoft.com/library/default.asp?url=/library/en-us/dndotnet/html/deicazainterview.asp">http://msdn.microsoft.com/library/default.asp?url=/library/en-us/dndotnet/html/deicazainterview.asp</a></dt>
|
||
|
<dd>A very interesting interview with Miguel de Icaza about the Mono project
|
||
|
and the use of ECMA standards.</dd>
|
||
|
<dt><a href="http://msdn.microsoft.com/library/default.asp?url=/library/en-us/cscon/html/vcoriCStartPage.asp">http://msdn.microsoft.com/library/default.asp?url=/library/en-us/cscon/html/vcoriCStartPage.asp</a></dt>
|
||
|
<dd>Information on the C# programming language at MSDN.</dd>
|
||
|
<dt><a href="http://www.ecma.ch/ecma1/STAND/ecma-334.htm">http://www.ecma.ch/ecma1/STAND/ecma-334.htm</a></dt>
|
||
|
<dd>The Standard ECMA-334 C# Language Specification.</dd>
|
||
|
<dt><a href="http://www.ecma.ch/ecma1/STAND/ecma-335.htm">http://www.ecma.ch/ecma1/STAND/ecma-335.htm</a></dt>
|
||
|
<dd>The Standard ECMA-335 Common Language Infrastructure.</dd>
|
||
|
</dl>
|
||
|
|
||
|
|
||
|
|
||
|
|
||
|
|
||
|
<!-- *** BEGIN copyright *** -->
|
||
|
<hr>
|
||
|
<CENTER><SMALL><STRONG>
|
||
|
Copyright © 2002, Ariel Ortiz Ramirez.
|
||
|
Copying license <A HREF="../copying.html">http://www.linuxgazette.com/copying.html</A><BR>
|
||
|
Published in Issue 84 of <i>Linux Gazette</i>, November 2002
|
||
|
</STRONG></SMALL></CENTER>
|
||
|
<!-- *** END copyright *** -->
|
||
|
<HR>
|
||
|
|
||
|
<!--startcut ==========================================================-->
|
||
|
<CENTER>
|
||
|
<!-- *** BEGIN navbar *** -->
|
||
|
<IMG ALT="" SRC="../gx/navbar/left.jpg" WIDTH="14" HEIGHT="45" BORDER="0" ALIGN="bottom"><A HREF="orr.html"><IMG ALT="[ Prev ]" SRC="../gx/navbar/prev.jpg" WIDTH="16" HEIGHT="45" BORDER="0" ALIGN="bottom"></A><A HREF="index.html"><IMG ALT="[ Table of Contents ]" SRC="../gx/navbar/toc.jpg" WIDTH="220" HEIGHT="45" BORDER="0" ALIGN="bottom" ></A><A HREF="../index.html"><IMG ALT="[ Front Page ]" SRC="../gx/navbar/frontpage.jpg" WIDTH="137" HEIGHT="45" BORDER="0" ALIGN="bottom"></A><A HREF="http://www.linuxgazette.com/cgi-bin/talkback/all.py?site=LG&article=http://www.linuxgazette.com/issue84/ortiz.html"><IMG ALT="[ Talkback ]" SRC="../gx/navbar/talkback.jpg" WIDTH="121" HEIGHT="45" BORDER="0" ALIGN="bottom" ></A><A HREF="../lg_faq.html"><IMG ALT="[ FAQ ]" SRC="./../gx/navbar/faq.jpg"WIDTH="62" HEIGHT="45" BORDER="0" ALIGN="bottom"></A><A HREF="qubism.html"><IMG ALT="[ Next ]" SRC="../gx/navbar/next.jpg" WIDTH="15" HEIGHT="45" BORDER="0" ALIGN="bottom" ></A><IMG ALT="" SRC="../gx/navbar/right.jpg" WIDTH="15" HEIGHT="45" ALIGN="bottom">
|
||
|
<!-- *** END navbar *** -->
|
||
|
</CENTER>
|
||
|
</BODY></HTML>
|
||
|
<!--endcut ============================================================-->
|