- World Of Java : le plugin existe pour Eclipse, Netbeans et depuis peu pour IntelliJIDea. Quelques screenshots << ici >> . Ce plugin existe en peut etre utilisé gratuitement pour usage personnel (Edition personnelle) ou pour développer sur un projet open source (Edition communauté). Pour toute application commerciale, il faut payer.
- Koders  : Permet de faire des recherches non seulement sur des sources Java mais aussi pour d’autres langages (C, C++, C#, Ruby, Python, …). Il a l’avantage d’être complètement gratuit. Existe sous la forme d’un plugin Eclipse et d’une extension pour Visual Studio.

Personnellement, j’utilise beaucoup plus Koders que WOJ.

A vous de tester maintenant.

Nous allons maintenant voir, en s’appuyant sur le framework NHibernate (portage C# de Hibernate pour Java) , comment persister nos objets en base.

Cet article se focalise sur NHibernate, mais pour montrer que nous pouvons developper en C# de facon identique a ce que l’on fait avec Java, on utilisera :

NAnt pour la compilation (portage C# de Ant)

NUnit pour les tests unitaires (portage C# de JUnit)

Avant de commencer

Il vous faudra downloader une copie de NHibernate. Téléchargez la dernière version sur Sourceforge, et dézippez le contenu dans un dossier.

Cycle de développement

• Créer la table qui servira à persister la classe .NET.
• Créer une classe .NET devant être persistée.
• Créer un fichier de mapping afin que NHibernate sache comment persister la classe .NET
• Créer un fichier de configuration afin que NHibernate sache comment se connecter a la base de données.
• Utiliser l’API NHibernate.

Ecrire le SQL

Je réutilise la base Oracle XE de mon precedent article, ainsi que la même table worldcup_results.

Créer la classe .NET:

Une simple classe qui peut être persistée au moyen de NHibernate:

using System;
using System.Security;
using System.Security.Permissions;
using System.Reflection;

namespace NHibernateQuickStart
{
///
/// Description of Class1.
///
public class WorldcupResults
{
private string team;
private int played;
private int wins;
private int draws;
private int losses;
private int goalsFor;
private int goalsAgainst;

public WorldcupResults()
{
}

public WorldcupResults(string team, int played, int wins, int draws, int losses, int goalsFor, int goalsAgainst) {
this.Team = team;
this.Played = played;
this.Wins = wins;
this.Draws = draws;
this.Losses = losses;
this.GoalsFor = goalsFor;
this.GoalsAgainst = goalsAgainst;
}

public string Team {
get{return team;}
set{team = value;}
}

public int Played {
get{return played;}
set{played = value;}
}

public int Wins {
get{return wins;}
set{wins = value;}
}

public int Draws {
get{return draws;}
set{draws = value;}
}

public int Losses {
get{return losses;}
set{losses = value;}
}

public int GoalsFor {
get{return goalsFor;}
set{goalsFor = value;}
}

public int GoalsAgainst {
get{return goalsAgainst;}
set{goalsAgainst = value;}
}
}
}

Ecrire le fichier de mapping:

Maintenant que nous avons la table et la classe .NET, on va effectuer le mapping. La facon la plus propre et la plus maintenable est d’écrire un fichier de mappign par classe nommé YourObject.hbm.xml et localisé dans le même répertoire que la classe. Voila l’exemple pour WorldcupResults.hbm.xml:

Créer un fichier de configuration pour la base de données:

Nous n’avons pas encore précisé a NHibernate comment retrouver les infos de connection a la base. Pour cela ecrire un fichier de config app.config, similaire a un fichier de properties, ressemblant a cela:

 La magie de NHibernate

Le job le plus fastidieux a été réalisé. Nous avons donc en possession:

WorldcupResults.cs – La classe C# a persister

WorldcupResults.hbm.xml – le fichier de mapping

app.config – Le fichier de configuration

Une table SQL dans la base de données

L’utilisation de NHibernate dans le code source est désormais assez simple :

Utiliser SharpDevelop

Ajouter la référence NHibernate.dll et NUnit.dll
Créer un objet configuration

Indiquer a la configuration quel type d’objet on veut persister

Créer une session vers la base de données

Load, store et query des objets

Flusher la session

Voici le code source du test unitaire qui permet de créer un enregistrement et retrouver le résultat :

using System;
using NUnit.Framework;
using System.Text.RegularExpressions;
using System.Reflection;
using NHibernate;
using NHibernate.Cfg;

namespace NHibernateQuickStart
{
///

[TestFixtureSetUp]
public void OneTimeSetUp()
{
Console.Out.WriteLine(“running “+MethodBase.GetCurrentMethod());
cfg = new Configuration();
cfg.AddFile(“WorldcupResults.hbm.xml”);
factory = cfg.Configure(“app.config”).BuildSessionFactory();

}

[TestFixtureTearDown]
public void OneTimeTearDown()
{
Console.Out.WriteLine(“running “+MethodBase.GetCurrentMethod());
cfg = null;
factory = null;
}

[Test]
public void Retrieve()
{
Console.Out.WriteLine(“running “+MethodBase.GetCurrentMethod());
string team = “Angleterre”;
CreateResult(team, 5, 4, 0, 1, 5, 0);

WorldcupResults w = GetResult(team);
Assert.IsNotNull(w);
Assert.AreEqual(w.Team, team);
Assert.AreEqual(w.Played, 5);
Assert.AreEqual(w.Wins, 4);
Assert.AreEqual(w.Draws, 0);
Assert.AreEqual(w.Losses, 1);
Assert.AreEqual(w.GoalsFor, 5);
Assert.AreEqual(w.GoalsAgainst, 0);
Console.Out.WriteLine(w.ToString());

}

public WorldcupResults GetResult(string team) {

ISession session = factory.OpenSession();
WorldcupResults w = (WorldcupResults)session.Load(typeof(WorldcupResults), team);
session.Close();
return w;

}

public WorldcupResults CreateResult(string team, int played, int wins, int draws, int losses, int goalsFor, int goalsAgainst) {
ISession session = factory.OpenSession();
ITransaction transaction = session.BeginTransaction();
WorldcupResults results = new WorldcupResults(team, played, wins, draws, losses, goalsFor, goalsAgainst);
session.Save(results);
transaction.Commit();
session.Close();
return results;
}

}
}

NUnit vient avec une interface qui permet de lancer les tests :

On setupe le projet, NUnit retrouve automatiquement la classe de test. On la joue et cela donne :

Enfin, compilation and run : 

Rajoutons un point d’entrée a notre projet , Main.cs :

depuis la methode methode main(), nous irons lire les enregistrements de notre table de la facon suivante (en utilisant NHibernate)

using System;
using System.Collections;
using System.Security;
using System.Security.Permissions;
using System.Reflection;
using NHibernate;
using NHibernate.Cfg;

[assembly:AllowPartiallyTrustedCallers]

namespace NHibernateQuickStart
{
class MainClass
{
public static void Main(string[] args)
{
Configuration cfg = new Configuration();
cfg.AddAssembly(“NHibernateQuickStart”);

ISessionFactory factory = cfg.BuildSessionFactory();
ISession session = factory.OpenSession();

IList resultList = session.CreateCriteria(typeof(WorldcupResults)).List();
foreach(WorldcupResults result in resultList)
{
System.Diagnostics.Debug.WriteLine(result.Team + “, played: ” + result.Played);
}
}
}
}

Pour compiler le projet et générer l’exécutable  nous utiliserons Nant .

Voici le fichier QuickStartNHibernate.build:

Commande :

Lancement de l’application :

Lancer l’exécutable généré par nant. Nous obtenons :

Conclusion :

On s’apercoit que les portages sont assez fidèles aux homologues du monde Java:

Il devient ainsi aisé d’implémenter une persistence avec NHibernate, si on a déjà pratiqué avec Java et Hibernate.

De même, on garde nos bonnes habitudes du monde Java pour tester et compiler grâce aux portages de JUnit et Ant.

• Preparation de l’environnement de développement

Comme il a été précisé ci dessus, nous nous passerons de l’environnement de développement Miscrosoft sachant que nous n’avons pas acheté la licence et que nous voulons rester un minimum “open source”.

Pour cela, un IDE open source existe : il s’appelle SharpDevelop.

SharpDevelop a le mérite de supporter différents langages : C# et VB .NET.

Je choisirai C# puisque ce langage est très proche de Java.

Installation de l’environnement .NET (respecter l’ordre)

1) Installer le framework .NET : pour cela downloader et installer Microsoft .NET version 2.0 Redistibutable package (telechargement gratuit)

2) Installer le .NET Framework Version 2.0 SDK
3) Installer l’IDE SharpDevelop

