Programmation en C# sous Linux avec Mono

En théorie, la compatibilité entre le Framework .Net et Mono devrait être totale.
En effet, tous deux exploitent le code IL et les assemblies .Net sont compilés en IL.
Oui, mais voilà, les assemblies de base du Framework .Net font appel aux fonctions de l'API Win32, or ces fonctions ne sont pas présentes sous Linux ou Mac. C'est pourquoi Mono redéfinit les assemblies de base pour assurer la compatibilité avec les systèmes Linux et Mac.
Toutefois, les assemblies compilées sous Windows avec le Framework .Net, si elles ne comportent pas de référence à des bibliothèques que Mono n'a pas, peuvent tourner sans être recompilées sous Mono. Mais je ne pense pas que ce soit une bonne idée à moins que la compilation de votre bibliothèque/programme prenne plus de deux jours.
En effet, les deux frameworks même s'ils exploitent les mêmes langages, restent différents par certains points.

Comme dit précédemment les classes de base du Framework .NET ont été portées pour tourner sous Linux et Mac.
Toutefois il existe une classe importante qui n'a pu être portée, la classe System.Windows.Forms.
En effet cette classe est dédiée à la gestion de l'interface graphique et des signaux aux applications. Or le traitement des signaux et les composants standard de l'interface graphique sont forts différents sur les différentes plates-formes. Ces nombreux appels aux fonctions de l'API WIN32 font que cette classe n'a pas pu être portée pour l'instant.
Mais le Projet MWF (Managed Windows Form) est un projet dynamique et dès maintenant la version 1.1.6 embarque les Winforms avec elle. Ce projet avance rapidement maintenant et à l'heure de l'écriture de ce tutoriel le projet est marqué comme fini à 93 %. C'est pourquoi je me permets de faire ici l'hypothèse qu’avant la fin de l'année 2005, les Winforms seront totalement supportées.
De plus j'ai réussi à faire tourner une petite application basique compilée sous Windows avec le framework 1.1 sous mono avec les Winforms Managées.

