IdentifiantMot de passe
Loading...
Mot de passe oublié ?Je m'inscris ! (gratuit)

Migration de VB6 à VB.NET ou C#

Ce document a pour but de présenter la technologie .NET rapidement, afin de faciliter le passage de VB6 à VB.NET ou C#.

Pour ceux qui ne le savent pas encore, .NET est une nouvelle technologie propriétaire inventée par Microsoft. Cette technologie a pour but de remplacer à terme tous les langages utilisés par Microsoft dont Visual Basic et le C++ avec la MFC. Pour ceux qui ont déjà fait du Java, vous ne serez pas perdu en C#. Vous trouverez des renseignements précis sur cette technologie ici.

2 commentaires Donner une note à l´article (5)

Article lu   fois.

Les deux auteurs

Profil Pro

Profil Pro

Liens sociaux

Viadeo Twitter Facebook Share on Google+   

I. La migration des programmes VB6 en VB.NET

Avant de vous lancer dans la migration de VB6 à VB.NET, vous devez bien comprendre à quoi sert .NET et quels sont ses avantages et inconvénients. Pour cela je vous renvoie à la FAQ .NET.

Je ne vais pas dire que la migration est impossible, car je mentirais. Mais vous devez savoir qu'elle est extrêmement longue. Pour prendre un petit exemple, vos tableaux, vos collections, sont à revoir à cause des indices de début. Vos modules de classes ne sont plus bons et doivent être modifiés. Plein de petites choses de ce style, qui ne sont pas complexes, mais extrêmement longues à faire. Donc il est beaucoup plus sage de redévelopper l'application que d'essayer de la migrer. Vous trouverez sur le forum d'entraide un sujet traitant de ce point.

La technologie .NET est une technologie orientée 100 % objet. C'est une des raisons qui font que la migration est très longue et demande un nombre important de modifications.