Pour se connecter a Oracle, nous avons le choix entre 3 méthodes :

• ODBC : méthode “universelle” pour se connecter à une base de données : ne garantit pas les meilleurs résultats
• via un provider intégré au framework : ne garantit pas non plus les performances optimales.
• via un provider dédié, concu par l’editeur de la base de données : exclusivement construit pour cette base, il vous garantira des meilleurs résultats.

Nous choisirons cette troisième option et irons downloader sur le site d’Oracle Technet le Oracle Data Provider pour .NET 2.0.

Ce Data Provider fait partie d’un bundle pack incluant également :

Oracle Data Provider for .NET 1.x

Oracle Developer Tools for Visual Studio .NET 2003

Oracle Developer Tools for Visual Studio .NET 2005

Oracle Services for Microsoft Transaction Server

Télécharger le bundle ODAC10202Beta.exe (213mb)

A l’installation , dans l’Oracle Installer, ne cocher que la case Oracle Data Provider for .NET 2.x .

Vérification de l’installation

Lancer SharpDevelop.

Créer un nouveau projet (appelé Solution) C#, choisir ‘Console Application’.

Ouvrir la vue ‘Project’ (onglet en bas a gauche)

Ouvrir le panneau de références (Click droit sur le projet ‘Add Reference’) et vérifier que les librairies Oracle DataAccess sont présentes :