Pour pallier le problème de la classe Winforms, l'équipe de Mono a décidé de créer une surcouche à GTK+ nommé GTK#.
Pourquoi avoir choisi GTK plutôt que Qt qui est écrit en C++ donc plus proche du C# ? Pour deux raisons : d'abord, Qt est un Framework commercial et surtout le chef de projet de Mono n'est autre que celui de Gnome (l'environnement de bureau) Miguel de Icaza.
Un projet pour créer une surcouche à Qt est en cours de développement, mais je n'ai pas pu le tester.
Plus généralement Mono est distribué avec de nombreux composants optionnels tels que les drivers pour MySql (déconseillé voir sur le site de MySql et l'exemple à la fin), Firebird (base de données), Mozilla Firefox (GECKO), et surtout OpenGL ainsi que bien d'autres.

Afin de procéder à l'installation de MonoDevelop, il vous faut récupérer soit les paquets binaires, soit les sources ou encore l'installateur binaire.
Ensuite je vous invite à vous reporter à l'explication qui est fournie sur le site de MonoDevelop afin de le compiler et de l'installer à partir des sources.
Si vous avez choisi l'une des deux autres méthodes, MonoDevelop est déjà installé.

En effet, MonoDevelop est le portage partiel de SharpDevelop sous GTK#/Mono. Je dis partiel, car de nombreuses fonctionnalités de SharpDevelop ne sont pas présentes sous MonoDevelop.

Il a été simplement été supprimé, car il ne pouvait pas servir pour la création d'interfaces graphiques avec GTK#.
On ne peut qu'espérer qu'un outil de ce genre soit rapidement développé et intégré à MonoDevelop et apparemment ce projet est en cours de réalisation, mais aucune précision n'a été trouvée.

À la création d'une nouvelle solution, MonoDevelop génère de nombreux fichiers. Toutefois, un seul va nous importer pour l'instant : c'est le fichier Makefile que tout 'Linuxien' connaît.
Je tenais à le préciser, car c'est un fichier important pour la compilation et surtout qui mérite d'être examiné afin de comprendre comment fonctionne le compilateur mcs.

Ce premier programme va simplement nous servir à illustrer la compilation en ligne de commande et les fichiers Makefile présents dans les répertoires des programmes.
Je tiens à ajouter une petite précision au sujet des fichiers Makefile contenus dans les répertoires des exemples.
Tout à l'heure, j'ai parlé des fichiers générés par MonoDevelop, toutefois les fichiers présents dans les exemples sont entièrement écrits à la main.

using System;
 
namespace Hello_World
{
 public class Hello_World
 {
     public Hello_World()
     {
 
     }
 
     public static void Main(string[] args)
     {
         Console.WriteLine("Hello Linux World :-) ");
 
     }
 
 }
}

mcs -out:hello_world.exe ./src/*.cs

Voyons maintenant les options utilisées et celles qui ne le sont pas encore dans les exemples :

Ce tableau n'est qu'un petit aperçu des options du compilateur mcs. Si vous voulez toutes les connaître vous faites :

mcs --help
ou
man mcs

Je vais maintenant vous montrer rapidement un fichier Makefile que j'utilise pour compiler sous Linux/Mono

all:
    mcs -out:MonoMySqlIO.exe -r:./MySql.Data.dll -r:System.Data.dll ./MonoMySqlIO/*.cs
    echo "mono ./MonoMySqlIO.exe" > ./monoMySqlIO
    chmod +x ./monoMySqlIO

La première déclare le nom de la règle pour les commandes.

La deuxième ligne effectue la compilation en elle-même.
mcs est le compilateur C# de Mono.
-out:MonoMySqlIO.exe indique que le nom du fichier de sortie du compilateur.
-r:./MySql.Data.dll indique que l'on doit lier l'assembly MySql.Data.dll située dans le répertoire courant (./) au programme.
./MonoMySqlIO/*.cs indique l'emplacement des fichiers pour la compilation.

La troisième ligne crée un fichier qui va permettre de lancer facilement le programme.
echo « mono ./MonoMySqlIO.exe » Permet d'afficher sur la sortie standard le texte entre '"'
> ./monoMySqlIO redirige la sortie standard vers le fichier monoMySqlIO.

La quatrième ligne rend le fichier monoMySqlIO exécutable.
chmod commande standard de Linux pour changer les droits sur un fichier.
-x ajoute le droit d'exécution pour l'utilisateur.
./monoMySqlIO le fichier sur lequel on applique ces nouveaux droits.

Dans cet exemple, nous allons voir comment accéder à une base MySql en C#. Le driver utilisé est celui de MySql.com (version compilée) :

using System;
using System.Data;
using MySql.Data.MySqlClient;
 
namespace MonoMySql
{
    class MainClass
    {
        private MySqlConnection connection;
        private MySqlCommand command;
        private MySqlDataReader dataReader;
 
        private bool Open;
 
        public MainClass()
        {
            this.Open = false;
 
        }
 
        public void Lunch()
        {
            Console.WriteLine("Entrez le nom du server :");
            string ServerName = Console.ReadLine();
            Console.WriteLine("Entrez le nom d'utilisateur");
            string userName = Console.ReadLine();
            Console.WriteLine("Entre le mot de passe");
            string password = Console.ReadLine();
            Console.WriteLine("Entrez la base à laquelle se connecter ");
            string dataBase = Console.ReadLine();
 
            //On ouvre la connexion avec les paramètres rentrés par l'utilisateur
            this.connection = new MySqlConnection("Server=" + ServerName + ";Database=" 
            + dataBase + ";User ID="+ userName + ";Password=" + password + ";");
 
            try
            {
                this.connection.Open();
                this.Open = true;
 
                this.Menu();
 
            }
            //On vérifie que MySql ne lève pas d'exception
            catch(MySqlException sqlEx)
            {
                Console.WriteLine("Exception MySql :-(");
                Console.WriteLine(sqlEx.Message);
                return ;
            }
            catch(Exception ex)
            {
                Console.WriteLine("Exception générale :-( ");
                Console.WriteLine(ex.Message);
                return;
            }
 
 
 
        }
 
        private void Menu()
        {
            bool exit = false;
 
            while(exit == false)
            {
                Console.WriteLine("Menu :");
                Console.WriteLine("---------------------");
                Console.WriteLine("1 : Executer une requete SELECT)");
                Console.WriteLine("2 : Exécuter une requête UPDATE,INSERT,CREATE,...");
                Console.WriteLine("3 : Quitter");
                Console.WriteLine("Choix ?");
                int rep = Int32.Parse(Console.ReadLine());
 
                switch(rep)
                {
                    case 1 : this.ExecuteQuery();
                        break;
                    case 2 : this.ExecuteNoQuery();
                        break;
                    case 3 : exit = true;
                        break;
                    default : break;
                }
 
            }
        }
 
        private void ExecuteQuery()
        {
            Console.WriteLine("Entrez la requête à effectuer");
            string req = Console.ReadLine();
 
            //On crée une nouvelle command avec la requête à effectuer et on l'associe à la connexion ouverte
            this.command = new MySqlCommand(req,this.connection);
 
            try
            {
                this.dataReader = this.command.ExecuteReader();
 
                while(this.dataReader.Read())
                {
                    foreach(Object obj in this.dataReader)
                    {
                        Console.Write(obj.ToString() + " *** ");
                    }
                    Console.WriteLine("-----------------------------------------");
                }
            }
            catch(MySqlException sqlEx)
            {
                Console.WriteLine(sqlEx.Message);
            }
            catch(Exception ex)
            {
                Console.WriteLine(ex.Message);
            }
            finally
            {
                this.dataReader.Close();
            }
 
 
        }
 
        private void ExecuteNoQuery()
        {
            Console.WriteLine("Entrez votre requête");
            string req = Console.ReadLine();
 
            //On crée une nouvelle commande avec la requête et la connexion ouverte
            this.command = new MySqlCommand(req,this.connection);
 
            try
            {    //ExecuteNonQuery renvoie le nombre de lignes affectées par la requête
                Console.WriteLine("Nombre de lignes affectées : " + this.command.ExecuteNonQuery());
            }
            catch(MySqlException sqlEx)
            {
                Console.WriteLine(sqlEx.Message);
            }
            catch(Exception ex)
            {
                Console.WriteLine(ex.Message);
            }
 
 
        }
 
        public void CloseMySql()
        {
            if(this.Open == true)
            {
                this.connection.Close();
            }
        }
 
        [STAThread]
        static void Main(string[] args)
        {
            Console.WriteLine("Bienvenue dans MonoMySql");
            MainClass mainClass = new MainClass();
            mainClass.Lunch();
 
            mainClass.CloseMySql();
            Console.WriteLine("À bientôt dans MonoMySql");
        }
    }
}

Dans cet exemple, nous allons voir la création et l'écriture dans un fichier :

private FileStream fileStream;
private StreamWriter sw;
 
...
 
private void RunLog()
{
    this.fileStream = new FileStream("./sql.log",FileMode.Create);
    this.sw = new StreamWriter(this.fileStream);
    this.log = true;
}
 
private void SaveLog(string log)
{
    this.sw.WriteLine(log);
}
 
private void StopLog()
{
    if(this.log == true)
    {
        this.sw.Close();
        this.fileStream.Close();
        this.log = false;
    }
}

Conclusion sur ces programmes console avec Mono
À l'issue de ces trois petits programmes, les développeurs qui connaissent un peu la programmation sous .NET me diront :
« Eh alors où est la différence ? ».
Justement, ces programmes n'ont d'autre but que de montrer que si on sait programmer avec .NET sous Windows, on sait le faire avec Mono sous Linux et Mac.
Il n'existe que très peu de différences entre les deux environnements de programmation et c'est un jeu d'enfant que de faire des programmes qui sont multiplates-formes pour peu que l'on sépare l'interface graphique du corps du programme.
Voici un exemple de portage d'une application sous Mono et GTK# et qui été écrite à l'origine sous .NET.
Une application portée sous Linux/Mac avec mono et GTK#.