D'un point de vue professionnel, les licences Visual Basic 6 ne sont plus vendues, vous ne trouverez désormais que des licences .NET. Cela veut dire que si votre société décide d'acheter de nouvelles licences, alors vous devrez passer à .NET (ce qui n'est pas mauvais, entre nous soit dit). Le plus gênant est que les développeurs doivent programmer à la fois en VB6 pour la maintenance et .NET pour les nouveaux projets. Le passage à VB.NET est plutôt facile pour ceux qui connaissent la notion d'objet. Vous pourrez enfin avoir plusieurs constructeurs pour vos formulaires et donc passer des paramètres à sa création. Quant à ceux n'ayant jamais fait de programmation-objet, le passage va être un plus rude. Mais ne vous inquiétez pas, ce n'est pas si sorcier que ça. La notion d'objet vous sera de plus en plus claire au fur et à mesure de vos développements.

Mais qu'en est-il exactement de vos habitudes de programmation ?

II. Les différences dans la façon de programmer

Comme je l'ai dit précédemment, la grosse différence est la programmation-objet. Dès le départ quand vous créez un formulaire, vous verrez que celui-ci est une classe. Afin de mieux voir la différence de programmation, je vais donner des exemples en VB6, VB.NET et C#. Microsoft a fait le choix de laisser des fonctions VB6 dans le langage VB.NET. Entre autres vous retrouverez votre MsgBox préférée. MAIS je vous déconseille de l'utiliser afin de ne pas prendre de mauvaises habitudes en VB.NET. Dans le paragraphe VB.NET vs C#, je vous expliquerai pourquoi il ne faut pas réutiliser ces fonctions. Donc pour afficher un message vous utiliserez désormais MessageBox.Show("VotreMessage"). Il en est de même pour toutes les fonctions sur les chaînes de caractères.

II-A. Les méthodes

Comme sous .NET tout est objet, vos types sont des classes. Pour le type String vous retrouverez toutes les fonctions en tant que méthodes de la classe. Certains d'entre vous doivent se demander ce que je raconte. Voici un petit exemple simple :

Visual Basic 6
Sélectionnez
Dim str As String
str = "Ma chaîne de caractères"
str = UCase(str)
MsgBox str
Visual Basic .NET
Sélectionnez
Dim str As String
str = "Ma chaîne de caractères"
str = str.ToUpper()
MessageBox.Show(str)
C#
Sélectionnez
string str;
str = "Ma chaîne de caractères";
str = str.ToUpper();
MessageBox.Show(str);

Vous voyez que ce n'est pas compliqué. La fonction UCase utilisée en VB6 est remplacée par la méthode ToUpper() de la classe String en .NET. Avec l'IDE Visual Studio .NET, lorsque vous tapez « str. » vous voyez apparaître la liste des méthodes et propriétés de l'objet, dans notre cas :

Image non disponible

Vous n'avez plus besoin de chercher dans l'ensemble des fonctions travaillant sur les chaînes de caractères, car il vous suffit de regarder les membres de la classe string. Comme vous pouvez le voir, la différence entre VB.NET et C# n'est pas si grande que ça. Ce n'est pas toujours aussi ressemblant.

Pour ce qui est de vos propres méthodes, il n'y a pas de changement :

Visual Basic 6
Sélectionnez
1.
2.
3.
4.
5.
6.
7.
Private Sub MaMethode()
  Dim str >As String
   Dim tab As String
  str = "TOTO;TATA"
  tab = Split(str,";")
  MsgBox tab(0) & " - "& tab(1)
End Sub
Visual Basic.NET
Sélectionnez
1.
2.
3.
4.
5.
6.
7.
Private Sub MaMethode()
  Dim str As String
  Dim tab As String
  str = "TOTO;TATA"
  tab = str.Split(";")
  MessageBox.Show(tab(0) & " - " & tab(1))
End Sub
 
Sélectionnez
1.
2.
3.
4.
5.
6.
7.
8.
private void MaMethode()
{
  string str;
  string[] tab;
  str = "TOTO;TATA";
  tab = str.Split(';');
  MessageBox.Show(tab[0] + " - " + tab[1]);
}

Dans cet exemple vous pouvez constater que je n'ai utilisé qu'un seul caractère comme séparateur, car la fonction Split sous .NET ne prend en compte qu'un seul caractère comme séparateur, mais peut prendre plusieurs séparateurs comme paramètre. Sous VB6 vous pouviez mettre une chaîne de caractères comme séparateur. Voici une de ces petites différences qui pose généralement des soucis lors de la migration.

II-B. Les fonctions

Pour les fonctions c'est un peu différent. Un nouveau mot clé est apparu qui est le return.

Visual Basic 6
Sélectionnez
Private Function MaFonction(str As String) As String
  MaFonction = LCase(str)
End Sub
Visual Basic.NET
Sélectionnez
Private Function MaFonction(ByVal str As String) As String
  Return str.ToLower()
End Function
C#
Sélectionnez
private string MaFontion(string str)
{
  return str.ToLower();
}

Pour le retour des fonctions, le choix s'est porté sur une solution équivalente au C/C++.

Une chose importante à savoir pour le passage par un paramètre : contrairement à VB6 où les paramètres sont passés par référence par défaut, en .NET les paramètres sont passés par valeur. Le mot clé ByRef pour VB.NET et ref pour le C# permet le passage par référence.

Petite chose à savoir aussi, en VB6 et VB.NET vous pouvez utiliser des paramètres optionnels (c'est-à-dire que vous n'êtes pas obligé de les renseigner au moment de l'appel de la méthode ou fonction), mais pas en C#.

II-C. Les formulaires

La plus grosse différence lors du développement en .NET est l'architecture du fichier source. Voici le code d'un formulaire vide :

Visual Basic 6
Sélectionnez
Option Explicit
Visual Basic.NET
Sélectionnez
1.
2.
3.
4.
5.
6.
7.
8.
9.
10.
11.
12.
13.
14.
15.
16.
17.
18.
19.
20.
21.
22.
23.
24.
25.
Public Class Form1
  Inherits System.Windows.Forms.Form
  Public Sub New()
    MyBase()
    InitializeComponent()
    End Sub

  Protected Overloads Overrides Sub Dispose(ByVal disposing As Boolean)
    If disposing Then
      If Not (components Is Nothing) Then
        components.Dispose()
      End If
    End If
    MyBase.Dispose(disposing)
  End Sub

  Private components As System.ComponentModel.IContainer<System.Diagnostics.DebuggerStepThrough()> Private
  Sub InitializeComponent()
    Me.AutoScaleBaseSize = New System.Drawing.Size(5, 13)
    Me.ClientSize = New System.Drawing.Size(292, 266)
    Me.Name = "Form1"
    Me.Text = "Form1"
  End Sub

End Class
C#
Sélectionnez
1.
2.
3.
4.
5.
6.
7.
8.
9.
10.
11.
12.
13.
14.
15.
16.
17.
18.
19.
20.
21.
22.
23.
24.
25.
26.
27.
28.
29.
30.
31.
32.
33.
34.
35.
36.
37.
38.
39.
40.
41.
using System;
using System.Drawing;
using System.Collections;
using System.ComponentModel;
using System.Windows.Forms;
using System.Data;

namespace WindowsApplication1
{
  public class Form1 : System.Windows.Forms.Form
  {
    private System.ComponentModel.Container components = null;   public Form1()
    {
    InitializeComponent();
    }
    protected override void Dispose( bool disposing )
    {
      if( disposing )
      {
        if (components != null)
        {
          components.Dispose();
        }
      }
      base.Dispose(disposing );
    }

    private void InitializeComponent()
    {
      this = new System.ComponentModel.Container();
      this.Size = new System.Drawing.Size(300,300);
      this = "Form1";
    }
    [STAThread]
    static void Main() 
    {
      Appliction.Run(new Form1());
    }

  }
}

Il apparaît clairement que des changements ont eu lieu. Pour ceux ayant déjà programmé en C++, cela vous semble familier. N'ayez pas peur, ce code est généré automatiquement.

Votre application est un assemblage d'objets dont votre formulaire fait partie. Un objet est une instance de classe. La classe permettant d'avoir un formulaire est la classe System.Windows.Forms.Form. Quand vous tapez, Public Class Form1 Inherits System.Windows.Forms.Form cela veut dire que vous créez une classe ayant pour modèle le formulaire standard. Votre classe porte le nom de Form1. C'est comme si vous faisiez un module de classe en VB6, hormis le fait que dans le code vous dites que c'est une classe. Vous retrouvez le New qui correspond au constructeur et le Finalize qui est le destructeur. Attention avec le Finalize, car certaines classes possèdent une méthode Dispose qui détruit l'objet. Je traiterai cela dans le prochain chapitre : « Les objetsLes objets ».

III. Les objets

Voilà le terme que désormais vous verrez partout : OBJET, ou CLASSE. Même si pour vous la programmation-objet est une programmation avec beaucoup de contraintes, vous allez vous apercevoir rapidement que ces contraintes n'en sont pas ou plutôt qu'elles n'en seront plus. Une grande différence avec VB6 est la notion de namespace (espace de nom). Qu'est-ce qu'un espace de nom ? Un espace de nom permet de regrouper plusieurs classes. Par exemple, pour tout ce qui est du traitement avec des bases de données vous devez utiliser le namespace System.Data. Dans ce dernier vous trouverez un ensemble de classes et d'autres namespaces tel que le namespace OleDb qui permet de réaliser une connexion à une base de données et d'effectuer des requêtes SQL. Vous travailliez déjà un peu de cette façon sous VB6 quand vous rajoutiez une référence afin de pouvoir déclarer votre objet. Sous .NET tout ça a été regroupé dans ce que l'on appelle un framework. Vous pouvez tout de même rajouter de nouveaux composants .NET ou bien utiliser vos ActiveX.

Nous allons voir comment déclarer une classe et les changements que vous devez faire pour passer de VB6 à VB.NET.

Dans le cas de Visual Basic 6 vous devez ajouter un module de classe à votre projet.

Visual Basic 6
Sélectionnez
1.
2.
3.
4.
5.
6.
7.
8.
9.
10.
11.
12.
13.
14.
15.
16.
17.
18.
19.
20.
21.
22.
23.
24.
25.
Option Explicit

Public tata As String
Private m_toto As Integer

'Utilisation des propriétés
Friend Property Let toto(ByVal vData As Integer)
  m_toto = vData
End Property

Friend Property Get toto() As Integer
  toto = m_toto
End Property

'Fonction
Public Function maFonction() As String
  Dim str As String
  ...
  maFonction = str
End Function

'Procédure
Public Sub MaSub()
  ...
End Sub

Sous Visual Basic .NET vous devez ajouter une classe.

Visual Basic.NET
Sélectionnez
1.
2.
3.
4.
5.
6.
7.
8.
9.
10.
11.
12.
13.
14.
15.
16.
17.
18.
19.
20.
21.
22.
23.
24.
25.
26.
27.
28.
29.
30.
31.
32.
33.
34.
35.
36.
37.
Public Class maClasse

  Public tata As String
  Private m_toto As Integer

  'Constructeur
  Public Sub New()
    ...
  End Sub

  'Destructeur
  Public Sub Finalize()
    ...
  End Sub

  'Utilisation des propriétés
  Friend Property toto As Integer
    Get
      Return m_toto
    End Get
    Set(ByVal vData As Integer)
      m_toto = vData
    End Set
  End Property

  'Fonction
  Public Function maFonction() As String
    Dim str As String
    ...
    Return str
  End Function

  'Procédure
  Public Sub MaSub()
    ...
  End Sub
End Class

Sous C# vous devez ajouter une classe comme en VB.NET. Par contre les propriétés vues ci-dessus portent le nom d'accesseurs.

C#
Sélectionnez
1.
2.
3.
4.
5.
6.
7.
8.
9.
10.
11.
12.
13.
14.
15.
16.
17.
18.
19.
20.
21.
22.
23.
24.
25.
26.
27.
28.
29.
30.
31.
32.
33.
34.
35.
36.
37.
38.
39.
40.
41.
42.
43.
44.
45.
46.
47.
48.
49.
using System;

namespace NamespaceDeVotreApplication
{
  public class MaClasse
  {
    //Constructeur
    public MaClasse()
    {
      ...
    }

    //Destructeur
    public ~MaClasse()
    {
      ...
    }

    public string tata;
    private int m_toto;

    //Utilisation des accesseurs
    public int toto
    {
      get
      {
        return m_toto;
      }
      set
      {
        m_toto = value;
      }
    }

    //Fonction
    string maFonction()
    {
      string str ;
      ...
      return str
    }

    //Procédure
    void MaSub()
    {
      ...
    }
  }
}

Comme vous le remarquez, on se rapproche beaucoup du C++ même en VB.NET. Quant à la différence entre VB.NET et C# elle est tout de même minime. Mais ce qui nous intéresse le plus ici c'est le VB6 et non le VB.NET. En fait ce qui demande le plus de travail c'est l'utilisation du mot clé Property. Hormis cela, la migration se fait sans trop de difficultés.

IV. Les tableaux et les collections

IV-A. Les tableaux

IV-A-1. Déclarations des tableaux simples

En VB.NET les tableaux ont aussi connu des modifications importantes par rapport à VB6. La principale raison de ces changements est l'abandon de la structure variant_array qui permettait des déclarations de tableaux assez « exotiques » comme :

Visual Basic 6
Sélectionnez
Dim MonTableau (15 to 30)

Maintenant sur l'ensemble des langages de .NET, les tableaux commencent tous par l'indice 0 et possèdent un nombre défini d'éléments typés. En VB.NET, lorsqu'un tableau est déclaré, la définition est basée sur la limite supérieure du tableau et non sur le nombre d'éléments qu'il contient. Par exemple, un tableau déclaré :

Visual Basic.NET
Sélectionnez
Dim MonTableau (10) As Integer

contiendra 11 éléments compris entre MonTableau(0) et MonTableau(10).

C#
Sélectionnez
int[] MonTableau = new int[10];

contiendra 10 éléments compris entre MonTableau[0] et MonTableau[9].

Pour ce qui est de la manipulation de ces tableaux, vous retrouverez la plupart des fonctionnalités de VB6 en VB.NET, mais pas en C#.

IV-A-2. Déclaration des tableaux multidimensionnels

Voici comment se déclare un tableau multidimensionnel :

Visual Basic.NET
Sélectionnez
Dim MonTableau (3,3) As Integer

On a donc ici l'exemple d'un tableau à deux dimensions, composé de 16 cases commençant à Montableau(0,0) et se terminant à MonTableau(3,3).

C#
Sélectionnez
int[,] MonTableau = new int[3,3];
//Est différent de
int[][] MonTableau = new int[3][3];

En C# on obtient un tableau de [0,0] à [2,2] dans le premier cas et de [0][0] à [2][2] dans le deuxième cas. Certains d'entre vous se demandent sans doute quelle est la différence entre [,] et [ ][ ]. Le premier représente un tableau multidimensionnel de même type. Le deuxième représente un tableau « en escalier » (terme utilisé par Microsoft). Dans notre cas nous avons le même type sur les deux dimensions, mais c'est possible d'avoir un type différent par dimension. Voici un petit exemple :

C#
Sélectionnez
object[][] MonTableau;
MonTableau = new int[3];
MonTableau[0] = new long[3];

Le principe est le même pour un tableau à trois dimensions :

Visual Basic.NET
Sélectionnez
Dim MonTableau (3,3,3) As Integer

Et ainsi de suite…

IV-A-3. Fonction UBound

Cette fonction permet d'obtenir la limite supérieure d'un tableau. Par exemple, un tableau déclaré :

Visual Basic.NET
Sélectionnez
Dim MonTableau4() As Integer = {0, 1, 2}
C#
Sélectionnez
int MonTableau4[] = new int[] {0, 1, 2};

Ce tableau contient trois éléments (0, 1, 2) et va de MonTableau4(0) à MonTableau4(2).

UBound(MonTableau4) retourne l'entier 2 : l'indice de l'extrémité de MonTableau4.

Nota : il existe une fonction LBound() qui permet de connaître la limite inférieure du tableau. Mais comme tous les tableaux de VB.NET commencent par l'indice 0 cette fonction ne présente pas un grand intérêt ;).

IV-A-4. Fonction ReDim

Cette fonction n'est disponible que sous VB.NET. Comme nous l'avons vu précédemment, les tableaux doivent posséder un nombre fini d'éléments. Pourtant, le nombre d'éléments que contiendra un tableau peut-être défini après sa déclaration grâce à l'instruction ReDim.

On peut ainsi déclarer un tableau :

Visual Basic.NET
Sélectionnez
Dim MonTableau5() As Integer

Cependant, si vous déclarez un tableau comme ci-dessus, celui-ci n'est pas instancié. Si un essai était réalisé pour affecter une valeur à ce tableau, une exception serait levée, alors que l'instruction ne pose aucun problème à la compilation. On remarquera quelques changements lors de l'utilisation de l'instruction ReDim par rapport à VB6 :

vous ne pouvez pas utiliser ReDim pour la déclaration initiale de la variable, vous devez d'abord déclarer cette variable avec Dim comme vu précédemment.

Vous ne pouvez pas changer le nombre de dimensions du tableau : un tableau déclaré en deux dimensions avec Dim restera en deux dimensions.

Ainsi on aura :

Visual Basic.NET
Sélectionnez
ReDim MonTableau5(10) As Integer

L'instruction ReDim effacera l'ensemble des valeurs de votre tableau avant de le redimensionner. Si vous voulez que les valeurs de votre tableau soient conservées, il faut utiliser l'instruction Preserve :

Visual Basic.NET
Sélectionnez
ReDim Preserve MonTableau5(10) As Integer

Si vous rétrécissez la taille de votre tableau, ReDim Preserve effacera seulement les données qui se situeront hors des bornes de votre nouveau tableau.

Les tableaux sont toujours très puissants en VB.NET, et ils permettent de satisfaire la plupart des besoins. Cependant, la classe de base des tableaux reste assez rudimentaire. Pour réaliser des tâches plus avancées comme le tri ou les systèmes de pile, la classe de base Array a été héritée par les classes de l'espace de nom collection.

IV-B. Les collections

L'espace de nom collection fait partie de l'espace de nom system. Il fournit une série de classes qui permettent d'utiliser des fonctionnalités de tableaux avancées comme trier naturellement ou ajouter dynamiquement des objets dans un tableau. Nous allons voir brièvement les quatre classes principales qui composent l'espace de nom collection.

IV-B-1. ArrayList

ArrayList permet d'implémenter un tableau dont la taille croît automatiquement au fur et à mesure que des éléments lui sont ajoutés. Une collection du type ArrayList peut contenir n'importe quel type d'objets. Voici un petit exemple :

Visual Basic.NET
Sélectionnez
1.
2.
3.
4.
5.
6.
7.
Dim collection1 As New ArrayList()
Dim MonObjet As Object
Dim MonEntier As Integer = 1
Dim MaChaine As String = "Hello"
Collection1.Add(MonObjet)
Collection1.Add(MonEntier)
Collection1.Add(MaChaine)
C#
Sélectionnez
1.
2.
3.
4.
5.
6.
7.
ArrayList collection1 = new ArrayList();
object MonObjet;
int MonEntier = 1;
string MaChaine = "Hello";
Collection1.Add(MonObjet);
Collection1.Add(MonEntier);
Collection1.Add(MaChaine);

Comme on peut le voir dans cet exemple, une collection du type ArrayList permet d'ajouter tout type d'objet à la collection. Pour récupérer une valeur dans une collection du type ArrayList, on utilisera la syntaxe :

 
Sélectionnez
Collection1.Item(1)

IV-B-2. BitArray

La collection BitArray gère un tableau de booléens qui sont stockés sous la forme de bits. Lors de la déclaration, comme pour les tableaux il faut définir la taille de la collection : soit lors de la déclaration, soit lorsqu'on instancie la classe. On a donc :

Visual Basic.NET
Sélectionnez
Dim TableauBool As New BitArray(3)
'Ou
Dim TableauBool As BitArray
TableauBool = New BitArray(3)
C#
Sélectionnez
BitArray TableauBool = new BitArray[3];

On ne peut affecter des valeurs à la collection qu'une fois qu'elle a été instanciée par un New, sinon, une exception sera levée. La syntaxe pour affecter une valeur à une collection du type BitArray est : TableauBool.Item(0) = True.

IV-B-3. Queue

Queue implémente une collection FIFO, appelée « premier entré, premier sorti », ou file. Tout comme les collections du type ArrayList, la taille d'une collection du type Queue croît automatiquement, et on y peut stocker n'importe quel type d'objet. Dans l'exemple ci-dessous nous nous contenterons d'une Queue d'entiers pour montrer la syntaxe et les méthodes de base.

Visual Basic.NET
Sélectionnez
1.
2.
3.
4.
5.
6.
7.
8.
9.
10.
11.
'La déclaration :
Dim MaFile As New Queue()

'Ajouter un objet dans la file :
MaFile.EnQueue(0)
MaFile.EnQueue(1)
MaFile.EnQueue(2)
MaFile.EnQueue(3) 

'Pour récupérer un objet de la file :
MaFile.DeQueue()
C#
Sélectionnez
1.
2.
3.
4.
5.
6.
7.
8.
9.
10.
11.
//La déclaration :
Queue MaFile = new Queue();

//Ajouter un objet dans la file :
MaFile.EnQueue(0);
MaFile.EnQueue(1);
MaFile.EnQueue(2);
MaFile.EnQueue(3);

//Pour récupérer un objet de la file :
MaFile.DeQueue();

DeQueue() retournera et supprimera l'élément d'indice « 0 » de la collection, car c'est le premier entré dans la file.

Note : on ne pourra pas récupérer un objet se trouvant dans une collection du type Queue avec un index. Si vous voulez récupérer les objets d'une collection avec un index, il faut utiliser la classe ArrayList décrite un peu plus haut.

IV-B-4. Stack

Stack implémente une collection de type LIFO, appelée « dernier entré, premier sorti » ou pile. Tout comme les collection du type ArrayList ou Queue, la taille d'une collection du type Stack croît automatiquement, et on peut y stocker n'importe quel type d'objet. Dans l'exemple ci-dessous nous nous contenterons d'une Stack d'entiers pour montrer la syntaxe et les méthodes de base.

Visual Basic.NET
Sélectionnez
1.
2.
3.
4.
5.
6.
7.
8.
9.
'La déclaration :
Dim MaPile As New Stack()
'Ajouter un objet dans la pile :
MaPile.Push(0)
MaFile.Push(1)
MaFile.Push(2)
MaFile.Push(3)
'Pour récupérer un objet de la pile :
MaFile.Pop()
C#
Sélectionnez
1.
2.
3.
4.
5.
6.
7.
8.
9.
//La déclaration :
Stack MaPile = New Stack();
//Ajouter un objet dans la pile :
MaPile.Push(0);
MaFile.Push(1);
MaFile.Push(2);
MaFile.Push(3);
//Pour récupérer un objet de la pile :
MaFile.Pop();

Pop() retournera et supprimera l'élément d'indice « 3 » de la collection, car c'est le dernier entré dans la pile.

Note : on ne pourra pas récupérer un objet se trouvant dans une collection du type Stack avec un index. Si vous voulez récupérer les objets d'une collection avec un index, il faut utiliser la classe ArrayList décrite un peu plus haut.

Nous venons de voir les quatre classes les plus utilisées de l'espace de nom Collection. Mais cet espace de nom contient d'autres classes qui peuvent permettre de faire face à d'autres situations : citons entre autres, les classes HashTable et SortedList qui permettent de trier et d'accéder aux valeurs de la collection avec des clés. Comme nous venons de le voir, dans VB.NET, les classes de l'espace de nom Collection complètent parfaitement les tableaux.

V. Que deviennent les modules ?

Sous .NET vous pouvez encore utiliser vos chers et tendres modules, mais pour une question de clarté je vous conseille de passer vos modules en objets. Si vous devez faire de l'orientation objet, autant la faire bien. Ce chapitre vous guidera dans la réalisation des classes à partir de vos modules. La méthode est assez personnelle, donc vous pouvez l'adapter ou même l'améliorer.

Normalement vous avez dû créer un module par groupe de fonctionnalités. Par exemple, tous les traitements sur la base de données sont dans un module, tous les traitements concernant votre métier sont dans un autre, voire plusieurs autres. Si ce n'est pas le cas, vous devez commencer par bien séparer chaque partie de votre application. Si possible séparer le code de l'IHM (Interface Homme-Machine) du code concernant l'applicatif. Pourquoi cette séparation ? Cela vous permettra de faire évoluer votre application plus facilement ou bien de modifier vos formulaires au goût de l'utilisateur sans avoir à retoucher à tout ce qui est applicatif.

Prenons un exemple simple : la connexion à une base de données. D'un côté vous faites une fenêtre dans laquelle l'utilisateur saisit son nom et son mot de passe ; de l'autre vous avez prévu une classe gérant les accès à la base de données. Dans le code de votre fenêtre, vous avez juste à mettre maConnexion.Connect(...). Si un jour on vous dit : « la fenêtre ne me plaît pas du tout, je voudrais quelque chose dans ce style… », votre développement sera beaucoup plus rapide, car vous n'aurez pas besoin de rechercher dans le code de votre fenêtre la phase de connexion et la mettre de côté pour pouvoir recoller ce morceau de code dans la nouvelle fenêtre. Si vous séparez bien vos traitements alors :

  • vous pourrez effectuer une maintenance beaucoup plus facilement ;
  • vous pourrez réutiliser votre code ailleurs.

Quand on vient d'un langage comme VB6 il est assez difficile de « penser objet ». Mais vous verrez qu'une fois ce cap franchi, faire marche arrière est rudement désagréable. Rentrons dans le vif afin de savoir quoi faire avec tous ces modules.

Comme je l'ai dit plus haut, la première phase est de bien séparer vos variables, fonctions et méthodes, afin de créer des classes cohérentes. Ensuite vous devez regarder si toutes vos variables globales sont utiles. Je rappelle qu'avec .NET vous pouvez avoir plusieurs constructeurs et des paramètres dans ces derniers. Donc si vous avez une variable globale dans votre Form1 afin que la Form2 puisse y accéder, alors mettez-la en private puis créez un constructeur dans votre Form2 qui prendra comme paramètre l'élément. Un petit exemple :

Form1 Visual Basic 6
Sélectionnez
1.
2.
3.
4.
5.
6.
7.
8.
Option Explicit

Public maVarForm1 As String

... 
Public Sub Meth1()
  Form2.Show;
End Sub
Form2 Visual Basic 6
Sélectionnez
1.
2.
3.
4.
5.
6.
7.
8.
Option Explicit

... 
Private Sub MaMethode()
  ...
  MsgBox(Form1.maVarForm1)
  ...
End Sub
Form1 Visual Basic.NET
Sélectionnez
1.
2.
3.
4.
5.
6.
7.
8.
9.
10.
11.
12.
13.
Public Class Form1
  Inherits System.Windows.Forms.Form

  Private m_toto As String

  ...
  Private Sub Meth1()
    ...
    Form2 frm = new Form2(m_toto)
    ...
  End Sub

End Class
Form2 Visual Basic.NET
Sélectionnez
1.
2.
3.
4.
5.
6.
7.
8.
9.
10.
11.
12.
13.
14.
15.
16.
17.
18.
Public Class Form2
  Inherits System.Windows.Forms.Form

  Private m_toto As String

  'Constructeur
  Public Sub New(maVar As String)
    ...
    m_toto = maVar;
  End Sub

  ...

  'Procédure
  Public Sub MaMethode()
    MessageBox.Show(m_toto);
  End Sub
End Class

Je ne donne pas d'exemple pour le C#, car c'est exactement la même méthode que pour VB.NET.

Quant aux variables globales liées à votre application (c'est-à-dire nécessaires à tous les éléments) vous pouvez les encapsuler dans une classe que vous appellerez MonApplication. Évitez d'utiliser le nom « Application », car c'est une classe déjà existante, qui correspond à App sous VB6. Dans la classe MonApplication, vous déclarez vos variables en Public ou alors vous utilisez les Property (les accesseurs en C#). Si une variable ou fonction est déclarée Static, alors elle est commune à l'ensemble des instances de la classe. Donc je vous conseille de déclarer tous vos éléments de votre classe MonApplication en Static.

Il ne nous reste plus qu'à voir les fonctions et méthodes présentes dans vos modules. Pour commencer, triez-les afin de créer des classes d'outils. Dans chacune de vos classes vous mettrez vos fonctions et méthodes. Vous aurez juste une modification à réaliser, qui est de mettre Shared à la place de Public. À quoi ça sert ? Comme sous .NET vous travaillez uniquement avec des objets, vous êtes normalement obligé de créer un objet pour pouvoir accéder aux membres décrits dans la classe. Grâce au mot clé Shared vous n'aurez pas besoin de faire de New MaClasse pour pouvoir utiliser la fonction. Faites un petit test chez vous. Créez deux classes, une avec les méthodes en Public, l'autre en Shared. Ensuite dans une autre classe vous faites MaClasse1., et vous verrez que vos méthodes n'apparaissent pas alors qu'avec MaClasse2 elles apparaissent. Je vous mets tout de même en garde concernant l'utilisation du mot clé Shared qui est spécifique à un traitement réalisé UNIQUEMENT sur l'élément passé en paramètre.

Vous voilà prêt(e) à migrer de VB6 à VB.NET sans trop être perdu(e).

VI. Différence entre VB.NET et C#

Vous ne trouverez pas la liste exhaustive des différences entre VB.net et C#, mais seulement celles que l'on a pu rencontrer. En effet beaucoup de personnes ont déjà des avis qui ne sont pas toujours vrais. Pour réaliser au mieux cette partie, nous l'avons conçue à trois : un développeur ASPX, un développeur C# et un développeur VB.NET. Ainsi nous avons une vue plutôt objective des différences entre ces deux langages. Nous mettrons cette partie à jour dès que nous trouverons de nouvelles différences.

Pour la plupart des applications réalisées en .NET, il est possible de le faire aussi bien en VB.NET qu'en C#. La première différence est le langage. Les adeptes de C++/Java se sentiront plus à l'aise sur C#, alors que ceux venant de VB6 seront moins perdus avec VB.NET.

La deuxième différence apparaît dans l'utilisation du code non managé. Cela n'est possible qu'en C#. Les adeptes des pointeurs peuvent toujours en faire en C#. Mais ce n'est utilisé que pour pouvoir travailler avec des DLL non managées. Si ce n'est pas le cas, vous devez utiliser absolument des pointeurs, n'oubliez pas de mettre le mot clé unsafe dans le prototype de votre fonction.

Le compilateur réagit différemment dans les deux langages. Prenons un petit exemple. Ne cherchez pas à le comprendre, car c'est juste un test pour montrer la réaction du compilateur.

Visual Basic.NET
Sélectionnez
1.
2.
3.
4.
5.
6.
7.
8.
9.
10.
  Dim app As System.AppDomain
  Dim i As Integer = 4

  If i = 4 Then
    app = System.AppDomain.CurrentDomain
  ElseIf i = 3 Then
    app = Nothing
  End If

  MessageBox.Show(app.BaseDirectory)

Sous VB.NET il n'y a pas d'erreur, même pas de warning. La compilation se passe très bien.

Voici le code similaire en C# :

C#
Sélectionnez
1.
2.
3.
4.
5.
6.
7.
8.
9.
10.
11.
12.
  System.AppDomain app;
  int i = 4;
  if(i==1)
  {
    app = System.AppDomain.CurrentDomain;
  }
  else if (i==3)
  {
    app= null;
  }

  MessageBox.Show(app.BaseDirectory);

Ici le compilateur donne une erreur : utilisation d'une variable locale non assignée app.

Méfiez-vous des programmes permettant de migrer d'un langage à un autre, car vous pouvez vous retrouver avec des cas comme celui-ci. Ceci dit le compilateur C# n'a pas tort. Donc si vous êtes programmeurs VB.NET, faites attention à ce genre de cas.

Remarque : il est tout à fait possible qu'il y ait des erreurs dans le document. Si vous en trouvez, ou bien souhaitez un peu plus d'explications sur certains points, veuillez m'envoyer un message privé via le forum afin de mettre à jour l'ensemble de ce document. D'avance merci.

VII. Note de la rédaction de Developpez.com

Nous tenons à remercier Winjerome pour la mise au gabarit, Maxy35 et Jacques_jean pour la relecture orthographique.

Vous avez aimé ce tutoriel ? Alors partagez-le en cliquant sur les boutons suivants : Viadeo Twitter Facebook Share on Google+   

Copyright © 2002 Leduke. Aucune reproduction, même partielle, ne peut être faite de ce site ni de l'ensemble de son contenu : textes, documents, images, etc. sans l'autorisation expresse de l'auteur. Sinon vous encourez selon la loi jusqu'à trois ans de prison et jusqu'à 300 000 € de dommages et intérêts.