La version de Oracle Data Access est pour base 10g (10.2)

Installer la base de données :

Dans le cadre d’un développement nous n’installerons pas une version enterprise d’Oracle 10g mais nous choisirons la version gratuite Oracle (10g) Express.

Télécharger et installer Oracle XE (Express Edition).

Créer l’environnement de développement en base :

Nous allons nous connecter a Oracle XE et créer :

• Un schema utilisateur DOTNET
• Une table worldcup_results

Sur Windows XP :

Menu Start -> All programs -> Oracle Database 10g Express Edition -> Démarrer la base de données
L’application d’administration est une interface Web.

Accéder à la base de données:

Menu Start -> All programs -> Oracle Database 10g Express Edition -> Accéder à la page d’accueil de la base de données

ou

Dans un navigateur : http://localhost:8080/apex

Se connecter SYSTEM :

Accéder à la page de création de schémas utilisateur: Administration -> Manage Database Users -> Create User

Créer le schéma DOTNET:

Se déconnecter du schéma SYSTEM et se reconnecter avec le user DOTNET.

Créer une table worldcup_results :

Sur l’interface d’admin, suivre : Object browser -> Create -> Table

Après création de la table saisir quelques données :

Aujourd’hui 3 juillet, en ce qui concerne l’équipe de France par exemple, nous avons 5 matches joués, 3 gagnés, 2 ex aequos, 0 perdus, 7 buts marqués, 2 encaissés:

On fera de meme pour les 3 autres equipes encore en course pour la demi finale :

Allemagne : 5 matches joués, 5 gagnés, 0 perdus, 0 nuls, 11 buts marqués, 3 encaissés.

Italie : 5 matches joués, 4 gagnés, 0 perdus, 1 nul, 9 buts marqués, 1 encaissé.

Portugal : 5 matches joués, 5 gagnés, 0 perdus, 0 nul, 6 buts marqués , 1 encaissé.

Développement de l’application:

Reprendre SharpDeveloper et ouvrir notre Solution (groupe de projets) OracleApplicationTest.

Avant de commencer ajouter la référence à Oracle dans votre projet :
Click droit projet, ‘Add Reference’ : descendre dans la liste jusqu’a trouver Oracle.DataAccess, puis l’ajouter.

Une fois la référence ajoutée , faire le using (équivalent de import en Java) comme suit :

using Oracle.DataAccess.Client;

Création de la connexion

La première chose à faire est l’initialisation de l’objet qui va effectuer une connexion à la base de données.

Nous avons l’objet OracleConnection,. prenant en paramètre la chaine de connexion.

Pour la chaine de connexion, nous utiliserons la méthode de nommage Easy Connect (qui évite tout fichier de configuration) :

user id=id;password=pass;data source=host:port/service_name
Code :

using System;
using System.Collections.Generic;
using Oracle.DataAccess.Client;

class MainClass {

private static OracleConnection conn = new OracleConnection();

public static void Main(string[] args)
{

conn.ConnectionString = “User Id=DOTNET;Password=DOTNET;Data Source=localhost:1521/XE”;

…

}

}

Ouverture/Fermeture connexion:

L’ouverture se fait au moyen de la méthode Open() et la fermeture au moyen de la méthode Dispose().

Code :

try {
conn.Open();
Console.WriteLine(“Connection opened successfully!”);
} catch (Exception ex) {
Console.WriteLine(ex.Message.ToString());
} finally {
conn.Dispose();
}

Fetch des données :

a) Déclarer une commande (pour exécuter le SQL) avec OracleCommand et écrire la requête SQL, et déclarer un OracleDataReader pour la lecture.
b) Ouvrir un block try

c) Ouvrir la connexion

d) Déclarer la requête SQL

e) Assigner la connexion à OracleCommand

f) Passer la commande en mode Text

g) Exécuter la requête

h) Boucler sur les résultats et les afficher a la console

i) Fermer les ressources (OracleCommand, OracleDataReader, OracleConnection)

Code :

// a)

OracleDataReader viewResultsReader;

OracleCommand viewResultsCmd;

// b)

try {

// c)

conn.Open();
// d)
viewResultsCmd = new OracleCommand(“SELECT ” +
“Team, ” +
“Played, ” +
“Wins, ” +
“Draws, ” +
“Losses, ” +
“Goals_For, ” +
“Goals_Against ” +
“FROM Worldcup_Results “);

// e)
viewResultsCmd.Connection =conn;

// f)
viewResultsCmd.CommandType = CommandType.Text;

// g)

viewResultsReader = viewResultsCmd.ExecuteReader();

// h)
while (viewResultsReader.Read()) {
Console.Write(“Team: ” + viewResultsReader.GetString(0) + “, “);
Console.Write(“Played: ” + viewResultsReader.GetDecimal(1).ToString() + “, “);
Console.Write(“Wins: ” + viewResultsReader.GetDecimal(2).ToString() + “, “);
Console.Write(“Draws: ” + viewResultsReader.GetDecimal(3).ToString() + “, “);
Console.Write(“Losses: ” + viewResultsReader.GetDecimal(4).ToString() + “, “);
Console.Write(“Goals for: ” + viewResultsReader.GetDecimal(5).ToString() + “, “);
Console.WriteLine(“Goals against: ” + viewResultsReader.GetDecimal(6).ToString() );
}
// i)

viewResultsReader.Close();
viewResultsReader.Dispose();
viewResultsCmd.Dispose();

} catch (Exception ex) {
Console.WriteLine(ex.Message.ToString());
} finally {
conn.Dispose();
}

Le résultat à la console :

Conclusion:

On s’apercoit avec ce petit programme que

1) Le c# est tres proche de Java

2) Connexion a la base Oracle et requetes se font tres naturellement (tres proche de l’utilisation de JDBC)

Si vous etes interessés par d’autres articles a ce sujet, faites le savoir en commentaire. Je prevois deja de faire un article au sujet d’une application graphique, elle aussi connectée à Oracle.

Sample Code :

Downloader le projet et ses sources >> ici <<